Autenticación para GDK Glassware

Si tu GDK Glassware necesita autenticar a los usuarios en un servicio web, el GDK proporciona una API que permite al usuario ingresar sus credenciales cuando instalar tu Glassware.

Con el uso de esta API, proporcionas una identidad coherente para los usuarios de Glass y evitar la sobrecarga que implica implementar tus propios esquemas de autenticación personalizados.

Nota: Por el momento, solo podrás probar y usar esta API después de que la subamos el APK a MyGlass, lo que sucede durante el proceso de revisión.

Crea una cuenta de servicio de la API de Google

Cuando la autenticación se configura correctamente, el backend de tu app web usa la API de Mirror para enviar las claves información de la cuenta a Glass. después de que se autentiquen con tu servicio.

Para acceder a esta API, crea un proyecto de API de Google y, luego, crear un ID de cliente para una "cuenta de servicio" (y no una “aplicación web”). De con una cuenta de servicio, los usuarios no tienen que otorgar tu acceso permiso de la aplicación para enviar sus credenciales a Glass y no la página de permisos de OAuth y tu propia autenticación página otra vez.

Para crear esta cuenta, sigue estos pasos:

1. Ve a Google Developers Console.
2. Haz clic en el botón Crear proyecto y, luego, ingresa la información solicitada.
3. Una vez que se cree el proyecto, toma nota del Número de proyecto, que necesitarás más adelante.
4. En APIs y auth, haz clic en APIs y habilita la API de Google Mirror. para tu nuevo proyecto.
5. En APIs y auth, haz clic en Credenciales y, luego, en Crear cliente nuevo ID Marca la casilla Cuenta de servicio para crear una nueva versión de OAuth 2.0. el ID de cliente del proyecto.
6. Una ventana emergente te informará que se está descargando la clave privada a tu computadora y te proporciona la contraseña de esa clave privada. Cuando cierres esta ventana, no podrás descargar esta o volver a ver la contraseña. Si alguna vez se pierden, debes crear una nueva. uno.
7. Toma nota de la dirección de correo electrónico de la cuenta de servicio, que necesitarás para realizar la llamada a la API.

Cómo proporcionar metadatos sobre tu contenido de Glass

Cuando estés listo para enviar tu Glassware, deberás proporcionar la la siguiente información. Esto nos permite configurar tu Glassware para y, así, autenticar correctamente cuando la implementas.

• Tu URL de autenticación, a la que se redirecciona a los usuarios cuando se encienden los cristales de MyGlass.
• El tipo de cuenta (la cadena que usarás cuando llames al APIs de AccountManager de Android en el dispositivo Glass)
• El nombre del paquete de la aplicación de tu AndroidManifest.xml
• El ID numérico del proyecto de la API de Google del proyecto que creaste arriba de
• Es el APK que se subirá en MyGlass. Para las pruebas, solo debes proporcionar este APK una vez para manejar la descarga inicial cuando tu Glassware se activado desde MyGlass después de eso, puedes iterar y depurar localmente reemplazando el APK en tu dispositivo. Ten en cuenta que este APK debe cumplir los siguientes criterios:
  • Debe estar alineada con la cremallera.
  • No debes realizar cambios en el nombre del paquete ni en la firma privada (el administrador de paquetes de Android no permite actualizaciones si alguno de estos cambia).
  • Debe tener un tamaño inferior a 50 megabytes.
  • Se debe compilar con la versión más reciente del GDK.

Cómo implementar el flujo de autenticación

En el siguiente diagrama, se muestra el flujo de autenticación básico para Artículos de cristalería de GDK:

Para implementar el flujo de autenticación, haz lo siguiente:

1. Cuando los usuarios activan Glassware en MyGlass, se los redirecciona. a tu URL de autenticación. Estas solicitudes incluyen un parámetro de consulta llamado userToken que deberás usar más adelante.

   Advertencia: No almacenes este token de usuario. Es solo para uso de Google en los extremos de autenticación para volver a asignar la solicitud al usuario originado solo durante esa sesión y no contiene información que pueda para identificar al usuario persistentemente. No se garantiza que el token De la misma manera si el usuario se autentica con la misma Glassware varias veces. o si el usuario se autentica con diferentes Glassware de la misma desarrollador.

2. El usuario ingresa sus credenciales en tu página de autenticación.

3. El servidor valida las credenciales del usuario. Si las credenciales son válidas, realiza una llamada a la API de Mirror al método mirror.accounts.insert. Este método requiere que especifiques https://www.googleapis.com/auth/glass.thirdpartyauth cuando compiles tu Duplicar objeto de servicio. Ejemplos de cómo realizar esta llamada a la API con modelos sin procesar HTTP o Java se muestran en los ejemplos de creación de cuentas.

   Los parámetros y el cuerpo de la solicitud que proporciones a continuación representan el mismo información que le proporcionarías a AccountManager de Android si estaban creando la cuenta directamente en el dispositivo.

   Nombre de la propiedad	Valor	Descripción
   features[]	lista de cadenas	Una lista de funciones (consulta AccountManager.hasFeatures).
   password	string	La contraseña de la cuenta (consulta AccountManager.getPassword). Recomendaciones no almacenas la contraseña real del usuario en en este campo, sino que lo usarás para almacenar datos como un token de actualización.
   userData[]	lista de objetos	Uno o más pares de datos del usuario asociados con la cuenta (consulta AccountManager.getUserData).
   userData[].key	string	La clave asociada con un par clave-valor de datos del usuario específico par.
   userData[].value	string	El valor asociado con un par clave-valor de datos del usuario en particular par.
   authTokens[]	lista de objetos	Uno o más tokens de autenticación asociados con la cuenta (consulta AccountManager.getAuthToken).
   authTokens[].type	string	El tipo de token de autenticación.
   authTokens[].authToken	string	El token de autenticación.

4. Cuando se recibe la solicitud mirror.account.insert, la API de Mirror envía la cuenta al dispositivo Glass del usuario, desde donde puedes acceder a ella con la clase AccountManager.

Flujos de autenticación recomendados

Sigue estos lineamientos para implementar un flujo de autenticación fácil de usar:

• Optimiza tu flujo para dispositivos móviles.
• Si tu flujo tiene un alcance y el usuario lo cancela, ten un buen diseño mensaje de error.
• Asegúrate de que los alcances que solicitas se usen en tu Glassware.
• Si se puede conectar una cuenta de usuario, asegúrate de conectarla.
• Siempre que sea posible, se debe crear una copia de seguridad de los datos del usuario en la nube.

Nota: Instala Glassware al menos una vez a través de MyGlass para garantizar de que el flujo de autenticación sea exitoso. Si lo has hecho una vez, Puedes instalarlo mediante sideloading para realizar pruebas.

Si deseas mantener la coherencia en la autenticación de Glassware, utiliza una de las siguientes opciones: de autenticación de usuarios:

Replicación o híbrida sin una cuenta

1. Después de activar y desactivar en MyGlass, la URL de autenticación se abre en una ventana emergente.
2. Esto envía directamente al usuario a los permisos que debe aceptar.
3. Después de que el usuario acepte o cancele los permisos, cierra la ventana emergente.

Replicar con una cuenta

1. Después de activar y desactivar en MyGlass, la URL de autenticación se abre en una ventana emergente.
   • Si el usuario ya accedió a tu servicio, envíalo directamente a los permisos.
   • Si el usuario no accedió, muestra los campos de acceso y permite que acceda. a tu servicio y, luego, enviarlos a los permisos.
   • Si el usuario no tiene una cuenta, proporciona un vínculo para crear una de servicio predeterminada. Los usuarios deben tener una forma de crear una cuenta como parte del de instalación del software.
2. El usuario acepta permisos.
   • Si su Glassware tiene una configuración configurable, envíe al usuario al de configuración con valores predeterminados razonables.
   • Si su Glassware no tiene una configuración configurable, envíe al usuario a una página de confirmación. Cierra la ventana emergente si no hay ninguna configuración adicional. como en los productos necesarios.

Híbrida con una cuenta

1. Después de activar y desactivar en MyGlass, la URL de autenticación se abre en una ventana emergente.
   • Si el usuario ya accedió a tu servicio, envíalo directamente a los permisos.
   • Si el usuario no accedió, muestra los campos de acceso y permite que acceda. y, luego, enviarlos a los permisos.
   • Si el usuario no tiene una cuenta, proporciónale un vínculo para crearla.
2. El usuario acepta permisos.
3. Envía una solicitud a la API de Mirror para insertar la cuenta de GDK.
   • Envía al usuario a la página de configuración con los valores predeterminados razonables seleccionados.
   • Envía una página de confirmación al usuario. Cierra la ventana emergente si no hay más configuración predeterminada.

Duplicación o híbrida con una cuenta y permisos personalizados

1. Después de activar y desactivar en MyGlass, la URL de autenticación se abre en una ventana emergente.
   • Si el usuario ya accedió a tu servicio, envíalo a tu permisos internos
   • Si el usuario no accedió, muestra los campos de acceso y permite que acceda. y, luego, enviarlos a tus permisos internos
   • Si el usuario no tiene una cuenta, proporciónale un vínculo para crearla.
2. Cuando el usuario acepte tus permisos personalizados, dirígelo a los alcances de Google.
3. Envía una solicitud a la API de Mirror para insertar la cuenta de GDK.
   • Envía al usuario a la página de configuración con los valores predeterminados razonables seleccionados.
   • Envía una página de confirmación al usuario. Cierra la ventana emergente si no hay más configuración predeterminada.

Duplicado o híbrido con una aplicación para Android/iPhone

1. Después de activar y desactivar en MyGlass, la URL de autenticación se abre en una ventana emergente.
2. Esto envía directamente al usuario a los permisos que debe aceptar.
3. Después de que el usuario acepta permisos, ocurre lo siguiente:
   • Si el usuario tiene la aplicación complementaria y se autenticó, cierra la ventana emergente. en la ventana modal.
   • De lo contrario, envía al usuario a un anuncio intersticial que le indique que descargue la app. Aplicación desde Google Play Store o iOS Store
4. Después de instalar la app y autenticarte, cierra la ventana emergente

GDK sin cuenta

Para este flujo, solo se debe activar Glassware en MyGlass.

GDK con una cuenta

1. Después de activar y desactivar en MyGlass, la URL de autenticación se abre en una ventana emergente.
   • Si el usuario ya accedió a tu servicio, dirígelo al de confirmación de la cita.
   • Si el usuario no accedió, muestra los campos de acceso y permítele acceder y, luego, dirigirlos a la pantalla de confirmación.
   • Si el usuario no tiene una cuenta, proporciónale un vínculo para crearla.
2. El usuario acepta permisos.
3. Envía una solicitud a la API de Mirror para insertar la cuenta de GDK.
4. Mostrar la pantalla de confirmación y cerrarla después de mostrarla durante un breve período de tiempo.

Ejemplos de creación de cuentas

Usa las bibliotecas cliente. para la API de Mirror cuando sea posible. Por lo tanto, llamar a mirror.accounts.insert crear la cuenta sea más fácil.

Ejemplo de HTTP sin procesar

El siguiente ejemplo solo muestra la URL de la solicitud y un ejemplo del JSON que espera. Realiza solicitudes HTTP sin procesar en nombre de un servicio es mucho más complicado (consulta Usa OAuth 2.0 para aplicaciones de servidor a servidor para ver todos los detalles), por lo que te recomendamos que uses una de nuestras bibliotecas cliente si es posible para que esto sea más fácil.

Método de solicitud y URL:

POST https://www.googleapis.com/mirror/v1/accounts/{userToken}/com.example.myapp/username%40email.com

Cuerpo de la solicitud:

{
    "features": ["a", "b", "c"],
    "userData": [
        { "key": "realName", "value": "Rusty Shackleford" },
        { "key": "foo", "value": "bar" }
    ],
    "authTokens": [
        { "type": "your_token_type", "authToken": "zT419Ma3X2pBr0L..." }
    ]
}

Reemplaza {userToken} en la URL de la solicitud por el token que se pasó a la URL de autenticación en el paso 1 de Implementa el flujo de autenticación.

Ejemplo de Java

En este ejemplo, se muestra cómo usar la biblioteca cliente de Java para llamar mirror.accounts.insert

import com.google.api.client.googleapis.auth.oauth2.GoogleCredential;
import com.google.api.client.http.HttpTransport;
import com.google.api.client.http.javanet.NetHttpTransport;
import com.google.api.client.json.JsonFactory;
import com.google.api.client.json.jackson.JacksonFactory;
import com.google.api.services.mirror.Mirror;
import com.google.api.services.mirror.model.Account;
import com.google.api.services.mirror.model.AuthToken;
import com.google.common.collect.Lists;
...

/** Email of the Service Account */
private static final String SERVICE_ACCOUNT_EMAIL =
    "<some-id>@developer.gserviceaccount.com";

/** Path to the Service Account's Private Key file */
private static final String SERVICE_ACCOUNT_PKCS12_FILE_PATH =
    "/path/to/<public_key_fingerprint>-privatekey.p12";

/** The account type, usually based on your company or app's package. */
private static final String ACCOUNT_TYPE = "com.example.myapp";

/** The Mirror API scopes needed to access the API. */
private static final String MIRROR_ACCOUNT_SCOPES =
    "https://www.googleapis.com/auth/glass.thirdpartyauth";

/**
 * Build and returns a Mirror service object authorized with the service accounts.
 *
 * @return Mirror service object that is ready to make requests.
 */
public static Mirror getMirrorService() throws GeneralSecurityException,
    IOException, URISyntaxException {
  HttpTransport httpTransport = new NetHttpTransport();
  JacksonFactory jsonFactory = new JacksonFactory();
  GoogleCredential credential = new GoogleCredential.Builder()
      .setTransport(httpTransport)
      .setJsonFactory(jsonFactory)
      .setServiceAccountId(SERVICE_ACCOUNT_EMAIL)
      .setServiceAccountScopes(MIRROR_ACCOUNT_SCOPES)
      .setServiceAccountPrivateKeyFromP12File(
          new java.io.File(SERVICE_ACCOUNT_PKCS12_FILE_PATH))
      .build();
  Mirror service = new Mirror.Builder(httpTransport, jsonFactory, null)
      .setHttpRequestInitializer(credential).build();
  return service;
}

/**
 * Creates an account and causes it to be synced up with the user's Glass.
 * This example only supports one auth token; modify it if you need to add
 * more than one, or to add features, user data, or the password field.
 *
 * @param mirror the service returned by getMirrorService()
 * @param userToken the user token sent to your auth callback URL
 * @param accountName the account name for this particular user
 * @param authTokenType the type of the auth token (chosen by you)
 * @param authToken the auth token
 */
public static void createAccount(Mirror mirror, String userToken, String accountName,
    String authTokenType, String authToken) {
  try {
    Account account = new Account();
    List<AuthToken> authTokens = Lists.newArrayList(
        new AuthToken().setType(authTokenType).setAuthToken(authToken));
    account.setAuthTokens(authTokens);
    mirror.accounts().insert(
        userToken, ACCOUNT_TYPE, accountName, account).execute();
  } catch (IOException e) {
    e.printStackTrace();
  }
}

Cómo recuperar cuentas en Glass

Cómo recuperar y usar Account en Glass es similar al uso de la API estándar de AccountManager

1. Declara los siguientes permisos de manifiesto en tu archivo AndroidManifest.xml:

   <uses-permission android:name="android.permission.GET_ACCOUNTS" />
   <uses-permission android:name="android.permission.USE_CREDENTIALS" />
   

2. Recupera las cuentas de Glassware:

   AccountManager accountManager = AccountManager.get(mContext);
   // Use your Glassware's account type.
   Account[] accounts = accountManager.getAccountsByType("com.example");
   
   // Pick an account from the list of returned accounts.
   

3. Recupera un token de autenticación desde Account:

   // Your auth token type.
   final String AUTH_TOKEN_TYPE = "oauth2:https://www.example.com/auth/login";
   
   accountManager.getAuthToken(account, AUTH_TOKEN_TYPE, null, activity, new AccountManagerCallback<Bundle>() {
       public void run(AccountManagerFuture<Bundle> future) {
           try {
               String token = future.getResult().getString(AccountManager.KEY_AUTHTOKEN);
               // Use the token.
           } catch (Exception e) {
               // Handle exception.
           }
       }
   }, null);