Anúncios intersticiais

Os anúncios intersticiais são anúncios em tela cheia que cobrem a interface dos aplicativos host. Normalmente, elas são exibidas em pontos de transição natural no fluxo de um aplicativo, como durante uma pausa entre as fases de um jogo. Quando um app mostra anúncio intersticial, o usuário tem a opção de tocar no anúncio e continuar seu destino ou feche-a e retorne ao app.

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

Pré-requisitos

Sempre faça testes com anúncios de teste

O exemplo de código a seguir contém um ID de bloco de anúncios, que você pode usar para solicitar anúncios de teste. Ele foi configurado especialmente para retornar anúncios de teste em vez anúncios de produção para todas as solicitações, o que torna o uso seguro.

No entanto, depois de registrar um aplicativo no na interface da Web do Ad Manager e criou seu próprio bloco de anúncios para uso no app, configure o dispositivo como um teste de forma explícita. dispositivo durante no desenvolvimento de software.

/21775744923/example/interstitial

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

Antes de carregar os anúncios, faça com que seu app inicialize o SDK dos anúncios para dispositivos móveis chamando MobileAds.Initialize(): 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 a chamada de retorno ocorra antes de carregar os anúncios como 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. Detectar eventos de anúncios intersticiais
  4. Limpe o anúncio intersticial
  5. Pré-carregue 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 InterstitialAd. O método de carregamento requer um ID de bloco de anúncios, um AdManagerAdRequest e um gerenciador de conclusão que é chamado quando o carregamento do anúncio é concluído ou apresenta falha. O modelo carregado O objeto AdManagerInterstitialAd é fornecido como um parâmetro no o 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() no 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 exibido.

/// <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 de seu anúncio, você pode vincular 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);
    };
}

Limpe o anúncio intersticial

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

_interstitialAd.Destroy();

Isso notifica o plug-in de que o objeto não é mais usado e que a memória ocupações podem ser recuperadas. A falha em chamar esse método resulta em vazamentos de memória.

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

Os anúncios intersticiais são um objeto de uso único. Isso significa que, quando um anúncio intersticial 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, assim que o OnAdFullScreenContentClosed ou OnAdFullScreenContentFailed evento de anúncio é 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 aplicativos, é possível criar anúncios que enviam mensagens ao código do aplicativo. O app podem realizar ações com base nessas mensagens.

É possível detectar eventos específicos de aplicativos 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 no app ocorre em um anúncio. Veja um exemplo de como processar este evento em seu 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;
    }
  }
};

Confira o criativo correspondente que envia o evento de app de cor:

<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 natural. A conclusão de uma tarefa em um aplicativo, como compartilhar uma imagem ou concluir uma nível de jogo, cria esse ponto. Considere em quais pontos o fluxo do app para mostrar anúncios intersticiais da melhor forma e qual é a probabilidade de o usuário responder.
Pause a ação ao exibir um anúncio intersticial.
Há vários tipos diferentes de anúncios intersticiais, como de texto, imagem ou vídeo. É importante garantir que, quando seu app exibir uma um anúncio intersticial, ela também suspende o uso de alguns recursos para permitir que o anúncio aproveitá-las. Por exemplo, quando você faz a chamada para exibir um anúncio intersticial, pause qualquer saída de áudio que esteja sendo produzida por seu aplicativo. Você pode retomar a reprodução dos sons no evento OnAdFullScreenContentClosed(), que pode ser invocado quando o usuário termina de interagir com o anúncio. Em Além disso, considere interromper temporariamente qualquer tarefa de computação intensa, como loop de jogo enquanto o anúncio está sendo exibido. Isso garante que o usuário não gráficos lentos, sem resposta ou com renderização lenta.
Não sobrecarregue 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, também pode prejudicar a experiência do usuário e taxas de cliques mais baixas. Certifique-se de que os usuários não estejam interrompido e não poderá mais usar seu app.

Outros recursos