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 spiega 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 specificata.

Gli annunci banner adattivi ancorati sono annunci con proporzioni fisse, anziché annunci con dimensioni fisse. Le proporzioni sono simili allo standard di settore 320x50. Una volta specificata la larghezza massima disponibile, verrà restituito un annuncio con un'altezza ottimale per quella larghezza. L'altezza ottimale non cambia nelle richieste dello stesso dispositivo e le visualizzazioni circostanti non devono spostarsi quando l'annuncio viene aggiornato.

Prerequisiti

• Completa la Guida introduttiva.

Esegui sempre test con annunci di prova

Quando crei e testi le tue app, assicurati di utilizzare annunci di prova anziché annunci pubblicati in produzione. In caso contrario, il tuo account potrebbe essere sospeso.

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

/21775744923/example/adaptive-banner

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

Per ulteriori informazioni sul funzionamento degli annunci di prova dell'SDK Mobile Ads, consulta Annunci di prova.

Aggiungi AdManagerAdView al layout

Per creare un banner, devi determinare le dimensioni dell'annuncio. Completa i seguenti passaggi:

1. Crea una dimensione dell'annuncio adattabile ancorato a tutta larghezza:

   Java

   // Get the ad size with screen width.
   public AdSize getAdSize() {
     DisplayMetrics displayMetrics = getResources().getDisplayMetrics();
     int adWidthPixels = displayMetrics.widthPixels;
   
     if (VERSION.SDK_INT >= VERSION_CODES.R) {
       WindowMetrics windowMetrics = this.getWindowManager().getCurrentWindowMetrics();
       adWidthPixels = windowMetrics.getBounds().width();
     }
   
     float density = displayMetrics.density;
     int adWidth = (int) (adWidthPixels / density);
     return AdSize.getCurrentOrientationAnchoredAdaptiveBannerAdSize(this, adWidth);
   }
   MyActivity.java
   

   Kotlin

   // Get the ad size with screen width.
   private val adSize: AdSize
     get() {
       val displayMetrics = resources.displayMetrics
       val adWidthPixels =
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
           val windowMetrics: WindowMetrics = this.windowManager.currentWindowMetrics
           windowMetrics.bounds.width()
         } else {
           displayMetrics.widthPixels
         }
       val density = displayMetrics.density
       val adWidth = (adWidthPixels / density).toInt()
       return AdSize.getCurrentOrientationAnchoredAdaptiveBannerAdSize(this, adWidth)
     }
   MyActivity.kt
   

2. Crea un AdManagerAdView utilizzando le dimensioni dell'annuncio e aggiunto al layout dell'app:

   Java

   // 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);
   MyActivity.java
   

   Kotlin

   // Create a new ad view.
   val adView = AdManagerAdView(this)
   adView.adUnitId = AD_UNIT_ID
   adView.setAdSize(adSize)
   this.adView = adView
   
   // Replace ad container with new ad view.
   binding.adViewContainer.removeAllViews()
   binding.adViewContainer.addView(adView)
   MyActivity.kt
   

Carica un annuncio

Una volta inserito il AdManagerAdView, il passaggio successivo consiste nel caricare un annuncio. Questo viene fatto con il metodo loadAd() nella classe AdManagerAdView. Richiede un parametro AdManagerAdRequest, che contiene informazioni di runtime, ad esempio informazioni sul targeting, relative a una singola richiesta di annuncio.

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

Ecco un esempio che mostra come caricare un annuncio:

Java

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

Kotlin

// Start loading the ad in the background.
val adRequest = AdManagerAdRequest.Builder().build()
adView.loadAd(adRequest)
MyActivity.kt

In caso di esito positivo, la tua app è pronta per mostrare gli annunci banner.

Suggerimento: puoi utilizzare le chiamate di caricamento degli annunci per creare una cache di annunci pre caricati prima di intenderne la pubblicazione, in modo che gli annunci possano essere mostrati senza latenza quando necessario. Poiché gli annunci scadono dopo un'ora, devi svuotare questa cache e ricaricare con nuovi annunci ogni ora.

Aggiornare un annuncio

Se hai configurato l'aggiornamento dell'unità pubblicitaria, non devi richiedere un altro annuncio quando non riesce a caricarsi. L'SDK Google Mobile Ads rispetta qualsiasi frequenza di aggiornamento specificata nell'interfaccia utente di Ad Manager. Se non hai attivato il aggiornamento, invia una nuova richiesta. Per ulteriori dettagli sull'aggiornamento delle unità pubblicitarie, ad esempio sull'impostazione di una frequenza di aggiornamento, consulta Frequenza di aggiornamento degli annunci nelle app mobile.

Nota: quando imposti una frequenza di aggiornamento nell'interfaccia utente di Ad Manager, l'aggiornamento automatico avviene solo se il banner è visibile sullo schermo.

Eventi dell'annuncio

Puoi rilevare una serie di eventi nel ciclo di vita dell'annuncio, tra cui caricamento, impressione e clic sull'annuncio, nonché eventi di apertura e chiusura dell'annuncio. Ti consigliamo di impostare il callback prima di caricare il banner.

Java

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

adView.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 sostituibili in AdListener corrisponde a un evento nel ciclo di vita di un annuncio.

Metodi sostituibili
onAdClicked()	Il metodo onAdClicked() viene invocato quando viene registrato un clic per un annuncio.
onAdClosed()	Il metodo onAdClosed() viene invocato quando un utente torna nell'app dopo aver visualizzato l'URL di destinazione di un annuncio. La tua app può utilizzarlo per riprendere le attività sospese o eseguire qualsiasi altro lavoro necessario per prepararsi all'interazione.
onAdFailedToLoad()	Il metodo onAdFailedToLoad() è l'unico che include un parametro. Il parametro errore di tipo LoadAdError descrive l'errore che si è verificato. Per saperne di più, consulta la documentazione relativa al 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 posticipare l'aggiunta di AdManagerAdView alla tua attività o al tuo frammento finché non hai la certezza che verrà caricato un annuncio, ad esempio, puoi farlo qui.
onAdOpened()	Il metodo onAdOpened() viene invocato 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, è necessario attivare l'accelerazione hardware.

L'accelerazione hardware è attiva per impostazione predefinita, ma alcune app potrebbero scegliere di disattivarla. Se questo vale per la tua app, ti consigliamo di attivare l'accelerazione hardware per i Activity classi che utilizzano gli annunci.

Attivare l'accelerazione hardware

Se la tua app non si comporta correttamente con l'accelerazione hardware attivata a livello globale, puoi controllarla anche per le singole attività. Per attivare o disattivare l'accelerazione hardware, puoi utilizzare l'attributo android:hardwareAccelerated per gli elementi <application> e <activity> nel AndroidManifest.xml. L'esempio seguente attiva l'accelerazione hardware per l'intera app, ma la disattiva 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>

Per ulteriori informazioni sulle opzioni di controllo dell'accelerazione hardware, consulta la guida sull'accelerazione hardware. Tieni presente che le visualizzazioni dei singoli annunci non possono essere attivate per l'accelerazione hardware se l'attività è disattivata, pertanto l'accelerazione hardware deve essere attivata per l'attività stessa.

Conteggio manuale delle impressioni

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

Puoi inviare manualmente i ping di impressione ad Ad Manager se hai condizioni speciali per la registrazione di un'impressione. Per farlo, 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 ed è sullo schermo, puoi registrare manualmente un'impressione:

Java

{ ad_view }.recordManualImpression();

Kotlin

AdManagerAdView.recordManualImpression()

Punto chiave: le impressioni vengono normalmente attivate quando viene invocato 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 può quindi eseguire azioni in base a questi messaggi.

Puoi ascoltare eventi app specifici di Ad Manager utilizzando 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 poi trasmessa 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 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 eventi relativi alle app a colori 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>

Consulta l'esempio di eventi app di Ad Manager per un'implementazione degli eventi app nell'app Demo API.

Java Kotlin

Risorse aggiuntive

Esempi su GitHub

• Esempio di annunci di banner adattivi ancorati: Java | Kotlin

• Demo delle funzionalità avanzate: Java | Kotlin

Passaggi successivi

Banner comprimibili

Gli annunci banner comprimibili sono annunci banner inizialmente presentati come overlay più grandi, con un pulsante per comprimere l'annuncio in modo da ridurne le dimensioni. Valuta la possibilità di utilizzarla per ottimizzare ulteriormente il rendimento. Per maggiori dettagli, consulta gli annunci banner comprimibili.

Banner adattivi in linea

I banner adattivi in linea sono banner più grandi e più alti rispetto ai banner adattivi ancorati. Sono di altezza variabile e possono occupare l'intero schermo del dispositivo. I banner adattivi in linea sono consigliati rispetto agli annunci banner adattivi ancorati per le app che posizionano gli annunci banner in contenuti scorrevoli. Per ulteriori dettagli, consulta la sezione relativa ai banner adattabili in linea.

Esplora altri argomenti

• Privacy degli utenti
• Ottimizzare l'inizializzazione dell'SDK e il caricamento degli annunci (beta)