Como autenticar no Android Wear

Com os smartwatches independentes, apps para Wear OS agora podem ser executados sem um app complementar. Esse novo recurso também significa que apps independentes do Wear OS precisarão gerenciar a autenticação por conta própria quando precisarem acessar dados da nuvem. O Wear OS é compatível com vários métodos de autenticação para permitir que apps para Wear consigam as credenciais de autenticação de um usuário.

No momento, o Wear OS é compatível com os seguintes métodos de autenticação:

As seções a seguir descrevem como integrar os métodos de autenticação acima nos seus apps Wear.

Login do Google

O Login do Google permite que o usuário faça login com a própria Conta do Google. Ele oferece a melhor experiência do usuário e é facilmente compatível, principalmente se você já implementa essas soluções nos seus apps portáteis.

O Login do Google é a solução preferencial, já que também funciona no iOS. As seções a seguir descrevem como realizar uma integração básica do Login do Google.

Pré-requisitos

Antes de começar a integrar o Login do Google no seu app para Wear, configure um projeto do Console de APIs do Google e configure seu projeto no Android Studio. Para mais informações, consulte o Guia de integração inicial para o Login do Google.

Observação: se você usa o Login do Google com um app ou site que se comunica com um servidor de back-end, crie um ID do cliente de aplicativo da Web OAuth 2.0 para seu servidor de back-end. Esse ID do cliente é diferente do ID do cliente do seu app. Para mais informações, consulte Ativar o acesso do lado do servidor.

Importante: caso seu app se comunique com um servidor de back-end, identifique o usuário conectado com segurança no servidor enviando o token do código do usuário com HTTPS. Para saber mais sobre como autenticar seu usuário no servidor de back-end, consulte Autenticar com um servidor de back-end.

Integrar o Login do Google no seu app

Para integrar o Login do Google no seu app para Wear:

  1. Configure o Login do Google.
  2. Adicione um botão de Login do Google.
  3. Inicie o fluxo de login quando o botão de login for clicado.

Configurar o Login do Google e criar o objeto GoogleApiClient

No método onCreate da atividade de login, configure o Login do Google para solicitar os dados de usuário necessários no acesso ao app. Em seguida, crie um objeto GoogleApiClient com acesso à API de Login do Google e às opções especificadas.

Kotlin

    // Configure sign-in to request the user's ID, email address, and basic
    // profile. The ID and basic profile are included in DEFAULT_SIGN_IN.
    // If you need to request additional scopes to access Google APIs, specify them with
    // requestScopes().
    googleApiClient = GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
            .requestEmail()
            .build()
            .let { signInConfigBuilder ->
                // Build a GoogleApiClient with access to the Google Sign-In API and the
                // options specified in the sign-in configuration.
                GoogleApiClient.Builder(this)
                        .enableAutoManage(this /* FragmentActivity */, this /* OnConnectionFailedListener */)
                        .addApi(Auth.GOOGLE_SIGN_IN_API, signInConfigBuilder)
                        .build()
            }

Java

    // Configure sign-in to request the user's ID, email address, and basic
    // profile. The ID and basic profile are included in DEFAULT_SIGN_IN.
    // If you need to request additional scopes to access Google APIs, specify them with
    // requestScopes().
    GoogleSignInOptions.Builder signInConfigBuilder = new GoogleSignInOptions
            .Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
            .requestEmail()
            .build();

    // Build a GoogleApiClient with access to the Google Sign-In API and the
    // options specified in the sign-in configuration.
    googleApiClient = new GoogleApiClient.Builder(this)
            .enableAutoManage(this /* FragmentActivity */, this /* OnConnectionFailedListener */)
            .addApi(Auth.GOOGLE_SIGN_IN_API, signInConfigBuilder)
            .build();

Adicionar um botão de Login do Google no app

  1. Adicione o SignInButton ao layout do app. 
    2.      <com.google.android.gms.common.SignInButton
     android:id="@+id/sign_in_button"
     android:layout_width="wrap_content"
     android:layout_height="wrap_content" />
  2. No método onCreate() do app, registre o OnClickListener do seu botão para fazer login do usuário quando clicado.

    3. Kotlin

        findViewById<View>(R.id.sign_in_button).setOnClickListener(this)

    Java

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

Criar um intent de login e iniciar o fluxo de login

Quando o usuário clicar no botão de login, processe os toques nesse botão no método onCLick() criando um intent de login com o método getSignInIntent e iniciando o intent com o método startActivityForResult.

Kotlin

    Auth.GoogleSignInApi.getSignInIntent(googleApiClient).also { signInIntent ->
        startActivityForResult(signInIntent, RC_SIGN_IN)
    }

Java

    Intent signInIntent = Auth.GoogleSignInApi.getSignInIntent(googleApiClient);
    startActivityForResult(signInIntent, RC_SIGN_IN);

É necessário selecionar uma Conta do Google para fazer login. Se você solicitar escopos além de perfil, e-mail e OpenID, o usuário precisará conceder acesso a esses recursos.

Por fim, no método onActivityResult da atividade, recupere o resultado de login com getSignInResultFromIntent. Depois de recuperar o resultado de login, verifique se o login foi bem-sucedido usando o método isSuccess. Se o login for bem-sucedido, chame o método getSignInAccount para ver o objeto GoogleSignInAccount que contém informações sobre o usuário conectado, como o nome dele.

Kotlin

    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent) {
        super.onActivityResult(requestCode, resultCode, data)

        // Result returned from launching the Intent from GoogleSignInApi.getSignInIntent(...)
        if (requestCode == RC_SIGN_IN) {
            Auth.GoogleSignInApi.getSignInResultFromIntent(data)?.apply {
                if (isSuccess) {
                    // Get account information
                    fullName = signInAccount?.displayName
                    mGivenName = signInAccount?.givenName
                    mFamilyName = signInAccount?.familyName
                    mEmail = signInAccount?.email
                }
            }
        }
    }

Java

    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);

        // Result returned from launching the Intent from GoogleSignInApi.getSignInIntent(...)
        if (requestCode == RC_SIGN_IN) {
            GoogleSignInResult signInResult = Auth.GoogleSignInApi.getSignInResultFromIntent(data);
            if (signInResult.isSuccess()) {
                GoogleSignInAccount acct = signInResult.getSignInAccount();

                // Get account information
                fullName = acct.getDisplayName();
                givenName = acct.getGivenName();
                familyName = acct.getFamilyName();
                email = acct.getEmail();
            }
        }
    }

Para ver um app de amostra com Login do Google implementado, consulte app de amostra.

OAuth 2.0

O Wear é compatível com o OAuth 2.0 em apps de terceiros para autenticar um usuário com um serviço da Web. Considerando o espaço limitado da tela em dispositivos Wear, a compatibilidade do Wear OS com OAuth permite que apps independentes para smartwatches concluam o fluxo de autenticação OAuth em um smartphone. Apps independentes usam um modelo de URL de solicitação e resposta para autenticar um usuário e receber um token OAuth a fim de acessar o serviço.

Observação: caso seu app Wear 2.0 tenha um app para smartphones complementar, use o mesmo nome de pacote em ambos.

Pré-requisitos

Antes de começar, crie um ID do cliente de aplicativo da Web OAuth 2.0 para seu servidor de back-end. Esse ID do cliente é diferente do ID do cliente do seu app. Encontre ou crie um ID do cliente para seu servidor no Console de APIs do Google.

Fluxo

  1. O usuário executa uma ação com o app de terceiros, que precisa de autorização.
  2. O app de terceiros envia uma solicitação para o app complementar do Wear OS com a API de serviços do Wear, sendAuthorizationRequest(), para abrir uma visualização da Web com o URL de autorização.
  3. O site do URL autoriza o usuário, pedindo informações como nome de usuário e senha, talvez fazendo uma autenticação de dois fatores etc.
  4. Após o sucesso ou a falha da autenticação, o site usa o código de autenticação para invocar o URL de callback especificado na solicitação para o servidor de back-end do app.
  5. O servidor de back-end troca o código de autenticação por acesso e tokens de atualização no servidor OAuth.
  6. O servidor de back-end redireciona a resposta ao app para smartwatch de terceiro pelo app complementar do Wear OS.
  7. O app complementar do Wear OS recebe o redirecionamento e usa a API de suporte de wearables, onAuthorizationResponse(), para enviar toda a resposta do servidor de volta ao app para smartwatch.
  8. O app de terceiros analisa a resposta do site de autenticação e extrai um token de autenticação dessa resposta.
  9. O app de terceiros usa o token de autenticação como credencial em solicitações futuras.

Para implementar o fluxo de autenticação em cima, faça o seguinte:

  1. Crie um ID e uma chave secreta do cliente.
  2. Execute uma solicitação de autenticação.
  3. Gerencie a resposta de autenticação.

Criar um ID e uma chave secreta do cliente

Apps para Wear que usam o OAuth 2.0 precisam criar um ID do cliente ou uma chave secreta do cliente para identificar o aplicativo em um provedor OAuth. Você precisa configurar um projeto de console de APIs para conseguir essas credenciais.

Executar uma solicitação de autenticação

Para executar uma solicitação de autenticação a um provedor OAuth, crie um objeto de cliente que você usará para enviar solicitações ao OAuth 2.0 no seu método onCreate().

Observação: para garantir que seu app não seja encerrado quando o smartwatch entrar no modo ambiente, ative o recurso "Sempre ativado" (via setAmbientEnabled) na atividade OAuth do app. Para mais informações sobre práticas recomendadas no modo ambiente, consulte a página Como manter seu app visível.

Kotlin

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        oAuthClient = OAuthClient.create(this)
        …
    }

Java

    @Override
    public void onCreate(Bundle b) {
        super.onCreate(b);
        oAuthClient = OAuthClient.create(this);
        …
    }

Em seguida, crie um URL que inclua um endpoint OAuth para conseguir um token, seu ID do cliente do servidor OAuth, o URL de redirecionamento ao servidor de back-end e o tipo de resposta.

O URL solicitado será semelhante ao seguinte: 

    https://accounts.google.com/o/oauth2/v2/auth?response_type=code
    &client_id="your_client_id_here";
    &scope=https://www.googleapis.com/auth/plus.login
    &redirect_uri=https://myserver.com

Depois de criar a solicitação de autenticação, você poderá enviar a solicitação ao app complementar com a API de serviços do Wear, sendAuthorizationRequest().

Essa solicitação aciona uma RPC para o app complementar, o que faz com que uma IU de autorização seja apresentada no smartphone do usuário. O provedor OAuth 2.0 autentica o usuário e consegue o consentimento para que seu aplicativo tenha acesso aos escopos solicitados. A resposta é enviada de volta ao servidor de back-end usando o URL de redirecionamento especificado.

Gerenciar a resposta de autenticação

Após o sucesso ou falha da autenticação, o servidor OAuth 2.0 redireciona ao URL especificado na solicitação. Se o usuário aprovar a solicitação de acesso, a resposta conterá um código de autorização. Se o usuário não aprovar a solicitação, a resposta conterá uma mensagem de erro.

A resposta será na forma de string de consulta, como mostrado abaixo:

    https://myserver.com/oauthtokens?code=xyz

Depois que o servidor de back-end receber o código de autorização, ele poderá trocá-lo por um token de acesso. Em seguida, o servidor de back-end retornará um redirecionamento HTTP 302 para o app para Wear OS que foi registrado como um recebedor de URLs no formato: https://wear.googleapis.com/3p_auth/app.html?full_suffix_from_redirect=com.your.package.name?accessToken=abc&refreshToken=xyz.
O app do smartphone verifica o URL de resposta e redireciona a resposta para o app de terceiros do smartwatch usando a API onAuthorizationResponse.

Observação: verifique se o nome do pacote do app é o componente do caminho de terceiro no URL de redirecionamento. Portanto, o redirect_uri precisa ser igual ao https://wear.googleapis.com/3p_auth/<receiving app's packagename>. Por exemplo, https://wear.googleapis.com/3p_auth/com.package.name.

O app de terceiros no smartwatch extrai o token de autenticação da resposta e o usa como credencial em solicitações futuras.

Kotlin

    oAuthClient.sendAuthorizationRequest(Uri.parse(requestUrl), MyOAuthCallback())

Java

    // The callback provided will be called when the OAuth request completes.
    oAuthClient.sendAuthorizationRequest(Uri.parse(requestUrl), new MyOAuthCallback());

Kotlin

    private class MyOAuthCallback : OAuthClient.Callback() {

        override fun onAuthorizationResponse(requestUrl: Uri, responseUrl: Uri) {
            Runnable {
                acquireToken()
                accessAPI()
            }.apply {
                ...
            }
        }
    }

Java

    private class MyOAuthCallback extends OAuthClient.Callback {
        @Override
        public void onAuthorizationResponse(Uri requestUrl, Uri responseUrl) {
            Runnable r =
                new Runnable() {
                    public void run() {
                        acquireToken();
                        accessAPI();
                    }
                };
        }
    }

Para ver uma implementação completa desse fluxo, consulte o exemplo.

Observação: para os fins desse exemplo, o smartwatch está gerenciando a troca de tokens. É recomendado definir o URL de redirecionamento para seu próprio URL de servidor, onde o servidor pode executar a troca de token de código de autorização.

Transmitir tokens via camada de dados

Essa opção só funciona com smartwatches pareados com Android. O app complementar no smartphone pode transferir com segurança os dados de autenticação para o app Wear pela Camada de dados do wearable. As credenciais podem ser transferidas como mensagens ou itens de dados.

Observação: recomendamos que você use o mesmo nome de pacote nos dois APKs. Isso permite que os apps para smartphones e smartwatches se comuniquem pela camada DataItem e transfiram tokens em segundo plano do smartphone para o smartwatch para que sejam autenticados.

Fluxo

Você pode usar sua própria lógica de negócios para transferir as credenciais usando a API Data Layer. O diagrama a seguir ilustra uma das formas de conseguir os tokens pela Camada de dados do wearable.

Autenticação por código personalizado

Para esse método de autenticação, é necessário que o usuário faça a autenticação a partir de uma fonte externa (dispositivo móvel/tablet/PC) e consiga um código temporário que será inserido para provar a identidade e trocá-la por um token de autenticação no dispositivo Wear. Nesse método, você pode autenticar usuários no seu app Wear usando o módulo de login do seu app ou integrando manualmente qualquer método de login de um provedor de autenticação de terceiros no código do seu app. Embora esse método de autenticação exija trabalho manual e mais esforço para garantir a segurança, se você precisar de autenticação mais cedo nos seus apps Wear independentes, poderá usá-lo.

O fluxo de autorização dessa configuração funciona assim:

  1. O usuário executa uma ação com o app de terceiros, que precisa de autorização.
  2. O app Wear de terceiros apresenta uma tela de autenticação ao usuário e o instrui a inserir um código de um URL especificado.
  3. O usuário alterna para um dispositivo móvel/tablet ou PC, abre um navegador, navega para o URL especificado no app Wear e faz login.
  4. O usuário recebe um código temporário, que ele insere na tela de autenticação do app Wear usando o teclado integrado do Wear para ser autenticado:

  5. A partir desse ponto, você pode usar o código inserido como prova da autenticidade do usuário e trocá-lo por um token de autenticação armazenado e protegido no dispositivo Wear para chamadas autenticadas.
Anterior
Como manter seu app visível
Próxima
Entrada de texto por voz