Anuncios en forma de banner

Las vistas de banner son anuncios rectangulares de imagen o texto que ocupan un lugar en la pantalla. Permanecen en la pantalla mientras los usuarios interactúan con la app y se pueden actualizar automáticamente después de un período determinado. Si eres nuevo en la publicidad para móviles, son un excelente punto de partida.

En esta guía, se muestra cómo integrar vistas de banners en una app de Unity. Además de instrucciones y fragmentos de código, se incluye información para ajustar correctamente el tamaño de los banners y vínculos a recursos adicionales.

Requisitos previos

• Completa la Guía de introducción.

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 anuncios de producción para cada solicitud, por lo que es seguro de usar.

Sin embargo, después de registrar una app en la interfaz web de Ad Manager y crear tus propios IDs de unidades de anuncios para usarlos en la app, configura tu dispositivo como dispositivo de prueba de forma explícita durante el desarrollo.

/6499/example/banner

Inicializa el SDK de Mobile Ads

Antes de cargar anuncios, llama a MobileAds.Initialize() para que tu app inicialice el SDK de anuncios para dispositivos móviles. Esto debe hacerse una sola vez, idealmente cuando se inicia la app.

using GoogleMobileAds;
using GoogleMobileAds.Api;

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

Si usas la mediación, espera hasta que se produzca la devolución de llamada antes de cargar anuncios, ya que esto garantizará que se inicialicen todos los adaptadores de mediación.

Ejemplo de BannerView

En el siguiente código de muestra, se detalla cómo usar la vista de banner. En el ejemplo, creas una instancia de una vista de banner, usas un AdManagerAdRequest para cargar un anuncio en esa vista y, luego, extiendes sus capacidades mediante el control de eventos de ciclo de vida.

Cómo crear una vista de banner

El primer paso para usar una vista de banner es crear una instancia de una vista de banner en una secuencia de comandos de C# adjunta a un GameObject.

  // This ad unit is configured to always serve test ads.
  private string _adUnitId = "/6499/example/banner";

  AdManagerBannerView _bannerView;

  /// <summary>
  /// Creates a 320x50 banner view at top of the screen.
  /// </summary>
  public void CreateBannerView()
  {
      Debug.Log("Creating banner view");

      // If we already have a banner, destroy the old one.
      if (_bannerView != null)
      {
          DestroyAd();
      }

      // Create a 320x50 banner at top of the screen
      _bannerView = new AdManagerBannerView(_adUnitId, AdSize.Banner, AdPosition.Top);
  }

El constructor de un AdManagerBannerView tiene los siguientes parámetros:

• adUnitId: Es el ID de la unidad de anuncios desde el que AdManagerBannerView debe cargar anuncios.
• AdSize: El tamaño del anuncio que desea utilizar. Consulta la sección Tamaños de banners para obtener más información.
• AdPosition: Es la posición en la que se deben colocar las vistas del banner. La enumeración AdPosition enumera los valores de posición del anuncio válidos.

Observa cómo se usan las diferentes unidades de anuncios según la plataforma. Debes usar una unidad de anuncios de iOS para realizar solicitudes de anuncios en iOS y una de Android para realizar solicitudes en Android.

(Opcional) Cómo crear una vista de banner con una posición personalizada

Para obtener un mayor control sobre la ubicación de un AdManagerBannerView en la pantalla que la que ofrecen los valores de AdPosition, usa el constructor que tenga las coordenadas x e y como parámetros:

// Create a 320x50 banner views at coordinate (0,50) on screen.
_bannerView = new AdManagerBannerView(_adUnitId, AdSize.Banner, 0, 50);

La esquina superior izquierda de AdManagerBannerView se posiciona en los valores "x" e "y" que se pasan al constructor, donde el origen es la parte superior izquierda de la pantalla.

(Opcional) Crea una vista de banner con un tamaño personalizado

Además de usar una constante AdSize, también puedes especificar un tamaño personalizado para tu anuncio:

// Use the AdSize argument to set a custom size for the ad.
AdSize adSize = new AdSize(250, 250);
_bannerView = new AdManagerBannerView(_adUnitId, adSize, AdPosition.Bottom);

Varios tamaños de anuncio (opcional)

Ad Manager te permite especificar varios tamaños de anuncios que podrían ser aptos para publicarse en un AdManagerBannerView. Antes de implementar esta función en el SDK, crea una línea de pedido segmentada para las mismas unidades de anuncios asociadas con creatividades de diferentes tamaños.

En tu app, pasa varios parámetros AdSize a ValidAdSizes:

var adView = new AdManagerBannerView(_adUnitId, AdSize.Banner, AdPosition.Top);
adView.ValidAdSizes = new List<AdSize>
{
    AdSize.Banner, new AdSize(120, 20), new AdSize(250, 250),
};

Si AdManagerAdView cambia de tamaño en el momento de la actualización, tu diseño debería poder adaptarse automáticamente al nuevo tamaño. De forma predeterminada, AdManagerAdView usa el tamaño que se pasa en el primer parámetro hasta que se muestre el siguiente anuncio.

Carga un anuncio banner

Después de implementar la AdManagerBannerView, carga un anuncio con el método LoadAd() en la clase AdManagerBannerView. Toma un parámetro que contiene información del entorno de ejecución, como la información de segmentación, las etiquetas de exclusión y el ID proporcionado por el publicador.

/// <summary>
/// Creates the banner view and loads a banner ad.
/// </summary>
public void LoadAd()
{
    // create an instance of a banner view first.
    if(_bannerView == null)
    {
        CreateAdManagerBannerView();
    }

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

    // send the request to load the ad.
    Debug.Log("Loading banner ad.");
    _bannerView.LoadAd(adRequest);
}

Sugerencia: Puedes usar llamadas de carga de anuncios para crear una caché de anuncios precargados antes de que decidas mostrarlos, de modo que los anuncios puedan mostrarse sin latencia cuando sea necesario. Dado que los anuncios vencen después de una hora, debes borrar esta caché y volver a cargarla con anuncios nuevos cada hora.

Cómo escuchar eventos de vista de banner

Para personalizar el comportamiento de tu anuncio, puedes incluir una serie de eventos en el ciclo de vida del anuncio, como la carga, la apertura o el cierre. Para escuchar estos eventos, registra a un delegado:

/// <summary>
/// listen to events the banner view may raise.
/// </summary>
private void ListenToAdEvents()
{
    // Raised when an ad is loaded into the banner view.
    _bannerView.OnBannerAdLoaded += () =>
    {
        Debug.Log("Banner view loaded an ad with response : "
            + _bannerView.GetResponseInfo());
    };
    // Raised when an ad fails to load into the banner view.
    _bannerView.OnBannerAdLoadFailed += (LoadAdError error) =>
    {
        Debug.LogError("Banner view failed to load an ad with error : "
            + error);
    };
    // Raised when the ad is estimated to have earned money.
    _bannerView.OnAdPaid += (AdValue adValue) =>
    {
        Debug.Log(String.Format("Banner view paid {0} {1}.",
            adValue.Value,
            adValue.CurrencyCode));
    };
    // Raised when an impression is recorded for an ad.
    _bannerView.OnAdImpressionRecorded += () =>
    {
        Debug.Log("Banner view recorded an impression.");
    };
    // Raised when a click is recorded for an ad.
    _bannerView.OnAdClicked += () =>
    {
        Debug.Log("Banner view was clicked.");
    };
    // Raised when an ad opened full screen content.
    _bannerView.OnAdFullScreenContentOpened += () =>
    {
        Debug.Log("Banner view full screen content opened.");
    };
    // Raised when the ad closed full screen content.
    _bannerView.OnAdFullScreenContentClosed += () =>
    {
        Debug.Log("Banner view full screen content closed.");
    };
}

Destruye la vista del banner

Cuando termines de usar la vista de banner, asegúrate de llamar a Destroy() para liberar recursos.

/// <summary>
/// Destroys the banner view.
/// </summary>
public void DestroyBannerView()
{
    if (_bannerView != null)
    {
        Debug.Log("Destroying banner view.");
        _bannerView.Destroy();
        _bannerView = null;
    }
}

Listo. Tu app ya está lista para mostrar anuncios de banner.

Tamaños de banner

En la siguiente tabla, se indican los tamaños de banner estándar.

Tamaño en dp (Ancho x Alto)	Descripción	Disponibilidad	Constante de AdSize
320 x 50	Banner estándar	Teléfonos y tablets	BANNER
320 x 100	Banner grande	Teléfonos y tablets	LARGE_BANNER
300 x 250	Rectángulo mediano de IAB	Teléfonos y tablets	MEDIUM_RECTANGLE
468 x 60	Banner de tamaño completo de IAB	Tablets	FULL_BANNER
728 x 90	Tabla de clasificación de IAB	Tablets	LEADERBOARD
Ancho proporcionado × Altura adaptable	Banner adaptable	Teléfonos y tablets	N/A
Ancho de pantalla x 32|50|90	Banner inteligente	Teléfonos y tablets	SMART_BANNER
Obtén más información sobre los banners adaptables, que reemplazan los banners inteligentes.

Nota: Si una app para Android intenta cargar un banner que es demasiado grande para su diseño, el SDK no lo mostrará y registrará un mensaje de error.

Eventos de aplicaciones

Los eventos de aplicaciones le permiten crear anuncios que pueden enviar mensajes a su código de aplicación. Luego, la app puede realizar acciones en función de estos mensajes.

Puedes escuchar eventos de aplicaciones específicos de Ad Manager con AppEvent. Estos eventos pueden ocurrir en cualquier momento del ciclo de vida del anuncio, incluso antes de que se llame a la carga.

namespace GoogleMobileAds.Api.AdManager;

/// The App event message sent from the ad.
public class AppEvent
{
    // Name of the app event.
    string Name;
    // Argument passed from the app event.
    string Value;
}

Se genera OnAppEventReceived cuando se produce un evento de aplicación en un anuncio. A continuación, te mostramos un ejemplo de cómo controlar este evento en tu código:

_bannerview.OnAppEventReceived += (AppEvent args) =>
{
    Debug.Log($"Received app event from the ad: {args.Name}, {args.Value}.");
};

En este ejemplo, se muestra cómo cambiar el color de fondo de tu app según un evento de la app con nombre de color:

_bannerview.OnAppEventReceived += (AppEvent args) =>
{
  if (args.Name == "color")
  {
    Color color;
    if (ColorUtility.TryParseColor(arg.Value, out color))
    {
      gameObject.GetComponent<Renderer>().material.color = color;
    }
  }
};

Y esta es la creatividad correspondiente que envía un evento de color de la app:

<html>
<head>
  <script src="//www.gstatic.com/afma/api/v1/google_mobile_app_ads.js"></script>
  <script>
    document.addEventListener("DOMContentLoaded", function() {
      // Send a color=green event when ad loads.
      admob.events.dispatchAppEvent("color", "green");

      document.getElementById("ad").addEventListener("click", function() {
        // Send a color=blue event when ad is clicked.
        admob.events.dispatchAppEvent("color", "blue");
      });
    });
  </script>
  <style>
    #ad {
      width: 320px;
      height: 50px;
      top: 0px;
      left: 0px;
      font-size: 24pt;
      font-weight: bold;
      position: absolute;
      background: black;
      color: white;
      text-align: center;
    }
  </style>
</head>
<body>
  <div id="ad">Carpe diem!</div>
</body>
</html>

Recursos adicionales

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