Anúncios em banner

Os anúncios de banner são retangulares e ocupam uma parte do layout do app. Eles permanecem na tela enquanto os usuários interagem com o app e ficam fixados na parte de cima ou de baixo da tela ou inline com o conteúdo conforme a rolagem do usuário. Os anúncios de banner podem ser atualizados automaticamente após um determinado período. Consulte Visão geral dos anúncios de bannerpara mais informações.

Este guia mostra como começar a usar anúncios de banner adaptativo fixos, que maximizam a performance otimizando o tamanho do anúncio para cada dispositivo usando uma largura de anúncio especificada por você.

Os anúncios de banner adaptativo fixos têm proporção fixa, e não os anúncios de tamanho fixo. A proporção é semelhante ao padrão do setor de 320 x 50. Assim que você especificar a largura total disponível, ele retornará um anúncio com a altura ideal para essa largura. A altura ideal não muda entre solicitações do mesmo dispositivo, e as visualizações ao redor não precisam se mover quando o anúncio é atualizado.

Pré-requisitos

• Leia o Guia explicativo.

Sempre teste com anúncios de teste

Ao criar e testar seus apps, use anúncios de teste em vez de anúncios de produção ativos. Sua conta poderá ser suspensa se isso não for feito.

A maneira mais fácil de carregar anúncios de teste é usar nosso ID de bloco de anúncios de teste dedicado para banners do Android:

/6499/example/adaptive-banner

Ele foi configurado especialmente para retornar anúncios de teste para cada solicitação e pode ser usado nos seus próprios apps durante a programação, o teste e a depuração. Basta substituí-lo pelo seu próprio ID do bloco de anúncios antes de publicar o aplicativo.

Para mais informações sobre como os anúncios de teste do SDK para dispositivos móveis funcionam, consulte Anúncios de teste.

Adicionar AdManagerAdView ao layout

A primeira etapa para mostrar um banner é colocar AdManagerAdView no layout da Activity ou Fragment em que você quer mostrá-lo:

Java

private AdSize getAdSize() {
  // Determine the screen width (less decorations) to use for the ad width.
  Display display = getWindowManager().getDefaultDisplay();
  DisplayMetrics outMetrics = new DisplayMetrics();
  display.getMetrics(outMetrics);

  float density = outMetrics.density;

  float adWidthPixels = adContainerView.getWidth();

  // If the ad hasn't been laid out, default to the full screen width.
  if (adWidthPixels == 0) {
    adWidthPixels = outMetrics.widthPixels;
  }

  int adWidth = (int) (adWidthPixels / density);
  return AdSize.getCurrentOrientationAnchoredAdaptiveBannerAdSize(this, adWidth);
}

private void loadBanner() {
  
  // Create a new ad view.
  AdManagerAdView adView = new AdManagerAdView(this);
  adView.setAdSizes(getAdSize());
  adView.setAdUnitId("/6499/example/adaptive-banner");

  // Replace ad container with new ad view.
  adContainerView.removeAllViews();
  adContainerView.addView(adView);

  // Start loading the ad in the background.
  AdManagerAdRequest adRequest = new AdManagerAdRequest.Builder().build();
  adView.loadAd(adRequest);
}

Kotlin

// Determine the screen width (less decorations) to use for the ad width.
// If the ad hasn't been laid out, default to the full screen width.
private val adSize: AdSize
  get() {
    val display = windowManager.defaultDisplay
    val outMetrics = DisplayMetrics()
    display.getMetrics(outMetrics)

    val density = outMetrics.density

    var adWidthPixels = binding.adViewContainer.width.toFloat()
    if (adWidthPixels == 0f) {
      adWidthPixels = outMetrics.widthPixels.toFloat()
    }

    val adWidth = (adWidthPixels / density).toInt()
    return AdSize.getCurrentOrientationAnchoredAdaptiveBannerAdSize(this, adWidth)
  }

private fun loadBanner() {
  
  // Create a new ad view.
  val adView = AdManagerAdView(this)
  adView.adSizes = adSize
  adView.adUnitId = "/6499/example/adaptive-banner"

  // Create an ad request.
  val adRequest = AdManagerAdRequest.Builder().build()

  // Start loading the ad in the background.
  adView.loadAd(adRequest)
}

Carregar um anúncio

Quando AdManagerAdView estiver em vigor, a próxima etapa será carregar um anúncio. Isso é feito com o método loadAd() na classe AdManagerAdView. Ele usa um parâmetro AdManagerAdRequest, que contém informações de tempo de execução, como informações de segmentação, sobre uma única solicitação de anúncio.

Importante :faça todas as chamadas para o SDK dos anúncios para dispositivos móveis na linha de execução principal.

Confira um exemplo que mostra como carregar um anúncio no método onCreate() de uma Activity:

Java

private void loadBanner() {
  // Create a new ad view.
  adView = new AdManagerAdView(this);
  adView.setAdUnitId(AD_UNIT);
  adView.setAdSize(getAdSize());
  
  // Replace ad container with new ad view.
  adContainerView.removeAllViews();
  adContainerView.addView(adView);

  // Start loading the ad in the background.
  AdManagerAdRequest adRequest = new AdManagerAdRequest.Builder().build();
  adView.loadAd(adRequest);
}

Kotlin

private fun loadBanner() {
  // This is an ad unit ID for a test ad. Replace with your own banner ad unit ID.
  adView.adUnitId = "/6499/example/banner"
  adView.setAdSize(adSize)
  
  // Create an ad request.
  val adRequest = AdManagerAdRequest.Builder().build()

  // Start loading the ad in the background.
  adView.loadAd(adRequest)
}

Se o anúncio não for carregado, não será necessário solicitar outro explicitamente, desde que você tenha configurado o bloco de anúncios para atualizar. O SDK dos anúncios para dispositivos móveis do Google respeita qualquer taxa de atualização especificada na interface da Web Ad Manager. Se você não tiver ativado a atualização, será necessário emitir uma nova solicitação.

Dica:é possível usar chamadas de carregamento de anúncios para criar um cache de anúncios pré-carregados antes da hora de exibi-los. Assim, eles podem aparecer com latência zero quando necessário. Como os anúncios expiram após uma hora, limpe o cache e recarregue com novos anúncios a cada hora.

Pronto! Agora seu app está pronto para exibir anúncios de banner.

Eventos de anúncio

Para personalizar ainda mais o comportamento do seu anúncio, você pode vincular a vários eventos do ciclo de vida do anúncio: carregamento, abertura, fechamento e assim por diante. É possível detectar esses eventos usando a classe AdListener.

Para usar um AdListener com AdManagerAdView, chame o método setAdListener():

Java

AdManagerAdView.setAdListener(new AdListener() {
    @Override
    public void onAdClicked() {
      // Code to be executed when the user clicks on an ad.
    }

    @Override
    public void onAdClosed() {
      // Code to be executed when the user is about to return
      // to the app after tapping on an ad.
    }

    @Override
    public void onAdFailedToLoad(LoadAdError adError) {
      // Code to be executed when an ad request fails.
    }

    @Override
    public void onAdImpression() {
      // Code to be executed when an impression is recorded
      // for an ad.
    }

    @Override
    public void onAdLoaded() {
      // Code to be executed when an ad finishes loading.
    }

    @Override
    public void onAdOpened() {
      // Code to be executed when an ad opens an overlay that
      // covers the screen.
    }
});

Kotlin

AdManagerAdView.adListener = object: AdListener() {
    override fun onAdClicked() {
      // Code to be executed when the user clicks on an ad.
    }

    override fun onAdClosed() {
      // Code to be executed when the user is about to return
      // to the app after tapping on an ad.
    }

    override fun onAdFailedToLoad(adError : LoadAdError) {
      // Code to be executed when an ad request fails.
    }

    override fun onAdImpression() {
      // Code to be executed when an impression is recorded
      // for an ad.
    }

    override fun onAdLoaded() {
      // Code to be executed when an ad finishes loading.
    }

    override fun onAdOpened() {
      // Code to be executed when an ad opens an overlay that
      // covers the screen.
    }
}

Cada um dos métodos modificáveis em AdListener corresponde a um evento no ciclo de vida de um anúncio.

Métodos modificáveis
onAdClicked()	O método onAdClicked() é invocado quando um clique é registrado para um anúncio.
onAdClosed()	O método onAdClosed() é invocado quando um usuário retorna ao aplicativo depois de ver o URL de destino de um anúncio. Ele pode ser usado pelo app para retomar atividades suspensas ou realizar qualquer outro trabalho necessário para se preparar para a interação.
onAdFailedToLoad()	O método onAdFailedToLoad() é o único que inclui um parâmetro. O parâmetro de erro do tipo LoadAdError descreve o erro ocorrido. Para mais informações, consulte a documentação Depuração de erros de carregamento de anúncios.
onAdImpression()	O método onAdImpression() é invocado quando uma impressão é registrada para um anúncio.
onAdLoaded()	O método onAdLoaded() é executado quando um anúncio termina de carregar. Se você quiser atrasar a adição de AdManagerAdView à sua atividade ou fragmento até ter certeza de que um anúncio será carregado, por exemplo, você pode fazer isso aqui.
onAdOpened()	O método onAdOpened() é invocado quando um anúncio abre uma sobreposição que cobre a tela.

Contagem manual de impressões

A contagem manual de impressões só é compatível com campanhas internas e de venda direta com criativos programados diretamente no Ad Manager. Ele não deve ser usado para preenchimento ou anúncios de redes de terceiros. Para mais detalhes, consulte Como contar impressões e cliques.

É possível enviar pings de impressão manualmente para o Ad Manager se você tem condições especiais para o momento em que uma impressão precisa ser registrada. Para fazer isso, ative uma AdManagerAdRequest para impressões manuais antes de carregar um anúncio:

Java

AdManagerAdRequest adRequest = new AdManagerAdRequest.Builder()
    .setManualImpressionsEnabled(true)
    .build();

Kotlin

val adRequest = AdManagerAdRequest.Builder()
    .setManualImpressionsEnabled(true)
    .build()

Ao determinar que um anúncio foi retornado e está na tela, é possível registrar manualmente uma impressão:

Java

AdManagerAdView.recordManualImpression();

Kotlin

AdManagerAdView.recordManualImpression()

Importante: as impressões normalmente são disparadas quando o callback onAdLoaded() é invocado. Você só poderá usar esse recurso se quiser registrar impressões em diferentes momentos.

Eventos de apps

Com os eventos de apps, é possível criar anúncios que enviam mensagens ao código do app. O app poderá realizar ações com base nessas mensagens.

É possível detectar eventos específicos no app do Ad Manager usando AppEventListener. Esses eventos podem ocorrer a qualquer momento durante o ciclo de vida do anúncio, mesmo antes que onAdLoaded() seja chamado.

Java

public interface AppEventListener {
  void onAppEvent(String name, String info);
}

Kotlin

interface AppEventListener {
    fun onAppEvent(name: String, info: String)
}

void onAppEvent(String name, String info) é chamado quando um evento de app ocorre em um anúncio. Essa interface pode ser implementada pela sua atividade ou por qualquer outro objeto:

Java

import com.google.android.gms.ads.admanager.*;

public class BannerExample extends Activity implements AppEventListener {
}

Kotlin

import com.google.android.gms.ads.admanager.*

class BannerExample : Activity(), AppEventListener {
}

e, em seguida, transmitida para AdManagerAdView:

Java

AdManagerAdView.setAppEventListener(this);

Kotlin

AdManagerAdView.appEventListener = this

Veja um exemplo de como mudar a cor de fundo do app dependendo de um evento com um nome de cor:

Java

@Override
public void onAppEvent(String name, String info) {
  if ("color".equals(name)) {
    if ("green".equals(info)) {
      // Set background color to green.
    } else if ("blue".equals(info)) {
      // Set background color to blue.
    } else {
      // Set background color to black.
    }
  }
}

Kotlin

override fun onAppEvent(name: String?, info: String?) {
    if (name == "color") {
        when (info) {
            "green" -> {
                // Set background color to green.
            }
            "blue" -> {
                // Set background color to blue.
            }
            else -> {
                // Set background color to black.
            }
        }
    }
}

Veja o criativo correspondente que envia mensagens coloridas de evento de app para o listener:

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

Veja o exemplo de eventos de app do Ad Manager para uma implementação de eventos de aplicativo no aplicativo de demonstração da API para iOS.

Java Kotlin

Aceleração de hardware para anúncios em vídeo

Para que os anúncios em vídeo sejam exibidos nas visualizações de anúncios de banner, a aceleração de hardware precisa estar ativada.

A aceleração de hardware é ativada por padrão, mas alguns apps podem optar por desativá-la. Caso isso se aplique ao seu app, recomendamos ativar a aceleração de hardware para classes Activity que usam anúncios.

Ativar a aceleração de hardware

Se o app não se comportar corretamente com a aceleração de hardware ativada globalmente, ela também poderá ser controlada para atividades individuais. Para ativar ou desativar a aceleração de hardware, use o atributo android:hardwareAccelerated para os elementos <application> e <activity> no AndroidManifest.xml. O exemplo abaixo ativa a aceleração de hardware para todo o app, mas a desativa para uma atividade:

<application android:hardwareAccelerated="true">
    <!-- For activities that use ads, hardwareAcceleration should be true. -->
    <activity android:hardwareAccelerated="true" />
    <!-- For activities that don't use ads, hardwareAcceleration can be false. -->
    <activity android:hardwareAccelerated="false" />
</application>

Consulte o guia Aceleração de hardware para mais informações sobre opções de controle da aceleração de hardware. Observe que visualizações individuais de anúncios não poderão ser ativadas para aceleração de hardware se a atividade estiver desativada. Portanto, a atividade em si precisa ter a aceleração de hardware ativada.

Outros recursos

Exemplos no GitHub

• Exemplo de anúncios de banner adaptativo fixos: Java | Kotlin

• Demonstração de recursos avançados: Java | Kotlin

Próximas etapas

Banners que podem ser recolhidos

Os anúncios de banner que podem ser recolhidos são inicialmente apresentados como uma sobreposição maior, com um botão para recolhê-los. Use esse recurso para otimizar ainda mais seu desempenho. Consulte os anúncios de banner que podem ser recolhidos para mais detalhes.

Banners adaptativos inline

Os banners adaptativos inline são maiores e mais altos em comparação com os fixos fixados. Eles têm altura variável e podem ter a mesma altura da tela do dispositivo. Recomendamos o uso de banners adaptativos inline, em vez de anúncios de banner adaptativos fixos, para apps que os colocam em conteúdo rolável. Consulte banners adaptáveis inline para mais detalhes.

Confira outros temas

• Privacidade do usuário
• A inicialização do SDK e o carregamento de anúncios do Optimize (Beta)