Créez des comptes d'un simple geste

Si vous acceptez la connexion avec des comptes Google, vous pouvez utiliser le client de connexion One Tap pour offrir à vos utilisateurs une expérience de création de compte fluide qui ne les fait jamais sortir du contexte de votre application.

UI d'inscription 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. Si l'utilisateur choisit de continuer, vous obtenez un jeton d'ID contenant des informations de base sur son profil (son nom, sa photo de profil et son 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 se fait en deux étapes :

  • Intégrer le client One Tap à votre application, comme décrit sur cette page. La procédure est pratiquement identique à celle de la connexion avec One Tap, mais avec quelques différences de configuration.
  • Ajouter à votre backend la possibilité de créer des comptes utilisateur à partir de jetons d'ID Google, comme indiqué dans 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 permettrait d'accéder à de nouvelles fonctionnalités. Tout d'abord, essayez de connecter l'utilisateur avec un identifiant enregistré. Si aucune information d'identification enregistrée n'est trouvée, proposez à l'utilisateur de créer un compte.

Avant de commencer

Configurez votre projet de console Google Cloud et votre projet Android comme décrit dans Premiers pas avec la connexion 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 en un clic n'est possible qu'avec l'authentification basée sur des jetons.)

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

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'UI One Tap

Vous devez vérifier 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. Par exemple, vous pouvez utiliser une propriété booléenne de votre activité. (voir Arrêter d'afficher l'interface utilisateur One Tap ci-dessous).

3. Afficher l'UI 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 au Task qu'il renvoie. Les applications effectuent généralement cette étape lorsqu'une demande de connexion avec One Tap ne trouve aucun identifiant enregistré, c'est-à-dire dans l'écouteur d'échec de la demande de connexion :

  • Écouteur de réussite : 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 lancer l'UI One Tap.

  • Écouteur d'échec : si l'utilisateur ne possède aucun compte Google sur l'appareil, le client One Tap appelle l'écouteur d'échec. Dans ce cas, aucune action n'est nécessaire : continuez à présenter l'expérience de l'application sans connexion, et l'utilisateur pourra s'inscrire via votre 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. Si l'utilisateur a refusé de s'inscrire, soit en fermant l'UI One Tap, soit en appuyant en dehors de celle-ci, le résultat renvoie 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 (consultez S'authentifier auprès d'un backend à l'aide de jetons d'ID) et connectez l'utilisateur.

L'identifiant contient également toutes les informations supplémentaires que vous avez demandées, telles 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 d'afficher l'UI One Tap

Si l'utilisateur a refusé de se connecter, l'appel à getSignInCredentialFromIntent() génère une exception 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 pour ne pas importuner vos utilisateurs avec des invites répétées. L'exemple suivant y parvient en définissant une propriété sur l'activité, qu'il utilise pour déterminer s'il doit 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 d'affilée, le client One Tap ne l'invitera pas à se connecter 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 processus d'inscription avec One Tap, vous recevez 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 authentifier l'utilisateur sur le backend et créer un compte.

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