O SDK do Glass Explorer Edition foi descontinuado. Esta documentação continua sendo uma referência histórica.

Esta página foi traduzida pela API Cloud Translation.

Autenticação para Glassware GDK

Se o GDK Glassware precisar autenticar usuários em um serviço da Web, o GDK fornece uma API que permite ao usuário inserir as credenciais ao instalar seu Glassware.

Com essa API, você oferece uma experiência consistente para usuários do Glass e evitar a sobrecarga da implementação da sua própria com esquemas de autenticação personalizados.

Como criar uma conta de serviço de API do Google

Quando a autenticação é configurada corretamente, o back-end do seu app da Web usa a API Mirror para enviar as informações da conta para o Glass depois que eles forem autenticados no seu serviço.

Para acessar essa API, crie um projeto de API do Google e depois criar um ID do cliente para uma "conta de serviço" (e não um "aplicativo da Web"). De com uma conta de serviço, os usuários não precisam conceder acesso permissão do aplicativo para enviar suas credenciais para o Google Glass e não você verá a página de permissões do OAuth e sua própria autenticação novamente.

Para criar essa conta:

Acesse o Google Developers Console.
Clique no botão Criar projeto e insira as informações solicitadas.
Depois de criar o projeto, anote o Número do projeto, que de que você vai precisar mais tarde.
Em APIs e auth, clique em APIs e ative a API Google Mirror para seu novo projeto.
Em APIs e auth, clique em Credenciais e depois em Criar novo cliente ID. Marque a caixa Conta de serviço para criar um novo OAuth 2.0 ID do cliente para o projeto.
Uma janela pop-up informará que o download da chave privada está sendo feito. ao seu computador e fornece a senha dessa chave privada. Depois de fechar esta janela, não será possível fazer o download deste vídeo ou a senha novamente. Se eles forem perdidos, você precisará criar um.
Anote o endereço de e-mail da conta de serviço, que será necessário mais tarde para fazer a chamada de API.

Como fornecer metadados sobre seu Glassware

Quando estiver pronto para enviar seu Glassware, você precisará fornecer o informações a seguir. Isso nos permite configurar seu Glassware para autenticado corretamente quando for implementado.

Seu URL de autenticação, para onde os usuários são redirecionados quando ele ativa o Glassware no MyGlass.
O tipo de conta (a string que você usará ao chamar a função APIs AccountManager do Android no dispositivo Glass)
O nome do pacote do seu aplicativo no AndroidManifest.xml
O ID numérico do projeto da API do Google que você criou acima de
O APK para fazer upload no MyGlass. Para testes, você só precisa fornecer o APK uma vez para processar o download inicial quando o Glassware for ativada no MyGlass, Depois disso, é possível iterar e depurar localmente substituindo o APK no seu dispositivo. Observe que este APK precisa atender os seguintes critérios:
- Ele precisa estar alinhado ao zip.
- Não é permitido fazer mudanças no nome do pacote nem na assinatura particular. depois disso. O gerenciador de pacotes Android não permite atualizações se uma dessas alterações for feita).
- Ela precisa ter menos de 50 megabytes.
- Ele precisa ser compilado com a versão mais recente do GDK.

Como implementar o fluxo de autenticação

O diagrama a seguir mostra o fluxo básico de autenticação para Glassware do GDK:

Para implementar o fluxo de autenticação:

Quando os usuários ativam o Glassware no MyGlass, eles são redirecionados ao seu URL de autenticação. Essas solicitações incluem um parâmetro de consulta chamado userToken que você vai precisar usar mais tarde.

Aviso: não armazene esse token de usuário. Ele só deve ser usado pelo endpoints de autenticação para mapear a solicitação de volta para o usuário originado apenas durante essa sessão e não contém informações que possam ser usada para identificar o usuário de forma persistente. Não há garantia de que o token O mesmo se o usuário autenticar com o mesmo Glassware várias vezes ou se o usuário for autenticado com diferentes Glassware do mesmo desenvolvedor.
O usuário insere as credenciais na página de autenticação.

Seu servidor valida as credenciais do usuário. Se as credenciais forem válidas, faça uma chamada da API Mirror para o método mirror.accounts.insert. Esse método exige que você especifique escopo https://www.googleapis.com/auth/glass.thirdpartyauth ao criar seu Espelhar objeto de serviço. Exemplos de como fazer essa chamada de API usando dados brutos HTTP ou Java são mostrados nos exemplos de criação de conta.

Os parâmetros e o corpo da solicitação fornecidos abaixo representam os mesmos informações que você forneceria ao AccountManager do Android se em vez de criarem a conta diretamente no dispositivo.

Nome da propriedade	Valor	Descrição
`features[]`	lista de strings	Uma lista de recursos (consulte `AccountManager.hasFeatures`).
`password`	string	A senha da conta (consulte `AccountManager.getPassword`). Recomendamos que você não armazene a senha real do usuário este campo, mas sim para armazenar dados de longa duração como um token de atualização.
`userData[]`	lista de objetos	Um ou mais pares de dados do usuário associados à conta (consulte `AccountManager.getUserData`).
`userData[].key`	string	Chave associada a uma determinada chave-valor de dados do usuário. par.
`userData[].value`	string	Valor associado a uma determinada chave-valor de dados do usuário. par.
`authTokens[]`	lista de objetos	Um ou mais tokens de autorização associados à conta (consulte `AccountManager.getAuthToken`).
`authTokens[].type`	string	O tipo do token de autenticação.
`authTokens[].authToken`	string	O token de autenticação.

Ao receber a solicitação mirror.account.insert, a API Mirror envia a conta para os dispositivos Google Glass do usuário, onde agora você pode acessá-la usando a classe AccountManager.

Fluxos de autenticação recomendados

Siga estas diretrizes para implementar um fluxo de autenticação fácil de usar:

Otimize seu fluxo para dispositivos móveis.
Se seu fluxo tem um escopo e o usuário o cancela, tenha um mensagem de erro.
Verifique se os escopos solicitados estão realmente sendo usados no Glassware.
Conecte uma conta de usuário, caso ela possa ser conectada.
Sempre que possível, os dados dos usuários devem ser armazenados em backup na nuvem.

Para manter a consistência na autenticação do Glassware, use uma das seguintes opções: fluxos de autenticação:

Espelhado ou híbrido sem uma conta

Depois de ativar o MyGlass, seu URL de autenticação será aberto em um pop-up.
Isso leva o usuário diretamente aos escopos para aceitação.
Depois que o usuário aceitar ou cancelar os escopos, feche o pop-up.

Espelhar com uma conta

Depois de ativar o MyGlass, seu URL de autenticação será aberto em um pop-up.
- Se o usuário já tiver feito login no seu serviço, envie-o diretamente aos escopos.
- Se o usuário não estiver conectado, mostrar os campos de login e permitir que ele faça login no serviço e enviá-las aos escopos.
- Se o usuário não tiver uma conta, forneça um link para criar um do Compute Engine. Os usuários devem ter uma forma de criar uma conta como parte do processo de fluxo de instalação.
O usuário aceita escopos.
- Se o Glassware tiver configurações configuráveis, encaminhe o usuário para o página de configurações com padrões razoáveis selecionados.
- Se o Glassware não tiver definições configuráveis, encaminhe o usuário para uma página de confirmação. Feche o pop-up se nenhuma configuração adicional for feita. obrigatórios.

Híbrido com uma conta

Depois de ativar o MyGlass, seu URL de autenticação será aberto em um pop-up.
- Se o usuário já tiver feito login no seu serviço, envie-o diretamente aos escopos.
- Se o usuário não estiver conectado, mostrar os campos de login e permitir que ele faça login e enviá-las para os escopos.
- Se o usuário não tiver uma conta, forneça um link para criar uma.
O usuário aceita escopos.
Envie uma solicitação à API Mirror para inserir a conta do GDK.
- Encaminhar o usuário à página de configurações com padrões razoáveis selecionados.
- Enviar uma página de confirmação ao usuário. Feche o pop-up se não houver é obrigatória.

Espelhamento ou híbrido com uma conta e escopos personalizados

Depois de ativar o MyGlass, seu URL de autenticação será aberto em um pop-up.
- Se o usuário já tiver feito login em seu serviço, envie-o para seu escopos internos
- Se o usuário não estiver conectado, mostrar os campos de login e permitir que ele faça login e enviá-las para seus escopos internos
- Se o usuário não tiver uma conta, forneça um link para criar uma.
Quando o usuário aceitar seus escopos personalizados, direcione o usuário para os escopos do Google.
Envie uma solicitação à API Mirror para inserir a conta do GDK.
- Encaminhar o usuário à página de configurações com padrões razoáveis selecionados.
- Enviar uma página de confirmação ao usuário. Feche o pop-up se não houver é obrigatória.

Espelhamento ou híbrido com um app para Android/iPhone

Depois de ativar o MyGlass, seu URL de autenticação será aberto em um pop-up.
Isso leva o usuário diretamente aos escopos para aceitação.
Depois que o usuário aceitar escopos:
- Se o usuário tiver o aplicativo complementar e estiver autenticado, feche o pop-up janela.
- Caso contrário, direcione o usuário a um intersticial que o direcione para fazer o download do na Google Play Store ou na loja do iOS
Depois de instalar o app e fazer a autenticação, feche a janela pop-up

GDK e nenhuma conta

Para esse fluxo, basta ativar o Glassware no MyGlass.

GDK com uma conta

Depois de ativar o MyGlass, seu URL de autenticação será aberto em um pop-up.
- Se o usuário já tiver feito login em seu serviço, envie-o para o tela de confirmação.
- Se o usuário não estiver conectado, exiba os campos de login, permita que ele fazer login e enviá-las para a tela de confirmação.
- Se o usuário não tiver uma conta, forneça um link para criar uma.
O usuário aceita escopos.
Envie uma solicitação à API Mirror para inserir a conta do GDK.
Mostre a tela de confirmação e feche-a após mostrá-la por um em um curto período de tempo.

Exemplos de criação de conta

Usar as bibliotecas de cliente para a API Mirror quando possível. Isso torna a chamada mirror.accounts.insert para criar a conta mais facilmente.

Exemplo de HTTP bruto

O exemplo abaixo mostra apenas o URL da solicitação e um exemplo do o corpo JSON esperado. Como fazer solicitações HTTP brutas em nome de um serviço é muito mais complicada (consulte Usar o OAuth 2.0 para aplicativos de servidor para servidor para todos os detalhes). Por isso, recomendamos que você use uma das APIs do Google bibliotecas de cliente se possível, para facilitar isso.

Método de solicitação e URL:

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

Corpo da solicitação:

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

Substitua {userToken} no URL da solicitação pelo token que foi transmitido para seu URL de autenticação na etapa 1 do Implementar o fluxo de autenticação.

Exemplo em Java

Este exemplo mostra como usar a biblioteca de cliente Java para chamar 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();
  }
}

Como recuperar contas no Glass

Como recuperar e usar Account no Google Glass é semelhante a usar o AccountManager

Declare as seguintes permissões de manifesto no arquivo AndroidManifest.xml:

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

Recuperar as contas do 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.

Recupere um token de autenticação do 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);