Caricare un annuncio nativo

Seleziona la piattaforma: Android (beta) Android iOS Flutter Unity

Gli annunci nativi sono asset pubblicitari presentati agli utenti tramite componenti dell'interfaccia utente nativi della piattaforma. Vengono mostrati utilizzando gli stessi tipi di visualizzazioni con cui crei già i layout e possono essere formattati in modo da corrispondere al design visivo dell'app.

Quando viene caricato un annuncio nativo, l'app riceve un oggetto annuncio che contiene i relativi asset, e l'app, anziché Google Mobile Ads SDK—è quindi responsabile della loro visualizzazione.

In generale, l'implementazione corretta degli annunci nativi prevede due passaggi: caricare un annuncio utilizzando l'SDK e poi visualizzare i contenuti dell'annuncio nell'app.

Questa pagina mostra come utilizzare l'SDK per caricare gli annunci nativi. Suggerimento: scopri di più sugli annunci nativi nel nostro Playbook per gli annunci nativi.

Puoi anche consultare alcune storie di successo dei clienti: case study 1, case study 2.

Prerequisiti

Prima di continuare, configura Google Mobile Ads SDK.

Esegui sempre i test con gli annunci di prova

Quando crei e testi le tue app, assicurati di utilizzare annunci di prova anziché annunci di produzione live.

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

ca-app-pub-3940256099942544/2247696110

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

Per i dettagli sugli annunci di prova Google Mobile Ads SDK, consulta Attivare gli annunci di prova.

Caricare gli annunci

Gli annunci nativi vengono caricati con la AdLoader classe, che ha una propria Builder classe per personalizzarla durante la creazione. Aggiungendo listener a AdLoader durante la creazione, un'app specifica i tipi di annunci nativi che è pronta a ricevere. Poi, AdLoader richiede solo questi tipi.

Creare un AdLoader

Il seguente codice mostra come creare un AdLoader in grado di caricare annunci nativi:

Java

// It is recommended to call AdLoader.Builder on a background thread.
new Thread(
        () -> {
          AdLoader adLoader =
              new AdLoader.Builder(context, "AD_UNIT_ID")
                  .forNativeAd(
                      new NativeAd.OnNativeAdLoadedListener() {
                        @Override
                        // The native ad loaded successfully. You can show the ad.
                        public void onNativeAdLoaded(@NonNull NativeAd nativeAd) {}
                      })
                  .withAdListener(
                      new AdListener() {
                        @Override
                        // The native ad load failed. Check the adError message for failure
                        // reasons.
                        public void onAdFailedToLoad(@NonNull LoadAdError adError) {}
                      })
                  // Use the NativeAdOptions.Builder class to specify individual options
                  // settings.
                  .withNativeAdOptions(new NativeAdOptions.Builder().build())
                  .build();
        })
    .start();
NativeAdSnippets.java

Kotlin

// It is recommended to call AdLoader.Builder on a background thread.
CoroutineScope(Dispatchers.IO).launch {
  val adLoader =
    AdLoader.Builder(context, "AD_UNIT_ID")
      .forNativeAd { nativeAd ->
        // The native ad loaded successfully. You can show the ad.
      }
      .withAdListener(
        object : AdListener() {
          override fun onAdFailedToLoad(adError: LoadAdError) {
            // The native ad load failed. Check the adError message for failure reasons.
          }
        }
      )
      // Use the NativeAdOptions.Builder class to specify individual options settings.
      .withNativeAdOptions(NativeAdOptions.Builder().build())
      .build()
}
NativeAdSnippets.kt

Sostituisci AD_UNIT_ID con l'ID del dispositivo di test.

Avviso:è fortemente sconsigliato tentare di caricare un nuovo annuncio dal metodo onAdFailedToLoad() è fortemente sconsigliato. Se devi caricare un annuncio da onAdFailedToLoad(), limita i tentativi di ricarica degli annunci per evitare richieste di annunci non riuscite continue in situazioni come la connettività di rete limitata.

Il forNativeAd() metodo è responsabile della preparazione del AdLoader per il formato NativeAd. Quando un annuncio viene caricato correttamente, viene chiamato il metodo onNativeAdLoaded() dell'oggetto listener.

Configurare un AdListener con AdLoader (facoltativo)

Quando crei AdLoader, la withAdListener funzione imposta un AdListener per il caricatore. Il metodo accetta un AdListener come unico parametro, che riceve i callback da AdLoader quando si verificano eventi del ciclo di vita dell'annuncio:

Java

adLoaderBuilder.withAdListener(
    // Override AdListener callbacks here.
    new AdListener() {});
NativeAdSnippets.java

Kotlin

adLoaderBuilder.withAdListener(
  // Override AdListener callbacks here.
  object : AdListener() {}
)
NativeAdSnippets.kt

Richiedere annunci

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

Dopo aver creato un AdLoader, è il momento di utilizzarlo per richiedere gli annunci. Sono disponibili due metodi: loadAd() e loadAds().

Punto chiave: il metodo loadAds() funziona solo con gli annunci Google. Per gli annunci con mediazione, utilizza invece loadAd().

loadAd()

Questo metodo invia una richiesta per un singolo annuncio.

Java

adLoader.loadAd(new AdRequest.Builder().build());
NativeAdSnippets.java

Kotlin

adLoader.loadAd(AdRequest.Builder().build())
NativeAdSnippets.kt

loadAds()

Questo metodo invia una richiesta per più annunci (fino a cinque):

Java

// Load three native ads.
adLoader.loadAds(new AdRequest.Builder().build(), 3);
NativeAdSnippets.java

Kotlin

// Load three native ads.
adLoader.loadAds(AdRequest.Builder().build(), 3)
NativeAdSnippets.kt

Entrambi i metodi accettano un AdRequest oggetto come primo parametro. Si tratta della stessa AdRequest classe utilizzata da banner e interstitial, e puoi utilizzare i metodi della AdRequest classe per aggiungere informazioni sul targeting, proprio come faresti con altri formati di annunci.

Caricare più annunci (facoltativo)

Il metodo loadAds() accetta un parametro aggiuntivo: il numero di annunci che l'SDK deve tentare di caricare per la richiesta. Questo numero è limitato a cinque e non è garantito che l'SDK restituisca il numero esatto di annunci richiesti.

Tutti gli annunci Google restituiti saranno diversi l'uno dall'altro, anche se non è garantito che gli annunci provenienti da inventario prenotato o da acquirenti di terze parti siano univoci.

Non utilizzare il metodo loadAds() se utilizzi la mediazione, poiché le richieste di più annunci nativi non funzionano per gli ID unità pubblicitarie configurati per la mediazione.

Callback

Dopo una chiamata a loadAd(), viene eseguito un singolo callback ai metodi listener definiti in precedenza per fornire l'oggetto annuncio nativo o segnalare un errore.

Dopo una chiamata a loadAds(), vengono eseguiti più callback di questo tipo (almeno uno e non più del numero di annunci richiesti). Le app che richiedono più annunci devono chiamare AdLoader.isLoading() nelle implementazioni dei callback per determinare se il processo di caricamento è terminato.

Ecco un esempio che mostra come controllare isLoading() nel callback onNativeAdLoaded():

Java

adLoaderBuilder
    .forNativeAd(
        nativeAd -> {
          // This callback is invoked when a native ad is successfully loaded.
        })
    .build();
NativeAdSnippets.java

Kotlin

adLoaderBuilder
  .forNativeAd { nativeAd ->
    // This callback is invoked when a native ad is successfully loaded.
  }
  .build()
NativeAdSnippets.kt

Svincolare risorse

Assicurati di utilizzare il metodo destroy() sugli annunci nativi caricati. In questo modo vengono rilasciate le risorse utilizzate e si prevengono perdite di memoria.

Punto chiave: destroy() deve essere chiamato su tutti gli annunci, anche se non sono stati utilizzati o a cui non è stato fatto riferimento.

Verifica che tutti i riferimenti NativeAd vengano eliminati nel metodo onDestroy() dell'attività.

Nel callback onNativeAdLoaded, assicurati di eliminare tutti gli annunci nativi esistenti a cui verrà annullato il riferimento.

Un altro controllo fondamentale è verificare se l'attività è stata eliminata e, in caso affermativo, chiamare destroy() sull'annuncio restituito e tornare immediatamente:

Java

nativeAd.destroy();
NativeAdSnippets.java

Kotlin

nativeAd.destroy()
NativeAdSnippets.kt

Best practice

Segui queste regole quando carichi gli annunci.

• Le app che utilizzano annunci nativi in un elenco devono prememorizzare nella cache l'elenco degli annunci.

• Quando prememorizzi gli annunci nella cache, svuota la cache e ricarica dopo un'ora.

• Non chiamare loadAd() o loadAds() su un AdLoader finché non viene completato il caricamento della prima richiesta.

• Limita la memorizzazione nella cache degli annunci nativi solo a ciò che è necessario. Ad esempio, quando si esegue il precaching, memorizza nella cache solo gli annunci immediatamente visibili sullo schermo. Gli annunci nativi hanno un footprint della memoria elevato e la memorizzazione nella cache degli annunci nativi senza eliminarli comporta un utilizzo eccessivo della memoria.

• Elimina gli annunci nativi quando non sono più in uso.

Accelerazione hardware per gli annunci video

Affinché gli annunci video vengano visualizzati correttamente nelle visualizzazioni degli annunci nativi, è necessario attivare l'accelerazione hardware.

L'accelerazione hardware è attivata 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 le classi Activity 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, utilizza l'attributo android:hardwareAcceleratedper gli <application> e <activity> elementi in 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>
HardwareAccelerationSnippet.xml

Per ulteriori informazioni sulle opzioni per il controllo dell'accelerazione hardware, consulta la guida all'accelerazione hardware. Tieni presente che le singole visualizzazioni degli annunci non possono essere attivate per l'accelerazione hardware se l'Activity è disattivata, quindi l'accelerazione hardware deve essere attivata per l'Activity stessa.

Visualizzare l'annuncio

Dopo aver caricato un annuncio, non ti resta che mostrarlo agli utenti. Consulta la nostra guida avanzata sugli annunci nativi per scoprire come fare.