Utilizando o Google SignIn em Projetos Android

É fato concreto que o interesse por desenvolvimento de aplicações para dispositivos móveis mais robustas tem necessitado amplo conhecimento dos desenvolvedores, já que, somente no Brasil, aproximadamente 91% dos dispositivos móveis são equipados com alguma versão do Google Android. Com tanto mercado, a quantidade de ataques a mesma plataforma também é grande, exigindo segurança o suficiente para evitar ações de usuários mal-intencionados.

Neste artigo ensinaremos como utilizar as API’s Google para fornecer às suas aplicações e aos usuários os recursos de autenticação do Google, provendo um meio seguro, elevando a aceitação das aplicações e melhorando sua avaliação diante de um mercado cada vez mais exigente e preocupado com a segurança dos dados.

Antes de prosseguirmos veremos uma breve explicação sobre o Android SDK, utilizado para os exemplos deste artigo. Para a correta aplicação da técnica proposta neste artigo é necessário mais conhecimento teórico do que prático, contudo, nas etapas finais serão apresentadas implementações que demonstram como realizar aquilo que se propõe no texto.

Android SDK

Trata-se de um ótimo ambiente de desenvolvimento e que precisa ser sempre atualizado quando o Google lança uma nova versão do Android, já que um novo SDK correspondente também é liberado. Tão embora este permita escrever programas através do prompt de comando, a maneira mais comum de utilizá-lo é através de algum ambiente de desenvolvimento integrado (IDE), como Eclipse ou IntelliJ. Como as aplicações são escritas em Java é necessário também ter o JDK instalado, que é o pacote com toda a infraestrutura necessária para o desenvolvimento da linguagem.

API’s Google

Preocupada com a comunidade desenvolvedora, a Google realizou uma série de atualizações em suas API’s, buscando fornecer uma série de facilidades e com isso realizar a construção de aplicativos que utilizam os recursos sign-in.

Ao criar um aplicativo que faça requisição do Google Login, veremos um código mais fácil de entender e manter. Em versões anteriores, ao desenvolver uma aplicação que utilizasse o GoogleApiClient, exigia-se que o usuário estivesse logado em sua conta no Google, onde o mesmo se deparava com uma série de diálogos e permissões que podiam acarretar em uma falha de conexão. Seria necessário então criar uma série de controles para lidar com isso.

Com as alterações realizadas na API, o código pode ser simplificado de forma significante, pois os processos de validação e conexão através do GoogleApiClient agora são tratados separadamente. A validação pode ser realizada através de um objeto GoogleSignInOption, onde podemos especificar vários parâmetros da operação, tal como o escopo que se deseja.

Iniciando o Projeto

Vamos iniciar o projeto partindo que o Android e o JDK estejam instalados na máquina. Caso ainda não tenha, acompanhe um dos tutoriais de android do site.

Além disso devemos realizar algumas configurações no ambiente de desenvolvimento e para isto, siga os passos a seguir:

1. Passo 1: acesse o SDK Manager, como demonstrado na Figura 1;
   
   Figura 1. SDM Manager.
2. Passo 2: selecione a opção Android SDK no menu à esquerda e, em seguida, vá a aba SDK Tools. Nesta selecione a opção Google Play Services e clique em Apply ->OK, como é demonstrado na Figura 2:
   
   Figura 2. Instalando o Google Play Services.
3. Passo 3: caso não possua, baixe o git (vide seção Links);
4. Passo 4: abra as configurações do Android SDK, conforme mostra a Figura 3.
   
   Figura 3. Acessando as configurações do Android SDK.
   Nas configurações, selecione no menu lateral esquerdo a opção Git e na tela a direita indique o caminho do executável, como pode ser visto na Figura 4.
   
   Figura 4. Integrando o Git ao Android SDK.

Precisamos testar a clonagem de repositório, que usaremos no nosso projeto. Para isso podemos usar um exemplo disponibilizado pela própria Google.

O exemplo pode ser baixado em seu próprio repositório, então primeiro, no seu computador selecione a pasta onde serão baixados os arquivos (no Windows abra o Windows Explorer, escolha a pasta, clique com o botão direito sobre ela) e escolha a opção Clone Existing Repository, como é mostrado na Figura 5. Em seguida, configure o endereço do repositório e o nome da pasta final para onde os arquivos serão copiados, conforme mostra a Figura 6.

Figura 5. Abrindo a Interface do Git

Figura 6. Adicionando caminho do repositório e clonando

A seguir abra o exemplo baixado pelo Git, indo em File>Open e encontre a pasta onde foi salvo o projeto, como mostra a Figura 7.

Figura 7. Abrindo projeto existente.

Web Client ID

Agora precisamos criar um Web Client ID para então criarmos o nosso arquivo JSON com as nossas credenciais, essenciais para a autenticação da aplicação.

Para executar a aplicação de exemplo deste artigo serão utilizados os seguintes recursos da Google API: IdTokenActivity e ServerAuthCodeActivity. Para que estes objetos funcionem, torna-se necessário especificar um OAuth 2.0 web client ID. Em qualquer outra aplicação real, este client ID representaria o servidor back-end do aplicativo.

Para começar a criação abra a página de credenciamento e na opção selecione um projeto escolha o projeto Default Demo App (default-demo-app-1eb0e), como é apresentado na Figura 8.

Figura 8. Obtendo um Client ID parte 1.

Caso queira criar o recurso para um projeto próprio, escolha a opção Criar um projeto.

Em seguida clique em Novas credenciais e escolha a opção ID do cliente OAuth, como pode ser visto na Figura 9.

Figura 9. Obtendo um Client ID parte 2.

NOTA: sem essa ID será impossível adquirir o arquivo google-services.json necessário para integração entre sua aplicação e determinadas API’s Google e que configuraremos a seguir.

Já na página que aparece, escolha a opção Aplicativo da Web e posteriormente escolha um nome qualquer, como pode ser visto na Figura 10. Clique em criar para concluir.

Figura 10. Obtendo um Client ID parte 3.

Após realizados esses passos, o cliente ID criado será exibido na tela, semelhante ao apresentado na Figura 11.

Figura 11. ID do cliente para serviços google.

Agora copie o valor destacado para dentro do arquivo string.xml (o arquivo encontra-se na pasta res>values) do projeto, como mostra a Figura 12.

Figura 12. Copiando ID do Cliente para dentro do arquivo strings.xml.

Gerando o SHA-1

Antes de prosseguirmos, precisamos obter o código SHA-1 do certificado para então gerar o arquivo JSON que veremos a seguir.

Para isso precisamos acessar o terminal do computador ou prompt de comando e ir até a pasta onde encontra-se o JDK.

Em seguida, dentro da pasta bin execute o comando a seguir:

 keytool -list -v -keystore c:\users\usuario\.android\debug.keystore -alias androiddebugkey -storepass android -keypass android 

Dependendo da configuração da máquina, o caminho pode ser diferente, então atenção ao local inserido no código apresentado. Realizado o procedimento, o código SHA-1 será apresentado no console como apresentado na Figura 13.

Figura 13. Obtendo o SHA-1 do Certificado Android.

Aguarde essa informação, pois a usaremos a seguir.

Arquivo google-services.json

Este arquivo contém as credenciais do programador e definições de configurações necessárias durante a conexão com o Google API Client.

Ainda logado em sua conta Google devemos acessar a página de geração do arquivo - Clique aqui e selecionar o pacote com.google.samples.quickstart.signin. Clique no botão choose and configure services, como apresentado na Figura 14.

Figura 14. Obtendo arquivo google-services.json parte 1.

Na página seguinte escolha a opção Google Sign-In e preencha com o código SHA-1 do Android Signing Cerficicate, que obtemos na seção anterior, como apresentado na Figura 15.

Figura 15. Obtendo arquivo google-services.json parte 2.

Por fim, na página que será aberta, realize o download do arquivo google-services.json e copie-o para a pasta app/ ou mobile/ do projeto.

Feche e abra o projeto novamente e clique no botão run, como apresentado na Figura 16.

Figura 16. Executando a aplicação exemplo.

Uma vez executados os passos anteriores corretamente, a tela da Figura 17 será apresentada.

Figura 17. Saída apresentada pelo exemplo exposto.

Com esses passos conseguimos dar acesso ao nosso projeto as APIs do Google.

Funcionamento

Basicamente o aplicativo cria um objeto GoogleApiClient, onde são especificadas as opções de sessão necessárias. Assim sendo, quando o comando para início de sessão é disparado, a aplicação inicia um Intent sing-in, que envia uma solicitação ao usuário para que o mesmo entre com uma conta do Google. Veja o código apresentado na Listagem 1.

Listagem 1. Configurando o GoogleSignInOptions.

  1. GoogleSignInOptions gso = new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
  2.         .requestEmail()
  3.         .build();
  4. 
  5. mGoogleApiClient = new GoogleApiClient.Builder(this) .enableAutoManage(this, this)
  6.         .addApi(Auth.GOOGLE_SIGN_IN_API, gso)
  7.        .build();
  8. 
  9. private void signIn() {
  10.     Intent signInIntent = Auth.GoogleSignInApi.getSignInIntent(mGoogleApiClient);
  11.    startActivityForResult(signInIntent, RC_SIGN_IN);
  12. }

Da linha 1 a linha 4 é definido e criado um objeto GoogleSignInOptions, que recebe as configurações básicas DEFAULT_SIGN_IN, requerendo somente o e-mail do usuário. Já da linha 5 até 7 é então instanciado o objeto que controla a API do cliente. Nota-se que o método enableAutoManage recebe duas referências de this: a primeira é referente à um fragmento do Activity e o segundo um ouvinte para falhas de conexão. Por fim, nas linhas 9 a 12 é criado o método signIn, que inicia um Intent, que efetivamente irá disparar o comando que solicitará ao usuário que realize sua autenticação no sistema.

Integrando o Google SignIn a sua Aplicação Android

Para que sua aplicação utilize os recursos do Google SignIn será necessário verificar outros pré-requisitos e configurar o projeto no Android Studio, antes de realizar efetivamente a integração de tais recursos à aplicação.

A seguir temos um checklist que oferece o auxílio necessário para que pequenas falhas não sejam cometidas:

• Para desenvolvimento de uma aplicação que faça uso de tais recursos, é necessário um dispositivo Android compatível com a versão 2.3 ou mais recente do sistema, e que inclua o Google Play Store ou um emulador com um Ambiente Visual de Desenvolvimento que execute a plataforma Google API’s, baseados no Android 4.2.2 ou superior e que tenha a versão do Google Services Play 8.4.0 ou mais recente;
• A mais recente versão do Android SDK, incluindo os componentes do SDK Tools, que estão disponíveis no gerenciador do Android SDK do Android Studio;
• O projeto deve ser configurado para executar na versão 2.3 (Gingerbread) ou superior;
• Arquivo de configuração pode ser baixado anteriormente e copiado para sua pasta de destino; e

Para o Google Services Play SDK:

• No Android Studio selecione: Tools > Android > SDK Manager.
• Navegue até a parte inferior da lista de pacotes e escolha: Extras > Google Play services. O pacote será baixado e instalado em seu ambiente SDK na pasta-do-android sdk/extras/Google/google_play_services, conforme vimos no início deste artigo.

Adicionando o Google Services PlugIn

O plug-in do Google Services analisa as informações de configuração do arquivo google-services.json. Para que o plug-in seja corretamente adicionado ao projeto é necessário atualizar o build.gradle de nível superior e os build.gradle de nível de aplicação. Para fazê-lo, oriente-se pelas Figuras 18 a 20 e Listagens 2 e 3, respectivamente.

Figura 18. Localização dos arquivos de Gradle.

Listagem 2. Adicionando a dependência ao build.gradle de projeto (Project:signin).

  1. dependencies{
  2. classpath ‘com.android.tools.build:gradle:2.0.0-alpha6’
  3. classpath ‘com.google.gms:google-services:2.0.0-alpha6’
  4.}  

Figura 19. Exemplo do arquivo build.gradle de projeto.

Listagem 3. Adicionando o plug-in e dependência ao build.gradle de aplicação

  1.apply plugin: 'com.google.gms.google-services' 
  2.apply plugin: 'com.android.application'
  3.    dependencies {
  4.        compile 'com.google.android.gms:play-services-auth:8.4.0'
  5.    }  

Figura 20. Exemplo do arquivo build.gradle de aplicação.

Configurando o Google SignIn e o Objeto GoogleApiClient

Para que o sistema de login do Google seja integrado a aplicação Android, deve-se configurar um botão com o login do Google para que se adapte ao layout da aplicação.

A correta configuração do Google SignIn no método onCreate da aplicação fará com que o objeto solicite corretamente ao usuário os dados necessários para utilização do aplicativo. Pode-se, por exemplo, configurar o Google SignIn para solicitar ao usuário seu ID e demais informações básicas de seu perfil. Basta criar um objeto GoogleSignInOptions com o parâmetro DEFAULT_SIGN_IN.

Caso haja necessidade de solicitar dados adicionais para acessar as API’s do Google, então os mesmos devem ser especificados com um requestScopes, como ano exemplo da Listagem 4.

Listagem 4. Alterando o escopo do GoogleSigninOptions.

  GoogleSignInOptions gso = new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN).requestScopes(new Scope(Scopes.DRIVE_APPFOLDER)).requestEmail().build();  

O código adiciona aos dados básicos retornados a pasta onde está armazenada a aplicação cliente.

Para adicionar o botão Google SignIn a aplicação use o código da Listagem 5. Adicione-o ao arquivo activity_main.xml, localizado na pasta res>layout de seu projeto.

Listagem 5. Adicionando botão signin ao layout do projeto.

  1. <com.google.android.gms.common.SignInButton
  2. android:id="@+id/sign_in_button"
  3. android:layout_width="wrap_content"
  4. android:layout_height="wrap_content" />   

Veja que criamos um botão simples, mas caso haja o desejo de se utilizar um botão personalizado para a aplicação é possível realizar tais atividades através dos métodos setSize e setScopes, como pode ser visto na Listagem 6.

Listagem 6. Personalizando o botão de login.

  1. SignInButton signInButton = (SignInButton) findViewById(R.id.sign_in_button);
  2. signInButton.setSize(SignInButton.SIZE_STANDARD);
  3. signInButton.setScopes(gso.getScopeArray()); 

Na linha 1 é criado o objeto SignInButton e em seguida define-se o tamanho do botão. Na linha 3 temos um array com seu escopo.

E para complementar podemos adicionar o listener para o clique do botão, que preferencialmente será adicionado no método onCreate da aplicação, de acordo com o código a seguir:

findViewById(R.id.sign_in_button).setOnClickListener(this); 

Iniciando o Fluxo do SignIn

Realizadas as configurações e preparações indicadas pode-se então efetivamente iniciar o processo de implementação e integração do sistema de autenticação de usuários através do Google SignIn ao aplicativo em desenvolvimento. Deve-se inicialmente criar no método onClick um Intent como método getSignInIntent e inicializá-lo com o método startActivityForResult, como mostra a Listagem 7.

Listagem 7. Iniciando o processo de autenticação do usuário.

  1. @Override
  2. public void onClick(View v) {
  3.     switch (v.getId()) {
  4.         case R.id.sign_in_button:
  5.         signIn();
  6.            break;
  7.    }
  8.}
  9.
  10. private void signIn() {
  11.    Intent signInIntent = Auth.GoogleSignInApi.getSignInIntent(mGoogleApiClient);
  12.     startActivityForResult(signInIntent, RC_SIGN_IN);
  13. }

O código compreendido entre as linhas 1 e 8 realizam uma única atividade, anunciando que o método onClick será sobrescrito, dando ao mesmo uma nova implementação. Em seguida, verifica-se o valor retornado pelo método getId do objeto View: sendo o ID retornado, referente ao ID do objeto sign_in_button, então o método signIn é disparado. Nas linhas 10 a 12 tem-se então a implementação do método signIn que vimos anteriormente.>

Ao ser iniciado, o Intent solicita ao usuário que o mesmo selecione uma conta Google para que seja realizada sua autenticação: caso durante a configuração do objeto GoogleSignInOptions tenham sido solicitadas informações além das básicas, o usuário terá também que fornecer estas informações. Para controlar o resultado do processo de autenticação é necessário verificar o método onActivityResult, que deve ser implementado em conjunto com o getSignInResultFromIntent, conforme mostra a Listagem 8.

Listagem 8. Recuperando o resultado da autenticação.

  1. @Override
  2. public void onActivityResult(int requestCode, int resultCode, Intent data) {
  3.     super.onActivityResult(requestCode, resultCode, data);
  4. 
  5.     if (requestCode == RC_SIGN_IN) {
  6.         GoogleSignInResult result = Auth.GoogleSignInApi.getSignInResultFromIntent(data);
  7.         handleSignInResult(result);
  8.     }
  9. }

Inicia-se informando que o método será sobrescrito, ganhando assim uma nova implementação. A linha 3 envia para a superclasse, através do método onActivityResult os valores recolhidos pelas variáveis requestCode, resultCode e data. Na linha 5 é verificado o retorno da variável requestCode: se esta vier a retornar um valor correspondente a RC_SIGN_IN, então fica caracterizado que a ação em tramite é de autenticação, sendo então solicitado na linha 6 o resultado desta transação. Na linha 7 é enviado este resultado para um handler, para posterior utilização.

Após verificar o resultado da autenticação, pode-se utilizar o método getSignInAccount para obter um objeto GoogleSignInAccount, que permite recuperar diversas informações sobre o usuário, como seu nome de usuário por exemplo. A Listagem 9 apresenta o código desta operação.

Listagem 9. Implementando o handler.

  private void handleSignInResult(GoogleSignInResult result) {
      Log.d(TAG, "handleSignInResult:" + result.isSuccess());
      if (result.isSuccess()) {
          GoogleSignInAccount acct = result.getSignInAccount();
          mStatusTextView.setText(getString(R.string.signed_in_fmt, acct.getDisplayName()));
          updateUI(true);
      } else {
          updateUI(false);
      }
  } 

Na linha 1 declaramos o método handleSignInResult e na linha 2 é criado um log onde são adicionadas as informações resultantes do processo de autenticação. A linha 3 realiza verificação se o processo foi realizado com sucesso: caso o resultado tenha sido positivo, cria-se um objeto GoogleSignInAccount na linha 4 e, na linha 5 recupera-se o nome do usuário. Nas demais linhas, caso a autenticação tenha sucesso, a interface gráfica é atualizada, caso contrário, não ocorre a atualização.

O recurso apresentado permite recuperar também o e-mail do usuário através do método getEmail, o ID do usuário através do método getID e até mesmo o token do usuário através do método getToken.

Com isso os desenvolvedores Android podem contar com uma série de recursos oferecidos pela própria Google, recursos estes que tornam sua atividade de desenvolvimento mais tranquila e produtiva. Os recursos aqui apresentados podem garantir um sistema seguro de autenticação de usuários para desenvolvedores de aplicações Android, uma vez que, para que se possa obter acesso a todos os recursos da plataforma Android, é necessário que o usuário tenha um Google ID.

Estes recursos permitem não somente o desenvolvimento de uma aplicação com um sistema seguro e robusto de autenticação, mas também o desenvolvimento de aplicações capazes de recuperar informações sobre seus usuários e adaptarem-se a suas necessidades, tais como região, permitindo assim oferecer-lhes recursos específicos para suas afinidades.

A utilização de tal recurso leva a uma considerável economia de tempo, reduzindo os custos do projeto sem, no entanto, comprometer sua qualidade, uma vez que, contanto com este recurso a possibilidade de um usuário mal-intencionado utilizar de artifícios para recuperar informações de seus usuários é minimizada pelo robusto processo de autenticação criado pela Google.

Pode-se ainda, através da recuperação de informações específicas do usuário, tais como região, idade, sexo e outras informações inerentes à sua conta Google, gerar uma base de conhecimento, capaz de fornecer futuramente informações capazes de auxiliar no desenvolvimento de ações específicas para determinados grupos de usuários.

Links

Pesquisa sobre uso do Android
http://olhardigital.uol.com.br/pro/noticia/android-domina-90-do-mercado-brasileiro-de-smartphones/48392

Sign-in
https://developers.google.com/identity/sign-in/android/start
https://developers.google.com/identity/sign-in/android/start-integrating
https://developers.google.com/identity/sign-in/android/sign-in

Git
http://git-scm.com/download/win