Cette page a été traduite par l'API Cloud Translation.

Maximiser l'intégration de Play Billing

1. Présentation

Optimisez vos sources de revenus et lancez votre application en toute confiance avec cet atelier de programmation sur l'intégration de la bibliothèque Play Billing par Google Play. Cet atelier de programmation structuré vous explique comment configurer, tester et implémenter un traitement des achats fiable. Vous pourrez ainsi atteindre vos objectifs de monétisation et proposer 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 particuliers, à simuler, reproduire et résoudre les problèmes potentiels, et à tester des offres et des changements de prix sans affecter les utilisateurs.

À la fin, vous serez prêt à mettre en œuvre des stratégies de fidélisation, à résoudre rapidement les problèmes d'intégration, à améliorer votre ROI, à proposer une expérience premium et à déployer votre application et ses mises à jour en toute confiance.

Prérequis

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

Points abordés

Gérer correctement vos cycles d'achat 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 (RTDN) à l'aide de Google Cloud Pub/Sub, qui peuvent ensuite être utilisées pour implémenter des campagnes de fidélisation et d'autres stratégies de gestion du cycle de vie
Configurer un récepteur sur votre serveur backend pour gérer de manière sécurisée les notifications avec un suivi et des droits d'accès précis afin de réduire les risques de remboursements involontaires, de fraude et d'utilisation abusive
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 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
Play Billing Lab installé sur votre appareil de test

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

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 uniques et les abonnements. Une expérience fluide peut augmenter la propension à l'achat et réduire la perte de clients.

Un parcours d'achat courant pour un achat unique ou un abonnement implique plusieurs étapes :

L'utilisateur parcourt les articles à acheter.
Lancez le parcours d'achat pour que l'utilisateur finalise l'achat et le paiement.
Informer 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 l'acheter à nouveau.

L'intégration dans l'application vous permet de lancer des parcours d'achat et de gérer cette 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 œuvre des stratégies de fidélisation des abonnés.

Par exemple, imaginons que votre utilisateur vient d'acheter un nouvel article ou qu'il a manqué son paiement, de sorte que l'abonnement est entré dans le délai de grâce. Avec les bonnes notifications RTDN, vous pouvez détecter en quasi-temps réel que l'état de l'utilisateur a changé et agir en conséquence. Par exemple, vous pouvez accroître l'engagement de l'utilisateur avec l'article qu'il vient d'acheter ou lui envoyer 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 commandes 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 perde 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 notifications 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, garantissant ainsi un processus d'achat fiable.

Pour en savoir plus sur tous les types de notifications RTDN actuellement pris en charge, cliquez ici. Chaque type de RTDN indique un état d'achat distinct. Il est essentiel d'implémenter les mécanismes de gestion correspondants pour garantir un traitement approprié selon les besoins dans vos cas d'utilisation. Cet atelier de programmation vous présente un exemple qui gère le message RTDN dans votre serveur backend sécurisé, y compris la réception du message, la validation de l'achat et l'octroi du droit d'accès à l'utilisateur approprié, lorsqu'un utilisateur effectue un achat dans votre application. Nous vous montrerons ensuite 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 (NTRD) s'appuient sur 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 notifications en temps réel pour les développeurs, 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 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, procédez comme suit :

Lisez le Guide pour les abonnés Cloud Pub/Sub pour découvrir comment configurer l'abonnement en tant qu'abonnement push ou en tant qu'abonnement pull. Dans cet atelier de programmation, nous allons utiliser 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, puis accédez à la page de configuration de Pub/Sub.
Recherchez votre sujet, puis ouvrez le paramètre des autorisations.
Cliquez sur ADD PRINCIPAL (AJOUTER UN COMPTE PRINCIPAL) pour ajouter le compte de service google-play-developer-notifications@system.gserviceaccount.com et lui attribuer le rôle Pub/Sub Publisher (Éditeur Pub/Sub).
Cliquez sur Enregistrer pour terminer la configuration du sujet.

Activer les notifications en temps réel pour les développeurs 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, et éviter la fraude et les abus pour améliorer votre ROI global.

Les notifications RTDN fournissent des mises à jour immédiates de serveur à serveur directement depuis Google Play pour les événements clés, tels que les renouvellements d'abonnements, les nouveaux achats et les problèmes de paiement. Elles aident vos systèmes backend à se synchroniser automatiquement avec l'état réel des droits d'accès des utilisateurs, en allant au-delà des limites côté client et en vous permettant 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 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é précédemment. 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 la 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 View Messages (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 d'abonnement et d'achat annulé. Vous recevrez également des événements d'achat de produits uniques, tels que ONE_TIME_PRODUCT_PURCHASED et ONE_TIME_PRODUCT_CANCELED. Pour en savoir plus sur ces événements d'achat, consultez la section Cycle de vie des achats uniques.

Cliquez sur Enregistrer les modifications.

Vous avez maintenant terminé les notifications en temps réel pour les développeurs de votre application. Vous disposez ainsi des outils nécessaires pour relever les défis courants, comme la perte d'utilisateurs grâce aux messages de fidélisation, ou la fraude et l'utilisation abusive. Dans la section suivante, nous allons créer un abonné dans 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 votre serveur backend informé de 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 livré à son compte dès que possible.

Pour cela, l'achat doit être détecté et traité dans les meilleurs délais. La bibliothèque Play Billing propose plusieurs méthodes pour détecter les achats dans votre application. Lorsqu'un achat est détecté, votre application doit en informer votre serveur backend pour qu'il le vérifie, accorde le contenu à l'utilisateur approprié, puis informe Google que l'achat a été traité. Toutefois, il se peut que votre application n'ait pas détecté l'achat dans les meilleurs délais 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. Le RTDN fournit des commandes côté serveur supplémentaires pour vous aider à gérer les achats, même lorsque le client de l'utilisateur rencontre des problèmes. La notification RTDN garantit l'envoi de notifications indépendantes à votre serveur en cas de modification de l'état de l'achat. Vous pouvez ainsi reconnaître les modifications de l'état de l'achat presque immédiatement via un deuxième chemin, indépendamment des problèmes potentiels du client, ce qui garantit un processus d'achat 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 valider l'achat, accorder le droit d'accès à l'utilisateur approprié et confirmer/utiliser 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 un exemple de code de 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 dans votre serveur backend sécurisé. Dans les sections suivantes, nous allons décrire les bonnes pratiques à suivre pour traiter les messages RTDN dans votre serveur backend.

5. Associer des identifiants utilisateur dans le parcours d'achat de 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 transmettant le contenu à l'utilisateur approprié. Pour ce faire, joignez tous les identifiants utilisateur dont vous disposez pour l'utilisateur effectuant l'achat à l'aide de obfuscatedAccountId lorsque vous lancez le parcours d'achat dans votre application. Un exemple d'identifiant peut être une version obscurcie de la connexion de l'utilisateur dans votre système. Définir ce paramètre peut aider Google à détecter les fraudes. De plus, cela peut vous aider à vous assurer que les achats sont attribués au bon utilisateur, comme indiqué dans la section Accorder des droits d'accès aux utilisateurs.

Vous trouverez ci-dessous des exemples de codes 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 à l'utilisateur approprié.

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

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

Une fois qu'un utilisateur a effectué un achat unique d'un produit, l'abonné Pub/Sub de votre serveur backend sécurisé reçoit un message Pub/Sub. Vous devez procéder comme suit sur votre serveur backend :

Analysez le purchaseToken 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 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 d'API pour l'API Google Play Developer. Nous l'utiliserons plus tard pour effectuer les appels d'API.

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 permettant d'effectuer l'appel d'API et de modifier le récepteur créé précédemment pour valider l'achat et accorder le droit d'accès à l'utilisateur approprié.

Dans AndroidPublisherHelper, ajoutez la méthode suivante pour extraire le 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 approprié dans votre système en fonction des données incluses dans la notification. Vous devez continuer à suivre l'purchaseToken sur votre serveur pour éviter tout 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 dans l'API Play Developer à partir de 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 du produit consommable ou confirmez l'achat du 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 vous permet de traiter les achats de manière fiable, comme démontré dans cet atelier de programmation. Pour vous assurer que tout fonctionne parfaitement, explorons 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 application en toute confiance, vous devez tester votre intégration tout au long du développement. Play Billing Lab est une application Android sans frais qui aide les développeurs à tester leur intégration au système de facturation de Google Play. Elle leur permet de tester facilement et rapidement les fonctionnalités de Play Billing, d'intégrer plus rapidement leur application et de la lancer 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. Vous pouvez ainsi tester des expériences utilisateur personnalisées dans différents pays/régions, quel que soit l'endroit où le testeur se trouve.
Tester des offres d'essai ou d'introduction à 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 tester différents scénarios d'erreur
Accélérez le renouvellement des abonnements pour accélérer les tests
Tester avec des modes de paiement réels pour contourner certains signaux de risque liés au 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 sur le Play Store ou consulter Tester votre intégration pour en savoir plus sur les tests avec Play Billing Lab.

Utiliser Play Billing Lab pour tester BillingResponseCode

Il est courant de rencontrer des difficultés pour tester tous les flux BillingResponseCode lors de l'intégration de votre application à la bibliothèque Play Billing, car vous n'avez que peu 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 les réponses aux codes d'erreur de 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é l'achat réussi. Vous souhaitez tester le scénario dans lequel votre application n'a pas pu consommer l'achat en raison d'une défaillance réseau, et que 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 vos tests. Vous trouverez ci-dessous la procédure à suivre pour effectuer des tests avec le simulateur de réponse Play Billing Lab.

Tester avec le simulateur de réponse

Lors 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 de Play Billing Lab.

Activer les tests des forçages de 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 les tests de forçage 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 à utiliser le simulateur de réponse Play Billing Lab.

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

Simuler des erreurs de la bibliothèque Play Billing

Pour tester 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 de testeur de licence pour votre application. L'image suivante affiche le tableau de bord de Play Billing Lab,y compris la fiche Simulateur de réponse.

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

Sur la fiche "Simulateur de réponse", cliquez sur Gérer 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 l'option "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 consommant, 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 les tests terminés, il vous suffit de désactiver le bouton "Simuler la réponse de la bibliothèque Play Billing" pour arrêter la simulation.

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

9. Félicitations !

Vous avez terminé cet atelier de programmation. Vous êtes maintenant en mesure d'optimiser de manière stratégique la monétisation de votre application pour améliorer l'expérience utilisateur et ainsi améliorer la satisfaction des utilisateurs, les conversions d'achat et le taux de désabonnement.

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

Grâce à ces outils, vous pouvez mettre en œuvre efficacement des stratégies de fidélisation 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 disposez désormais des compétences nécessaires pour gérer l'intégralité du parcours d'achat et tester rigoureusement votre implémentation avec l'atelier Play Billing. Vous pourrez ainsi garantir une expérience utilisateur fluide et maximiser votre potentiel de monétisation sur Google Play.