Le SDK Glass Explorer Edition est obsolète. Cette documentation vous servira de référence historique.

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

Authentification pour GDK Glassware

Si votre Glass GDK doit authentifier les utilisateurs auprès d'un service Web, GDK fournit une API qui leur permet de saisir leurs identifiants lorsqu'ils installent votre Glassware.

En utilisant cette API, vous offrez une expérience cohérente aux utilisateurs de Glass et vous évitez les frais généraux liés à la mise en œuvre de vos propres schémas d'authentification personnalisés.

Créer un compte de service d'API Google

Une fois l'authentification correctement configurée, le backend de votre application Web utilise l'API Mirror pour transmettre les informations de compte des utilisateurs à 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'accorder séparément à votre application l'autorisation de transférer leurs identifiants vers Glass. Ils ne verront alors 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 Create Project (Créer un projet), puis saisissez les informations demandées.
Une fois le projet créé, notez le numéro de projet. Vous en aurez besoin ultérieurement.
Sous API et authentification, cliquez sur API et 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 informe 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. S'ils sont perdus, vous devez en créer un autre.
Notez l'adresse e-mail du compte de service, car vous en aurez besoin ultérieurement pour appeler l'API.

Fournir des métadonnées sur votre Glassware

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 allument votre Glassware dans MyGlass.
Le type de compte (la chaîne que vous utiliserez pour appeler les API Android AccountManager sur l'appareil Glass)
Le nom du package de l'application, issu de votre AndroidManifest.xml
L'ID numérique du projet d'API Google que vous avez créé ci-dessus
Fichier APK à importer sur MyGlass À des fins de test, vous n'avez besoin de fournir cet APK qu'une seule fois pour gérer le téléchargement initial lorsque votre Glassware est activé à partir de MyGlass. Vous pouvez ensuite effectuer une itération et un débogage localement en écrasant l'APK sur votre appareil. Notez que cet APK doit répondre aux critères suivants :
- Il doit être aligné au format ZIP.
- Vous ne devez pas modifier le nom du package ni la clé de signature privée après cela (le gestionnaire de packages Android n'autorise pas les mises à niveau si l'une de ces modifications est effectuée).
- Sa taille doit être inférieure à 50 mégaoctets.
- Il doit être compilé à l'aide de la dernière version de GDK.

Implémenter 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 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. Elle est uniquement utilisée par les points de terminaison d'authentification de Google pour mapper la requête à l'utilisateur d'origine au cours de cette session uniquement. Elle ne contient aucune information permettant d'identifier l'utilisateur de manière permanente. La présence du jeton n'est pas garantie si l'utilisateur s'authentifie plusieurs fois avec le même Glassware, ou s'il s'authentifie auprès de différents Glassware du même développeur.
L'utilisateur saisit ses identifiants sur la page d'authentification.

Votre serveur valide les identifiants de l'utilisateur. Si les identifiants sont valides, effectuez un appel d'API Mirror vers 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 Miroir. Des exemples de création de cet appel d'API à l'aide de HTTP ou de Java bruts sont présentés dans les exemples de création de compte.

Les paramètres et le corps de la requête que vous indiquez ci-dessous représentent les mêmes informations que celles 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 à longue durée de vie, comme 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 particulière.
`userData[].value`	chaîne	Valeur associée à une paire clé/valeur de données utilisateur particulière.
`authTokens[]`	liste d'objets	Un ou plusieurs jetons d'authentification associés au compte (voir `AccountManager.getAuthToken`).
`authTokens[].type`	chaîne	Type de jeton d'authentification.
`authTokens[].authToken`	chaîne	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, auxquels vous pouvez désormais accéder à l'aide de la classe AccountManager.

Flux d'authentification recommandés

Suivez ces consignes pour mettre en œuvre un processus d'authentification convivial:

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

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

Miroir ou mixte sans compte

Après avoir activé l'option dans MyGlass, votre URL d'authentification s'ouvre dans une fenêtre pop-up.
L'utilisateur est alors directement dirigé vers les habilitations à accepter.
Une fois que l'utilisateur a accepté ou annulé les champs d'application, fermez le pop-up.

Reproduire un compte

Après avoir activé l'option dans MyGlass, votre URL d'authentification s'ouvre dans une fenêtre pop-up.
- Si l'utilisateur est déjà connecté à votre service, dirigez-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'application.
- Si l'utilisateur ne possède pas de compte, fournissez-lui 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 champs d'application.
- Si les paramètres Glassware sont configurables, dirigez l'utilisateur vers la page des paramètres en sélectionnant les paramètres par défaut raisonnables.
- Si vos lunettes Glassware n'ont pas de paramètres configurables, dirigez l'utilisateur vers une page de confirmation. Fermez le pop-up si aucune configuration supplémentaire n'est requise.

Hybride avec un compte

Après avoir activé l'option dans MyGlass, votre URL d'authentification s'ouvre dans une fenêtre pop-up.
- Si l'utilisateur est déjà connecté à votre service, dirigez-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'application.
- Si l'utilisateur ne possède pas de compte, fournissez-lui 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 en sélectionnant les paramètres par défaut raisonnables.
- Envoyez une page de confirmation à l'utilisateur. Fermez le pop-up si aucune configuration supplémentaire n'est requise.

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

Après avoir activé l'option dans MyGlass, votre URL d'authentification s'ouvre dans une fenêtre pop-up.
- Si l'utilisateur est déjà connecté à votre service, dirigez-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-le à vos champs d'application internes
- Si l'utilisateur ne possède pas de compte, fournissez-lui un lien pour en créer un.
Lorsque l'utilisateur accepte vos champs d'application personnalisés, dirigez-le vers les champs d'application Google.
Envoyez une requête à l'API Mirror pour insérer le compte GDK.
- Redirigez l'utilisateur vers la page des paramètres en sélectionnant les paramètres par défaut raisonnables.
- Envoyez une page de confirmation à l'utilisateur. Fermez le pop-up si aucune configuration supplémentaire n'est requise.

Dupliquer ou utiliser une application Android/iPhone

Après avoir activé l'option dans MyGlass, votre URL d'authentification s'ouvre dans une fenêtre pop-up.
L'utilisateur est alors directement dirigé vers les habilitations à 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.
- Sinon, redirigez l'utilisateur vers un interstitiel l'invitant à télécharger l'application depuis le Google Play Store ou iOS.
Après avoir installé l'application et vous être authentifié, fermez la fenêtre pop-up

GDK et aucun compte

Il suffit d'activer Glassware dans MyGlass pour suivre cette procédure.

GDK avec un compte

Après avoir activé l'option dans MyGlass, votre URL d'authentification s'ouvre dans une fenêtre pop-up.
- Si l'utilisateur est déjà connecté à votre service, dirigez-le vers l'écran de confirmation.
- Si l'utilisateur n'est pas connecté, affichez les champs de connexion, autorisez-le à se connecter, puis dirigez-le vers l'écran de confirmation.
- Si l'utilisateur ne possède pas de compte, fournissez-lui 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.
Affichez l'écran de confirmation, puis fermez-le après un court moment.

Exemples de création de compte

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

Exemple de code HTTP brut

L'exemple ci-dessous n'affiche que l'URL de la requête et un exemple de corps JSON attendu. Il est beaucoup plus complexe d'effectuer des requêtes HTTP brutes au nom d'un compte de service (consultez la page Utiliser OAuth 2.0 pour l'authentification serveur à serveur pour en savoir plus). Nous vous recommandons donc d'utiliser l'une de nos bibliothèques clientes d'API Google, si possible.

Méthode et URL de la requête:

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 à l'URL d'authentification à l'étape 1 de la mise en œuvre du 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 des comptes sur Glass

La récupération et l'utilisation d'objets Account sur Glass sont similaires à l'utilisation de 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 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.

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