Comment ça marche

Ce guide explique comment intégrer Xsolla pour traiter les paiements via Xsolla Mobile SDK, en respectant les exigences Apple.

Flux utilisateur

1. L’utilisateur ouvre l’application de jeu sur iOS.
2. L’utilisateur clique sur le bouton d’achat à côté de l’objet souhaité.
3. L’application ouvre Safari (ou le navigateur par défaut) avec un lien Pay Station contenant le jeton de paiement. Le SDK traite l’autorisation et la sélection de l’objet.
4. L’utilisateur est automatiquement autorisé. La page Pay Station pour le paiement de l’objet concerné s’affiche.
5. L’utilisateur sélectionne un mode de paiement et effectue l’achat.
6. Pay Station redirige l’utilisateur vers l’application de jeu.
7. L’application reçoit la confirmation d’achat via un webhook.

Démarrage rapide

Inscrivez un Compte éditeur et créez un projet

Le Compte éditeur est l’outil principal pour configurer les fonctionnalités Xsolla, ainsi que pour gérer les analyses et les transactions.

Pour vous inscrire, accédez au Compte éditeur et créez un compte. Pour créer un projet, appuyez sur Create project dans le menu latéral et fournissez toutes les informations nécessaires. Vous pourrez modifier les paramètres ultérieurement.

Au cours du processus d’intégration, vous devez fournir l’ID de projet. Il se trouve dans le Compte éditeur à côté du nom du projet.

Configurer Xsolla Login

1. Ouvrez le projet dans le Compte éditeur et accédez à la section Players > Login.
2. Cliquez sur Create Login project.
3. Sélectionnez Standard Login project et cliquez sur Create and set up. Patientez pendant la création de votre nouveau projet Login. La page du projet Login s’affiche ensuite.
4. Dans le bloc Login methods, sélectionnez une option et cliquez sur Configure.
5. Dans le bloc de paramètres supérieur, cliquez sur Login API integration.
6. Réglez la bascule Login with device ID sur On.

7. Cliquez sur Save changes.

Au cours du processus d’intégration, vous aurez besoin de votre Login ID. Pour l’obtenir, cliquez sur le nom de votre projet Login dans le fil d’Ariane pour revenir à la page du projet Login, puis cliquez sur Copy ID à côté du nom du projet Login.

Configurer des achats in-app (objets virtuels)

Choisissez l’une des méthodes suivantes pour configurer votre catalogue IAP :

• Importation des objets : téléchargez un fichier JSON pour ajouter rapidement votre catalogue au Compte éditeur.
• Utilisez les appels API : idéal pour les mises à jour automatisées ou à grande échelle.

Installer le SDK

Xsolla Mobile SDK est fourni sous la forme d’un fichier XCFramework nommé XsollaMobileSDK.xcframework.

Pour l’installer manuellement dans votre projet Xcode :

1. Ouvrez votre projet dans Xcode.
2. Sélectionnez votre application cible et accédez à l’onglet General.
3. Dans la section Frameworks, Libraries, and Embedded Content, faites glisser le fichier XsollaMobileSDK.xcframework.
4. Dans la liste déroulante à côté du framework, assurez-vous que Embed & Sign est sélectionné.

Configurer le SDK

Pour la configuration du SDK, vous avez besoin des identifiants suivants du Compte éditeur :

• ID de projet. Il se trouve dans le Compte éditeur à côté du nom du projet.
• Login ID. Pour l’obtenir, ouvrez le Compte éditeur, accédez à la section Players > Login > Dashboard > votre projet de Login, puis appuyez sur Copy ID à côté du nom du projet de Login.

Pour commencer, utilisez des exemples d’identifiants comme modèles.

 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)

Configurer des liens profonds pour rediriger l'utilisateur vers l'application après l'achat

Configurez un schéma d’URL pour l’application cible :

1. Sélectionnez le projet dans le navigateur de projet.
2. Sélectionnez l’application cible.
3. Ouvrez l’onglet Info.
4. Cliquez sur le bouton ➕ dans la section URL Types.
5. Définissez le champ URL Scheme sur $(PRODUCT_BUNDLE_IDENTIFIER).

Initialiser le SDK

Après la configuration, Xsolla Mobile SDK doit être initialisé et connecté aux services Xsolla. Intégrez cette logique dans le flux d’initialisation de votre application, par exemple dans la méthode AppDelegate didFinishLaunchingWithOptions.

 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}

Après avoir démarré SKPaymentQueue et ajouté un observateur de transactions, l’application peut demander des informations sur l’UGS comme suit :

 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}

Effectuer un achat

Le flux d’achat est un processus en plusieurs étapes, qui comprend l’encaissement du paiement, la validation de l’achat et la consommation.

Initialiser le flux d'achat

Pour créer un paiement et initier un achat, utilisez les informations précédemment obtenues via l’objet SKProduct :

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)

Valider l'achat

Chaque achat doit être validé avant d’être attribué à l’utilisateur final afin d’éviter les achats non autorisés.

Le moyen le plus efficace de garantir la validité d’un achat consiste à utiliser des appels serveur à serveur (S2S), qui n’impliquent pas le client dans le processus de décision. Cette approche permet d’éviter toute faille de sécurité.

En règle générale, la validation S2S suit les étapes suivantes :

• Le client de l’application envoie l’ID de la commande au backend. Cet ID est obtenu une fois la transaction finalisée côté client, généralement via un rappel de transaction. Voir Initier le flux d’achat pour en savoir plus sur l’initialisation des achats.
• Le serveur reçoit l’ID de la commande et en valide l’authenticité via un webhook déclenché par les services Xsolla dès que l’achat est terminé et que la notification serveur est envoyée. Ce mécanisme permet de traiter les reçus de manière asynchrone, sans recourir au polling, et peut être exécuté en arrière-plan (le résultat étant mis en cache) avant même l’arrivée de la requête du client. Pour en savoir plus sur les webhooks, consultez la section Configurer un webkook.

Consommer le contenu acheté

La toute dernière étape du flux d’achat consiste à attribuer les achats à l’utilisateur et à les marquer comme attribués. Ce processus est également connu sous le nom de consommation des achats.

Le résultat de l’achat est passé par l’intermédiaire de la fonction de rappel paymentQueue:updatedTransactions: en Objective-C ou paymentQueue(_:updatedTransactions:) en 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}

Configurer des webhooks

Les webhooks sont des notifications sur les événements survenant dans le système. Lorsqu’un événement spécifique survient, Xsolla envoie une requête HTTP avec les données associées à votre serveur de jeu. Ces webhooks permettent à votre client ou à votre serveur de recevoir des informations sur les paiements réussis ou échoués, ainsi que sur les tentatives d’authentification utilisateur.

Activation des webhooks

1. Dans votre projet, dans le Compte éditeur, accédez à la section Project setting > Webhooks.
2. Dans le champ Webhook server, indiquez l’URL du serveur sur lequel vous souhaitez recevoir les webhooks, au format https://example.com. Vous pouvez également utiliser l’URL générée par un outil de test de webhooks.
3. Une clé secrète pour signer les webhooks du projet est générée par défaut. Si vous souhaitez générer une nouvelle clé secrète, cliquez sur l’icône d’actualisation.
4. Cliquez sur Enable webhooks.

Test de webhooks

Dans l’onglet Payments and Store, vous pouvez tester les webhooks suivants :

Validation utilisateur (“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}'

Successful payment for order (“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}'

Test en mode bas à sable

Cette section présente des extraits de code et des exemples montrant comment configurer l’environnement bac à sable pour tester les paiements, activer la journalisation étendue et effectuer d’autres tâches associées.

Activation du mode bac à sable

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

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

Activation de la journalisation étendue

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

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

Cartes de test

Pour obtenir une liste de cartes permettant de simuler des paiements en mode bac à sable, consultez la section Liste de cartes de test.

MISE EN PRODUCTION

1. Signez le contrat de licence. Pour ce faire, dans le Compte éditeur, accédez à la section Agreements & Taxes > Agreements et remplissez le formulaire de contrat.
2. Dans le code de configuration du SDK, définissez le paramètre sandbox sur false.

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

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

Comment détecter la région de la vitrine App Store

Pour déterminer la région de la vitrine actuelle de l’App Store et ajuster les fonctionnalités du SDK en conséquence, utilisez les extraits de code suivants :

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}

La méthode loadCurrentStorefrontCountryCode récupère de manière asynchrone le code pays à trois lettres de la vitrine actuelle. Utilisez cette information pour activer ou désactiver certaines fonctionnalités du SDK selon la région.

Vous pouvez également utiliser directement la classe native Storefront d’Apple, comme indiqué ci-dessous :

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

Comment ça marche

Ce guide explique comment intégrer Xsolla pour traiter les paiements via Xsolla API, en respectant les exigences Apple.

Flux utilisateur

1. L’utilisateur ouvre l’application de jeu sur iOS.
2. L’utilisateur clique sur le bouton d’achat à côté de l’objet souhaité.
3. L’application ouvre Safari (ou le navigateur par défaut) avec un lien Pay Station contenant le jeton de paiement.
4. La page Pay Station pour le paiement de l’objet concerné s’affiche.
5. L’utilisateur sélectionne un mode de paiement et effectue l’achat.
6. Pay Station redirige l’utilisateur vers l’application de jeu.
7. L’application reçoit la confirmation d’achat via un webhook.

Démarrage rapide

Inscrivez un Compte éditeur et créez un projet

Le Compte éditeur est l’outil principal pour configurer les fonctionnalités Xsolla, ainsi que pour gérer les analyses et les transactions.

Pour vous inscrire, accédez au Compte éditeur et créez un compte. Pour créer un projet, appuyez sur Create project dans le menu latéral et fournissez toutes les informations nécessaires. Vous pourrez modifier les paramètres ultérieurement.

Au cours du processus d’intégration, vous devez fournir l’ID de projet. Il se trouve dans le Compte éditeur à côté du nom du projet.

Configurer des achats in-app (objets virtuels)

Choisissez l’une des méthodes suivantes pour configurer votre catalogue IAP :

• Importation des objets : téléchargez un fichier JSON pour ajouter rapidement votre catalogue au Compte éditeur.
• Créez un catalogue des objets à l’aide des appels API de la section Virtual Items & Currency > Admin de la documentation.

Configurer les liens universels

Les liens universels sont des liens tels que https://your-site.com/your-game qui s’ouvrent dans l’application si elle est installée sur l’appareil de l’utilisateur, ou dans le navigateur dans le cas contraire.

Pour configurer les liens universels :

1. Ajoutez un fichier d’association de domaine à la racine de votre site web. Par exemple, https://your-site.com/apple-app-site-association.
2. Dans votre projet Xcode, accédez à Signing & Capabilities > Associated Domains et ajoutez applinks:your-site.com.

Configurer des redirections pour renvoyer l'utilisateur vers l'application après l'achat

1. Ouvrez le projet dans le Compte éditeur et accédez à la section Payments > Payment interface > Settings > Redirect policy.
2. Dans le champ Return URL, entrez une URL ou un lien profond vers lequel l’utilisateur sera redirigé après avoir finalisé son paiement. Cette URL doit prendre en charge les liens universels. Pour une expérience utilisateur optimale dans une application mobile de jeu, nous vous recommandons d’utiliser un lien profond comme URL de retour.
3. Dans la liste déroulante Automatic redirect condition, choisissez une condition nécessaire.
4. Dans la liste déroulante Manual redirect condition, choisissez None — do not redirect.
5. Cliquez sur Save.

Détecter de la région de l'iOS App Store

Les systèmes de paiement externes sont actuellement autorisés uniquement aux États-Unis. Pour vérifier si votre application est disponible sur l’App Store américain, utilisez le code suivant :

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

La méthode loadCurrentStorefrontCountryCode récupère de manière asynchrone le code pays à trois lettres de la vitrine actuelle.

Effectuer un achat

Créer une commande côté serveur de l'application

Le client de l’application envoie une requête à votre serveur pour obtenir un jeton de paiement :

 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}

Pour créer une commande avec les données utilisateur et les données de l’objet côté Xsolla, utilisez l’appel API Créer un jeton de paiement pour un achat. Cette méthode renverra un jeton de paiement, nécessaire pour ouvrir l’interface et effectuer un paiement. Pour utiliser le mode bac à sable, passez le paramètre “sandbox”: true dans le corps de la requête d’obtention du jeton.

Ouvrir l'interface de paiement

Après avoir reçu un jeton, générez un lien pour ouvrir l’interface de paiement dans un navigateur via le lien suivant : https://secure.xsolla.com/paystation4/?token=TOKEN, où TOKEN est le jeton obtenu.

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}

Pour tester le processus de paiement, vous pouvez utiliser le mode bac à sable. Il s’agit d’un environnement autonome qui prend en charge toutes les fonctionnalités d’un environnement réel, à l’exception des paiements réels et des paiements refusés. En mode bac à sable, vous pouvez tester un paiement unique ainsi qu’un paiement avec des modes de paiement enregistrés, en utilisant des cartes bancaires et PayPal.

Rediriger les utilisateurs vers l'application

Après un paiement réussi, gérez le renvoi des utilisateurs vers votre application à l’aide de liens universels. Pour cela, implémentez la méthode suivante dans votre application, dans la classe SceneDelegate ou AppDelegate :

 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}

Configurer des webhooks

1. Dans votre projet, dans le Compte éditeur, accédez à la section Project setting > Webhooks.
2. Dans le champ Webhook server, indiquez l’URL du serveur sur lequel vous souhaitez recevoir les webhooks, au format https://example.com. Vous pouvez également utiliser l’URL générée par un outil de test de webhooks.
3. Une clé secrète pour signer les webhooks du projet est générée par défaut. Si vous souhaitez générer une nouvelle clé secrète, cliquez sur l’icône d’actualisation.
4. Cliquez sur Enable webhooks.

Pour gérer pleinement le magasin en jeu et les paiements, il est nécessaire d’implémenter le traitement des principaux webhooks :

Lancer

1. Signez le contrat de licence. Pour ce faire, dans le Compte éditeur, accédez à la section Agreements & Taxes > Agreements et remplissez le formulaire de contrat.
2. Passez l’entretien fiscal. Pour ce faire, dans le Compte éditeur, accédez à la section Agreements & Taxes > Tax interview et remplissez le formulaire.
3. Passez à l’environnement de production. Pour ce faire, supprimez “sandbox”: true de la demande de création de jeton.