Anuncios para inicio de aplicación

Selecciona la plataforma: Android iOS Unity Flutter

Esta guía está dirigida a los publicadores que integran anuncios para inicio de aplicación con el SDK de anuncios de Google para dispositivos móviles.

Los anuncios para inicio de aplicación son un formato de anuncios especial que está diseñado para los publicadores que desean monetizar las pantallas de carga de sus apps. Estos anuncios se pueden cerrar en cualquier momento y se muestran cuando los usuarios ponen tu app en primer plano.

Nota: El formato específico podría variar según la región.

Los anuncios para inicio de aplicación muestran automáticamente un área pequeña de recursos de la marca para que los usuarios sepan que se encuentran en tu app. El siguiente ejemplo ilustra la apariencia de un anuncio para inicio de aplicación:

Requisitos previos

• Completar la guía de introducción

Haz siempre una comprobación con anuncios de prueba

Al compilar y verificar tus apps, asegúrate de usar anuncios de prueba en vez de anuncios activos en fase de producción. De lo contrario, tu cuenta podría suspenderse.

La forma más sencilla de cargar anuncios de prueba es usar nuestro ID de unidad de anuncios de prueba exclusivo de los anuncios para inicio de aplicación:

ca-app-pub-3940256099942544/9257395921

Está configurado especialmente para devolver anuncios de prueba en cada solicitud, y puedes usarlo en tus propias apps mientras realizas tus actividades de programación, prueba y depuración. Solo asegúrate de reemplazarlo por tu propio ID de unidad de anuncios antes de publicar tu app.

Para obtener más información sobre el funcionamiento de los anuncios de prueba del SDK de anuncios de Google para dispositivos móviles, consulta la sección Habilita los anuncios de prueba.

Extiende la clase Application

Crea una clase nueva que extienda la clase Application. Esto te brinda una manera de administrar, en función del ciclo de vida, anuncios que están vinculados al estado de la aplicación en lugar de una única clase Activity:

Java

public class MyApplication extends Application
    implements ActivityLifecycleCallbacks, DefaultLifecycleObserver {

  private AppOpenAdManager appOpenAdManager;
  private Activity currentActivity;

  @Override
  public void onCreate() {
    super.onCreate();
    this.registerActivityLifecycleCallbacks(this);

    ProcessLifecycleOwner.get().getLifecycle().addObserver(this);
    appOpenAdManager = new AppOpenAdManager();
  }
MyApplication.java

Kotlin

class MyApplication :
  MultiDexApplication(), Application.ActivityLifecycleCallbacks, DefaultLifecycleObserver {

  private lateinit var appOpenAdManager: AppOpenAdManager
  private var currentActivity: Activity? = null

  override fun onCreate() {
    super<MultiDexApplication>.onCreate()
    registerActivityLifecycleCallbacks(this)

    ProcessLifecycleOwner.get().lifecycle.addObserver(this)
    appOpenAdManager = AppOpenAdManager()
  }
MyApplication.kt

A continuación, agrega el siguiente código a tu archivo AndroidManifest.xml:

<!-- TODO: Update to reference your actual package name. -->
<application
    android:name="com.google.android.gms.example.appopendemo.MyApplication" ...>
...
</application>

Implementa tu componente de utilidad

Tu anuncio se debería mostrar rápidamente, por lo que es mejor que lo cargues antes de que tengas que mostrarlo. De esta manera, tendrás un anuncio listo para publicarse cuando el usuario abra tu app.

Implementa un componente de utilidad AppOpenAdManager para encapsular el trabajo relacionado con la carga y la publicación de anuncios para inicio de aplicación:

Java

private class AppOpenAdManager {

  private static final String LOG_TAG = "AppOpenAdManager";
  private static final String AD_UNIT_ID = "ca-app-pub-3940256099942544/9257395921";

  private AppOpenAd appOpenAd = null;
  private boolean isLoadingAd = false;
  private boolean isShowingAd = false;

  /** Keep track of the time an app open ad is loaded to ensure you don't show an expired ad. */
  private long loadTime = 0;

  /** Constructor. */
  public AppOpenAdManager() {}
MyApplication.java

Kotlin

private inner class AppOpenAdManager {

  private var appOpenAd: AppOpenAd? = null
  private var isLoadingAd = false
  var isShowingAd = false

  /** Keep track of the time an app open ad is loaded to ensure you don't show an expired ad. */
  private var loadTime: Long = 0
MyApplication.kt

Para usar AppOpenAdManager, llama a los métodos de wrapper públicos en la instancia de singleton MyApplication. La clase Application interactúa con el resto del código y delega en el administrador la tarea de cargar y mostrar el anuncio.

Carga un anuncio

El siguiente paso es completar el método loadAd() y procesar las devoluciones de llamada de carga de anuncios.

Java

AppOpenAd.load(
    context,
    "AD_UNIT_ID",
    new AdRequest.Builder().build(),
    new AppOpenAdLoadCallback() {
      @Override
      public void onAdLoaded(AppOpenAd ad) {
        // Called when an app open ad has loaded.
        Log.d(LOG_TAG, "App open ad loaded.");

        appOpenAd = ad;
        isLoadingAd = false;
        loadTime = (new Date()).getTime();
      }

      @Override
      public void onAdFailedToLoad(LoadAdError loadAdError) {
        // Called when an app open ad has failed to load.
        Log.d(LOG_TAG, "App open ad failed to load with error: " + loadAdError.getMessage());

        isLoadingAd = false;
      }
    });
MyApplication.java

Kotlin

AppOpenAd.load(
  context,
  "AD_UNIT_ID",
  AdRequest.Builder().build(),
  object : AppOpenAdLoadCallback() {
    override fun onAdLoaded(ad: AppOpenAd) {
      // Called when an app open ad has loaded.
      Log.d(LOG_TAG, "App open ad loaded.")

      appOpenAd = ad
      isLoadingAd = false
      loadTime = Date().time
    }

    override fun onAdFailedToLoad(loadAdError: LoadAdError) {
      // Called when an app open ad has failed to load.
      Log.d(LOG_TAG, "App open ad failed to load with error: " + loadAdError.message)

      isLoadingAd = false
    }
  },
)
MyApplication.kt

Reemplaza AD_UNIT_ID por tu propio ID de unidad de anuncios.

Muestra el anuncio

La implementación más común de los anuncios para inicio de aplicación consiste en intentar mostrar un anuncio de este tipo cerca del momento en que se inicia la app, presentar el contenido de la app si el anuncio no está listo y precargar otro anuncio para la próxima oportunidad de inicio de aplicación. Para ver ejemplos de implementación, consulta la guía de anuncios para inicio de aplicación.

El siguiente código muestra un anuncio y, luego, vuelve a cargarlo:

Java

public void showAdIfAvailable(
    @NonNull final Activity activity,
    @NonNull OnShowAdCompleteListener onShowAdCompleteListener) {
  // If the app open ad is already showing, do not show the ad again.
  if (isShowingAd) {
    Log.d(TAG, "The app open ad is already showing.");
    return;
  }

  // If the app open ad is not available yet, invoke the callback then load the ad.
  if (appOpenAd == null) {
    Log.d(TAG, "The app open ad is not ready yet.");
    onShowAdCompleteListener.onShowAdComplete();
    // Load an ad.
    return;
  }

  isShowingAd = true;
  appOpenAd.show(activity);
}
AppOpenAdSnippets.java

Kotlin

fun showAdIfAvailable(activity: Activity, onShowAdCompleteListener: OnShowAdCompleteListener) {
  // If the app open ad is already showing, do not show the ad again.
  if (isShowingAd) {
    Log.d(TAG, "The app open ad is already showing.")
    return
  }

  // If the app open ad is not available yet, invoke the callback then load the ad.
  if (appOpenAd == null) {
    Log.d(TAG, "The app open ad is not ready yet.")
    onShowAdCompleteListener.onShowAdComplete()
    // Load an ad.
    return
  }

  isShowingAd = true
  appOpenAd?.show(activity)
}
AppOpenAdSnippets.kt

Establece el objeto FullScreenContentCallback

El objeto FullScreenContentCallback procesa los eventos relacionados con la visualización de tu AppOpenAd. Antes de mostrar el AppOpenAd, asegúrate de configurar la devolución de llamada:

Java

appOpenAd.setFullScreenContentCallback(
    new FullScreenContentCallback() {
      @Override
      public void onAdDismissedFullScreenContent() {
        // Called when full screen content is dismissed.
        Log.d(TAG, "Ad dismissed fullscreen content.");
        // Don't forget to set the ad reference to null so you
        // don't show the ad a second time.
        appOpenAd = null;
        isShowingAd = false;

        onShowAdCompleteListener.onShowAdComplete();
        // Load an ad.
      }

      @Override
      public void onAdFailedToShowFullScreenContent(@NonNull AdError adError) {
        // Called when full screen content failed to show.
        Log.d(TAG, adError.getMessage());
        appOpenAd = null;
        // Don't forget to set the ad reference to null so you
        // don't show the ad a second time.
        isShowingAd = false;

        onShowAdCompleteListener.onShowAdComplete();
        // Load an ad.
      }

      @Override
      public void onAdShowedFullScreenContent() {
        Log.d(TAG, "Ad showed fullscreen content.");
      }

      @Override
      public void onAdImpression() {
        // Called when an impression is recorded for an ad.
        Log.d(TAG, "The ad recorded an impression.");
      }

      @Override
      public void onAdClicked() {
        // Called when ad is clicked.
        Log.d(TAG, "The ad was clicked.");
      }
    });
AppOpenAdSnippets.java

Kotlin

appOpenAd?.fullScreenContentCallback =
  object : FullScreenContentCallback() {
    override fun onAdDismissedFullScreenContent() {
      // Called when full screen content is dismissed.
      Log.d(TAG, "Ad dismissed fullscreen content.")
      // Don't forget to set the ad reference to null so you
      // don't show the ad a second time.
      appOpenAd = null
      isShowingAd = false

      onShowAdCompleteListener.onShowAdComplete()
      // Load an ad.
    }

    override fun onAdFailedToShowFullScreenContent(adError: AdError) {
      // Called when full screen content failed to show.
      Log.d(TAG, adError.message)
      // Don't forget to set the ad reference to null so you
      // don't show the ad a second time.
      appOpenAd = null
      isShowingAd = false

      onShowAdCompleteListener.onShowAdComplete()
      // Load an ad.
    }

    override fun onAdShowedFullScreenContent() {
      Log.d(TAG, "Ad showed fullscreen content.")
    }

    override fun onAdImpression() {
      // Called when an impression is recorded for an ad.
      Log.d(TAG, "The ad recorded an impression.")
    }

    override fun onAdClicked() {
      // Called when ad is clicked.
      Log.d(TAG, "The ad was clicked.")
    }
  }
AppOpenAdSnippets.kt

Punto clave: Si un usuario hace clic en un anuncio para inicio de aplicación y vuelve a tu app después de haberla abandonado, ese objeto garantiza que no se le muestre otro anuncio de este tipo.

Ten en cuenta el vencimiento de los anuncios

Punto clave: Una vez transcurridas cuatro horas, se agotará el tiempo de espera de los anuncios para inicio de aplicación. Los anuncios renderizados más de cuatro horas después del momento de la solicitud dejarán de ser válidos y posiblemente no generarán ingresos.

Para asegurarte de no mostrar un anuncio vencido, agrega un método a AppOpenAdManager que verifique cuánto tiempo transcurrió desde que se cargó tu referencia de anuncio. Una vez que lo hayas hecho, utiliza ese método para comprobar si el anuncio sigue siendo válido.

Java

/** Check if ad was loaded more than n hours ago. */
private boolean wasLoadTimeLessThanNHoursAgo(long numHours) {
  long dateDifference = (new Date()).getTime() - loadTime;
  long numMilliSecondsPerHour = 3600000;
  return (dateDifference < (numMilliSecondsPerHour * numHours));
}

/** Check if ad exists and can be shown. */
private boolean isAdAvailable() {
  // For time interval details, see: https://support.google.com/admob/answer/9341964
  return appOpenAd != null && wasLoadTimeLessThanNHoursAgo(4);
}
MyApplication.java

Kotlin

/** Check if ad was loaded more than n hours ago. */
private fun wasLoadTimeLessThanNHoursAgo(numHours: Long): Boolean {
  val dateDifference: Long = Date().time - loadTime
  val numMilliSecondsPerHour: Long = 3600000
  return dateDifference < numMilliSecondsPerHour * numHours
}

/** Check if ad exists and can be shown. */
private fun isAdAvailable(): Boolean {
  // For time interval details, see: https://support.google.com/admob/answer/9341964
  return appOpenAd != null && wasLoadTimeLessThanNHoursAgo(4)
}
MyApplication.kt

Haz un seguimiento de la actividad actual

Para mostrar el anuncio, necesitarás un contexto de Activity. Puedes registrar y, luego, implementar Application.ActivityLifecycleCallbacks para hacer un seguimiento de la actividad más reciente que se utiliza.

Java

@Override
public void onActivityCreated(@NonNull Activity activity, @Nullable Bundle savedInstanceState) {}

@Override
public void onActivityStarted(@NonNull Activity activity) {
  // An ad activity is started when an ad is showing, which could be AdActivity class from Google
  // SDK or another activity class implemented by a third party mediation partner. Updating the
  // currentActivity only when an ad is not showing will ensure it is not an ad activity, but the
  // one that shows the ad.
  if (!appOpenAdManager.isShowingAd) {
    currentActivity = activity;
  }
}

@Override
public void onActivityResumed(@NonNull Activity activity) {}

@Override
public void onActivityPaused(@NonNull Activity activity) {}

@Override
public void onActivityStopped(@NonNull Activity activity) {}

@Override
public void onActivitySaveInstanceState(@NonNull Activity activity, @NonNull Bundle outState) {}

@Override
public void onActivityDestroyed(@NonNull Activity activity) {}
MyApplication.java

Kotlin

override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {}

override fun onActivityStarted(activity: Activity) {
  // An ad activity is started when an ad is showing, which could be AdActivity class from Google
  // SDK or another activity class implemented by a third party mediation partner. Updating the
  // currentActivity only when an ad is not showing will ensure it is not an ad activity, but the
  // one that shows the ad.
  if (!appOpenAdManager.isShowingAd) {
    currentActivity = activity
  }
}

override fun onActivityResumed(activity: Activity) {}

override fun onActivityPaused(activity: Activity) {}

override fun onActivityStopped(activity: Activity) {}

override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) {}

override fun onActivityDestroyed(activity: Activity) {}
MyApplication.kt

registerActivityLifecycleCallbacks te permite escuchar todos los eventos de Activity. Si escuchas cuándo se inician y destruyen las actividades, puedes hacer un seguimiento de una referencia a la clase Activity actual, que luego usarás para mostrar tu anuncio para inicio de aplicación.

Escucha los eventos en primer plano de la app

Para escuchar los eventos en primer plano de la app, sigue estos pasos:

Agrega las bibliotecas a tu archivo Gradle

Para recibir notificaciones sobre los eventos en primer plano de la app, tienes que registrar un DefaultLifecycleObserver. Agrega su dependencia a tu archivo de compilación a nivel de la app:

Kotlin

  dependencies {
    implementation("com.google.android.gms:play-services-ads:24.5.0")
    implementation("androidx.lifecycle:lifecycle-process:2.8.3")
  }

Groovy

  dependencies {
    implementation 'com.google.android.gms:play-services-ads:24.5.0'
    implementation 'androidx.lifecycle:lifecycle-process:2.8.3'
  }

Implementa la interfaz del observador del ciclo de vida

Para escuchar los eventos en primer plano, implementa la interfaz DefaultLifecycleObserver.

Implementa onStart() para mostrar el anuncio para inicio de aplicación.

Java

@Override
public void onStart(@NonNull LifecycleOwner owner) {
  DefaultLifecycleObserver.super.onStart(owner);
  // Show the ad (if available) when the app moves to foreground.
  appOpenAdManager.showAdIfAvailable(currentActivity);
}
MyApplication.java

Kotlin

override fun onStart(owner: LifecycleOwner) {
  super.onStart(owner)
  currentActivity?.let {
    // Show the ad (if available) when the app moves to foreground.
    appOpenAdManager.showAdIfAvailable(it)
  }
}
MyApplication.kt

Inicios en frío y pantallas de carga

Hasta ahora, en la documentación, se da por hecho que solo muestras anuncios para inicio de aplicación cuando los usuarios ponen tu app en primer plano después de que haya estado suspendida en la memoria. Los "inicios en frío" se producen cuando se inicia tu app sin haber estado suspendida en la memoria previamente.

Un ejemplo de un inicio en frío es cuando un usuario abre tu app por primera vez. Con los inicios en frío, no tendrás ningún anuncio para inicio de aplicación cargado previamente que esté listo para mostrarse de inmediato. La demora entre el momento en que solicitas un anuncio y el momento en que lo recibes puede generar una situación en la que los usuarios utilizan tu app brevemente y luego los sorprende un anuncio fuera de contexto. Esto se debe evitar porque genera una mala experiencia del usuario.

En lo que respecta a un anuncio para inicio de aplicación, la manera preferida de aprovecharlo en los inicios en frío es utilizar una pantalla de carga de los recursos de tu juego o app, y mostrar el anuncio únicamente desde esa pantalla de carga. No muestres el anuncio si tu app ya terminó de cargarse y llevó al usuario al contenido principal.

Punto clave: Siempre carga los recursos de la app en un subproceso en segundo plano si deseas que se sigan cargando mientras se muestra un anuncio para inicio de aplicación.

Prácticas recomendadas

Los anuncios para inicio de aplicación te ayudan a monetizar la pantalla de carga de tu app cuando se inicia por primera vez y durante los cambios de app, pero es importante tener en cuenta las prácticas recomendadas para que los usuarios puedan disfrutar de tu app. Lo mejor es que hagas lo siguiente:

• Muestra tu primer anuncio para inicio de aplicación después de que los usuarios hayan utilizado tu app algunas veces.
• Muestra anuncios para inicio de aplicación en los momentos en que los usuarios estén esperando a que se cargue tu app.
• Si, debajo del anuncio para inicio de aplicación, tienes una pantalla de carga que termina de cargarse antes de que se descarte el anuncio, es conveniente que descartes esa pantalla en el método onAdDismissedFullScreenContent().

Ejemplos en GitHub

• Ejemplo de anuncios para inicio de aplicación: Java | Kotlin

Próximos pasos

Explora los siguientes temas:

• Privacidad del usuario
• Optimización de la inicialización del SDK y la carga de anuncios (beta)