Configura anuncios intersticiales

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

Los anuncios intersticiales son anuncios de pantalla completa que cubren la interfaz de la app. Estos anuncios se muestran en los puntos de transición naturales de la app, como entre actividades o durante las pausas en los niveles del juego.

Cuando tu app muestra un anuncio intersticial, los usuarios pueden presionar el anuncio y continuar, o bien cerrarlo y volver a la app. Lee uno de nuestros casos de éxito.

En esta guía, se explica cómo integrar los anuncios intersticiales en una app para Android.

Antes de comenzar

Antes de continuar, haz lo siguiente:

  • Configura GMA Next-Gen SDK.
  • Usa el ID de unidad de anuncios intersticiales de prueba ca-app-pub-3940256099942544/1033173712.
    • 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 GMA Next-Gen SDK, consulta Habilita los anuncios de prueba.

Información sobre la precarga de anuncios

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

La precarga de anuncios proporciona 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 del caché.
  • Reintentos administrados: Carga un anuncio nuevo cuando no se puede cargar uno.
  • Control de vencimiento: Actualiza los anuncios antes de que venzan.
  • Optimización del caché: Optimiza el orden del caché para publicar el anuncio de mayor prioridad.

Comienza a precargar anuncios

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

En el siguiente ejemplo, se muestra cómo comenzar a precargar anuncios:

Kotlin

// Call start() once after SDK initialization.
// Preload only one ad unit per format to optimize performance.
val adRequest = AdRequest.Builder(adUnitId).build()
val preloadConfig = PreloadConfiguration(adRequest)
InterstitialAdPreloader.start(adUnitId, preloadConfig)

Java

// Call start() once after SDK initialization.
// Preload only one ad unit per format to optimize performance.
AdRequest adRequest = new AdRequest.Builder(adUnitId).build();
PreloadConfiguration preloadConfig = new PreloadConfiguration(adRequest);
InterstitialAdPreloader.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 ID de precarga. Un ID de precarga es un identificador de cadena que creas para identificar una configuración de precarga de anuncios. Si tu app requiere varias configuraciones de segmentación para el mismo ID de unidad de anuncios, pasa un identificador de cadena personalizado.

Obtén y muestra los anuncios precargados

Cuando quieras mostrar un anuncio, llama 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 ningún anuncio.

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 = InterstitialAdPreloader.pollAd(adUnitId)
  if (ad == null) {
    Log.e(TAG, "Interstitial ad is not available.")
    return
  }

  // Interact with the ad object as needed.
  Log.d(TAG, "Interstitial ad response info: ${ad.getResponseInfo()}")
  ad.adEventCallback =
    object : InterstitialAdEventCallback {
      override fun onAdImpression() {
        Log.d(TAG, "Interstitial 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.
  final InterstitialAd ad = InterstitialAdPreloader.pollAd(adUnitId);

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

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

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

Evita llamar al método pollAd() hasta que estés listo para mostrar un anuncio. Para leer la información de la respuesta de solicitud de anuncio sin mostrarla, consulta Lee la información de la respuesta de solicitud de anuncio.

Escucha eventos de anuncios

Antes de mostrar el anuncio, escucha los eventos de anuncios. En el siguiente ejemplo, se muestra cómo registrar devoluciones de llamada para eventos de anuncios:

Kotlin

// Listen for ad events.
val ad = interstitialAd
if (ad == null) {
  Log.e(TAG, "Interstitial ad is not ready yet.")
  return
}

ad.adEventCallback =
  object : InterstitialAdEventCallback {
    override fun onAdShowedFullScreenContent() {
      // Interstitial ad did show.
    }

    override fun onAdDismissedFullScreenContent() {
      // Interstitial ad did dismiss.
      interstitialAd = null
    }

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

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

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

Java

// Listen for ad events.
if (interstitialAd == null) {
  Log.e(TAG, "Interstitial ad is not ready yet.");
  return;
}

interstitialAd.setAdEventCallback(
    new InterstitialAdEventCallback() {
      @Override
      public void onAdShowedFullScreenContent() {
        // Interstitial ad did show.
      }

      @Override
      public void onAdDismissedFullScreenContent() {
        // Interstitial ad did dismiss.
        interstitialAd = null;
      }

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

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

      @Override
      public void onAdClicked() {
        // Interstitial 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 puedan precargar o se agote el caché de anuncios.

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

Kotlin

val preloadCallback =
  // [Important] Don't call ad preloader start() or pollAd() within the PreloadCallback.
  object : PreloadCallback {
    override fun onAdFailedToPreload(preloadId: String, adError: LoadAdError) {
      Log.d(
        TAG,
        ("Interstitial preload ad $preloadId failed to load with error: ${adError.message}"),
      )
    }

    override fun onAdsExhausted(preloadId: String) {
      Log.i(TAG, "Interstitial preload ad $preloadId is not available")
      // [Important] Don't call ad preloader start() or pollAd() from onAdsExhausted.
    }

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

Java

PreloadCallback preloadCallback =
    // [Important] Don't call ad preloader start() or pollAd() within the PreloadCallback.
    new PreloadCallback() {
      @Override
      public void onAdFailedToPreload(@NonNull String preloadId, @NonNull LoadAdError adError) {
        Log.d(
            TAG,
            String.format(
                "Interstitial preload ad %s failed to load with error: %s",
                preloadId, adError.getMessage()));
        // [Optional] Get the error response info for additional details.
        // ResponseInfo responseInfo = adError.getResponseInfo();
      }

      @Override
      public void onAdsExhausted(@NonNull String preloadId) {
        Log.i(TAG, "Interstitial preload ad " + preloadId + " is not available");
        // [Important] Don't call ad preloader start() or pollAd() from onAdsExhausted.
      }

      @Override
      public void onAdPreloaded(@NonNull String preloadId, @NonNull ResponseInfo responseInfo) {
        Log.i(TAG, "Interstitial preload ad " + preloadId + " is available");
      }
    };

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

Cuando no se puede cargar un anuncio, GMA Next-Gen SDK precarga automáticamente los anuncios y reintenta las solicitudes fallidas para las configuraciones precargadas.

[Opcional] Verifica la disponibilidad de anuncios

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

Kotlin

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

Java

private boolean isAdAvailable(String adUnitId) {
  return InterstitialAdPreloader.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 la cantidad de anuncios que se conservan en la memoria. Recomendamos un tamaño de búfer máximo de cuatro.

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

Kotlin

val adRequest = AdRequest.Builder(adUnitId).build()
// Maintain small or default buffer size unless rapid transitions are expected.
val preloadConfig = PreloadConfiguration(adRequest, bufferSize = 2)
InterstitialAdPreloader.start(adUnitId, preloadConfig)

Java

// Maintain small or default buffer size unless rapid transitions are expected.
AdRequest adRequest = new AdRequest.Builder(adUnitId).build();
PreloadConfiguration preloadConfig = new PreloadConfiguration(adRequest, 2);
InterstitialAdPreloader.start(adUnitId, preloadConfig);

Límites de caché de precarga

GMA Next-Gen SDK aplica un límite en toda la app para 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 6 anuncios precargados en la memoria. Este límite se comparte en todos los formatos y los IDs de precarga.
  • Recomendamos mantener un tamaño de búfer de 2 o 3 por ID de precarga.

[Opcional] Detén la precarga de los anuncios

Si no necesitas volver a mostrar anuncios para un ID de precarga específico en la sesión, puedes detener la precarga de anuncios. Para detener la carga de anuncios para un ID de precarga específico, llama al método destroy() con un ID de precarga. Si llamas al método destroy(), se quitarán del caché todos los anuncios precargados asociados con el ID de precarga.

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

Kotlin

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

Java

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

[Opcional] Lee la información de la respuesta

Lee la información de la respuesta del siguiente anuncio precargado sin quitar el anuncio del caché.

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

Kotlin

val responseInfo = InterstitialAdPreloader.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 = InterstitialAdPreloader.peekAdResponseInfo(preloadId);
if (responseInfo == null) {
  Log.e(TAG, "Failed to peek ad response info.");
  return;
}

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