Autenticação em wearables

Os apps para Wear OS podem ser executados de forma independente, sem um app complementar. Isso significa que Um app para Wear OS precisa gerenciar a autenticação por conta própria ao acessar. dados da Internet. Mas o tamanho da tela do relógio é pequeno de entrada 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 ficar desbloqueados por mais tempo

Em dispositivos compatíveis que executam o 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 exibir dados potencialmente confidenciais ou privados. Primeiro, verifique se a detecção do pulso ativado:

val wristDetectionEnabled =
        isWristDetectionAutoLockingEnabled(applicationContext)

Se o valor de retorno desse método for false, solicite que o usuário faça login em um no app antes de exibir 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 seja fácil de dar suporte, especialmente se você já implementa nos apps para dispositivos portáteis.

Após os métodos de autenticação recomendados descritos anteriormente, o Google O login é a próxima solução preferencial porque também funciona 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 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 saber como autenticar seu usuário no servidor de back-end, consulte Autentique com um servidor de back-end.

Integrar o Login do Google no seu app

Revise e implemente as etapas a seguir, 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 sua atividade de login, configure o Login do Google para solicitar os dados do usuário exigidos pelo aplicativo. Depois, 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:

 <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 para fazer o login do usuário quando um usuário toca nele:

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ê solicitou escopos além do perfil, e-mail e open ID, o usuário também é solicitado a conceder acesso a esses do Google Cloud.

Por fim, no módulo onActivityResult, recupere o resultado do login com getSignInResultFromIntent. Depois de recuperar o resultado do login, você poderá verifique se o login foi bem-sucedido usando o isSuccess. Se o login tiver êxito, será possível chamar o método getSignInAccount para receber Objeto GoogleSignInAccount que contém informações sobre o usuário conectado usuário, 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();
        }
    }
}