Annunci nativi

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

Quando si carica un annuncio nativo, l'app riceve un oggetto annuncio che contiene i suoi asset. e l'app, invece dell'SDK Google Mobile Ads, viene responsabile della loro visualizzazione.

In generale, la corretta implementazione degli annunci nativi si compone di due parti: Caricare un annuncio utilizzando l'SDK e poi mostrare il contenuto dell'annuncio nell'app.

Questa pagina mostra come utilizzare l'SDK per caricare annunci nativi. Suggerimento: scopri di più sugli annunci nativi nella nostra sezione Annunci nativi Guida pratica.

Puoi anche leggere alcuni casi di successo dei clienti: case study 1, case study 2.

Prerequisiti

• Completa la Guida introduttiva.

Effettua sempre test con annunci di prova

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

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 appositamente configurato per restituire annunci di prova per ogni richiesta usalo 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 su come funzionano gli annunci di prova dell'SDK Google Mobile Ads, consulta Annunci di prova.

Carica annunci

Gli annunci nativi vengono caricati AdLoader, che ha il suo Builder per personalizzarlo durante la creazione. Aggiungendo listener a AdLoader durante la sua creazione, un'app specifica per quali tipi di annunci nativi ricevere. AdLoader richiede quindi solo questi tipi.

Crea un AdLoader

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

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

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

Avviso: il tentativo di caricare un nuovo annuncio dal metodo onAdFailedToLoad() è Sconsigliamo vivamente di farlo. Se devi caricare un annuncio da onAdFailedToLoad(), limita l'annuncio nuovi tentativi di caricamento per evitare richieste di annunci continue non riuscite in situazioni connettività di rete limitata.

La forNativeAd() responsabile della preparazione di AdLoader per il formato NativeAd. Dopo che un annuncio è stato caricato correttamente, l'elemento onNativeAdLoaded() dell'oggetto listener .

Impostare un AdListener con AdLoader (facoltativo)

Quando crei l'AdLoader, withAdListener imposta una funzione AdListener per caricatore di emergenza. Il metodo utilizza AdListener come parametro unico, che riceve 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

Suggerimento: Puoi utilizzare le chiamate al carico degli annunci per creare una cache di annunci precaricati intendono pubblicarli, in modo che gli annunci possano essere pubblicati con latenza zero quando necessario. Poiché gli annunci scadono dopo un'ora, devi svuotare la cache e ricaricare con nuovi annunci ogni ora.

Dopo aver completato la creazione di un AdLoader, è il momento di utilizzarlo per richiedere annunci. Sono disponibili due metodi per eseguire questa operazione: loadAd() e loadAds().

Punto chiave :il metodo loadAds() attualmente funziona solo con gli annunci Google. Per annunci mediati, usa invece loadAd().

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 prendono un AdRequest come primo parametro. È lo stesso Classe AdRequest utilizzata da banner e interstitial, e puoi usare i metodi della classe AdRequest aggiungere informazioni sul targeting, proprio come che faresti con gli altri formati di annunci.

Carica più annunci (facoltativo)

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

Gli annunci Google restituiti sono tutti diversi l'uno dall'altro, sebbene gli annunci di inventario riservato o acquirenti di terze parti non sono garantiti come univoci.

Non usare il metodo loadAds() se utilizzi la mediazione, come richieste per attualmente più annunci nativi non funzionano per gli ID unità pubblicitaria configurate per la mediazione.

Callback

Dopo una chiamata al numero loadAd(), viene eseguito un singolo callback all'elemento definito in precedenza metodi di ascolto per pubblicare l'oggetto annuncio nativo o segnalare un errore.

Dopo una chiamata al numero loadAds(), vengono effettuati più richiami di questo tipo (almeno uno, e non più del numero di annunci richiesti). App che richiedono più annunci deve chiamare AdLoader.isLoading() nelle implementazioni di callback per determinare se il processo di caricamento è terminato.

Ecco un esempio che mostra come controllare isLoading() nel Chiamata di 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() per gli annunci nativi caricati. Questa release utilizzate le risorse ed evita fughe di memoria.

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

Assicurati che tutti i riferimenti NativeAd vengano eliminati nel file Metodo onDestroy().

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

Un altro controllo della chiave è se l'attività viene eliminata e, in questo caso, chiama destroy() sul l'annuncio restituito e lo restituisce 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 durante il caricamento degli annunci.

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

• Quando esegui la pre-memorizzazione degli annunci nella cache, svuota la cache e ricarica la pagina dopo un'ora.

• Non chiamare loadAd() o loadAds() su AdLoader fino al primo viene completato il caricamento della richiesta.

Accelerazione hardware per annunci video

Affinché gli annunci video vengano mostrati correttamente nelle visualizzazioni degli annunci nativi, hardware di accelerazione devono essere abilitati.

L'accelerazione hardware è attiva per impostazione predefinita, ma alcune app potrebbero scegliere di farlo disabilitarlo. In questo caso, ti consigliamo di attivare l'hardware accelerazione per le classi attività che utilizzano gli annunci.

Attivazione dell'accelerazione hardware

Se l'app non funziona correttamente con l'accelerazione hardware attivata a livello globale, puoi controllarlo anche per le singole attività. Per attivare o disattiva l'accelerazione hardware, usa l'attributo android:hardwareAccelerated per <application> e <activity> in AndroidManifest.xml. L'esempio seguente abilita l'hardware l'accelerazione 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>

Visualizza l'accelerazione HW per Ulteriori informazioni sulle opzioni per il controllo dell'accelerazione hardware. Nota che le visualizzazioni dei singoli annunci non possano essere abilitate per l'accelerazione hardware se il parametro L'attività è disattivata, pertanto l'attività stessa deve avere un'accelerazione hardware in un bucket in cui è abilitato il controllo delle versioni.

Mostra il tuo annuncio

Una volta caricato un annuncio, è sufficiente mostrarlo agli utenti. Vai al nostro corso native Advanced per scoprire come.