Como Criar Seu Próprio Aplicativo com Login do Google Usando Android Studio

Seja bem-vindo a mais um guia completo do JovemProjeto.com.br! Nesta publicação, iremos explorar passo a passo como construir um aplicativo Android que permita autenticação através do Google Sign-In, utilizando o Android Studio. Você aprenderá desde a criação do projeto até a configuração de credenciais na Google Cloud Console, integração do SDK do Google e exibição de informações básicas do usuário. Nosso objetivo é entregar um conteúdo fluido, repleto de dicas práticas, links úteis para aprofundar conhecimentos e exemplos de código claros para que você possa replicar em seus próprios projetos. Prepare-se para imergir em um tutorial dinâmico e envolvente!

Por que implementar login com Google?

O Google Sign-In é a forma mais simples e confiável de permitir que usuários acessem seu aplicativo Android com sua conta Google. Entre as principais vantagens:

• Usuário não precisa criar novas credenciais: a maior parte dos usuários já possui conta Google, o que reduz a fricção durante o cadastro.
• Segurança robusta: o Google lida com autenticação, criptografia e verificação de identidade, melhorando a segurança do seu app.
• Experiência consistente: utiliza um padrão de interface familiar, garantindo que os usuários saibam exatamente o que estão fazendo.
• Integração com outros serviços: após o login, você pode acessar APIs do Google como Google Drive, Google Calendar e Google Contacts com o token de autenticação.

Em suma, ao adotar o login do Google, além de oferecer praticidade, você confia em uma infraestrutura confiável e consolidada para autenticar usuários, sem precisar desenvolver seu próprio sistema de login.

1. Preparando o ambiente de desenvolvimento

Antes de começar a escrever qualquer código, é fundamental garantir que você possui as ferramentas necessárias:

1.1 Android Studio

Certifique-se de que o Android Studio esteja instalado em sua máquina. Recomendamos utilizar a versão mais recente disponível, pois ela traz suporte a novos recursos do Android, correções de bugs e compatibilidade com as bibliotecas mais recentes do Google. Para baixar ou atualizar, acesse o site oficial do Android Studio (Android Studio) e siga as instruções de instalação.

1.2 Java Development Kit (JDK)

Verifique se o JDK está instalado. Se você não tiver certeza, abra o terminal (ou Prompt de Comando no Windows) e execute:

java -version

Deve aparecer algo como “java version “1.8.0_xxx”” ou superior. Caso não esteja instalado, baixe a versão apropriada em JDK Download e siga as instruções para configuração de variáveis de ambiente (JAVA_HOME).

1.3 Conta Google e Google Cloud Console

Você precisará de uma conta Google ativa para acessar o Google Cloud Console e criar credenciais de OAuth 2.0 para Android. Se ainda não possui uma conta, registre-se gratuitamente em Google Account Sign Up.

Acesse o Google Cloud Console em Google Cloud Console e crie um novo projeto ou utilize um existente. É nele que você vai gerar o OAuth 2.0 Client ID necessário para autenticar usuários via Google Sign-In no seu app Android.

2. Criando o projeto Android no Android Studio

Com as ferramentas em mãos, abra o Android Studio e siga os passos abaixo:

2.1 Novo projeto

1. Clique em “Start a new Android Studio project”.
2. Selecione o template “Empty Activity” e clique em “Next”.
3. Configure:
   • Nome do aplicativo: pode ser algo como “MeuAppGoogleLogin”.
   • Domain da empresa: insira seu domínio ou, se não tiver, use algo como “com.jovemprojeto”.
   • Local de salvamento: escolha a pasta onde o projeto será criado em seu computador.
   • Min SDK: selecione pelo menos o nível API 21 (Android 5.0 Lollipop) para alcançar uma boa base de usuários, mas você pode ajustar conforme a necessidade.
4. Clique em “Finish”. O Android Studio criará a estrutura básica do projeto.

2.2 Estrutura de pastas e arquivos principais

Assim que o projeto for gerado, observe no painel “Project” a seguinte estrutura relevante:

• app/src/main/java: contém nossos arquivos de código em Java ou Kotlin. Para este tutorial, usaremos Java, mas você pode adaptar facilmente para Kotlin.
• app/src/main/res/layout/activity_main.xml: layout da MainActivity, onde colocaremos botão de login e exibição de dados do usuário.
• app/src/main/AndroidManifest.xml: arquivo de manifesto, necessário para declarar permissões e atividades.
• app/build.gradle (Module: app): onde adicionaremos as dependências do Google Sign-In e outras bibliotecas necessárias.

Nos próximos tópicos, iremos configurar gradle, manifest e criar a interface do usuário.

3. Configurando dependências no Gradle

Para habilitar o Google Sign-In, precisamos adicionar bibliotecas específicas do Google Play Services. Abra o arquivo app/build.gradle (Module: app) e inclua as seguintes dependências no bloco dependencies:

implementation 'com.google.android.gms:play-services-auth:20.7.0' implementation 'androidx.appcompat:appcompat:1.6.1' implementation 'com.google.android.material:material:1.9.0' implementation 'androidx.constraintlayout:constraintlayout:2.1.4'

Essas versões podem mudar ao longo do tempo, portanto, caso encontre algum erro, pesquise a versão mais recente em Google Play Services Auth Gradle ou em MVN Repository. Após adicionar essas linhas, clique em “Sync Now” para que o Gradle baixe as bibliotecas e atualize o projeto.

3.1 Repositórios necessários

Certifique-se de que, no topo do arquivo build.gradle (Project: MeuAppGoogleLogin), existam os repositórios “google()” e “mavenCentral()”:

buildscript { repositories { google() mavenCentral() } dependencies { classpath 'com.android.tools.build:gradle:8.0.2' } }

allprojects {
repositories {
google()
mavenCentral()
}
}

Se estiver usando versions anteriores do Gradle Plugin, ajuste conforme a recomendação do Android Studio. Após garantir que os repositórios estão corretos, sincronize novamente.

4. Configurando credenciais no Google Cloud Console

Antes de escrever qualquer código de autenticação, é imprescindível gerar as credenciais de OAuth 2.0 para Android. Siga este passo a passo:

4.1 Criar projeto no Google Cloud Console

1. Acesse o Google Cloud Console.
2. Se necessário, selecione ou crie um novo projeto clicando em “Select a project” e depois no ícone “New Project”. Dê um nome como “MeuAppGoogleLogin”.
3. Espere o console criar o novo projeto e certifique-se de estar com ele selecionado na lista de projetos.

4.2 Ativar API do Google Sign-In

1. No menu lateral, clique em “APIs & Services” → “Library”.
2. Pesquise por “Google Sign-In” ou “Google Identity Services” e clique em “Google Identity Services” (ou “Google Sign-In API”).
3. Clique em “Enable” para ativar a API no seu projeto.

4.3 Criar credenciais OAuth 2.0

1. No menu lateral, vá em “APIs & Services” → “Credentials”.
2. Clique em “Create Credentials” → “OAuth client ID”.
3. Será exibida uma mensagem informando que você precisa configurar a tela de consentimento OAuth. Clique em “Configure consent screen”.

4.3.1 Configurar tela de consentimento OAuth

• User Type: selecione “Externally” se for um app público ou “Internally” se for restrito a usuários do seu domínio (caso seja G Suite). Geralmente escolhemos “Externally” para aplicações abertas.
• App Information:
  • App name: “MeuAppGoogleLogin”.
  • User support email: seu e-mail de contato.
  • App logo: opcional, mas pode adicionar um ícone simples para facilitar a identificação.
  • Developer contact information: adicione um e-mail para contato.
• Clique em “Save and Continue”.
• Nos campos “Scopes” e “Test users”, como este tutorial é para fins de desenvolvimento, não é necessário adicionar nada; basta acompanhar o processo clicando em “Save and Continue” e “Back to Dashboard”.

4.3.2 Criar o ID de cliente OAuth

1. De volta à página “Credentials”, clique em “Create credentials” → “OAuth client ID”.
2. Em “Application type”, selecione “Android”.
3. Em “Name”, informe algo como “Android Client for MeuApp”.
4. Package name: insira exatamente o mesmo que está no seu AndroidManifest.xml, por exemplo, “com.jovemprojeto.meuappgooglelogin”. Para conferir, abra o manifest e procure pelo atributo package.
5. SHA-1 certificate fingerprint: copie o SHA-1 gerado pelo seu keystore de debug (ou release). Para obter o SHA-1 do keystore de debug, execute no terminal (ou no “Terminal” do Android Studio) o comando:

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

   Copie a parte que diz SHA1: e cole no campo correspondente.

6. Clique em “Create”.
7. Será exibido o “Client ID” para Android. Anote-o, pois precisaremos em breve.

5. Ajustes no AndroidManifest.xml

Para permitir que o Google Sign-In funcione corretamente, algumas configurações no manifest são necessárias. Abra app/src/main/AndroidManifest.xml e adicione o seguinte dentro da tag <application>:

<meta-data android:name="com.google.android.gms.auth.app_id" android:value="@string/default_web_client_id" />

A linha acima faz referência ao web client ID que precisamos definir no arquivo de strings. Algumas pessoas se confundem achando que é o “Android Client ID”, mas, de fato, para obter um token válido, usamos o “Web Client ID” do OAuth. Para achar esse valor:

1. No Google Cloud Console, volte à página “Credentials”.
2. Procure por “OAuth 2.0 Client IDs” e localize o item cujo “Application type” é “Web application”. Caso não tenha criado ainda, crie um novo “Web application”:
   • Nome: “MeuAppWebClient”.
   • No campo “Authorized JavaScript origins”: deixe em branco (não se aplica para Android).
   • No campo “Authorized redirect URIs”: informe “https://oauth2.googleapis.com/token”.
   • Clique em “Create”.
3. Copie o valor do campo “Client ID” do tipo Web. Ele tem formato XXXXXXXXXXXXXXXXXXXXX-xxxxxx.apps.googleusercontent.com.

Em seguida, abra app/src/main/res/values/strings.xml e adicione:

<string name="default_web_client_id">XXXXXXXXXXXXXXXXXXXXX-xxxxxx.apps.googleusercontent.com</string>

Substitua “XXXXXXXXXXXXXXXXXXXXX-xxxxxx.apps.googleusercontent.com” pelo valor que você copiou. Isso garantirá que a autenticação com o Google utilize o client ID correto para gerar tokens de acesso e refresh.

6. Preparando o layout da interface de login

O próximo passo é criar uma interface simples que exiba o botão de Google Sign-In. Abra o arquivo app/src/main/res/layout/activity_main.xml e substitua o conteúdo pelo seguinte:

<?xml version="1.0" encoding="utf-8"?> <androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:app="http://schemas.android.com/apk/res-auto" xmlns:tools="http://schemas.android.com/tools" android:id="@+id/constraintLayout" android:layout_width="match_parent" android:layout_height="match_parent" tools:context=".MainActivity">
perl
Copiar
Editar
<com.google.android.gms.common.SignInButton
    android:id="@+id/btnGoogleSignIn"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_marginTop="24dp"
    app:layout_constraintTop_toTopOf="parent"
    app:layout_constraintStart_toStartOf="parent"
    app:layout_constraintEnd_toEndOf="parent" />

<TextView
    android:id="@+id/tvStatus"
    android:layout_width="0dp"
    android:layout_height="wrap_content"
    android:text="Você não está conectado"
    android:textSize="18sp"
    android:gravity="center"
    android:layout_marginTop="32dp"
    app:layout_constraintTop_toBottomOf="@+id/btnGoogleSignIn"
    app:layout_constraintStart_toStartOf="parent"
    app:layout_constraintEnd_toEndOf="parent" />

<ImageView
    android:id="@+id/ivProfile"
    android:layout_width="100dp"
    android:layout_height="100dp"
    android:layout_marginTop="24dp"
    android:visibility="gone"
    app:layout_constraintTop_toBottomOf="@+id/tvStatus"
    app:layout_constraintStart_toStartOf="parent"
    app:layout_constraintEnd_toEndOf="parent" />

<Button
    android:id="@+id/btnSignOut"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="Sair"
    android:visibility="gone"
    app:layout_constraintTop_toBottomOf="@+id/ivProfile"
    app:layout_constraintStart_toStartOf="parent"
    app:layout_constraintEnd_toEndOf="parent"
    android:layout_marginTop="24dp" />

Explicando cada elemento do layout:

• SignInButton: componente oficial do Google Play Services que exibe o botão “Sign in with Google” com estilo padronizado.
• TextView (tvStatus): usado para mostrar mensagens ao usuário, como “Você não está conectado” ou exibir o nome de quem fez login.
• ImageView (ivProfile): utilizado para carregar a foto de perfil do usuário após a autenticação.
• Button (btnSignOut): botão simples para realizar logout, reaparecendo somente após o usuário estar conectado.

7. Implementando a lógica de autenticação na MainActivity

Abra o arquivo app/src/main/java/com/jovemprojeto/meuappgooglelogin/MainActivity.java (ou o pacote equivalente do seu projeto) e substitua o conteúdo pelo código a seguir. Vamos comentar cada trecho para facilitar o entendimento.

package com.jovemprojeto.meuappgooglelogin;

import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;

import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.TextView;
import android.widget.Toast;

import com.bumptech.glide.Glide;
import com.google.android.gms.auth.api.Auth;
import com.google.android.gms.auth.api.signin.GoogleSignIn;
import com.google.android.gms.auth.api.signin.GoogleSignInAccount;
import com.google.android.gms.auth.api.signin.GoogleSignInClient;
import com.google.android.gms.auth.api.signin.GoogleSignInOptions;
import com.google.android.gms.auth.api.signin.GoogleSignInResult;
import com.google.android.gms.common.SignInButton;
import com.google.android.gms.common.api.ApiException;
import com.google.android.gms.tasks.OnCompleteListener;
import com.google.android.gms.tasks.Task;

public class MainActivity extends AppCompatActivity {

typescript
Copiar
Editar
private static final int RC_SIGN_IN = 100; // Código de requisição para autenticação
private GoogleSignInClient mGoogleSignInClient;
private SignInButton btnGoogleSignIn;
private TextView tvStatus;
private ImageView ivProfile;
private Button btnSignOut;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    // Inicializando componentes da interface
    btnGoogleSignIn = findViewById(R.id.btnGoogleSignIn);
    tvStatus = findViewById(R.id.tvStatus);
    ivProfile = findViewById(R.id.ivProfile);
    btnSignOut = findViewById(R.id.btnSignOut);

    // Configurando opções de sign-in do Google
    GoogleSignInOptions gso = new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
            .requestIdToken(getString(R.string.default_web_client_id)) // solicitado token JWT
            .requestEmail() // solicitar e-mail do usuário
            .build();

    // Obtendo cliente de sign-in
    mGoogleSignInClient = GoogleSignIn.getClient(this, gso);

    // Verifica se há usuário já logado
    GoogleSignInAccount account = GoogleSignIn.getLastSignedInAccount(this);
    if (account != null) {
        // Usuário já está conectado
        updateUI(account);
    }

    // Configurando clique no botão de sign-in
    btnGoogleSignIn.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {
            signIn();
        }
    });

    // Configurando clique no botão de sign-out
    btnSignOut.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {
            signOut();
        }
    });
}

// Método para iniciar fluxo de sign-in
private void signIn() {
    Intent signInIntent = mGoogleSignInClient.getSignInIntent();
    startActivityForResult(signInIntent, RC_SIGN_IN);
}

// Recebe resultado da intent de sign-in
@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    if (requestCode == RC_SIGN_IN) {
        Task<GoogleSignInAccount> task = GoogleSignIn.getSignedInAccountFromIntent(data);
        handleSignInResult(task);
    }
}

// Processa resultado do sign-in
private void handleSignInResult(Task<GoogleSignInAccount> completedTask) {
    try {
        GoogleSignInAccount account = completedTask.getResult(ApiException.class);
        // Login bem-sucedido, atualiza interface
        updateUI(account);
    } catch (ApiException e) {
        // Erro de autenticação, exibe mensagem para o usuário
        Toast.makeText(this, "Falha ao autenticar: " + e.getStatusCode(), Toast.LENGTH_SHORT).show();
        updateUI(null);
    }
}

// Atualiza UI com informações do usuário ou estado desconectado
private void updateUI(GoogleSignInAccount account) {
    if (account != null) {
        // Exibe foto e nome do usuário
        String displayName = account.getDisplayName();
        String email = account.getEmail();
        String photoUrl = (account.getPhotoUrl() != null) ? account.getPhotoUrl().toString() : "";

        tvStatus.setText("Olá, " + displayName + "\n(" + email + ")");
        btnGoogleSignIn.setVisibility(View.GONE);
        ivProfile.setVisibility(View.VISIBLE);
        btnSignOut.setVisibility(View.VISIBLE);

        // Carrega foto de perfil com Glide
        if (!photoUrl.isEmpty()) {
            Glide.with(this)
                    .load(photoUrl)
                    .circleCrop()
                    .into(ivProfile);
        } else {
            ivProfile.setImageResource(R.drawable.default_avatar);
        }
    } else {
        // Usuário não está conectado
        tvStatus.setText("Você não está conectado");
        btnGoogleSignIn.setVisibility(View.VISIBLE);
        ivProfile.setVisibility(View.GONE);
        btnSignOut.setVisibility(View.GONE);
    }
}

// Realiza logout e atualiza interface para estado desconectado
private void signOut() {
    mGoogleSignInClient.signOut()
            .addOnCompleteListener(this, new OnCompleteListener<Void>() {
                @Override
                public void onComplete(@NonNull Task<Void> task) {
                    updateUI(null);
                }
            });
}


}

Explicação detalhada:

• GoogleSignInOptions: definimos DEFAULT_SIGN_IN para obter informações básicas e solicitamos o ID Token com requestIdToken(), usando o Web Client ID presente em strings.xml. Também solicitamos email do usuário.
• GoogleSignInClient: objeto principal para iniciar o fluxo de login e logout.
• getLastSignedInAccount: método que verifica se já há um usuário autenticado em sessões anteriores; caso positivo, pulamos o fluxo de login e exibimos diretamente informações do usuário.
• startActivityForResult: inicia a intent padrão de login do Google; quando o usuário completar ou cancelar, o método onActivityResult será chamado.
• handleSignInResult: método que processa a resposta (callback). Se o login for bem-sucedido, obtemos um GoogleSignInAccount contendo dados do usuário; caso contrário, exibimos toast com código de erro.
• updateUI: função responsável por ajustar visibilidade de botões e exibir nome, email e foto do perfil. Utilizamos a biblioteca Glide (Glide) para carregar a imagem de forma otimizada e aplicar circleCrop, deixando a foto redonda.
• signOut: realiza logout chamando mGoogleSignInClient.signOut() e, ao completar, chama updateUI(null) para voltar ao estado inicial.

8. Adicionando permissões e configurações extras

Geralmente, o login do Google não requer permissões especiais além de acesso à internet. Contudo, vale a pena conferir:

8.1 Permissão de internet

No AndroidManifest.xml, certifique-se de ter a permissão:

<uses-permission android:name="android.permission.INTERNET"/>

Isso é necessário para que o Google Sign-In funcione corretamente e para carregar a foto de perfil usando Glide.

8.2 Tema da atividade

Em alguns casos, especialmente se seu aplicativo utiliza temas personalizados, certifique-se de que sua MainActivity use um tema derivado de Theme.MaterialComponents ou Theme.AppCompat. No styles.xml:

<style name="AppTheme" parent="Theme.MaterialComponents.Light.NoActionBar"> <item name="colorPrimary">#6200EE</item> <item name="colorPrimaryVariant">#3700B3</item> <item name="colorOnPrimary">#FFFFFF</item> </style>

No AndroidManifest.xml, atribua:

<application android:theme="@style/AppTheme" ... >

Isso garante que os componentes do Google Sign-In sejam exibidos corretamente.

9. Testando o aplicativo

Com toda a configuração pronta, vamos testar o app:

1. Conecte seu dispositivo Android via USB (modo desenvolvedor ativado) ou utilize emulador configurado com Google Play Services.
2. No Android Studio, clique em “Run” (triângulo verde) ou pressione Shift+F10. Selecione seu dispositivo/emulador e aguarde o build e instalação.
3. Ao abrir o app, você verá o botão “Sign in with Google”. Toque nele e selecione sua conta Google. Se tudo estiver configurado corretamente, em poucos segundos você será autenticado e verá seu nome, e-mail e foto de perfil exibidos na tela.
4. Clique no botão “Sair” para testar a lógica de logout. Após deslogar, o botão de login reaparecerá e a interface voltará ao estado inicial.

Se você encontrar erros como “API not configured” ou “SHA-1 mismatch”, revise suas credenciais no Google Cloud Console e verifique se o SHA-1 e o package name estão idênticos aos declarados no OAuth client do tipo Android.

10. Lidando com tokens e fusos de segurança

Após o login, além de exibir dados básicos do usuário, talvez você queira enviar o ID Token para seu servidor backend a fim de verificar a autenticidade e obter informações adicionais. Veja como extrair e usar esse token:

private void handleSignInResult(Task<GoogleSignInAccount> completedTask) { try { GoogleSignInAccount account = completedTask.getResult(ApiException.class); String idToken = account.getIdToken(); // Envie idToken ao seu servidor para validação sendIdTokenToServer(idToken); updateUI(account); } catch (ApiException e) { // ... } }

No lado do servidor, você deve validar o ID Token usando bibliotecas específicas, como o Google API Client para diversas linguagens (Java, Node.js, Python, PHP). Pesquise por “Google ID token verification” e encontrará exemplos de código para validar emissões, verificar assinatura e extrair dados:

• Java: GoogleIdTokenVerifier no SDK do Google API Client.
• Node.js: google-auth-library e método verifyIdToken().
• Python: google.oauth2.id_token e google.auth.transport.requests.

Validar o token no servidor impede que usuários mal-intencionados forjem dados de autenticação e garante maior segurança no uso de APIs sensíveis.

11. Integração com outras APIs do Google

Após autenticar o usuário, você pode aproveitar a mesma sessão para chamar outras APIs do Google. Por exemplo, para acessar o perfil completo ou recuperar informações do Google Drive:

11.1 Recuperar dados do Google People API

Se quiser obter dados adicionais, como contatos, foto em diferentes tamanhos ou localização:

1. Ative a People API no Google API Console.
2. Adicione escopos adicionais ao GoogleSignInOptions:

   GoogleSignInOptions gso = new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN) .requestIdToken(getString(R.string.default_web_client_id)) .requestEmail() .requestScopes(new Scope("https://www.googleapis.com/auth/userinfo.profile")) .build();

3. No callback de sign-in, utilize GoogleApiClient ou People API client para solicitar dados. Exemplo em Java:

   PeopleService peopleService = new PeopleService.Builder( AndroidHttp.newCompatibleTransport(), new GsonFactory(), credential) .setApplicationName("MeuAppGoogleLogin") .build();
   
   Person profile = peopleService.people().get("people/me")
   .setPersonFields("names,emailAddresses,photos").execute();

   Você precisa de credential obtida via GoogleAccountCredential com escopo “https://www.googleapis.com/auth/userinfo.profile”.

Para instruções detalhadas sobre como integrar o People API, consulte a documentação oficial em Google People API Android.

11.2 Acessar Google Drive ou Google Calendar

Da mesma forma, caso seu app necessite acesso ao Google Drive para armazenamento em nuvem ou leitura de arquivos, aprenda a usar o Drive API:

• Ative o Drive API no Google Cloud Console.
• Adicione escopos no GoogleSignInOptions, por exemplo:

  .requestScopes(new Scope(DriveScopes.DRIVE_FILE))

• Use a biblioteca oficial do Google Drive API para Android (Drive API Android client library).

O mesmo vale para o Calendar API e demais serviços, bastando ativá-los no console e requisitar escopos adequados.

12. Personalizando o botão de login do Google

Por padrão, o SignInButton exibe o texto “Sign in with Google” em inglês. Se você quiser personalizar para “Entrar com Google” em português, existem duas abordagens:

12.1 Usar tema e estilo

Você pode alterar o texto do botão definindo atributos no código Java:

btnGoogleSignIn.setSize(SignInButton.SIZE_WIDE); btnGoogleSignIn.setColorScheme(SignInButton.COLOR_DARK);

TextView textView = (TextView) btnGoogleSignIn.getChildAt(0);
textView.setText("Entrar com Google");

Essa abordagem acessa internamente o TextView do SignInButton e o altera para o texto desejado. É simples, mas não oficial, pois dependenmos da posição fixa do TextView dentro do componente. Caso o Google atualize internamente, pode haver necessidade de ajustes.

12.2 Criar botão personalizado

Para total liberdade, crie seu próprio botão utilizando Button ou MaterialButton. Exemplo em XML:

<com.google.android.material.button.MaterialButton android:id="@+id/btnCustomGoogleSignIn" style="@style/Widget.MaterialComponents.Button.OutlinedButton" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Entrar com Google" app:icon="@drawable/ic_google_logo" app:iconPadding="8dp" app:iconTint="@null" app:layout_constraintTop_toTopOf="parent" app:layout_constraintStart_toStartOf="parent" app:layout_constraintEnd_toEndOf="parent" />

No script, substitua a referência ao SignInButton por esse MaterialButton e mantenha o fluxo de chamada a signIn(). Assim, você tem total controle sobre cor, tamanho, texto e posicionamento.

13. Tratamento de erros e edge cases

Para garantir uma experiência robusta, trate possíveis falhas comuns:

13.1 Sem conexão com a internet

Verifique se o dispositivo está online antes de iniciar o login. Exemplo de método para checar conectividade:

private boolean isNetworkAvailable() { ConnectivityManager connectivityManager = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE); NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo(); return activeNetworkInfo != null && activeNetworkInfo.isConnected(); }

Antes de chamar signIn(), faça:

if (isNetworkAvailable()) { signIn(); } else { Toast.makeText(this, "Sem conexão com a internet", Toast.LENGTH_SHORT).show(); }

Isso impede que o app tente se autenticar sem acesso à rede, evitando erros e frustração do usuário.

13.2 Exceções inesperadas

Mesmo que todo o fluxo esteja configurado corretamente, podem ocorrer exceções diversas. Para melhorar a robustez, envolva as chamadas sensíveis em blocos try-catch e registre logs completos no console:

try { Task<GoogleSignInAccount> task = GoogleSignIn.getSignedInAccountFromIntent(data); handleSignInResult(task); } catch (Exception ex) { Log.e("MainActivity", "Erro ao processar sign-in", ex); Toast.makeText(this, "Ocorreu um erro inesperado. Tente novamente.", Toast.LENGTH_SHORT).show(); }

Isso ajuda a identificar rapidamente a origem do problema ao consultar o Logcat do Android Studio.

13.3 Revogando acesso

Caso deseje dar ao usuário a opção de revogar permissão de acesso ao app (fora do fluxo de sign-out), utilize:

mGoogleSignInClient.revokeAccess() .addOnCompleteListener(this, new OnCompleteListener<Void>() { @Override public void onComplete(@NonNull Task<Void> task) { // Acesso revogado, atualiza UI updateUI(null); Toast.makeText(MainActivity.this, "Acesso revogado com sucesso", Toast.LENGTH_SHORT).show(); } });

Isso faz com que o token de autorização seja invalidado e o usuário precise conceder novamente as permissões caso queira entrar com Google no futuro.

14. Gerando APK de release e assinando o aplicativo

Após concluir testes e garantir que tudo funciona corretamente no modo debug, você deve gerar uma versão de release assinada antes de publicar na Google Play ou distribuir para usuários finais. Siga estes passos:

14.1 Criar keystore de release

1. No Android Studio, vá em Build → Generate Signed Bundle / APK….
2. Selecione “APK” e clique em “Next”.
3. Clique em “Create new…” para criar um novo Key Store:
   • Key store path: escolha a pasta e informe um nome, por exemplo “meuappkeystore.jks”.
   • Password: crie uma senha forte (anote em local seguro).
   • Key alias: ex: “meuappkey”.
   • Key password: senha para a chave (pode ser a mesma do keystore ou diferente).
   • Validity (anos): informe 25 anos ou mais para garantir longevidade.
   • Preencha campos de “First and Last Name”, “Organization Unit”, “Organization”, “Country Code” etc. São apenas para identificação e podem ser fictícios.
4. Clique em “OK” para criar o keystore. O Android Studio retornará à janela principal de geração de APK.
5. Selecione o keystore recém-criado, informe alias e senhas e clique em “Next”.

14.2 Configurar build de release

No diálogo “Generate Signed Bundle or APK”, selecione “release” em “Build Type” e marque “V1 (Jar Signature)” e/ou “V2 (Full APK Signature)” — o Android recomenda usar ambas para máxima compatibilidade. Clique em “Finish”.

O Android Studio irá compilar uma versão otimizada do aplicativo, incluindo obfuscação e otimizações de recursos. Ao finalizar, exibirá o caminho do APK de release gerado, por exemplo:

/path/to/project/app/release/app-release.apk

Esse APK já está pronto para distribuição. Caso faça atualizações futuras, mantenha o mesmo keystore e chave; caso contrário, usuários que já tiverem instalado a versão anterior não poderão atualizar para a nova.

15. Publicando na Google Play Store

Para levar seu app ao público, siga as diretrizes da Google Play:

15.1 Conta de desenvolvedor

• É necessário ter uma Conta de Desenvolvedor Google Play. Acesse Google Play Console e faça o registro, que possui custo de US$25 (um único pagamento).
• Após registrar a conta, faça login no Play Console.

15.2 Criar um App no Play Console

1. No painel do Play Console, clique em “Create App”.
2. Informe:
   • Nome do aplicativo: “MeuAppGoogleLogin”.
   • Idioma padrão: Português (Brasil).
   • Conta de desenvolvedor: selecione sua conta.
   • Tipo de app: Aplicativo ou Jogo (escolha “Aplicativo”).
   • Política de Conteúdo: marque se seu app fornece conteúdo pago ou gratuito.
3. Clique em “Create App”.

15.3 Preenchendo informações do app

• Ficha de inscrição: crie uma breve descrição (até 80 caracteres) e descrição completa (até 4000 caracteres). Explique o propósito do app e destaque o recurso de login com Google.
• Grupos de usuários: selecione se o app é para público geral ou crianças; se for para crianças, observe diretrizes de privacidade específicas da Play Store.
• Icone e screenshots: crie um ícone em 512x512px com transparência, preferencialmente no estilo Material Design. Tire capturas de telas do app mostrando a interface de login, tela logada com nome e foto do usuário e botão de logout. As imagens devem estar em 24-bit PNG.
• Página de listagem: adicione um banner de 1024x500px e, opcionalmente, um vídeo promocional no YouTube.
• Detalhes adicionais: categorias (por exemplo, “Produtividade”), conteúdo e classificação etária, termos de privacidade (link para política de privacidade em site próprio ou repositório, se aplicável).

15.4 Enviando APK ou App Bundle

1. No menu lateral, clique em “Release” → “Production” → “Create new release”.
2. Escolha enviar um Android App Bundle (.aab) em vez de APK, pois gera pacotes otimizados para cada dispositivo; contudo, você ainda pode enviar o APK de release gerado anteriormente.
3. Faça o upload do arquivo e preencha as notas de lançamento, informando versão (por exemplo, “Versão 1.0 – Lançamento inicial com Google Sign-In”).
4. Clique em “Save” e depois em “Review release”.
5. Após verificar que não há erros, clique em “Start rollout to production” e confirme “Rollout” para iniciar o processo de publicação.

A aprovação pode levar algumas horas ou até dias, dependendo da análise do Google. Fique atento a e-mails de feedback ou solicitações de ajuste, caso a equipe de revisão encontre problemas.

16. Boas práticas de UX e design para tela de login

Para entregar uma experiência agradável e incentivar o uso do login com Google, leve em consideração:

16.1 Feedback visual para carregamento

Quando o usuário clicar em “Entrar com Google”, exiba um indicador de progresso ou carregamento (por exemplo, ProgressBar) para mostrar que a autenticação está em andamento. No layout, inclua:

<ProgressBar android:id="@+id/progressBar" android:layout_width="wrap_content" android:layout_height="wrap_content" android:visibility="gone" app:layout_constraintTop_toTopOf="parent" app:layout_constraintEnd_toEndOf="parent" app:layout_constraintStart_toStartOf="parent" android:layout_marginTop="16dp" />

No signIn(), antes de chamar a intent, faça:

progressBar.setVisibility(View.VISIBLE); btnGoogleSignIn.setEnabled(false);

E, dentro de handleSignInResult, ao final de cada caminho (sucesso ou falha), esconda o indicador:

progressBar.setVisibility(View.GONE); btnGoogleSignIn.setEnabled(true);

Assim, o usuário entende que algo está acontecendo e evita múltiplos cliques.

16.2 Mensagens de erro claras

Evite exibir códigos de erro numéricos para o usuário final. Em vez de mostrar “Falha ao autenticar: 12501”, preferível seria:

catch (ApiException e) { int statusCode = e.getStatusCode(); String message; switch(statusCode) { case GoogleSignInStatusCodes.SIGN_IN_CANCELLED: message = "Login cancelado pelo usuário."; break; case GoogleSignInStatusCodes.SIGN_IN_FAILED: message = "Falha na autenticação. Tente novamente."; break; default: message = "Ocorreu um erro inesperado. Tente novamente."; break; } Toast.makeText(this, message, Toast.LENGTH_SHORT).show(); updateUI(null); }

Dessa forma, o usuário entende o que aconteceu sem precisar interpretar códigos.

16.3 Acessibilidade

Considere usuários com necessidades especiais:

• Suporte a TalkBack: defina descrições acessíveis (atributo android:contentDescription) para botões e imagens:

  <com.google.android.gms.common.SignInButton ... android:contentDescription="Botão para entrar com Google" />
  
  

• Contraste de cores: garanta que textos brancos sobre fundo colorido sejam legíveis.
• Tamanho de fonte ajustável: use unidades sp em vez de dp para textos, permitindo que usuários ampliem configurações de fonte no dispositivo.

17. Integração com Retrofit para comunicação com seu backend

Na maioria dos aplicativos, após a autenticação, você deseja enviar o token do usuário ao seu servidor para autenticação adicional, criação de sessão ou vincular dados ao perfil. Para isso, utilizamos a biblioteca Retrofit para simplificar chamadas HTTP. Veja como configurar:

17.1 Adicionando dependências do Retrofit

No app/build.gradle, inclua:

implementation 'com.squareup.retrofit2:retrofit:2.9.0' implementation 'com.squareup.retrofit2:converter-gson:2.9.0' implementation 'com.squareup.okhttp3:logging-interceptor:4.9.3'

Em seguida, sincronize o Gradle.

17.2 Criando a interface da API

Suponha que seu backend possua um endpoint para validar o token Google em:

POST https://api.meuservidor.com/auth/google

O corpo da requisição recebe um JSON como:

{ "idToken": "ID_TOKEN_DO_GOOGLE" }

O servidor retorna um JSON com dados do usuário no seu sistema, por exemplo:

{ "userId": "12345", "name": "João Silva", "email": "joao@gmail.com", "token": "TOKEN_JWT_DO_SEU_SERVIDOR" }

No pacote de scripts, crie o arquivo ApiService.java:

package com.jovemprojeto.meuappgooglelogin.network;

import retrofit2.Call;
import retrofit2.http.Body;
import retrofit2.http.Headers;
import retrofit2.http.POST;

public interface ApiService {

less
Copiar
Editar
@Headers("Content-Type: application/json")
@POST("auth/google")
Call<ServerResponse> signInWithGoogle(@Body GoogleTokenRequest request);


}

Crie também as classes de modelo:

package com.jovemprojeto.meuappgooglelogin.network;

public class GoogleTokenRequest {
private String idToken;

arduino
Copiar
Editar
public GoogleTokenRequest(String idToken) {
    this.idToken = idToken;
}


}

package com.jovemprojeto.meuappgooglelogin.network;

public class ServerResponse {
private String userId;
private String name;
private String email;
private String token;

cpp
Copiar
Editar
// Getters e setters


}

17.3 Configurando RetrofitClient

Crie a classe RetrofitClient.java para gerar instância singleton do Retrofit:

package com.jovemprojeto.meuappgooglelogin.network;

import okhttp3.OkHttpClient;
import okhttp3.logging.HttpLoggingInterceptor;
import retrofit2.Retrofit;
import retrofit2.converter.gson.GsonConverterFactory;

public class RetrofitClient {

java
Copiar
Editar
private static Retrofit retrofit = null;
private static final String BASE_URL = "https://api.meuservidor.com/";

public static ApiService getApiService() {
    if (retrofit == null) {
        // Adiciona interceptor para logar requisições/respostas
        HttpLoggingInterceptor logging = new HttpLoggingInterceptor();
        logging.setLevel(HttpLoggingInterceptor.Level.BODY);
        OkHttpClient client = new OkHttpClient.Builder()
                .addInterceptor(logging)
                .build();

        retrofit = new Retrofit.Builder()
                .baseUrl(BASE_URL)
                .addConverterFactory(GsonConverterFactory.create())
                .client(client)
                .build();
    }
    return retrofit.create(ApiService.class);
}


}

17.4 Enviando token ao servidor

No MainActivity.java, modifique o método handleSignInResult para chamar seu backend assim que o usuário se autenticar localmente:

private void handleSignInResult(Task<GoogleSignInAccount> completedTask) { try { GoogleSignInAccount account = completedTask.getResult(ApiException.class); String idToken = account.getIdToken(); // Envia token ao servidor sendIdTokenToServer(idToken); updateUI(account); } catch (ApiException e) { // ... } }

// Envia token para seu servidor
private void sendIdTokenToServer(String idToken) {
ApiService apiService = RetrofitClient.getApiService();
GoogleTokenRequest request = new GoogleTokenRequest(idToken);
apiService.signInWithGoogle(request).enqueue(new Callback() {
@Override
public void onResponse(Call call, Response response) {
if (response.isSuccessful() && response.body() != null) {
ServerResponse serverResponse = response.body();
// Armazene informações retornadas (JWT, userId) em SharedPreferences
saveSession(serverResponse);
Toast.makeText(MainActivity.this, "Login no servidor bem-sucedido", Toast.LENGTH_SHORT).show();
} else {
Toast.makeText(MainActivity.this, "Falha no login no servidor", Toast.LENGTH_SHORT).show();
}
}

java
Copiar
Editar
    @Override
    public void onFailure(Call<ServerResponse> call, Throwable t) {
        Toast.makeText(MainActivity.this, "Erro de rede: " + t.getMessage(), Toast.LENGTH_SHORT).show();
    }
});


}

// Exemplo de método para salvar sessão em SharedPreferences
private void saveSession(ServerResponse serverResponse) {
SharedPreferences sharedPref = getSharedPreferences("meuAppPrefs", MODE_PRIVATE);
SharedPreferences.Editor editor = sharedPref.edit();
editor.putString("userId", serverResponse.getUserId());
editor.putString("userName", serverResponse.getName());
editor.putString("userEmail", serverResponse.getEmail());
editor.putString("userToken", serverResponse.getToken());
editor.apply();
}

Explicação:

• enqueue: método assíncrono do Retrofit que envia a requisição e chama onResponse ou onFailure conforme o resultado.
• saveSession: exemplo simples de como armazenar dados em SharedPreferences para manter o usuário logado e autorizar chamadas subsequentes ao seu backend usando o token JWT retornado.

18. Mantendo usuário logado entre sessões do app

Para evitar que o usuário precise fazer login toda vez que abrir o app, podemos checar, no onCreate da MainActivity, se existe um token JWT válido armazenado em SharedPreferences. Exemplo:

@Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState);
java
Copiar
Editar
// Verifica session no SharedPreferences
SharedPreferences sharedPref = getSharedPreferences("meuAppPrefs", MODE_PRIVATE);
String jwtToken = sharedPref.getString("userToken", null);
if (jwtToken != null) {
    // Usuário já está logado no servidor, redireciona para tela principal do app
    Intent intent = new Intent(MainActivity.this, HomeActivity.class);
    startActivity(intent);
    finish();
    return;
}

setContentView(R.layout.activity_main);
// ... restante do onCreate conforme antes


}

Quando o usuário fizer logout, além de chamar mGoogleSignInClient.signOut(), remova o token JWT:

private void signOut() { mGoogleSignInClient.signOut().addOnCompleteListener(this, new OnCompleteListener<Void>() { @Override public void onComplete(@NonNull Task<Void> task) { // Remove session SharedPreferences sharedPref = getSharedPreferences("meuAppPrefs", MODE_PRIVATE); SharedPreferences.Editor editor = sharedPref.edit(); editor.clear(); editor.apply(); updateUI(null); } }); }

Assim, quando o usuário iniciar o aplicativo novamente, será redirecionado à tela de login caso não tenha token válido salvo.

19. Exibindo dados personalizados na HomeActivity

Crie uma nova atividade chamada HomeActivity para exibir informações específicas após o login no servidor. Exemplo de layout em app/src/main/res/layout/activity_home.xml:

<?xml version="1.0" encoding="utf-8"?> <androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:app="http://schemas.android.com/apk/res-auto" xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent" android:layout_height="match_parent" tools:context=".HomeActivity">
perl
Copiar
Editar
<TextView
    android:id="@+id/tvWelcome"
    android:layout_width="0dp"
    android:layout_height="wrap_content"
    android:text="Bem-vindo!"
    android:textSize="20sp"
    android:textStyle="bold"
    android:gravity="center"
    android:layout_marginTop="32dp"
    app:layout_constraintTop_toTopOf="parent"
    app:layout_constraintStart_toStartOf="parent"
    app:layout_constraintEnd_toEndOf="parent" />

<Button
    android:id="@+id/btnLogoutHome"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="Sair"
    app:layout_constraintTop_toBottomOf="@+id/tvWelcome"
    app:layout_constraintStart_toStartOf="parent"
    app:layout_constraintEnd_toEndOf="parent"
    android:layout_marginTop="24dp" />

Agora, crie a classe HomeActivity.java:

package com.jovemprojeto.meuappgooglelogin;

import androidx.appcompat.app.AppCompatActivity;
import android.content.Intent;

import android.content.SharedPreferences;

import android.os.Bundle;

import android.view.View;

import android.widget.Button;

import android.widget.TextView;
public class HomeActivity extends AppCompatActivity {
java

Copiar

Editar

private TextView tvWelcome;

private Button btnLogoutHome;
@Override

protected void onCreate(Bundle savedInstanceState) {

    super.onCreate(savedInstanceState);

    setContentView(R.layout.activity_home);
    tvWelcome = findViewById(R.id.tvWelcome);

    btnLogoutHome = findViewById(R.id.btnLogoutHome);
    // Recupera nome do usuário do SharedPreferences

    SharedPreferences sharedPref = getSharedPreferences("meuAppPrefs", MODE_PRIVATE);

    String name = sharedPref.getString("userName", "Usuário");

    String email = sharedPref.getString("userEmail", "");
    tvWelcome.setText("Bem-vindo, " + name + " (" + email + ")!");
    btnLogoutHome.setOnClickListener(new View.OnClickListener() {

        @Override

        public void onClick(View view) {

            // Limpa sessão e volta para MainActivity

            SharedPreferences.Editor editor = sharedPref.edit();

            editor.clear();

            editor.apply();
            // Faz logout do Google

            GoogleSignIn.getClient(HomeActivity.this, new GoogleSignInOptio