Autenticación en wearables

Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

El tamaño pequeño de la pantalla del reloj y las capacidades de entrada reducidas limitan las opciones de autenticación que puede usar una app para Wear OS. Además, las apps para Wear OS pueden ejecutarse de manera independiente sin una app complementaria. Es decir, una app para Wear OS necesita administrar la autenticación por su cuenta cuando accede a datos de Internet.

Modo de Invitado

No se requiere autenticación para todas las funciones. En su lugar, proporciona tantas funciones como sea posible para el usuario, sin necesidad de que acceda.

Los usuarios pueden descubrir e instalar tu app para Wear sin haber usado la app para dispositivos móviles anteriormente y, por lo tanto, es posible que no tengan una cuenta. En este caso, la funcionalidad del modo de invitado debe mostrar con precisión las funciones de tu app para incentivar a los usuarios a crear una cuenta.

Métodos de autenticación recomendados

Usa los siguientes métodos de autenticación con el objeto de habilitar apps independientes para Wear OS a fin de obtener credenciales de autenticación de usuarios:

Pasa tokens con la capa de datos

La app complementaria para teléfonos puede transferir datos de autenticación de forma segura a la app para Wear OS con la capa de datos de wearables. Transfiere credenciales como mensajes o elementos de datos.

Por lo general, este tipo de autenticación no requiere ninguna acción por parte del usuario. Sin embargo, evita realizar la autenticación sin informarle al usuario que está accediendo. Puedes informarle al usuario con una pantalla simple que se puede descartar y que muestre que la cuenta se está transfiriendo desde dispositivos móviles.

Importante: Tu app para Wear debe ofrecer al menos otro método de autenticación, ya que esta opción solo funciona en relojes vinculados con Android cuando está instalada la app para dispositivos móviles correspondiente. Proporciona un método de autenticación alternativo para los usuarios que no tienen la app para dispositivos móviles correspondiente o cuyos dispositivos Wear OS están vinculados con un dispositivo iOS.

Pasa tokens con la capa de datos de la app para dispositivos móviles, como se muestra en el siguiente ejemplo:

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)

Detecta eventos de cambio de datos en la app de reloj, como se muestra en el siguiente ejemplo:

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 obtener más información sobre el uso de la capa de datos de wearables, consulta Cómo enviar y sincronizar datos en Wear OS.

Usa OAuth 2.0

Wear OS admite los siguientes flujos basados en OAuth 2.0:

  • Otorgamiento de código de autorización con PKCE (clave de prueba para el intercambio de código), como se define en RFC 7636.
  • Otorgamiento de autorización de dispositivo, como se define en RFC 8628

Nota: Para garantizar que tu app no se cierre cuando se active el modo ambiente en el reloj, habilita la opción "Siempre encendida" con AmbientModeSupport.attach en la actividad que realiza la autenticación. Para obtener más información sobre las prácticas recomendadas en el modo ambiente, consulta Cómo mantener tu app visible en Wear.

Clave de prueba para el intercambio de código (PKCE)

Para usar la PKCE de manera efectiva, usa RemoteAuthClient.

A fin de realizar una solicitud de Auth a un proveedor de OAuth desde tu app para Wear OS, crea un objeto OAuthRequest. Este objeto consiste en una URL a tu extremo de OAuth para obtener un token y un objeto CodeChallenge. Consulta el siguiente ejemplo a fin de crear una solicitud de Auth:

val request = OAuthRequest.Builder(this.applicationContext)
    .setAuthProviderUrl(Uri.parse("https://...."))
    .setClientId(clientId)
    .setCodeChallenge(codeChallenge)
    .build()

Después de compilar la solicitud de Auth, envíala a la app complementaria con el 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
        }
    }
)

Esta solicitud activa una llamada a la app complementaria, que luego presenta una IU de autorización en un navegador web en el teléfono celular del usuario. El proveedor de OAuth 2.0 autentica al usuario y obtiene su consentimiento para los permisos solicitados. La respuesta se envía a la URL de redireccionamiento que se genera automáticamente.

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 la solicitud de acceso, la respuesta contendrá un código de autorización. Si no lo aprueba, entonces esta contendrá un mensaje de error.

La respuesta es de un formulario de cadena de consulta y se verá como uno de los siguientes ejemplos:

  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

Carga una página que dirige al usuario a la app complementaria. Esta verifica la URL de respuesta y la retransmite a la app de reloj de terceros con la API de onAuthorizationResponse.

La app de reloj puede intercambiar el código de autorización por un token de acceso.

Nota: Una vez que se haya compilado el objeto OAuthRequest, podrás acceder a redirectUrl< para encontrar la URL de redireccionamiento.

Otorgamiento de autorización de dispositivo

Cuando se usa el otorgamiento de autorización de dispositivo, el usuario abre el URI de verificación en otro dispositivo. Luego, el servidor de autorización les solicita aprobar o rechazar la solicitud.

Para facilitar este proceso, usa un RemoteActivityHelper a fin de abrir una página web en el dispositivo móvil vinculado del usuario, como se muestra en el siguiente ejemplo:

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

Si tienes una app para iOS, usa vínculos universales a fin de interceptar este intent en tu app, en lugar de depender del navegador para autorizar el token.

Autenticación basada en contraseñas

Si tu servidor no admite uno de los flujos de OAuth 2.0 que se describieron, muéstrale al usuario un mensaje para el nombre de usuario y la contraseña.

Asegúrate de incluir sugerencias para autocompletar los campos a fin de garantizar que se le ofrezca al usuario una contraseña guardada si tiene una disponible. En el siguiente ejemplo, se configura una sugerencia de contraseña para EditText en tu archivo de diseño:

<EditText
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:autofillHints="password" />

Si quieres obtener más información, consulta Cómo optimizar tu app para el autocompletado.

Otros métodos de autenticación

Wear OS admite métodos de acceso adicionales.

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 de mano.

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 OS, 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 es diferente del ID de cliente 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 el usuario que accedió en ese momento al servidor si envías el token de ID del usuario mediante HTTPS. Si quieres obtener información para 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

A fin de integrar el Acceso con Google en tu app para Wear OS, 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 requiere tu app. Luego, crea un objeto GoogleApiClient con acceso a la API de Google Sign-In 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 tu app, registra el OnClickListener del botón para acceder al usuario cuando se haga clic en él.
  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 y luego iniciando el intent con el 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);

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 en GitHub que implementa el Acceso con Google.

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 OS. En este método, puedes autenticar usuarios en tu app para Wear OS con 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 OS 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 OS 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 OS 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 OS con el teclado integrado en Wear OS a fin de 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 OS para las llamadas autenticadas que se desvían.