Crea nuovi account con un tocco

Se supporti l'accesso con gli Account Google, puoi utilizzare l'accesso One Tap per offrire agli utenti un'esperienza di creazione dell'account fluida che non li rimuove mai dal contesto della tua app.

UI di registrazione con un tocco

Quando visualizzi l'UI di One Tap, agli utenti viene chiesto di creare un nuovo account con utilizzando uno degli Account Google sul dispositivo. Se l'utente sceglie per continuare, ricevi un token ID con informazioni di base del profilo: nome, la foto del profilo e l'indirizzo email verificato, che puoi utilizzare per per creare il nuovo account.

L'implementazione della creazione di un account One Tap prevede due parti:

  • Integrazione del client One Tap nell'app, procedura descritta in questa pagina. È praticamente la stessa cosa dell'accesso One Tap, ma con alcune differenze configurazione.
  • In aggiunta al tuo backend la possibilità di creare account utente dall'ID Google di cui abbiamo parlato in Utilizzo dei token ID sul backend.

Dove dovrei utilizzare la registrazione One Tap?

Il luogo più efficace in cui offrire l'iscrizione One Tap agli utenti è un contesto in cui l'accesso abiliterebbe nuove funzionalità. Innanzitutto, prova a far accedere l'utente con un credenziale salvata. Se non vengono trovate credenziali salvate, proponi di crearne una nuova account per l'utente.

Prima di iniziare

Configura il progetto della console API di Google e il progetto Android come descritto in Iniziare a utilizzare l'accesso One Tap.

1. Configurare il client One Tap

Per configurare il client One Tap per la creazione dell'account:

  • Non abilitare le richieste di credenziali delle password. La registrazione con un tocco è possibile solo con l'autenticazione basata su token).

  • Attiva le richieste di token ID Google utilizzando setGoogleIdTokenRequestOptions() e queste impostazioni:

Java

public class YourActivity extends AppCompatActivity {

  // ...

  private SignInClient oneTapClient;
  private BeginSignInRequest signUpRequest;

  @Override
  public void onCreate(@Nullable Bundle savedInstanceState,
                       @Nullable PersistableBundle persistentState) {
      super.onCreate(savedInstanceState, persistentState);

      oneTapClient = Identity.getSignInClient(this);
      signUpRequest = BeginSignInRequest.builder()
              .setGoogleIdTokenRequestOptions(GoogleIdTokenRequestOptions.builder()
                      .setSupported(true)
                      // Your server's client ID, not your Android client ID.
                      .setServerClientId(getString(R.string.your_web_client_id))
                      // Show all accounts on the device.
                      .setFilterByAuthorizedAccounts(false)
                      .build())
              .build();

      // ...
  }
}

Kotlin

class YourActivity : AppCompatActivity() {
    // ...

    private lateinit var oneTapClient: SignInClient
    private lateinit var signUpRequest: BeginSignInRequest

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        oneTapClient = Identity.getSignInClient(this)
        signUpRequest = BeginSignInRequest.builder()
            .setGoogleIdTokenRequestOptions(
                BeginSignInRequest.GoogleIdTokenRequestOptions.builder()
                    .setSupported(true)
                    // Your server's client ID, not your Android client ID.
                    .setServerClientId(getString(R.string.your_web_client_id))
                    // Show all accounts on the device.
                    .setFilterByAuthorizedAccounts(false)
                    .build())
            .build()
        // ...
    }
    // ...
}

2. Tieni traccia dell'annullamento dell'UI di One Tap

Dovresti monitorare se l'utente ha già rifiutato di utilizzare One Tap registrati chiudendo il messaggio o toccandolo all'esterno. Può essere semplice come una proprietà booleana dell'attività. (vedi Interrompi la visualizzazione di One Tap UI di seguito.

3. Visualizzare l'interfaccia utente per la registrazione One Tap

Se l'utente non ha rifiutato di utilizzare One Tap per creare un nuovo account, chiama metodo beginSignIn() dell'oggetto client e collega i listener al relativo Task i resi. In genere le app eseguono questo passaggio quando la richiesta di accesso One Tap non trova Le credenziali salvate, ovvero nel listener di errori dell'accesso richiesta.

Il client One Tap chiamerà il listener di successo se l'utente dispone di uno o più Account Google configurati sul dispositivo. Nel listener riuscito, ottieni lo stato intent dal risultato di Task e passarlo a startIntentSenderForResult() avvia l'UI di One Tap.

Se l'utente non ha Account Google sul dispositivo, il client One Tap chiamerà il listener di errori. In questo caso non è necessaria alcuna azione: puoi è sufficiente continuare a presentare l'esperienza dell'app senza eseguire l'accesso e l'utente potrà registrati con il normale flusso di creazione dell'account.

Java

oneTapClient.beginSignIn(signUpRequest)
        .addOnSuccessListener(this, new OnSuccessListener<BeginSignInResult>() {
            @Override
            public void onSuccess(BeginSignInResult result) {
                try {
                    startIntentSenderForResult(
                            result.getPendingIntent().getIntentSender(), REQ_ONE_TAP,
                            null, 0, 0, 0);
                } catch (IntentSender.SendIntentException e) {
                    Log.e(TAG, "Couldn't start One Tap UI: " + e.getLocalizedMessage());
                }
            }
        })
        .addOnFailureListener(this, new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception e) {
                // No Google Accounts found. Just continue presenting the signed-out UI.
                Log.d(TAG, e.getLocalizedMessage());
            }
        });

Kotlin

oneTapClient.beginSignIn(signUpRequest)
    .addOnSuccessListener(this) { result ->
        try {
            startIntentSenderForResult(
                result.pendingIntent.intentSender, REQ_ONE_TAP,
                null, 0, 0, 0)
        } catch (e: IntentSender.SendIntentException) {
            Log.e(TAG, "Couldn't start One Tap UI: ${e.localizedMessage}")
        }
    }
    .addOnFailureListener(this) { e ->
        // No Google Accounts found. Just continue presenting the signed-out UI.
        Log.d(TAG, e.localizedMessage)
    }

4. Gestire la risposta dell'utente

La risposta dell'utente alla richiesta di registrazione con One Tap verrà segnalata alla tua app utilizzando il metodo onActivityResult() delle tue attività. Se l'utente ha scelto di creare account, il risultato sarà un token ID Google. Se l'utente ha rifiutato di registrarsi, chiudendo l'interfaccia utente di One Tap o toccandola all'esterno, il risultato con il codice RESULT_CANCELED. La tua app deve gestire entrambe le possibilità.

Crea un account con un token ID Google

Se l'utente ha scelto di registrarsi con un Account Google, puoi ottenere un token ID per all'utente trasmettendo i dati sull'intent da onActivityResult() a One Tap metodo getSignInCredentialFromIntent() del cliente. La credenziale avrà un proprietà googleIdToken non null.

Utilizza il token ID per creare un account nel tuo backend (vedi Autenticazione con un backend utilizzando token ID) ed eseguire l'accesso dell'utente.

La credenziale contiene anche eventuali dettagli aggiuntivi richiesti, ad esempio il numero di telefono verificato dell'account, se disponibile.

Java

public class YourActivity extends AppCompatActivity {

  // ...
  private static final int REQ_ONE_TAP = 2;  // Can be any integer unique to the Activity.
  private boolean showOneTapUI = true;
  // ...

  @Override
  protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
      super.onActivityResult(requestCode, resultCode, data);

      switch (requestCode) {
          case REQ_ONE_TAP:
              try {
                  SignInCredential credential = oneTapClient.getSignInCredentialFromIntent(data);
                  String idToken = credential.getGoogleIdToken();
                  if (idToken !=  null) {
                      // Got an ID token from Google. Use it to authenticate
                      // with your backend.
                      Log.d(TAG, "Got ID token.");
                  }
              } catch (ApiException e) {
                  // ...
              }
              break;
      }
  }
}

Kotlin

class YourActivity : AppCompatActivity() {

    // ...
    private val REQ_ONE_TAP = 2  // Can be any integer unique to the Activity
    private var showOneTapUI = true
    // ...

    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)

        when (requestCode) {
             REQ_ONE_TAP -> {
                try {
                    val credential = oneTapClient.getSignInCredentialFromIntent(data)
                    val idToken = credential.googleIdToken
                    when {
                        idToken != null -> {
                            // Got an ID token from Google. Use it to authenticate
                            // with your backend.
                            Log.d(TAG, "Got ID token.")
                        }
                        else -> {
                            // Shouldn't happen.
                            Log.d(TAG, "No ID token!")
                        }
                    }
                } catch (e: ApiException) {
                    // ...
            }
        }
    }
    // ...
}

Interrompere la visualizzazione dell'UI di One Tap

Se l'utente ha rifiutato di accedere, la chiamata al numero getSignInCredentialFromIntent() restituirà un ApiException con il codice di stato CommonStatusCodes.CANCELED. In questo caso, dovresti interrompere temporaneamente la visualizzazione dell'interfaccia utente di accesso One Tap. per non infastidire gli utenti con richieste ripetute. Nell'esempio che segue a questo scopo impostando una proprietà nell'attività, che utilizza per Stabilire se offrire all'utente l'accesso One Tap; ma puoi anche salva un valore in SharedPreferences o utilizza un altro metodo.

È importante implementare la limitazione di frequenza delle richieste di accesso One Tap. In caso contrario, e un utente annulla diverse richieste di seguito, il client One Tap all'utente non verrà inviata alcuna richiesta per le prossime 24 ore.

Java

public class YourActivity extends AppCompatActivity {

  // ...
  private static final int REQ_ONE_TAP = 2;  // Can be any integer unique to the Activity.
  private boolean showOneTapUI = true;
  // ...

  @Override
  protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
      super.onActivityResult(requestCode, resultCode, data);

      switch (requestCode) {
          case REQ_ONE_TAP:
              try {
                  // ...
              } catch (ApiException e) {
                  switch (e.getStatusCode()) {
                      case CommonStatusCodes.CANCELED:
                          Log.d(TAG, "One-tap dialog was closed.");
                          // Don't re-prompt the user.
                          showOneTapUI = false;
                          break;
                      case CommonStatusCodes.NETWORK_ERROR:
                          Log.d(TAG, "One-tap encountered a network error.");
                          // Try again or just ignore.
                          break;
                      default:
                          Log.d(TAG, "Couldn't get credential from result."
                                  + e.getLocalizedMessage());
                          break;
                  }
              }
              break;
      }
  }
}

Kotlin

class YourActivity : AppCompatActivity() {

    // ...
    private val REQ_ONE_TAP = 2  // Can be any integer unique to the Activity
    private var showOneTapUI = true
    // ...

    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)

        when (requestCode) {
            REQ_ONE_TAP -> {
                try {
                    // ...
                } catch (e: ApiException) {
                    when (e.statusCode) {
                        CommonStatusCodes.CANCELED -> {
                            Log.d(TAG, "One-tap dialog was closed.")
                            // Don't re-prompt the user.
                            showOneTapUI = false
                        }
                        CommonStatusCodes.NETWORK_ERROR -> {
                            Log.d(TAG, "One-tap encountered a network error.")
                            // Try again or just ignore.
                        }
                        else -> {
                            Log.d(TAG, "Couldn't get credential from result." +
                                " (${e.localizedMessage})")
                        }
                    }
                }
            }
        }
    }
    // ...
}

Passaggi successivi

Quando un utente completa la procedura di registrazione a One Tap, ricevi un token ID Google, che include alcune informazioni di base del profilo: indirizzo email, nome completo, e l'URL dell'immagine del profilo. Per molte app queste informazioni sono sufficienti per autenticare l'utente sul backend e creare un nuovo account.

Se hai bisogno di ulteriori informazioni per completare la creazione dell'account, ad esempio la data di nascita dell'utente: presenta all'utente un flusso di dettagli di registrazione, dove richiedi queste informazioni aggiuntive. Quindi, invialo al tuo backend per completare la creazione dell'account.