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 GDK Glassware doit authentifier les utilisateurs auprès d'un service web, le GDK fournit une API qui permet à l'utilisateur de saisir ses identifiants lorsqu'il installez vos appareils Glassware.

Grâce à cette API, vous fournissez aux utilisateurs pour les utilisateurs de Google Glass tout en évitant les frais généraux liés à la mise en œuvre des schémas d'authentification personnalisés.

Créer un compte de service pour les API Google

Lorsque l'authentification est correctement configurée, le backend utilise l'API Mirror pour transmettre les données informations de compte à Glass après s'être authentifié auprès de votre service.

Pour accéder à cette API, créez un projet d'API Google, puis créer un ID client pour un "compte de service" (et non une "application Web"). Par à l'aide d'un compte de service, les utilisateurs n'ont pas besoin d'accorder séparément votre l'autorisation à l'application de transférer ses identifiants vers Glass et la page des autorisations OAuth et votre propre système d'authentification à nouveau.

Pour créer ce compte:

Accédez à la Google Play Console.
Cliquez sur le bouton Créer un projet et saisissez les informations demandées.
Une fois le projet créé, notez le numéro du projet, qui dont vous aurez besoin ultérieurement.
Sous API et auth, cliquez sur API, puis activez l'API Google Mirror. pour votre nouveau projet.
Sous API et auth, cliquez sur Identifiants, puis sur Créer un client ID vidéo. Pour créer un nouveau protocole OAuth 2.0, cochez la case Compte de service. l'ID client du projet.
Une fenêtre pop-up vous informe que la clé privée est en cours de téléchargement. à 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 ou afficher à nouveau le mot de passe. S'ils sont perdus, vous devez créer 1.
Notez l'adresse e-mail du compte de service, dont vous aurez besoin. pour effectuer l'appel d'API.

Fournir des métadonnées sur vos appareils Glassware

Lorsque vous êtes prêt à envoyer votre appareil Glassware, vous devez fournir le les informations suivantes. Cela nous permet de configurer votre Glassware pour s'authentifier correctement lors de sa mise en œuvre.

Votre URL d'authentification, vers laquelle les utilisateurs sont redirigés lorsque ils allument vos lunettes Glassware dans MyGlass.
Le type de compte (la chaîne que vous utiliserez lorsque vous appelez la méthode API Android AccountManager sur l'appareil Glass)
Le nom de package de votre application à partir de votre AndroidManifest.xml
L'ID numérique de projet d'API Google du projet que vous avez créé au-dessus
Le APK à importer sur MyGlass Pour les tests, il vous suffit de fournir ce fichier APK une fois pour gérer le téléchargement initial lorsque votre Glassware est activé depuis MyGlass ; vous pouvez itérer et déboguer en local en écrasant l'APK sur votre appareil. Notez que cet APK doit respecter les critères suivants: <ph type="x-smartling-placeholder">
- Il doit être aligné à l'aide d'une fermeture éclair.
- Vous ne devez pas modifier le nom du package ni la signature privée (le gestionnaire de packages Android n'autorise pas les mises à niveau si l'un de ces changements change).
- Elle doit être inférieure à 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 allument votre Glassware dans MyGlass, ils sont redirigés à votre URL d'authentification. Ces requêtes incluent un paramètre de requête nommé userToken que vous aurez besoin d'utiliser plus tard.

Avertissement :Ne stockez pas ce jeton utilisateur. Elle ne doit être utilisée que par points de terminaison d'authentification pour mapper la requête à l'utilisateur d'origine pendant cette session uniquement et ne contient aucune information pouvant être utilisé pour identifier l’utilisateur de façon persistante. Il n'est pas garanti que le jeton soit même chose si l'utilisateur s'authentifie plusieurs fois avec le même Glassware. ou si l'utilisateur s'authentifie avec des applications différentes 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 vers la méthode mirror.accounts.insert. Cette méthode vous devez spécifier le paramètre https://www.googleapis.com/auth/glass.thirdpartyauth lorsque vous créez votre Mettez en miroir l'objet de service. Voici quelques exemples illustrant comment effectuer cet appel d'API en utilisant des fichiers Les méthodes HTTP ou Java sont présentées 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 le même des informations que vous fourniriez au AccountManager d'Android si vous créaient le compte directement sur l'appareil.

Nom de propriété	Valeur	Description
`features[]`	liste de chaînes	Une liste des fonctionnalités (voir <ph type="x-smartling-placeholder"></ph> `AccountManager.hasFeatures`).
`password`	chaîne	Le mot de passe du compte (voir <ph type="x-smartling-placeholder"></ph> `AccountManager.getPassword`). Nous vous recommandons de ne pas stocker le véritable mot de passe de l'utilisateur ce champ, mais utilisez-le plutôt pour stocker des données privées de longue durée des données comme un jeton d'actualisation.
`userData[]`	liste d'objets	Une ou plusieurs paires de données utilisateur associées au compte (voir la section `AccountManager.getUserData`).
`userData[].key`	chaîne	Clé associée à une clé-valeur de données utilisateur particulière .
`userData[].value`	chaîne	Valeur associée à une clé-valeur de données utilisateur particulière .
`authTokens[]`	liste d'objets	Un ou plusieurs jetons d'authentification associés au compte (voir la section `AccountManager.getAuthToken`).
`authTokens[].type`	chaîne	Type du 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 vers le ou les appareils Glass de l'utilisateur, où vous pouvez maintenant 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 flux pour les appareils mobiles.
Si votre flux comporte une portée et que l'utilisateur les annule, assurez-vous s'affiche.
Assurez-vous que les champs d'application que vous demandez sont effectivement utilisés dans votre Glassware.
Si un compte utilisateur peut être connecté, assurez-vous de le faire.
Dans la mesure du possible, les données utilisateur doivent être sauvegardées dans le cloud.

Pour assurer la cohérence de l'authentification Glassware, utilisez l'une des méthodes suivantes flux d'authentification:

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 la fenêtre 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 aux niveaux d'accès.
- Si l'utilisateur n'est pas connecté, afficher les champs de connexion et l'autoriser à se connecter à votre service, puis les envoyer aux niveaux d'accès.
- Si l'utilisateur n'a pas de compte, fournissez un lien pour créer un Google Cloud. Les utilisateurs doivent avoir la possibilité de créer un compte processus d'installation.
L'utilisateur accepte les niveaux d'accès.
- Si les paramètres de votre Glassware sont configurables, redirigez l'utilisateur vers le avec des valeurs par défaut raisonnables sélectionnées.
- Si votre Glassware ne dispose pas de paramètres configurables, renvoyez l'utilisateur vers une page de confirmation. Fermez la fenêtre pop-up si aucune configuration supplémentaire n'est obligatoire.

Hybride 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 aux niveaux d'accès.
- Si l'utilisateur n'est pas connecté, afficher les champs de connexion pour lui permettre de se connecter puis les envoyer aux niveaux d'accès.
- Si l'utilisateur n'a pas de compte, fournissez un lien pour en créer un.
L'utilisateur accepte les niveaux d'accès.
Envoyez une requête à l'API Mirror pour insérer le compte GDK.
- Redirigez l'utilisateur vers la page des paramètres où des valeurs par défaut raisonnables sont sélectionnées.
- Envoyez une page de confirmation à l'utilisateur. Fermez la fenêtre contextuelle si aucune est requise.

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

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 vers votre champs d'application internes
- Si l'utilisateur n'est pas connecté, afficher les champs de connexion pour lui permettre de se connecter et les envoyer à vos niveaux d'accès internes
- Si l'utilisateur n'a pas de compte, fournissez un lien pour en créer un.
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 où des valeurs par défaut raisonnables sont sélectionnées.
- Envoyez une page de confirmation à l'utilisateur. Fermez la fenêtre contextuelle si aucune est requise.

Miroir ou hybride avec une application Android/iPhone

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é les niveaux d'accès: <ph type="x-smartling-placeholder">
- Si l'utilisateur dispose de l'application associée et qu'il est authentifié, fermez la fenêtre pop-up. fenêtre.
- Si ce n'est pas le cas, redirigez l'internaute vers un interstitiel qui l'invite à télécharger depuis le Google Play Store ou l'iOS Store
Après avoir installé l'application et vous être authentifié, fermez la fenêtre pop-up

GDK et aucun compte

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

GDK 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 vers la l'écran de confirmation.
- Si l'utilisateur n'est pas connecté, afficher les champs de connexion et l'autoriser à se connecter, puis le rediriger vers l'écran de confirmation.
- Si l'utilisateur n'a pas de compte, fournissez un lien pour en créer un.
L'utilisateur accepte les niveaux d'accès.
Envoyez une requête à l'API Mirror pour insérer le compte GDK.
Affichez l'écran de confirmation, puis fermez-le pendant une sur une courte période.

Exemples de création de compte

Utiliser les bibliothèques clientes pour l'API Mirror lorsque cela est possible. Cela permet d'appeler mirror.accounts.insert pour créer le compte plus facilement.

Exemple HTTP brut

L'exemple ci-dessous ne montre que l'URL de la requête et un exemple corps JSON attendu. Envoyer des requêtes HTTP brutes pour le compte d'un service votre compte est beaucoup plus complexe (voir Utiliser OAuth 2.0 pour l'authentification serveur à serveur ). Nous vous recommandons donc d'utiliser l'une de nos API bibliothèques clientes pour vous faciliter la tâche.

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 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 des comptes dans Glass

Récupérer et utiliser Account sur les lunettes Glass s'apparente à l'utilisation AccountManager

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