Créez des comptes d'un simple geste

Si vous autorisez la connexion avec des comptes Google, vous pouvez également utiliser le client de connexion avec One Tap pour offrir à vos utilisateurs une expérience de création de compte fluide, sans jamais les faire quitter le contexte de votre application.

Interface utilisateur d'inscription avec One Tap

Lorsque vous affichez l'interface utilisateur One Tap, les utilisateurs sont invités à créer un compte dans votre application à l'aide de l'un des comptes Google de leur appareil. S'ils choisissent de continuer, vous obtenez un jeton d'ID contenant des informations de base sur leur profil (nom, photo du profil et adresse e-mail validée), que vous pouvez utiliser pour créer le compte.

L'implémentation de la création de compte One Tap comporte deux parties :

  • L'intégration du client One Tap dans votre application, décrite sur cette page. Elle est en grande partie identique à l'utilisation de la connexion avec One Tap, mais avec quelques différences de configuration.
  • L'ajout à votre backend de la possibilité de créer des comptes utilisateur à partir de jetons d'ID Google, abordé dans la section Utiliser des jetons d'ID sur le backend.

Où dois-je utiliser l'inscription avec One Tap ?

L'endroit le plus efficace pour proposer l'inscription avec One Tap aux utilisateurs est un contexte dans lequel la connexion activerait de nouvelles fonctionnalités. Commencez par essayer de connecter l'utilisateur avec des identifiants enregistrés. Si aucun identifiant enregistré n'est trouvé, proposez de créer un compte pour l'utilisateur.

Avant de commencer

Configurez votre projet dans la console Google APIs et votre projet Android comme décrit dans Premiers pas avec la connexion avec One Tap.

1. Configurer le client One Tap

Pour configurer le client One Tap pour la création de compte, procédez comme suit :

  • N'activez pas les demandes d'identifiants de mot de passe. (L'inscription One Tap n'est possible qu'avec l'authentification par jeton.)

  • Activez les requêtes de jeton d'ID Google à l'aide de setGoogleIdTokenRequestOptions() et de ces paramètres :

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. Suivre l'annulation de l'interface utilisateur One Tap

Vous devez suivre si l'utilisateur a déjà refusé d'utiliser l'inscription One Tap en fermant l'invite ou en appuyant en dehors de celle-ci. Cela peut être aussi simple qu'une propriété booléenne de votre activité. (Voir Arrêter l'affichage de l'interface utilisateur One Tap UI ci-dessous.)

3. Afficher l'interface utilisateur d'inscription avec One Tap

Si l'utilisateur n'a pas refusé d'utiliser One Tap pour créer un compte, appelez la méthode beginSignIn() de l'objet client et associez des écouteurs à la Task qu'il renvoie. Les applications effectuent généralement cette étape lorsqu'une requête de connexion avec One Tap ne trouve aucun identifiant enregistré, c'est-à-dire dans l'écouteur d'échec de la requête de connexionin.

Le client One Tap appelle l'écouteur de réussite si l'utilisateur a configuré un ou plusieurs comptes Google sur l'appareil. Dans l'écouteur de réussite, récupérez l'intent en attente à partir du résultat Task et transmettez-le à startIntentSenderForResult() pour démarrer l'interface utilisateur One Tap.

Si l'utilisateur n'a aucun compte Google sur l'appareil, le client One Tap appelle l'écouteur d'échec. Dans ce cas, aucune action n'est nécessaire : vous pouvez simplement continuer à présenter l'expérience de déconnexion de l'application, et l'utilisateur peut s'inscrire avec le flux de création de compte normal.

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. Gérer la réponse de l'utilisateur

La réponse de l'utilisateur à l'invite d'inscription avec One Tap sera signalée à votre application à l'aide de la méthode onActivityResult() de votre Activity. Si l'utilisateur a choisi de créer un compte, le résultat sera un jeton d'ID Google. S'il a refusé de s'inscrire, soit en fermant l'interface utilisateur One Tap, soit en appuyant en dehors de celle-ci, le résultat sera renvoyé avec le code RESULT_CANCELED. Votre application doit gérer les deux possibilités.

Créer un compte avec un jeton d'ID Google

Si l'utilisateur a choisi de s'inscrire avec un compte Google, vous pouvez obtenir un jeton d'ID pour l'utilisateur en transmettant les données d'intent de onActivityResult() à la méthode getSignInCredentialFromIntent() du client One Tap. L'identifiant aura une propriété googleIdToken non nulle.

Utilisez le jeton d'ID pour créer un compte sur votre backend (voir S'authentifier auprès d'un backend à l'aide de jetons d'ID) et connectez l'utilisateur.

L'identifiant contient également tous les détails supplémentaires que vous avez demandés, tels que le numéro de téléphone validé du compte, le cas échéant.

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) {
                    // ...
            }
        }
    }
    // ...
}

Arrêter l'affichage de l'interface utilisateur One Tap

Si l'utilisateur a refusé de se connecter, l'appel à getSignInCredentialFromIntent() génère une ApiException avec un code d'état CommonStatusCodes.CANCELED. Dans ce cas, vous devez arrêter temporairement d'afficher l'interface utilisateur de connexion avec One Tap afin de ne pas ennuyer vos utilisateurs avec des invites répétées. L'exemple suivant y parvient en définissant une propriété sur l'Activity, qu'il utilise pour déterminer s'il faut proposer à l'utilisateur la connexion avec One Tap. Toutefois, vous pouvez également enregistrer une valeur dans SharedPreferences ou utiliser une autre méthode.

Il est important d'implémenter votre propre limitation du débit des invites de connexion avec One Tap. Si vous ne le faites pas et qu'un utilisateur annule plusieurs invites de suite, le client One Tap ne l'invitera pas pendant les 24 heures suivantes.

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})")
                        }
                    }
                }
            }
        }
    }
    // ...
}

Étapes suivantes

Lorsqu'un utilisateur termine le flux d'inscription avec One Tap, vous obtenez un jeton d'ID Google, qui inclut des informations de base sur son profil : son adresse e-mail, son nom complet et l'URL de sa photo de profil. Pour de nombreuses applications, ces informations suffisent pour vous authentifier l'utilisateur sur le backend et créer un compte.

Si vous avez besoin d'informations supplémentaires pour créer un compte (par exemple, la date de naissance de l'utilisateur), présentez-lui un flux de détails d'inscription dans lequel vous demandez ces informations supplémentaires. Ensuite, envoyez-les à votre backend pour terminer la création du compte.