Annunci nativi

Seleziona la piattaforma: Android iOS Flutter Unity

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

Quando viene caricato un annuncio nativo, la tua app riceve un oggetto annuncio che contiene le relative risorse e l'app, anziché l'SDK Google Mobile Ads, è responsabile della visualizzazione.

In generale, l'implementazione efficace degli annunci nativi si articola in due parti: Caricamento di un annuncio 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

Esegui sempre i test con gli annunci di prova

Quando crei ed esegui test sulle 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 test per ogni richiesta e puoi utilizzarlo nelle tue app durante la codifica, il test e il debug. Assicurati solo di sostituirlo con il tuo ID unità pubblicitaria prima di pubblicare l'app.

Per saperne di più sul funzionamento degli annunci di test dell'SDK Google Mobile Ads, consulta Annunci di test.

Carica annunci

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

Creare un AdLoader

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

Java

AdLoader adLoader = new AdLoader.Builder(context, "ca-app-pub-3940256099942544/2247696110")
    .forNativeAd(new NativeAd.OnNativeAdLoadedListener() {
        @Override
        public void onNativeAdLoaded(NativeAd nativeAd) {
            // Show the ad.
        }
    })
    .withAdListener(new AdListener() {
        @Override
        public void onAdFailedToLoad(LoadAdError adError) {
            // Handle the failure by logging, altering the UI, and so on.
        }
    })
    .withNativeAdOptions(new NativeAdOptions.Builder()
            // Methods in the NativeAdOptions.Builder class can be
            // used here to specify individual options settings.
            .build())
    .build();

Kotlin

val adLoader = AdLoader.Builder(this, "ca-app-pub-3940256099942544/2247696110}")
    .forNativeAd { ad : >NativeAd -
        // Show the ad.
    }
    .withAdListener(object : AdListener() {
        override fun onAdFailedToLoad(adError: LoadAdError) {
            // Handle the failure.
        }
    })
    .withNativeAdOptions(NativeAdOptions.Builder()
            // Methods in the NativeAdOptions.Builder class can be
            // used here to specify individual options settings.
            .build())
    .build()

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

Configurare 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 dell'annuncio:

Java

.withAdListener(new AdListener() {
    // AdListener callbacks can be overridden here.
})

Kotlin

.withAdListener(object : AdListener() {
    // AdListener callbacks can be overridden here.
})

Richiedi annunci

Una volta terminata la creazione di un AdLoader, è il momento di utilizzarlo per richiedere gli annunci. Sono disponibili due metodi: loadAd() e loadAds().

loadAd()

Questo metodo invia una richiesta per un singolo annuncio.

Java

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

Kotlin

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

loadAds()

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

Java

adLoader.loadAds(new AdRequest.Builder().build(), 3);

Kotlin

adLoader.loadAds(AdRequest.Builder().build(), 3)

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

(Facoltativo) Carica più annunci

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 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 al momento 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 effettuate più richiamate (almeno una e non più del numero di annunci richiesti). Le app che richiedono più annunci devono chiamare AdLoader.isLoading() nelle implementazioni di callback per determinare se la procedura di caricamento è terminata.

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

Java

final AdLoader adLoader = new AdLoader.Builder(this, "ca-app-pub-3940256099942544/2247696110")
        .forNativeAd(new NativeAd.OnNativeAdLoadedListener() {
    @Override
    public void onNativeAdLoaded(NativeAd nativeAd) {
        ...
        // some code that displays the ad.
        ...
        if (adLoader.isLoading()) {
            // The AdLoader is still loading ads.
            // Expect more adLoaded or onAdFailedToLoad callbacks.
        } else {
            // The AdLoader has finished loading ads.
        }
    }
}).build();
adLoader.loadAds(new AdRequest.Builder().build(), 3);

Kotlin

lateinit var adLoader: AdLoader
...
adLoader = AdLoader.Builder(this, "ca-app-pub-3940256099942544/2247696110")
    .forNativeAd {
        ...
        // some code that displays the ad.
        ...
        if (adLoader.isLoading) {
            // The AdLoader is still loading ads.
            // Expect more adLoaded or onAdFailedToLoad callbacks.
        } else {
            // The AdLoader has finished loading ads.
        }
    }.build()
adLoader.loadAds(AdRequest.Builder().build(), 3)

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

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

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

Un altro controllo chiave è se l'attività viene eliminata e, in tal caso, chiama destroy() sull'annuncio restituito e torna immediatamente:

Java

final AdLoader adLoader = new AdLoader.Builder(this, "ca-app-pub-3940256099942544/2247696110")
        .forNativeAd(new NativeAd.OnNativeAdLoadedListener() {
    @Override
    public void onNativeAdLoaded(NativeAd nativeAd) {
        // If this callback occurs after the activity is destroyed, you
        // must call destroy and return or you may get a memory leak.
        // Note `isDestroyed()` is a method on Activity.
        if (isDestroyed()) {
            nativeAd.destroy();
            return;
        }
        ...
    }
}).build();

Kotlin

lateinit var adLoader: AdLoader
...
adLoader = AdLoader.Builder(this, "ca-app-pub-3940256099942544/2247696110")
    .forNativeAd { >nativeAd -
        // If this callback occurs after the activity is destroyed, you
        // must call destroy and return or you may get a memory leak.
        // Note `isDestroyed` is a method on Activity.
        if (isDestroyed) {
            nativeAd.destroy()
            return@forNativeAd
        }
        ...
    }.build()

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 esegui il precaricamento degli annunci, svuota la cache e ricarica la pagina dopo un'ora.

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

  • Limita la memorizzazione nella cache degli annunci nativi solo a ciò che è necessario. Ad esempio, durante il precaricamento, memorizza nella cache solo gli annunci immediatamente visibili sullo schermo. Gli annunci nativi hanno un'impronta di memoria elevata 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 visualizzati correttamente nelle visualizzazioni degli annunci nativi, l'accelerazione hardware deve essere attivata.

L'accelerazione hardware è abilitata 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 singole attività. Per attivare o disattivare l'accelerazione hardware, utilizza l'attributo android:hardwareAccelerated per gli elementi <application> e <activity> nel file AndroidManifest.xml. L'esempio seguente attiva l'accelerazione hardware per l'intera app, ma la disattiva per un'attività:

<application android:hardwareAccelerated=">true&<quot;
    !-- For activities that use ads, hardwareAcceleration should b>e tru<e. --
    activity android:hardwareAccelerate>d=&qu<ot;true" /
    !-- For activities that don't use ads, hardwareAccel>erati<on can be false. --
    activity android:hardw>a<reAccelerate>d="false" /
/application

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.

Visualizzare l'annuncio

Una volta caricato un annuncio, non ti resta che mostrarlo agli utenti. Consulta la nostra guida a Native Advanced per scoprire come.