Apple Pay

Knihovna obsahuje komponentu SecureApplePayButton, která zjednodušuje integraci Apple Pay do vaší aplikace. Komponenta automaticky:

ověří dostupnost Apple Pay na zařízení a v session,
zobrazí standardní Apple Pay tlačítko (PKPaymentButton),
zpracuje platební tok a získá platební token,
odešle token ke zpracování na platební bránu.

Informace

Předpokladem pro využití Apple Pay je aktivace Checkout API a správné nastavení v Apple Developer účtu a Apple Pay zpracovatelského certifikátu, které jsou popsány níže.

1. Apple Developer Account

Před nasazením Apple Pay je nutné v Apple Developer portálu vytvořit Merchant ID.

Přihlaste se do Apple Developer portálu.
Otevřete sekci Certificates, Identifiers & Profiles → Identifiers.
V levém menu zvolte typ Merchant IDs.
Klikněte na tlačítko + a zaregistrujte nové Merchant ID ve formátu merchant.<vase-domena>.<jmeno> (např. merchant.cz.example.production).
Doporučujeme vytvořit dva Merchant IDs — jeden pro testovací prostředí a jeden pro produkci.

Tyto Merchant IDs následně použijete v ComgateSecureSession jako parametr applePayMerchantIdentifier.

2. Apple Pay Payment Processing Certificate

Pro každé Merchant ID je nutné vygenerovat Payment Processing Certificate, který umožní šifrování platebních dat.

V detailu Merchant ID v Apple Developer portálu klikněte na sekci Apple Pay Payment Processing Certificate → Create Certificate.
Apple si vyžádá Certificate Signing Request (CSR).
Tento CSR vám poskytne podpora Comgate — kontaktujte ji pro doručení správného CSR souboru.
Nahrajte CSR do Apple Developer portálu, stáhněte vygenerovaný certifikát a předejte ho zpět Comgate.
Po nasazení certifikátu na straně Comgate je Apple Pay pro dané Merchant ID připraveno k použití.

Prvotní zprovoznění

Aktivace certifikátu na straně Comgate není okamžitá — chvíli trvá. Při prvotním zprovoznění Apple Pay dodejte certifikát Comgate s dostatečným časovým předstihem před plánovaným spuštěním v produkci.

Upozornění

Certifikát Apple Pay je nutné obnovovat každý rok. Hlídání platnosti je na straně obchodníka — ideálně 2 měsíce před vypršením proaktivně kontaktujte podporu Comgate a zahajte obnovu.

3. Implementace

Následující část popisuje jednotlivé komponenty knihovny potřebné k integraci Apple Pay do vaší aplikace.

Tip

Knihovna řeší konfiguraci platební brány, sestavení platebního požadavku, extrakci tokenu i jeho odeslání na API automaticky. Stačí použít komponentu SecureApplePayButton a předat potřebné parametry.

Požadavky

Požadavek	Popis
Apple Pay capability	V Xcode v záložce Signing & Capabilities přidejte capability Apple Pay.
Merchant ID v entitlement	Apple Pay Merchant ID musí být uveden v `com.apple.developer.in-app-payments` v entitlement souboru.
`applePayMerchantIdentifier`	Apple Pay Merchant ID — povinný pro Apple Pay. Předává se do `ComgateSecureSession`.
`applePayDisplayName`	Název obchodníka zobrazený v Apple Pay sheetu (volitelné, doporučeno).
`threeDSConfig`	Instance `ThreeDSConfig` předaná do `ComgateSecureSession` (vyžadováno i pro Apple Pay).
Aktivace Checkout API	Konfigurace Apple Pay je během inicializace session načtena interně knihovnou.

Jak získat `applePayMerchantIdentifier`

applePayMerchantIdentifier získáte v Apple Developer portálu v detailu vašeho Merchant ID:

Přihlaste se do Apple Developer portálu.
Vyberte své Merchant ID.
Zkopírujte hodnotu Identifier (např. merchant.cz.example.production).
Tuto hodnotu použijte jako applePayMerchantIdentifier v ComgateSecureSession.

SecureApplePayButton

import SwiftUI
import ComgateSDK

SecureApplePayButton(
    session: session,
    paymentParams: {
        try! PaymentParams(
            email: "zakaznik@example.com",
            price: 100,
            curr: "CZK",
            country: "CZ",
            label: "Název platby",
            refId: "ref-123",
            fullName: "Jan Novák"
        )
    },
    onResult: { result in
        // Zpracování výsledku platby
    }
)
.frame(height: 56)

Nastavení vzhledu tlačítka

SecureApplePayButton umožňuje přizpůsobit vzhled a typ Apple Pay tlačítka pomocí struktury ApplePayButtonStyle:

Vlastnost	Typ	Popis
`type`	`PKPaymentButtonType`	Typ popisku tlačítka (např. `.plain`, `.buy`, `.checkout`, `.continue`, `.donate`, `.subscribe`). Výchozí: `.plain`.
`appearance`	`PKPaymentButtonStyle`	Vizuální varianta (`.black`, `.white`, `.whiteOutline`, `.automatic`). Výchozí: `.black`.
`cornerRadius`	`CGFloat`	Zaoblení rohů tlačítka v bodech. Výchozí: `12`.

SecureApplePayButton(
    session: session,
    paymentParams: { /* ... */ },
    onResult: { _ in },
    style: ApplePayButtonStyle(
        type: .checkout,
        appearance: .black,
        cornerRadius: 16
    )
)
.frame(height: 56)

Automatická vazba na session

SecureApplePayButton se automaticky naváže na ComgateSecureSession. Tlačítko se zobrazí pouze tehdy, když:

byl při vytváření session předán applePayMerchantIdentifier,
session ohlásí isApplePayConfigured == true (po úspěšné inicializaci).

Pokud Apple Pay není nakonfigurován, vrátí komponenta prázdný EmptyView() — můžete tak na obrazovku bezpečně přidat tlačítko, aniž byste museli kontrolovat dostupnost ručně.

PaymentParams

Parametry platby pro Apple Pay využívají stejnou strukturu PaymentParams jako karetní platby. Kompletní popis všech parametrů naleznete v sekci Karetní data — PaymentParams.

Konfigurace v ComgateSecureSession

Pro Apple Pay je nutné v konstruktoru ComgateSecureSession předat applePayMerchantIdentifier a volitelně applePayDisplayName:

let session = ComgateSecureSession(
    checkoutId: "váš-checkout-id",
    applePayMerchantIdentifier: "merchant.cz.example.production",
    applePayDisplayName: "Název obchodu",
    threeDSConfig: ThreeDSConfig()
)

Kompletní příklad

import SwiftUI
import ComgateSDK

@main
struct ApplePayApp: App {
    @StateObject private var session = ComgateSecureSession(
        checkoutId: "váš-checkout-id",
        applePayMerchantIdentifier: "merchant.cz.example.production",
        applePayDisplayName: "Název obchodu",
        threeDSConfig: ThreeDSConfig()
    )

    var body: some Scene {
        WindowGroup {
            ApplePayScreen(session: session)
                .task {
                    if case .notInitialized = session.state {
                        try? await session.initialize()
                    }
                }
        }
    }
}

struct ApplePayScreen: View {
    @ObservedObject var session: ComgateSecureSession
    @State private var resultText = ""

    var body: some View {
        VStack(spacing: 16) {
            SecureApplePayButton(
                session: session,
                paymentParams: {
                    try! PaymentParams(
                        email: "zakaznik@example.com",
                        price: 100,
                        curr: "CZK",
                        country: "CZ",
                        label: "Objednávka #123",
                        refId: "order-123",
                        fullName: "Jan Novák"
                    )
                },
                onResult: { result in
                    switch result {
                    case .paid: resultText = "Platba úspěšná"
                    case .authorized: resultText = "Platba autorizována"
                    case .pending: resultText = "Platba se zpracovává…"
                    case .cancelled(let reason, _): resultText = "Platba zamítnuta: \(reason ?? "-")"
                    case .failed(let err): resultText = "Chyba: \(err.message)"
                    }
                }
            )
            .frame(height: 56)

            if !resultText.isEmpty {
                Text(resultText)
            }
        }
        .padding()
    }
}

Kombinace s karetní platbou

Apple Pay tlačítko lze snadno kombinovat s karetním formulářem na jedné obrazovce. Obě komponenty sdílejí stejnou ComgateSecureSession:

struct CombinedPaymentScreen: View {
    @ObservedObject var session: ComgateSecureSession

    @StateObject private var panState: SecurePanFieldState
    @StateObject private var expiryState: SecureExpiryFieldState
    @StateObject private var cvvState: SecureCvvFieldState
    @StateObject private var statusState = PaymentStatusState()
    @StateObject private var holder: CollectorHolder

    init(session: ComgateSecureSession) {
        self._session = ObservedObject(wrappedValue: session)
        let pan = SecurePanFieldState()
        let expiry = SecureExpiryFieldState()
        let cvv = SecureCvvFieldState()
        _panState = StateObject(wrappedValue: pan)
        _expiryState = StateObject(wrappedValue: expiry)
        _cvvState = StateObject(wrappedValue: cvv)
        _holder = StateObject(wrappedValue: CollectorHolder(pan: pan, expiry: expiry, cvv: cvv))
    }

    private var collector: SecureCardDataCollector { holder.collector }

    private func params() -> PaymentParams {
        try! PaymentParams(
            email: "zakaznik@example.com",
            price: 100,
            curr: "CZK",
            country: "CZ",
            label: "Objednávka",
            refId: "order-123",
            fullName: "Jan Novák"
        )
    }

    var body: some View {
        VStack(spacing: 12) {
            SecurePanField(state: panState)
            SecureExpiryField(state: expiryState)
            SecureCvvField(state: cvvState)

            SecurePayButton(
                session: session,
                collector: collector,
                paymentParams: params,
                onResult: { statusState.show(result: $0) }
            )

            Divider()

            SecureApplePayButton(
                session: session,
                paymentParams: params,
                onResult: { statusState.show(result: $0) }
            )
            .frame(height: 56)

            SecurePaymentStatusView(state: statusState)
        }
        .padding()
    }
}

Informace

Při použití Apple Pay v rámci Mobilního SDK vždy vytvořte a předejte threeDSConfig do ComgateSecureSession.

4. Testovací prostředí

Sandbox tester

Pro testování Apple Pay v testovacím prostředí použijte Sandbox Tester Account vytvořený v App Store Connect (Users and Access → Sandbox Testers).

Vytvořte Sandbox Tester Account s testovacím Apple ID.
Na fyzickém zařízení se odhlaste z produkčního Apple ID v App Store a přihlaste se Sandbox testerem v Settings → Wallet & Apple Pay.
Přidejte testovací karty z Apple seznamu testovacích karet.

Testovací Merchant ID

Testovací Merchant ID musí být zaregistrován ve vašem Apple Developer účtu a musí mít vygenerovaný Payment Processing Certificate napárovaný s Comgate.

Fyzické zařízení vs. simulátor

Apple Pay má v simulátoru omezenou funkcionalitu:

Prostředí	Podpora Apple Pay
iOS simulátor	Apple Pay sheet se zobrazí, ale lze pracovat pouze s testovacími kartami uloženými ve Wallet (omezená sada). Pro plné testování není dostatečný.
Fyzické zařízení (sandbox)	Plná podpora s Sandbox Tester Accountem a testovacími kartami. Doporučeno pro testování.
Fyzické zařízení (produkce)	Po schválení certifikátu reálné transakce.

Upozornění

Pro plnohodnotné testování Apple Pay vždy používejte fyzické zařízení přihlášené Sandbox Tester Accountem. Simulátor neumožňuje generovat platný platební token v produkčním tvaru.

1. Apple Developer Account​

2. Apple Pay Payment Processing Certificate​

3. Implementace​

Požadavky​

Jak získat applePayMerchantIdentifier​

SecureApplePayButton​

Nastavení vzhledu tlačítka​

Automatická vazba na session​

PaymentParams​

Konfigurace v ComgateSecureSession​

Kompletní příklad​

Kombinace s karetní platbou​

4. Testovací prostředí​

Sandbox tester​

Testovací Merchant ID​

Fyzické zařízení vs. simulátor​