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 o máximo de recursos possível ao usuário sem exigir que ele faça 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.

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 desativar a detecção do pulso e tirar o dispositivo do pulso, o sistema manterá o dispositivo desbloqueado por um período mais longo do que o normal.

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 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 Começar a integrar o 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 de 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 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 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:

 <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 botão para fazer login do usuário quando tocado:

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

É 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:

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
            }
        }
    }
}

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