Bannières

Les bannières sont des annonces rectangulaires qui occupent une partie de la mise en page d'une application. Elles restent à l'écran lorsque les utilisateurs interagissent avec l'application et sont ancrées en haut ou en bas de l'écran, ou intégrées au contenu lorsque l'utilisateur fait défiler la page. Les bannières peuvent s'actualiser automatiquement au bout d'un certain temps. Pour en savoir plus, consultez la page Présentation des bannières.

Ce guide vous explique comment commencer à utiliser les bannières adaptatives ancrées, qui maximisent les performances en optimisant la taille des annonces pour chaque appareil à l'aide d'une largeur d'annonce que vous spécifiez.

Les bannières adaptatives ancrées sont des annonces au format fixe plutôt que des annonces de taille fixe standards. Le format est semblable au format standard du secteur (320 x 50). Une fois que vous avez spécifié la largeur totale disponible, une annonce avec une hauteur optimale pour cette largeur s'affiche. La hauteur optimale ne change pas entre les requêtes provenant du même appareil, et les vues environnantes n'ont pas besoin de bouger lorsque l'annonce est actualisée.

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. À défaut, votre compte risque d'être suspendu.

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

ca-app-pub-3940256099942544/9214589741

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 Mobile Ads, consultez Annonces tests.

Ajouter AdView à la mise en page

Pour créer une bannière, vous devez déterminer la taille de l'annonce. Procédez comme suit :

1. Créez un format d'annonce adaptative ancrée en plein écran:

   Java

   // Get the ad size with screen width.
   public AdSize getAdSize() {
     DisplayMetrics displayMetrics = getResources().getDisplayMetrics();
     int adWidthPixels = displayMetrics.widthPixels;
   
     if (VERSION.SDK_INT >= VERSION_CODES.R) {
       WindowMetrics windowMetrics = this.getWindowManager().getCurrentWindowMetrics();
       adWidthPixels = windowMetrics.getBounds().width();
     }
   
     float density = displayMetrics.density;
     int adWidth = (int) (adWidthPixels / density);
     return AdSize.getCurrentOrientationAnchoredAdaptiveBannerAdSize(this, adWidth);
   }
   MyActivity.java
   

   Kotlin

   // Get the ad size with screen width.
   private val adSize: AdSize
     get() {
       val displayMetrics = resources.displayMetrics
       val adWidthPixels =
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
           val windowMetrics: WindowMetrics = this.windowManager.currentWindowMetrics
           windowMetrics.bounds.width()
         } else {
           displayMetrics.widthPixels
         }
       val density = displayMetrics.density
       val adWidth = (adWidthPixels / density).toInt()
       return AdSize.getCurrentOrientationAnchoredAdaptiveBannerAdSize(this, adWidth)
     }
   MainActivity.kt
   

2. Créez un AdView à l'aide de la taille de l'annonce et ajoutez-le à la mise en page de votre application:

   Java

   // Create a new ad view.
   adView = new AdView(this);
   adView.setAdUnitId(AD_UNIT_ID);
   adView.setAdSize(getAdSize());
   
   // Replace ad container with new ad view.
   adContainerView.removeAllViews();
   adContainerView.addView(adView);
   MyActivity.java
   

   Kotlin

   // Create a new ad view.
   val adView = AdView(this)
   adView.adUnitId = AD_UNIT_ID
   adView.setAdSize(adSize)
   this.adView = adView
   
   // Replace ad container with new ad view.
   binding.adViewContainer.removeAllViews()
   binding.adViewContainer.addView(adView)
   MainActivity.kt
   

Charger une annonce

Une fois le AdView en place, l'étape suivante consiste à charger une annonce. Pour ce faire, exécutez la méthode loadAd() de la classe AdView. Il utilise un paramètre AdRequest, qui contient des informations d'exécution, telles que des informations de ciblage, sur une seule demande d'annonce.

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

Voici un exemple illustrant comment charger une annonce:

Java

// Start loading the ad in the background.
AdRequest adRequest = new AdRequest.Builder().build();
adView.loadAd(adRequest);
MyActivity.java

Kotlin

// Start loading the ad in the background.
val adRequest = AdRequest.Builder().build()
adView.loadAd(adRequest)
MainActivity.kt

Si l'opération réussit, votre application est prête à diffuser des bannières publicitaires.

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.

Actualiser une annonce

Si vous avez configuré votre bloc d'annonces pour qu'il s'actualise, vous n'avez pas besoin de demander une autre annonce lorsque celle-ci ne parvient pas à se charger. Le SDK Google Mobile Ads respecte la fréquence d'actualisation que vous avez spécifiée dans l'interface utilisateur d'AdMob. Si vous n'avez pas activé l'actualisation, envoyez une nouvelle requête. Pour en savoir plus sur l'actualisation des blocs d'annonces, par exemple pour définir une fréquence d'actualisation, consultez Utiliser l'actualisation automatique pour les bannières.

Remarque :Lorsque vous définissez une fréquence d'actualisation dans l'interface utilisateur d'AdMob, l'actualisation automatique ne se produit que si la bannière est visible à l'écran.

Événements d'annonce

Vous pouvez écouter un certain nombre d'événements au cours du cycle de vie de l'annonce, y compris le chargement, l'impression et le clic sur l'annonce, ainsi que les événements d'ouverture et de fermeture de l'annonce. Nous vous recommandons de définir le rappel avant de charger la bannière.

Java

adView.setAdListener(new AdListener() {
    @Override
    public void onAdClicked() {
      // Code to be executed when the user clicks on an ad.
    }

    @Override
    public void onAdClosed() {
      // Code to be executed when the user is about to return
      // to the app after tapping on an ad.
    }

    @Override
    public void onAdFailedToLoad(LoadAdError adError) {
      // Code to be executed when an ad request fails.
    }

    @Override
    public void onAdImpression() {
      // Code to be executed when an impression is recorded
      // for an ad.
    }

    @Override
    public void onAdLoaded() {
      // Code to be executed when an ad finishes loading.
    }

    @Override
    public void onAdOpened() {
      // Code to be executed when an ad opens an overlay that
      // covers the screen.
    }
});

Kotlin

adView.adListener = object: AdListener() {
    override fun onAdClicked() {
      // Code to be executed when the user clicks on an ad.
    }

    override fun onAdClosed() {
      // Code to be executed when the user is about to return
      // to the app after tapping on an ad.
    }

    override fun onAdFailedToLoad(adError : LoadAdError) {
      // Code to be executed when an ad request fails.
    }

    override fun onAdImpression() {
      // Code to be executed when an impression is recorded
      // for an ad.
    }

    override fun onAdLoaded() {
      // Code to be executed when an ad finishes loading.
    }

    override fun onAdOpened() {
      // Code to be executed when an ad opens an overlay that
      // covers the screen.
    }
}

Chacune des méthodes remplaçables dans AdListener correspond à un événement du cycle de vie d'une annonce.

Méthodes remplaçables
onAdClicked()	La méthode onAdClicked() est appelée lorsqu'un clic est enregistré pour une annonce.
onAdClosed()	La méthode onAdClosed() est appelée lorsqu'un utilisateur revient dans l'application après avoir consulté l'URL de destination d'une annonce. Votre application peut l'utiliser pour reprendre les activités suspendues ou effectuer toute autre tâche nécessaire pour se préparer à l'interaction. Consultez l'exemple AdListener AdMob pour découvrir une implémentation des méthodes d'écouteur d'annonces dans l'application de démonstration de l'API Android.
onAdFailedToLoad()	La méthode onAdFailedToLoad() est la seule à inclure un paramètre. Le paramètre d'erreur de type LoadAdError décrit l'erreur qui s'est produite. Pour en savoir plus, consultez la documentation sur le débogage des erreurs de chargement d'annonces.
onAdImpression()	La méthode onAdImpression() est appelée lorsqu'une impression est enregistrée pour une annonce.
onAdLoaded()	La méthode onAdLoaded() est exécutée une fois qu'une annonce a fini de se charger. Si vous souhaitez retarder l'ajout de AdView à votre activité ou fragment jusqu'à ce que vous soyez sûr qu'une annonce sera chargée, par exemple, vous pouvez le faire ici.
onAdOpened()	La méthode onAdOpened() est appelée lorsqu'une annonce ouvre une superposition qui recouvre l'écran.

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

Pour que les annonces vidéo s'affichent correctement dans les vues de vos bannières publicitaires, 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, vous pouvez utiliser 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 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.

Ressources supplémentaires

Exemples sur GitHub

• Exemple d'annonces de bannières adaptatives ancrées : Java | Kotlin

• Démo des fonctionnalités avancées : Java | Kotlin

Étapes suivantes

Bannières réductibles

Les bannières réductibles sont des bannières qui sont initialement présentées sous la forme d'une superposition plus grande, avec un bouton permettant de réduire la bannière à une taille plus petite. Envisagez de l'utiliser pour optimiser davantage vos performances. Pour en savoir plus, consultez la section Bannières réductibles.

Bannières adaptatives intégrées

Les bannières adaptatives intégrées sont plus grandes et plus larges que les bannières adaptatives ancrées. Elles sont de hauteur variable et peuvent être aussi grandes que l'écran de l'appareil. Les bannières adaptatives intégrées sont recommandées aux applications qui placent des bannières publicitaires dans du contenu à faire défiler plutôt que les bannières adaptatives ancrées. Pour en savoir plus, consultez Bannières adaptatives intégrées.

Découvrir d'autres sujets

• Confidentialité des données des utilisateurs
• Optimisation de l'initialisation du SDK et du chargement des annonces (bêta)