Lancer l'association de comptes Google directement depuis votre plate-forme

Vous pouvez associer des comptes directement dans votre application mobile. Vos utilisateurs peuvent ainsi associer leur compte sur votre service avec leur compte Google. Le lien établi autorise Google à accéder aux données que l'utilisateur accepte de partager.

Remarque :Le lien à partir de votre plate-forme n'est disponible que sur Android. (bientôt disponible sur le Web)

Cette approche améliore les performances de l'association de compte en engageant les utilisateurs dans le contexte familier de votre application plutôt que dans une conversation avec l'Assistant. Il peut être intégré à l'intégration des utilisateurs, aux paramètres et à d'autres surfaces d'application, ce qui permet de découvrir et d'utiliser votre action de l'Assistant Google. Par exemple, après l'association, vous pouvez proposer de rediriger l'utilisateur directement vers votre action.

用户可享有的优势包括：

• 用户可以在您的应用中开始并完成帐号关联流程，这是他们熟悉的环境。
• 用户无需登录凭据，因为已在设备和您的移动应用中通过身份验证。

开发者获得的好处包括：

• 在移动应用中（例如，在用户设置中，在插页式广告上或用户登录移动应用后）宣传和启动帐号关联，以提高互动度和关联的帐号数量。
• 转化率有所提高，因为用户可以完成的步骤比基于网络的标准 OAuth 流程少。
• 实现您的平台 (Android) 链接的工程工作量很少，因为此流程已利用您现有的 OAuth2.0 实现（假设您已实现一个）。
• 提升了用户流失率，因为用户无需重新输入登录凭据，用更少的步骤就能完成此流程。 在要求用户召回和输入登录凭据的流程中，流失率可能高达 80%。

Fonctionnement

L'association depuis votre plate-forme s'effectue en procédant comme suit :

1. L'utilisateur clique sur un déclencheur d'association ou l'active dans votre application mobile.
2. L'utilisateur sélectionne le compte Google à associer.
   1. L'utilisateur sélectionne un compte Google existant sur l'appareil à associer ou se connecte avec un nouveau compte.
3. L'utilisateur voit des écrans de consentement hébergés par Google et doit accepter pour continuer ou annuler pour arrêter le processus d'association.
4. L'utilisateur voit votre écran de consentement et doit accepter pour continuer ou annuler pour arrêter le processus d'association.
5. L'association est établie entre le compte de l'utilisateur dans votre service et son compte Google.

Figure 1 : Flux d'association depuis votre plate-forme

Conditions requises

Pour implémenter l'association depuis votre plate-forme, vous avez besoin des éléments suivants :

• Une application Android
• Un serveur OAuth 2.0 qui vous appartient, que vous gérez et que vous entretenez, et qui est compatible avec le flux avec code d'autorisation OAuth 2.0 authorization code flow

Configuration

Avant de suivre les étapes ci-dessous, vous devez avoir terminé le processus d'inscription à l'association de comptes registration process.

Configurer votre environnement de développement.

Obtenez la dernière version des services Google Play sur votre hôte de développement :

1. Ouvrez le Android SDK Manager.

Remarque : Si vous configurez votre environnement de développement Android pour la première fois, vous devez examiner et installer les packages recommandés du SDK Android.

1. Sous SDK Tools (Outils SDK), recherchez Google Play services (Services Google Play).

2. Si l'état de ces packages n'est pas "Installed" (Installé), sélectionnez-les tous les deux, puis cliquez sur Install Packages (Installer les packages).

Configurer votre application

1. Dans le fichier build.gradle au niveau du projet, incluez le dépôt Maven de Google dans les sections buildscript et allprojects.

   buildscript {
       repositories {
           google()
       }
   }
   
   allprojects {
       repositories {
           google()
       }
   }
   

2. Ajoutez les dépendances de l'API "Associer à Google" au fichier Gradle au niveau de l'application de votre module, qui est généralement app/build.gradle :

   dependencies {
     implementation 'com.google.android.gms:play-services-auth:21.6.0'
   }
   

Ajouter la compatibilité avec l'association depuis votre plate- forme

Le flux d'association depuis votre plate-forme entraîne l'enregistrement par Google d'un jeton d'accès fourni par votre service. Le consentement doit être obtenu avant de renvoyer le jeton à l'utilisateur.

Suivez les étapes ci-dessous pour obtenir le consentement de l'utilisateur et renvoyer un jeton de code d'autorisation via le SDK des services Google Play.

1. Créez un PendingIntent qui peut lancer votre activité de consentement. Le consentement est lancé par l'API Services Play. Vous devrez fournir un PendingIntent (qui sera appelé consentPendingIntent par souci de clarté) lorsque l'API est appelée.

   Kotlin

   // Build a PendingIntent that can launch the consent activity
   val consentPendingIntent = buildConsentPendingIntent()
   

   Java

   // Build a PendingIntent that can launch your consent activity
   PendingIntent consentPendingIntent =
             buildConsentPendingIntent();
   

2. Créez l'activité correspondante pour gérer l'intent de consentement.

   Kotlin

     class ConsentActivity : AppCompatActivity
   
     private fun onConsentAccepted() {
         // Obtain a token (for simplicity, we’ll ignore the async nature
         // of the following call)
         val token = getToken()
         val intent = Intent()
                     .putExtra(SaveAccountLinkingTokenRequest.EXTRA_TOKEN,
                               token)
         setResult(Activity.RESULT_OK, intent)
         finish()
     }
   
     private fun onConsentRejectedOrCanceled() {
         setResult(Activity.RESULT_CANCELED)
         finish()
     }
   

   Java

     public class ConsentActivity extends AppCompatActivity {
       ...
       private void onConsentAccepted() {
         // Obtain a token (for simplicity, we’ll ignore the async nature of
         // the following call
         String token = getToken();
         Intent intent = new Intent();
         intent.putExtra(SaveAccountLinkingTokenRequest.EXTRA_TOKEN, token);
         setResult(Activity.RESULT_OK, intent);
         finish();
       }
   
       private void onConsentRejectedOrCanceled() {
         setResult(Activity.RESULT_CANCELED, null);
         finish();
       }
    }
   
   

   Nous supposons que les méthodes onConsentAccpeted() et onConsentRejectedOrCanceled() sont appelées si l'utilisateur accepte ou refuse/annule votre consentement, respectivement.

3. Créez une requête pour enregistrer le jeton et, entre autres paramètres de configuration, transmettez le PendingIntent créé à l'étape 1 ci-dessus.

   Kotlin

     // Create an ActivityResultLauncher which registers a callback for the
     // Activity result contract
     val activityResultLauncher = registerForActivityResult(
       ActivityResultContracts.StartIntentSenderForResult())
       { result ->
         if (result.resultCode == RESULT_OK) {
           // Successfully finished the flow and saved the token
         } else {
           // Flow failed, for example the user may have canceled the flow
         }
       }
   
     // Build token save request
     val request = SaveAccountLinkingTokenRequest.builder()
       .setTokenType(SaveAccountLinkingTokenRequest.TOKEN_TYPE_AUTH_CODE)
       .setConsentPendingIntent(consentPendingIntent)
       .setServiceId("service-id-of-and-defined-by-developer")
       //Set the scopes that the token is valid for on your platform
       .setScopes(scopes)
       .build()
   
      // Launch consent activity and retrieve token
      Identity.getCredentialSavingClient(this)
        .saveAccountLinkingToken(request)
        .addOnSuccessListener( saveAccountLinkingTokenResult -> {
           if (saveAccountLinkingTokenResult.hasResolution()) {
             val pendingIntent = saveAccountLinkingTokenResult
                                 .getPendingIntent()
             val intentSenderRequest = IntentSenderRequest
                                       .Builder(pendingIntent).build()
             activityResultLauncher.launch(intentSenderRequest)
           } else {
              // This should not happen, let’s log this
              Log.e(TAG, "Failed to save token");
           }
         })
         .addOnFailureListener(e -> Log.e(TAG, “Failed to save token”, e))
   

   Java

     // Create an ActivityResultLauncher which registers a callback for the
     // Activity result contract
     ActivityResultLauncher<IntentSenderRequest>
         activityResultLauncher =
         registerForActivityResult(new ActivityResultContracts
                                       .StartIntentSenderForResult(),
                                   result -> {
         if (result.getResultCode() == RESULT_OK) {
             // Successfully finished the flow and saved the token
         } else {
             // Flow failed, for example the user may have canceled the flow
         }
     });
   
    // Build token save request
    SaveAccountLinkingTokenRequest request =
       SaveAccountLinkingTokenRequest.builder()
           .setTokenType(
               SaveAccountLinkingTokenRequest.TOKEN_TYPE_AUTH_CODE)
           .setConsentPendingIntent(consentPendingIntent)
           .setServiceId("service-id-of-and-defined-by-developer")
           //Set the scopes that the token is valid for on your platform
           .setScopes(scopes)
           .build();
   
     // Launch consent activity and retrieve token
     Identity.getCredentialSavingClient(this)
         .saveAccountLinkingToken(request)
         .addOnSuccessListener(
             saveAccountLinkingTokenResult -> {
               if (saveAccountLinkingTokenResult.hasResolution()) {
                 // Launch the resolution intent
                 PendingIntent pendingIntent =
                     saveAccountLinkingTokenResult.getPendingIntent();
                 IntentSenderRequest intentSenderRequest =
                     new IntentSenderRequest.Builder(pendingIntent).build();
                 activityResultLauncher.launch(intentSenderRequest);
               } else {
                 // This should not happen, let’s log this
                 Log.e(TAG, "Failed to save token");
               }
             })
         .addOnFailureListener(e -> Log.e(TAG, "Failed to save token", e));
     ```
   

Les étapes ci-dessus invitent l'utilisateur à donner son consentement et renvoient un code d'autorisation à Google.

Bonnes pratiques

• Votre application doit indiquer l'état de l'association à l'utilisateur à l'aide d'un bouton, d'un bouton à bascule ou d'un élément visuel similaire.

  

  Figure 1 : Exemple d'image d'état de l'association

• Vous devez informer l'utilisateur une fois l'association réussie (par exemple, en affichant une notification toast, en déclenchant un changement d'état du bouton à bascule ou en redirigeant l'utilisateur vers une page distincte indiquant que l'association a réussi).

• Vous devez envisager d'inviter les utilisateurs de l'application à associer leurs comptes, idéalement en fonction de signaux forts indiquant que l'association leur serait bénéfique.

• Une fois l'association réussie, vous devez donner aux utilisateurs un exemple de ce qu'ils peuvent faire avec le compte associé. Par exemple, si vous venez d'associer un service de streaming musical, demandez à votre Assistant Google de diffuser de la musique.

• Permettez aux utilisateurs de gérer leurs comptes associés, y compris de les dissocier. Dirigez-les vers la page de gestion de leurs comptes Google associés, c'est-à-dire https://myaccount.google.com/accountlinking.

Référence

Documentation de référence de l'API d'authentification Android