Annunci banner

Gli annunci banner sono annunci rettangolari che occupano una parte del layout di un'app. Rimangono sullo schermo durante l'interazione degli utenti con l'app, ancorati nella parte superiore o inferiore dello schermo o in linea con i contenuti mentre l'utente scorre. Gli annunci banner possono aggiornarsi automaticamente dopo un determinato periodo di tempo. Per saperne di più, consulta la Panoramica degli annunci banner.

Questa guida mostra come iniziare a utilizzare gli annunci banner adattivi ancorati, che massimizzano il rendimento ottimizzando le dimensioni dell'annuncio per ogni dispositivo utilizzando una larghezza dell'annuncio da te specificata.

Gli annunci banner adattivi ancorati sono annunci con proporzioni fisse anziché normali annunci con dimensioni fisse. Le proporzioni sono simili allo standard di settore 320 x 50. Una volta specificata l'intera larghezza disponibile, verrà restituito un annuncio con altezza ottimale per quella larghezza. L'altezza ottimale non cambia tra le richieste provenienti dallo stesso dispositivo e non è necessario che le visualizzazioni circostanti si spostino quando l'annuncio si aggiorna.

Prerequisiti

• Completa la Guida introduttiva.

Esegui sempre test con annunci di prova

Quando crei e test le tue app, assicurati di utilizzare annunci di prova anziché annunci di produzione pubblicati. In caso contrario, l'account potrebbe essere sospeso.

Il modo più semplice per caricare annunci di prova è utilizzare il nostro ID unità pubblicitaria di prova dedicato per i banner Android:

/6499/example/adaptive-banner

È configurato appositamente per restituire annunci di prova per ogni richiesta e puoi utilizzarlo nelle tue app durante la programmazione, il test e il debug. Assicurati di sostituirlo con il tuo ID unità pubblicitaria prima di pubblicare l'app.

Per ulteriori informazioni su come funzionano gli annunci di prova dell'SDK Mobile Ads, consulta Test Ads.

Aggiungi AdManagerAdView al layout

Il primo passaggio per mostrare un banner è posizionare AdManagerAdView nel layout per Activity o Fragment in cui vuoi mostrarlo .:

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

Carica un annuncio

Dopo AdManagerAdView l'implementazione, il passaggio successivo consiste nel caricare un annuncio. Puoi farlo con il metodo loadAd() nel corso AdManagerAdView. Prende un parametro AdManagerAdRequest, che contiene le informazioni di runtime, ad esempio le informazioni di targeting, relative a una singola richiesta di annuncio.

Punto chiave: effettua tutte le chiamate all'SDK Mobile Ads nel thread principale.

Ecco un esempio che mostra come caricare un annuncio nel metodo onCreate() di un 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 l'annuncio non viene caricato, non è necessario richiederne un altro in modo esplicito, purché tu abbia configurato l'aggiornamento dell'unità pubblicitaria; l'SDK Google Mobile Ads rispetta la frequenza di aggiornamento specificata nell' Ad Manager interfaccia web. Se non hai abilitato l'aggiornamento, dovrai inviare una nuova richiesta.

Suggerimento: puoi utilizzare le chiamate al carico degli annunci per creare una cache di annunci precaricati prima di volerli mostrare, in modo che gli annunci possano essere mostrati con latenza zero quando necessario. Poiché gli annunci scadono dopo un'ora, è consigliabile svuotare la cache e ricaricare gli annunci ogni ora.

È tutto. L'app è ora pronta per la pubblicazione degli annunci banner.

Eventi annuncio

Puoi rimanere in ascolto per una serie di eventi del ciclo di vita dell'annuncio, tra cui caricamento, impressioni e clic dell'annuncio, nonché eventi di apertura e chiusura dell'annuncio. Ti consigliamo di impostare il callback prima di caricare il banner.

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

Ciascuno dei metodi eseguibili in AdListener corrisponde a un evento nel ciclo di vita di un annuncio.

Metodi sostituibili
onAdClicked()	Il metodo onAdClicked() viene richiamato quando viene registrato un clic per un annuncio.
onAdClosed()	Il metodo onAdClosed() viene richiamato quando un utente torna all'app dopo aver visualizzato l'URL di destinazione di un annuncio. La tua app può utilizzarla per riprendere le attività sospese o eseguire qualsiasi altra operazione necessaria per prepararsi all'interazione.
onAdFailedToLoad()	Il metodo onAdFailedToLoad() è l'unico che include un parametro. Il parametro di errore di tipo LoadAdError descrive quale errore si è verificato. Per saperne di più, consulta la documentazione sul debug degli errori di caricamento degli annunci.
onAdImpression()	Il metodo onAdImpression() viene richiamato quando viene registrata un'impressione per un annuncio.
onAdLoaded()	Il metodo onAdLoaded() viene eseguito al termine del caricamento di un annuncio. Se vuoi ritardare l'aggiunta di AdManagerAdView all'attività o al frammento fino a quando hai la certezza che un annuncio verrà caricato, ad esempio, puoi farlo qui.
onAdOpened()	Il metodo onAdOpened() viene richiamato quando un annuncio apre un overlay che copre lo schermo.

Accelerazione hardware per gli annunci video

Affinché gli annunci video vengano visualizzati correttamente nelle visualizzazioni degli annunci banner, l'accelerazione hardware deve essere attivata.

L'accelerazione hardware è abilitata per impostazione predefinita, ma alcune app potrebbero scegliere di disattivarla. Se questo è il caso della tua app, consigliamo di abilitare l'accelerazione hardware per le classi Activity che utilizzano annunci.

Attivazione dell'accelerazione hardware

Se la tua app non si comporta correttamente con l'accelerazione hardware attivata a livello globale, puoi anche controllarla per le singole attività. Per attivare o disabilitare l'accelerazione hardware, puoi utilizzare l'attributo android:hardwareAccelerated per gli elementi <application> e <activity> in AndroidManifest.xml. L'esempio seguente consente l'accelerazione hardware per l'intera app, ma la disabilita per un'attività:

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

Consulta la guida all'accelerazione hardware per ulteriori informazioni sulle opzioni disponibili per il controllo dell'accelerazione hardware. Tieni presente che le singole visualizzazioni di annunci non possono essere attivate per l'accelerazione hardware se l'attività è disattivata, pertanto per l'attività stessa deve essere attivata l'accelerazione hardware.

Conteggio manuale delle impressioni

Il conteggio manuale delle impressioni è compatibile solo con le campagne vendute direttamente e autopromozionali con creatività il cui traffico viene gestito direttamente in Ad Manager. Non deve essere utilizzato per annunci di backfill o di reti di terze parti. Per ulteriori dettagli, consulta Conteggio di impressioni e clic.

Puoi inviare manualmente ping delle impressioni ad Ad Manager se hai condizioni speciali per la registrazione dell'impressione. A questo scopo, attiva un AdManagerAdRequest per le impressioni manuali prima di caricare un annuncio:

Java

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

Kotlin

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

Quando stabilisci che un annuncio è stato restituito correttamente e che è visualizzato sullo schermo, puoi registrare manualmente un'impressione:

Java

AdManagerAdView.recordManualImpression();

Kotlin

AdManagerAdView.recordManualImpression()

Punto chiave: in genere le impressioni vengono attivate quando viene richiamato il callback onAdLoaded(). Ti consigliamo di utilizzare questa funzionalità solo se vuoi registrare le impressioni in un momento diverso.

Eventi app

Gli eventi app ti consentono di creare annunci che possono inviare messaggi al codice dell'app. L'app potrà quindi eseguire azioni in base a questi messaggi.

Puoi ascoltare eventi dell'app specifici di Ad Manager utilizzando l'istruzione AppEventListener. Questi eventi possono verificarsi in qualsiasi momento durante il ciclo di vita dell'annuncio, anche prima della chiamata di onAdLoaded().

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) viene chiamato quando si verifica un evento app in un annuncio. Questa interfaccia può essere implementata dalla tua attività o da qualsiasi altro oggetto:

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 passato a AdManagerAdView:

Java

AdManagerAdView.setAppEventListener(this);

Kotlin

AdManagerAdView.appEventListener = this

Ecco un esempio che mostra come modificare il colore di sfondo dell'app in base a un evento dell'app con un nome di colore:

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

Ecco la creatività corrispondente che invia messaggi di evento dell'app colore al 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>

Guarda l'esempio di Eventi app di Ad Manager per un'implementazione di eventi app nell'app demo API.

Java Kotlin

Risorse aggiuntive

Esempi su GitHub

• Esempio di annunci banner adattivi ancorati: Java | Kotlin

• Demo sulle funzionalità avanzate: Java | Kotlin

Passaggi successivi

Banner comprimibili

Gli annunci banner comprimibili sono annunci banner che all'inizio vengono presentati come un overlay più grande, con un pulsante per comprimere l'annuncio riducendolo. Valuta la possibilità di utilizzarlo per ottimizzare ulteriormente il rendimento. Per ulteriori dettagli, consulta la sezione sugli annunci banner comprimibili.

Banner adattivi incorporati

I banner adattivi in linea sono banner più grandi e più alti rispetto ai banner adattivi ancorati. Hanno un'altezza variabile e possono raggiungere l'altezza dello schermo del dispositivo. I banner adattivi in linea sono consigliati rispetto agli annunci banner adattivi ancorati per le app che inseriscono gli annunci banner in contenuti scorrevoli. Per ulteriori dettagli, consulta i banner adattivi incorporati.

Esplora altri argomenti

• Privacy utente
• Ottimizza l'inizializzazione dell'SDK e il caricamento degli annunci (beta)