Anuncios para inicio de aplicación

Selecciona la plataforma: Android iOS Unity Flutter

Los anuncios para inicio de aplicación son un formato de anuncio especial 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.

Los anuncios para inicio de aplicación muestran automáticamente un área pequeña de desarrollo 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

Haz siempre una comprobación con anuncios de prueba

El siguiente código de muestra contiene un ID de unidad de anuncios que puedes usar para solicitar anuncios de prueba. Se configuró especialmente para devolver anuncios de prueba en lugar de anuncios de producción para cada solicitud, lo que hace que sea seguro de usar.

Sin embargo, una vez que registres una app en la interfaz web de AdMob y crees IDs de tus propias unidades de anuncios para usarlos en tu app, configura tu dispositivo como dispositivo de prueba de forma explícita durante el desarrollo.

Android

ca-app-pub-3940256099942544/9257395921

iOS

ca-app-pub-3940256099942544/5575463023

Implementación

Estos son los pasos principales para integrar los anuncios para inicio de aplicación:

  1. Crea una clase de utilidad.
  2. Carga el anuncio para inicio de aplicación.
  3. Escucha los eventos de anuncio para inicio de aplicación.
  4. Ten en cuenta el vencimiento de los anuncios.
  5. Escucha los eventos de estado de la aplicación.
  6. Muestra el anuncio para inicio de aplicación.
  7. Borra el anuncio para inicio de aplicación.
  8. Precarga el próximo anuncio para inicio de aplicación.

Crea una clase de utilidad

Crea una clase nueva llamada AppOpenAdController para cargar el anuncio. Esta clase administra una variable de instancia para hacer seguimiento de un anuncio cargado y del ID de unidad de anuncios de cada plataforma.

using System;
using UnityEngine;
using GoogleMobileAds.Api;
using GoogleMobileAds.Common;

/// <summary>
/// Demonstrates how to use the Google Mobile Ads app open ad format.
/// </summary>
[AddComponentMenu("GoogleMobileAds/Samples/AppOpenAdController")]
public class AppOpenAdController : MonoBehaviour
{

    // These ad units are configured to always serve test ads.
#if UNITY_ANDROID
    private string _adUnitId = "ca-app-pub-3940256099942544/9257395921";
#elif UNITY_IPHONE
    string _adUnitId = "ca-app-pub-3940256099942544/5575463023";
#else
    private string _adUnitId = "unused";
#endif

    public bool IsAdAvailable
    {
        get
        {
            return _appOpenAd != null;
        }
    }

    public void Start()
    {
        // Initialize Google Mobile Ads SDK.
        MobileAds.Initialize((InitializationStatus initStatus) =>
        {
            // This callback is called once the MobileAds SDK is initialized.
        });
    }

    /// <summary>
    /// Loads the app open ad.
    /// </summary>
    public void LoadAppOpenAd()
    {
    }

    /// <summary>
    /// Shows the app open ad.
    /// </summary>
    public void ShowAppOpenAd()
    {
    }
}

Carga el anuncio para inicio de aplicación

Para cargar un anuncio para inicio de aplicación, puedes utilizar el método estático Load() en la clase AppOpenAd. En particular, el método de carga requiere un ID de unidad de anuncios, un objeto AdRequest y un controlador de finalización al que se llama cuando la carga de anuncios falla o se realiza correctamente. El objeto AppOpenAd cargado se incluye como parámetro en el controlador de finalización. En el siguiente ejemplo, se muestra cómo cargar un AppOpenAd.


 // These ad units are configured to always serve test ads.
#if UNITY_ANDROID
   private string _adUnitId = "ca-app-pub-3940256099942544/9257395921";
#elif UNITY_IPHONE
   string _adUnitId = "ca-app-pub-3940256099942544/5575463023";
#else
  private string _adUnitId = "unused";
#endif

  private AppOpenAd appOpenAd;

  /// <summary>
  /// Loads the app open ad.
  /// </summary>
  public void LoadAppOpenAd()
  {
      // Clean up the old ad before loading a new one.
      if (appOpenAd != null)
      {
            appOpenAd.Destroy();
            appOpenAd = null;
      }

      Debug.Log("Loading the app open ad.");

      // Create our request used to load the ad.
      var adRequest = new AdRequest();

      // send the request to load the ad.
      AppOpenAd.Load(_adUnitId, adRequest,
          (AppOpenAd ad, LoadAdError error) =>
          {
              // if error is not null, the load request failed.
              if (error != null || ad == null)
              {
                  Debug.LogError("app open ad failed to load an ad " +
                                 "with error : " + error);
                  return;
              }

              Debug.Log("App open ad loaded with response : "
                        + ad.GetResponseInfo());

              appOpenAd = ad;
              RegisterEventHandlers(ad);
          });
  }

Escucha los eventos de anuncio para inicio de aplicación

Para personalizar aún más el comportamiento de tu anuncio, puedes agregar un hook en varios eventos del ciclo de vida del anuncio, como apertura, cierre, etc. Para escuchar estos eventos, registra un delegado como se muestra a continuación.

private void RegisterEventHandlers(AppOpenAd ad)
{
    // Raised when the ad is estimated to have earned money.
    ad.OnAdPaid += (AdValue adValue) =>
    {
        Debug.Log(String.Format("App open ad paid {0} {1}.",
            adValue.Value,
            adValue.CurrencyCode));
    };
    // Raised when an impression is recorded for an ad.
    ad.OnAdImpressionRecorded += () =>
    {
        Debug.Log("App open ad recorded an impression.");
    };
    // Raised when a click is recorded for an ad.
    ad.OnAdClicked += () =>
    {
        Debug.Log("App open ad was clicked.");
    };
    // Raised when an ad opened full screen content.
    ad.OnAdFullScreenContentOpened += () =>
    {
        Debug.Log("App open ad full screen content opened.");
    };
    // Raised when the ad closed full screen content.
    ad.OnAdFullScreenContentClosed += () =>
    {
        Debug.Log("App open ad full screen content closed.");
    };
    // Raised when the ad failed to open full screen content.
    ad.OnAdFullScreenContentFailed += (AdError error) =>
    {
        Debug.LogError("App open ad failed to open full screen content " +
                       "with error : " + error);
    };
}

Ten en cuenta el vencimiento de los anuncios

Para evitar mostrar un anuncio vencido, agrega un método a AppOpenAdController que controla cuánto tiempo transcurrió desde que se cargó tu anuncio. Luego utiliza ese método para comprobar si el anuncio sigue siendo válido.

Los anuncios para inicio de aplicación tienen un tiempo de espera de 4 horas. Almacena el tiempo de carga en caché en la variable _expireTime.

// send the request to load the ad.
AppOpenAd.Load(_adUnitId, adRequest,
    (AppOpenAd ad, LoadAdError error) =>
    {
        // If the operation failed, an error is returned.
        if (error != null || ad == null)
        {
            Debug.LogError("App open ad failed to load an ad with error : " +
                            error);
            return;
        }

        // If the operation completed successfully, no error is returned.
        Debug.Log("App open ad loaded with response : " + ad.GetResponseInfo());

        // App open ads can be preloaded for up to 4 hours.
        _expireTime = DateTime.Now + TimeSpan.FromHours(4);

        _appOpenAd = ad;
    });

Actualiza la propiedad IsAdAvailable para verificar _expireTime y confirmar que el anuncio cargado siga siendo válido.

public bool IsAdAvailable
{
    get
    {
        return _appOpenAd != null
               && _appOpenAd.IsLoaded()
               && DateTime.Now < _expireTime;
    }
}

Escucha los eventos de estado de la aplicación

Usa AppStateEventNotifier para escuchar eventos de primer y segundo plano de la aplicación. Esta clase activará el evento AppStateChanged cada vez que la aplicación pase a primer o segundo plano.

private void Awake()
{
    // Use the AppStateEventNotifier to listen to application open/close events.
    // This is used to launch the loaded ad when we open the app.
    AppStateEventNotifier.AppStateChanged += OnAppStateChanged;
}

private void OnDestroy()
{
    // Always unlisten to events when complete.
    AppStateEventNotifier.AppStateChanged -= OnAppStateChanged;
}

Cuando controlamos el estado AppState.Foreground y el IsAdAvailable es true, llamamos a ShowAppOpenAd() para mostrar el anuncio.

private void OnAppStateChanged(AppState state)
{
    Debug.Log("App State changed to : "+ state);

    // if the app is Foregrounded and the ad is available, show it.
    if (state == AppState.Foreground)
    {
        if (IsAdAvailable)
        {
            ShowAppOpenAd();
        }
    }
}

Muestra el anuncio para inicio de aplicación

Para mostrar un anuncio para inicio de aplicación cargado, llama al método Show() en la instancia de AppOpenAd. Los anuncios solo se pueden mostrar una vez por carga. Usa el método CanShowAd() para verificar que el anuncio esté listo para mostrarse.

/// <summary>
/// Shows the app open ad.
/// </summary>
public void ShowAppOpenAd()
{
    if (appOpenAd != null && appOpenAd.CanShowAd())
    {
        Debug.Log("Showing app open ad.");
        appOpenAd.Show();
    }
    else
    {
        Debug.LogError("App open ad is not ready yet.");
    }
}

Borra el anuncio para inicio de aplicación

Cuando termines de usar un AppOpenAd, asegúrate de llamar al método Destroy() antes de descartar la referencia correspondiente:

appOpenAd.Destroy();

Esto notifica al complemento que el objeto ya no se usa y que se puede recuperar la memoria que ocupa. No llamar a este evento provoca fugas de memoria.

Precarga el próximo anuncio para inicio de aplicación

AppOpenAd es un objeto de un solo uso. Esto significa que, una vez que se muestra un anuncio para inicio de aplicación, el objeto no se puede volver a utilizar. Para solicitar otro anuncio para inicio de aplicación, debes crear un objeto AppOpenAd nuevo.

Para preparar un anuncio para inicio de aplicación para la próxima oportunidad de impresión, realiza una carga previa de este cuando se activen los eventos de anuncio OnAdFullScreenContentClosed o OnAdFullScreenContentFailed.

private void RegisterReloadHandler(AppOpenAd ad)
{
    ...
    // Raised when the ad closed full screen content.
    ad.OnAdFullScreenContentClosed += ()
    {
        Debug.Log("App open ad full screen content closed.");

        // Reload the ad so that we can show another as soon as possible.
        LoadAppOpenAd();
    };
    // Raised when the ad failed to open full screen content.
    ad.OnAdFullScreenContentFailed += (AdError error) =>
    {
        Debug.LogError("App open ad failed to open full screen content " +
                       "with error : " + error);

        // Reload the ad so that we can show another as soon as possible.
        LoadAppOpenAd();
    };
}

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 haber 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 debe evitarse, ya que genera una mala experiencia del usuario.

En lo que respecta a los anuncios para inicio de aplicación, la manera preferida de aprovecharlos 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 allí. Si tu app terminó de cargarse y envió al usuario al contenido principal, no muestres el anuncio.

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 siguientes prácticas recomendadas para que los usuarios puedan disfrutar de tu app.

  • Muestra tu primer anuncio para inicio de aplicación después de que los usuarios hayan utilizado tu aplicación varias 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 tienes una pantalla de carga debajo del anuncio para inicio de aplicación y esta termina de cargarse antes de que el anuncio se descarte, cierra la pantalla de carga en el controlador de eventos OnAdDidDismissFullScreenContent.
  • En la plataforma de iOS, AppStateEventNotifier crea una instancia de AppStateEventClient GameObject. Este GameObject es obligatorio para que los eventos se activen, así que no lo destruyas. Los eventos dejan de activarse si se destruye el objeto GameObject.

Recursos adicionales