Maximiser l'intégration de Play Billing

1. Présentation

Optimisez vos sources de revenus et lancez votre application en toute confiance grâce à cet atelier de programmation sur l'intégration de la bibliothèque Play Billing par Google Play. Cet atelier de programmation structuré vous guide dans la configuration, le test et l'implémentation d'un traitement fiable des achats. Vous pourrez ainsi atteindre vos objectifs de monétisation et offrir une expérience utilisateur plus fluide.

Nous vous aiderons à configurer les notifications en temps réel pour les développeurs (RTDN) et Play Billing Lab pour les abonnements et les produits ponctuels de vos applications et jeux. Vous apprendrez à réduire le taux de désabonnement, à vous protéger contre la fraude et les utilisations abusives, à tester les cas extrêmes, à simuler, reproduire et résoudre les problèmes potentiels, et à tester les offres et les changements de prix sans impacter les utilisateurs.

À la fin de ce cours, vous serez prêt à implémenter des stratégies de récupération des utilisateurs, à résoudre rapidement les problèmes d'intégration, à améliorer le ROI, à offrir une expérience premium et à déployer votre application et vos mises à jour en toute confiance.

Prérequis

Connaissance de l'intégration de base de la bibliothèque Play Billing
Connaissances en développement d'applications Android (Java)

Points abordés

Gérer correctement vos cycles de vie des achats pour optimiser la croissance grâce à des techniques permettant d'améliorer les conversions d'achat et la fidélisation des clients
Configurer les notifications en temps réel pour les développeurs (NTRD) à l'aide de Google Cloud Pub/Sub, qui peuvent ensuite être utilisées pour mettre en œuvre des campagnes de récupération et d'autres stratégies de gestion du cycle de vie
Comment configurer un récepteur sur votre serveur backend pour gérer les notifications de manière sécurisée, avec un suivi précis et des droits d'accès, afin de réduire les risques de remboursements involontaires, de fraude et d'utilisation abusive
Comment tester votre intégration et simuler des erreurs à l'aide de Play Billing Lab pour améliorer l'expérience utilisateur tout en réduisant les coûts de développement

Prérequis

Accès au compte de développeur Play pour votre application dans la Google Play Console
Accès à votre projet Google Cloud Platform avec l'API Google Play Developer activée
Un serveur de backend pour gérer les comptes et les droits d'accès de votre application Android
Testeurs de licence enregistrés pour votre application dans la Play Console
L'application Play Billing Lab installée sur votre appareil de test

2. Stratégies de monétisation pour les abonnements et les achats ponctuels

Lorsque vous vendez des produits numériques via votre application, une stratégie de monétisation efficace doit prendre en compte l'expérience utilisateur dans son ensemble, à la fois pour les achats ponctuels et les abonnements. Une expérience fluide peut accroître la préparation à l'achat et réduire le taux de perte de clients.

Un parcours d'achat courant pour un achat ponctuel ou un abonnement comporte plusieurs étapes :

L'utilisateur parcourt les articles à acheter.
Lancez le parcours d'achat pour que l'utilisateur finalise l'achat et le paiement.
Notifier votre serveur de l'achat effectué
Vérifiez l'achat sur votre serveur.
Fournissez le contenu à l'utilisateur.
Confirmez la livraison du contenu. Pour les produits consommables, utilisez l'achat au moment opportun afin que l'utilisateur puisse acheter l'article à nouveau.

L'intégration dans l'application vous permet de lancer des parcours d'achat et de gérer l'expérience utilisateur. Toutefois, il est essentiel de maintenir le backend à jour en ce qui concerne les droits d'accès achetés par les utilisateurs. Cela est important pour suivre les achats et gérer d'autres aspects de l'expérience utilisateur, tels que les droits d'accès multiplates-formes.

Les notifications en temps réel pour les développeurs (RTDN) sont un excellent moyen de reconnaître ces différentes étapes du cycle de vie des achats. Elles peuvent être utilisées efficacement à la fois comme outil de suivi des performances en temps réel et comme outil permettant de mettre en place des stratégies de récupération des abonnés.

Par exemple, imaginons que votre utilisateur vient d'acheter un nouvel article ou qu'il vient de manquer son paiement, de sorte que l'abonnement est entré dans la période de grâce. Avec le bon RTDN, vous pouvez reconnaître, en temps quasi réel, que l'état de l'utilisateur a changé et agir en conséquence en l'incitant à s'intéresser davantage à l'article qu'il vient d'acheter ou en lui envoyant des e-mails de rappel pour qu'il mette à jour ses informations de paiement afin de continuer son abonnement.

Les RTDN sont également un excellent moyen d'ajouter des contrôles côté serveur supplémentaires pour vous aider à gérer les achats, même lorsque le client de l'utilisateur rencontre des problèmes. Imaginons qu'un utilisateur ait effectué un achat et reçu la confirmation de Google, mais que son appareil ait perdu la connectivité réseau avant que son appareil et votre application ne reçoivent une notification de l'achat via l'écouteur d'achat. Avec les RTDN, vous recevez une notification indépendante via votre serveur, ce qui vous permet de reconnaître l'achat et d'accorder le droit d'accès à l'utilisateur indépendamment du problème client, ce qui garantit un processus d'achat fiable.

Pour en savoir plus sur tous les types de notifications RTDN actuellement acceptés, cliquez ici. Chaque type de signal RTDN indique un état d'achat distinct. Il est essentiel de mettre en œuvre des mécanismes de gestion correspondants pour garantir un traitement approprié selon vos cas d'utilisation. Cet atelier de programmation vous guidera à travers un exemple de gestion du message RTDN sur votre serveur backend sécurisé. Vous apprendrez à recevoir le message, à valider l'achat et à accorder le droit à l'utilisateur concerné lorsqu'il effectue un achat dans votre application. Ensuite, nous vous montrerons comment configurer les RTDN pour votre application.

3. Configurer les notifications en temps réel pour les développeurs (RTDN)

Les notifications en temps réel pour les développeurs (RTDN) utilisent Google Cloud Pub/Sub pour vous permettre de réagir immédiatement aux changements d'état des achats. Cloud Pub/Sub est un service de messagerie en temps réel entièrement géré qui vous permet d'envoyer et de recevoir des messages entre différentes applications. Google Play utilise Cloud Pub/Sub pour publier des notifications push sur les sujets auxquels vous êtes abonné.

Pour activer les RTDN, vous devez d'abord configurer Cloud Pub/Sub à l'aide de votre propre projet Google Cloud Platform (GCP), puis activer les notifications pour votre application. Si vous ne connaissez pas GCP ni Cloud Pub/Sub, consultez le guide de démarrage rapide.

Créer un sujet

Pour commencer à recevoir des notifications, vous devez créer un sujet dans lequel Google Play doit publier les notifications. Pour créer un sujet, suivez les instructions de la section Créer le sujet.

Créer un abonnement Pub/Sub

Pour recevoir des messages publiés dans un sujet, vous devez créer un abonnement Pub/Sub pour ce sujet. Pour créer un abonnement Pub/Sub :

Lisez le Guide pour les abonnés Cloud Pub/Sub pour savoir comment configurer l'abonnement en tant qu'abonnement push ou abonnement pull. Dans cet atelier de programmation, nous allons travailler avec un abonnement pull qui nécessite que votre serveur backend sécurisé envoie des requêtes au serveur Cloud Pub/Sub pour récupérer les messages.

Suivez les instructions de la section Ajouter un abonnement pour créer un abonnement.

Accorder des droits de publication sur votre sujet

Cloud Pub/Sub nécessite que vous accordiez des droits Google Play pour publier des notifications dans votre sujet.

Ouvrez la console Google Cloud.
Sélectionnez votre projet, puis recherchez Pub/Sub dans la barre de recherche et accédez à la page de configuration Pub/Sub.
Recherchez votre sujet et ouvrez le paramètre d'autorisation.
Cliquez sur AJOUTER UN PRINCIPAL pour ajouter le compte de service google-play-developer-notifications@system.gserviceaccount.com et lui accorder le rôle d'Éditeur Pub/Sub.
Cliquez sur Enregistrer pour terminer la configuration du sujet.

Activer les RTDN pour votre application

Découvrez comment configurer les notifications en temps réel pour les développeurs afin d'améliorer considérablement votre intégration de Play Billing. Vous pouvez améliorer la fiabilité des achats grâce à des messages personnalisés, mais aussi prévenir la fraude et les utilisations abusives pour améliorer votre ROI global.

Les RTDN fournissent des mises à jour immédiates de serveur à serveur directement depuis Google Play pour les événements clés, comme les renouvellements d'abonnement, les nouveaux achats et les problèmes de paiement. Ils aident vos systèmes de backend à se synchroniser automatiquement avec l'état réel des droits d'accès des utilisateurs, ce qui vous permet de dépasser les limites côté client et de réagir instantanément et de manière appropriée.

Pour activer les notifications en temps réel pour les développeurs pour votre application :

Ouvrez la Google Play Console.
Sélectionnez votre application.
Accédez à Monétiser avec Play > Configuration de la monétisation.
Faites défiler la page jusqu'à la section Notifications en temps réel pour les développeurs.
Cochez la case Activer les notifications en temps réel.
Dans le champ Nom du sujet, saisissez le nom complet du sujet Cloud Pub/Sub que vous avez configuré plus tôt. Le nom du sujet doit être au format projects/{project_id}/topics/{topic_name}, où project_id est l'identifiant unique de votre projet et topic_name le nom du sujet créé précédemment.
Cliquez sur Envoyer un message test pour envoyer un message test. Effectuer une publication de test permet de s'assurer que tout est correctement configuré. Si la publication de test réussit, un message s'affiche. Si vous avez associé un abonnement à ce sujet, vous devriez recevoir le message de test. Pour un abonnement pull, accédez à l'abonnement dans la console Cloud, cliquez sur Afficher les messages, puis extrayez les messages. Vous devez accuser réception de tous les messages que vous avez extraits pour éviter que Cloud Pub/Sub ne diffuse plusieurs fois le message. Pour un abonnement push, vérifiez si le message de test est distribué à votre point de terminaison push. Si la publication de test réussit, un message s'affiche. Si la publication échoue, une erreur s'affiche. Assurez-vous que le nom du sujet est correct et que le compte de service google-play-developer-notifications@system.gserviceaccount.com dispose d'un accès Éditeur Pub/Sub au sujet.
Choisissez les types de notifications que vous souhaitez recevoir.

Recevoir des notifications sur les abonnements et tous les achats annulés : recevez des notifications en temps réel pour les développeurs concernant les abonnements et les achats annulés. Vous ne recevrez pas de notifications pour les achats de produits ponctuels.
Recevoir toutes les notifications sur les abonnements et les produits ponctuels : recevez des notifications pour tous les événements liés aux abonnements et aux achats annulés. Vous recevrez également des événements d'achat de produits ponctuels, tels que ONE_TIME_PRODUCT_PURCHASED et ONE_TIME_PRODUCT_CANCELED. Pour en savoir plus sur ces événements d'achat, consultez Cycle de vie des achats uniques.

Cliquez sur Enregistrer les modifications.

Vous avez maintenant terminé les notifications pour les développeurs en temps réel pour votre application. Vous disposez ainsi des outils nécessaires pour relever les défis courants, comme le churn des utilisateurs grâce à des messages de récupération, ou la fraude et l'utilisation abusive. Dans la section suivante, nous allons créer un abonné sur votre serveur backend sécurisé pour consommer les messages envoyés à votre sujet Cloud Pub/Sub.

4. Recevoir des notifications

Il est essentiel de tenir à jour le serveur backend sur l'état des achats pour offrir la meilleure expérience utilisateur possible dans votre application. Par exemple, lorsqu'un utilisateur effectue un achat avec un paiement dans l'application, le contenu doit être fourni à son compte dès que possible.

Pour cela, il faut que l'achat soit détecté et traité rapidement. La bibliothèque Play Billing offre plusieurs façons de détecter les achats dans votre application. Une fois un achat effectué détecté, votre application doit notifier votre serveur backend pour qu'il vérifie l'achat, accorde le contenu à l'utilisateur concerné, puis informe Google que l'achat a été traité. Toutefois, il est possible que votre application n'ait pas détecté l'achat à temps pour diverses raisons. Par exemple, un utilisateur peut effectuer un achat et recevoir la confirmation de Google, mais son appareil perd la connectivité réseau avant que son appareil et votre application ne reçoivent une notification via l'interface de la bibliothèque Play Billing. RTDN fournit des contrôles supplémentaires côté serveur pour vous aider à gérer les achats, même lorsque le client de l'utilisateur rencontre des problèmes. RTDN garantit des notifications indépendantes à votre serveur lorsque l'état d'un achat change. Vous pouvez ainsi reconnaître les changements d'état d'un achat presque immédiatement via un deuxième chemin, indépendamment des éventuels problèmes client. Le processus d'achat est ainsi plus fiable.

Dans cette section, vous allez créer un abonné pour consommer les messages envoyés à votre sujet Cloud Pub/Sub à l'aide des bibliothèques clientes Cloud Pub/Sub. Ces bibliothèques sont disponibles dans plusieurs langues. Dans les sections suivantes, nous allons ajouter l'abonné pour vérifier l'achat, accorder le droit d'accès à l'utilisateur approprié et confirmer/consommer l'achat sur le serveur. Pour cet atelier de programmation, nous utilisons Java.

Chaque publication effectuée sur un sujet Cloud Pub/Sub ne contient qu'un seul champ de données encodé en base64.

{
 "message": {
   "attributes": {
     "key": "value"
   },
   "data": "eyAidmVyc2lvbiI6IHN0cmluZywgInBhY2thZ2VOYW1lIjogc3RyaW5nLCAiZXZlbnRUaW1lTWlsbGlzIjogbG9uZywgIm9uZVRpbWVQcm9kdWN0Tm90aWZpY2F0aW9uIjogT25lVGltZVByb2R1Y3ROb3RpZmljYXRpb24sICJzdWJzY3JpcHRpb25Ob3RpZmljYXRpb24iOiBTdWJzY3JpcHRpb25Ob3RpZmljYXRpb24sICJ0ZXN0Tm90aWZpY2F0aW9uIjogVGVzdE5vdGlmaWNhdGlvbiB9",
   "messageId": "136969346945"
 },
 "subscription": "projects/myproject/subscriptions/mysubscription"
}

Après avoir décodé le champ de données encodé en base64, DeveloperNotification contient les champs suivants :

{
 "version": string,
 "packageName": string,
 "eventTimeMillis": long,
 "oneTimeProductNotification": OneTimeProductNotification,
 "subscriptionNotification": SubscriptionNotification,
 "voidedPurchaseNotification": VoidedPurchaseNotification,
 "testNotification": TestNotification
}

Pour en savoir plus, consultez la documentation de référence sur les notifications en temps réel pour les développeurs.

Vous trouverez ci-dessous l'exemple de code d'un NotificationReceiver permettant à votre serveur backend sécurisé de traiter les messages Pub/Sub. Pour vous authentifier auprès de Security Command Center, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

import com.google.cloud.pubsub.v1.AckReplyConsumer;
import com.google.cloud.pubsub.v1.MessageReceiver;
import com.google.cloud.pubsub.v1.Subscriber;
import com.google.pubsub.v1.ProjectSubscriptionName;
import com.google.pubsub.v1.PubsubMessage;
import java.util.Base64;
import org.json.JSONObject;

/** Real-time developer notifications receiver. */
public class NotificationReceiver {

 private NotificationReceiver() {}

 /*
  * Receive notification messages from the subscription.
  *
  * @param projectId The project ID of your Google Cloud Project.
  * @param subscriptionId The subscription ID of the subscriber to the pub/sub topic.
  */
 public static void receiveNotificationMessages(String projectId, String subscriptionId) {
   ProjectSubscriptionName subscriptionName =
       ProjectSubscriptionName.of(projectId, subscriptionId);

   try {
     Subscriber subscriber =
         Subscriber.newBuilder(subscriptionName, new NotificationMessageReceiver()).build();
     // Start the subscriber.
     subscriber.startAsync().awaitRunning();

     subscriber.awaitTerminated();
   } catch (IllegalStateException e) {
     System.out.println("Subscriber stopped: " + e);
   }
 }

 static class NotificationMessageReceiver implements MessageReceiver {

   @Override
   public void receiveMessage(PubsubMessage message, AckReplyConsumer consumer) {
     // Decode the data into a String from the message data field.
     String jsonString = new String(Base64.getDecoder().decode(message.getData().toStringUtf8()));
     // Parse the String into a JSON object.
     JSONObject messageJson = new JSONObject(jsonString);

     // Fetch the value for certain fields.
     String version = messageJson.getString("version");
     String packageName = messageJson.getString("packageName");
     System.out.println("version: " + version);
     System.out.println("packageName: " + packageName);

     // Validate the purchase and grant the entitlement as needed.
     // More details in the following sections.
     // ......

     // Acknowledge the message to avoid repeated delivery.
     consumer.ack();
   }
 }
}

Vous disposez maintenant d'un récepteur de notifications qui consomme les messages envoyés à votre sujet Cloud Pub/Sub sur votre serveur backend sécurisé. Dans les sections suivantes, nous aborderons les bonnes pratiques pour traiter les messages RTDN sur votre serveur backend.

5. Joindre des identifiants utilisateur au parcours d'achat dans votre application

Lorsque votre serveur reçoit le message RTDN concernant la mise à jour de l'état de l'achat, il doit savoir quel utilisateur a effectué l'achat pour le traiter, par exemple en fournissant le contenu au bon utilisateur. Pour ce faire, vous pouvez associer les identifiants utilisateur dont vous disposez pour l'utilisateur effectuant l'achat à l'aide de obfuscatedAccountId lorsque vous lancez le processus d'achat dans votre application. Un identifiant peut, par exemple, être une version obscurcie de l'identifiant de connexion de l'utilisateur dans votre système. Définir ce paramètre peut aider Google à détecter les fraudes. De plus, il peut vous aider à vous assurer que les achats sont attribués au bon utilisateur, comme indiqué dans Accorder des droits d'accès aux utilisateurs.

Vous trouverez ci-dessous des exemples de code permettant d'associer l'identifiant utilisateur lors du lancement du parcours d'achat dans l'application en définissant obfuscatedAccountId.

// An activity reference from which the billing flow will be launched.
Activity activity = ...;
// A user identifier, e.g. an obfuscated user id in your system.
String obfuscatedAccountId = ...;

ImmutableList<ProductDetailsParams> productDetailsParamsList =
    ImmutableList.of(
        ProductDetailsParams.newBuilder()
            // retrieve a value for "productDetails" by calling queryProductDetailsAsync()
            .setProductDetails(productDetails)
            // set the offer token to specify the offer to purchase when applicable, e.g., subscription products
            // .setOfferToken(offerToken)
            .build()
    );

BillingFlowParams billingFlowParams = BillingFlowParams.newBuilder()
    .setProductDetailsParamsList(productDetailsParamsList)
    .setObfuscatedAccountId(obfuscatedAccountId)
    .build();

// Launch the billing flow
BillingResult billingResult = billingClient.launchBillingFlow(activity, billingFlowParams);

Comme vous le verrez dans la section suivante, l'identifiant utilisateur défini dans le parcours d'achat sera inclus dans l'achat et pourra être utilisé pour accorder des droits d'accès au bon utilisateur.

6. Vérifier les achats avant d'accorder des droits

Dans cette section, nous allons passer en revue les bonnes pratiques pour vérifier les achats avant d'accorder des droits sur votre serveur backend sécurisé.

Une fois qu'un utilisateur a effectué un achat ponctuel, l'abonné Pub/Sub de votre serveur backend sécurisé reçoit un message Pub/Sub. Sur votre serveur de backend, vous devez effectuer les opérations suivantes :

Analysez le purchaseToken à partir du message Pub/Sub. Vous devez conserver un enregistrement de toutes les valeurs de purchaseToken pour tous les achats.
Vérifiez que la valeur de purchaseToken pour l'achat en question ne correspond à aucune valeur de purchaseToken antérieure. purchaseToken est unique. Vous pouvez donc utiliser cette valeur en toute sécurité comme clé primaire dans votre base de données.
Utilisez le point de terminaison purchases.products:get dans l'API Google Play Developer pour vérifier auprès de Google que l'achat est légitime.

Si l'achat est légitime et qu'il n'a pas été utilisé par le passé, vous pouvez alors accorder en toute sécurité le droit d'accès à l'abonnement ou à l'élément intégré.
Vous ne devez accorder des droits d'accès que lorsque l'état d'achat est PURCHASED (Acheté) et vous assurer de gérer correctement les achats PENDING (Annulés). Pour en savoir plus, consultez Gérer les transactions en attente.

L'exemple de code suivant crée un client API pour l'API Google Play Developer. Nous l'utiliserons pour effectuer les appels d'API plus tard.

import com.google.api.client.auth.oauth2.Credential;
import com.google.api.client.googleapis.auth.oauth2.GoogleCredential;
import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.http.HttpTransport;
import com.google.api.client.json.JsonFactory;
import com.google.api.client.json.gson.GsonFactory;
import com.google.api.services.androidpublisher.AndroidPublisher;
import com.google.api.services.androidpublisher.AndroidPublisherScopes;
import java.io.IOException;
import java.security.GeneralSecurityException;
import java.util.Collections;

/** Helper class to initialize the publisher APIs client library. */
public class AndroidPublisherHelper {
 /* Your application name */
 private static final String APPLICATION_NAME = "YourApplicationName";

 /* Load credentials from a JSON key file. Replace with the actual path to your downloaded service
  * account key file.
  */
 private static final String RESOURCES_CLIENT_SECRETS_JSON =
     "/path/to/your/service_account_key.json";

 /** Global instance of the JSON factory. */
 private static final JsonFactory JSON_FACTORY = GsonFactory.getDefaultInstance();

 /* The API client */
 private static final AndroidPublisher ANDROID_PUBLISHER = init();

 /**
  * Performs all necessary setup steps for running requests against the API.
  *
  * @return the {@link AndroidPublisher} service
  */
 private static AndroidPublisher init(){
   try {
     // Authorization.
     Credential credential =
         GoogleCredential.fromStream(
                 AndroidPublisherHelper.class.getResourceAsStream(RESOURCES_CLIENT_SECRETS_JSON))
             .createScoped(Collections.singleton(AndroidPublisherScopes.ANDROIDPUBLISHER));

     HttpTransport httpTransport = GoogleNetHttpTransport.newTrustedTransport();

     // Set up and return API client.
     return new AndroidPublisher.Builder(httpTransport, JSON_FACTORY, credential)
         .setApplicationName(ApplicationConfig.APPLICATION_NAME)
         .build();
   } catch (GeneralSecurityException | IOException ex) {
     throw new RuntimeException("fail to initialize the publisher APIs client library", ex);
   }
 }
}

Nous ajoutons ensuite la logique pour effectuer l'appel d'API et modifier le récepteur créé précédemment afin de valider l'achat et d'accorder le droit d'accès à l'utilisateur concerné.

Dans AndroidPublisherHelper, ajoutez la méthode suivante pour récupérer ProductPurchase à partir du point de terminaison Purchases.products:get de l'API Google Play Developer.

 /* Fetch the ProductPurchase for the one-time product purchase from
  * Purchases.products.get endpoint in the Google Play Developer API
  */
 public static ProductPurchase executeProductPurchasesGet(
     String packageName, String sku, String purchaseToken) {
   try {
     ProductPurchase productPurchase =
         ANDROID_PUBLISHER.purchases().products().get(packageName, sku, purchaseToken).execute();
     return productPurchase;
   } catch (IOException ex) {
     log.error("Exception was thrown while getting a product purchase", ex);
     // It is recommended to apply some retry mechanism, such as exponential backoff, to fetch the purchase in case of transient failures.
     return null;
   }
 }

Dans NotificationMessageReceiver, validez l'achat et accordez le droit d'accès à l'utilisateur concerné dans votre système en fonction des données incluses dans la notification. Vous devez continuer à suivre le purchaseToken dans votre serveur pour éviter le traitement en double.

 @Override
 public void receiveMessage(PubsubMessage message, AckReplyConsumer consumer) {
   // Decode the data into a String from the message data field.
   String jsonString = new String(Base64.getDecoder().decode(message.getData().toStringUtf8()));
   // Parse the String into a JSON object.
   JSONObject messageJson = new JSONObject(jsonString);

   // Fetch the value for certain fields.
   String version = messageJson.getString("version");
   String packageName = messageJson.getString("packageName");

   // Process notification data based on your business requirements.
   // Process oneTimeProductNotification in the message.
   JSONObject oneTimeProductNotificationJson =
       messageJson.getJSONObject("oneTimeProductNotification");
   if (oneTimeProductNotificationJson != null) {
     String purchaseToken = oneTimeProductNotificationJson.getString("purchaseToken");
     String sku = oneTimeProductNotificationJson.getString("sku");
     int notificationType = oneTimeProductNotificationJson.getInt("notificationType");

     if (notificationType == 1) {
       // ONE_TIME_PRODUCT_PURCHASED - A one-time product was successfully purchased by a user.
       // Verify that the purchaseToken value does not match any previous purchaseToken values in
       // your backend system to avoid duplicate processing.
       ......
       // Fetch the ProductPurchase from Purchases.products.get endpoint
       ProductPurchase productPurchase =
         AndroidPublisherHelper.executeProductPurchasesGet(packageName, sku, purchaseToken);
       if (productPurchase != null && productPurchase.getPurchaseState() == 0) {
         // The purchase is valid and in PURCHASED state.

         // The account Id set in the App when launching the billing flow.
         String obfuscatedExternalAccountId = productPurchase.getObfuscatedExternalAccountId();
         // Grant the entitlement to the correct account for obfuscatedExternalAccountId in your
         // system.
       ......
       }
     }
     // Process subscriptionNotification in the message.
     JSONObject subscriptionNotificationJson = messageJson.getJSONObject("subscriptionNotification");
     if (subscriptionNotificationJson != null) {
       ......
     }
     // Process other notification data in the message as needed.
     ......
   }

   // Acknowledge the message to avoid repeated delivery.
   consumer.ack();
 }

7. Informer Google que l'achat a été traité

Après avoir accordé un droit d'accès, vous devez informer Google que l'achat a été traité en appelant les points de terminaison purchases.products:consume ou purchases.products:acknowledge de l'API Play Developer depuis votre serveur backend sécurisé pour consommer un produit consommable ou confirmer un produit non consommable.

Dans AndroidPublisherHelper, ajoutez les méthodes suivantes pour appeler purchases.products:consume ou purchases.products:acknowledge dans l'API Google Play Developer.

 /* Consume the one-time product purchase by calling
  * Purchases.products.consume endpoint in the Google Play Developer API
  */
 public static void executeProductPurchasesConsume(
     String packageName, String sku, String purchaseToken) {
   try {
     ANDROID_PUBLISHER
       .purchases().products().consume(packageName, sku, purchaseToken).execute();
   } catch (IOException ex) {
     log.error("Exception was thrown while consuming a product purchase", ex);
     // It is recommended to apply some retry mechanism, such as exponential backoff, to ensure the purchase is correctly consumed in case of transient failures.
   }
 }

 /* Acknowledge the one-time product purchase by calling
  * Purchases.products.acknowledge endpoint in the Google Play Developer API
  */
 public static void executeProductPurchasesAcknowledge(
     String packageName, String sku, String purchaseToken) {
   try {
     ANDROID_PUBLISHER
       .purchases().products().acknowledge(packageName, sku, purchaseToken, new ProductPurchasesAcknowledgeRequest()).execute();
   } catch (IOException ex) {
     log.error("Exception was thrown while acknowledging a product purchase", ex);
     // It is recommended to apply some retry mechanism, such as exponential backoff, to ensure the purchase is correctly acknowledged in case of transient failures.
   }
 }

Dans NotificationMessageReceiver, consommez l'achat de produit consommable ou confirmez l'achat de produit non consommable après avoir accordé le droit d'accès sur votre serveur backend.

 @Override
 public void receiveMessage(PubsubMessage message, AckReplyConsumer consumer) {
   ......
       String obfuscatedExternalAccountId = productPurchase.getObfuscatedExternalAccountId();
       // Grant the entitlement to the correct account for obfuscatedExternalAccountId in your
       // system.
       ......
       // If the product is a consumable product, consume the purchase.
       AndroidPublisherHelper.executeProductPurchasesConsume(packageName, sku, purchaseToken);
       // Or if the product is a non-consumable product, acknowledge the purchase.
       // AndroidPublisherHelper.executeProductPurchasesAcknowledge(packageName, sku, purchaseToken);
  ......

 }

Une confirmation est nécessaire, car Google Play sait ainsi que le droit d'acheter a été accordé à l'utilisateur. Vous devez confirmer l'achat immédiatement après avoir accordé le droit.

Bravo ! Vous avez réussi à intégrer les notifications en temps réel pour les développeurs, ce qui permet un traitement fiable des achats, comme démontré dans cet atelier de programmation. Maintenant, pour vous assurer que tout fonctionne parfaitement, découvrons Play Billing Lab, un outil convivial conçu pour vous aider à tester votre intégration de Play Billing.

8. Tester avec Play Billing Lab

Pour lancer votre intégration en toute confiance, vous devez la tester tout au long du développement. Play Billing Lab est une application Android sans frais qui aide les développeurs à tester leur intégration avec le système de facturation de Google Play. Elle leur permet de tester facilement et de manière pratique les fonctionnalités de Play Billing, d'accélérer l'intégration et de lancer leur application plus sereinement.

Play Billing Lab propose différentes fonctionnalités de test pour vous aider à tester différents scénarios, y compris les suivants :

Modifiez le pays Play dans Play Billing Lab et appliquez les paramètres à votre test. Cela permet de tester des expériences utilisateur personnalisées dans différents pays/régions, quel que soit l'endroit où le testeur effectue les tests physiques.
Tester les offres d'essai ou de bienvenue à plusieurs reprises avec le même compte
Tester les changements de prix des abonnements sans affecter les autres abonnés actifs
Simuler le code de réponse de la bibliothèque Play Billing pour effectuer des tests dans différents scénarios d'erreur
Accélérer le renouvellement des abonnements pour accélérer les tests
Tester avec des modes de paiement réels pour contourner certains signaux de risque du parcours d'achat

Nous ajoutons régulièrement de nouvelles fonctionnalités de test à l'application Play Billing Lab. Vous pouvez télécharger et installer Play Billing Lab depuis le Play Store. Pour en savoir plus sur les tests avec Play Billing Lab, consultez Tester votre intégration.

Utiliser Play Billing Lab pour tester BillingResponseCode

Il est souvent difficile de tester tous les flux BillingResponseCode lorsque vous intégrez votre application à la bibliothèque Play Billing, car vous n'avez pas beaucoup de contrôle sur la communication entre le Play Store et le backend de Play. La fonctionnalité Simulateur de réponse de l'application Play Billing Lab vous permet de configurer des réponses de code d'erreur pour la bibliothèque Play Billing afin de tester différents scénarios d'erreur complexes.

Par exemple, vous avez implémenté la logique dans votre application pour consommer l'achat une fois que votre application a détecté qu'il avait bien été effectué. Vous souhaitez tester le scénario dans lequel votre application n'a pas pu consommer l'achat en raison d'une défaillance du réseau, et où le récepteur RTDN de votre serveur backend récupère le message et gère correctement l'achat. Vous pouvez utiliser le simulateur de réponse pour simuler le scénario de test. Les étapes suivantes vous guideront pour effectuer des tests avec le simulateur de réponse Play Billing Lab.

Tester avec le simulateur de réponse

Lorsque vous effectuez des tests avec le simulateur de réponse, votre application communique avec Play Billing Lab pour obtenir le code de réponse que vous avez configuré dans le simulateur de réponse Play Billing Lab.

Activer les tests de contournement de la facturation pour la Bibliothèque Play Billing

Pour activer la communication entre le simulateur de réponse et votre application, vous devez d'abord activer le test des remplacements de facturation pour la bibliothèque Play Billing depuis votre application. Pour ce faire, ajoutez les balises de métadonnées suivantes au fichier AndroidManifest.xml de votre application.

<manifest ... >
  <application ... >
    ...
     <meta-data
      android:name="com.google.android.play.largest_release_audience.NONPRODUCTION"
      android:value="" />
    <meta-data
      android:name="com.google.android.play.billingclient.enableBillingOverridesTesting"
      android:value="true" />
  </application>
</manifest>

Créez votre application avec le fichier AndroidManifest.xml mis à jour. Votre application est maintenant prête pour le simulateur de réponse Play Billing Lab.

Lorsque vous déployez votre application dans l'environnement de production après l'avoir testée, vous devez utiliser un fichier AndroidManifest.xml distinct qui n'inclut pas ces balises de métadonnées ou vous assurer de les avoir supprimées du fichier AndroidManifest.xml.

Simuler les erreurs de la bibliothèque Play Billing

Pour effectuer des tests avec des erreurs simulées de la Bibliothèque Play Billing, commencez par configurer le code de réponse dans l'application Play Billing Lab, puis effectuez le test dans votre application.

Configurer un code de réponse

Connectez-vous à l'application Play Billing Lab avec un compte testeur de licence pour votre application. L'image suivante affiche le tableau de bord Play Billing Lab,y compris la fiche Simulateur de réponse.

Tableau de bord Play Billing Lab avec simulateur de réponse

Cliquez sur Gérer sur la fiche "Simulateur de réponse" pour accéder à l'écran du simulateur de réponse.
Lorsque vous y êtes invité, autorisez les notifications de Play Billing Lab pour voir l'état de connexion de votre application.
Activez le bouton "Simuler les réponses de la bibliothèque Play Billing", si ce n'est pas déjà fait.

Sélectionnez un code de réponse pour les API de la Bibliothèque Play Billing que vous souhaitez tester. Pour simuler l'erreur pour l'achat de consommation, sélectionnez un code d'erreur pour l'API consumeAsync. Vos sélections sont enregistrées automatiquement. Le simulateur de réponse est maintenant prêt à envoyer les codes de réponse sélectionnés à votre application.

Tester votre application

Vous pouvez maintenant tester votre application pour vérifier que tout fonctionne comme prévu dans le scénario d'erreur configuré. Ouvrez votre application et déclenchez la méthode de l'API Play Billing Library. Si votre application effectue l'appel consumeAsync pour consommer l'achat, elle recevra le code d'erreur que vous venez de configurer. Vous pouvez vérifier si votre application fonctionne correctement en fonction du code d'erreur et si votre serveur backend traite correctement l'achat.

Une fois vos tests terminés, désactivez le bouton "Simuler les réponses de la bibliothèque Play Billing" pour arrêter la simulation de la réponse.

En savoir plus sur les tests avec Play Billing Lab ou consultez le Centre d'aide pour en savoir plus sur le test de la facturation des achats in-app avec les testeurs de licence

9. Félicitations !

Vous avez terminé cet atelier de programmation. Vous êtes désormais en mesure d'optimiser stratégiquement la monétisation de votre application pour améliorer l'expérience utilisateur, ce qui vous permettra d'accroître la satisfaction des utilisateurs, les conversions d'achat et le taux de désabonnement.

En tirant parti des notifications en temps réel pour les développeurs et de l'application associée Play Billing Lab, vous pouvez traiter de manière proactive les événements du cycle de vie des achats pour les achats ponctuels et les abonnements.

Grâce à ces outils, vous pouvez mettre en œuvre efficacement des stratégies de réactivation attrayantes, résoudre rapidement les problèmes d'intégration et, en fin de compte, améliorer l'expérience utilisateur et les sources de revenus pour lancer votre application ou votre jeu en toute confiance.

En suivant cet atelier de programmation, vous avez acquis les compétences nécessaires pour gérer l'ensemble du parcours d'achat et tester rigoureusement votre implémentation avec le Play Billing Lab. Vous pouvez ainsi offrir une expérience utilisateur fluide et maximiser votre potentiel de monétisation sur Google Play.