Esta página foi traduzida pela API Cloud Translation.

Maximizar a integração do Google Play Faturamento

1. Visão geral

Otimize seus fluxos 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 orienta você a configurar, testar e implementar o processamento de compras confiável, permitindo que você atenda às 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, na sigla em inglês) e o Laboratório de Faturamento do Google Play para assinaturas e produtos únicos em apps e jogos. Você vai aprender a reduzir a taxa de cancelamento de assinaturas, se proteger contra fraudes e abusos, testar casos extremos, simular, reproduzir e resolver possíveis problemas e testar ofertas e mudanças de preço sem afetar os usuários.

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

Pré-requisitos

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

O que você vai aprender

Como gerenciar corretamente os ciclos de compra para otimizar o crescimento com técnicas para melhorar as conversões de compra e a retenção de clientes
Como configurar as Notificações do desenvolvedor em tempo real (RTDN, na sigla em inglês) usando o Google Cloud Pub/Sub, que podem ser usadas para implementar campanhas de recuperação e outras estratégias de gerenciamento de 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 para reduzir reembolsos não intencionais ou riscos de fraude e abuso
Como testar a 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 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 app Android
Testadores de licença registrados para o app no Play Console do desenvolvedor
Laboratório do Play Faturamento instalado no 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 disposição para comprar e reduzir a perda de clientes.

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 o 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 apropriado 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 como uma ferramenta de acompanhamento de desempenho em tempo real e para ativar estratégias de recuperação de assinantes.

Por exemplo: digamos que o usuário acabou de comprar um novo item ou deixou de pagar, então 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 com isso, aumentando o engajamento do 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.

Os RTDNs também são uma ótima maneira de adicionar mais controles do lado do servidor para ajudar a gerenciar compras, mesmo quando o cliente do usuário tiver problemas. Digamos que um usuário fez uma compra e recebeu a confirmação do Google, mas o dispositivo perdeu a conectividade de rede antes que o app recebesse a 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 confiável de compra.

Saiba mais sobre todos os tipos de RTDNs compatíveis neste link. Cada tipo de RTDN indica um status de compra diferente. É crucial implementar os mecanismos de processamento correspondentes para garantir o processamento adequado conforme necessário nos 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 um usuário conclui uma compra no seu app. Em seguida, vamos mostrar como configurar RTDNs para o app.

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

As notificações do desenvolvedor em tempo real (RTDN, na sigla em inglês) usam o Google Cloud Pub/Sub para que você reaja imediatamente às mudanças de 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 as Notificações do desenvolvedor em tempo real, é preciso configurar o Cloud Pub/Sub usando seu próprio projeto do Google Cloud Platform (GCP) e, em seguida, ativar 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.

Crie 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 de push ou de pull. Neste codelab, vamos trabalhar com uma assinatura de pull que exige que seu servidor de back-end seguro inicie solicitações ao servidor do Cloud Pub/Sub para extrair mensagens.

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

Conceder direitos de publicação no tópico

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

Abra o Console do Google Cloud.
Selecione seu projeto e pesquise "Pub/Sub" na barra de pesquisa. Em seguida, acesse a página de configuração do Pub/Sub.
Encontre 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 Editor do Pub/Sub.
Clique em Salvar para concluir a configuração do tópico.

Ativar as RTDNs 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. Você pode melhorar a confiabilidade das compras com mensagens personalizadas e evitar fraudes e abusos para melhorar 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 sincronizar automaticamente com o status real dos direitos do usuário, superando as limitações do lado do cliente e permitindo que você reaja de forma instantânea e adequada.

Como ativar as Notificações do desenvolvedor em tempo real no 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. Realizar uma publicação de teste 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, receberá a mensagem de teste. Para uma assinatura de 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 de push, confira se a mensagem de teste é entregue ao endpoint de push. Um código de resposta bem-sucedido vai 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 de produtos únicos.
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, oferecendo as ferramentas para lidar com desafios comuns, como a rotatividade 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 ao usuário no app. Por exemplo, quando um usuário finaliza uma compra com um pagamento no app, o conteúdo precisa ser entregue à conta dele o mais rápido possível.

Para isso, a conclusão da compra precisa ser detectada e processada em tempo hábil. A Biblioteca Play Faturamento oferece várias maneiras de detectar as compras no app. Após a detecção de 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 devido a vários motivos. Por exemplo, um usuário pode fazer uma compra e receber a confirmação do Google, mas o dispositivo perde a conectividade de rede antes que o dispositivo e o app recebam uma notificação pela interface da Biblioteca Play Faturamento. O RTDN oferece controles adicionais no servidor para ajudar a gerenciar compras, mesmo quando o cliente do usuário tiver problemas. As RTDNs garantem notificações independentes para seu servidor quando o status da compra muda, permitindo que você reconheça as mudanças quase imediatamente por um segundo caminho, independentemente dos 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 próximas seções, vamos adicionar ao assinante para verificar a compra, conceder o direito ao usuário correto e confirmar/consumir a compra no servidor. Neste codelab, usamos 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 código de exemplo de um NotificationReceiver para que seu servidor de back-end seguro processe 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ção 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 de RTDN no seu servidor de back-end.

5. Anexar identificadores do usuário no fluxo de compra do app

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

Confira a seguir os exemplos de códigos 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ê vai ver na próxima seção, o identificador do 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 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 seu 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 de purchaseToken da compra atual não corresponde a nenhum valor de 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 confirmar 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 abaixo 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 método abaixo para buscar a compra do produto 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 processamentos duplicados.

 @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 pontos de endpoint 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 métodos abaixo 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 de produtos consumíveis ou confirme a compra de produtos não consumíveis 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 de compras confiável, conforme demonstrado neste codelab. Agora, para garantir que tudo esteja funcionando perfeitamente, vamos conhecer o Play Billing Lab, uma ferramenta fácil de usar projetada para ajudar a testar sua integração com o Play Faturamento.

8. Testar 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 de testar os recursos do Play Billing, integrar mais rapidamente e lançar 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 teste. Isso permite testar experiências personalizadas do usuário em diferentes países/regiões, independente do local em que o testador está realizando o teste físico.
Testar ofertas de teste ou de promoção inicial repetidamente com a mesma conta
Testar mudanças de preço da 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 acelerar os testes.
Testar com formas de pagamento reais para ignorar alguns indicadores de risco do fluxo de compra

Estamos sempre adicionando novos recursos de teste ao app Play Billing Lab. Você pode fazer o download e instalar o Play Billing Lab na Play Store ou conferir Testar sua integração para mais informações sobre testes com o Play Billing Lab.

Usar o Play Billing Lab para testar o BillingResponseCode

É um desafio comum testar todos os fluxos de BillingResponseCode ao integrar seu app à biblioteca Play Faturamento, porque você não tem muito controle sobre a comunicação entre a Play Store e o back-end do Google Play. O recurso Simulador de resposta no app Play Faturamento Lab permite 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 ele detecta a compra bem-sucedida. Você quer testar o cenário em que o app não conseguiu consumir a compra devido a uma falha na rede e o receptor de RTDN no servidor de back-end recebe a mensagem e processa a compra corretamente. Você pode usar o Response Simulator para simular o cenário para seus testes. Confira a seguir as etapas para testar com o Simulador de Resposta do Play Billing Lab.

Testar com o simulador de resposta

Ao testar com o Simulador de resposta, o app vai se comunicar com o Play Billing Lab para receber o código de resposta configurado no Simulador de resposta 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 resposta e o app, primeiro ative o teste de substituições de faturamento para a Biblioteca Play Faturamento no app. Para fazer 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 resposta do Laboratório do Play Faturamento.

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 essas tags 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 Play Billing Lab e depois realize o teste no seu app.

Configurar um código de resposta

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

Painel do Play Billing Lab com simulador de resposta

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

Selecione um código de resposta para as APIs da Biblioteca Play Billing que você quer testar. Para simular o erro da 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 conforme o esperado no cenário de erro configurado. Abra o app e acione o método da API Play Billing Library. Se o app fizer a chamada consumeAsync para consumir a compra, ele vai receber o código de erro que 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 os testes, desative a chave "Simular resposta da Biblioteca Play Faturamento" para interromper a simulação.

Saiba mais sobre os testes com o Laboratório de faturamento do Google Play ou acesse a Central de Ajuda para saber mais sobre como testar o faturamento em apps com os Testadores de licença.

9. Parabéns!

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

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

Com essas ferramentas, você pode implementar estratégias de recuperação eficazes, resolver rapidamente os desafios de integração e, por fim, melhorar a experiência do usuário e os fluxos 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 sua implementação de forma rigorosa com o Play Billing Lab, garantindo uma experiência do usuário perfeita e maximizando seu potencial de monetização no Google Play.