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:
- Login do Google
- OAuth 2.0
- Transmissão de tokens via camada de dados
- Autenticação por código personalizado
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:
- Configure o Login do Google.
- Adicione um botão de Login do Google.
- 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
- Adicione o SignInButton ao layout do app.
-
No método
onCreate()
do app, registre oOnClickListener
do seu botão para fazer login do usuário quando clicado.
<com.google.android.gms.common.SignInButton android:id="@+id/sign_in_button" android:layout_width="wrap_content" android:layout_height="wrap_content" />
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
- O usuário executa uma ação com o app de terceiros, que precisa de autorização.
- 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. - 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.
- 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.
- O servidor de back-end troca o código de autenticação por acesso e tokens de atualização no servidor OAuth.
- O servidor de back-end redireciona a resposta ao app para smartwatch de terceiro pelo app complementar do Wear OS.
- 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. - O app de terceiros analisa a resposta do site de autenticação e extrai um token de autenticação dessa resposta.
- 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:
- Crie um ID e uma chave secreta do cliente.
- Execute uma solicitação de autenticação.
- 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.
- Para saber como transferir credenciais como itens de dados, consulte Enviar e sincronizar dados.
- Para detectar apps portáteis capazes de gerenciar mensagens e anunciar seu app com a capacidade de processar uma solicitação, consulte as seções Anunciar recursos e Recuperar nós com os recursos necessários.
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:
- O usuário executa uma ação com o app de terceiros, que precisa de autorização.
- 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.
- 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.
- 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:
- 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.

Confira também os seguintes recursos relacionados: