Autenticação em wearables

Os apps para Wear OS podem ser executados sem um app complementar. Isso significa que eles precisam gerenciar a autenticação por conta própria ao acessar dados da Internet. O tamanho de tela pequeno do smartwatch e os recursos de entrada reduzidos limitam as opções de autenticação que um app para Wear OS pode usar.

Este guia aborda os métodos de autenticação recomendados para apps para Wear OS, além de alternativas quando esses métodos não se encaixam no caso de uso de um app.

Para saber mais sobre como criar uma boa experiência de login, consulte o Guia de UX de login.

Modo convidado

Não exija autenticação para todas as funcionalidades. Em vez disso, forneça o máximo de recursos possível ao usuário, sem a necessidade de fazer login.

Os usuários podem descobrir e instalar o app para Wear sem ter usado o app para dispositivos móveis. Assim, podem não ter uma conta e não saber quais recursos ele oferece. Confira se a função do modo visitante apresenta corretamente os recursos do app.

Métodos de autenticação recomendados

Use os métodos de autenticação abaixo para permitir que apps para Wear OS autônomos recebam credenciais de autenticação do usuário.

Transmitir tokens usando a camada de dados

O app complementar do smartphone pode transferir dados de autenticação com segurança ao app para Wear OS usando a camada de dados wearable. Transfira credenciais como mensagens ou itens de dados.

Normalmente, esse tipo de autenticação não requer nenhuma ação do usuário. No entanto, evite realizar a autenticação sem informar o usuário que ele está conectado. Informe o usuário usando uma tela simples e dispensável que mostre que a conta está sendo transferida do dispositivo móvel.

Importante: o app para Wear precisa oferecer pelo menos um outro método de autenticação, já que essa opção funciona apenas em smartwatches pareados com Android quando o app para dispositivos móveis correspondente está instalado. Forneça um método de autenticação alternativo para usuários que não têm o app para dispositivos móveis correspondente ou que usam um dispositivo Wear OS pareado com um dispositivo iOS.

Transmita tokens usando a camada de dados do app para dispositivos móveis, como mostrado neste exemplo:

val token = "..." // Auth token to transmit to the wearable device.
val dataClient: DataClient = Wearable.getDataClient(context)
val putDataReq: PutDataRequest = PutDataMapRequest.create("/auth").run {
    dataMap.putString("token", token)
    asPutDataRequest()
}
val putDataTask: Task<DataItem> = dataClient.putDataItem(putDataReq)

Detecte eventos de mudança de dados no app para smartwatch, conforme mostrado neste exemplo:

val dataClient: DataClient = Wearable.getDataClient(context)
dataClient.addListener{ dataEvents ->
    dataEvents.forEach { event ->
        if (event.type == DataEvent.TYPE_CHANGED) {
            val dataItemPath = event.dataItem.uri.path ?: ""
            if (dataItemPath.startsWith("/auth")) {
                val token = DataMapItem.fromDataItem(event.dataItem).dataMap.getString("token")
                // Display interstitial screen to notify the user they are being signed in.
                // Then, store the token and use it in network requests.
            }
        }
    }
}

Para mais informações sobre como usar a camada de dados de wearables, consulte Enviar e sincronizar dados no Wear OS.

Usar o OAuth 2.0

O Wear OS oferece suporte a dois fluxos baseados em OAuth 2.0, que são descritos nas seções a seguir:

  • Concessão de código de autorização com chave de prova para troca de código (PKCE, na sigla em inglês), conforme definido na RFC 7636 (link em inglês)
  • Concessão de autorização do dispositivo, conforme definido na RFC 8628 (link em inglês)

Observação: para garantir que seu app não seja encerrado quando o smartwatch entrar no modo ambiente, ative a opção "Sempre ativado" usando AmbientModeSupport.attach na atividade que está realizando a autenticação. Para mais informações sobre práticas recomendadas no modo ambiente, consulte Manter seu app visível no Wear.

Chave de prova para troca de código (PKCE, na sigla em inglês)

Para usar a PKCE com eficiência, use RemoteAuthClient.

Para solicitar a autenticação no seu app para Wear OS a um provedor OAuth, crie um objeto OAuthRequest. Esse objeto consiste em um URL para o endpoint de OAuth para receber um token e um objeto CodeChallenge. O código a seguir mostra um exemplo de como criar uma solicitação de autenticação:

val request = OAuthRequest.Builder(this.applicationContext)
    .setAuthProviderUrl(Uri.parse("https://...."))
    .setClientId(clientId)
    .setCodeChallenge(codeChallenge)
    .build()

Depois de criar a solicitação de autenticação, faça o envio dela ao app complementar usando o método sendAuthorizationRequest():

val client = RemoteAuthClient.create(this)
client.sendAuthorizationRequest(request,
    { command -> command?.run() },
    object : RemoteAuthClient.Callback() {
        override fun onAuthorizationResponse(
            request: OAuthRequest,
            response: OAuthResponse
        ) {
            // Extract the token from the response, store it and use it in network requests.
        }

        override fun onAuthorizationError(errorCode: Int) {
            // Handle error
        }
    }
)

Essa solicitação aciona uma chamada para o app complementar, que depois apresenta uma interface de autorização em um navegador da Web no smartphone do usuário. O provedor de OAuth 2.0 autentica o usuário e recebe o consentimento dele para as permissões solicitadas. A resposta é enviada ao URL de redirecionamento gerado automaticamente.

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 vai conter um código de autorização. Se o usuário não aprovar a solicitação, a resposta vai conter uma mensagem de erro.

A resposta está na forma de uma string de consulta e é semelhante a um dos exemplos abaixo:

  https://wear.googleapis.com/3p_auth/com.your.package.name?code=xyz
  https://wear.googleapis-cn.com/3p_auth/com.your.package.name?code=xyz

Isso carrega uma página que direciona o usuário ao app complementar, que verifica o URL da resposta e a redireciona ao app para smartwatch usando a API onAuthorizationResponse.

O app para smartwatch pode trocar o código de autorização por um token de acesso.

Observação:depois que o parâmetro OAuthRequest é criado, o URL de redirecionamento fica disponível em redirectUrl.

Concessão de autorização do dispositivo

Ao usar a concessão de autorização do dispositivo, o usuário abre o URI de verificação em outro dispositivo. Depois, o servidor de autorização pede que ele aprove ou negue a solicitação.

Para facilitar esse processo, use um RemoteActivityHelper para abrir uma página da Web no dispositivo móvel pareado do usuário, conforme mostrado neste exemplo:

// Request access from the authorization server and receive Device Authorization Response.
val verificationUri = "..." // Extracted from the Device Authorization Response.
RemoteActivityHelper.startRemoteActivity(
    this,
    Intent(Intent.ACTION_VIEW)
        .addCategory(Intent.CATEGORY_BROWSABLE)
        .setData(Uri.parse(verificationUri)),
    null
)
// Poll the authorization server to find out if the user completed the user authorization
// step on their mobile device.

Se você tiver um app iOS, use links universais (link em inglês) para interceptar essa intent no app, em vez de depender do navegador para autorizar o token.

Outros métodos de autenticação

O Wear OS oferece suporte a outros métodos de login, que são descritos nas seções a seguir.

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 é fácil oferecer suporte a ele, principalmente se você já implementa esse recurso nos seus apps portáteis.

Após os métodos de autenticação recomendados descritos anteriormente, o Login do Google é a próxima solução preferencial, porque também funciona bem no iOS. A seção a seguir descreve 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 OS, configure um projeto do Console de APIs do Google e configure seu projeto no Android Studio. Para mais informações, consulte Iniciar a integração do Login do Google no seu app Android.

Se você usa o Login do Google com um app ou site que se comunica com um servidor de back-end, há mais dois pré-requisitos:
  • Crie um ID do cliente de aplicativo da Web OAuth 2.0 para seu servidor de back-end. Esse ID do cliente é diferente no seu app. Para mais informações, consulte Como ativar o acesso do lado do servidor.
  • Identifique com segurança o usuário conectado no servidor enviando o token do ID do usuário por HTTPS. Para aprender a 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

Revise e implemente estas etapas, que são detalhadas nas seções a seguir, para integrar o Login do Google no seu app para Wear OS:

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

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 exigidos pelo seu app. Em seguida, crie um objeto GoogleApiClient com acesso à API de Login do Google e às opções especificadas. Essas etapas são mostradas no exemplo a seguir.

  public class MyNewActivity extends AppCompatActivity {

    private static final int RC_SIGN_IN = 9001;

    private GoogleSignInClient mSignInClient;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        GoogleSignInOptions options =
               new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
                        .build();

        mSignInClient = GoogleSignIn.getClient(this, options);
    }
  }

Adicionar um botão de Login do Google no app

Siga estas etapas para adicionar um botão de Login do Google:
  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" />
    
  3. No método onCreate() do app, registre o OnClickListener para o botão que faz o login do usuário quando tocado:
  4. Kotlin

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

    Java

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

Criar uma intent de login e iniciar o fluxo de login

Processe os toques no botão de login no método onCLick() criando uma intent de login com o método getSignInIntent(). Em seguida, inicie a intent com o método startActivityForResult().

  Intent intent = mSignInClient.getSignInIntent();
  startActivityForResult(intent, RC_SIGN_IN);

The user is prompted to select a Google account to sign in with. If you requested scopes beyond profile, email, and open ID, the user is also prompted to grant access to those resources.

Finally, in the activity's onActivityResult method, retrieve the sign-in result with getSignInResultFromIntent. After you retrieve the sign-in result, you can check whether the sign-in succeeded using the isSuccess method. If sign-in succeeds, you can call the getSignInAccount method to get a GoogleSignInAccount object that contains information about the signed-in user, such as the user's name. These steps are shown in the following example:

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
protected 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();
        }
    }
}

Consulte o exemplo de Login do Google para Android Wear (link em inglês) no GitHub para conferir uma implementação do Login do Google.

Autenticação por código personalizado

Como alternativa aos métodos de autenticação descritos anteriormente, você pode exigir que o usuário faça a autenticação em outro dispositivo, como um smartphone ou tablet, e receba um código numérico temporário. Em seguida, o usuário insere o código no dispositivo Wear OS para confirmar a identidade e recebe um token de autenticação.

Esse fluxo de autenticação usa o módulo de login do seu app ou integra manualmente um método de login de um provedor de autenticação terceirizado no código do app. Embora esse método de autenticação exija trabalho manual e mais esforço para garantir a segurança, você pode usá-lo se precisar de autenticação mais cedo nos seus apps Wear OS independentes.

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

  1. O usuário executa uma ação com o app para Wear OS, que precisa de autorização.
  2. O app para Wear OS 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 para Wear OS e faz login.
  4. O usuário recebe um código numérico temporário que precisa inserir na tela de autenticação do app para Wear OS usando o teclado integrado do Wear OS:

  5. Depois, você pode usar o código inserido como prova da autenticidade dos usuários e fazer a troca dele por um token de autenticação armazenado e protegido no dispositivo Wear OS para chamadas autenticadas.

Observação: o código gerado pelo usuário precisa ser numérico. Ele não pode conter caracteres alfabéticos.

Esse fluxo de autenticação é mostrado no gráfico abaixo: