Integra reCAPTCHA en apps para Android

En esta página, se explica cómo integrar reCAPTCHA en tu app para Android.

El SDK usa reflexión y código dinámico para permitir la modificación y el perfeccionamiento del sistema de detección en las aplicaciones o los SDKs implementados existentes. El conjunto de clases disponibles en el sistema se limita a una lista controlada para evitar interferencias con la aplicación.

Antes de comenzar

1. Prepara tu entorno para reCAPTCHA.

2. Crea una clave de reCAPTCHA para la plataforma de la app para Android.

   Como alternativa, puedes copiar el ID de una clave de reCAPTCHA existente para Android. Para ello, realiza uno de los siguientes pasos:

   • Para copiar el ID de una clave existente desde la consola deGoogle Cloud , haz lo siguiente:

     1. Ve a la página de reCAPTCHA.

        Ir a reCAPTCHA

     2. En la lista de claves de reCAPTCHA, mantén el puntero sobre la clave que deseas copiar y, luego, haz clic en content_copy .
   • Para copiar el ID de una clave existente con la API de REST, usa el método projects.keys.list.
   • Para copiar el ID de una clave existente con la CLI de gcloud, usa el comando gcloud recaptcha keys list.

Prepara tu entorno de Android

Integra reCAPTCHA en tu app para Android

1. Crea una instancia de un cliente con la clave de reCAPTCHA (KEY_ID) que creaste para tu app para Android.

   Kotlin con fetchClient

   El método fetchClient devuelve un cliente de inmediato y comienza a inicializar el SDK en segundo plano. Vuelve a intentar la comunicación con el servidor de reCAPTCHA en caso de fallas de red.

   class CustomApplication : Application() {
   
       private lateinit var recaptchaClient: RecaptchaClient
       // we recommend initializing in a ViewModel
       private val recaptchaScope = CoroutineScope(Dispatchers.IO)
   
       override fun onCreate() {
         super.onCreate()
         initializeRecaptchaClient()
       }
   
       private fun initializeRecaptchaClient() {
         recaptchaScope.launch {
           try {
             recaptchaClient = Recaptcha.fetchClient(application, "KEY_ID")
           } catch(e: RecaptchaException) {
             // Handle errors ...
             // See "Handle errors" section
           }
         }
       }
   }
   

   Java con 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
               }
             });
     }
   }
   

   La inicialización del SDK puede tardar varios segundos en completarse. Para mitigar esta latencia, inicializa el cliente lo antes posible, por ejemplo, durante la llamada onCreate() de una clase Application personalizada. No debes hacer que los elementos de la IU se bloqueen en el SDK de reCAPTCHA.

2. Para cada acción de tu app que esté protegida con reCAPTCHA, llama al método execute y pasa un objeto RecaptchaAction. reCAPTCHA proporciona un conjunto integrado de acciones y, si es necesario, puedes crear acciones personalizadas.

   En el siguiente fragmento de código, se muestra cómo usar execute para proteger una acción de LOGIN.

   Kotlin

   private fun executeLoginAction() {
     recaptchaScope.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 ...
             }
           });
   }
   

Migra del método getClient al método fetchClient

El método fetchClient devuelve un RecaptchaClient que vuelve a intentar la inicialización en caso de fallas de red. Si la app no tiene acceso a la red cuando se crea el cliente, este sigue reintentando y se inicializa correctamente cuando se adquiere una red.

Si llamas a execute(timeout) y el cliente aún no está listo, se intenta inicializar antes de devolver un token o un RecaptchaErrorCode.

En el siguiente ejemplo, se muestra cómo migrar de getClient a fetchClient.

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

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

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

Cómo establecer un tiempo de espera para las llamadas a la API

Puedes especificar un valor de tiempo de espera para las APIs de execute con la propiedad withTimeout.

Soluciona errores

Si tu app no se puede comunicar con el servicio de reCAPTCHA correctamente, es posible que la API haya detectado un error. Deberás agregar lógica en tu app para resolver el error.

Para obtener más detalles sobre las mitigaciones de errores comunes de la API, consulta RecaptchaErrorCode.

Referencia de la API

Para obtener una referencia completa de la API de reCAPTCHA para Android, consulta com.google.android.recaptcha.

¿Qué sigue?

• Para evaluar el token de respuesta de reCAPTCHA, crea una evaluación.