Como funciona

Neste guia, você aprenderá como integrar a Xsolla para processar pagamentos usando o Xsolla Mobile SDK, em conformidade com os requisitos da Apple.

Fluxo do usuário:

1. O usuário abre o aplicativo do jogo no iOS.
2. O usuário clica no botão de compra próximo ao item desejado.
3. O aplicativo abre o Safari (ou o navegador padrão) com um link Pay Station que contém o token de pagamento. O SDK gerencia a autorização e a seleção de itens.
4. O usuário é autorizado automaticamente. O Pay Station é aberto para o item específico.
5. O usuário seleciona um método de pagamento e conclui a compra.
6. O Pay Station redireciona o usuário ao aplicativo do jogo.
7. O aplicativo recebe a confirmação da compra via webhook.

Início rápido

Cadastre uma Conta de Distribuidor e crie um projeto

A Conta de Distribuidor é a ferramenta principal para configurar recursos da Xsolla, bem como trabalhar com análises e transações.

Para se cadastrar, acesse Conta de Distribuidor e crie uma conta. Para criar um projeto, selecione Create project no menu lateral e forneça quaisquer informações necessárias. Você pode modificar as configurações mais tarde.

Durante o processo de integração, você precisa fornecer o ID do projeto, encontrado na Conta de Distribuidor ao lado do nome do seu projeto.

Configure o Xsolla Login

1. No seu projeto dentro da Conta de Distribuidor, vá para a seção Players > Login.
2. Clique em Create Login project.
3. Selecione Standard Login project e clique em Create and set up. Espere até seu novo projeto Login ser criado. Você verá então a página do projeto Login.
4. No bloco Login methods, selecione qualquer opção e clique em Configure.
5. No bloco das configurações superior, clique em Login API integration.
6. Defina a opção Login with device ID como On.

7. Clique em Save changes.

Durante o processo de integração, você precisará do seu Login ID. Para obtê-lo, clique no nome do seu projeto Login na trilha de migalhas para retornar à página do projeto Login e então clique em Copy ID ao lado do nome do projeto Login.

Configure produtos de compras no app (itens virtuais)

Escolha um dos seguintes métodos para configurar seu catálogo de produtos SKU IAP:

• Importe itens – envie um arquivo JSON para adicionar rapidamente seu catálogo à Conta de Distribuidor.
• Use chamadas API – ideal para atualizações automatizadas ou de larga escala.

Instalação do SDK

O Xsolla Mobile SDK é fornecido como XCFramework de nome XsollaMobileSDK.xcframework.

Para instalá-lo manualmente no seu projeto Xcode:

1. Abra seu projeto no Xcode.
2. Selecione seu aplicativo alvo e acesse a aba General.
3. Na seção Frameworks, Libraries, and Embedded Content, arraste e solte o arquivo XsollaMobileSDK.xcframework.
4. Na lista suspensa próxima à estrutura, certifique-se de que Embed & Sign esteja selecionado.

Configure o SDK

Para a configuração do SDK, você precisa dos seguintes IDs da Conta de Distribuidor:

• ID de Projeto. Pode ser encontrado na Conta de Distribuidor próximo ao nome do seu projeto.
• ID de Login. Para acessar, abra a Conta de Distribuidor, acesse a seção Players > Login> Dashboard > Seu Projeto Login, e selecione Copy ID perto do nome do projeto Login.

Como ponto inicial, você pode usar IDs de exemplo.

 1#import <XsollaMobileSDK/StoreKitWrapper.h>
 2
 3SKPaymentSettings* settings = [[SKPaymentSettings alloc] initWithProjectId: 77640
 4                                                         loginProjectId:@"026201e3-7e40-11ea-a85b-42010aa80004"
 5                                                         platform: SKPaymentPlatformStandalone
 6                                                         paystationUIThemeId: SKPaystationThemeDark
 7                                                         paystationUISize: SKPaystationSizeMedium];
 8
 9settings.useSandbox = YES;
10settings.enablePayments = YES;
11settings.openExternalBrowser = YES;
12
13SKPaymentQueue* queue = [SKPaymentQueue defaultQueue];
14[queue startWithSettings: settings];
15[queue addTransactionObserver: self];

 1import XsollaMobileSDK
 2
 3let settings = SKPaymentSettings(projectId: 77640,
 4                                 loginProjectId: "026201e3-7e40-11ea-a85b-42010aa80004",
 5                                 platform: .standalone)
 6
 7settings.useSandbox = true;
 8settings.enablePayments = true;
 9settings.openExternalBrowser = true;
10
11SKPaymentQueue.default().start(settings)
12SKPaymentQueue.default().add(self)

Configure links profundos para retornar os usuários ao aplicativo do jogo após a compra

Configure o esquema URL para o alvo:

1. Selecione seu projeto no navegador do projeto.
2. Selecione seu alvo.
3. Abra a aba Info.
4. Clique no botão ➕ na seção URL Types.
5. Defina o URL Scheme para $(PRODUCT_BUNDLE_IDENTIFIER).

Inicialize o SDK

Depois de realizar a configuração, o Xsolla Mobile SDK precisa ser inicializado e conectado aos serviços da Xsolla. Coloque essa lógica no seu fluxo de inicialização do aplicativo. Por exemplo, dentro do método didFinishLaunchingWithOptions da AppDelegate.

 1SKPaymentQueue* queue = [SKPaymentQueue defaultQueue];
 2[queue startWithSettings: settings]; // settings from the previous step
 3
 4// conform your class to SKPaymentTransactionObserver and implement its method
 5@interface YourClass (SKPaymentTransactionObserver) <SKPaymentTransactionObserver>
 6@end
 7
 8@implementation YourClass (SKPaymentTransactionObserver)
 9
10- (void)paymentQueue:(SKPaymentQueue *)queue updatedTransactions:(NSArray *)transactions {
11    for(SKPaymentTransaction *transaction in transactions) {
12        switch (transaction.transactionState) {
13            case SKPaymentTransactionStateFailed:
14                // purchase failed, present an error
15                break;
16            case SKPaymentTransactionStatePurchased:
17                // award the player with the purchase of the SKU - transaction.payment.productIdentifier
18                break;
19            default: break;
20        }
21    }
22}
23
24@end

 1SKPaymentQueue.default().start(settings)
 2SKPaymentQueue.default().add(self)
 3
 4// conform your class to SKPaymentTransactionObserver and implement its method
 5extension YourClass: SKPaymentTransactionObserver {
 6    func paymentQueue(_: SKPaymentQueue, updatedTransactions: [SKPaymentTransaction]) {
 7        for transaction in updatedTransactions {
 8            switch transaction.transactionState {
 9            case .failed:
10                // purchase failed, present an error
11            case .purchased:
12                // award the player with the purchase of the SKU - transaction.payment.productIdentifier
13            default:
14                break
15            }
16        }
17    }
18}

Depois de iniciar SKPaymentQueue e adicionar um observador de transação, o aplicativo poderá solicitar a informação do SKU conforme abaixo:

 1NSSet *skus = [NSSet setWithArray:@[@"your_sku1", @"your_sku2"]];
 2SKProductsRequest* req = [[SKProductsRequest alloc] initWithProductIdentifiers:skus];
 3
 4req.delegate = self;
 5[req start];
 6
 7// conform your class to SKProductsRequestDelegate and implement its method
 8@interface YourClass (SKProductsRequestDelegate) <SKProductsRequestDelegate>
 9@end
10
11@implementation YourClass (SKProductsRequestDelegate)
12
13- (void)productsRequest:(SKProductsRequest *)request didReceiveResponse:(SKProductsResponse *)response {
14    // save loaded products somewhere
15    self.products = response.products
16}
17
18@end

 1let skus: Set<String> = ["your_sku1", "your_sku2"]
 2let req = SKProductsRequest(productIdentifiers: skus)
 3
 4req.delegate = self
 5req.start()
 6
 7// conform your class to SKProductsRequestDelegate and implement its method
 8extension YourClass: SKProductsRequestDelegate {
 9    func productsRequest(_ request: SKProductsRequest, didReceive response: SKProductsResponse) {
10        // save loaded products somewhere
11        self.products = response.products
12    }
13}

Fazer compra

O fluxo de compra é um processo de diversas etapas, que envolvem a coleta de pagamento, a validação da compra e o consumo.

Fluxo de compra inicial

Para criar um pagamento e iniciar uma compra, use a informação SKProduct adquirida anteriormente:

1SKProduct *product = ...;  // previously fetched product
2SKPayment *payment = [SKPayment paymentWithProduct:product];
3[[SKPaymentQueue defaultQueue] addPayment:payment];

1let product = ... // previously fetched product
2let payment = SKPayment(product: product)
3SKPaymentQueue.default().add(payment)

Valide a compra

Cada compra deve ser validada antes de entregá-la ao usuário final para ajudar a prevenir compras não autorizadas.

A maneira mais eficiente de garantir a validade de uma compra é usar as chamadas de servidor a servidor (S2S0), removendo o cliente do processo de tomada de decisão e, assim, evitando criar uma brecha de segurança em potencial.

Comumente, a abordagem da validação S2S segue estas etapas:

• O aplicativo do cliente envia o ID do pedido da compra para o backend. Este ID é obtido quando a transação de pagamento é finalizada do lado do cliente (tipicamente via callback de transação). Veja Fluxo de compra inicial para entender como as compras são iniciadas.
• O servidor recebe o ID do pedido e valida sua autenticidade usando a abordagem do webhook (acionado pelos serviços Xsolla) assim que a compra conclui a notificação de servidor. Isso permite o gerenciamento de recibos assíncronos sem fazer uso de polling, e pode ser feito em plano de fundo (o resultado é armazenado em cache) antes mesmo da solicitação de um cliente chegar. Para mais informações sobre webhooks, veja a seção Configuração de webhook.

Consuma o conteúdo comprado

A etapa final no fluxo de compra é conceder as compras ao usuário e marcá-las como “concedidas”. O processo é conhecido como “consumo de compra”.

O resultado da compra é entregue através do callback paymentQueue:updatedTransactions: em Objective-C, ou paymentQueue(_:updatedTransactions:) em Swift.

 1- (void)paymentQueue:(SKPaymentQueue *)queue updatedTransactions:(NSArray *)transactions {
 2    for(SKPaymentTransaction *transaction in transactions) {
 3        switch (transaction.transactionState) {
 4            case SKPaymentTransactionStateFailed:
 5                // Always acknowledge transaction and finish it
 6                [[SKPaymentQueue defaultQueue] finishTransaction:transaction];
 7                break;
 8            case SKPaymentTransactionStatePurchased:
 9                // here you can save the purchase and award it to the user
10                // Always acknowledge transaction and finish it after it was saved
11                [[SKPaymentQueue defaultQueue] finishTransaction:transaction];
12                break;
13            default: break;
14        }
15    }
16}

 1func paymentQueue(_: SKPaymentQueue, updatedTransactions: [SKPaymentTransaction]) {
 2    for transaction in updatedTransactions {
 3        switch transaction.transactionState {
 4        case .failed:
 5            // Always acknowledge transaction and finish it
 6            SKPaymentQueue.default().finishTransaction(transaction)
 7        case .purchased:
 8            // here you can save the purchase and award it to the user
 9            // Always acknowledge transaction and finish it after it was saved
10            SKPaymentQueue.default().finishTransaction(transaction)
11        default:
12            break
13        }
14    }
15}

Configurar webhooks

Webhooks são notificações sobre eventos ocorrendo no sistema. Quando um evento específico ocorre, a Xsolla envia uma solicitação HTTP, transmitindo os dados do evento ao seu servidor do jogo. Esses webhooks são essenciais para o cliente do jogo e/ou servidor para receber notificações sobre pagamentos bem-sucedidos ou mal-sucedidos e tentativas de autenticação de usuários.

Ativando webhooks

1. No seu projeto dentro da Conta de Distribuidor, vá para a seção Configuração do projeto > Webhooks.
2. No campo Webhook server, especifique o URL do servidor, onde você deseja receber webhooks no formato https://example.com. Você também pode especificar o URL que encontrar em uma ferramenta para testar webhooks.
3. Uma chave secreta para assinar webhooks de projeto é gerada por padrão. Se quiser gerar uma nova chave secreta, clique no ícone de atualização.
4. Clique em Enable webhooks.

Testando webhooks

Na aba Payments and Store, você pode testar os seguintes webhooks:

Validação de usuário (“notification_type”:“user_validation”):

 1curl -v 'https://your.hostname/your/uri' \
 2-X POST \
 3-H 'Accept: application/json' \
 4-H 'Content-Type: application/json' \
 5-H 'Authorization: Signature 13342703ccaca5064ad33ba451d800c5e823db8f' \
 6-d '{
 7    "notification_type":"user_validation",
 8    "settings": {
 9      "project_id": 18404,
10      "merchant_id": 2340
11    },
12    "user": {
13        "ip": "127.0.0.1",
14        "phone": "18777976552",
15        "email": "email@example.com",
16        "id": "1234567",
17        "name": "John Smith",
18        "country": "US"
19    }
20}'

Pagamento bem-sucedido do pedido (“notification_type”: “order_paid”):

  1curl -v 'https://your.hostname/your/uri' \
  2-X POST \
  3-H 'Accept: application/json' \
  4-H 'Content-Type: application/json' \
  5-H 'Authorization: Signature d09695066c52c1b8bdae92f2d6eb59f5b5f89843' \
  6-d '{
  7    "notification_type": "order_paid",
  8    "items": [
  9      {
 10        "sku": "com.xsolla.item_1",
 11        "type": "virtual_good",
 12        "is_pre_order": false,
 13        "quantity": 3,
 14        "amount": "1000",
 15        "promotions": [
 16          {
 17            "amount_without_discount": "6000",
 18            "amount_with_discount": "5000",
 19            "sequence": 1
 20          },
 21          {
 22            "amount_without_discount": "5000",
 23            "amount_with_discount": "4000",
 24            "sequence": 2
 25          }
 26        ],
 27        "custom_attributes":
 28          {
 29            "purchased": 0,
 30            "attr": "value"
 31          }
 32      },
 33      {
 34        "sku": "com.xsolla.item_new_1",
 35        "type": "bundle",
 36        "is_pre_order": false,
 37        "quantity": 1,
 38        "amount": "1000",
 39        "promotions": []
 40      },
 41      {
 42        "sku": "com.xsolla.gold_1",
 43        "type": "virtual_currency",
 44        "is_pre_order": false,
 45        "quantity": 1500,
 46        "amount": null,
 47        "promotions": []
 48      }
 49    ],
 50    "order": {
 51      "id": 1,
 52      "mode": "default",
 53      "currency_type": "virtual",
 54      "currency": "sku_currency",
 55      "amount": "2000",
 56      "status": "paid",
 57      "platform": "xsolla",
 58      "comment": null,
 59      "invoice_id": "1",
 60      "promotions": [
 61        {
 62          "amount_without_discount": "4000",
 63          "amount_with_discount": "2000",
 64          "sequence": 1
 65        }
 66      ],
 67      "promocodes": [
 68        {
 69          "code": "promocode_some_code",
 70          "external_id": "promocode_sku"
 71        }
 72      ],
 73      "coupons": [
 74        {
 75          "code": "WINTER2021",
 76          "external_id": "coupon_sku"
 77        }
 78      ]
 79    },
 80    "user": {
 81      "external_id": "id_xsolla_login_1",
 82      "email": "gc_user@xsolla.com"
 83    },
 84    "billing": {
 85      "notification_type": "payment",
 86      "settings": {
 87        "project_id": 18404,
 88        "merchant_id": 2340
 89      },
 90      "purchase": {
 91          "subscription": {
 92              "plan_id": "b5dac9c8",
 93              "subscription_id": "10",
 94              "product_id": "Demo Product",
 95              "date_create": "2014-09-22T19:25:25+04:00",
 96              "date_next_charge": "2014-10-22T19:25:25+04:00",
 97              "currency": "USD",
 98              "amount": 9.99
 99          },
100          "total": {
101              "currency": "USD",
102              "amount": 200
103          },
104          "promotions": [{
105              "technical_name": "Demo Promotion",
106              "id": 853
107          }],
108          "coupon": {
109              "coupon_code": "ICvj45S4FUOyy",
110              "campaign_code": "1507"
111          }
112        },
113      "transaction": {
114          "id": 1,
115          "external_id": 1,
116          "payment_date": "2014-09-24T20:38:16+04:00",
117          "payment_method": 1,
118          "payment_method_name": "PayPal",
119          "payment_method_order_id": 1234567890123456789,
120          "dry_run": 1,
121          "agreement": 1
122      },
123      "payment_details": {
124          "payment": {
125              "currency": "USD",
126              "amount": 230
127          },
128          "vat": {
129              "currency": "USD",
130              "amount": 0,
131              "percent": 20
132          },
133          "sales_tax": {
134              "currency": "USD",
135              "amount": 0,
136              "percent": 0
137          },
138          "direct_wht": {
139              "currency": "USD",
140              "amount": 0,
141              "percent": 0
142          },
143          "payout_currency_rate": "1",
144          "payout": {
145              "currency": "USD",
146              "amount": 200
147          },
148          "country_wht": {
149              "currency": "USD",
150              "amount": 2,
151              "percent": 10
152          },
153          "user_acquisition_fee": {
154              "currency": "USD",
155              "amount": 2,
156              "percent": 1
157          },
158          "xsolla_fee": {
159              "currency": "USD",
160              "amount": 10
161          },
162          "payment_method_fee": {
163              "currency": "USD",
164              "amount": 20
165          },
166          "repatriation_commission": {
167              "currency": "USD",
168              "amount": 10
169          }
170      }
171    }
172 ,
173  "custom_parameters": {
174    "parameter1": "value1",
175    "parameter2": "value2"
176  }
177}'

Testar no sandbox

Essa seção contém trechos de códigos e exemplos demonstrando como é possível configurar o ambiente sandbox para testar pagamentos, habilitando registros detalhados e outras tarefas relacionadas.

Ativando o modo sandbox

1SKPaymentSettings* settings = ...;
2
3settings.useSandbox = YES;

1let settings = SKPaymentSettings(...)
2
3settings.useSandbox = true

Habilitando registros adicionais

1SKPaymentSettings* settings = ...;
2
3settings.logLevel = SKLogLevelDebug;

1let settings = SKPaymentSettings(...)
2
3settings.logLevel = .debug

Cartões de teste

Para obter uma lista de cartões para simular pagamentos no modo sandbox, veja a seção Testar lista de cartões.

ATIVAR

1. Assine o contrato de licenciamento. Para fazer isso, na Conta de Distribuidor, acesse a seção Contratos & Taxas > Contratos, preencha o formulário do contrato.
2. Defina sandbox como false no código de configuração SDK.

1SKPaymentSettings* settings = ...;
2
3settings.useSandbox = NO;
4settings.logLevel = SKLogLevelError;

1let settings = SKPaymentSettings(...)
2
3settings.useSandbox = false
4settings.logLevel = .error

Como detectar a loja digital iOS

Para determinar a loja digital iOS atual e ajustar a funcionalidade do SDK com base na região, use os seguintes trechos de códigos:

1[SKPaymentQueue loadCurrentStorefrontCountryCodeWithCompletion:^(NSString* _Nullable countryCode) {
2    settings.enablePayments = countryCode && [countryCode isEqualToString:@"USA"];
3
4    [[SKPaymentQueue defaultQueue] startWithSettings:settings];
5}];

1SKPaymentQueue.loadCurrentStorefrontCountryCode { countryCode in
2    settings.enablePayments = countryCode == "USA"
3
4    SKPaymentQueue.default().start(settings)
5}

O método loadCurrentStorefrontCountryCode recupera o código do país de três letras de forma assíncrona para a loja digital atual. Você pode usar essa informação para ativar ou desativar a funcionalidade do SDK para regiões específicas.

Alternativamente, você pode usar a Storefront nativa da Apple diretamente, como exibido abaixo:

1let storefront = await Storefront.current   
2let countryCode = storefront?.countryCode
3
4settings.enablePayments = countryCode == "USA"
5
6SKPaymentQueue.default().start(settings)

Como funciona

Neste guia, você aprenderá como integrar a Xsolla para processar pagamentos usando a Xsolla API, em conformidade com os requisitos da Apple.

Fluxo do usuário:

1. O usuário abre o aplicativo do jogo no iOS.
2. O usuário clica no botão de compra próximo ao item desejado.
3. O aplicativo abre o Safari (ou o navegador padrão) com um link Pay Station que contém o token de pagamento.
4. O Pay Station é aberto para o item específico.
5. O usuário seleciona um método de pagamento e conclui a compra.
6. O Pay Station redireciona o usuário ao aplicativo do jogo.
7. O aplicativo recebe a confirmação da compra via webhook.

Início rápido

Cadastre uma Conta de Distribuidor e crie um projeto

A Conta de Distribuidor é a ferramenta principal para configurar recursos da Xsolla, bem como trabalhar com análises e transações.

Para se cadastrar, acesse Conta de Distribuidor e crie uma conta. Para criar um projeto, selecione Create project no menu lateral e forneça quaisquer informações necessárias. Você pode modificar as configurações mais tarde.

Durante o processo de integração, você precisa fornecer o ID do projeto, encontrado na Conta de Distribuidor ao lado do nome do seu projeto.

Configure produtos de compras no app (itens virtuais)

Escolha um dos seguintes métodos para configurar seu catálogo de produtos SKU IAP:

• Importe itens – envie um arquivo JSON para adicionar rapidamente seu catálogo à Conta de Distribuidor.
• Crie um catálogo de itens usando as chamadas API da seção de documentação Virtual Items & Currency > Admin.

Configure links universais

Links universais são links como https://your-site.com/your-game que são abertos no aplicativo se ele estiver instalado no dispositivo do usuário, ou no navegador se o aplicativo não estiver instalado.

Para configurar links universais:

1. Adicione um arquivo de associação de domínio à raiz do seu site. Por exemplo, https://your-site.com/apple-app-site-association.
2. No seu projeto Xcode, acesse Signing & Capabilities > Associated Domains e adicione applinks:your-site.com.

Configure redirecionamentos para retornar usuários ao aplicativo do jogo após a compra

1. Abra seu projeto na Conta de Distribuidor e acesse a seção Payments > Payment interface > Settings > Redirect policy.
2. No campo Return URL, insira um endereço URL ou trajeto (link profundo) para o qual o usuário será redirecionado após fazer um pagamento. Este URL precisa suportar links universais. Para melhorar a experiência do usuário em um jogo móvel, recomendamos especificar um link profundo como o URL de retorno.
3. Na lista suspensa Automatic redirect condition, escolha uma condição necessária.
4. Na lista suspensa Manual redirect condition, escolha None — do not redirect.
5. Clique em Save.

Detectar vitrine iOS

Sistemas de pagamento externos são permitidos somente nos EUA no momento. Para verificar se seu aplicativo é obtido na loja americana, use o seguinte código:

1let storefront = await Storefront.current   
2let countryCode = storefront?.countryCode
3
4settings.enablePayments = countryCode == "USA"
5
6SKPaymentQueue.default().start(settings)

O método loadCurrentStorefrontCountryCode recupera o código do país de três letras de forma assíncrona para a loja digital atual.

Fazer compra

Criar pedidos no lado do servidor do aplicativo

O cliente do aplicativo faz uma solicitação ao seu servidor para recuperar um token de pagamento:

 1struct TokenRequest: Codable {
 2  let sku: String
 3  let userId: String
 4}
 5
 6func fetchPaymentToken(for sku: String, userId: String, completion: @escaping (Result<String, Error>) -> Void) {
 7  let req = TokenRequest(sku: sku, userId: userId)
 8  guard let url = URL(string: "https://your-backend.com/xsolla/create_token") else { return }
 9  var request = URLRequest(url: url)
10  request.httpMethod = "POST"
11  request.setValue("application/json", forHTTPHeaderField: "Content-Type")
12  request.httpBody = try? JSONEncoder().encode(req)
13  URLSession.shared.dataTask(with: request) { data, _, error in
14    if let error = error {
15      completion(.failure(error)); return
16    }
17    let token = try! JSONDecoder().decode([String: String].self, from: data!)["token"]!
18    completion(.success(token))
19  }.resume()
20}

Para criar um pedido com o usuário e os dados de itens no lado da Xsolla, use a chamada API Criar token de pagamento para compra. O método retornará um token de pagamento, que é necessário para abrir uma interface de pagamento e realizar um pagamento. Para usar o modo sandbox, passe o parâmetro “sandbox”: true no corpo da solicitação para obter um token.

Abertura da interface de pagamento

Depois de receber um token, gere um link para abrir a interface de pagamento em um navegador através do seguinte link:https://secure.xsolla.com/paystation4/?token=TOKEN, onde TOKEN é o token obtido.

1func openPayStation(token: String) {
2    let urlString = "https://secure.xsolla.com/paystation4/?token=\(token)"
3    guard let url = URL(string: urlString) else { return }
4    UIApplication.shared.open(url, options: [:], completionHandler: nil)
5}

Para testar o processo de pagamento, você pode usar o modo sandbox. É um ambiente independente que suporta todos os recursos de um ambiente ativo, exceto pagamentos reais e recusados. No modo sandbox, você pode testar um pagamento único e pagamentos com métodos de pagamento salvos usando cartões bancários e PayPal.

Redirecione os usuários ao aplicativo

Após um pagamento bem-sucedido, leve os usuários regressantes ao seu aplicativo usando links universais. Para gerenciar esse redirecionamento, implemente o seguinte método no seu SceneDelegate ou SceneDelegate:

 1func scene(_ scene: UIScene, continue userActivity: NSUserActivity) {
 2    guard userActivity.activityType == NSUserActivityTypeBrowsingWeb,
 3          let url = userActivity.webpageURL,
 4          url.host == "your-site.com",
 5          url.path.starts(with: "/payment_callback_success") else { return }
 6    // Extract parameters (e.g., status, transaction_id)
 7    let components = URLComponents(url: url, resolvingAgainstBaseURL: false)
 8    let queryItems = components?.queryItems
 9    let status = queryItems?.first { $0.name == "status" }?.value
10    handlePaymentResult(status: status)
11}

Configurar webhooks

1. No seu projeto dentro da Conta de Distribuidor, vá para a seção Configuração do projeto > Webhooks.
2. No campo Webhook server, especifique o URL do servidor, onde você deseja receber webhooks no formato https://example.com. Você também pode especificar o URL que encontrar em uma ferramenta para testar webhooks.
3. Uma chave secreta para assinar webhooks de projeto é gerada por padrão. Se quiser gerar uma nova chave secreta, clique no ícone de atualização.
4. Clique em Enable webhooks.

Para a operação completa da loja no jogo e gerenciamento de pagamento, é necessário implementar o processamento dos webhooks principais:

Iniciar

1. Assine o contrato de licenciamento. Para fazer isso, na Conta de Distribuidor, acesse a seção Contratos & Taxas > Contratos, preencha o formulário do contrato.
2. Faça a entrevista fiscal. Para fazer isso, na Conta de Distribuidor, acesse a seção Agreements & Taxes > Tax interview e preencha o formulário.
3. Troque para um ambiente de produção. para fazer isso, remova “sandbox”: true da solicitação para criar um token.