Maximizar a integração do Google Play Faturamento

1. Visão geral

Otimize suas fontes de receita e lance seu app com confiança com este codelab de integração da Biblioteca Play Faturamento do Google Play. Este codelab estruturado ensina a configurar, testar e implementar um processamento de compras confiável, permitindo que você alcance suas metas de monetização e ofereça uma experiência do usuário mais integrada.

Vamos ajudar você a configurar as Notificações do desenvolvedor em tempo real (RTDNs) e o Google Play Billing Lab para assinaturas e produtos únicos nos seus apps e jogos. Você vai aprender a reduzir a rotatividade de assinantes, se proteger contra fraudes e abusos, testar casos extremos, simular, reproduzir e resolver possíveis problemas, além de testar ofertas e mudanças de preços sem afetar os usuários.

Ao final, você vai estar pronto para implementar estratégias de recuperação, resolver rapidamente desafios de integração, melhorar o ROI, oferecer uma experiência premium e lançar seu app e atualizações com confiança.

Pré-requisitos

Familiaridade com a integração básica da Biblioteca Play Faturamento
Familiaridade com o desenvolvimento de apps Android (Java)

O que você vai aprender

Como gerenciar adequadamente os ciclos de vida de compra para otimizar o crescimento com técnicas que melhoram as conversões de compra e a retenção de clientes
Como configurar as Notificações do desenvolvedor em tempo real (RTDN) usando o Google Cloud Pub/Sub, que pode ser usado para implementar campanhas de recuperação e outras estratégias de gerenciamento do ciclo de vida
Como configurar um receptor no servidor de back-end para processar as notificações com segurança, com rastreamento e direitos precisos, reduzindo reembolsos não intencionais ou riscos de fraude e abuso
Como testar sua integração e simular erros usando o Play Billing Lab para melhorar a experiência do usuário e reduzir os custos de desenvolvimento

O que é necessário

Acesso à conta de desenvolvedor do Google Play para seu app no Google Play Console
Acesso ao seu projeto do Google Cloud Platform com a API Google Play Developer ativada
Um servidor de back-end para processar contas e direitos do seu app Android
Testadores de licença registrados para seu app no Play Console
O Play Billing Lab instalado no seu dispositivo de teste

2. Estratégias de monetização para assinaturas e compras únicas

Ao vender produtos digitais pelo seu app, uma estratégia de monetização bem-sucedida precisa considerar toda a experiência do usuário, tanto para compras únicas quanto para assinaturas. Uma experiência integrada pode aumentar a prontidão para compra e reduzir a rotatividade.

Um fluxo de compra comum para uma compra única ou assinatura envolve várias etapas:

O usuário navega pelos itens para comprar.
Inicie o fluxo de compra para que o usuário conclua a compra e o pagamento.
Notificar seu servidor sobre a compra concluída
Verifique a compra no seu servidor.
Forneça conteúdo ao usuário.
Confirme a entrega do conteúdo. Para produtos de consumo, consuma a compra no momento adequado para que o usuário possa comprar o item novamente.

A integração no app permite iniciar fluxos de compra e gerenciar essa experiência do usuário, mas é fundamental manter seu back-end atualizado com relação aos direitos de acesso que os usuários estão comprando. Isso é importante para acompanhar compras e gerenciar outros aspectos da experiência do usuário, como direitos multiplataforma.

As notificações do desenvolvedor em tempo real (RTDN, na sigla em inglês) são uma ótima maneira de reconhecer essas diferentes etapas no ciclo de vida da compra e podem ser usadas de forma eficaz como uma ferramenta de acompanhamento de performance em tempo real e como uma ferramenta para ativar estratégias de recuperação de assinantes.

Por exemplo, digamos que o usuário acabou de comprar um novo item ou perdeu o pagamento e a assinatura entrou no período de carência. Com a RTDN certa, você pode reconhecer, quase em tempo real, que o status do usuário mudou e agir de acordo, envolvendo ainda mais o usuário com o item que ele acabou de comprar ou enviando e-mails de lembrete para atualizar os detalhes de pagamento e continuar a assinatura.

As RTDNs também são uma ótima maneira de adicionar outros controles do lado do servidor para ajudar você a gerenciar compras mesmo quando o cliente do usuário tem problemas. Por exemplo, um usuário fez uma compra bem-sucedida e recebeu a confirmação do Google, mas o dispositivo perdeu a conexão de rede antes que ele e o app recebessem uma notificação da compra pelo listener de compra. Com as RTDNs, você recebe uma notificação independente pelo servidor, o que permite reconhecer a compra e conceder o direito de acesso ao usuário, independentemente do problema do cliente, garantindo um processo de compra confiável.

Saiba mais sobre todos os tipos de RTDNs atualmente compatíveis aqui. Cada tipo de RTDN indica um status de compra diferente. É fundamental implementar mecanismos de tratamento correspondentes para garantir o processamento adequado conforme necessário nos seus casos de uso. Este codelab vai mostrar um exemplo que processa a mensagem RTDN no seu servidor de back-end seguro, incluindo o recebimento da mensagem, a validação da compra e a concessão do direito ao usuário correto quando ele conclui uma compra no seu app. Em seguida, vamos mostrar como configurar as RTDNs para seu app.

3. Configurar as Notificações do desenvolvedor em tempo real (RTDN)

As notificações do desenvolvedor em tempo real (RTDN) usam o Google Cloud Pub/Sub para permitir que você reaja imediatamente às mudanças no estado da compra. O Cloud Pub/Sub é um serviço de mensagens em tempo real totalmente gerenciado que pode ser usado para enviar e receber mensagens entre aplicativos independentes. O Google Play usa o Cloud Pub/Sub para publicar notificações push sobre tópicos que você assina.

Para ativar o RTDN, primeiro configure o Cloud Pub/Sub usando seu próprio projeto do Google Cloud Platform (GCP) e depois ative as notificações para seu app. Se você não conhece o GCP e o Cloud Pub/Sub, consulte o Guia de início rápido.

Criar um tópico

Para começar a receber notificações, crie um tópico em que o Google Play vai publicar as notificações. Para criar um tópico, siga as instruções em Criar um tópico.

Criar uma assinatura do Pub/Sub

Para receber mensagens publicadas em um tópico, crie uma assinatura do Pub/Sub para ele. Para criar uma assinatura do Pub/Sub, faça o seguinte:

Leia o Guia do assinante do Cloud Pub/Sub para saber como configurar a assinatura como assinatura por push ou assinatura por pull. Neste codelab, vamos trabalhar com uma assinatura por pull que exige que seu servidor de back-end seguro inicie solicitações ao servidor do Cloud Pub/Sub para recuperar mensagens.

Siga as instruções em Adicionar uma assinatura para criar uma.

Conceder direitos de publicação no tópico

O Cloud Pub/Sub requer que você conceda permissões ao Google Play para publicar notificações no seu tópico.

Abra o Console do Google Cloud.
Selecione seu projeto, pesquise Pub/Sub na barra de pesquisa e acesse a página de configuração do Pub/Sub.
Localize seu tópico e abra a configuração de permissões.
Clique em ADICIONAR PRINCIPAL para adicionar a conta de serviço google-play-developer-notifications@system.gserviceaccount.com e conceda a ela o papel de Publicador do Pub/Sub.
Clique em Salvar para concluir a configuração do tópico.

Ativar as RTDN para seu app

Aprenda a configurar as Notificações do desenvolvedor em tempo real (RTDN, na sigla em inglês) para melhorar significativamente a integração do Play Faturamento. É possível melhorar a confiabilidade das compras com mensagens personalizadas e evitar fraudes e abusos para aumentar o ROI geral.

As RTDNs fornecem atualizações imediatas de servidor para servidor diretamente do Google Play para eventos importantes, como renovações de assinatura, novas compras e problemas de pagamento. Eles ajudam seus sistemas de back-end a se sincronizar automaticamente com o status real dos direitos do usuário, indo além das limitações do lado do cliente e permitindo que você reaja instantaneamente e de maneira adequada.

Como ativar as Notificações do desenvolvedor em tempo real para seu app:

Abra o Google Play Console.
Selecione seu app.
Acesse Monetizar com o Google Play > Configuração de monetização.
Role até a seção Notificações do desenvolvedor em tempo real.
Marque Ativar notificações em tempo real.
No campo Nome do tópico, insira o nome completo do tópico do Cloud Pub/Sub que você configurou anteriormente. O nome do tópico precisa estar no formato projects/{project_id}/topics/{topic_name}, em que project_id é o identificador exclusivo do seu projeto e topic_name é o nome do tópico criado anteriormente.
Clique em Enviar mensagem de teste. O teste de publicação ajuda a garantir que tudo esteja configurado corretamente. Se a publicação de teste for bem-sucedida, uma mensagem será exibida informando isso. Se você anexou uma assinatura para este tópico, você vai receber a mensagem de teste. Para uma assinatura por pull, acesse a assinatura no Console do Cloud, clique em Ver mensagens e prossiga para extrair mensagens. É necessário confirmar todas as mensagens que você quer extrair para evitar o envio repetido pelo Cloud Pub/Sub. Para uma assinatura por push, confira se a mensagem de teste é entregue ao endpoint de push. Um código de resposta bem-sucedido servirá como uma mensagem de confirmação. Se a publicação falhar, um erro será exibido. Verifique se o nome do tópico está correto e se a conta de serviço google-play-developer-notifications@system.gserviceaccount.com tem acesso de Editor do Pub/Sub ao tópico.
Escolha os tipos de notificação que você quer receber.

Receber notificações de assinaturas e de todas as compras anuladas: receba notificações do desenvolvedor em tempo real relacionadas a assinaturas e compras anuladas. Você não vai receber notificações de compras únicas de produtos.
Receber todas as notificações de assinaturas e produtos únicos: receba notificações de todos os eventos de assinatura e compra anulada. Você também vai receber eventos de compra de produtos únicos, como ONE_TIME_PRODUCT_PURCHASED e ONE_TIME_PRODUCT_CANCELED. Consulte Ciclo de vida de compras únicas para saber mais sobre esses eventos de compra.

Clique em Salvar alterações.

Agora você concluiu as notificações do desenvolvedor em tempo real para seu app, fornecendo as ferramentas para lidar com desafios comuns, como o desligamento de usuários por meio de mensagens de recuperação ou fraude e abuso. Na próxima seção, vamos criar um assinante no seu servidor de back-end seguro para consumir as mensagens enviadas ao seu tópico do Cloud Pub/Sub.

4. Receber notificações

É fundamental manter o servidor de back-end atualizado sobre o status das compras para oferecer a melhor experiência do usuário no app. Por exemplo, quando um usuário conclui uma compra com um pagamento no app, o conteúdo precisa ser entregue à conta dele o mais rápido possível.

Isso exige que a conclusão da compra seja detectada e processada de maneira oportuna. A Biblioteca Play Faturamento oferece várias maneiras de detectar as compras no seu app. Ao detectar uma compra concluída, o app precisa notificar o servidor de back-end para verificar a compra, conceder o conteúdo ao usuário correto e notificar o Google de que a compra foi processada. No entanto, pode acontecer de o app não detectar a compra a tempo por vários motivos. Por exemplo, um usuário pode fazer uma compra bem-sucedida e receber a confirmação do Google, mas o dispositivo perde a conectividade de rede antes que ele e o app recebam uma notificação pela interface da Biblioteca Play Faturamento. O RTDN oferece controles adicionais do lado do servidor para ajudar você a gerenciar compras mesmo quando o cliente do usuário tem problemas. As RTDNs garantem notificações independentes ao seu servidor quando há mudanças no status da compra. Assim, você pode reconhecer essas mudanças quase imediatamente por um segundo caminho, independente de possíveis problemas do cliente, garantindo um processo de compra mais confiável.

Nesta seção, você vai criar um assinante para consumir as mensagens enviadas ao seu tópico do Cloud Pub/Sub usando as bibliotecas de cliente do Cloud Pub/Sub. Essas bibliotecas estão disponíveis em várias linguagens. Nas seções a seguir, vamos adicionar ao assinante para verificar a compra, conceder o direito ao usuário correto e confirmar/efetivar a compra no servidor. Neste codelab, vamos usar Java.

Cada publicação feita em um tópico do Cloud Pub/Sub contém um único campo de dados codificado em base64.

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

Depois de decodificar o campo de dados codificado em base64, o DeveloperNotification contém os seguintes campos:

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

Consulte Referência de notificações do desenvolvedor em tempo real para mais informações.

Confira a seguir o exemplo de código de um NotificationReceiver para seu servidor de back-end seguro processar as mensagens do Pub/Sub. Para autenticar no Security Command Center, configure o Application Default Credentials. Consulte Configurar a autenticação para um ambiente de desenvolvimento 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();
   }
 }
}

Agora você tem um receptor de notificações que consome as mensagens enviadas ao seu tópico do Cloud Pub/Sub no servidor de back-end seguro. Nas seções a seguir, vamos abordar as práticas recomendadas para processar as mensagens da RTDN no servidor de back-end.

5. Anexe identificadores de usuário ao fluxo de compra no seu app

Quando o servidor recebe a mensagem RTDN sobre a atualização do status da compra, ele precisa saber qual usuário fez a compra para processá-la, como entregar o conteúdo ao usuário correto. Para isso, anexe os identificadores de usuário que você tem para o usuário que está fazendo a compra usando obfuscatedAccountId ao iniciar o fluxo de compra no seu app. Um exemplo de identificador pode ser uma versão ofuscada do login do usuário no seu sistema. Definir esse parâmetro pode ajudar o Google a detectar fraudes. Além disso, ele ajuda a garantir que as compras sejam atribuídas ao usuário certo, conforme discutido em conceder direitos aos usuários.

Confira abaixo os exemplos de código para anexar o identificador do usuário ao iniciar o fluxo de compra no app definindo 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);

Como você verá na próxima seção, o identificador de usuário definido no fluxo de compra será incluído na compra e poderá ser usado para conceder direitos ao usuário correto.

6. Verificar compras antes de conceder titularidade

Nesta seção, vamos abordar as práticas recomendadas para verificar compras antes de conceder direitos no seu servidor de back-end seguro.

Depois que um usuário faz uma compra única de um produto, o assinante do Pub/Sub no seu servidor de back-end seguro recebe uma mensagem do Pub/Sub. Faça o seguinte no servidor de back-end:

Analise o purchaseToken da mensagem do Pub/Sub. Você precisa manter um registro de todos os valores purchaseToken para todas as compras.
Verifique se o valor purchaseToken da compra atual não corresponde a nenhum valor purchaseToken anterior. purchaseToken é globalmente exclusivo. Assim, esse valor pode ser usado como a chave primária do seu banco de dados com segurança.
Use o endpoint purchases.products:get na API Google Play Developer para validar com o Google se a compra é legítima.

Se a compra for legítima e não tiver sido usada no passado, você poderá conceder a titularidade ao item no app ou à assinatura com segurança.
Conceda o direito apenas quando o estado de compra for PURCHASED e garanta que as compras PENDING sejam processadas corretamente. Saiba mais em Como processar transações pendentes.

O exemplo de código a seguir cria um cliente de API para a API Google Play Developer. Vamos usá-lo para fazer as chamadas de API mais tarde.

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

Em seguida, adicionamos a lógica para fazer a chamada de API e modificar o receptor criado anteriormente para validar a compra e conceder o direito ao usuário correto.

Em AndroidPublisherHelper, adicione o seguinte método para buscar o ProductPurchase do endpoint Purchases.products:get na 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;
   }
 }

Em NotificationMessageReceiver, valide a compra e conceda o direito ao usuário correto no seu sistema com base nos dados incluídos na notificação. Continue rastreando o purchaseToken no seu servidor para evitar o processamento duplicado.

 @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. Notificar o Google de que a compra foi processada

Depois de conceder o direito, notifique o Google de que a compra foi processada chamando os endpoints purchases.products:consume ou purchases.products:acknowledge na API Play Developer do seu servidor de back-end seguro para consumir um produto de consumo ou confirmar um produto que não é de consumo.

Em AndroidPublisherHelper, adicione os seguintes métodos para chamar purchases.products:consume ou purchases.products:acknowledge na 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.
   }
 }

Em NotificationMessageReceiver, consuma a compra do produto consumível ou confirme a compra do produto não consumível depois de conceder o direito no servidor de back-end.

 @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);
  ......

 }

A confirmação é necessária, já que notifica o Google Play de que o usuário tem direito à compra. Você precisa confirmar a compra imediatamente após conceder o direito.

Muito bem! Você integrou as notificações do desenvolvedor em tempo real, permitindo o processamento confiável de compras, conforme demonstrado neste codelab. Agora, para garantir que tudo esteja funcionando perfeitamente, vamos conhecer o Google Play Billing Lab, uma ferramenta fácil de usar criada para ajudar a testar sua integração com o Google Play Faturamento.

8. Teste com o Play Billing Lab

Para lançar com confiança, teste sua integração durante o desenvolvimento. O Play Billing Lab é um app Android sem custo financeiro que ajuda os desenvolvedores a testar a integração com o sistema de faturamento do Google Play. Ele oferece uma maneira fácil e conveniente para os desenvolvedores testarem recursos do Google Play Faturamento, agilizarem as integrações e fazerem lançamentos com mais confiança.

O Play Billing Lab oferece vários recursos de teste para ajudar a testar diferentes cenários, incluindo:

Mude o país do Google Play no Play Billing Lab e aplique as configurações ao seu teste. Isso permite testar experiências personalizadas do usuário em diferentes países/regiões, independente de onde o testador está realizando os testes físicos.
Testar testes ou promoções iniciais repetidamente com a mesma conta
Teste mudanças de preço na assinatura sem afetar outros assinantes ativos
Simule o código de resposta da Biblioteca Play Faturamento para testar em vários cenários de erro.
Acelere as renovações de assinatura para agilizar os testes
Teste com formas de pagamento reais para ignorar determinados indicadores de risco do fluxo de compra

Estamos sempre adicionando novos recursos de teste ao app Play Billing Lab. Baixe e instale o Play Billing Lab na Google Play Store ou confira Teste sua integração para mais informações sobre como testar com o Play Billing Lab.

Usar o Play Billing Lab para testar BillingResponseCode

É um desafio comum testar todos os fluxos de BillingResponseCode ao integrar o app à Biblioteca Play Faturamento, porque você não tem muito controle sobre a comunicação entre a Google Play Store e o back-end do Google Play. Com o recurso Simulador de respostas do app Google Play Billing Lab, é possível configurar respostas de código de erro para a Biblioteca Play Faturamento e testar vários cenários de erro complexos.

Por exemplo, você implementou a lógica no app para consumir a compra depois que ela é detectada como concluída. Você quer testar o cenário em que o app não consumiu a compra devido a uma falha na rede, e o receptor RTDN no servidor de back-end recebe a mensagem e processa a compra corretamente. Você pode usar o simulador de respostas para simular o cenário dos seus testes. A seguir, você vai aprender a testar com o simulador de respostas do Play Billing Lab.

Testar com o simulador de respostas

Ao testar com o simulador de respostas, o app vai se comunicar com o Play Billing Lab para receber o código de resposta configurado no simulador de respostas do Play Billing Lab.

Ativar o teste de substituições de faturamento para a Biblioteca Play Faturamento

Para ativar a comunicação entre o Simulador de respostas e seu app, primeiro ative o teste de substituições de faturamento para a Biblioteca Play Faturamento no app. Para isso, adicione as seguintes tags de metadados ao arquivo AndroidManifest.xml do 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>

Crie seu app com o arquivo AndroidManifest.xml atualizado. Agora, seu app está pronto para o simulador de respostas do Play Billing Lab.

Ao implantar o app no ambiente de produção após o teste, use um arquivo AndroidManifest.xml separado que não inclua essas tags de metadados ou remova-as do arquivo AndroidManifest.xml.

Simular erros da Biblioteca Play Faturamento

Para testar com erros simulados da Biblioteca Play Faturamento, primeiro configure o código de resposta no app Play Billing Lab e depois faça o teste no seu app.

Configurar um código de resposta

Faça login no app Play Billing Lab com uma conta de testador de licença do seu app. A imagem a seguir mostra o painel do Play Billing Lab,incluindo o card Simulador de respostas.

Play Billing Lab Dashboard com o simulador de respostas

Clique em Gerenciar no card "Simulador de respostas" para acessar a tela do simulador.
Quando solicitado, permita as notificações do Play Billing Lab para conferir o status da conexão do seu app.
Ative a opção "Simular resposta da Biblioteca Play Faturamento", se ela ainda não estiver ativada.

Selecione um código de resposta para as APIs da Biblioteca Play Faturamento que você quer testar. Para simular o erro na compra de consumo, selecione um código de erro para a API consumeAsync. Suas seleções são salvas automaticamente. Agora o simulador de respostas está pronto para enviar os códigos de resposta selecionados ao seu app.

Testar o app

Agora, você pode testar o app para verificar se tudo funciona como esperado no cenário de erro configurado. Abra o app e acione o método da API Biblioteca Play Faturamento. Se o app fizer a chamada consumeAsync para consumir a compra, ele vai receber o código de erro conforme você acabou de configurar. Você pode verificar se o app está funcionando corretamente com base no código de erro e se o servidor de back-end está processando a compra corretamente.

Depois de concluir o teste, desative a opção "Simular resposta da Biblioteca Play Faturamento" para interromper a simulação.

Saiba mais sobre como testar com o Google Play Billing Lab ou acesse a Central de Ajuda para saber mais sobre como testar o faturamento em apps com testadores de licença.

9. Parabéns!

Você concluiu este codelab e agora está pronto para otimizar estrategicamente a monetização do app, melhorar a experiência do usuário e aumentar a satisfação, as conversões de compra e a rotatividade de assinantes.

Ao usar as Notificações do desenvolvedor em tempo real e o app complementar Play Billing Lab, você pode resolver de forma proativa os eventos do ciclo de vida de compras para compras únicas e assinaturas.

Com essas ferramentas, você pode implementar estratégias de recuperação envolventes, resolver rapidamente desafios de integração e, por fim, melhorar a experiência do usuário e as fontes de receita para lançar seu app ou jogo com confiança.

Ao concluir este codelab, você terá as habilidades necessárias para gerenciar toda a jornada de compra e testar rigorosamente sua implementação com o Play Billing Lab, garantindo uma experiência do usuário perfeita e maximizando seu potencial de monetização no Google Play.