7 lojas de aplicativos Android alternativas ao Google Play

Por Luciana Anselmo

12 Comentários

Sabemos que o Google Play é a loja oficial dos aplicativos Android, mas muitas vezes ela não
permite que você baixe certos apps para o seu dispositivo. Seja porque o app não está
localizado para sua região ou porque acredita que seu dispositivo – mesmo celulares recentes
como o Galaxy A8+ – não é compatível com ele. Seja qual for o motivo, sempre é bom ter
opções de outras lojas que vendem ou disponibilizam estes apps oficialmente.

Além disso, muitas lojas acabam oferecendo apps pagos por preços bem mais em conta ou até
de graça em certos períodos. O nosso objetivo, com este artigo, é mostrar as opções
alternativas ao Google Play.

Leia também: Top 6 apps para fazer downloads no Android

Mas antes de avançarmos, você precisará habilitar seu aparelho para que seja possível instalar
apps de outras lojas. Para fazer isso, vá em suas configurações e procure a opção “Segurança”.
Lá, você verá a opção “Fontes alternativas”, que deverá ser ativada como na imagem abaixo:

aplicativos Android

Então, sem mais demora, confira algumas das melhores lojas virtuais de aplicativos Android
para quem procura uma alternativa ao Google Play. Lembre-se de sempre verificar se os apps
são seguros, mesmo que as lojas se esforcem ao máximo para garantir sua segurança, é bom
ficar alerta quando utilizando qualquer plataforma que não seja a oficial do Android.

amazon aplicativos android1. Amazon App Store

Esta é alternativa mais popular e usada em questão de aplicativos Android, já que oferece
praticamente o mesmo conteúdo que o Google Play e quase sempre oferece descontos
enormes nos apps pagos.

Algumas vezes, a Amazon App Store até faz um pacote de dezenas de apps e jogos pagos que
podem baixados de graça por um período de tempo. Você pode baixar o aplicativo da loja
virtual neste link e já começar a baixar seus apps!
2. ApkMirror

O ApkMirror também é bem popular entre usuários de Android, especialmente aqueles que
querem testar lançamentos e atualizações de aplicativos que às vezes demoram um pouco
para chegar na Google Play.

Diferente da Amazon, o ApkMirror não tem um aplicativo só para você baixar apps
diretamente de seu dispositivo. Ainda assim, você poderá acessar ao site com todos os
aplicativos Android através deste link. Com os arquivos em mãos, basta colocá-os em uma
pasta de sua preferência no seu aparelho (seja na memória interna ou em um cartão SD) e
clicar neles para iniciar a instalação.

Se estiver tendo dificuldades em instalar seus aplicativos baixados através do ApkMirror,

temos um guia completo que pode ajudá-lo não apenas a fazer isso, mas também a atualizar
apps por fora da Google Play.

3. GetJar

O nome pode parecer estranho, mas fazia sentido na época que o Android nem existia e
aplicativos podiam ser encontrados no formato Jar. Como deve imaginar, esta é basicamente a
loja de aplicativos mais antiga na internet.

Você pode conferir os aplicativos Android disponibilizados diretamente através do site, que
pode ser acessado neste link. Se preferir, também há um app não oficial da loja (que pode ser
baixado aqui), mas que funciona direitinho em seu propósito.

4. AppBrain

Caso os aplicativos que você goste sempre sejaappbrain aplicativos androidm pagos, o
AppBrain é uma excelente alternativa para consegui-los de graça oficialmente. Os
desenvolvedores destes apps premium geralmente deixam seus aplicativos serem baixados de
graça por um período de tempo e, em troca, o AppBrain os divulga na internet.

Você pode acessar o site por este link ou até baixar o aplicativo oficial da loja clicando aqui!

5. Aptoide

Outra alternativa popular, o Aptoide oferece ainda mais opções gratuitas de aplicativos pagos
(ainda mais do que o AppBrain). O layout é muito bonito, a ponto de ser comparado com um
app oficial do Google.
No site, a experiência é bem suave e intuitiva (como você pode ver através deste link) e no
aplicativo oficial não poderia ser diferente. Entre todos os citados nesta lista, o Aptoide é sem
dúvidas a alternativa mais interessante para quem gosta do design e funcionalidade do Google
Play.

6. Opera Mobile Store

O Opera é um dos navegadores mobile mais antigos e usados até hoje, mas o mais legal é que
ele oferece uma loja virtual com vasto número de aplicativos Android disponíveis.

Ele pode não ser o mais funcional ou ter a melhor experiência, mas é possível encontrar quase
de tudo por lá. Você pode baixar o app do Opera através deste link. Bom, agora não tem mais
desculpas para deixar de baixar todos os aplicativos que tiver vontade, seja dentro da Google
Play ou fora!

7. SlideMe

O SlideMe é outra excelente opção entre as alternativas ao Google Play, contando com uma
enorme comunidade de usuários que compartilham dados e análises sobre aplicativos em sua
página. Sua seção de aplicativos incluir diversas categorias que facilitam uma navegação mais
rápida entre as opções.

Um diferencial que faz com que o SlideMe seja uma excelente alternativa é que todos
aplicativos inseridos em seu banco passam por um rigoroso processo de controle de qualidade,
portanto, existem chances bem menores de algum app instalado por lá ser malicioso ou trazer
problemas à seus usuários. Acesse o site oficial pelo link!

Encontre também no AppTuts:

Como abrir links do Spotify no Google Play Music

7 dicas para resolver problemas do Google Play

Como ter reembolso de apps Android na Google Play

O que achou dessas lojas alternativas ao Google Play?

Você já conhecia ou mesmo havia utilizado alguma das lojas citadas no artigo para baixar
apps? Conta pra gente nos comentários se conseguimos ajudá-lo e qual chamou mais atenção.
Criar um app para Android usando o Firebase e o ambiente flexível do App Engine

Este tutorial demonstra como usar o Firebase para escrever um aplicativo para dispositivos
móveis com armazenamento de dados de back-end, sincronização em tempo real e registro de
eventos de 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.

Observação: esta amostra também tem uma versão para iOS.

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 aplicativo e o servlet acontece em três partes:

Quando um novo usuário faz login no Playchat, um servlet de geração de registros é solicitado
pelo aplicativo para esse usuário. Isso é feito incluindo 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, sai ou muda para um novo canal, a ação é registrada pelo Playchat
no /inbox/[SERVLET_ID]/[USER_ID]/, em que [SERVLET_ID] é o identificador da instância do
servlet e [USER_ID] é o valor de hash que representa o usuário.

A inclusão de novas entradas na caixa de entrada é monitorada e os dados do log são

coletados pelo servlet.

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 aplicativo, os dados de
registro são processados pelos servlets ou copiados 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.

Observação: o aplicativo cliente neste código de amostra é para aplicativos Android, mas é
possível criar aplicativos para iOS e Web que armazenem mensagens e registros no Firebase
Realtime Database. Como o front-end e o back-end são agrupados levemente usando o
Firebase como intermediário, não será necessário fazer alterações no serviço de back-end ou
no projeto do Firebase.

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:

Git.

Android Studio 3.0 ou superior.

Um dispositivo ou emulador, com o Android 6.0 (nível de API 23) ou superior, com as APIs
Google.

Python 2.7

Apache Maven 3.3.x ou superior

Java 8

SDK do Google Cloud

Instale o componente Java do App Engine do Cloud SDK executando o comando a seguir na
linha de comando.

gcloud components install app-engine-java

Como clonar o código da amostra

Clone o código do aplicativo cliente de front end.

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

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 -exportcert -list -v \

-alias androiddebugkey -keystore ~/.android/debug.keystore

Observação: se você já tem um arquivo $HOME/.android/debug.keystore e receber o erro “O

arquivo keystore não existe”, gere um keystore de depuração. Basta criar um projeto em
branco e desenvolvê-lo no Android Studio.

Como criar um projeto do Firebase

Observação: se você já tiver executado a versão para iOS desta amostra, reutilize esse projeto
do Firebase em vez de criar um novo. Para isso, ignore as cinco primeiras etapas abaixo e abra
o Console do Firebase, clique no projeto e selecione Adicionar aplicativo.

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

Clique em Adicionar projeto.

Em Nome do projeto, digite: Playchat.

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

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

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

projeto.

Clique em Adicionar o Firebase a um aplicativo para Android.

Em Nome do pacote Android, digite: com.google.cloud.solutions.flexenv.

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

anterior.

Clique em Registrar aplicativo.

Siga as etapas da seção Fazer o download do arquivo de configuração para adicionar o arquivo
google-services.json ao projeto.

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

Anote as alterações sugeridas para os arquivos build.gradle em nível de projeto e de aplicativo.

Observação: as alterações sugeridas já estão configuradas no código de amostra.

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

Clique em Ignorar esta etapa na seção Executar seu aplicativo para verificar a instalação.

Como criar um banco de dados em tempo real

No menu à esquerda do Console do Firebase, selecione Banco de dados no grupo Desenvolver.

Na página Banco de dados, acesse a seção Realtime Database e clique em Criar banco de
dados.

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

Atenção: no modo de teste, qualquer pessoa com sua referência de banco de dados pode
realizar operações de leitura e gravação. Caso o modo de teste não seja adequado aos seus
objetivos, crie regras de segurança para gerenciar o acesso aos dados. Para mais informações,
consulte Primeiros passos com as regras do banco de dados na documentação do Firebase.

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.

Anote o URL do Firebase para seu projeto. Ele está no formato

https://[FIREBASE_PROJECT_ID].firebaseio.com/ e aparece ao lado de um ícone de link.

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

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

Observação: se o menu à esquerda não for exibido, verifique se o projeto do Playchat está
selecionado.

Clique em Configurar método de login.

Selecione Google, alterne para Ativar 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.

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.

Selecione Contas de serviço e Gerenciar todas as contas de serviço.

Clique em CRIAR CONTA DE SERVIÇO.

Defina as configurações a seguir:

Em Nome da conta de serviço, digite playchat-servlet.

Em Papel, selecione Projeto > Proprietário.

Atenção: o papel de proprietário concede à conta de serviço acesso total a todos os recursos
do projeto. Em um arquivo de produção, configure-o com o mínimo de acesso necessário à sua
conta.

Marque Fornecer uma nova chave particular.

Selecione JSON em Tipo de chave.

Clique em Criar

Faça o download do arquivo de chave JSON da conta de serviço e salve-o no projeto de serviço
de back-end firebase-appengine-backend, no diretório src/main/webapp/WEB-INF/. O nome
do arquivo está no formato Playchat-[UNIQUE_ID].json.

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.

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

ACESSAR A PÁGINA "PROJETOS"

Verifique se o faturamento foi ativado no projeto do Google Cloud Platform. Saiba como
confirmar que o faturamento está ativado para seu projeto.

Ative a(s) App Engine Admin API e Compute Engine API APIs necessária(s).

ATIVAR A(S) 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.

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

gcloud auth login

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]

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

gcloud config list

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

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 ferramenta de linha de comando gcloud em um diretório diferente de

~/google-cloud-sdk, adicione o caminho de instalação ao comando, conforme mostrado a
seguir, substituindo [PATH_TO_TOOL] pelo caminho personalizado.

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

Observação: se a biblioteca do agente não for inicializada durante a execução do comando

anterior, use a versão 240 do SDK do Google Cloud:

gcloud components update --version 240.0.0

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 você executa o serviço de back-end no ambiente flexível do App Engine, a

configuração em /firebase-appengine-backend/src/main/webapp/Dockerfiles é usada para
criar o ambiente de hospedagem onde 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

Observação: se a ferramenta gcloud tiver sido instalada em um diretório diferente de

~/google-cloud-sdk, adicione o caminho de instalação ao comando, conforme demonstrado
abaixo. Substitua [PATH_TO_GCLOUD] pelo caminho personalizado.

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

Durante a compilação, você vê as linhas “Enviando o contexto de compilação para o daemon

do Docker…”. Com o comando anterior, é feito o upload da configuração do Docker e a
respectiva configuração 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.

No Android Studio, selecione Ferramentas > SDK Manager.

Na parte superior do painel direito, selecione Ferramentas do SDK.

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

Clique em OK.

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

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

As alterações nos arquivos build.gradle nos níveis do projeto e aplicativo que você anotou em
Criar um projeto do Firebase já foram feitas no código de amostra.

Como executar e testar o app para Android

No Android Studio, com o projeto firebase-android-client aberto, selecione Executar >

Executar "aplicativo".

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

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

Fazer login no Playchat

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

Selecionar um canal

Digite uma mensagem.

Enviar uma mensagem

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

Como 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

Na parte inferior do Firebase Realtime Database, no local de dados /inbox/, há um grupo de

nós prefixados por client- e seguido por uma chave gerada aleatoriamente, representando o
login da conta de um usuário. A última entrada neste exemplo, client-1240563753, é seguida
por um identificador de 16 dígitos do servlet que atualmente atende eventos de registros
desse usuário, neste exemplo 0035806813827987.

Dados armazenados no Firebase Realtime Database

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

Abra a página do App Engine do serviço de back-end em

https://[FIREBASE_PROJECT_ID].appspot.com/printLogs, em que [FIREBASE_PROJECT_ID] é o
identificador de 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.

Observação: vários servlets são executados simultaneamente ao serviço de back-end no

ambiente flexível do App Engine. Recarregue a página do serviço de back-end mais vezes, até
que a solicitação de carregamento da página seja respondida pelo servlet que rastreia os
registros.

Como explorar o código

O app Playchat para Android define a classe FirebaseLogger para gravar os logs de eventos de
usuários no Firebase Realtime Database.

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

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 o login, o Playchat chama a função requestLogger para adicionar
uma nova entrada ao local /inbox/ no Firebase Realtime Database e configurar um listener.
Assim, o Playchat é capaz de responder quando um servlet atualiza 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.javaVER NO GITHUB

/*

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

No serviço de back-end, quando uma instância de servlet é iniciada, a função init(ServletConfig

config) em MessageProcessorServlet.java conecta-se ao Firebase Realtime Database e adiciona
um listener no local de dados /inbox/.

Quando uma nova entrada é adicionada ao local de dados /inbox/, o valor é atualizado pelo
servlet com o respectivo identificador. Isso indica ao aplicativo Playchat que a atribuição para
processar registros desse usuário foi aceita no servlet. 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.javaVE
R NO GITHUB

/*

* 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.javaVE
R NO GITHUB

/*

* 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) {}

});

Como fazer a 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.

Cuidado: excluir um projeto tem os seguintes efeitos:

Tudo no projeto é excluído. Se você tiver usado um projeto atual para seguir este tutorial, a
exclusão dele incluirá quaisquer outras ações feitas no projeto.

Os IDs do projeto personalizados são perdidos. Ao criar o projeto, você pode ter criado um
código do projeto personalizado para ser usado no futuro. Para preservar os URLs que usam o
ID do projeto, como um URL appspot.com, exclua recursos específicos do projeto, em vez de
excluir o projeto inteiro.

Se você planeja explorar vários tutoriais e guias de início rápido, a reutilização de projetos
pode evitar que você exceda os limites da cota do projeto.

No Console do GCP, acesse a página Gerenciar recursos.

ACESSAR A PÁGINA GERENCIAR RECURSOS

Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir excluir.

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.

No Console do GCP, acesse a página Versões para o App Engine.

ACESSAR A PÁGINA "VERSÕES"

Marque a caixa de seleção da versão não padrão do aplicativo que você quer excluir.

Observação: a única maneira de excluir a versão padrão de seu aplicativo do App Engine é
excluir seu projeto. No entanto, você pode parar a versão padrão no Console do GCP. Isso
encerra todas as instâncias associadas à versão. Você pode reiniciar essas instâncias
posteriormente, se necessário.

No ambiente padrão do App Engine, apenas será possível interromper a versão padrão se o
aplicativo tiver uma escala manual ou básica.

Clique em Excluir excluir para excluir a versão do aplicativo.

Próximas etapas

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 Cloud Storage, Cloud Bigtable, Google Cloud Dataflow e
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.

Implementar recursos extras usando produtos do Cloud AI: explore como fornecer recursos
baseados em ML com produtos e serviços do Cloud AI. Por exemplo, é possível estender essa
implementação de amostra para fornecer um recurso de tradução de voz por meio de uma
combinação das APIs Speech-to-Text, Translation e Text-to-Speech. Para mais informações,
consulte Como adicionar a tradução de voz a seu aplicativo para Android.

Esta página foi útil? Conte sua opinião sobre