Configura anuncios para inicio de aplicación

Selecciona la plataforma: Android iOS Unity Flutter Android (heredada)

Los anuncios para inicio de aplicación son un formato de anuncio diseñado para los publicadores que desean monetizar las pantallas de carga de sus apps. Los usuarios pueden cerrar los anuncios para inicio de aplicación en cualquier momento. Cuando los usuarios pongan tu app en primer plano, muestra anuncios para inicio de aplicación.

Para obtener más información, consulta la guía de anuncios para inicio de aplicación.

En esta guía, se explica cómo integrar anuncios para inicio de aplicación en una app para Android.

Antes de comenzar

Antes de continuar, haz lo siguiente:

  • Configura el GMA Next-Gen SDK.
  • Usa el ID de unidad de anuncios para inicio de aplicación de prueba ca-app-pub-3940256099942544/9257395921.
    • Cuando compiles y pruebes tu app, asegúrate de usar anuncios de prueba en vez de anuncios activos en fase de producción. Si no usas el ID de unidad de anuncios de prueba, Google puede suspender tu cuenta.
    • Antes de publicar tu app, reemplaza este ID por tu ID de unidad de anuncios.
    • Para obtener detalles sobre los anuncios de prueba del GMA Next-Gen SDK, consulta Habilita los anuncios de prueba.

Información sobre la precarga de anuncios (beta)

La precarga de anuncios en GMA Next-Gen SDK automatiza la carga y el almacenamiento en caché de los anuncios.

La precarga de anuncios ofrece los siguientes beneficios:

  • Administración de referencias: Mantiene las referencias hasta que se muestran los anuncios.
  • Recarga automática: Carga un anuncio nuevo cuando se recupera uno de la caché.
  • Reintentos administrados: Carga un anuncio nuevo cuando no se puede cargar uno.
  • Administración de vencimientos: Actualiza los anuncios antes de que venzan.
  • Optimización de la caché: Optimiza el orden de la caché para publicar el anuncio con la prioridad más alta.

Comienza a precargar anuncios

Para comenzar a precargar anuncios, llama al método start una vez que inicialices GMA Next-Gen SDK. Después de llamar al método start, GMA Next-Gen SDK precarga automáticamente los anuncios y reintenta las solicitudes fallidas para las configuraciones precargadas.

En el siguiente ejemplo, se muestra cómo iniciar la precarga de anuncios:

Kotlin

val adRequest = AdRequest.Builder(adUnitId).build()
val preloadConfig = PreloadConfiguration(adRequest)
AppOpenAdPreloader.start(adUnitId, preloadConfig)

Java

AdRequest adRequest = new AdRequest.Builder(adUnitId).build();
PreloadConfiguration preloadConfig = new PreloadConfiguration(adRequest);
AppOpenAdPreloader.start(adUnitId, preloadConfig);

Reemplaza AD_UNIT_ID por tu ID de unidad de anuncios.

En el ejemplo anterior, se muestra cómo usar el ID de unidad de anuncios como el ID de carga previa. Un ID de precarga es un identificador de cadena que creas para identificar una configuración de precarga de anuncios. Si tu app requiere varios parámetros de configuración de segmentación para el mismo ID de unidad de anuncios, pasa un identificador de cadena personalizado.

La precarga de anuncios no admite el cambio de parámetros de segmentación ni de solicitudes de anuncios. Si necesitas cambiar los parámetros de segmentación entre solicitudes, usa la carga única.

Obtén y muestra los anuncios precargados

Antes de mostrar el anuncio, llama al método pollAd. No almacenes el objeto de anuncio precargado. Cuando llamas al método pollAd, GMA Next-Gen SDK recupera un anuncio disponible y precarga automáticamente el siguiente anuncio en segundo plano. Si no hay anuncios disponibles, GMA Next-Gen SDK no devuelve ninguno.

Cuando tengas un objeto de anuncio disponible, llama al método show para mostrar el anuncio. En el siguiente ejemplo, se muestra cómo recuperar y mostrar un anuncio precargado:

Kotlin

private fun pollAndShowAd(activity: Activity, adUnitId: String) {
  // Polling returns the next available ad and loads another ad in the background.
  val ad = AppOpenAdPreloader.pollAd(adUnitId)
  if (ad == null) {
    Log.e(TAG, "App open ad is not available.")
    return
  }

  // Interact with the ad object as needed.
  Log.d(TAG, "App open ad response info: ${ad.getResponseInfo()}")
  ad.adEventCallback =
    object : AppOpenAdEventCallback {
      override fun onAdImpression() {
        Log.d(TAG, "App open ad recorded an impression.")
      }
    }
  ad.show(activity)
}

Java

private void pollAndShowAd(Activity activity, String adUnitId) {
  // Polling returns the next available ad and loads another ad in the background.
  AppOpenAd ad = AppOpenAdPreloader.pollAd(adUnitId);

  // Interact with the ad object as needed.
  if (ad == null) {
    Log.e(TAG, "App open ad is not available.");
    return;
  }

  Log.d(TAG, "App open ad response info: " + ad.getResponseInfo());
  ad.setAdEventCallback(
      new AppOpenAdEventCallback() {
        @Override
        public void onAdImpression() {
          Log.d(TAG, "App open ad recorded an impression.");
        }
      });

  // Show the ad.
  ad.show(activity);
}

Cuando tu app llegue a una posición de anuncios y pueda llamar al método show, llama al método pollAd. No llames al método pollAd en las devoluciones de llamada de carga previa ni después de verificar el método isAdAvailable para retener un anuncio. Si necesitas inspeccionar los metadatos del anuncio antes de mostrarlo, lee la información de la respuesta sin quitar el anuncio de la caché.

Escucha los eventos de anuncios

Antes de mostrar el anuncio, escucha los eventos de anuncios. En el siguiente ejemplo, se registran devoluciones de llamada para eventos de anuncios:

Kotlin

private fun listenToAdEvents() {
  // Listen for ad events.
  val ad = appOpenAd
  if (ad == null) {
    Log.e(TAG, "App open ad is not ready yet.")
    return
  }

  ad.adEventCallback =
    object : AppOpenAdEventCallback {
      override fun onAdShowedFullScreenContent() {
        // App open ad did show.
      }

      override fun onAdDismissedFullScreenContent() {
        // App open ad did dismiss.
        appOpenAd = null
      }

      override fun onAdFailedToShowFullScreenContent(
        fullScreenContentError: FullScreenContentError
      ) {
        // App open ad failed to show.
        Log.e(TAG, "App open ad failed to show: ${fullScreenContentError.message}")
      }

      override fun onAdImpression() {
        // App open ad did record an impression.
      }

      override fun onAdClicked() {
        // App open ad did record a click.
      }
    }
}

Java

private void listenToAdEvents() {
  // Listen for ad events.
  if (appOpenAd == null) {
    Log.e(TAG, "App open ad is not ready yet.");
    return;
  }

  appOpenAd.setAdEventCallback(
      new AppOpenAdEventCallback() {
        @Override
        public void onAdShowedFullScreenContent() {
          // App open ad did show.
        }

        @Override
        public void onAdDismissedFullScreenContent() {
          // App open ad did dismiss.
          appOpenAd = null;
        }

        @Override
        public void onAdFailedToShowFullScreenContent(
            @NonNull FullScreenContentError fullScreenContentError) {
          // App open ad failed to show.
          Log.e(TAG, "App open ad failed to show: " + fullScreenContentError.getMessage());
        }

        @Override
        public void onAdImpression() {
          // App open ad did record an impression.
        }

        @Override
        public void onAdClicked() {
          // App open ad did record a click.
        }
      });
}

Opcional: Escucha eventos de precarga

Cuando comiences a precargar anuncios, regístrate para recibir eventos de precarga y recibir notificaciones cuando los anuncios se precarguen correctamente, no se precarguen o se agote la caché de anuncios.

En el siguiente ejemplo, se muestra cómo registrarse para recibir eventos de anuncios precargados:

Kotlin

val preloadCallback =
  object : PreloadCallback {
    override fun onAdFailedToPreload(preloadId: String, adError: LoadAdError) {
      Log.d(TAG, "App open preload ad $preloadId failed to load with error: ${adError.message}")
    }

    override fun onAdsExhausted(preloadId: String) {
      Log.i(TAG, "App open preload ad $preloadId is not available")
    }

    override fun onAdPreloaded(preloadId: String, responseInfo: ResponseInfo) {
      Log.i(TAG, "App open preload ad $preloadId is available")
    }
  }
val adRequest = AdRequest.Builder(adUnitId).build()
val preloadConfig = PreloadConfiguration(adRequest)
AppOpenAdPreloader.start(adUnitId, preloadConfig, preloadCallback)

Java

PreloadCallback preloadCallback =
    new PreloadCallback() {
      @Override
      public void onAdFailedToPreload(@NonNull String preloadId, @NonNull LoadAdError adError) {
        Log.d(
            TAG,
            String.format(
                "App open preload ad %s failed to load with error: %s",
                preloadId, adError.getMessage()));
      }

      @Override
      public void onAdsExhausted(@NonNull String preloadId) {
        Log.i(TAG, String.format("App open preload ad %s is not available", preloadId));
      }

      @Override
      public void onAdPreloaded(@NonNull String preloadId, @NonNull ResponseInfo responseInfo) {
        Log.i(TAG, String.format("App open preload ad %s is available", preloadId));
      }
    };
AdRequest adRequest = new AdRequest.Builder(adUnitId).build();
PreloadConfiguration preloadConfig = new PreloadConfiguration(adRequest);
AppOpenAdPreloader.start(adUnitId, preloadConfig, preloadCallback);

Cuando un anuncio no se carga, GMA Next-Gen SDK precarga automáticamente los anuncios y reintenta las solicitudes fallidas para las configuraciones precargadas. No invoques solicitudes de carga manuales en devoluciones de llamada con errores. En los métodos de devolución de llamada de eventos de precarga, no llames a los métodos pollAd, destroy ni start. Llamar a estos métodos en devoluciones de llamada puede invocar bucles de carga recursivos.

Opcional: Verifica la disponibilidad de anuncios

Si necesitas saber si hay un anuncio disponible, verifica la disponibilidad de anuncios. En el siguiente ejemplo, se verifica si hay un anuncio precargado disponible:

Kotlin

private fun isAdAvailable(adUnitId: String): Boolean {
  return AppOpenAdPreloader.isAdAvailable(adUnitId)
}

Java

private boolean isAdAvailable(String adUnitId) {
  return AppOpenAdPreloader.isAdAvailable(adUnitId);
}

Opcional: Configura el tamaño del búfer

El tamaño del búfer controla la cantidad de anuncios precargados que se almacenan en la memoria. De forma predeterminada, Google optimiza el tamaño del búfer para equilibrar el consumo de memoria y la latencia de publicación de anuncios. Puedes establecer un tamaño de búfer personalizado para aumentar o disminuir la cantidad de anuncios que se conservan en la memoria. Recomendamos un tamaño de búfer de dos anuncios precargados. Si la mayor parte de tu tráfico proviene de dispositivos con poca memoria, reduce el tamaño del búfer.

En el siguiente ejemplo, se muestra cómo establecer un tamaño de búfer:

Kotlin

val adRequest = AdRequest.Builder(adUnitId).build()
// Define a PreloadConfiguration and set the buffer size to 2 preloaded ads.
val preloadConfig = PreloadConfiguration(adRequest, bufferSize = 2)
AppOpenAdPreloader.start(adUnitId, preloadConfig)

Java

AdRequest adRequest = new AdRequest.Builder(adUnitId).build();
// Define a PreloadConfiguration and set the buffer size to 2 preloaded ads.
PreloadConfiguration preloadConfig = new PreloadConfiguration(adRequest, 2);
AppOpenAdPreloader.start(adUnitId, preloadConfig);

Límites de la caché de precarga

GMA Next-Gen SDK aplica un límite para toda la app en la cantidad total de anuncios precargados en todas las unidades de anuncios y los IDs de precarga:

  • Límite predeterminado: Google almacena un máximo de seis anuncios precargados en la memoria. Este límite se comparte entre todos los formatos y los IDs de carga previa.
  • Recomendamos mantener un tamaño de búfer de dos para cada ID de carga previa.

Opcional: Detén la precarga de los anuncios

Mantén activa la carga previa mientras tu app publica anuncios. Durante este tiempo, no llames al método destroy. Si no necesitas volver a mostrar anuncios para un ID de carga previa específico en la sesión, puedes detener la carga previa de anuncios. Para detener la carga de anuncios de un ID de precarga específico, llama al método destroy con un ID de precarga. Cuando se llama al método destroy, se quitan de la caché todos los anuncios precargados asociados con el ID de precarga.

En el siguiente ejemplo, se muestra cómo detener la precarga de anuncios:

Kotlin

private fun stopPreloading(adUnitId: String) {
  // Stops the preloading and destroy preloaded ads.
  AppOpenAdPreloader.destroy(adUnitId)
}

Java

private void stopPreloading(String adUnitId) {
  // Stops the preloading and destroy preloaded ads.
  AppOpenAdPreloader.destroy(adUnitId);
}

Opcional: Lee la información de la respuesta

Lee la información de respuesta del siguiente anuncio precargado sin quitarlo de la caché. Si necesitas inspeccionar los metadatos de un anuncio antes de mostrarlo, lee la información de la respuesta en lugar de llamar al método pollAd.

En el siguiente ejemplo, se muestra cómo leer la información de la respuesta del siguiente anuncio precargado:

Kotlin

val responseInfo = AppOpenAdPreloader.peekAdResponseInfo(preloadId)
if (responseInfo == null) {
  Log.e(TAG, "Failed to peek ad response info.")
  return
}

Log.d(TAG, "Peeked ad response ID: ${responseInfo.responseId}")

Java

ResponseInfo responseInfo = AppOpenAdPreloader.peekAdResponseInfo(preloadId);
if (responseInfo == null) {
  Log.e(TAG, "Failed to peek ad response info.");
  return;
}

Log.d(TAG, "Peeked ad response ID: " + responseInfo.getResponseId());

Controla los inicios en frío y las pantallas de carga

Un inicio en frío se produce cuando la app se inicia desde el disco, y un inicio semicaliente se produce cuando vuelves a abrir la app desde la memoria. Durante un inicio en frío, no tienes un anuncio precargado para mostrar de inmediato. Durante un inicio semicaliente, es posible que aún tengas un anuncio precargado listo para mostrarse.

Durante un inicio en frío, es posible que los usuarios interactúen con tu app antes de que se cargue y muestre un anuncio. Para evitar una mala experiencia del usuario, muestra anuncios para inicio de aplicación en los inicios en frío estrictamente desde una pantalla de carga mientras se cargan los recursos de la app. Si la carga de recursos se completa y el usuario llega al contenido principal antes de que se cargue el anuncio, no lo muestres.

Recomendaciones

Sigue estas recomendaciones para los anuncios para inicio de aplicación:

  • No muestres un anuncio para inicio de aplicación la primera vez que se inicie la app.
  • Si la pantalla de carga termina de cargarse mientras se muestra el anuncio, descártala en el método de devolución de llamada de anuncio descartado.
  • Los anuncios para inicio de aplicación vencen cuatro horas después de cargarse. No muestres un anuncio para inicio de aplicación que se haya cargado hace más de cuatro horas.