Anuncios de aplicación abierta

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 de Ad Manager 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.

/21775744923/example/app-open

Implementación

Los pasos principales para integrar anuncios de aplicación abierta son los siguientes:

1. Cómo crear una clase de utilidad
2. Cómo cargar el anuncio de aplicación abierta
3. Cómo escuchar eventos de anuncios de aplicación abierta
4. Ten en cuenta el vencimiento de los anuncios
5. Escucha eventos de estado de la app
6. Muestra el anuncio de aplicación abierta
7. Limpia el anuncio de aplicación abierta
8. 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
{

    // This ad unit is configured to always serve test ads.
    private string _adUnitId = "/21775744923/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 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 AdManagerAdRequest 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.

  // This ad unit is configured to always serve test ads.
  private string _adUnitId = "/21775744923/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);
          });
  }

Advertencia: Intentar cargar un anuncio nuevo desde el bloque de finalización de la solicitud de anuncio no se recomienda para nada la carga de un anuncio. Si debes cargar un anuncio desde él bloque de finalización de solicitudes, limite los reintentos de carga de anuncios para evitar solicitudes de anuncios fallidas en situaciones como conectividad de red limitada.

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

Punto clave: El tiempo de espera de los anuncios de aplicación abierta se agotará después de cuatro horas. Anuncios renderizados más de cuatro horas después del momento de la solicitud dejará de ser válida y es posible que no genere ingresos.

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.

Nota: Los anuncios de aplicación abierta deben mostrarse durante las pausas naturales en el flujo de una aplicación. Entre los niveles de un juego es un buen ejemplo o después de que el usuario finaliza. una tarea.

/// <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.

Punto clave: Para seguir cargando recursos de aplicación mientras se muestra el anuncio que se muestra, siempre debes cargar los recursos en un subproceso en segundo plano.

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 una AppStateEventClient GameObject Este GameObject es obligatorio para los eventos no lo destruyas, así que no lo destruyas. Los eventos dejan de activarse si se desactiva GameObject antes de que se destruyan.

Recursos adicionales

• Ejemplo de HelloWorld: Una implementación mínima de todos los formatos de anuncios