Anúncios nativos overlay

Primeiros passos

Os anúncios overlay nativos são apresentados aos usuários por meio de componentes de interface nativos da plataforma. Esses anúncios são apresentados como uma sobreposição no aplicativo. Isso é semelhante à forma como os anúncios de banner funcionam, mas com a capacidade de personalizar a aparência deles.

Os anúncios overlay nativos são compatíveis com a mediação e anúncios em vídeo. Essa é uma das principais vantagens dos anúncios overlay nativos em relação aos anúncios nativos.

Este guia mostra como implementar anúncios overlay nativos em um app do Unity, além de alguns fatores importantes a serem considerados ao longo do caminho.

Pré-requisitos

Sempre teste com anúncios de teste

O exemplo de código abaixo contém um ID do bloco de anúncios que pode ser usado para solicitar anúncios de teste. Ele foi configurado especificamente para retornar anúncios de teste em vez de anúncios de produção para cada solicitação, o que o torna seguro para uso.

No entanto, depois de registrar um app na interface da Web do Ad Manager e criar seus próprios IDs de bloco de anúncios para uso no app, configure o dispositivo como um dispositivo de teste durante o desenvolvimento.

/21775744923/example/native

Carregar o anúncio overlay nativo

O carregamento de um anúncio overlay nativo é feito usando o método estático Load() na classe NativeOverlayAd. O objeto NativeOverlayAd carregado é fornecido como um parâmetro no gerenciador de conclusão.

O código abaixo usa NativeOverlayAd para carregar um anúncio:




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



private NativeOverlayAd _nativeOverlayAd;

/// <summary>
/// Loads the ad.
/// </summary>
public void LoadAd()
{
    // Clean up the old ad before loading a new one.
    if (_nativeOverlayAd != null)
    {
        DestroyAd();
    }

    Debug.Log("Loading native overlay ad.");

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

    // Optional: Define native ad options.
    var options = new NativeAdOptions
    {
        AdChoicesPosition = AdChoicesPlacement.TopRightCorner,
        MediaAspectRatio = NativeMediaAspectRatio.Any,
    };

    // Send the request to load the ad.
    NativeOverlayAd.Load(_adUnitId, adRequest, options,
        (NativeOverlayAd ad, LoadAdError error) =>
    {
        if (error != null)
        {
            Debug.LogError("Native Overlay ad failed to load an ad " +
                           " with error: " + error);
            return;
        }

        // The ad should always be non-null if the error is null, but
        // double-check to avoid a crash.
        if (ad == null)
        {
            Debug.LogError("Unexpected error: Native Overlay ad load event " +
                           " fired with null ad and null error.");
            return;
        }

        // The operation completed successfully.
        Debug.Log("Native Overlay ad loaded with response : " +
                   ad.GetResponseInfo());
        _nativeOverlayAd = ad;

        // Register to ad events to extend functionality.
        RegisterEventHandlers(ad);
    });
}

Renderizar e estilizar o anúncio overlay nativo

Os anúncios overlay nativos são renderizados usando um NativeTemplateStyle. Essa classe define campos que permitem personalizar a aparência do anúncio.

O TemplateID é uma string obrigatória que define o modelo nativo usado para renderizar o anúncio overlay nativo. Use a constante NativeTemplateID para escolher um modelo nativo adequado para seu anúncio.

O código abaixo renderiza o anúncio de overlay nativo com um modelo médio e um estilo personalizado.

/// <summary>
/// Renders the ad.
/// </summary>
public void RenderAd()
{
    if (_nativeOverlayAd != null)
    {
        Debug.Log("Rendering Native Overlay ad.");

        // Define a native template style with a custom style.
        var style = new NativeTemplateStyle
        {
            TemplateID = NativeTemplateID.Medium,
            MainBackgroundColor = Color.red,
            CallToActionText = new NativeTemplateTextStyles
            {
                BackgroundColor = Color.green,
                FontColor = Color.white,
                FontSize = 9,
                Style = NativeTemplateFontStyle.Bold
            }
        };

        // Renders a native overlay ad at the default size
        // and anchored to the bottom of the screne.
        _nativeOverlayAd.RenderTemplate(style, AdPosition.Bottom);
    }
}

Mostrar e ocultar o anúncio em sobreposição nativo

O código a seguir demonstra como mostrar um anúncio de overlay nativo carregado.

/// <summary>
/// Shows the ad.
/// </summary>
public void ShowAd()
{
    if (_nativeOverlayAd != null)
    {
        Debug.Log("Showing Native Overlay ad.");
        _nativeOverlayAd.Show();
    }
}

Ocultar o anúncio nativo sobreposto

O código abaixo demonstra como ocultar um anúncio overlay nativo.

/// <summary>
/// Hides the ad.
/// </summary>
public void HideAd()
{
    if (_nativeOverlayAd != null)
    {
        Debug.Log("Hiding Native Overlay ad.");
        _nativeOverlayAd.Hide();
    }
}

Destruir o anúncio overlay nativo

Ao terminar de usar o anúncio overlay nativo, chame Destroy() para liberar recursos.

/// <summary>
/// Destroys the native overlay ad.
/// </summary>
public void DestroyAd()
{
    if (_nativeOverlayAd != null)
    {
        Debug.Log("Destroying native overlay ad.");
        _nativeOverlayAd.Destroy();
        _nativeOverlayAd = null;
    }
}