Criar um app para Android usando o Firebase e o ambiente flexível do App Engine

Last reviewed 2018-07-31 UTC

Este tutorial demonstra como usar o Firebase para escrever um app para dispositivos móveis com armazenamento de dados de back-end, sincronização em tempo real e registro de eventos do usuário. Os servlets Java em execução no ambiente flexível do App Engine do Google Cloud Platform (GCP) detectam e processam novos registros de usuários armazenados no Firebase.

Nas instruções, veja como fazer isso usando o Firebase e o ambiente flexível do App Engine.

Use seu aplicativo para processar dados do usuário ou orquestrar eventos. Para isso, estenda o Firebase com o ambiente flexível do App Engine e faça a sincronização automática de dados em tempo real.

Com o app de amostra Playchat, as mensagens de bate-papo são armazenadas no Firebase Realtime Database, onde esses dados são sincronizados automaticamente com os dispositivos. Nesse aplicativo, os logs de eventos do usuário também são gravados no Firebase. Para saber mais sobre como o banco de dados sincroniza dados, consulte Como funciona? na documentação do Firebase.

Veja no diagrama abaixo a arquitetura do cliente do Playchat.

Arquitetura do cliente do Playchat

Um conjunto de servlets Java em execução no ambiente flexível do App Engine é registrado como listener no Firebase. Eles respondem aos logs de evento do novo usuário e processam os dados desses logs. As transações são usadas para garantir que o processamento de cada log de evento do usuário seja feito apenas por um servlet.

Veja no diagrama abaixo a arquitetura do servidor do Playchat.

Arquitetura do servidor do Playchat

A comunicação entre o app e o servlet acontece em três partes:

  • Quando um novo usuário faz login no Playchat, o app solicita um servlet de registro para esse usuário adicionando uma entrada em /inbox/ no Firebase Realtime Database.

  • Um dos servlets aceita a atribuição por meio da atualização do valor da entrada para seu identificador de servlet. Uma transação do Firebase é usada para garantir que ele seja o único a atualizar o valor. Depois disso, a solicitação é ignorada por todos os outros servlets.

  • Quando o usuário faz login/logout ou muda para um novo canal, o Playchat registra a ação em /inbox/[SERVLET_ID]/[USER_ID]/, em que [SERVLET_ID] é o identificador da instância do servlet e [USER_ID] é um valor de hash que representa o usuário.

  • O servlet monitora a inclusão de novas entradas na caixa de entrada e coleta os dados de registro.

Neste aplicativo de amostra, os dados do registro são copiados localmente e exibidos em uma página da Web pelos servlets. Em uma versão de produção deste app, os servlets processam os dados de registro ou copiam esses dados para o Cloud Storage, o Cloud Bigtable ou o BigQuery para armazenamento e análise.

Objetivos

Neste tutorial, mostramos como:

  • criar um app para Android, Playchat, que armazene dados no Firebase Realtime Database;

  • executar um servlet Java nos ambientes flexíveis do App Engine que se conecte ao Firebase e receba notificações quando os dados armazenados no Firebase são alterados;

  • usar esses dois componentes para criar um serviço de back-end de streaming distribuído para coleta e processamento de dados do log.

Custos

O Firebase tem um nível de uso gratuito. Quando o uso desses serviços é menor do que os limites especificados no plano gratuito do Firebase, não há custos para isso.

As instâncias do ambiente flexível do App Engine são cobradas pelo custo das máquinas virtuais subjacentes do Google Compute Engine.

Antes de começar

Instale os seguintes softwares:

Instale o componente Java do App Engine da CLI gcloud executando o seguinte comando na linha de comando.

gcloud components install app-engine-java

Clonar o código de amostra

  1. Clone o código do app cliente de front-end.

    git clone https://github.com/GoogleCloudPlatform/firebase-android-client

  2. Clone o código do servlet de back-end.

    git clone https://github.com/GoogleCloudPlatform/firebase-appengine-backend

Como gerar uma impressão digital SHA-1 para o aplicativo

Para autenticar o aplicativo cliente para Login do Google, informe uma impressão digital SHA-1 do certificado. Este tutorial usa o keystore de depuração. Para mais informações sobre como criar versões da impressão digital do keystore, veja Como autenticar seu cliente.

  • Crie um SHA-1 do keystore de depuração.

    keytool -list -v \
-alias androiddebugkey -keystore ~/.android/debug.keystore

Como criar um projeto do Firebase

  1. Crie uma conta do Firebase ou faça login em uma conta.

  2. Clique em Adicionar projeto.

  3. Se estiver na página pela primeira vez, clique em Criar um projeto.

  4. Em Nome do projeto, insira Playchat.

  5. Siga as etapas de configuração restantes e clique em Criar projeto.

    • Você não precisa ativar o Google Analytics neste projeto.

  6. Após o assistente provisionar seu projeto, clique em Continuar.

  7. Na página Visão geral do projeto, clique em Configurações e em Configurações do projeto.

  8. Clique no ícone do Android, que o direciona para a página Adicionar o Firebase ao app para Android.

  9. Em Nome do pacote Android, insira com.google.cloud.solutions.flexenv.

  10. Em Certificado de assinatura de depuração SHA-1, insira o valor SHA-1 gerado na seção anterior.

  11. Clique em Register app.

  12. Siga os passos na seção Fazer o download do arquivo de configuração para adicionar o arquivo google-services.json ao seu projeto.

  13. Clique em Avançar na seção Fazer download do arquivo de configuração.

  14. Anote as alterações sugeridas nos arquivos build.gradle nos níveis do projeto e do app.

  15. Clique em Avançar na seção Adicionar SDK do Firebase.

  16. Clique em Continuar para o Console para concluir a configuração.

Como criar um Realtime Databasea

  1. No Console do Firebase, selecione seu projeto.

  2. No menu à esquerda do console, selecione Realtime Database no grupo Build.

  3. Clique em Criar banco de dados na seção Realtime Database.

  4. Selecione um local próximo a você.

  5. Na caixa de diálogo Regras de segurança, selecione Iniciar no modo de teste e clique em Ativar.

    Nesse passo, os dados armazenados são exibidos no Firebase. Nas próximas etapas deste tutorial, revisite essa página da Web para ver os dados acrescentados e atualizados pelo aplicativo cliente e pelo servlet do back-end.

  6. Na guia Regras do banco de dados, confirme se você tem as regras de segurança para leitura/gravação que especificam uma data 30 dias no futuro com a unidade de tempo definida em Horário Unix do período. Por exemplo, se você estiver criando a regra em 4 de agosto, ela deverá expirar após 4 de setembro:

    {
  "rules": {
    ".read": "now < 1659639249000", //2022-08-04
    ".write": "now < 1659639249000" //2022-08-04
  }
}

  7. Anote o URL do Firebase do seu projeto, que está no formato https://[FIREBASE_PROJECT_ID].firebaseio.com/ e aparece ao lado de um ícone de link.

Ativar a autenticação do Google para o projeto do Firebase

Há vários provedores de login configurados para fazer a conexão com o projeto do Firebase. Neste tutorial, você aprende a configurar a autenticação para que o usuário faça o login usando uma Conta do Google.

  1. No menu à esquerda do Console do Firebase, clique em Autenticação no grupo Desenvolver.

  2. Clique em Configurar método de login ou Primeiros passos se for a primeira vez que você acessa a página.

  3. Sob aMétodo de login guia, selecionar Google, selecione o botão Ativar, selecione o e-mail de suporte e clique em Salvar.

Adicionar uma conta de serviço ao projeto do Firebase

O login no servlet de back-end não é feito usando uma Conta do Google. Em vez disso, é usada uma conta de serviço para se conectar ao Firebase. Nas etapas a seguir é mostrado como criar uma conta de serviço para conectar-se com o Firebase e adicionar as credenciais dessa conta ao código do servlet.

  1. No menu à esquerda do Console do Firebase, ao lado da página inicial do projeto do Playchat, selecione a engrenagem Configurações e clique em Configurações do projeto.

  2. Selecione Contas de serviço e clique no link Gerenciar permissões de conta de serviço.

  3. Clique em Criar conta de serviço.

  4. Defina as configurações a seguir:

    1. Em Nome da conta de serviço, digite playchat-servlet e clique em Criar e continuar.

    2. Em Selecionar um papel, selecione Projeto > Proprietário e clique em Continuar.

    3. Clique em Concluído.

  5. Clique na conta de serviço que você acabou de criar, na guia CHAVES, clique em Adicionar chave e, em seguida, clique em Criar nova chave.

  6. Ao lado de Tipo de chave, clique em JSON e em Criar para fazer o download da chave.

  7. Salve o arquivo de chave JSON baixado para a conta de serviço no projeto de serviço de back-end, firebase-appengine-backend, no diretório src/main/webapp/WEB-INF/. O nome de arquivo está no formato Playchat-[UNIQUE_ID].json.

  8. Edite src/main/webapp/WEB-INF/web.xml e os parâmetros de inicialização da seguinte forma:

    • Substitua JSON_FILE_NAME pelo nome do arquivo de chave JSON que você fez download.

    • Substitua FIREBASE_URL pelo URL do Firebase anotado anteriormente.

      <init-param>
  <param-name>credential</param-name>
  <param-value>/WEB-INF/JSON_FILE_NAME</param-value>
</init-param>
<init-param>
  <param-name>databaseUrl</param-name>
  <param-value>FIREBASE_URL</param-value>
</init-param>

Como ativar o faturamento e APIs para o projeto do Cloud Platform

Para que o serviço de back-end seja executado no Cloud Platform, você precisa ativar o faturamento e as APIs do projeto. O projeto do Cloud Platform é o mesmo criado na seção Criar um projeto do Firebase e tem o mesmo identificador.

  1. No Console do Cloud Platform, selecione o projeto do Playchat.

    Acessar a página "Projetos"

  2. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

  3. Ative as APIs App Engine Admin API and Compute Engine API.

    Ative as APIs

Criar e implantar o serviço de back-end

Uma configuração do Docker é usada no serviço de back-end desta amostra para especificar o ambiente de hospedagem. Essa personalização significa que você precisa usar o ambiente flexível do App Engine, não o ambiente padrão.

Para criar o servlet de back-end e implantá-lo no ambiente flexível do App Engine, use o plug-in Maven do Google App Engine. Esse plug-in está especificado no arquivo de criação do Maven, incluído nesta amostra.

Configurar o projeto

Para que o servlet de back-end seja criado corretamente pelo Maven, forneça a ele o projeto do Google Cloud Platform (GCP) para ativar os recursos desse servlet. O identificador de projeto do GCP e o do Firebase são os mesmos.

  1. Forneça as credenciais usadas pela CLI gcloud para acessar o GCP.

    gcloud auth login

  2. Defina o projeto do Firebase com o comando a seguir, substituindo [FIREBASE_PROJECT_ID] pelo nome do código do projeto anotado anteriormente.

    gcloud config set project [FIREBASE_PROJECT_ID]

  3. Para verificar se o projeto foi definido, liste a configuração.

    gcloud config list

  4. Se esta for a primeira vez que você está usando o App Engine, inicialize seu aplicativo do App Engine:

    gcloud app create

(Opcional) Executar o serviço no servidor local

Ao desenvolver um novo serviço de back-end, execute o serviço localmente antes de implantá-lo no App Engine para repetir rapidamente as alterações sem a sobrecarga de uma implantação completa.

Quando o servidor é executado localmente, não é usada uma configuração Docker nem a execução em um ambiente do App Engine. Em vez disso, o Maven garante que todas as bibliotecas dependentes sejam instaladas localmente e o aplicativo seja executado no servidor da Web Jetty.

  1. No diretório firebase-appengine-backend, crie e execute o módulo de back-end localmente com o comando a seguir:

    mvn clean package appengine:run

    Se você instalou a Google Cloud CLI em um diretório diferente de ~/google-cloud-sdk, adicione o caminho de instalação ao comando substituindo [PATH_TO_TOOL] pelo caminho personalizado, como demonstrado a seguir.

    mvn clean package appengine:run -Dgcloud.gcloud_directory=[PATH_TO_TOOL]

  2. Quando a pergunta Quer que o aplicativo "Python.app" aceite conexões de rede recebidas? for exibida, selecione Permitir.

Quando a implantação terminar, abra http://localhost:8080/printLogs para verificar se o serviço de back-end está sendo executado. Na página da Web, será exibida Caixa de entrada:, seguida por um identificador de 16 dígitos. Esse é o identificador da caixa de entrada para o servlet em execução na máquina local.

Quando você atualiza a página, esse identificador permanece inalterado. Seu servidor local ativa uma única instância de servlet. Isso é útil para testes, porque há apenas um identificador de servlet armazenado no Firebase Realtime Database.

Para encerrar o servidor local, digite Ctrl + C.

Implantar o serviço no ambiente flexível do App Engine

Quando o serviço de back-end é executado no ambiente flexível do App Engine, o app usa a configuração em /firebase-appengine-backend/src/main/webapp/Dockerfiles para criar o ambiente de hospedagem em que o serviço é executado. Nesse ambiente, várias instâncias de servlet são geradas e escalonadas para atender à demanda.

  • No diretório firebase-appengine-backend, crie e execute o módulo de back-end localmente com o comando a seguir:

    mvn clean package appengine:deploy

    mvn clean package appengine:deploy -Dgcloud.gcloud_directory=[PATH_TO_GCLOUD]

Durante a execução da compilação, aparece a mensagem “Enviando contexto de compilação para o daemon do Docker…”. O comando anterior faz o upload da configuração do Docker e a instala no ambiente flexível do App Engine.

Ao final da implantação, abra https://[FIREBASE_PROJECT_ID].appspot.com/printLogs, em que [FIREBASE_PROJECT_ID] é o identificador de Criar um projeto do Firebase. Na página da Web, será exibida Caixa de entrada:, seguida por um identificador de 16 dígitos. Esse é o identificador da caixa de entrada de um servlet em execução no ambiente flexível do App Engine.

Esse identificador muda periodicamente, à medida que a página é atualizada, já que o App Engine ativa diversas instâncias de servlet para processar as solicitações de clientes recebidas.

Como adicionar o Firebase e o Google Play Services ao app para Android

O aplicativo cliente usa o Firebase Realtime Database para armazenar e sincronizar mensagens e gravar logs de eventos de usuários. O aplicativo cliente usa o Google Play Services para autenticar usuários com a Conta do Google.

  1. No Android Studio, selecione Ferramentas > SDK Manager.

  2. Selecione a guia Ferramentas do SDK.

  3. Selecione o Google Play Services, caso ainda não o tenha feito.

  4. Clique em OK para instalá-lo.

  5. Selecione Arquivo > Abrir… e escolha o diretório firebase-android-client.

  6. Aguarde a informação do projeto Gradle para terminar a criação. Se o uso do wrapper do Gradle for solicitado, clique em OK.

  7. As mudanças nos arquivos build.gradle no nível do app e para envolvidos no projeto anotadas em Criar um projeto do Firebase foram feitas no código de amostra.

Como executar e testar o app para Android

  1. Com o projeto firebase-android-client aberto no Android Studio, selecione Executar > Executar 'app'.

  2. Selecione um dispositivo ou emulador que execute o Android 6.0 com as APIs Google como seu dispositivo de teste.

  3. Quando o app for carregado no dispositivo, faça login com a Conta do Google.

    Fazer login no Playchat

  4. Clique no menu à esquerda do título PlayChat e selecione o canal de livros.

    Selecione um canal

  5. Digite uma mensagem.

    Enviar uma mensagem

  6. Quando você faz isso, o aplicativo Playchat armazena a mensagem no Firebase Realtime Database. Os dados armazenados no banco de dados do Firebase são sincronizados com todos os dispositivos. Quando o Playchat é executado nesses dispositivos, a nova mensagem é exibida se um usuário seleciona o canal books.

    Enviar uma mensagem

Verificar os dados

Depois de usar o aplicativo Playchat para gerar alguns eventos do usuário, verifique se os servlets estão sendo registrados como listeners e coletando logs de eventos de usuários.

Abra o Firebase Realtime Database do aplicativo, em que [FIREBASE_PROJECT_ID] é o identificador de Criar um projeto do Firebase.

https://console.firebase.google.com/project/[FIREBASE_PROJECT_ID]/database/data

No parte inferior do Firebase Realtime Database, no local de dados /inbox/, há um grupo de nós prefixados por client- e seguidos por uma chave gerada aleatoriamente que representa o login da conta do usuário. A última entrada neste exemplo, client-1240563753, é seguida por um identificador de 16 dígitos do servlet que está detectando os eventos de registro do usuário neste exemplo 0035806813827987.

Dados armazenados no Firebase Realtime Database

Logo acima, no local de dados /inbox/, estão os identificadores servlet de todos os servlets atribuídos no momento. Neste exemplo, os logs são coletados por apenas um servlet. Os registros de usuário gravados pelo app para esse servlet estão em /inbox/[SERVLET_IDENTIFIER].

Abra a página do App Engine para seu serviço de back-end em https://[FIREBASE_PROJECT_ID].appspot.com/printLogs, em que [FIREBASE_PROJECT_ID] é o identificador de Como criar um projeto do Firebase. O identificador do servlet que registrou os eventos do usuário gerados por você é exibido na página. É possível também ver as entradas de registros para os eventos abaixo do identificador da caixa de entrada do servlet.

Explorar o código

No app Playchat para Android, a classe FirebaseLogger é definida para gravar os registros de eventos de usuário no Firebase Realtime Database.

app/src/main/java/com/google/cloud/solutions/flexenv/FirebaseLogger.java 

import com.google.cloud.solutions.flexenv.common.LogEntry;
import com.google.firebase.database.DatabaseReference;
import com.google.firebase.database.FirebaseDatabase;

/*
 * FirebaseLogger pushes user event logs to a specified path.
 * A backend servlet instance listens to
 * the same key and keeps track of event logs.
 */
class FirebaseLogger {
    private final DatabaseReference logRef;

    FirebaseLogger(String path) {
        logRef = FirebaseDatabase.getInstance().getReference().child(path);
    }

    public void log(String tag, String message) {
        LogEntry entry = new LogEntry(tag, message);
        logRef.push().setValue(entry);
    }

}

Quando um novo usuário faz login, o Playchat chama a função requestLogger para adicionar uma nova entrada ao local /inbox/ no Firebase Realtime Database e definir um listener. Dessa forma, o Playchat poderá responder quando um servlet atualizar o valor dessa entrada, aceitando a atribuição.

Quando um servlet atualiza o valor, o Playchat remove o listener e grava o registro como "Conectado" na caixa de entrada do servlet.

app/src/main/java/com/google/cloud/solutions/flexenv/PlayActivity.java 
/*
 * Request that a servlet instance be assigned.
 */
private void requestLogger(final LoggerListener loggerListener) {
    final DatabaseReference databaseReference = FirebaseDatabase.getInstance().getReference();
    databaseReference.child(IBX + "/" + inbox).addListenerForSingleValueEvent(new ValueEventListener() {
        public void onDataChange(@NonNull DataSnapshot snapshot) {
            if (snapshot.exists() && snapshot.getValue(String.class) != null) {
                firebaseLoggerPath = IBX + "/" + snapshot.getValue(String.class) + "/logs";
                fbLog = new FirebaseLogger(firebaseLoggerPath);
                databaseReference.child(IBX + "/" + inbox).removeEventListener(this);
                loggerListener.onLoggerAssigned();
            }
        }

        public void onCancelled(@NonNull DatabaseError error) {
            Log.e(TAG, error.getDetails());
        }
    });

    databaseReference.child(REQLOG).push().setValue(inbox);
}

Quando uma instância de servlet é iniciada no lado do serviço de back-end, a função init(ServletConfig config) em MessageProcessorServlet.java se conecta ao Firebase Realtime Database e adiciona um listener ao local de dados /inbox/.

Quando uma nova entrada é adicionada ao local de dados /inbox/, o servlet atualiza o valor com seu identificador. Isso sinaliza para o app Playchat que o servlet aceita a atribuição para processar registros para esse usuário. As transações do Firebase são usadas para garantir que somente um servlet possa atualizar o valor e aceitar a atribuição.

src/main/java/com/google/cloud/solutions/flexenv/backend/MessageProcessorServlet.java 
/*
 * Receive a request from a client and reply back its inbox ID.
 * Using a transaction ensures that only a single servlet instance replies
 * to the client. This lets the client know to which servlet instance
 * send consecutive user event logs.
 */
firebase.child(REQLOG).addChildEventListener(new ChildEventListener() {
  public void onChildAdded(DataSnapshot snapshot, String prevKey) {
    firebase.child(IBX + "/" + snapshot.getValue()).runTransaction(new Transaction.Handler() {
      public Transaction.Result doTransaction(MutableData currentData) {
        // Only the first servlet instance writes its ID to the client inbox.
        if (currentData.getValue() == null) {
          currentData.setValue(inbox);
        }
        return Transaction.success(currentData);
      }

      public void onComplete(DatabaseError error, boolean committed, DataSnapshot snapshot) {}
    });
    firebase.child(REQLOG).removeValue();
  }
  // ...
});

Depois de uma tarefa de processar os logs de eventos de um usuário ser aceita pelo servlet, um listener é adicionado. Esse listener detecta quando um novo arquivo de log é gravado na caixa de entrada pelo aplicativo Playchat. A resposta do servlet é recuperar os novos dados de log do Firebase Realtime Database.

src/main/java/com/google/cloud/solutions/flexenv/backend/MessageProcessorServlet.java 
/*
 * Initialize user event logger. This is just a sample implementation to
 * demonstrate receiving updates. A production version of this app should
 * transform, filter, or load to another data store such as Google BigQuery.
 */
private void initLogger() {
  String loggerKey = IBX + "/" + inbox + "/logs";
  purger.registerBranch(loggerKey);
  firebase.child(loggerKey).addChildEventListener(new ChildEventListener() {
    public void onChildAdded(DataSnapshot snapshot, String prevKey) {
      if (snapshot.exists()) {
        LogEntry entry = snapshot.getValue(LogEntry.class);
        logs.add(entry);
      }
    }

    public void onCancelled(DatabaseError error) {
      localLog.warning(error.getDetails());
    }

    public void onChildChanged(DataSnapshot arg0, String arg1) {}

    public void onChildMoved(DataSnapshot arg0, String arg1) {}

    public void onChildRemoved(DataSnapshot arg0) {}
  });
}

Limpeza

Para evitar que os recursos usados nesse tutorial sejam cobrados na sua conta do Google Cloud Platform:

Excluir o projeto do Cloud Platform e do Firebase

A maneira mais simples de não ser cobrado é excluir o projeto criado neste tutorial. O projeto foi criado no Firebase console, mas também pode ser excluído no Console do Cloud Platform, uma vez que os dois correspondem ao mesmo projeto.

  1. No Console do Google Cloud, acesse a página Gerenciar recursos.

    Acessar "Gerenciar recursos"

  2. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
  3. Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

Excluir as versões não padrão do aplicativo App Engine

Se não quiser excluir o projeto do Cloud Platform e do Firebase, para reduzir os custos, exclua as versões não padrão do aplicativo de ambiente flexível do App Engine.

  1. No Console do Google Cloud, acesse a página Versões do App Engine.

    Acessar "Versões"

  2. Marque a caixa de seleção da versão não padrão do app que você quer excluir.
  3. Para excluir a versão do app, clique em Excluir.

A seguir

  • Analisar e arquivar dados: neste exemplo, os dados do log são armazenados apenas na memória pelos servlets. Para ampliar essa amostra, use os servlets para arquivar, transformar e analisar os dados, com serviços como o Cloud Storage, o Cloud Bigtable, o Google Cloud Dataflow e o BigQuery.

  • Distribuir uniformemente a carga de trabalho entre os servlets: no App Engine, você tem escalonamento automático e manual. Com o escalonamento automático, as alterações são detectadas no ambiente flexível, que responde adicionando ou removendo instâncias de VMs no cluster. Com o escalonamento manual, você especifica um número estático de VMs para processar o tráfego. Para mais informações sobre como configurar o escalonamento, consulte Configurações de escalonamento de serviço na documentação do App Engine.

    Como os logs de atividade do usuário são atribuídos aos servlets por meio do acesso ao Firebase Realtime Database, a carga de trabalho pode não ser distribuída uniformemente. Por exemplo, um servlet pode processar mais logs de eventos de usuários do que outros.

    Para melhorar a eficiência, implemente um gerenciador para controlar de maneira independente a carga de trabalho de cada VM. Esse balanceamento de carga pode basear-se em métricas como, por exemplo, as solicitações de geração de registros por segundo ou o número de clientes simultâneos.

  • Recuperar logs de eventos de usuários não processados: nessa implementação de amostra, quando ocorre uma falha em uma instância de servlet, o aplicativo cliente associado a ela continua a enviar eventos de registros para a caixa de entrada do servlet no Firebase Realtime Database. Em uma versão de produção desse aplicativo, é necessário que o serviço de back-end identifique a situação para recuperar os registros de eventos de usuários não processados.

  • Implemente recursos extras usando produtos do Cloud AI: explore como fornecer recursos baseados em ML com produtos e serviços do Cloud AI. Por exemplo, amplie essa implementação de amostra para fornecer um recurso de tradução de fala usando uma combinação das APIs Speech-to-Text, Translation e Text-to-Speech. Para mais informações, consulte Como adicionar tradução de fala ao seu app para Android.