Le SDK Glass Explorer Edition est obsolète. Cette documentation demeure une référence historique.

Cette page a été traduite par l'API Cloud Translation.

Authentification pour GDK Glassware

Si votre application Glassware GDK doit authentifier les utilisateurs auprès d'un service Web, la GDK fournit une API qui permet à l'utilisateur de saisir ses identifiants lorsqu'il installe votre application Glassware.

En utilisant cette API, vous offrez une expérience utilisateur cohérente aux utilisateurs de Glass et évitez les coûts liés à l'implémentation de vos propres schémas d'authentification personnalisés.

Créer un compte de service d'API Google

Lorsque l'authentification est correctement configurée, le backend de votre application Web utilise l'API Mirror pour transférer les informations de compte des utilisateurs vers Glass après leur authentification auprès de votre service.

Pour accéder à cette API, créez un projet d'API Google, puis un ID client pour un "compte de service" (et non une "application Web"). En utilisant un compte de service, les utilisateurs n'ont pas besoin d'autoriser séparément votre application à transférer leurs identifiants vers Glass. Ils ne verront plus la page des autorisations OAuth ni votre propre page d'authentification.

Pour créer ce compte :

Accédez à la Google Developers Console.
Cliquez sur le bouton Créer un projet et saisissez les informations demandées.
Une fois votre projet créé, notez le numéro de projet, car vous en aurez besoin plus tard.
Sous API et authentification, cliquez sur API, puis activez l'API Google Mirror pour votre nouveau projet.
Sous API et authentification, cliquez sur Identifiants, puis sur Créer un ID client. Cochez la case Compte de service pour créer un ID client OAuth 2.0 pour le projet.
Une fenêtre pop-up vous indique que la clé privée est en cours de téléchargement sur votre ordinateur et vous fournit le mot de passe de cette clé privée. Une fois cette fenêtre fermée, vous ne pourrez plus télécharger cette clé privée ni afficher le mot de passe. Si vous les perdez, vous devrez en créer un autre.
Notez l'adresse e-mail du compte de service, dont vous aurez besoin plus tard pour effectuer l'appel d'API.

Fournir des métadonnées sur vos verres

Lorsque vous êtes prêt à envoyer votre Glassware, vous devez fournir les informations suivantes. Cela nous permet de configurer votre Glassware pour qu'il soit correctement authentifié lorsque vous l'implémentez.

Votre URL d'authentification, vers laquelle les utilisateurs sont redirigés lorsqu'ils activent vos applications Glass dans MyGlass.
Le type de compte (la chaîne que vous utiliserez lorsque vous appelez les API Android AccountManager sur l'appareil Glass)
Le nom du package de votre application à partir de votre AndroidManifest.xml
ID numérique du projet d'API Google du projet que vous avez créé ci-dessus
L'APK à importer sur MyGlass. Pour les tests, vous n'avez besoin de fournir cet APK qu'une seule fois pour gérer le téléchargement initial lorsque votre application Glassware est activée depuis MyGlass. Ensuite, vous pouvez itérer et déboguer localement en écrasant l'APK sur votre appareil. Notez que cet APK doit répondre aux critères suivants :
- Il doit être aligné à l'aide d'une fermeture éclair.
- Vous ne devez plus modifier le nom du package ni la clé de signature privée par la suite (le gestionnaire de paquets Android n'autorise pas les mises à niveau si l'une de ces modifications est apportée).
- Elle ne doit pas dépasser 50 mégaoctets.
- Il doit être compilé à l'aide de la dernière version du GDK.

Mettre en œuvre le flux d'authentification

Le schéma suivant illustre le flux d'authentification de base pour GDK Glassware:

Pour implémenter le flux d'authentification :

Lorsque les utilisateurs activent votre application Glassware dans MyGlass, ils sont redirigés vers votre URL d'authentification. Ces requêtes incluent un paramètre de requête nommé userToken que vous devrez utiliser ultérieurement.

Avertissement : Ne stockez pas ce jeton utilisateur. Il ne doit être utilisé que par les points de terminaison d'authentification de Google pour mapper la requête à l'utilisateur à l'origine de la session uniquement. Il ne contient aucune information pouvant être utilisée pour identifier de manière persistante l'utilisateur. Il n'est pas garanti que le jeton soit identique si l'utilisateur s'authentifie plusieurs fois avec le même Glassware ou s'il s'authentifie avec d'autres Glassware du même développeur.
L'utilisateur saisit ses identifiants sur votre page d'authentification.

Votre serveur valide les identifiants de l'utilisateur. Si les identifiants sont valides, effectuez un appel d'API Mirror à la méthode mirror.accounts.insert. Cette méthode nécessite que vous spécifiiez le champ d'application https://www.googleapis.com/auth/glass.thirdpartyauth lorsque vous créez votre objet de service Mirror. Des exemples d'appel de cette API à l'aide d'HTTP brut ou de Java sont présentés dans les exemples de création de compte.

Les paramètres et le corps de la requête que vous fournissez ci-dessous représentent les mêmes informations que vous fourniriez au AccountManager d'Android si vous créiez le compte directement sur l'appareil.

Nom de propriété	Valeur	Description
`features[]`	liste de chaînes	Liste des fonctionnalités (voir `AccountManager.hasFeatures`).
`password`	chaîne	Mot de passe du compte (voir `AccountManager.getPassword`). Nous vous recommandons de ne pas stocker le mot de passe réel de l'utilisateur dans ce champ, mais de l'utiliser pour stocker des données privées de longue durée, telles qu'un jeton d'actualisation.
`userData[]`	liste d'objets	Une ou plusieurs paires de données utilisateur associées au compte (voir `AccountManager.getUserData`).
`userData[].key`	chaîne	Clé associée à une paire clé/valeur de données utilisateur spécifique.
`userData[].value`	chaîne	Valeur associée à une paire clé-valeur de données utilisateur spécifique.
`authTokens[]`	liste d'objets	Un ou plusieurs jetons d'authentification associés au compte (voir `AccountManager.getAuthToken`).
`authTokens[].type`	chaîne	Type du jeton d'autorisation.
`authTokens[].authToken`	chaîne	Le jeton d'authentification.

À la réception de la requête mirror.account.insert, l'API Mirror transfère le compte sur le ou les appareils Glass de l'utilisateur, où vous pouvez désormais y accéder à l'aide de la classe AccountManager.

Flux d'authentification recommandés

Suivez ces consignes pour implémenter un flux d'authentification convivial :

Optimisez votre parcours pour les appareils mobiles.
Si votre flux comporte un champ d'application et que l'utilisateur les annule, affichez un message d'erreur bien conçu.
Assurez-vous que les portées que vous demandez sont effectivement utilisées dans votre application Glassware.
Si un compte utilisateur peut être associé, assurez-vous de l'associer.
Dans la mesure du possible, les données utilisateur doivent être sauvegardées dans le cloud.

Pour assurer la cohérence de l'authentification des applications Glassware, utilisez l'un des flux d'authentification suivants :

Miroir ou hybride sans compte

Après avoir activé l'option dans MyGlass, l'URL d'authentification s'ouvre dans un pop-up.
L'utilisateur est alors directement redirigé vers les niveaux d'accès pour qu'il l'accepte.
Une fois que l'utilisateur a accepté ou annulé les champs d'application, fermez le pop-up.

Dupliquer avec un compte

Après avoir activé l'option dans MyGlass, l'URL d'authentification s'ouvre dans un pop-up.
- Si l'utilisateur est déjà connecté à votre service, redirigez-le directement vers les champs d'application.
- Si l'utilisateur n'est pas connecté, affichez les champs de connexion, autorisez-le à se connecter à votre service, puis envoyez-le aux champs d'étendue.
- Si l'utilisateur ne possède pas de compte, fournissez un lien pour en créer un. Les utilisateurs doivent pouvoir créer un compte dans le cadre du processus d'installation.
L'utilisateur accepte les niveaux d'accès.
- Si votre Glassware comporte des paramètres configurables, redirigez l'utilisateur vers la page des paramètres en sélectionnant des valeurs par défaut raisonnables.
- Si votre Glassware ne dispose pas de paramètres configurables, redirigez l'utilisateur vers une page de confirmation. Fermez le pop-up si aucune configuration supplémentaire n'est requise.

Hybride avec un compte

Une fois l'option activée dans MyGlass, votre URL d'authentification s'ouvre dans un pop-up.
- Si l'utilisateur est déjà connecté à votre service, redirigez-le directement vers les champs d'application.
- Si l'utilisateur n'est pas connecté, affichez les champs de connexion, autorisez-le à se connecter, puis envoyez-le aux champs d'étendue.
- Si l'utilisateur ne possède pas de compte, fournissez un lien pour en créer un.
L'utilisateur accepte les champs d'application.
Envoyez une requête à l'API Mirror pour insérer le compte GDK.
- Redirigez l'utilisateur vers la page des paramètres avec des valeurs par défaut raisonnables sélectionnées.
- Envoyez à l'utilisateur une page de confirmation. Fermez la fenêtre pop-up si aucune configuration supplémentaire n'est requise.

Mise en miroir ou hybride avec un compte et des champs d'application personnalisés

Une fois l'option activée dans MyGlass, votre URL d'authentification s'ouvre dans un pop-up.
- Si l'utilisateur est déjà connecté à votre service, envoyez-le vers vos champs d'application internes.
- Si l'utilisateur n'est pas connecté, affichez les champs de connexion, autorisez-le à se connecter, puis envoyez-les vers vos champs d'application internes.
- Si l'utilisateur ne possède pas de compte, fournissez un lien permettant de créer un compte.
Lorsque l'utilisateur accepte vos champs d'application personnalisés, redirigez-le vers les champs d'application de Google.
Envoyez une requête à l'API Mirror pour insérer le compte GDK.
- Redirigez l'utilisateur vers la page des paramètres avec des valeurs par défaut raisonnables sélectionnées.
- Envoyez à l'utilisateur une page de confirmation. Fermez le pop-up si aucune configuration supplémentaire n'est requise.

Miroir ou hybride avec une application Android/iPhone

Une fois l'option activée dans MyGlass, votre URL d'authentification s'ouvre dans un pop-up.
L'utilisateur est alors redirigé directement vers les champs d'application à accepter.
Une fois que l'utilisateur a accepté les champs d'application :
- Si l'utilisateur dispose de l'application associée et qu'il est authentifié, fermez la fenêtre pop-up.
- Si ce n'est pas le cas, redirigez l'utilisateur vers un interstitiel qui l'invite à télécharger l'application à partir du Google Play Store ou de l'iOS Store.
Après avoir installé l'application et authentifié, fermez la fenêtre pop-up.

GDK et pas de compte

Pour cela, il suffit d'activer ou de désactiver Glassware dans MyGlass.

GDK avec un compte

Une fois l'option activée dans MyGlass, votre URL d'authentification s'ouvre dans un pop-up.
- Si l'utilisateur est déjà connecté à votre service, redirigez-le vers l'écran de confirmation.
- Si l'utilisateur n'est pas connecté, affichez les champs de connexion, autorisez-le à se connecter, puis redirigez-le vers l'écran de confirmation.
- Si l'utilisateur ne possède pas de compte, fournissez un lien permettant de créer un compte.
L'utilisateur accepte les champs d'application.
Envoyez une requête à l'API Mirror pour insérer le compte GDK.
Affichez l'écran de confirmation, puis fermez-le après l'avoir affiché pendant une courte période.

Exemples de création de compte

Utilisez les bibliothèques clientes pour l'API Mirror lorsque cela est possible. Cela facilite l'appel de mirror.accounts.insert pour créer le compte.

Exemple HTTP brut

L'exemple ci-dessous n'affiche que l'URL de la requête et un exemple du corps JSON attendu. Il est beaucoup plus compliqué d'effectuer des requêtes HTTP brutes au nom d'un compte de service (consultez Utiliser OAuth 2.0 pour les applications de serveur à serveur pour en savoir plus). Par conséquent, nous vous recommandons d'utiliser si possible l'une des bibliothèques clientes de l'API Google pour simplifier cette opération.

Méthode de la requête et URL :

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

Corps de la requête :

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

Remplacez {userToken} dans l'URL de la requête par le jeton transmis à votre URL d'authentification à l'étape 1 de la section Implémenter le flux d'authentification.

Exemple Java

Cet exemple montre comment utiliser la bibliothèque cliente Java pour appeler 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();
  }
}

Récupérer les comptes sur Glass

La récupération et l'utilisation d'objets Account sur Glass est semblable à l'utilisation de l'AccountManager Android standard.

Déclarez les autorisations de fichier manifeste suivantes dans votre fichier AndroidManifest.xml :

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

Récupérez les comptes de la verrerie :

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.

Récupérez un jeton d'autorisation à partir de 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);