SDK Engage Health and Fitness: instruções técnicas de integração de terceiros

O Google está criando uma plataforma no dispositivo que organiza os apps dos usuários por categoria e possibilita uma nova experiência imersiva para consumo e descoberta de conteúdo personalizado de apps. Essa experiência em tela cheia oferece aos parceiros dos desenvolvedores uma oportunidade de mostrar o melhor conteúdo avançado em um canal dedicado fora do app. Este guia contém instruções para que os parceiros dos desenvolvedores integrem conteúdo de saúde e fitness, usando o SDK Engage para preencher essa nova área.

Detalhe de integração

Terminologia

Essa integração inclui os três tipos de cluster a seguir: recomendação, destaque e continuação.

• Os clusters de recomendação mostram sugestões personalizadas de saúde e condicionamento físico de um parceiro de desenvolvimento. Essas recomendações podem ser personalizadas para o usuário ou generalizadas (por exemplo, condicionamento físico e saúde em alta). Use-as para mostrar artigos ou pessoas relacionadas à saúde e condicionamento ao condicionamento físico.

  • Um cluster de recomendação pode ser composto por ArticleEntity, PersonEntity ou EventEntity, mas não uma combinação de diferentes tipos de entidade.

  As recomendações têm a seguinte estrutura:

  • Cluster de recomendação: uma visualização de interface que contém um grupo de recomendações do mesmo parceiro do desenvolvedor.

  • Entidade: um objeto que representa um único item em um cluster. Essa integração oferece algumas entidades que seriam exibidas usando o cluster de recomendação:

    • ArticleEntity: representa uma recomendação para conteúdo baseado em texto relacionado à saúde e condicionamento físico. Ele pode ser usado para artigos, postagens de blog, conteúdo de marketing, snippets de notícias etc.

      

    • PersonEntity: representa uma pessoa. As recomendações podem ser para destacar um treinador ou qualquer pessoa relacionada à saúde e ao condicionamento físico, etc.

      

    • EventEntity: representa um evento que vai acontecer no futuro. O horário de início do evento é uma informação importante que precisa ser transmitida aos usuários. Essa entidade pode ser usada para mostrar eventos como acampamento de doação de sangue, sessões de treinamento, academia ou aulas de ioga, etc. relacionados à saúde e ao condicionamento físico.

      

• O cluster de continuação mostra conteúdo com que os usuários interagiram recentemente de vários parceiros de desenvolvimento em um único grupo de interfaces. Cada parceiro de desenvolvedor poderá transmitir no máximo 10 entidades no cluster de continuação.

  O conteúdo de continuação pode ter a seguinte estrutura:

  • ArticleEntity: representa uma recomendação para conteúdo baseado em texto relacionado à saúde e condicionamento físico. Essa entidade pode ser usada para representar artigos de notícias inacabados ou outro conteúdo que o usuário queira continuar consumindo de onde parou. Por exemplo: snippet de notícias, snippet de postagem de blog sobre tópicos relacionados a saúde ou condicionamento físico.

    

  • EventReservationEntity: representa a reserva de um evento e ajuda os usuários a acompanhar as reservas de eventos de saúde e fitness atuais ou futuras. Por exemplo, sessões de treinamento

    

• O cluster de destaque mostra uma seleção de entidades de vários parceiros de desenvolvimento em um único grupo de interfaces. Há um único cluster de destaque, exibido perto da parte de cima da interface, com um posicionamento prioritário acima de todos os clusters de recomendação. Cada parceiro de desenvolvedor pode transmitir até 10 entidades no cluster de destaque.

  • GenericFeaturedEntity: GenericFeaturedEntity difere do item de recomendação, porque o item em destaque precisa ser usado para um único conteúdo principal dos desenvolvedores e representar o conteúdo mais importante que será interessante e relevante para os usuários.

    

Pré-trabalho

Nível mínimo da API: 19

Adicione a biblioteca com.google.android.engage:engage-core ao app:

dependencies {
    // Make sure you also include that repository in your project's build.gradle file.
    implementation 'com.google.android.engage:engage-core:1.5.2'
}

Resumo

O design é baseado na implementação de um serviço vinculado.

Os dados que um cliente pode publicar estão sujeitos aos seguintes limites para diferentes tipos de clusters:

Etapa 1: fornecer dados da entidade

O SDK definiu entidades diferentes para representar cada tipo de item. Oferecemos suporte às seguintes entidades na categoria "Saúde e fitness":

1. GenericFeaturedEntity
2. ArticleEntity
3. PersonEntity
4. EventEntity
5. EventReservationEntity

As tabelas abaixo descrevem os atributos e os requisitos disponíveis para cada tipo.

GenericFeaturedEntity

ArticleEntity

PersonEntity

EventEntity

EventReservationEntity

Especificações da imagem

As especificações necessárias para recursos de imagem estão listadas nesta tabela:

As imagens precisam ser hospedadas em CDNs públicas para que possam ser acessadas pelo Google.

Formatos de arquivo

PNG, JPG, GIF estático, WebP

Tamanho máximo do arquivo

5.120 KB

Recomendações adicionais

• Área de segurança da imagem: posicione o conteúdo importante no centro da imagem, ocupando 80% do espaço.
• Use um plano de fundo transparente para que a imagem possa ser exibida corretamente nas configurações do tema claro e escuro.

Categoria do conteúdo

A categoria de conteúdo permite que os apps publiquem conteúdo pertencente a várias categorias. Isso mapeia o conteúdo com algumas das categorias predefinidas, a saber:

• TYPE_EDUCATION
• TYPE_SPORTS
• TYPE_MOVIES_AND_TV_SHOWS
• TYPE_BOOKS
• TYPE_AUDIOBOOKS
• TYPE_MUSIC
• TYPE_DIGITAL_GAMES
• TYPE_TRAVEL_AND_LOCAL
• TYPE_HOME_AND_AUTO
• TYPE_BUSINESS
• TYPE_NEWS
• TYPE_FOOD_AND_DRINK
• TYPE_SHOPPING
• TYPE_HEALTH_AND_FITENESS
• TYPE_MEDICAL
• TYPE_PARENTING
• TYPE_DATING

As imagens precisam ser hospedadas em CDNs públicas para que possam ser acessadas pelo Google.

Diretrizes para usar as categorias de conteúdo

1. Algumas entidades, como ArticleEntity e GenericFeaturedEntity, estão qualificadas para usar qualquer uma das categorias de conteúdo. Para outras entidades, como EventEntity, EventReservationEntity e PersonEntity, apenas um subconjunto dessas categorias é qualificado. Verifique a lista de categorias qualificadas para um tipo de entidade antes de preencher a lista.

2. Use o tipo de entidade específico para algumas categorias de conteúdo em uma combinação das entidades genéricas e da ContentCategory:

   • TYPE_FILTERS_AND_TV_SHOWS: confira as entidades no Guia de integração do relógio antes de usar entidades genéricas.
   • TYPE_BOOKS: confira a EbookEntity antes de usar as entidades genéricas.
   • TYPE_AUDIOBOOKS: confira AudiobookEntity antes de usar as entidades genéricas.
   • TYPE_SHOPPING: confira ShoppingEntity antes de usar as entidades genéricas.
   • TYPE_FOOD_AND_DRINK: confira as entidades do guia de integração de alimentos antes de usar as entidades genéricas.

3. O campo ContentCategory é opcional e precisa ser deixado em branco se o conteúdo não pertencer a nenhuma das categorias mencionadas anteriormente.

4. Caso várias categorias de conteúdo sejam fornecidas, faça isso na ordem de relevância para o conteúdo, com a categoria mais relevante colocada primeiro na lista.

Etapa 2: fornecer dados do cluster

É recomendável executar o job de publicação de conteúdo em segundo plano (por exemplo, usando o WorkManager) e o programar com frequência ou por evento (por exemplo, toda vez que o usuário abrir o app ou adicionar algo ao carrinho).

AppEngagePublishClient é responsável pela publicação de clusters.

Estas são as APIs para publicar clusters no cliente:

• isServiceAvailable
• publishRecommendationClusters
• publishFeaturedCluster
• publishContinuationCluster
• publishUserAccountManagementRequest
• updatePublishStatus
• deleteRecommendationsClusters
• deleteFeaturedCluster
• deleteContinuationCluster
• deleteUserManagementCluster
• deleteClusters

isServiceAvailable

Essa API é usada para conferir se o serviço está disponível para integração e se o conteúdo pode ser apresentado no dispositivo.

client.isServiceAvailable.addOnCompleteListener { task ->
    if (task.isSuccessful) {
        // Handle IPC call success
        if(task.result) {
          // Service is available on the device, proceed with content publish
          // calls.
        } else {
          // Service is not available, no further action is needed.
        }
    } else {
      // The IPC call itself fails, proceed with error handling logic here,
      // such as retry.
    }
}

client.isServiceAvailable().addOnCompleteListener(task - > {
    if (task.isSuccessful()) {
        // Handle success
        if(task.getResult()) {
          // Service is available on the device, proceed with content publish
          // calls.
        } else {
          // Service is not available, no further action is needed.
        }
    } else {
      // The IPC call itself fails, proceed with error handling logic here,
      // such as retry.
    }
});

publishRecommendationClusters

Essa API é usada para publicar uma lista de objetos RecommendationCluster.

client.publishRecommendationClusters(
      PublishRecommendationClustersRequest.Builder()
        .addRecommendationCluster(
          RecommendationCluster.Builder()
            .addEntity(entity1)
            .addEntity(entity2)
            .setTitle("Top Picks For You")
            .build()
        )
        .build()
    )

client.publishRecommendationClusters(
            new PublishRecommendationClustersRequest.Builder()
                .addRecommendationCluster(
                    new RecommendationCluster.Builder()
                        .addEntity(entity1)
                        .addEntity(entity2)
                        .setTitle("Top Picks For You")
                        .build())
                .build());

Quando o serviço recebe a solicitação, as ações abaixo ocorrem em uma transação:

• Os dados do RecommendationCluster do parceiro do desenvolvedor são removidos.
• Os dados da solicitação são analisados e armazenados no cluster de recomendação atualizado.

Em caso de erro, o pedido inteiro é rejeitado e o estado atual é mantido.

publishFeaturedCluster

Essa API é usada para publicar uma lista de objetos FeaturedCluster.

client.publishFeaturedCluster(
    PublishFeaturedClusterRequest.Builder()
      .setFeaturedCluster(
        FeaturedCluster.Builder()
          .addEntity(entity1)
          .addEntity(entity2)
          .build())
      .build())

client.publishFeaturedCluster(
            new PublishFeaturedClustersRequest.Builder()
                .addFeaturedCluster(
                    new FeaturedCluster.Builder()
                        .addEntity(entity1)
                        .addEntity(entity2)
                        .build())
                .build());

Quando o serviço recebe a solicitação, as ações abaixo ocorrem em uma transação:

• Os dados do FeaturedCluster do parceiro do desenvolvedor são removidos.
• Os dados da solicitação são analisados e armazenados no cluster de destaque atualizado.

Em caso de erro, a solicitação inteira é rejeitada e o estado atual é mantido.

publishContinuationCluster

Essa API é usada para publicar um objeto ContinuationCluster.

client.publishContinuationCluster(
    PublishContinuationClusterRequest.Builder()
      .setContinuationCluster(
        ContinuationCluster.Builder()
          .addEntity(entity1)
          .addEntity(entity2)
          .build())
      .build())

client.publishContinuationCluster(
            new PublishContinuationClusterRequest.Builder()
                .setContinuationCluster(
                    new ContinuationCluster.Builder()
                        .addEntity(entity1)
                        .addEntity(entity2)
                        .build())
                .build());

Quando o serviço recebe a solicitação, as ações abaixo ocorrem em uma transação:

• Os dados do ContinuationCluster do parceiro do desenvolvedor são removidos.
• Os dados da solicitação são analisados e armazenados no cluster de continuação atualizado.

Em caso de erro, a solicitação inteira é rejeitada e o estado atual é mantido.

publishUserAccountManagementRequest

Essa API é usada para publicar um card de login. A ação de login direciona os usuários à página de login do app para que ele possa publicar ou oferecer conteúdo mais personalizado.

Os metadados abaixo fazem parte do card de login:

var SIGN_IN_CARD_ENTITY =
      SignInCardEntity.Builder()
          .addPosterImage(
              Image.Builder()
                  .setImageUri(Uri.parse("http://www.x.com/image.png"))
                  .setImageHeightInPixel(500)
                  .setImageWidthInPixel(500)
                  .build())
          .setActionText("Sign In")
          .setActionUri(Uri.parse("http://xx.com/signin"))
          .build()

client.publishUserAccountManagementRequest(
            PublishUserAccountManagementRequest.Builder()
                .setSignInCardEntity(SIGN_IN_CARD_ENTITY)
                .build());

SignInCardEntity SIGN_IN_CARD_ENTITY =
      new SignInCardEntity.Builder()
          .addPosterImage(
              new Image.Builder()
                  .setImageUri(Uri.parse("http://www.x.com/image.png"))
                  .setImageHeightInPixel(500)
                  .setImageWidthInPixel(500)
                  .build())
          .setActionText("Sign In")
          .setActionUri(Uri.parse("http://xx.com/signin"))
          .build();

client.publishUserAccountManagementRequest(
            new PublishUserAccountManagementRequest.Builder()
                .setSignInCardEntity(SIGN_IN_CARD_ENTITY)
                .build());

Quando o serviço recebe o pedido, as seguintes ações ocorrem em uma transação:

• Os dados do UserAccountManagementCluster do parceiro do desenvolvedor são removidos.
• Os dados do pedido são analisados e armazenados no cluster UserAccountManagementCluster atualizado.

Em caso de erro, a solicitação inteira é rejeitada e o estado atual é mantido.

updatePublishStatus

Se, por qualquer motivo interno, nenhum dos clusters for publicado, é altamente recomendável atualizar o status de publicação usando a API updatePublishStatus. Isso é importante pelos seguintes motivos:

• Informar o status em todos os casos possíveis, mesmo quando o conteúdo é publicado (STATUS == PUBLISHED), é fundamental para preencher painéis que usam o status explícito para transmitir informações de integridade e outras métricas da integração.
• Se nenhum conteúdo for publicado, mas o status da integração não estiver corrompido (STATUS == NOT_PUBLISHED), o Google poderá evitar o acionamento de alertas nos painéis de integridade do app. Isso confirma que o conteúdo não foi publicado devido a uma situação esperada pelo provedor.
• Ajuda os desenvolvedores a oferecer insights sobre quando os dados foram publicados ou não.
• O Google pode usar os códigos de status para incentivar o usuário a executar ações específicas no app, como acessar o conteúdo ou resolver o problema.

Lista de códigos de status de publicação que podem ser usados:

// Content is published
AppEngagePublishStatusCode.PUBLISHED,

// Content is not published as user is not signed in
AppEngagePublishStatusCode.NOT_PUBLISHED_REQUIRES_SIGN_IN,

// Content is not published as user is not subscribed
AppEngagePublishStatusCode.NOT_PUBLISHED_REQUIRES_SUBSCRIPTION,

// Content is not published as user location is ineligible
AppEngagePublishStatusCode.NOT_PUBLISHED_INELIGIBLE_LOCATION,

// Content is not published as there is no eligible content
AppEngagePublishStatusCode.NOT_PUBLISHED_NO_ELIGIBLE_CONTENT,

// Content is not published as the feature is disabled by the client
// Available in v1.3.1
AppEngagePublishStatusCode.NOT_PUBLISHED_FEATURE_DISABLED_BY_CLIENT,

// Content is not published as the feature due to a client error
// Available in v1.3.1
AppEngagePublishStatusCode.NOT_PUBLISHED_CLIENT_ERROR,

// Content is not published as the feature due to a service error
// Available in v1.3.1
AppEngagePublishStatusCode.NOT_PUBLISHED_SERVICE_ERROR,

// Content is not published due to some other reason
// Reach out to engage-developers@ before using this enum.
AppEngagePublishStatusCode.NOT_PUBLISHED_OTHER

Se o conteúdo não for publicado porque o usuário não estava conectado, o Google recomenda publicar o card de login. Se, por algum motivo, os provedores não conseguirem publicar o card de login, recomendamos chamar a API updatePublishStatus usando o código de status NOT_PUBLISHED_REQUIRES_SIGN_IN.

client.updatePublishStatus(
   PublishStatusRequest.Builder()
     .setStatusCode(AppEngagePublishStatusCode.NOT_PUBLISHED_REQUIRES_SIGN_IN)
     .build())

client.updatePublishStatus(
    new PublishStatusRequest.Builder()
        .setStatusCode(AppEngagePublishStatusCode.NOT_PUBLISHED_REQUIRES_SIGN_IN)
        .build());

deleteRecommendationClusters

Essa API é usada para excluir o conteúdo dos clusters de recomendação.

client.deleteRecommendationClusters()

client.deleteRecommendationClusters();

Quando o serviço recebe o pedido, ele remove os dados atuais dos clusters de recomendação. Em caso de erro, o pedido inteiro é rejeitado e o estado atual é mantido.

deleteFeaturedCluster

Essa API é usada para excluir o conteúdo do cluster de destaque.

client.deleteFeaturedCluster()

client.deleteFeaturedCluster();

Quando o serviço recebe o pedido, ele remove os dados atuais do cluster de destaque. Em caso de erro, a solicitação inteira é rejeitada e o estado existente é mantido.

deleteContinuationCluster

Essa API é usada para excluir o conteúdo do cluster de continuação.

client.deleteContinuationCluster()

client.deleteContinuationCluster();

Quando o serviço recebe o pedido, ele remove os dados atuais do cluster de continuação. Em caso de erro, o pedido inteiro é rejeitado e o estado atual é mantido.

deleteUserManagementCluster

Essa API é usada para excluir o conteúdo do cluster UserAccountManagement.

client.deleteUserManagementCluster()

client.deleteUserManagementCluster();

Quando o serviço recebe o pedido, ele remove os dados atuais do cluster UserAccountManagement. Em caso de erro, a solicitação inteira é rejeitada e o estado atual é mantido.

deleteClusters

Essa API é usada para excluir o conteúdo de determinado tipo de cluster.

client.deleteClusters(
    DeleteClustersRequest.Builder()
      .addClusterType(ClusterType.TYPE_CONTINUATION)
      .addClusterType(ClusterType.TYPE_FEATURED)
      .addClusterType(ClusterType.TYPE_RECOMMENDATION)
      .build())

client.deleteClusters(
            new DeleteClustersRequest.Builder()
                .addClusterType(ClusterType.TYPE_CONTINUATION)
                .addClusterType(ClusterType.TYPE_FEATURED)
                .addClusterType(ClusterType.TYPE_RECOMMENDATION)
                .build());

Quando o serviço recebe a solicitação, ele remove os dados de todos os clusters que correspondem aos tipos especificados. Os clientes podem transmitir um ou vários tipos de clusters. Em caso de erro, a solicitação inteira é rejeitada e o estado existente é mantido.

Tratamento de erros

É recomendável detectar o resultado da tarefa nas APIs de publicação. Com isso, uma ação de acompanhamento pode ser realizada para extrair e reenviar uma tarefa bem-sucedida.

client.publishRecommendationClusters(
        PublishRecommendationClustersRequest.Builder()
          .addRecommendationCluster(..)
          .build())
      .addOnCompleteListener { task ->
        if (task.isSuccessful) {
          // do something
        } else {
          val exception = task.exception
          if (exception is AppEngageException) {
            @AppEngageErrorCode val errorCode = exception.errorCode
            if (errorCode == AppEngageErrorCode.SERVICE_NOT_FOUND) {
              // do something
            }
          }
        }
      }

client.publishRecommendationClusters(
              new PublishRecommendationClustersRequest.Builder()
                  .addRecommendationCluster(...)
                  .build())
          .addOnCompleteListener(
              task -> {
                if (task.isSuccessful()) {
                  // do something
                } else {
                  Exception exception = task.getException();
                  if (exception instanceof AppEngageException) {
                    @AppEngageErrorCode
                    int errorCode = ((AppEngageException) exception).getErrorCode();
                    if (errorCode == AppEngageErrorCode.SERVICE_NOT_FOUND) {
                      // do something
                    }
                  }
                }
              });

O erro é retornado como AppEngageException e a causa é incluída como um código de erro.

Etapa 3: processar intents de transmissão

Além de fazer chamadas de API de conteúdo de publicação usando um job, também é necessário configurar um BroadcastReceiver para receber a solicitação de publicação de conteúdo.

O objetivo principal das intents de transmissão é reativar o app e forçar a sincronização de dados. As intents de transmissão não são projetadas para envio muito frequente. Elas só são acionadas quando o serviço do Engage determina que o conteúdo pode estar desatualizado (por exemplo, é de uma semana atrás). Dessa forma, há mais confiança de que o usuário poderá ter uma nova experiência de conteúdo, mesmo que o aplicativo não tenha sido executado por um longo período.

O BroadcastReceiver precisa ser configurado de duas maneiras:

• Registre dinamicamente uma instância da classe BroadcastReceiver usando Context.registerReceiver(). Isso permite a comunicação de aplicativos que ainda estão ativos na memória.

class AppEngageBroadcastReceiver : BroadcastReceiver(){
  // Trigger recommendation cluster publish when PUBLISH_RECOMMENDATION broadcast
  // is received
  // Trigger featured cluster publish when PUBLISH_FEATURED broadcast is received
  // Trigger continuation cluster publish when PUBLISH_CONTINUATION broadcast is
  // received
}

fun registerBroadcastReceivers(context: Context){
  var  context = context
  context = context.applicationContext

// Register Recommendation Cluster Publish Intent
  context.registerReceiver(AppEngageBroadcastReceiver(),
                           IntentFilter(Intents.ACTION_PUBLISH_RECOMMENDATION))

// Register Featured Cluster Publish Intent
  context.registerReceiver(AppEngageBroadcastReceiver(),
                           IntentFilter(Intents.ACTION_PUBLISH_FEATURED))

// Register Continuation Cluster Publish Intent
  context.registerReceiver(AppEngageBroadcastReceiver(),
                           IntentFilter(Intents.ACTION_PUBLISH_CONTINUATION))
}

class AppEngageBroadcastReceiver extends BroadcastReceiver {
// Trigger recommendation cluster publish when PUBLISH_RECOMMENDATION broadcast
// is received

// Trigger featured cluster publish when PUBLISH_FEATURED broadcast is received

// Trigger continuation cluster publish when PUBLISH_CONTINUATION broadcast is
// received
}

public static void registerBroadcastReceivers(Context context) {

context = context.getApplicationContext();

// Register Recommendation Cluster Publish Intent
context.registerReceiver(new AppEngageBroadcastReceiver(),
new IntentFilter(com.google.android.engage.service.Intents.ACTION_PUBLISH_RECOMMENDATION));

// Register Featured Cluster Publish Intent
context.registerReceiver(new AppEngageBroadcastReceiver(),
new IntentFilter(com.google.android.engage.service.Intents.ACTION_PUBLISH_FEATURED));

// Register Continuation Cluster Publish Intent
context.registerReceiver(new AppEngageBroadcastReceiver(),
new IntentFilter(com.google.android.engage.service.Intents.ACTION_PUBLISH_CONTINUATION));

}

• Declare estaticamente uma implementação com a tag <receiver> no arquivo AndroidManifest.xml. Isso permite que o aplicativo receba intents de transmissão quando não está em execução e também permite que ele publique o conteúdo.

<application>
   <receiver
      android:name=".AppEngageBroadcastReceiver"
      android:exported="true"
      android:enabled="true">
      <intent-filter>
         <action android:name="com.google.android.engage.action.PUBLISH_RECOMMENDATION" />
      </intent-filter>
      <intent-filter>
         <action android:name="com.google.android.engage.action.PUBLISH_FEATURED" />
      </intent-filter>
      <intent-filter>
         <action android:name="com.google.android.engage.action.PUBLISH_CONTINUATION" />
      </intent-filter>
   </receiver>
</application>

As intents abaixo são enviadas pelo serviço:

• com.google.android.engage.action.PUBLISH_RECOMMENDATION É recomendável iniciar uma chamada publishRecommendationClusters ao receber essa intent.
• com.google.android.engage.action.PUBLISH_FEATURED É recomendável iniciar uma chamada publishFeaturedCluster ao receber essa intent.
• com.google.android.engage.action.PUBLISH_CONTINUATION É recomendável iniciar uma chamada publishContinuationCluster ao receber essa intent.

Fluxo de trabalho de integração

Para acessar um guia explicativo sobre como verificar a integração após a conclusão, consulte Fluxo de trabalho de integração de desenvolvedor.

Perguntas frequentes

Consulte as Perguntas frequentes sobre o SDK Engage para acessar as perguntas frequentes.

Contato

Entre em contato com engagement-developers@google.com se tiver perguntas durante o processo de integração.

Próximas etapas

Depois de concluir essa integração, as próximas etapas serão as seguintes:

• Envie um e-mail para engage-developers@google.com e anexe o APK integrado pronto para ser testado pelo Google.
• O Google realiza uma verificação e revisão interna para garantir que a integração funcione como esperado. Se for necessário fazer mudanças, o Google vai entrar em contato informando todos os detalhes necessários.
• Quando o teste estiver concluído e nenhuma mudança for necessária, o Google vai entrar em contato para informar que você pode começar a publicar o APK atualizado e integrado na Play Store.
• Depois que o Google confirmar a publicação do APK atualizado na Play Store, seus clusters de recomendação, destaque e continuação poderão ser publicados e ficar visíveis aos usuários.