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. No entanto, 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 quantos recursos para o usuário sem que ele precise fazer login.

Os usuários podem descobrir e instalar seu app para Wear sem ter usado o dispositivo móvel por isso, eles podem não ter uma conta e não saber quais recursos de produtos Google. Confira se a função do modo visitante apresenta corretamente os recursos do app.

Alguns dispositivos podem permanecer desbloqueados por mais tempo

Em dispositivos com suporte ao Wear OS 5 ou mais recente, o sistema detecta se o usuário está usando o dispositivo no pulso. Se o usuário desligar o pulso e depois tira o dispositivo do pulso, o sistema mantém dispositivo desbloqueado por mais tempo do que de outra forma.

Se o app exigir um nível mais alto de segurança, como ao mostrar dados potencialmente sensíveis ou particulares, primeiro verifique se a detecção de pulso está ativada:

val wristDetectionEnabled =
        isWristDetectionAutoLockingEnabled(applicationContext)

Se o valor de retorno desse método for false, peça para o usuário fazer login em uma conta no app antes de mostrar o conteúdo específico do usuário.

Métodos de autenticação recomendados

Use os métodos de autenticação abaixo para permitir que apps Wear OS independentes façam o seguinte: recebem as 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. O seguinte seção descreve como concluir 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 o projeto do Console de APIs do Google e configure o projeto do Android Studio. Para mais informações, consulte Comece a integrar o Login do Google no seu app Android.

Se você usa o Login do Google com um app ou site que se comunicar com um servidor de back-end, há dois pré-requisitos adicionais:

  • Criar 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 de ID do usuário usando 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 as etapas a seguir, 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 tocados.

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. Estas etapas são mostrados neste exemplo:

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

Conclua as etapas a seguir 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 do botão para fazer 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

Processar toques no botão de login no seu onCLick() criando uma intent de login com o getSignInIntent(). Em seguida, inicie a intent com o startActivityForResult().

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

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

Por fim, no método onActivityResult da atividade, extraia o resultado de login com getSignInResultFromIntent. Depois de extrair o resultado, verifique se o login foi bem-sucedido usando o método isSuccess. Se o login tiver sucesso, chame o método getSignInAccount para receber um objeto GoogleSignInAccount que contenha informações sobre o usuário conectado, como o nome dele. Essas etapas são mostradas no exemplo a seguir:

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

Para conferir um app de exemplo que implementa o Login do Google, consulte a Exemplo de login do Google para o Horologist (link em inglês) no GitHub.

Autenticação por código personalizado

Como alternativa aos métodos de autenticação descritos anteriormente, pode exigir que o usuário faça a autenticação em outro dispositivo, como um celular ou tablet, e obtêm um código numérico de curta duração. Em seguida, o usuário insere no dispositivo Wear OS para confirmar a identidade e receber 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 muda para um dispositivo móvel, tablet ou PC e abre um navegador, navega até 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. A partir deste ponto, você pode usar o código inserido como prova de que ele está correto usuário e trocar o código 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: