Massimizzare l'integrazione di Fatturazione Google Play

1. Panoramica

Ottimizza i flussi di entrate e lancia la tua app in tutta sicurezza con questo codelab di Google Play sull'integrazione della Libreria Fatturazione Play. Questo codelab strutturato ti guida nella configurazione, nel test e nell'implementazione di un'elaborazione degli acquisti affidabile, consentendoti di supportare i tuoi obiettivi di monetizzazione e di offrire un'esperienza utente più fluida.

Ti aiuteremo a configurare le notifiche in tempo reale per lo sviluppatore (RTDN) e Play Billing Lab per gli abbonamenti e i prodotti a pagamento singolo per le tue app e i tuoi giochi. Scoprirai come ridurre il tasso di abbandono degli abbonati, proteggerti da frodi e abusi, testare casi limite, simulare, riprodurre e risolvere potenziali problemi, nonché sperimentare offerte e variazioni di prezzo senza influire sugli utenti.

Al termine, sarai pronto a implementare strategie di recupero, risolvere rapidamente i problemi di integrazione, migliorare il ROI, offrire un'esperienza premium e implementare la tua app e gli aggiornamenti in tutta sicurezza.

Prerequisiti

Obiettivi didattici

  • Come gestire correttamente i cicli di vita degli acquisti per contribuire a ottimizzare la crescita con tecniche per migliorare le conversioni di acquisto e la fidelizzazione dei clienti
  • Come configurare le notifiche in tempo reale per lo sviluppatore (RTDN) utilizzando Google Cloud Pub/Sub, che possono essere utilizzate per implementare campagne di recupero e altre strategie di gestione del ciclo di vita
  • Come configurare un destinatario sul server di backend per gestire in modo sicuro le notifiche con monitoraggio e diritti accurati al fine di ridurre i rimborsi involontari o i rischi di frodi e abusi
  • Come testare l'integrazione e simulare gli errori utilizzando Play Billing Lab per migliorare l'esperienza utente riducendo al contempo i costi di sviluppo

Che cosa ti serve

2. Strategie di monetizzazione per abbonamenti e acquisti una tantum

Quando vendi prodotti digitali tramite la tua app, una strategia di monetizzazione efficace deve considerare l'intera esperienza utente, sia per gli acquisti una tantum che per gli abbonamenti. Un'esperienza fluida può aumentare la prontezza all'acquisto e ridurre il tasso di abbandono.

Un percorso di acquisto comune per un acquisto o un abbonamento una tantum prevede più fasi:

  1. L'utente sfoglia gli articoli da acquistare.
  2. Avvia il flusso di acquisto per consentire all'utente di completare l'acquisto e il pagamento.
  3. Invia una notifica al server sull'acquisto completato
  4. Verifica l'acquisto sul tuo server.
  5. Fornire contenuti all'utente.
  6. Conferma l'invio dei contenuti. Per i prodotti di consumo, consuma l'acquisto al momento opportuno in modo che l'utente possa acquistare di nuovo l'articolo.

L'integrazione in-app ti consente di lanciare flussi di acquisto e gestire questa esperienza utente, ma è fondamentale mantenere aggiornato il backend in merito ai diritti acquistati dagli utenti. Questo è importante per monitorare gli acquisti e gestire altri aspetti dell'esperienza utente, come i diritti multipiattaforma.

Le notifiche in tempo reale per lo sviluppatore (RTDN) sono un ottimo modo per riconoscere queste diverse fasi del ciclo di vita dell'acquisto e possono essere utilizzate efficacemente sia come strumento di monitoraggio del rendimento in tempo reale sia come strumento per attivare strategie di recupero degli abbonati.

Ad esempio, supponiamo che l'utente abbia appena acquistato un nuovo articolo o abbia perso il pagamento, quindi l'abbonamento è entrato nel periodo di tolleranza. Con il giusto RTDN, puoi riconoscere, quasi in tempo reale, che lo stato dell'utente è cambiato e agire di conseguenza coinvolgendo l'utente ancora di più con l'articolo appena acquistato o inviando email di promemoria per aggiornare i dati di pagamento per continuare l'abbonamento.

Le RTDN sono anche un ottimo modo per aggiungere ulteriori controlli lato server che ti consentono di gestire gli acquisti anche quando il client dell'utente presenta problemi. Supponiamo che un utente abbia effettuato un acquisto e abbia ricevuto la conferma da Google, ma che il suo dispositivo perda la connettività di rete prima che il dispositivo e la tua app ricevano la notifica dell'acquisto tramite l'ascoltatore di acquisti. Con le RTDN, riceverai una notifica indipendente tramite il tuo server, che ti consentirà di riconoscere l'acquisto e concedere il diritto all'utente indipendentemente dal problema del cliente, garantendo un processo di acquisto affidabile.

Puoi scoprire di più su tutti i tipi di RTDN attualmente supportati qui. Ogni tipo di RTDN indica uno stato di acquisto distinto. È fondamentale implementare i meccanismi di gestione corrispondenti per garantire un'elaborazione corretta in base alle esigenze dei tuoi casi d'uso. Questo codelab illustra un esempio che gestisce il messaggio RTDN nel server di backend sicuro, inclusa la ricezione del messaggio, la convalida dell'acquisto e la concessione del diritto all'utente corretto quando un utente completa correttamente un acquisto nella tua app. Successivamente, ti mostreremo come configurare gli RTDN per la tua app.

3. Configurare le notifiche in tempo reale per lo sviluppatore (RTDN)

Le notifiche in tempo reale per lo sviluppatore (RTDN) sfruttano Google Cloud Pub/Sub per consentirti di reagire immediatamente alle modifiche dello stato dell'acquisto. Cloud Pub/Sub è un servizio di messaggistica in tempo reale completamente gestito che puoi utilizzare per inviare e ricevere messaggi tra applicazioni indipendenti. Google Play utilizza Cloud Pub/Sub per pubblicare notifiche push sugli argomenti a cui ti iscrivi.

Per attivare le notifiche in tempo reale per lo sviluppatore, devi prima configurare Cloud Pub/Sub utilizzando il tuo progetto Google Cloud (Google Cloud) e poi attivare le notifiche per la tua app. Se non hai dimestichezza con Google Cloud e Cloud Pub/Sub, consulta la guida introduttiva.

Crea un argomento

Per iniziare a ricevere le notifiche, devi creare un argomento su cui Google Play deve pubblicarle. Per creare un argomento, segui le istruzioni in Creare l'argomento.

Crea un abbonamento Pub/Sub

Per ricevere i messaggi pubblicati in un argomento, devi creare un abbonamento Pub/Sub per quell'argomento. Per creare una sottoscrizione Pub/Sub, segui questi passaggi:

  1. Leggi la guida per gli abbonati a Cloud Pub/Sub per familiarizzare con la configurazione dell'abbonamento come abbonamento push o abbonamento pull. In questo codelab lavoreremo con un abbonamento pull che richiede che il server di backend sicuro avvii richieste al server Cloud Pub/Sub per recuperare i messaggi.
  1. Segui le istruzioni riportate in Aggiungere un abbonamento per creare un abbonamento.

Concedi i diritti di pubblicazione sull'argomento

Cloud Pub/Sub richiede che tu conceda a Google Play i privilegi per pubblicare notifiche nel tuo argomento.

  1. Apri la console Google Cloud.
  2. Seleziona il progetto, cerca "Pub/Sub" nella barra di ricerca e vai alla pagina di configurazione di Pub/Sub. Cerca e vai alla pagina di configurazione di Pub/Sub
  3. Trova l'argomento e apri l'impostazione delle autorizzazioni. Apri l'impostazione di autorizzazione
  4. Fai clic su AGGIUNGI PRINCIPALE per aggiungere l'account di servizio google-play-developer-notifications@system.gserviceaccount.com e concedigli il ruolo di Publisher Pub/Sub. Aggiungi l'account di servizio google-play-developer-notifications@system.gserviceaccount.com e concedigli il ruolo Publisher Pub/Sub
  5. Fai clic su Salva per completare la configurazione dell'argomento. Fai clic su Salva per completare la configurazione dell'argomento.

Attivare le notifiche in tempo reale per lo sviluppatore (RTDN) per la tua app

Scopri come configurare le notifiche in tempo reale per lo sviluppatore (RTDN) per migliorare notevolmente l'integrazione di Fatturazione Play. Puoi migliorare l'affidabilità degli acquisti con la messaggistica personalizzata e anche prevenire attività fraudolente e abusi per migliorare il ROI complessivo.

I report RTDN forniscono aggiornamenti immediati da server a server direttamente da Google Play per eventi chiave, come rinnovi degli abbonamenti, nuovi acquisti e problemi di pagamento. Aiutano i sistemi di backend a sincronizzarsi automaticamente con lo stato reale dei diritti utente, superando le limitazioni lato client e consentendoti di reagire immediatamente e in modo appropriato.

Come attivare le notifiche in tempo reale per lo sviluppatore per la tua app:

  1. Apri Google Play Console.
  2. Selezionare l'app.
  3. Vai a Monetizza con Google Play > Configurazione della monetizzazione.
  4. Scorri fino alla sezione Notifiche in tempo reale per lo sviluppatore.
  5. Seleziona Attiva notifiche in tempo reale.
  6. Nel campo Nome argomento, inserisci il nome completo dell'argomento Cloud Pub/Sub configurato in precedenza. Il nome dell'argomento deve essere nel formato projects/{project_id}/topics/{topic_name}, dove project_id è l'identificatore univoco del progetto e topic_name è il nome dell'argomento creato in precedenza.
  7. Fai clic su Invia messaggio di prova per inviare un messaggio di prova. L'esecuzione di una pubblicazione di prova consente di assicurarti che tutto sia configurato correttamente. Se la pubblicazione di prova ha esito positivo, viene visualizzato un messaggio che lo indica. Se hai allegato una sottoscrizione per questo argomento, dovresti ricevere il messaggio di test. Per un abbonamento pull, vai all'abbonamento in Cloud Console, fai clic su Visualizza messaggi e procedi con il pull dei messaggi. Devi confermare tutti i messaggi che hai estratto per evitare che Cloud Pub/Sub li invii ripetutamente. Per un abbonamento push, controlla se il messaggio di prova viene recapitato al tuo endpoint push. Un codice di risposta positivo fungerà da messaggio di conferma. Se la pubblicazione non riesce, viene visualizzato un errore. Assicurati che il nome dell'argomento sia corretto e che l'account di servizio google-play-developer-notifications@system.gserviceaccount.com abbia accesso come Publisher Pub/Sub all'argomento.
  8. Scegli i tipi di notifiche che vuoi ricevere.
  • Ricevi notifiche relative agli abbonamenti e a tutti gli acquisti annullati: ricevi notifiche in tempo reale per lo sviluppatore relative ad abbonamenti e acquisti annullati. Non riceverai notifiche per gli acquisti di prodotti a pagamento singolo.
  • Ricevi tutte le notifiche per gli abbonamenti e i prodotti a pagamento singolo: ricevi notifiche per tutti gli eventi relativi ad abbonamenti e acquisti annullati. Riceverai anche eventi di acquisto di prodotti una tantum, come ONE_TIME_PRODUCT_PURCHASED e ONE_TIME_PRODUCT_CANCELED. Per scoprire di più su questi eventi di acquisto, consulta Ciclo di vita dell'acquisto una tantum.

a266e5dec5c93cd8.png

  1. Fai clic su Salva modifiche.

Ora che hai completato le notifiche per gli sviluppatori in tempo reale per la tua app, hai a disposizione gli strumenti per risolvere le sfide comuni, come il tasso di abbandono degli utenti tramite messaggi di recupero o attività fraudolente e illecite. Nella sezione successiva, creeremo un sottoscrittore nel server di backend sicuro per consumare i messaggi inviati all'argomento Cloud Pub/Sub.

4. Ricevere notifiche

Per offrire la migliore esperienza utente nella tua app, è fondamentale mantenere aggiornato il server di backend sullo stato degli acquisti. Ad esempio, quando un utente completa correttamente un acquisto con pagamento nell'app, deve ricevere i contenuti nel proprio account il prima possibile.

Ciò richiede che il completamento dell'acquisto venga rilevato ed elaborato in modo tempestivo. Libreria Fatturazione Play offre diversi modi per rilevare gli acquisti nella tua app. Al rilevamento di un acquisto completato, l'app deve inviare una notifica al server di backend per verificare l'acquisto, concedere i contenuti all'utente corretto e poi notificare a Google che l'acquisto è stato elaborato. Tuttavia, potrebbe capitare che la tua app non abbia rilevato l'acquisto in modo tempestivo per vari motivi. Ad esempio, un utente può effettuare un acquisto riuscito e ricevere una conferma da Google, ma il suo dispositivo perde la connettività di rete prima che il dispositivo e la tua app ricevano la notifica tramite l'interfaccia della Libreria Fatturazione Google Play. RTDN fornisce controlli lato server aggiuntivi per aiutarti a gestire gli acquisti anche quando il client dell'utente presenta problemi. RTDN garantisce notifiche indipendenti al tuo server in caso di variazioni dello stato di acquisto, consentendoti di riconoscerle quasi immediatamente tramite un secondo percorso, indipendentemente dai potenziali problemi del cliente, garantendo un processo di acquisto più affidabile.

In questa sezione creerai un sottoscrittore per utilizzare i messaggi inviati al tuo argomento Cloud Pub/Sub utilizzando le librerie client Cloud Pub/Sub. Queste librerie sono disponibili in diverse lingue. Nelle sezioni seguenti, aggiungeremo l'abbonato per verificare l'acquisto, concedere il diritto all'utente corretto e confermare/consumare l'acquisto sul server. Per questo codelab utilizzeremo Java.

Ogni pubblicazione effettuata in un argomento Cloud Pub/Sub contiene un singolo campo di dati con codifica base64.

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

Dopo aver decodificato il campo di dati codificato in Base64, DeveloperNotification contiene i seguenti campi:

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

Per ulteriori informazioni, consulta la documentazione di riferimento delle notifiche in tempo reale per lo sviluppatore.

Di seguito è riportato il codice di esempio di un NotificationReceiver per il server di backend sicuro per l'elaborazione dei messaggi Pub/Sub. Per effettuare l'autenticazione in Security Command Center, configura le Credenziali predefinite dell'applicazione. Consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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();
   }
 }
}

Ora hai un destinatario di notifiche che utilizza i messaggi inviati all'argomento Cloud Pub/Sub nel server di backend sicuro. Nelle sezioni seguenti illustreremo le best practice per elaborare i messaggi RTDN nel server di backend.

5. Collega gli identificatori utente nel flusso di acquisto della tua app

Quando il server riceve il messaggio RTDN relativo all'aggiornamento dello stato dell'acquisto, deve sapere quale utente ha effettuato l'acquisto per poterlo elaborare, ad esempio inviare i contenuti all'utente corretto. Puoi farlo associando eventuali identificatori utente che hai per l'utente che effettua l'acquisto utilizzando obfuscatedAccountId quando avvii il flusso di acquisto nella tua app. Un identificatore di esempio potrebbe essere una versione offuscata dell'accesso dell'utente nel tuo sistema. L'impostazione di questo parametro può aiutare Google a rilevare le frodi. Inoltre, può aiutarti ad assicurarti che gli acquisti vengano attribuiti all'utente giusto, come descritto in Concedere diritti agli utenti.

Di seguito sono riportati i codici di esempio per associare l'identificatore utente all'avvio del flusso di acquisto nell'app impostando 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);

Come vedrai nella sezione successiva, l'identificatore utente impostato nel flusso di acquisto verrà incluso nell'acquisto e potrà essere utilizzato per concedere i diritti all'utente corretto.

6. Verificare gli acquisti prima di concedere i diritti

In questa sezione illustreremo le best practice per verificare gli acquisti prima di concedere i diritti nel server di backend sicuro.

Dopo che un utente ha effettuato un acquisto di un prodotto a pagamento singolo, l'abbonato Pub/Sub nel tuo server di backend sicuro riceverà un messaggio Pub/Sub. Nel server di backend devi:

  1. Analizza purchaseToken dal messaggio Pub/Sub. Devi conservare un record di tutti i valori purchaseToken per tutti gli acquisti.
  2. Verifica che il valore purchaseToken per l'acquisto corrente non corrisponda a nessun valore purchaseToken precedente. purchaseToken è univoco a livello globale, quindi puoi utilizzare questo valore in tutta sicurezza come chiave primaria nel tuo database.
  3. Utilizza l'endpoint purchases.products:get nell'API Google Play Developer per verificare con Google che l'acquisto sia legittimo.
  1. Se l'acquisto è legittimo e non è stato utilizzato in passato, puoi concedere in sicurezza il diritto all'articolo o all'abbonamento in-app.
  2. Devi concedere il diritto solo quando lo stato dell'acquisto è PURCHASED e assicurarti di gestire correttamente gli acquisti PENDING. Puoi trovare ulteriori informazioni nella pagina Gestire le transazioni in sospeso.

Il seguente esempio di codice crea un client API per l'API Google Play Developer. Lo utilizzeremo per effettuare le chiamate API in un secondo momento.

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);
   }
 }
}

Aggiungiamo quindi la logica per effettuare la chiamata all'API e modificare il destinatario creato in precedenza per convalidare l'acquisto e concedere il diritto all'utente corretto.

In AndroidPublisherHelper, aggiungi il seguente metodo per recuperare l'oggetto ProductPurchase dall'endpoint Purchases.products:get nell'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;
   }
 }

In NotificationMessageReceiver, convalida l'acquisto e concedi il diritto all'utente corretto nel tuo sistema in base ai dati inclusi nella notifica. Devi continuare a monitorare purchaseToken nel tuo server per evitare l'elaborazione duplicata.

 @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. Comunicare a Google che l'acquisto è stato elaborato

Dopo aver concesso il diritto, devi informare Google che l'acquisto è stato elaborato chiamando i punti di endpoint purchases.products:consume o purchases.products:acknowledge nell'API Play Developer dal tuo server di backend sicuro per consumare un prodotto consumabile o confermare un prodotto non consumabile.

In AndroidPublisherHelper, aggiungi i seguenti metodi per chiamare purchases.products:consume o purchases.products:acknowledge nell'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.
   }
 }

In NotificationMessageReceiver, utilizza l'acquisto del prodotto di consumo o conferma l'acquisto del prodotto non di consumo dopo aver concesso il diritto nel server di 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);
  ......

 }

Il riconoscimento è obbligatorio, in quanto comunica a Google Play che all'utente è stato concesso il diritto all'acquisto. Devi confermare l'acquisto immediatamente dopo aver concesso il diritto.

Ottimo lavoro. Hai eseguito l'integrazione con le notifiche in tempo reale per lo sviluppatore, consentendo un'elaborazione affidabile degli acquisti, come dimostrato in questo codelab. Ora, per assicurarti che tutto funzioni perfettamente, scopriamo Play Billing Lab, uno strumento facile da usare progettato per aiutarti a testare l'integrazione di Fatturazione Play.

8. Eseguire test con Play Billing Lab

Per lanciare il prodotto in tutta sicurezza, devi testare l'integrazione durante lo sviluppo. Play Billing Lab è un'app per Android senza costi che aiuta gli sviluppatori a testare la propria integrazione con il sistema di fatturazione di Google Play, offrendo un modo semplice e pratico per testare le funzionalità di Fatturazione Google Play, eseguire l'integrazione più velocemente e lanciare le app con maggiore sicurezza.

Play Billing Lab offre varie funzionalità di test per aiutarti a testare diversi scenari, tra cui:

Stiamo aggiungendo continuamente nuove funzionalità di test all'app Play Billing Lab. Puoi scaricare e installare Play Billing Lab dal Play Store oppure consultare l'articolo Testare l'integrazione per saperne di più sui test con Play Billing Lab.

Utilizzare Play Billing Lab per testare BillingResponseCode

È una sfida comune testare tutti i flussi di BillingResponseCode durante l'integrazione dell'app con la Libreria Fatturazione Play, perché non hai molto controllo sulla comunicazione tra il Play Store e il backend di Google Play. La funzionalità Simulatore di risposta nell'app Play Billing Lab ti consente di configurare le risposte ai codici di errore per la Libreria Fatturazione Play al fine di testare vari scenari di errori complessi.

Ad esempio, hai implementato la logica nell'app per utilizzare l'acquisto dopo che l'app ha rilevato il completamento dell'acquisto. Vuoi testare lo scenario in cui la tua app non è riuscita a utilizzare l'acquisto a causa di un errore di rete e il ricevitore RTDN nel tuo server di backend riceve il messaggio e gestisce l'acquisto correttamente. Puoi utilizzare il simulatore di risposta per simulare lo scenario per i test. Di seguito sono riportati i passaggi per eseguire il test con il simulatore di risposta di Play Billing Lab.

Eseguire il test con il simulatore di risposte

Durante il test con il simulatore di risposte, la tua app comunicherà con Play Billing Lab per ottenere il codice di risposta configurato nel simulatore di risposte di Play Billing Lab.

Attivare i test delle sostituzioni di fatturazione per la Libreria Fatturazione Play

Per attivare la comunicazione tra il Simulatore di risposta e la tua app, devi prima attivare i test di override della fatturazione per la Libreria Fatturazione Google Play dalla tua app. A tale scopo, aggiungi i seguenti tag metadati al file AndroidManifest.xml della tua app.

<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>

Crea la tua app con il file AndroidManifest.xml aggiornato. Ora la tua app è pronta per il simulatore di risposte di Play Billing Lab.

Quando esegui il deployment dell'app nell'ambiente di produzione dopo il test, devi utilizzare un file AndroidManifest.xml separato che non includa questi tag dei metadati o assicurarti di averli rimossi dal file AndroidManifest.xml.

Simulare gli errori della Libreria Fatturazione Play

Per eseguire il test con errori simulati della Libreria Fatturazione Play, configura prima il codice di risposta nell'app Play Billing Lab, quindi esegui il test nella tua app.

Configurare un codice di risposta

  1. Accedi all'app Play Billing Lab con un account tester della licenza per la tua app. La seguente immagine mostra la dashboard di Play Billing Lab,inclusa la scheda Simulatore di risposte.

Dashboard di Play Billing Lab con il simulatore di risposte

  1. Fai clic su Gestisci nella scheda del simulatore di risposte per accedere alla relativa schermata.
  2. Quando richiesto, consenti le notifiche da Play Billing Lab per visualizzare lo stato di connessione della tua app.
  3. Attiva l'opzione Simula le risposte della Libreria Fatturazione Play, se non è già attivata.

c841baa4c96bf306.png

  1. Seleziona un codice di risposta per le API Play Billing Library che vuoi testare. Per simulare l'errore per l'acquisto del consumatore, seleziona un codice di errore per l'API consumeAsync. Le selezioni vengono salvate automaticamente. Ora il simulatore di risposte è pronto per inviare i codici di risposta selezionati alla tua app.

Testa la tua app

Ora puoi testare l'app per verificare se tutto funziona come previsto nello scenario di errore configurato. Apri l'app e attiva il metodo dell'API Play Billing Library. Se la tua app effettua la chiamata consumeAsync per utilizzare l'acquisto, riceverà il codice di errore che hai appena configurato. Puoi verificare se la tua app funziona correttamente in base al codice di errore e se il server di backend sta elaborando correttamente l'acquisto.

Al termine dei test, disattiva l'opzione Simula le risposte della Libreria Fatturazione Play per interrompere la simulazione della risposta.

Scopri di più sui test con Lab Fatturazione Play o visita il Centro assistenza per saperne di più sul test della fatturazione in-app con i tester delle licenze.

9. Complimenti!

Hai completato questo codelab e ora hai le competenze per ottimizzare strategicamente la monetizzazione della tua app al fine di migliorare l'esperienza utente e aumentare la soddisfazione degli utenti, le conversioni di acquisto e il tasso di abbandono degli abbonati.

Sfruttando le notifiche in tempo reale per lo sviluppatore e l'app complementare Play Billing Lab, puoi gestire in modo proattivo gli eventi del ciclo di vita degli acquisti sia per gli acquisti una tantum sia per gli abbonamenti.

Con questi strumenti, puoi implementare in modo efficace strategie di ricoinvolgimento coinvolgenti, risolvere rapidamente i problemi di integrazione e, in ultima analisi, migliorare l'esperienza utente e i flussi di entrate per lanciare la tua app o il tuo gioco in tutta sicurezza.

Dopo aver completato questo codelab, ora disponi delle competenze per gestire l'intero percorso di acquisto e testare rigorosamente l'implementazione con Play Billing Lab, garantendo un'esperienza utente senza interruzioni e massimizzando il potenziale di monetizzazione su Google Play.