Annonces natives

Sélectionnez une plate-forme : Android iOS Flutter Unity

Les annonces natives sont des composants d'annonce présentés aux utilisateurs à l'aide de composants d'interface utilisateur natifs pour la plate-forme. Elles sont affichées à l'aide des mêmes types de vues que ceux avec lesquels vous créez déjà vos mises en page, et peuvent être mises en forme pour correspondre à la conception visuelle de votre application.

Lorsqu'une annonce native est chargée, votre application reçoit un objet d'annonce contenant ses composants. L'application, et non le SDK Google Mobile Ads, est alors responsable de leur affichage.

De manière générale, l'implémentation réussie d'annonces natives se fait en deux étapes : charger une annonce à l'aide du SDK, puis afficher le contenu de l'annonce dans votre application.

Cette page explique comment utiliser le SDK pour charger des annonces natives. Conseil : Pour en savoir plus sur les annonces natives, consultez notre guide des annonces natives.

Vous pouvez également consulter des témoignages de réussite de clients : étude de cas 1, étude de cas 2.

Prérequis

Toujours effectuer des tests avec des annonces tests

Lorsque vous créez et testez vos applications, assurez-vous d'utiliser des annonces tests plutôt que des annonces de production.

Le moyen le plus simple de charger des annonces tests consiste à utiliser notre ID de bloc d'annonces test dédié pour les annonces natives sur Android :

ca-app-pub-3940256099942544/2247696110

Il a été spécialement configuré pour renvoyer des annonces tests pour chaque demande. Vous pouvez l'utiliser dans vos propres applications lors du codage, des tests et du débogage. Veillez simplement à le remplacer par votre propre ID de bloc d'annonces avant de publier votre application.

Pour en savoir plus sur le fonctionnement des annonces tests du SDK Google Mobile Ads, consultez Annonces tests.

Charger des annonces

Les annonces natives sont chargées avec la classe AdLoader, qui possède sa propre classe Builder pour la personnaliser lors de la création. En ajoutant des écouteurs à AdLoader lors de sa création, une application spécifie les types d'annonces natives qu'elle est prête à recevoir. Le AdLoader demande ensuite uniquement ces types.

Créer un AdLoader

Le code suivant montre comment créer un AdLoader capable de charger des annonces natives :

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

La méthode forNativeAd() est chargée de préparer le AdLoader pour le format NativeAd. Lorsqu'une annonce est chargée, la méthode onNativeAdLoaded() de l'objet d'écouteur est appelée.

Configurer un AdListener avec AdLoader (facultatif)

Lors de la création de AdLoader, la fonction withAdListener définit un AdListener pour le chargeur. La méthode utilise un AdListener comme seul paramètre, qui reçoit des rappels du AdLoader lorsque des événements du cycle de vie des annonces ont lieu :

Java

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

Kotlin

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

Demander des annonces

Une fois que vous avez terminé de créer un AdLoader, il est temps de l'utiliser pour demander des annonces. Pour cela, vous avez le choix entre deux méthodes : loadAd() et loadAds().

loadAd()

Cette méthode envoie une demande pour une seule annonce.

Java

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

Kotlin

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

loadAds()

Cette méthode envoie une demande pour plusieurs annonces (jusqu'à cinq) :

Java

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

Kotlin

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

Les deux méthodes acceptent un objet AdRequest comme premier paramètre. Il s'agit de la même classe AdRequest que celle utilisée par les bannières et les interstitiels. Vous pouvez utiliser les méthodes de la classe AdRequest pour ajouter des informations de ciblage, comme vous le feriez avec d'autres formats d'annonces.

Charger plusieurs annonces (facultatif)

La méthode loadAds() utilise un paramètre supplémentaire : le nombre d'annonces que le SDK doit tenter de charger pour la demande. Ce nombre est limité à cinq. Il n'est pas garanti que le SDK renvoie le nombre exact d'annonces demandées.

Les annonces Google renvoyées seront toutes différentes les unes des autres, mais il n'est pas garanti que les annonces provenant d'un inventaire réservé ou d'acheteurs tiers soient uniques.

N'utilisez pas la méthode loadAds() si vous utilisez la médiation, car les demandes pour plusieurs annonces natives ne fonctionnent pas actuellement pour les ID de blocs d'annonces qui ont été configurés pour la médiation.

Rappels

Après un appel à loadAd(), un seul rappel est effectué aux méthodes d'écouteur précédemment définies pour fournir l'objet d'annonce native ou signaler une erreur.

Après un appel à loadAds(), plusieurs de ces rappels sont effectués (au moins un et pas plus que le nombre d'annonces demandées). Les applications qui demandent plusieurs annonces doivent appeler AdLoader.isLoading() dans leurs implémentations de rappel pour déterminer si le processus de chargement est terminé.

Voici un exemple montrant comment vérifier isLoading() dans le rappel 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)

Libérer des ressources

Veillez à utiliser la méthode destroy() sur les annonces natives chargées. Cela libère les ressources utilisées et évite les fuites de mémoire.

Assurez-vous que toutes les références NativeAd sont détruites dans la méthode onDestroy() de votre activité.

Dans votre rappel onNativeAdLoaded, assurez-vous de détruire toutes les annonces natives existantes qui seront déréférencées.

Une autre vérification clé consiste à déterminer si l'activité est détruite. Si c'est le cas, appelez destroy() sur l'annonce renvoyée et revenez immédiatement :

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

Bonnes pratiques

Suivez ces règles lorsque vous chargez des annonces.

  • Les applications qui utilisent des annonces natives dans une liste doivent précharger la liste des annonces.

  • Lorsque vous prémettez des annonces en cache, videz votre cache et rechargez la page au bout d'une heure.

  • N'appelez pas loadAd() ni loadAds() sur un AdLoader tant que la première requête n'a pas fini de se charger.

  • Limitez la mise en cache des annonces natives au strict nécessaire. Par exemple, lors de la mise en cache anticipée, ne mettez en cache que les annonces immédiatement visibles à l'écran. Les annonces natives ont une empreinte mémoire importante. La mise en cache des annonces natives sans les détruire entraîne une utilisation excessive de la mémoire.

  • Détruisez les annonces natives lorsqu'elles ne sont plus utilisées.

Accélération matérielle pour les annonces vidéo

Pour que les annonces vidéo s'affichent correctement dans vos vues d'annonces natives, l'accélération matérielle doit être activée.

L'accélération matérielle est activée par défaut, mais certaines applications peuvent choisir de la désactiver. Si cela s'applique à votre application, nous vous recommandons d'activer l'accélération matérielle pour les classes d'activité qui utilisent des annonces.

Activer l'accélération matérielle

Si l'accélération matérielle est activée de façon globale et que votre application n'adopte pas le comportement attendu, vous pouvez également la contrôler pour chaque activité. Pour activer ou désactiver l'accélération matérielle, utilisez l'attribut android:hardwareAccelerated pour les éléments <application> et <activity> dans votre AndroidManifest.xml. L'exemple suivant active l'accélération matérielle pour l'ensemble de l'application, mais la désactive pour une activité :

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

Pour en savoir plus sur les options permettant de contrôler l'accélération matérielle, consultez le guide sur l'accélération matérielle. Notez que l'accélération matérielle ne peut pas être activée pour les vues d'annonces individuelles si l'activité est désactivée. L'accélération matérielle doit donc être activée pour l'activité elle-même.

Diffuser votre annonce

Une fois l'annonce chargée, il ne vous reste plus qu'à la diffuser auprès de vos utilisateurs. Pour en savoir plus, consultez notre guide sur les annonces natives avancées.