Começar

Atenção: o plug-in nativo dos anúncios para dispositivos móveis do Google para Unity foi descontinuado. Use anúncios overlay nativos em vez disso. Se você quiser continuar usando anúncios nativos renderizados como parte do ambiente do jogo, preencha o formulário de solicitação da versão Beta dos anúncios In-Game imersivos do Google e notifique seu gerente de contas.

Este guia mostra como usar o complemento de anúncios nativos para implementar anúncios nativos da AdMob em um app Unity, além de algumas considerações importantes.

Os anúncios nativos correspondem à forma e à função da experiência do usuário em que são inseridos. Eles também correspondem ao design visual do app em que estão inseridos. Com o formato de anúncios nativos da AdMob, os editores podem renderizar anúncios que combinam com o conteúdo. Você pode usar essa tecnologia para implementar renderizações altamente personalizadas que aproveitam ao máximo o código nativo em apps do Unity.

Os anúncios nativos são exibidos usando os mesmos tipos de GameObjects que você já usa para criar seus apps e podem ser formatados para combinar com o design visual da experiência do usuário em que eles estão. Quando um anúncio nativo é carregado, seu app recebe um objeto nativo que contém os recursos, e o app Unity (e não o SDK) os exibe.

Importante: saiba mais sobre anúncios nativos no nosso manual de anúncios nativos. Você também pode conferir algumas histórias de sucesso de clientes: estudo de caso 1, estudo de caso 2.

Pré-requisitos

• Plug-in de anúncios para dispositivos móveis do Google para Unity versão 7.0.0 ou mais recente.
• Conclua o Guia para iniciantes.
• Faça o download e instale o complemento de anúncios nativos.

Carregar formatos de anúncios nativos

Os anúncios nativos são carregados pela classe AdLoader, que tem a própria classe AdLoader.Builder para personalização durante a criação. O método ForNativeAd() configura o AdLoader para processar anúncios nativos.

private void RequestNativeAd() {
    AdLoader adLoader = new AdLoader.Builder(INSERT_AD_UNIT_HERE)
        .ForNativeAd()
        .Build();
}

Registrar eventos de anúncios do AdLoader

Para receber uma notificação quando um anúncio nativo for carregado ou não, adicione delegados à classe AdLoader para os eventos listados abaixo.

OnNativeAdLoaded

Invocado quando um anúncio nativo é carregado. É necessário ter um delegado para que esse evento acesse o anúncio carregado.

OnAdFailedToLoad

Invocado quando um anúncio nativo não é carregado.

Carregar o anúncio

Dica:é possível usar chamadas de carregamento de anúncios para criar um cache de anúncios carregados antes de exibi-los, para que eles possam ser mostrados sem latência quando necessário. Como os anúncios expiram após uma hora, limpe esse cache e recarregue com novos anúncios a cada hora.

Depois de criar um AdLoader, chame o método LoadAd() dele para solicitar um anúncio:

adLoader.LoadAd(new AdRequest.Builder().Build());

Reunir a solicitação de anúncio

O snippet de código abaixo demonstra como criar um AdLoader que está configurado para solicitar anúncios nativos, define delegados para carregamentos de anúncios bem-sucedidos e com falha e faz uma solicitação de anúncio.

private void RequestNativeAd() {
    AdLoader adLoader = new AdLoader.Builder(INSERT_AD_UNIT_HERE)
        .ForNativeAd()
        .Build();
    adLoader.OnNativeAdLoaded += this.HandleNativeAdLoaded;
    adLoader.OnAdFailedToLoad += this.HandleAdFailedToLoad;
    adLoader.LoadAd(new AdRequest.Builder().Build());
}

Processar carregamentos de anúncios com falha

O evento OnAdFailedToLoad é do tipo EventHandle<AdFailedToLoadEventArgs>. A análise do motivo de uma falha de carregamento de anúncio desse evento é mostrada abaixo.

private void RequestNativeAd() {
    ...
    adLoader.OnAdFailedToLoad += this.HandleNativeAdFailedToLoad;
}

private void HandleNativeAdFailedToLoad(object sender, AdFailedToLoadEventArgs args) {
    Debug.Log("Native ad failed to load: " + args.Message);
}

Mostrar um anúncio nativo

Quando um anúncio nativo é carregado, o evento de anúncio correspondente é invocado. Seu app é responsável por mostrar o anúncio, mas não necessariamente precisa fazer isso imediatamente.

Processar o carregamento de anúncios

O evento OnNativeAdLoaded é do tipo EventHandler<NativeAdEventArgs>. O anúncio, encapsulado em um objeto NativeAd, pode ser recuperado de NativeAdEventArgs, conforme mostrado:

private NativeAd nativeAd;
...
private void HandleNativeAdLoaded(object sender, NativeAdEventArgs args) {
    Debug.Log("Native ad loaded.");
    this.nativeAd = args.nativeAd;
}

Extrair recursos de anúncios nativos

Depois que os anúncios são carregados, os recursos deles podem ser acessados, conforme mostrado abaixo. Os recursos gráficos são retornados como objetos Texture2D, e os recursos de texto são retornados como objetos string.

private bool nativeAdLoaded;
private NativeAd nativeAd;

void Update() {
    ...

    if (this.nativeAdLoaded) {
        this.nativeAdLoaded = false;
        // Get Texture2D for the icon asset of native ad.
        Texture2D iconTexture = this.nativeAd.GetIconTexture();

        // Get string for headline asset of native ad.
        string headline = this.nativeAd.GetHeadlineText();
    }
}

private void HandleNativeAdLoaded(object sender, NativeAdEventArgs args) {
    Debug.Log("Native ad loaded.");
    this.nativeAd = args.nativeAd;
    this.nativeAdLoaded = true;
}

Os recursos de anúncios só podem ser acessados na linha de execução principal, por exemplo, no método Update() de um script do Unity. Além disso, os recursos a seguir nem sempre estão presentes e precisam ser verificados antes de serem exibidos:

• GetStarRating()
• GetStore()
• GetPrice()
• GetAdvertiser()
• GetIconTexture()

Recurso de Opções de anúncios

É necessário mostrar o recurso de anúncio das Opções de anúncios como parte do anúncio nativo. Além disso, é importante que o recurso de anúncio das Opções de anúncios seja facilmente encontrado. Portanto, escolha cores e imagens de plano de fundo adequadas.

Registrar GameObjects para recursos de anúncios

É necessário registrar o GameObject para que o recurso de anúncio seja exibido no app Unity. Se o registro for bem-sucedido, o método usado para registrar o GameObject vai retornar um bool. Para um List<GameObject>, o método retorna um int indicando a contagem de GameObject registrada com sucesso.

Se o registro de um recurso de anúncio não for bem-sucedido, as impressões e os cliques no anúncio nativo correspondente não serão reconhecidos.

if (!this.nativeAd.RegisterIconImageGameObject(icon))
{
    // Handle failure to register the icon ad asset.
}

O GameObject registrado para um recurso de anúncio precisa ter um componente Collider convexo que represente o tamanho e a forma do GameObject. Se os objetos GameObject registrados para recursos de anúncio não tiverem componentes Collider ou estiverem configurados incorretamente, os anúncios nativos não vão funcionar corretamente.

No snippet de código abaixo, uma BoxCollider é adicionada a GameObject, que usa um TextMesh para mostrar o recurso de anúncio principal de um anúncio nativo. Quando o BoxCollider for anexado ao GameObject, ele será dimensionado automaticamente para acomodar o texto do componente TextMesh.

// Create GameObject that will display the headline ad asset.
GameObject headline = new GameObject();
headline.AddComponent<TextMesh>();
headline.GetComponent<TextMesh>().characterSize = 0.5 f;
headline.GetComponent<TextMesh>().anchor = TextAnchor.MiddleCenter;
headline.GetComponent<TextMesh>().color = Color.black;

// Get string of the headline asset.
string headlineText = this.nativeAd.GetHeadlineText();
headline.GetComponent<TextMesh>().text = headlineText;

// Add box collider to the GameObject which will automatically scale.
headline.AddComponent<BoxCollider>();

Demonstração

O código a seguir demonstra como recuperar o recurso de ícone de um anúncio nativo carregado, mostrar o recurso de anúncio de ícone definindo a textura de um Quad e registrar o GameObject a ser usado para mostrar o recurso. Esse processo de recuperar o recurso do anúncio e registrá-lo com a classe de anúncio nativo precisa ser repetido para cada um dos recursos que o app exibe.

private GameObject icon;
private bool nativeAdLoaded;
private NativeAd nativeAd;
...
void Update() {
    ...

    if (this.nativeAdLoaded) {
        this.nativeAdLoaded = false;
        // Get Texture2D for icon asset of native ad.
        Texture2D iconTexture = this.nativeAd.GetIconTexture();

        icon = GameObject.CreatePrimitive(PrimitiveType.Quad);
        icon.transform.position = new Vector3(1, 1, 1);
        icon.transform.localScale = new Vector3(1, 1, 1);
        icon.GetComponent<Renderer>().material.mainTexture = iconTexture;

        // Register GameObject that will display icon asset of native ad.
        if (!this.nativeAd.RegisterIconImageGameObject(icon))
        {
            // Handle failure to register ad asset.
        }
    }
}
...

private void HandleNativeAdLoaded(object sender, NativeAdEventArgs args) {
    Debug.Log("Native ad loaded.");
    this.nativeAd = args.nativeAd;
    this.nativeAdLoaded = true;
}