Intégrer reCAPTCHA aux applications Android

Cette page explique comment intégrer reCAPTCHA dans votre application Android.

Si vous souhaitez proposer des défis visuels pour le trafic suspect, vous pouvez utiliser l'API SafetyNet reCAPTCHA.

Le SDK utilise la réflexion et le code dynamique pour permettre la modification et l'affinement du système de détection dans les applications/SDK déployées existantes. L'ensemble des classes disponibles dans le système est limité à une liste contrôlée pour éviter toute interférence avec l'application.

Important :Prenez note du règlement concernant les abandons et l'arrêt, et prévoyez de mettre à niveau le SDK régulièrement.

Avant de commencer

1. Préparez votre environnement pour reCAPTCHA.

2. Créez une clé reCAPTCHA pour la plate-forme d'applications Android.

   Vous pouvez également copier l'ID d'une clé reCAPTCHA existante pour Android en effectuant l'une des opérations suivantes :

   • Pour copier l'ID d'une clé existante à partir de la console Google Cloud, procédez comme suit : effectuer les opérations suivantes:

     1. Accédez à la page reCAPTCHA.

        Accéder à reCAPTCHA

     2. Dans la liste des clés reCAPTCHA, pointez sur la clé que vous souhaitez copier, puis cliquez sur
   • Pour copier l'ID d'une clé existante à l'aide de l'API REST, utilisez la méthode projects.keys.list.
   • Pour copier l'ID d'une clé existante à l'aide de la gcloud CLI, procédez comme suit : utilisez la commande gcloud recaptcha keys list.

Préparer votre environnement Android

Avertissement : Ne migrez pas vers le SDK Android 18.2.0, car cela pourrait rendre votre application inutilisable en raison de certaines erreurs internes. Pour éviter ces problèmes, migrez directement au SDK Android 18.2.1 ou version ultérieure. Pour en savoir plus, consultez les rapport de problème sur GitHub.

Appareil Android natif

1. Préparez votre environnement de développement en téléchargeant et en installant la dernière version d'Android Studio.

2. Assurez-vous que la valeur minimale du SDK Android est définie sur API 23 : Android 6.0 (Marshmallow). Vous pouvez définir la version minimale du SDK de votre application sur l'API 19 ou créer une nouvelle application mobile.

3. Si vous créez une application mobile, créez une application de test un nouveau projet Android Studio:

   1. Sélectionnez Empty Activity (Activité vide). Si vous souhaitez utiliser Jetpack Compose dans votre application, sélectionnez Activité Compose vide.
   2. Définissez la langue sur kotlin.
   3. Définissez la valeur du SDK minimal sur API 23 : Android 6.0 (Marshmallow).

4. Assurez-vous que le dépôt Maven de Google google() figure dans la liste des dans le fichier build.gradle au niveau du projet, comme indiqué dans extrait suivant:

   allprojects {
       repositories {
           google()
       }
   }
   

   Pour en savoir plus, consultez les informations sur le dépôt Maven de Google.

5. Pour ajouter la dépendance de l'API reCAPTCHA, ajoutez la règle de compilation suivante à la section dependencies du fichier build.gradle au niveau de l'application.

     implementation 'com.google.android.recaptcha:recaptcha:18.6.1'
   

   Pour en savoir plus sur l'ajout de dépendances dans les applications Android, consultez la section Ajouter des dépendances de compilation.

6. Ajouter une autorisation Internet entre la première balise <manifest> et la première <application> dans le fichier manifeste de votre application (par exemple, AndroidManifest.xml). Cette autorisation est nécessaire, car le L'API reCAPTCHA implique des opérations réseau.

   <manifest ...>
   
       <uses-permission android:name="android.permission.INTERNET" />
   
       <application ...>
       ...
     </application>
   </manifest>
   

7. Si vous souhaitez utiliser des bibliothèques AndroidX dans votre nouveau projet, compilez le SDK vers Android 9.0 ou version ultérieure et ajoutez l'extrait de code suivant à votre gradle.properties.

   android.useAndroidX=true
   android.enableJetifier=true
   

   Pour en savoir plus, consultez Migrer vers AndroidX.

Flutter

Pour obtenir des instructions détaillées sur l'utilisation de reCAPTCHA via Flutter, consultez la documentation Flutter.

React Native

Pour obtenir des instructions détaillées sur l'utilisation de reCAPTCHA via React Native, consultez la documentation React Native.

Intégrer reCAPTCHA à votre application Android

1. Instanciez un client à l'aide de la clé reCAPTCHA (KEY_ID) que vous que vous avez créée pour votre application Android.

   Remarque : Vous ne devez utiliser le client reCAPTCHA qu'une seule fois pendant la durée de vie de votre application.

   Kotlin avec fetchClient

   La méthode fetchClient renvoie immédiatement un client et démarre initialiser le SDK en arrière-plan. Il réessaie la communication avec le serveur reCAPTCHA en cas d'échec réseau.

   class CustomApplication : Application() {
   
       private lateinit var recaptchaClient: RecaptchaClient
   
       override fun onCreate() {
         super.onCreate()
         initializeRecaptchaClient()
       }
   
       private fun initializeRecaptchaClient() {
         lifecycleScope.launch {
           try {
             recaptchaClient = Recaptcha.fetchClient(application, "KEY_ID")
           } catch(e: RecaptchaException) {
             // Handle errors ...
             // See "Handle errors" section
           }
         }
       }
   }
   

   Java avec fetchClient

   public final class CustomApplication extends Application {
     @Nullable private RecaptchaTasksClient recaptchaTasksClient = null;
   
     @Override
     protected void onCreate() {
       super.onCreate();
       initializeRecaptchaClient();
     }
   
     private void initializeRecaptchaClient() {
       Recaptcha
         .fetchTaskClient(getApplication(), "KEY_ID")
         .addOnSuccessListener(
             this,
             new OnSuccessListener<RecaptchaTasksClient>() {
               @Override
               public void onSuccess(RecaptchaTasksClient client) {
                 MainActivity.this.recaptchaTasksClient = client;
               }
             })
         .addOnFailureListener(
             this,
             new OnFailureListener() {
               @Override
               public void onFailure(@NonNull Exception e) {
                 // Handle errors ...
                 // See "Handle errors" section
               }
             });
     }
   }
   

   L'initialisation du SDK peut prendre plusieurs secondes. Pour atténuer cette latence, initialisez le client le plus tôt possible, par exemple pendant la Appel onCreate() d'une classe Application personnalisée. Vous ne devez pas bloquer le blocage des éléments de l'interface utilisateur dans le SDK reCAPTCHA.

   Remarque :Si l'API transmet une instance de ApiException à onFailure(), vous devez gérer chaque code d'état possible que vous pouvez récupérer en utilisant getStatusCode() Pour en savoir plus, consultez Gérez les erreurs.

2. Pour chaque action de votre application protégée par reCAPTCHA, appelez la méthode execute en transmettant une RecaptchaAction : reCAPTCHA fournit un ensemble intégré d'actions et, si nécessaire, vous pouvez créer des actions personnalisées.

   L'extrait de code suivant montre comment utiliser execute pour protéger une action LOGIN.

   Kotlin

   private fun executeLoginAction() {
     lifecycleScope.launch {
       recaptchaClient
         .execute(RecaptchaAction.LOGIN)
         .onSuccess { token ->
           // Handle success ...
           // See "What's next" section for instructions
           // about handling tokens.
         }
         .onFailure { exception ->
           // Handle errors ...
         }
     }
   }
   

   Java

   private void executeLoginAction(View v) {
     assert recaptchaTasksClient != null;
     recaptchaTasksClient
       .executeTask(RecaptchaAction.LOGIN)
       .addOnSuccessListener(
           this,
           new OnSuccessListener<String>() {
             @Override
             public void onSuccess(String token) {
               // Handle success ...
               // See "What's next" section for instructions
               // about handling tokens.
             }
           })
       .addOnFailureListener(
           this,
           new OnFailureListener() {
             @Override
             public void onFailure(@NonNull Exception e) {
               // Handle errors ...
             }
           });
   }
   

Remarque :Le Google Play Store vous demande de remplir les données de l'application avant d'importer votre application sur le Play Store. Examiner Exigences concernant le communiqué sur les données de Google Play pour trouver les informations dont vous avez besoin sur le SDK reCAPTCHA pour Android pour remplir le formulaire Sécurité des données.

Passer de la méthode getClient à la méthode fetchClient

La méthode fetchClient renvoie un objet RecaptchaClient qui retente l'initialisation en cas de défaillance du réseau. Si l'application n'a pas accès au réseau lors de la création du client, le client continue de réessayer et s'initialise correctement lorsqu'un réseau est acquis.

Si vous appelez execute(timeout) et que le client n'est pas encore prêt, il tente s'initialiser avant de renvoyer un jeton ou un code RecaptchaErrorCode.

L'exemple suivant montre comment passer de getClient à fetchClient.

Kotlin

// Migrate from getClient
private fun initializeWithGetClient() {
  lifecycleScope.launch {
    Recaptcha.getClient(application, "KEY_ID")
      .onSuccess { client ->
        recaptchaClient = client
      }
      .onFailure { exception ->
        // Handle errors ...
      }
  }
}

 // Migrate to fetchClient
private fun initializeWithFetchClient() {
  lifecycleScope.launch {
    try {
      recaptchaClient = Recaptcha.fetchClient(application, "KEY_ID")
    } catch(e: RecaptchaException){
      // Handle errors ...
    }
  }
}

Java

  // Migrate from getTasksClient
  private void initializeWithGetTasksClient() {
    Recaptcha
      .getTasksClient(getApplication(), "KEY_ID")
      .addOnSuccessListener(
          this,
          new OnSuccessListener<RecaptchaTasksClient>() {
            @Override
            public void onSuccess(RecaptchaTasksClient client) {
              recaptchaTasksClient = client;
            }
          })
      .addOnFailureListener(
          this,
          new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception e) {
              // Handle errors ...
            }
          });
  }

  // Migrate to fetchTaskClient
  private void initializeWithFetchTaskClient() {
    Recaptcha
      .fetchTaskClient(getApplication(), "KEY_ID")
      .addOnSuccessListener(
          this,
          new OnSuccessListener<RecaptchaTasksClient>() {
            @Override
            public void onSuccess(RecaptchaTasksClient client) {
              recaptchaTasksClient = client;
            }
          })
      .addOnFailureListener(
          this,
          new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception e) {
              // Handle errors ...
            }
          });
  }

Définir un délai d'expiration pour les appels d'API

Vous pouvez spécifier une valeur de délai avant expiration pour les API execute à l'aide de la propriété withTimeout.

Kotlin

• Définissez le délai avant expiration lorsque vous appelez execute.

      lifecycleScope.launch {
        recaptchaClient
          .execute(RecaptchaAction.LOGIN(), timeout = 10000L)
          .onSuccess { token ->
            // Handle success ...
            // See "What's next" section for instructions
            // about handling tokens.
          }
          .onFailure { exception ->
            // Handle errors ...
            // See "Handle errors" section
          }
      }
  

  Cet extrait de code définit le délai avant expiration de execute sur 10 secondes.

Java

• Définissez le délai avant expiration lorsque vous appelez execute.

    recaptchaTasksClient
      .executeTask(RecaptchaAction.custom("redeem"), 10000L)
      .addOnSuccessListener(
          this,
          new OnSuccessListener<String>() {
            @Override
            public void onSuccess(String token) {
              // Handle success ...
              // See "What's next" section for instructions
              // about handling tokens.
            }
          })
      .addOnFailureListener(
          this,
          new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception e) {
              // Handle errors ...
              // See "Handle errors" section
            }
          });
  

  Cet extrait de code définit le délai avant expiration de execute sur 10 secondes.

Gérer les erreurs

Si votre application ne peut pas communiquer avec le service reCAPTCHA, il se peut que l'API ait rencontré une erreur. Vous devez ajouter une logique dans votre application pour gérer correctement ces erreurs.

Pour en savoir plus sur les mesures d'atténuation des erreurs courantes liées aux API, consultez la page RecaptchaErrorCode.

Document de référence sur les API

Pour obtenir une documentation de référence complète sur l'API reCAPTCHA pour Android, consultez la page com.google.android.recaptcha.

Étape suivante

• Pour évaluer le jeton de réponse reCAPTCHA, créez une évaluation.

  Remarque : Les jetons de réponse reCAPTCHA sont évalués et annotés à partir de votre serveur backend, et non de l'appareil mobile.