Pré-carregamento de anúncios (Beta)

Selecionar plataforma: Android iOS Unity Android (Legacy)

O pré-carregamento de anúncios é um recurso gerenciado pelo Google em GMA Next-Gen SDK que gerencia o carregamento e o armazenamento em cache de anúncios em seu nome. O pré-carregamento de anúncios exige uma mudança na forma como você gerencia o carregamento de anúncios. Para otimizar a performance usando o pré-carregamento de anúncios, desative o armazenamento em cache personalizado e delegue essa responsabilidade a GMA Next-Gen SDK.

O pré-carregamento de anúncios oferece os seguintes benefícios em relação ao carregamento manual de anúncios:

  • Gerenciamento de referências:mantém os anúncios carregados para que você não precise manter referências até estar pronto para mostrá-los.
  • Recarregamento automático:carrega automaticamente um novo anúncio quando você retira um do cache.
  • Novas tentativas gerenciadas:repete automaticamente as solicitações com falha usando a retirada exponencial.
  • Processamento de expiração:atualiza automaticamente os anúncios antes que eles expirem (normalmente após uma hora).
  • Otimização do cache: se você usar um tamanho de cache maior que um, GMA Next-Gen SDK otimizará a ordem do cache para veicular o melhor anúncio.

Este guia aborda a configuração de anúncios de pré-carregamento, a verificação da disponibilidade de anúncios de pré-carregamento e a exibição do anúncio pré-carregado.

Pré-requisitos

Antes de continuar com este tutorial, você deve configurar GMA Next-Gen SDK.

Começar a pré-carregar anúncios

Quando o app for iniciado, chame o método startPreload uma vez. Depois de chamar o método startPreload, GMA Next-Gen SDK pré-carrega anúncios automaticamente e repete as solicitações com falha para configurações pré-carregadas.

O exemplo a seguir inicia o pré-carregamento de anúncios:

Kotlin

private fun startPreloading(adUnitId: String) {
  val adRequest = AdRequest.Builder(adUnitId).build()
  val preloadConfig = PreloadConfiguration(adRequest)
  InterstitialAdPreloader.start(adUnitId, preloadConfig)
}

Java

private void startPreloading(String adUnitId) {
  AdRequest adRequest = new AdRequest.Builder(adUnitId).build();
  PreloadConfiguration preloadConfig = new PreloadConfiguration(adRequest);
  InterstitialAdPreloader.start(adUnitId, preloadConfig);
}

Receber e mostrar o anúncio pré-carregado

Ao usar o pré-carregamento de anúncios, GMA Next-Gen SDK mantém os anúncios armazenados em cache. Quando quiser mostrar um anúncio, chame pollAd. GMA Next-Gen SDK recupera o anúncio disponível e pré-carrega automaticamente o próximo anúncio em segundo plano.

Evite chamar o método pollAd até estar pronto para mostrar um anúncio. Manter anúncios no cache permite que GMA Next-Gen SDK atualize automaticamente anúncios expirados e realize a otimização do cache.

O exemplo a seguir recupera e mostra um anúncio pré-carregado:

Kotlin

private fun pollAndShowAd(activity: Activity, adUnitId: String) {
  // Polling returns the next available ad and loads another ad in the background.
  val ad = InterstitialAdPreloader.pollAd(adUnitId)

  // Interact with the ad object as needed.
  ad?.apply {
    Log.d(TAG, "Interstitial ad response info: ${this.getResponseInfo()}")
    this.adEventCallback =
      object : InterstitialAdEventCallback {
        override fun onAdImpression() {
          Log.d(TAG, "Interstitial ad recorded an impression.")
        }

        override fun onAdPaid(value: AdValue) {
          Log.d(TAG, "Interstitial ad onPaidEvent: ${value.valueMicros} ${value.currencyCode}")
        }
      }

    // Show the ad.
    ad.show(activity)
  }
}

Java

private void pollAndShowAd(Activity activity, String adUnitId) {
  // Polling returns the next available ad and loads another ad in the background.
  final InterstitialAd ad = InterstitialAdPreloader.pollAd(adUnitId);

  // Interact with the ad object as needed.
  if (ad != null) {
    Log.d(TAG, "Interstitial ad response info: " + ad.getResponseInfo());
    ad.setAdEventCallback(
        new InterstitialAdEventCallback() {
          @Override
          public void onAdImpression() {
            Log.d(TAG, "Interstitial ad recorded an impression.");
          }

          @Override
          public void onAdPaid(AdValue value) {
            Log.d(
                TAG,
                "Interstitial ad onPaidEvent: "
                    + value.getValueMicros()
                    + " "
                    + value.getCurrencyCode());
          }
        });

    // Show the ad.
    ad.show(activity);
  }
}

Receber metadados de anúncios pré-carregados

Para receber metadados de anúncios pré-carregados, você pode pesquisar o objeto de informações de resposta do anúncio. Esse processo permite inspecionar os metadados do anúncio sem removê-lo do cache.

O exemplo a seguir pesquisa os metadados de um anúncio pré-carregado no objeto de informações de resposta:

Kotlin

private fun peekAdResponseInfo(preloadId: String) {
  InterstitialAdPreloader.peekAdResponseInfo(preloadId)?.let {
    Log.d(TAG, "Peeked ad response ID: ${it.responseId}")
  }
}

Java

private void peekAdResponseInfo(String preloadId) {
  ResponseInfo responseInfo = InterstitialAdPreloader.peekAdResponseInfo(preloadId);
  if (responseInfo != null) {
    Log.d(TAG, "Peeked ad response ID: " + responseInfo.getResponseId());
  }
}

Verificar a disponibilidade de anúncios de pré-carregamento

Para verificar a disponibilidade de anúncios, escolha uma das seguintes opções:

Receber a disponibilidade de anúncios de pré-carregamento

O exemplo a seguir verifica a disponibilidade de anúncios:

Kotlin

private fun isAdAvailable(adUnitId: String): Boolean {
  return InterstitialAdPreloader.isAdAvailable(adUnitId)
}

Java

private boolean isAdAvailable(String adUnitId) {
  return InterstitialAdPreloader.isAdAvailable(adUnitId);
}

Ouvir a disponibilidade de anúncios de pré-carregamento

Registre-se para eventos de pré-carregamento para receber notificações quando os anúncios forem pré-carregados, falharem ao pré-carregar ou o cache de anúncios estiver esgotado.

Os eventos de pré-carregamento são destinados a fins de análise. Nas funções de callback de eventos de pré-carregamento:

  • Não chame startPreload.
  • Evite chamar pollAd, a menos que o anúncio seja mostrado imediatamente.

O exemplo a seguir registra eventos de anúncios:

Kotlin

private fun startPreloadingWithCallback(adUnitId: String) {
  val preloadCallback =
    // [Important] Don't call ad preloader start() or pollAd() within the PreloadCallback.
    object : PreloadCallback {
      override fun onAdFailedToPreload(preloadId: String, adError: LoadAdError) {
        Log.i(
          TAG,
          ("Interstitial preload ad $preloadId failed to load with error: ${adError.message}"),
        )
        // [Optional] Get the error response info for additional details.
        // val responseInfo = adError.responseInfo
      }

      override fun onAdsExhausted(preloadId: String) {
        Log.i(TAG, "Interstitial preload ad $preloadId is not available")
        // [Important] Don't call ad preloader start() or pollAd() from onAdsExhausted.
      }

      override fun onAdPreloaded(preloadId: String, responseInfo: ResponseInfo) {
        Log.i(TAG, "Interstitial preload ad $preloadId is available")
      }
    }
  val adRequest = AdRequest.Builder(adUnitId).build()
  val preloadConfig = PreloadConfiguration(adRequest)
  InterstitialAdPreloader.start(adUnitId, preloadConfig, preloadCallback)
}

Java

private void startPreloadingWithCallback(String adUnitId) {
  PreloadCallback preloadCallback =
      // [Important] Don't call ad preloader start() or pollAd() within the PreloadCallback.
      new PreloadCallback() {
        @Override
        public void onAdFailedToPreload(String preloadId, LoadAdError adError) {
          Log.e(
              TAG,
              String.format(
                  "Interstitial preload ad %s failed to load with error: %s",
                  preloadId, adError.getMessage()));
          // [Optional] Get the error response info for additional details.
          // ResponseInfo responseInfo = adError.getResponseInfo();
        }

        @Override
        public void onAdsExhausted(String preloadId) {
          Log.i(TAG, "Interstitial preload ad " + preloadId + " is not available");
          // [Important] Don't call ad preloader start() or pollAd() from onAdsExhausted.
        }

        @Override
        public void onAdPreloaded(String preloadId, ResponseInfo responseInfo) {
          Log.i(TAG, "Interstitial preload ad " + preloadId + " is available");
        }
      };

  AdRequest adRequest = new AdRequest.Builder(adUnitId).build();
  PreloadConfiguration preloadConfig = new PreloadConfiguration(adRequest);
  InterstitialAdPreloader.start(adUnitId, preloadConfig, preloadCallback);
}

Parar de pré-carregar anúncios

Se você não precisar mostrar anúncios para um ID de pré-carregamento novamente na sessão, poderá parar de pré-carregar anúncios. Para parar de pré-carregar anúncios para um ID de pré-carregamento específico, chame destroy com um ID de pré-carregamento. Para parar o pré-carregamento de todos os pré-carregadores, chame destroyAll.

Definir o tamanho do buffer

O tamanho do buffer controla o número de anúncios pré-carregados mantidos na memória. Por padrão, o Google otimiza o tamanho do buffer para equilibrar o consumo de memória e a latência de veiculação de anúncios. Se o app mostrar anúncios antes que o próximo anúncio seja carregado, você poderá definir um tamanho de buffer personalizado para aumentar o número de anúncios mantidos na memória.

Kotlin

private fun setBufferSize(adUnitId: String) {
  val adRequest = AdRequest.Builder(adUnitId).build()
  val preloadConfig = PreloadConfiguration(adRequest, bufferSize = 3)
  InterstitialAdPreloader.start(adUnitId, preloadConfig)
}

Java

private void setBufferSize(String adUnitId) {
  AdRequest adRequest = new AdRequest.Builder(adUnitId).build();
  PreloadConfiguration preloadConfig = new PreloadConfiguration(adRequest, 3);
  InterstitialAdPreloader.start(adUnitId, preloadConfig);
}

Limites de cache de pré-carregamento

GMA Next-Gen SDK aplica um limite em todo o app para o número total de anúncios pré-carregados em todos os blocos de anúncios e IDs de pré-carregamento:

  • Limite padrão: GMA Next-Gen SDK mantém um máximo de seis anúncios pré-carregados na memória. Esse limite é compartilhado em todos os formatos e IDs de pré-carregamento.
  • Recomendamos manter um tamanho de buffer de 2 ou 3 por ID de pré-carregamento.