Annonces natives

Les annonces natives sont des composants d'annonces présentés aux utilisateurs via des composants d'interface utilisateur natifs pour la plate-forme. Ils sont affichés à l'aide des mêmes types de vues que vous utilisez déjà pour créer vos mises en page et peuvent être mis en forme pour correspondre à la conception visuelle de votre application.

Lorsqu'une annonce native se charge, votre application reçoit un objet d'annonce contenant ses composants, et c'est elle, et non le SDK Google Mobile Ads, qui est chargée de les afficher.

De manière générale, l'implémentation d'annonces natives se compose de 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.

Prérequis

• Suivez le guide de démarrage.

Effectuez toujours 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 tests dédié pour les annonces natives sur Android:

/21775744923/example/native

Il a été spécialement configuré pour renvoyer des annonces de test pour chaque requête. 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. AdLoader ne demande alors que ces types.

Créer un AdLoader

Important :Effectuez tous les appels au SDK Mobile Ads sur le thread principal.

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

Java

AdLoader adLoader = new AdLoader.Builder(context, "/21775744923/example/native")
    .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, "/21775744923/example/native}")
    .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()

Avertissement :Nous vous déconseillons vivement d'essayer de charger une nouvelle annonce à partir de la méthode onAdFailedToLoad(). Si vous devez charger une annonce à partir de onAdFailedToLoad(), limitez les tentatives de chargement d'annonces pour éviter les échecs continus des demandes d'annonces dans des situations telles que la connectivité réseau limitée.

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

Configurer un AdListener avec l'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 de la AdLoader lorsque des événements de cycle de vie des annonces se produisent:

Java

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

Kotlin

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

Demander des annonces

Conseil:Vous pouvez utiliser des appels de chargement d'annonces pour créer un cache d'annonces préchargées avant de les diffuser, afin qu'elles puissent être diffusées sans latence si nécessaire. Étant donné que les annonces expirent au bout d'une heure, vous devez vider ce cache et recharger de nouvelles annonces toutes les heures.

Une fois que vous avez créé un AdLoader, vous pouvez l'utiliser pour demander des annonces. Utilisez la méthode loadAd(), qui prend un objet AdManagerAdRequest comme premier paramètre. Il s'agit de la même classe AdManagerAdRequest utilisée par les bannières et les interstitiels. Vous pouvez utiliser les méthodes de la classe AdManagerAdRequest pour ajouter des informations de ciblage, comme vous le feriez avec d'autres formats d'annonces.

loadAd()

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

Java

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

Kotlin

adLoader.loadAd(AdManagerAdRequest.Builder().build())

Remarque :Ad Manager n'est pas compatible avec la méthode loadAds() et ne renvoie qu'une seule annonce si elle est utilisée.

Rappels

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

Libérer les 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.

Point clé :destroy() doit être appelé pour toutes les annonces, même si elles n'ont pas été utilisées ni référencées.

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

Dans votre rappel onNativeAdLoaded, veillez à détruire toutes les annonces natives existantes qui seront désindexées.

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

Java

final AdLoader adLoader = new AdLoader.Builder(this, "/21775744923/example/native")
        .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, "/21775744923/example/native")
    .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écachez des annonces, videz votre cache et rechargez-le au bout d'une heure.

• N'appelez pas loadAd() sur un AdLoader tant que le chargement de la première requête n'est pas terminé.

• Limitez le stockage en cache des annonces natives à ce qui est nécessaire. Par exemple, lors du préchargement, 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.

• Supprimez 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 Activity 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> de 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 de contrôle de l'accélération matérielle, consultez le guide de 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 que vous avez chargé une annonce, il ne vous reste plus qu'à l'afficher auprès de vos utilisateurs. Pour savoir comment procéder, consultez notre guide avancé sur les composants natifs.