Los anuncios de aplicación abierta son un formato de anuncio especial destinado a los publicadores que desean monetizar sus pantallas de carga de aplicaciones. Los anuncios de aplicación abierta se pueden cerrar en cualquier momento y están diseñados para mostrarse cuando los usuarios lleven la aplicación al primer plano.
Los anuncios de aplicación abierta muestran automáticamente un área de desarrollo de la marca pequeña para que los usuarios sepan que están en tu aplicación. A continuación, se muestra un ejemplo de cómo se ve un anuncio de aplicación abierta:
Requisitos previos
- Completa la Guía de introducción.
- Complemento de Unity 7.1.0 o una versión posterior
Realizar pruebas siempre 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 mostrar anuncios de prueba en lugar de anuncios de producción en cada solicitud, lo que hace que su uso sea seguro.
Sin embargo, después de registrar una app en la interfaz web deAd Manager y crear tus propios ID de unidades de anuncios para usar en la app, configura tu dispositivo como dispositivo de prueba de forma explícita durante el desarrollo.
/6499/example/app-open
Implementación
Estos son los pasos principales para integrar los anuncios de aplicación abierta:
- Crea una clase de utilidad
- Cómo cargar el anuncio de aplicación abierta
- Cómo escuchar eventos de anuncios de aplicación abierta
- Ten en cuenta el vencimiento de los anuncios
- Cómo detectar eventos de estado de la app
- Muestra el anuncio de aplicación abierta
- Limpia el anuncio de aplicación abierta
- Precarga el próximo anuncio de aplicación abierta
Crea una clase de utilidad
Crea una clase nueva llamada AppOpenAdController para cargar el anuncio. Esta clase controla una variable de instancia para hacer un seguimiento de un anuncio cargado y el 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
{
// This ad unit is configured to always serve test ads.
private string _adUnitId = "/6499/example/app-open";
public bool IsAdAvailable
{
get
{
return _appOpenAd != null;
}
}
public void Start()
{
// Initialize the 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()
{
}
}
Cómo cargar el anuncio de aplicación abierta
La carga de un anuncio de aplicación abierta se logra usando el método estático Load() en la clase AppOpenAd. El método de carga requiere un ID de unidad de anuncios, un objeto AdManagerAdRequest 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 proporciona como parámetro en el controlador de finalización. En el siguiente ejemplo, se muestra cómo cargar un AppOpenAd.
// This ad unit is configured to always serve test ads.
private string _adUnitId = "/6499/example/app-open";
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 AdManagerAdRequest();
// 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);
});
}
Cómo escuchar eventos de anuncios de aplicación abierta
Para personalizar aún más el comportamiento de tu anuncio, puedes incluir una serie de eventos en su ciclo de vida: apertura, cierre, etcétera. Registra un delegado para detectar estos eventos, 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 asegurarte de no mostrar un anuncio vencido, agrega un método a AppOpenAdController que verifique cuánto tiempo transcurrió desde que se cargó tu anuncio.
Luego, utiliza ese método para comprobar si el anuncio sigue siendo válido.
El anuncio de aplicación abierta tiene un tiempo de espera de 4 horas. Almacena en caché el tiempo de carga 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 aún sea válido.
public bool IsAdAvailable
{
get
{
return _appOpenAd != null
&& _appOpenAd.IsLoaded()
&& DateTime.Now < _expireTime;
}
}
Cómo detectar eventos de estado de la app
Usa AppStateEventNotifier para escuchar los eventos de la aplicación en primer y segundo plano. Esta clase generará el evento AppStateChanged cada vez que la aplicación se encuentre en 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 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 de aplicación abierta
Para mostrar un anuncio de aplicación abierta cargado, llama al método Show() en la instancia AppOpenAd. Los anuncios solo se pueden mostrar una vez por carga. Utiliza 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.");
}
}
Limpia el anuncio de aplicación abierta
Cuando termines con un AppOpenAd, asegúrate de llamar al método Destroy() antes de quitar tu referencia a él:
appOpenAd.Destroy();
Esto notifica al complemento que el objeto ya no se usa y que la memoria que ocupa se puede reclamar. Si no se llama a este método, se generan pérdidas de memoria.
Precarga el próximo anuncio de aplicación abierta
AppOpenAd es un objeto de uso único. Esto significa que, una vez que se muestra un anuncio de aplicación abierta, el objeto no se puede volver a usar. Para solicitar otro anuncio de aplicación abierta, deberás crear un nuevo objeto AppOpenAd.
A fin de preparar un anuncio de aplicación abierta para la próxima oportunidad de impresión, precarga el anuncio de aplicación abierta una vez que se genere el evento 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 supone que solo muestras anuncios de aplicación abierta cuando los usuarios colocan la app en primer plano cuando está suspendida en la memoria. Los "inicios en frío" ocurren cuando se inicia tu app, pero no se suspendió anteriormente en la memoria.
Un ejemplo de inicio en frío es cuando un usuario abre tu app por primera vez. Con los inicios en frío, no tendrás un anuncio de aplicación abierta cargado con anterioridad que esté listo para mostrarse de inmediato. La demora entre el momento en que solicitas un anuncio y la recepción de un anuncio puede crear una situación en la que los usuarios puedan usar tu app brevemente antes de que un anuncio fuera de contexto los sorprenda. Esto debe evitarse, ya que brinda una mala experiencia del usuario.
La forma preferida de usar los anuncios de aplicación abierta en inicios en frío es usar una pantalla de carga para cargar tu juego o los elementos de la aplicación, y mostrar solo el anuncio desde esa pantalla. Si tu app terminó de cargarse y envió al usuario al contenido principal de tu app, no muestres el anuncio.
Prácticas recomendadas
Los anuncios de aplicación abierta te ayudan a monetizar la pantalla de carga de tu app cuando esta se inicia por primera vez y durante los cambios de app, pero es importante que tengas en cuenta las siguientes prácticas recomendadas para que los usuarios disfruten de usarla.
- Muestra tu primer anuncio de aplicación abierta después de que los usuarios la hayan utilizado unas cuantas veces.
- Muestra anuncios de aplicación abierta durante los momentos en que los usuarios estarían esperando que tu app se cargue.
- Si tienes una pantalla de carga debajo del anuncio de aplicación abierta y esta termina de cargarse antes de que se descarte, descártala en el controlador de eventos
OnAdDidDismissFullScreenContent. - En la plataforma de iOS,
AppStateEventNotifiercrea una instancia deAppStateEventClient GameObject. EsteGameObjectes necesario para que los eventos se activen, así que no lo destruyas. Los eventos dejan de activarse si se destruyeGameObject.
Recursos adicionales
- Ejemplo de HelloWorld: Una implementación mínima de todos los formatos de anuncios