Los anuncios de aplicación abierta son un formato de anuncio especial destinado a los publicadores que desean monetizar las pantallas de carga de la aplicación. Los anuncios de aplicación abierta se pueden cerrar en cualquier momento y están diseñados se muestre cuando los usuarios lleven la app 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 allí tu app. Este es 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
Probar 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ó de forma especial para mostrar anuncios de prueba en lugar de mostrar anuncios de producción para cada solicitud, por lo que es seguro de usar.
Sin embargo, después de registrar una app en la la interfaz web de AdMob y creaste tu propia unidad de anuncios IDs para usar en tu app, configura tu dispositivo como una prueba de manera explícita dispositivo durante en el desarrollo de software.
Android
ca-app-pub-3940256099942544/9257395921
iOS
ca-app-pub-3940256099942544/5575463023
Implementación
Los pasos principales para integrar anuncios de aplicación abierta son los siguientes:
- Cómo crear 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
- Escucha eventos de estado de la app
- Muestra el anuncio de aplicación abierta
- Limpia el anuncio de aplicación abierta
- Precargar el próximo anuncio de aplicación abierta
Cómo crear 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 la unidad de anuncios
para 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 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 realiza con el método estático Load()
en la
Clase AppOpenAd
. El método de carga requiere un ID de unidad de anuncios, un
AdRequest
y un controlador de finalización que
se llama cuando la carga de anuncios se realiza correctamente o falla. El objeto AppOpenAd
cargado es
proporcionado como parámetro en el controlador de finalización. En el siguiente ejemplo, se muestra cómo
para 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);
});
}
Cómo escuchar eventos de anuncios de aplicación abierta
Para personalizar aún más el comportamiento de su anuncio, puede vincular en el ciclo de vida del anuncio: inicio, cierre, etc. Escuchar estos eventos registrando 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 asegurarse de no mostrar un anuncio vencido, agregue un método a la
AppOpenAdController
que verifica 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 de aplicación abierta tienen un tiempo de espera de 4 horas. Almacena en caché el tiempo de carga en _expireTime
.
de salida.
// 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 marcar _expireTime
y confirmar que se cargó
el anuncio sigue siendo válido.
public bool IsAdAvailable
{
get
{
return _appOpenAd != null
&& _appOpenAd.IsLoaded()
&& DateTime.Now < _expireTime;
}
}
Escucha eventos de estado de la app
Usa el AppStateEventNotifier
para escuchar el primer plano de la aplicación y
eventos en segundo plano. Esta clase generará el evento AppStateChanged
siempre que sea
en primer o segundo plano de la aplicación.
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. Usa el 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 a Destroy()
.
antes de descartar tu referencia:
appOpenAd.Destroy();
Esto notifica al complemento que el objeto ya no se usa y la memoria que ocuparse de ellos. Si no se llama a este método, se generarán fugas de memoria.
Precargar el próximo anuncio de aplicación abierta
AppOpenAd
es un objeto de un solo uso. Esto significa que, cuando se muestra
el objeto no se puede volver a usar. Para solicitar otro anuncio de aplicación abierta,
deberás crear un nuevo objeto AppOpenAd
.
Para 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 OnAdFullScreenContentClosed
o
Se generó OnAdFullScreenContentFailed
evento de anuncio.
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 primer plano de tu app cuando está suspendida en la memoria. "Inicios en frío" se producen cuando se inició 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 previamente cargado que esté listo para se mostrará de inmediato. La demora entre el momento en que solicitas un anuncio y lo recibes puede crear una situación en la que los usuarios puedan usar brevemente tu app se sorprenden con un anuncio fuera de contexto. Esto se debe evitar porque es un mala experiencia del usuario.
La forma preferida de usar los anuncios de aplicación abierta durante inicios en frío es usar una pantalla de carga para cargar tus recursos de juego o app, y mostrar solo el anuncio en la pantalla. Si tu app terminó de cargarse y envió al usuario a la página principal contenido 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 encuentra por primera vez y durante los cambios de app, pero es importante mantener prácticas recomendadas para que tus usuarios disfruten de usar tu app.
- Muestre su primer anuncio de aplicación abierta después de que los usuarios hayan utilizado su aplicación varias veces.
- Muestra anuncios de aplicación abierta en los momentos en que los usuarios estarían esperando que cargue tu app.
- Si hay una pantalla de carga debajo del anuncio de aplicación abierta y tu pantalla de carga
termine de cargarse antes de que se descarte el anuncio, descarta la pantalla de carga en
el controlador de eventos
OnAdDidDismissFullScreenContent
- En la plataforma de iOS,
AppStateEventNotifier
crea una instancia de unaAppStateEventClient GameObject
EsteGameObject
es obligatorio para los eventos no lo destruyas, así que no lo destruyas. Los eventos dejan de activarse si se desactivaGameObject
antes de que se destruyan.
Recursos adicionales
- Ejemplo de HelloWorld: Una implementación mínima de todos los formatos de anuncios