Autenticación en Wear

Con la introducción de relojes independientes, las apps para Wear OS ya pueden ejecutarse completamente en un reloj sin necesidad de una app complementaria. Esta nueva capacidad también implica que las apps independientes para Wear OS necesitarán administrar la autenticación por su cuenta cuando necesiten acceder a datos de la nube. Wear OS admite varios métodos de autenticación para permitirles a las apps independientes obtener las credenciales de autenticación del usuario.

Actualmente, Wear OS admite los siguientes métodos de autenticación:

En la siguientes secciones, se describe cómo integrar los métodos de autenticación nombrados anteriormente en tus apps para Wear.

Acceso con Google

El Acceso con Google permite al usuario acceder con su Cuenta de Google existente. Es fácil de incorporar y ofrece la mejor experiencia del usuario, especialmente si ya implementas estas soluciones en tus apps para dispositivos móviles.

El Acceso con Google es la solución más elegida porque también funciona en iOS. En la siguiente sección, se describe cómo realizar una integración básica con el Acceso con Google.

Requisitos previos

Antes de comenzar a integrar el Acceso con Google en tu app para Wear, debes configurar un proyecto de la Consola de API de Google y tu proyecto de Android Studio. Puedes obtener más información en la Guía para comenzar a integrar el Acceso con Google.

Nota: Si usas el Acceso con Google en una app o sitio que se comunica con un servidor de backend, entonces debes crear un ID de cliente de aplicación web de OAuth 2.0 para tu servidor de backend. Este ID de cliente no es el mismo que el de tu app. Para obtener más información, consulta Cómo habilitar el acceso al servidor.

Importante: Si tu app se comunica con un servidor de backend, puedes identificar de manera segura cuál es el usuario que accedió en ese momento al servidor si envías el token de ID del usuario mediante HTTPS. Para obtener información sobre cómo autenticar tu usuario en el servidor de backend, consulta Cómo autenticar con un servidor de backend.

Cómo integrar el Acceso con Google en tu app

Para integrar el Acceso con Google en tu app para Wear, haz lo siguiente:

  1. Configura el Acceso con Google.
  2. Agrega un botón de Acceso con Google.
  3. Inicia el flujo de acceso cuando se haga clic en el botón de acceso.

Configura el Acceso con Google y compila un objeto GoogleApiClient

En el método onCreate de tu actividad de acceso, configura el Acceso con Google para solicitar los datos del usuario que necesita tu app. Luego, crea un objeto GoogleApiClient con acceso a la API de Acceso con Google y las opciones que especificaste.

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

Agrega un botón de Acceso con Google a tu app

  1. Agrega el SignInButton al diseño de tu 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. En el método onCreate() de la app, registra el OnClickListener de tu botón para que el usuario acceda al hacer clic.
  4. Kotlin

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

    Java

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

Inicia el flujo de acceso y crea un intent de acceso

Cuando se hace clic en el botón de acceso, puedes administrar estos clics en tu método onCLick() creando un intent de acceso con el método getSignInIntent e iniciando luego el intent con el método startActivityForResult method.

Kotlin

    Auth.GoogleSignInApi.getSignInIntent(googleApiClient).also { signInIntent ->
        startActivityForResult(signInIntent, RC_SIGN_IN)
    }
    

Java

    Intent signInIntent = Auth.GoogleSignInApi.getSignInIntent(googleApiClient);
    startActivityForResult(signInIntent, RC_SIGN_IN);
    

Se le solicita al usuario que seleccione una Cuenta de Google para acceder. Si solicitaste datos que exceden el perfil, el correo electrónico y el OpenID, también se le pedirá al usuario acceso a esos recursos.

Por último, en el método onActivityResult de la actividad, recupera el resultado de acceso con getSignInResultFromIntent. Una vez que lo hagas, podrás verificar si el acceso fue exitoso con el método isSuccess. Si lo fue, podrás llamar al método getSignInAccount para obtener un objeto GoogleSignInAccount, que contiene información sobre el usuario que accedió, como su nombre.

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

Consulta la app de ejemplo que implementa el Acceso con Google.

Compatibilidad con OAuth 2.0

Wear proporciona compatibilidad con OAuth 2.0 para apps de terceros a fin de autenticar un usuario con un servicio web. Teniendo en cuenta el espacio limitado de pantalla en dispositivos Wear, la compatibilidad de Wear OS con OAuth permite que las apps para reloj independientes completen el flujo de autenticación de OAuth por medio de un teléfono. Las apps independientes usan un modelo de URL de solicitud y respuesta para autenticar un usuario y recibir un token de OAuth para acceder al servicio.

Nota: Si tu app para Wear 2.0 tiene una app para teléfono complementaria, usa el mismo nombre de paquete para ambas

Requisitos previos

Antes de comenzar, crea un ID de cliente de aplicación web de OAuth 2.0 para tu servidor de backend. Este difiere del ID de cliente de tu app. Puedes buscar o crear un ID de cliente para tu servidor en la Consola de API de Google.

Flujo

  1. El usuario realiza una acción con la app de terceros que solicita autorización.
  2. La app de terceros envía una solicitud a la app para Wear OS complementaria mediante la API de servicios Wear, sendAuthorizationRequest(), para abrir una vista web con la URL de la autorización.
  3. El sitio web de la URL autoriza al usuario (le solicita el nombre de usuario, la contraseña, quizás realiza una autenticación de dos factores, etcétera).
  4. Luego de que el acceso se realiza correctamente o falla, el sitio invoca la URL de devolución de llamada (al servidor de backend de la app) especificada en la solicitud con el código de Auth.
  5. El servidor de backend intercambia el código de Auth por acceso y tokens de actualización desde el servidor se OAuth.
  6. El servidor de backend luego redirecciona la respuesta a la app para reloj de terceros mediante la app para Wear OS complementaria.
  7. La app para Wear OS complementaria recibe ese redireccionamiento y usa la API de compatibilidad con dispositivos wearable, onAuthorizationResponse(), para enviar la respuesta completa desde el servidor a la app para reloj.
  8. La app de terceros analiza la respuesta del sitio de Auth y extrae un token de Auth.
  9. La app de terceros usa el token de Auth como credencial en las solicitudes futuras.

Para implementar el flujo de Auth, debes realizar lo siguiente:

  1. Crea un ID de cliente y un secreto de cliente.
  2. Envía una solicitud de Auth.
  3. Administra la respuesta de Auth.

Crea un ID de cliente y un secreto de cliente

Las apps para Wear que usan OAuth 2.0 deben crear un ID de cliente y un secreto de cliente que identifiquen la app ante un proveedor de OAuth. Para obtener estas credenciales, debes configurar un proyecto de Consola de API.

Envía una solicitud de Auth

A fin de enviar una solicitud de Auth para un proveedor de OAuth, primero debes crear un objeto de cliente, que usarás en las solicitudes de OAuth 2.0 en tu método onCreate().

Nota: Para garantizar que tu app no se cierre al activarse el modo ambiente en el reloj, habilita la opción "Siempre activa" (mediante setAmbientEnabled) en su actividad OAuth. Para obtener más información sobre las prácticas recomendadas en el modo ambiente, consulta la página Cómo mantener tu app visible.

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

Luego, crea una URL que incluya un extremo de OAuth para obtener un token, tu ID de cliente de OAuth del servidor, la URL de redireccionamiento (a tu servidor de backend) y el tipo de respuesta.

La URL solicitada es similar a la siguiente:

    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
    

Una vez que crees la solicitud de Auth, podrás enviarla a la app complementaria mediante la API de servicios de Wear: sendAuthorizationRequest().

Esta solicitud activa una RPC a la app complementaria, que presenta una IU de autorización en el teléfono del usuario. El proveedor de OAuth 2.0 autentica el usuario y obtiene su consentimiento para que tu app pueda acceder a los datos que solicita. La respuesta se envía de vuelta a tu servidor de backend mediante la URL de redireccionamiento que especificaste.

Administra la respuesta de Auth

Luego de que la solicitud se procesa correctamente o falla, el servidor de OAuth 2.0 redirecciona a la URL especificada en la solicitud. Si el usuario aprueba el acceso, entonces la respuesta contendrá el código de autorización. Si no lo aprueba, entonces esta contendrá un mensaje de error.

La respuesta será en formato de cadena de consulta, como se muestra debajo:

    https://myserver.com/oauthtokens?code=xyz
    

Una vez que el servidor de backend recibe el código de autorización, puede intercambiarlo por un token de acceso. Luego, el servidor de backend muestra un redireccionamiento HTTP 302 a la app para teléfonos de Wear OS que se registró como receptor de las URL del formulario: https://wear.googleapis.com/3p_auth/app.html?full_suffix_from_redirect=com.your.package.name?accessToken=abc&refreshToken=xyz.
La app de teléfono verifica la URL de respuesta y retransmite la respuesta a la app para reloj de terceros con la API de onAuthorizationResponse.

Nota: Asegúrate de que el nombre de paquete de la app sea el componente de la tercera ruta de acceso en la URL de redireccionamiento. Por lo tanto, el redirect_uri debe ser igual a https://wear.googleapis.com/3p_auth/<receiving app's packagename>. Por ejemplo, https://wear.googleapis.com/3p_auth/com.package.name.

La app de terceros en el reloj extrae el token de Auth de la respuesta y lo usa como credencial en solicitudes 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 una implementación completa de este flujo, consulta el ejemplo.

Nota: A efectos del siguiente ejemplo, el reloj administra el intercambio del token. Como práctica recomendada, establece el URI de redireccionamiento en tu propia URL de servidor, en donde el servidor pueda realizar el intercambio de token de código de autorización.

Pase de tokens mediante la capa de datos

Esta opción solo funciona para los relojes sincronizados con dispositivos Android. La app complementaria en el teléfono puede transferir de manera segura datos de autenticación a la app para Wear mediante la capa de datos de wearables. Las credenciales pueden transferirse como mensajes o elementos de datos.

Nota: Te recomendamos publicar el APK de teléfono y el APK de reloj con el mismo nombre de paquete. De esta manera, las apps para teléfono y para Wear pueden comunicarse mediante la capa de DataItem y realizar la transferencia de token en segundo plano del teléfono al reloj a fin de proporcionar la autenticación.

Flujo

Puedes usar tu propia lógica empresarial para pasar las credenciales mediante la API de capa de datos. En el siguiente diagrama, se ilustra una de las maneras de obtener los tokens mediante la capa de datos de wearables.

Autenticación de código personalizada

Este método de autenticación requiere que el usuario realice la autenticación desde una fuente externa (dispositivo móvil/tablet/PC) y obtenga un código de corta duración que deberá ingresar para demostrar su identidad y, luego, intercambiar por un token de Auth en su dispositivo Wear. En este método, puedes autenticar usuarios en tu app para Wear mediante el módulo de acceso de tu app o con la integración manual de cualquier método de acceso de un proveedor de Auth de terceros en el código de tu app. Si bien este método de autenticación requiere acciones manuales y un esfuerzo adicional para que sea más seguro, puedes usarlo si necesitas solicitar la autenticación en una etapa anterior de tus apps para Wear independientes.

El flujo de Auth para esta configuración funciona de la siguiente manera:

  1. El usuario realiza una acción con la app de terceros que requiere autorización.
  2. La app para Wear de terceros le presenta una pantalla de autenticación al usuario y le indica que debe ingresar un código desde una URL especificada.
  3. El usuario cambia a un dispositivo móvil, una tablet o una PC, inicia un navegador, navega a la URL especificada en la app para Wear y accede.
  4. El usuario recibe un código de corta duración que debe ingresar en la pantalla de autenticación de la app para Wear mediante el teclado integrado en Wear para realizar correctamente la autenticación:

  5. Desde este punto, puedes usar el código ingresado como prueba de que es el usuario correcto y, luego, intercambiarlo por un token de Auth almacenado y protegido en un dispositivo Wear para las llamadas autenticadas que se desvían.

Además, puedes consultar los siguientes recursos relacionados: