Questa pagina è stata tradotta dall'API Cloud Translation.

Accedi nei giochi Android

Per accedere alla funzionalità dei servizi per i giochi di Google Play, il gioco deve fornire i seguenti elementi: all'account del giocatore che ha eseguito l'accesso. Se il giocatore non è autenticato, il tuo gioco potrebbe riscontrare errori quando effettui chiamate alle API dei servizi per i giochi di Google Play. Questa documentazione descrive come implementare un'esperienza di accesso fluida nel tuo gioco.

Implementare l'accesso dei giocatori

La classe GoogleSignInClient è il punto di ingresso principale per recuperare l'account della classe lettore che ha eseguito l'accesso e per eseguire l'accesso se non l'ha fatto in precedenza nell'app nel dispositivo.

Per creare un client di accesso:

Crea un client di accesso tramite il GoogleSignInOptions come mostrato nello snippet di codice riportato di seguito. Nella GoogleSignInOptions.Builder per configurare il tuo accesso, devi specificare GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN.
```
GoogleSignInOptions signInOptions = GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN;
```
Se vuoi utilizzare un SnapshotsClient, quindi aggiungi .requestScopes(Games.SCOPE_GAMES_SNAPSHOTS) a GoogleSignInOptions.Builder come mostrato nello snippet di codice riportato di seguito:
```
GoogleSignInOptions  signInOptions =
    new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN)
        .requestScopes(Games.SCOPE_GAMES_SNAPSHOTS)
        .build();
```
Attenzione: non richiedere altri ambiti o dati del profilo Google a meno che sono essenziali per il tuo caso d'uso. Qualsiasi altro ambito determina la prima volta l'accesso silenzioso non andrà a buon fine, tranne che per gli utenti che hanno già eseguito l'accesso correttamente su un altro dispositivo.
Chiama il metodo GoogleSignIn.getClient() e trasmettilo le opzioni configurate nei passaggi precedenti. Se la chiamata è correttamente, l'API Accedi con Google restituisce un'istanza GoogleSignInClient

Controllare se il giocatore ha già effettuato l'accesso

Puoi controllare se hai già effettuato l'accesso a un account sul dispositivo corrente utilizzando GoogleSignIn.getLastSignedInAccount() e se questo account dispone già delle autorizzazioni richieste GoogleSignIn.hasPermissions(). Se entrambe le condizioni sono vere, getLastSignedInAccount() restituisce un valore non null e hasPermissions() restituisce true; puoi utilizzare in tutta sicurezza l'account restituito da getLastSignedInAccount(), anche se il dispositivo è offline.

Esecuzione dell'accesso silenzioso

Puoi chiamare silentSignIn() per recuperare l'account del giocatore che ha eseguito l'accesso. e fai in modo che i giocatori accedano senza visualizzare un'interfaccia utente, se hanno hai eseguito l'accesso alla tua app su un altro dispositivo.

Il metodo silentSignIn() restituisce un Task<GoogleSignInAccount>. Una volta completata l'attività, imposti il campo GoogleSignInAccount che hai dichiarato in precedenza all'account di accesso che l'attività o a null, che indica che non è presente alcun utente che ha eseguito l'accesso.

Se il tentativo di accesso silenzioso non va a buon fine, puoi inviare l'intent di accesso per visualizzare un di accesso, come descritto in Eseguire l'accesso interattivo.

Poiché lo stato del player che ha eseguito l'accesso può cambiare quando l'attività non è in primo piano, ha consigliato di chiamare silentSignIn() dal onResume() .

Per eseguire l'accesso in modalità invisibile, procedi nel seguente modo:

Chiama il metodo silentSignIn() sul GoogleSignInClient per avviare il flusso di accesso silenzioso. Questa chiamata restituisce un oggetto Task<GoogleSignInAccount> che contiene un elemento GoogleSignInAccount se accesso silenzioso riuscito.
Gestire l'esito positivo o negativo dell'accesso del giocatore eseguendo l'override OnCompleteListener
- Se l'attività di accesso è riuscita, recupera il GoogleSignInAccount richiamando getResult().
- Se l'accesso non è riuscito, puoi inviare un intent di accesso per avviare un flusso di accesso interattivo. Per un elenco di altri listener di callback che puoi utilizzare, consulta Guida per gli sviluppatori dell'API Tasks e Task Riferimento API.

Il seguente snippet di codice mostra in che modo la tua app può eseguire l'accesso silenzioso:

private void signInSilently() {
  GoogleSignInOptions signInOptions = GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN;
  GoogleSignInAccount account = GoogleSignIn.getLastSignedInAccount(this);
  if (GoogleSignIn.hasPermissions(account, signInOptions.getScopeArray())) {
    // Already signed in.
    // The signed in account is stored in the 'account' variable.
    GoogleSignInAccount signedInAccount = account;
  } else {
    // Haven't been signed-in before. Try the silent sign-in first.
    GoogleSignInClient signInClient = GoogleSignIn.getClient(this, signInOptions);
    signInClient
        .silentSignIn()
        .addOnCompleteListener(
            this,
            new OnCompleteListener<GoogleSignInAccount>() {
              @Override
              public void onComplete(@NonNull Task<GoogleSignInAccount> task) {
                if (task.isSuccessful()) {
                  // The signed in account is stored in the task's result.
                  GoogleSignInAccount signedInAccount = task.getResult();
                } else {
                  // Player will need to sign-in explicitly using via UI.
                  // See [sign-in best practices](http://developers.google.com/games/services/checklist) for guidance on how and when to implement Interactive Sign-in,
                  // and [Performing Interactive Sign-in](http://developers.google.com/games/services/android/signin#performing_interactive_sign-in) for details on how to implement
                  // Interactive Sign-in.
                }
              }
            });
  }
}

@Override
protected void onResume() {
  super.onResume();
  signInSilently();
}

Se il tentativo di accesso silenzioso non va a buon fine, puoi chiamare Da getException() a ottieni un ApiException con il codice di stato dettagliato. Un codice di stato CommonStatusCodes.SIGN_IN_REQUIRED indica che il giocatore deve eseguire un'azione esplicita per accedere. In questo caso, l'app dovrebbe avviare un flusso di accesso interattivo come descritto nella sezione successiva.

Accesso interattivo in corso...

Per accedere con l'interazione con il giocatore, la tua app deve avviare l'intent di accesso. In caso di esito positivo, L'API Accedi con Google mostra un'interfaccia utente che richiede al player di inserire le proprie credenziali per eseguire l'accesso. Questo approccio semplifica lo sviluppo dell'app, poiché l'attività di accesso gestisce scenari come la necessità di aggiornare Google Play Services o di mostrare richieste di consenso, per conto tuo. Il risultato viene restituito tramite onActivityResult di Google.

Per eseguire l'accesso in modo interattivo, segui questi passaggi:

Chiama il numero getSigninIntent() sul GoogleSignInClient per ottenere un intent di accesso, poi chiama startActivity() e trasmettere tale intento. Il seguente snippet di codice mostra come l'app può avvia un flusso di accesso interattivo:

private void startSignInIntent() {
  GoogleSignInClient signInClient = GoogleSignIn.getClient(this,
      GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN);
  Intent intent = signInClient.getSignInIntent();
  startActivityForResult(intent, RC_SIGN_IN);
}

In onActivityResult() il callback, gestirai il risultato dell'intent restituito.

Se l'accesso è riuscito, ricevi il GoogleSignInAccount dell'oggetto GoogleSignInResult.
Se il risultato dell'accesso non è andato a buon fine, dovresti gestire l'errore di accesso (ad esempio, tramite visualizzare un messaggio di errore in un avviso). Il seguente snippet di codice mostra come la tua app può gestire i risultati dell'accesso al player:

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
  super.onActivityResult(requestCode, resultCode, data);
  if (requestCode == RC_SIGN_IN) {
    GoogleSignInResult result = Auth.GoogleSignInApi.getSignInResultFromIntent(data);
    if (result.isSuccess()) {
      // The signed in account is stored in the result.
      GoogleSignInAccount signedInAccount = result.getSignInAccount();
    } else {
      String message = result.getStatus().getStatusMessage();
      if (message == null || message.isEmpty()) {
        message = getString(R.string.signin_other_error);
      }
      new AlertDialog.Builder(this).setMessage(message)
          .setNeutralButton(android.R.string.ok, null).show();
    }
  }
}

Recupero informazioni giocatore

L'elemento GoogleSignInAccount restituito dall'API Accedi con Google non contiene alcun player. informazioni. Se il gioco utilizza informazioni del giocatore, ad esempio il nome visualizzato e l'ID giocatore, puoi seguire questi passaggi per recuperare queste informazioni.

Ottenere un oggetto PlayersClient chiamando il metodo getPlayersClient() e passando GoogleSignInAccount come parametro.
Utilizza i metodi PlayersClient per caricare in modo asincrono Player che contiene le informazioni di un giocatore. Ad esempio, puoi chiamare getCurrentPlayer() per caricare il player a cui è stato eseguito l'accesso. Se l'attività restituisce un ApiException con codice di stato di SIGN_IN_REQUIRED, questo indica che il player deve essere nuovamente autenticato. A questo scopo, chiama GoogleSignInClient.getSignInIntent() per accedere al player in modo interattivo.
Se l'attività restituisce correttamente l'oggetto Player, puoi chiamare i metodi del metodo Player per recuperare dettagli specifici del player (ad esempio, getDisplayName() o getPlayerId().

Fornire un pulsante di accesso

Per fornire un pulsante Accedi con Google standard nel tuo gioco, puoi utilizzare uno di questi approcci:

Includi un elemento com.google.android.gms.common.SignInButton nel layout principale dell'attività; o
Progetta un pulsante di accesso personalizzato in base al branding Accedi con Google linee guida.

Quando gli utenti fanno clic sul pulsante di accesso, il gioco dovrebbe avviare il flusso di accesso inviando un intent di accesso, come descritto in Eseguire l'accesso interattivo.

Questo snippet di codice mostra come aggiungere un pulsante di accesso nel onCreate() per la tua attività.

@Override
protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.activity_sign_in);
  findViewById(R.id.sign_in_button).setOnClickListener(this);
  findViewById(R.id.sign_out_button).setOnClickListener(this);
}

Il seguente snippet di codice mostra come inviare l'intent di accesso quando l'utente fa clic sulla pulsante di accesso.

@Override
public void onClick(View view) {
  if (view.getId() == R.id.sign_in_button) {
    // start the asynchronous sign in flow
    startSignInIntent();
  } else if (view.getId() == R.id.sign_out_button) {
    // sign out.
    signOut();
    // show sign-in button, hide the sign-out button
    findViewById(R.id.sign_in_button).setVisibility(View.VISIBLE);
    findViewById(R.id.sign_out_button).setVisibility(View.GONE);
  }
}

Visualizzazione dei popup dei giochi

Puoi mostrare le visualizzazioni popup nel tuo gioco utilizzando il corso GamesClient. Ad esempio, il tuo gioco possono visualizzare un popup "Ti diamo il bentornato" o "Obiettivi sbloccati". Consentire i servizi per i giochi di Google Play per avviare i popup nelle visualizzazioni del gioco, chiama setViewForPopups() . Puoi personalizzare ulteriormente la posizione del popup nella schermata chiamando setGravityForPopups()

Disconnessione del giocatore

La disconnessione viene effettuata chiamando il metodo signOut() su GoogleSignInClient.

private void signOut() {
  GoogleSignInClient signInClient = GoogleSignIn.getClient(this,
      GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN);
  signInClient.signOut().addOnCompleteListener(this,
      new OnCompleteListener<Void>() {
        @Override
        public void onComplete(@NonNull Task<Void> task) {
          // at this point, the user is signed out.
        }
      });
}