Caricare un annuncio nativo

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

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

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

In generale, l'implementazione degli annunci nativi si articola in due fasi: caricamento degli annunci utilizzando l'SDK e visualizzazione dei contenuti dell'annuncio nell'app.

Questa pagina mostra come utilizzare l'SDK per caricare annunci nativi. Suggerimento: scopri di più sugli annunci nativi nel nostro playbook sugli 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 (Legacy).

Esegui sempre i test con gli annunci di prova

Durante la creazione e il test delle tue app, assicurati di utilizzare annunci di prova anziché annunci di prodotto.

Il modo più semplice per caricare annunci di prova è utilizzare il nostro ID unità pubblicitaria di test 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 programmazione, il test e il debug. Assicurati di sostituirlo con l'ID unità pubblicitaria prima di pubblicare l'app.

Per informazioni dettagliate sugli annunci di prova Google Mobile Ads SDK (Legacy), consulta Attiva gli annunci di prova.

Carica gli annunci

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

Crea un AdLoader

Il seguente codice mostra come creare un AdLoader che può 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 tuo dispositivo di test.

Avviso: sconsigliamo vivamente di provare a caricare un nuovo annuncio dal metodo onAdFailedToLoad(). Se devi caricare un annuncio da onAdFailedToLoad(), limita i nuovi tentativi di caricamento degli annunci per evitare richieste di annunci non riuscite continue in situazioni come la connettività di rete limitata.

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

Configura un AdListener con AdLoader (facoltativo)

Quando crei AdLoader, la funzione withAdListener 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 degli annunci:

Java

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

Kotlin

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

Richiedi annunci

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

Una volta completata la creazione di un AdLoader, è il momento di utilizzarlo per richiedere annunci. Per farlo, 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 oggetto AdRequest come primo parametro. Si tratta della stessa classe AdRequest utilizzata dai banner e dagli interstitial e puoi utilizzare i metodi della classe AdRequest per aggiungere informazioni di targeting, proprio come faresti con altri formati degli annunci.

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

Gli annunci Google restituiti saranno tutti diversi tra loro, anche se non è garantito che gli annunci provenienti dall'inventario prenotato o da acquirenti di terze parti siano unici.

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

Callback

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

Dopo una chiamata a loadAds(), vengono effettuati 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 loro implementazioni di 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

Rilascia le risorse

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

Punto chiave: destroy() deve essere chiamato su tutti gli annunci, anche se non sono stati utilizzati o referenziati.

Verifica che tutti i riferimenti a NativeAd vengano eliminati nel metodo onDestroy() della tua attività.

Nel callback onNativeAdLoaded, assicurati di eliminare tutti gli annunci nativi esistenti che verranno dereferenziati.

Un altro controllo fondamentale è verificare se l'attività è stata eliminata e, in caso affermativo, chiamare destroy() sull'annuncio restituito e restituirlo 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 di annunci.

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

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

• Limita la memorizzazione nella cache degli annunci nativi solo a ciò che è necessario. Ad esempio, durante la pre-memorizzazione nella cache, 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 distruggerli 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 mostrati correttamente nelle visualizzazioni degli annunci nativi, l'accelerazione hardware deve essere attivata.

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

Attivazione dell'accelerazione hardware

Se la tua app non si comporta correttamente con l'accelerazione hardware attivata a livello globale, puoi controllarla anche per singole attività. Per attivare o disattivare l'accelerazione hardware, utilizza l'attributo android:hardwareAccelerated per gli elementi <application> e <activity> nel tuo 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 visualizzazioni dei singoli annunci non possono essere attivate per l'accelerazione hardware se l'attività è disattivata, pertanto l'attività stessa deve avere l'accelerazione hardware attivata.

Visualizza l'annuncio

Una volta caricato un annuncio, non resta che mostrarlo agli utenti. Per saperne di più, consulta Nativi avanzati o Annunci nativi a schermo intero.