Anúncios intersticiais

Os anúncios intersticiais são anúncios de tela cheia que cobrem a interface do app host. Normalmente, eles são exibidos em pontos de transição naturais no fluxo de um app, como durante a pausa entre os níveis de um jogo. Quando um app mostra um anúncio intersticial, o usuário pode tocar no anúncio e continuar para o destino ou fechá-lo e retornar ao app.

Este guia explica como integrar anúncios intersticiais a um app Unity.

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 especialmente 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/interstitial

Inicializar o SDK dos anúncios para dispositivos móveis

Antes de carregar anúncios, chame MobileAds.Initialize() para que o app inicialize o SDK de anúncios para dispositivos móveis. Isso precisa ser feito apenas uma vez, de preferência na inicialização do 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.
        });
    }
}

Se você estiver usando a mediação, aguarde até que o callback ocorra antes de carregar anúncios, porque isso garante que todos os adaptadores de mediação sejam inicializados.

Implementação

As principais etapas para integrar anúncios intersticiais são:

  1. Carregar o anúncio intersticial
  2. Mostrar o anúncio intersticial
  3. Ouvir eventos de anúncios intersticiais
  4. Limpar o anúncio intersticial
  5. Pré-carregar o próximo anúncio intersticial

Carregar o anúncio intersticial

É possível carregar um anúncio intersticial usando o método estático Load() na classe InterstitialAd. O método de carregamento requer um ID do bloco de anúncios, um objeto AdManagerAdRequest e um gerenciador de conclusão que é chamado quando o carregamento do anúncio é concluído ou falha. O objeto AdManagerInterstitialAd carregado é fornecido como um parâmetro no gerenciador de conclusão. O exemplo abaixo mostra como carregar uma AdManagerInterstitialAd.


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

  private InterstitialAd _interstitialAd;

  /// <summary>
  /// Loads the interstitial ad.
  /// </summary>
  public void LoadInterstitialAd()
  {
      // Clean up the old ad before loading a new one.
      if (_interstitialAd != null)
      {
            _interstitialAd.Destroy();
            _interstitialAd = null;
      }

      Debug.Log("Loading the interstitial ad.");

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

      // send the request to load the ad.
      AdManagerInterstitialAd.Load(_adUnitId, adRequest,
          (InterstitialAd ad, LoadAdError error) =>
          {
              // if error is not null, the load request failed.
              if (error != null || ad == null)
              {
                  Debug.LogError("interstitial ad failed to load an ad " +
                                 "with error : " + error);
                  return;
              }

              Debug.Log("Interstitial ad loaded with response : "
                        + ad.GetResponseInfo());

              _interstitialAd = ad;
          });
  }

Mostrar o anúncio intersticial

Para mostrar um anúncio intersticial carregado, chame o método Show() na instância AdManagerInterstitialAd. Os anúncios podem ser mostrados uma vez por carregamento. Use o método CanShowAd() para verificar se o anúncio está pronto para ser mostrado.

/// <summary>
/// Shows the interstitial ad.
/// </summary>
public void ShowInterstitialAd()
{
    if (_interstitialAd != null && _interstitialAd.CanShowAd())
    {
        Debug.Log("Showing interstitial ad.");
        _interstitialAd.Show();
    }
    else
    {
        Debug.LogError("Interstitial ad is not ready yet.");
    }
}

Ouvir eventos de anúncios intersticiais

Para personalizar ainda mais o comportamento do seu anúncio, você pode se conectar a vários eventos no ciclo de vida do anúncio. Ouça esses eventos registrando um delegado conforme mostrado abaixo.

private void RegisterEventHandlers(InterstitialAd interstitialAd)
{
    // Raised when the ad is estimated to have earned money.
    interstitialAd.OnAdPaid += (AdValue adValue) =>
    {
        Debug.Log(String.Format("Interstitial ad paid {0} {1}.",
            adValue.Value,
            adValue.CurrencyCode));
    };
    // Raised when an impression is recorded for an ad.
    interstitialAd.OnAdImpressionRecorded += () =>
    {
        Debug.Log("Interstitial ad recorded an impression.");
    };
    // Raised when a click is recorded for an ad.
    interstitialAd.OnAdClicked += () =>
    {
        Debug.Log("Interstitial ad was clicked.");
    };
    // Raised when an ad opened full screen content.
    interstitialAd.OnAdFullScreenContentOpened += () =>
    {
        Debug.Log("Interstitial ad full screen content opened.");
    };
    // Raised when the ad closed full screen content.
    interstitialAd.OnAdFullScreenContentClosed += () =>
    {
        Debug.Log("Interstitial ad full screen content closed.");
    };
    // Raised when the ad failed to open full screen content.
    interstitialAd.OnAdFullScreenContentFailed += (AdError error) =>
    {
        Debug.LogError("Interstitial ad failed to open full screen content " +
                       "with error : " + error);
    };
}

Limpar o anúncio intersticial

Quando terminar de usar um AdManagerInterstitialAd, chame o método Destroy() antes de descartar a referência a ele:

_interstitialAd.Destroy();

Isso notifica o plug-in de que o objeto não será mais usado e que a memória que ele ocupa pode ser recuperada. A falha na chamada desse método resulta em vazamentos de memória.

Pré-carregar o próximo anúncio intersticial

Os anúncios intersticiais são um objeto de uso único. Isso significa que, depois que um anúncio intersticial é mostrado, o objeto não pode ser usado novamente. Para solicitar outro anúncio intersticial, crie um novo objeto AdManagerInterstitialAd.

Para preparar um anúncio intersticial para a próxima oportunidade de impressão, pré-carregue o anúncio intersticial quando o evento de anúncio OnAdFullScreenContentClosed ou OnAdFullScreenContentFailed for gerado.

private void RegisterReloadHandler(InterstitialAd interstitialAd)
{
    // Raised when the ad closed full screen content.
    interstitialAd.OnAdFullScreenContentClosed += ()
    {
        Debug.Log("Interstitial Ad full screen content closed.");

        // Reload the ad so that we can show another as soon as possible.
        LoadInterstitialAd();
    };
    // Raised when the ad failed to open full screen content.
    interstitialAd.OnAdFullScreenContentFailed += (AdError error) =>
    {
        Debug.LogError("Interstitial ad failed to open full screen content " +
                       "with error : " + error);

        // Reload the ad so that we can show another as soon as possible.
        LoadInterstitialAd();
    };
}

Eventos de apps

Com os eventos de apps, você pode criar anúncios que enviam mensagens para o código do app. O app pode realizar ações com base nessas mensagens.

Você pode detectar eventos de app específicos do Ad Manager usando AppEvent. Esses eventos podem ocorrer a qualquer momento durante o ciclo de vida do anúncio, mesmo antes de o carregamento ser chamado.

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;
}

OnAppEventReceived é gerado quando um evento do app ocorre em um anúncio. Confira um exemplo de como processar esse evento no código:

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

Confira um exemplo que mostra como mudar a cor de plano de fundo do app dependendo de um evento do app com um nome de cor:

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

E este é o criativo correspondente que envia o evento de app de cores:

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

Práticas recomendadas

Determine se os anúncios intersticiais são o tipo certo de anúncio para seu app.
Os anúncios intersticiais funcionam melhor em apps com pontos de transição naturais. A conclusão de uma tarefa em um app, como compartilhar uma imagem ou passar de fase em um jogo, cria esse ponto. Considere em quais pontos do fluxo do app você quer mostrar os anúncios intersticiais e qual a probabilidade de o usuário reagir.
Pausar a ação ao mostrar um anúncio intersticial.
Existem vários tipos diferentes de anúncios intersticiais, como texto, imagem ou vídeo. É importante garantir que, quando o app mostra um anúncio intersticial, ele também suspende o uso de alguns recursos para permitir que o anúncio aproveite esses recursos. Por exemplo, ao fazer uma chamada para exibir um anúncio intersticial, interrompa a saída de áudio produzida pelo app. Você pode retomar a reprodução de sons no evento OnAdFullScreenContentClosed(), que pode ser invocado quando o usuário terminar de interagir com o anúncio. Além disso, considere interromper temporariamente tarefas de computação intensa, como um ciclo de jogo, enquanto o anúncio está sendo exibido. Isso garante que o usuário não tenha gráficos lentos ou não responsivos ou vídeos travando.
Não inunde o usuário com anúncios.
Embora aumentar a frequência dos anúncios intersticiais no seu app possa parecer uma ótima maneira de aumentar a receita, isso também pode prejudicar a experiência do usuário e reduzir as taxas de cliques. Certifique-se de que os usuários não sejam interrompidos com muita frequência de modo que não possam mais usar o app.

Outros recursos