Bannières

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

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 au format fixe plutôt que les annonces standards. des annonces de taille fixe. Le format est semblable à la norme du secteur : 320 x 50. Une fois vous spécifiez toute la largeur disponible, l'annonce affiche pour cette largeur. 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

Toujours tester 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 test dédié Bannières Android:

/21775744923/example/adaptive-banner

Il a été spécialement configuré pour afficher des annonces tests pour chaque demande. et l'utiliser dans vos propres applications lors du codage, des tests et du débogage. Assurez-vous simplement que remplacez-le 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 AdManagerAdView à la mise en page

Pour afficher une bannière, la première étape consiste à placer AdManagerAdView. dans la mise en page de votre application:

Java

// Create a new ad view.
adView = new AdManagerAdView(this);
adView.setAdUnitId(AD_UNIT);
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 = AdManagerAdView(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)
MyActivity.kt

Charger une annonce

Une fois AdManagerAdView en place, l'étape suivante consiste à pour charger une annonce. Pour ce faire, utilisez loadAd() dans la classe AdManagerAdView. Il faut un AdManagerAdRequest , qui contient des informations d'exécution, telles que les informations de ciblage, sur un demande d'annonce unique.

Voici un exemple illustrant comment charger une annonce:

Java

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

Kotlin

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

Si l'annonce ne se charge pas, vous n'avez pas besoin d'en demander une autre, car si votre bloc d'annonces est actualisée. le SDK Google Mobile Ads respecte la fréquence d'actualisation spécifiée dans Ad Manager l'interface Web. Si vous n'avez pas activé l'actualisation, vous devrez envoyer une nouvelle requête.

Et voilà ! Votre application est maintenant prête à diffuser des bannières.

Événements d'annonces

Vous pouvez écouter un certain nombre d'événements au cours du cycle de vie de l'annonce, tels que le chargement, les impressions et les clics sur une annonce, ainsi que les événements d'ouverture et de fermeture d'une 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 à remplacer dans AdListener correspond à un événement du cycle de vie d'une annonce.

Méthodes remplaçables
onAdClicked() onAdClicked() est appelée lorsqu'un clic est enregistré pour une annonce.
onAdClosed() onAdClosed() est appelée lorsqu'un utilisateur revient dans l'application après avoir consulté l'événement l'URL de destination. Votre application peut l'utiliser pour reprendre des activités suspendues ou effectuer toute autre tâche nécessaire pour se préparer à l'interaction.
onAdFailedToLoad() onAdFailedToLoad() est la seule à inclure un paramètre. Le paramètre d'erreur du type LoadAdError décrit l'erreur qui s'est produite. Pour plus d'informations, reportez-vous à la section Déboguer les erreurs de chargement des annonces documentation.
onAdImpression() onAdImpression() est appelée lorsqu'une impression est enregistrée pour une annonce.
onAdLoaded() onAdLoaded() est exécutée lorsque le chargement d'une annonce est terminé. Si vous souhaitez retarder en ajoutant AdManagerAdView à 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() 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 votre application est concernée, nous vous recommandons d'activer l'accélération matérielle pour Activity de classes qui utilisent des annonces.

Activer l'accélération matérielle

Si votre application ne se comporte pas correctement avec l'accélération matérielle activée de façon globale, mais vous pouvez aussi le contrôler pour des activités spécifiques. Pour activer ou désactiver l'accélération matérielle, vous pouvez utiliser android:hardwareAccelerated de l'attribut <application> et <activity> dans votre AndroidManifest.xml. L'exemple suivant active le matériel 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>

Reportez-vous à la section Accélération matérielle pour en savoir plus des informations sur les options de contrôle 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.

Comptage manuel des impressions

La comptabilisation manuelle des impressions n'est compatible qu'avec les annonces vendues directement et les annonces d'auto-promotion. avec des créations dont le trafficking est effectué directement dans Ad Manager. Cela ne devrait pas être pour les annonces de remplissage ou celles de réseaux tiers. Pour en savoir plus, consultez la section Comptage le nombre d'impressions et de clics.

Vous pouvez envoyer manuellement des pings d'impression à Ad Manager si vous avez les conditions d'enregistrement d'une impression. Pour ce faire, activez un AdManagerAdRequest pour les impressions manuelles avant de charger une annonce:

Java

AdManagerAdRequest adRequest = new AdManagerAdRequest.Builder()
    .setManualImpressionsEnabled(true)
    .build();

Kotlin

val adRequest = AdManagerAdRequest.Builder()
    .setManualImpressionsEnabled(true)
    .build()

Lorsque vous déterminez qu'une annonce a bien été renvoyée et qu'elle apparaît à l'écran, vous pouvez enregistrer une impression manuellement:

Java

{ ad_view }.recordManualImpression();

Kotlin

AdManagerAdView.recordManualImpression()

Événements d'application

Les événements d'application vous permettent de créer des annonces qui peuvent envoyer des messages au code de l'application. L'application peut ensuite prendre des mesures en fonction de ces messages.

Vous pouvez écouter les événements d'application spécifiques à Ad Manager à l'aide de AppEventListener. Ces événements peuvent se produire à tout moment au cours du cycle de vie de l'annonce, onAdLoaded() est appelé.

Java

public interface AppEventListener {
  void onAppEvent(String name, String info);
}

Kotlin

interface AppEventListener {
    fun onAppEvent(name: String, info: String)
}

void onAppEvent(String name, String info) est appelé lorsqu'un événement d'application se produit dans une annonce. Cette interface peut être implémentée par votre activité ou tout autre objet :

Java

import com.google.android.gms.ads.admanager.*;

public class BannerExample extends Activity implements AppEventListener {
}

Kotlin

import com.google.android.gms.ads.admanager.*

class BannerExample : Activity(), AppEventListener {
}

puis transmis à AdManagerAdView:

Java

AdManagerAdView.setAppEventListener(this);

Kotlin

AdManagerAdView.appEventListener = this

Voici un exemple montrant comment modifier la couleur d'arrière-plan de votre application. en fonction d'un événement d'application avec un nom de couleur:

Java

@Override
public void onAppEvent(String name, String info) {
  if ("color".equals(name)) {
    if ("green".equals(info)) {
      // Set background color to green.
    } else if ("blue".equals(info)) {
      // Set background color to blue.
    } else {
      // Set background color to black.
    }
  }
}

Kotlin

override fun onAppEvent(name: String?, info: String?) {
    if (name == "color") {
        when (info) {
            "green" -> {
                // Set background color to green.
            }
            "blue" -> {
                // Set background color to blue.
            }
            else -> {
                // Set background color to black.
            }
        }
    }
}

Et voici la création correspondante qui envoie des messages d'événement d'application couleur l'écouteur:

<html>
<head>
  <script src="//www.gstatic.com/afma/api/v1/google_mobile_app_ads.js"></script>
  <script>
    document.addEventListener("DOMContentLoaded", function() {
      // Send a color=green event when ad loads.
      admob.events.dispatchAppEvent("color", "green");

      document.getElementById("ad").addEventListener("click", function() {
        // Send a color=blue event when ad is clicked.
        admob.events.dispatchAppEvent("color", "blue");
      });
    });
  </script>
  <style>
    #ad {
      width: 320px;
      height: 50px;
      top: 0px;
      left: 0px;
      font-size: 24pt;
      font-weight: bold;
      position: absolute;
      background: black;
      color: white;
      text-align: center;
    }
  </style>
</head>
<body>
  <div id="ad">Carpe diem!</div>
</body>
</html>

Consultez l'exemple d'événements d'application Ad Manager pour découvrir comment implémenter des événements d'application dans l'application de démonstration de l'API.

Java Kotlin

Ressources supplémentaires

Exemples sur GitHub

  • Exemple de bannière adaptative ancrée: Java | Kotlin
  • Démonstration 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. Envisager de l'utiliser pour optimiser vos performances. Pour en savoir plus, consultez Bannières réductibles.

Bannières adaptatives intégrées

Les bannières adaptatives intégrées sont plus grandes et plus grandes que les bannières adaptatives ancrées. des bannières. Ils sont de hauteur variable et peuvent être aussi hauts que l'écran de l'appareil. Nous recommandons d'utiliser des bannières adaptatives intégrées plutôt que des bannières adaptatives ancrées pour Applications qui diffusent des bannières dans du contenu à faire défiler Voir la section API adaptative intégrée des bannières plus de détails.

Découvrir d'autres sujets