Annonces à l'ouverture d'une application

Ce guide s'adresse aux éditeurs qui intègrent des annonces App open à l'aide du SDK Google Mobile Ads (bêta).

Les annonces à l'ouverture sont un format d'annonce spécial destiné aux éditeurs qui souhaitent monétiser les écrans de chargement de leurs applications. Les annonces à l'ouverture d'une application peuvent être fermées à tout moment. Elles sont conçues pour s'afficher lorsque vos utilisateurs mettent votre application au premier plan.

Les annonces à l'ouverture affichent automatiquement une petite zone de branding pour faire savoir aux utilisateurs qu'ils se trouvent dans votre application. Voici un exemple d'annonce à l'ouverture :

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. À 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é aux annonces app open :

ca-app-pub-3940256099942544/9257395921

Il a été spécialement configuré pour renvoyer des annonces tests pour chaque demande. Vous pouvez l'utiliser librement 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 (bêta), consultez Activer les annonces tests.

Étendre la classe Application

Créez une classe qui étend la classe Application. Cela permet de gérer les annonces liées à l'état de l'application plutôt qu'à un seul Activity, en tenant compte du cycle de vie :

Kotlin

/** Application class that initializes, loads and show ads when activities change states. */
class MyApplication : Application() {

  override fun onCreate() {
    super<Application>.onCreate()
    CoroutineScope(Dispatchers.IO).launch {
      // Initialize the Mobile Ads SDK synchronously on a background thread.
      MobileAds.initialize(this@MyApplication, InitializationConfig.Builder(APP_ID).build()) {}
    }
  }

  private companion object {
    // Sample AdMob App ID.
    const val APP_ID = "ca-app-pub-3940256099942544~3347511713"
  }
}

Java

/** Application class that initializes, loads and show ads when activities change states. */
public class MyApplication extends Application {

  // Sample AdMob App ID.
  private static final String APP_ID = "ca-app-pub-3940256099942544~3347511713";

  @Override
  public void onCreate() {
    super.onCreate();
    new Thread(
        () -> {
          // Initialize the SDK on a background thread.
          MobileAds.initialize(
              MyApplication.this,
              new InitializationConfig.Builder(APP_ID).build(),
              initializationStatus -> {});
        })
        .start();
  }
}

Cela fournit le squelette dans lequel vous vous inscrirez ultérieurement aux événements de mise au premier plan de l'application.

Ajoutez ensuite le code suivant à votre AndroidManifest.xml :

<!-- TODO: Update to reference your actual package name. -->
<application
    android:name="com.google.android.gms.example.appopendemo.MyApplication" ...>
...
</application>

Implémenter votre composant utilitaire

Votre annonce doit s'afficher rapidement. Il est donc préférable de la charger avant de devoir la diffuser. Vous aurez ainsi une annonce prête à être diffusée dès que l'utilisateur entrera dans votre application.

Implémentez un composant utilitaire AppOpenAdManager pour encapsuler le travail lié au chargement et à l'affichage des annonces à l'ouverture de l'application :

Kotlin

/**
* Interface definition for a callback to be invoked when an app open ad is complete (i.e. dismissed
* or fails to show).
*/
fun interface OnShowAdCompleteListener {
  fun onShowAdComplete()
}

/** Singleton object that loads and shows app open ads. */
object AppOpenAdManager {
  private var appOpenAd: AppOpenAd? = null
  private var isLoadingAd = false
  var isShowingAd = false

  /**
  * Load an ad.
  *
  * @param context a context used to perform UI-related operations (e.g. display Toast messages).
  *   Showing the app open ad itself does not require a context.
  */
  fun loadAd(context: Context) {
    // We will implement this later.
  }

  /**
  * Show the ad if one isn't already showing.
  *
  * @param activity the activity that shows the app open ad.
  * @param onShowAdCompleteListener the listener to be notified when an app open ad is complete.
  */
  fun showAdIfAvailable(activity: Activity, onShowAdCompleteListener: OnShowAdCompleteListener?) {
    // We will implement this later.
  }

  /** Check if ad exists and can be shown. */
  private fun isAdAvailable(): Boolean {
    return appOpenAd != null
  }
}

Java

/** Singleton object that loads and shows app open ads. */
public class AppOpenAdManager {

  /**
  * Interface definition for a callback to be invoked when an app open ad is complete (i.e.
  * dismissed or fails to show).
  */
  public interface OnShowAdCompleteListener {
    void onShowAdComplete();
  }

  private static AppOpenAdManager instance;
  private AppOpenAd appOpenAd;
  private boolean isLoadingAd = false;
  private boolean isShowingAd = false;

  /** Keep track of the time an app open ad is loaded to make sure you don't show an expired ad. */
  private long loadTime = 0;

  public static synchronized AppOpenAdManager getInstance() {
    if (instance == null) {
      instance = new AppOpenAdManager();
    }
    return instance;
  }

  /**
  * Load an ad.
  *
  * @param context a context used to perform UI-related operations (e.g. display Toast messages).
  *     Loading the app open ad itself does not require a context.
  */
  public void loadAd(@NonNull Context context) {
    // We will implement this later.
  }

  /**
  * Show the ad if one isn't already showing.
  *
  * @param activity the activity that shows the app open ad.
  * @param onShowAdCompleteListener the listener to be notified when an app open ad is complete.
  */
  public void showAdIfAvailable(
      @NonNull Activity activity, @Nullable OnShowAdCompleteListener onShowAdCompleteListener) {
    // We will implement this later.
  }

  /** Check if ad exists and can be shown. */
  private boolean isAdAvailable() {
    return appOpenAd != null
  }
}

Maintenant que vous disposez d'une classe utilitaire, vous pouvez l'instancier dans votre classe MyApplication :

Java

public class MyApplication extends Application {

  private AppOpenAdManager appOpenAdManager;

  @Override
  public void onCreate() {
    super.onCreate();
    new Thread(
            () -> {
              // Initialize Google Mobile Ads SDK (beta) on a background thread.
              MobileAds.initialize(this, initializationStatus -> {});
            })
        .start();
    appOpenAdManager = new AppOpenAdManager(this);
  }
}

Kotlin

class MyApplication : Application() {

  private lateinit var appOpenAdManager: AppOpenAdManager

  override fun onCreate() {
    super.onCreate()
    val backgroundScope = CoroutineScope(Dispatchers.IO)
    backgroundScope.launch {
      // Initialize Google Mobile Ads SDK (beta) on a background thread.
      MobileAds.initialize(this@MyApplication) {}
    }
    appOpenAdManager = AppOpenAdManager()
  }
}

Pour utiliser AppOpenAdManager, appelez les méthodes d'encapsulation publiques sur l'instance singleton MyApplication. La classe Application interagit avec le reste du code, en déléguant au gestionnaire le chargement et l'affichage de l'annonce.

Charger une annonce

L'étape suivante consiste à remplir la méthode loadAd() et à gérer les rappels de chargement d'annonces.

Kotlin


/**
 * Load an ad.
 *
 * @param context a context used to perform UI-related operations (e.g. display Toast messages).
 *   Loading the app open ad itself does not require a context.
 */
fun loadAd(context: Context) {
  // Do not load ad if there is an unused ad or one is already loading.
  if (isLoadingAd || isAdAvailable()) {
    Log.d(Constant.TAG, "App open ad is either loading or has already loaded.")
    return
  }

  isLoadingAd = true
  AppOpenAd.load(
    AdRequest.Builder(AppOpenFragment.AD_UNIT_ID).build(),
    object : AdLoadCallback<AppOpenAd> {
      /**
       * Called when an app open ad has loaded.
       *
       * @param ad the loaded app open ad.
       */
      override fun onAdLoaded(ad: AppOpenAd) {
        // Called when an ad has loaded.
        appOpenAd = ad
        isLoadingAd = false
        Log.d(Constant.TAG, "App open ad loaded.")
      }

      /**
       * Called when an app open ad has failed to load.
       *
       * @param loadAdError the error.
       */
      override fun onAdFailedToLoad(loadAdError: LoadAdError) {
        isLoadingAd = false
        Log.w(Constant.TAG, "App open ad failed to load: $loadAdError")
      }
    },
  )
}

Java


/**
 * Load an ad.
 *
 * @param context a context used to perform UI-related operations (e.g. display Toast messages).
 *     Loading the app open ad itself does not require a context.
 */
public void loadAd(@NonNull Context context) {
  // Do not load ad if there is an unused ad or one is already loading.
  if (isLoadingAd || isAdAvailable()) {
    Log.d(Constant.TAG, "App open ad is either loading or has already loaded.");
    return;
  }

  isLoadingAd = true;
  AppOpenAd.load(
      new AdRequest.Builder(AppOpenFragment.AD_UNIT_ID).build(),
      new AdLoadCallback<AppOpenAd>() {
        @Override
        public void onAdLoaded(@NonNull AppOpenAd ad) {
          appOpenAd = ad;
          isLoadingAd = false;
          Log.d(Constant.TAG, "App open ad loaded.");
        }

        @Override
        public void onAdFailedToLoad(@NonNull LoadAdError loadAdError) {
          isLoadingAd = false;
          Log.w(Constant.TAG, "App open ad failed to load: " + loadAdError);
        }
      });
}

Remplacez AD_UNIT_ID par votre propre ID de bloc d'annonces.

Diffuser l'annonce

L'implémentation la plus courante des annonces à l'ouverture d'application consiste à essayer d'afficher une annonce à l'ouverture d'application au lancement de l'application, à démarrer le contenu de l'application si l'annonce n'est pas prête et à précharger une autre annonce pour la prochaine opportunité d'annonce à l'ouverture d'application. Pour obtenir des exemples d'implémentation, consultez les conseils concernant les annonces à l'ouverture d'une application.

Le code suivant affiche une annonce, puis la recharge :

Kotlin

/**
 * Show the ad if one isn't already showing.
 *
 * @param activity the activity that shows the app open ad.
 * @param onShowAdCompleteListener the listener to be notified when an app open ad is complete.
 */
fun showAdIfAvailable(activity: Activity, onShowAdCompleteListener: OnShowAdCompleteListener?) {
  // If the app open ad is already showing, do not show the ad again.
  if (isShowingAd) {
    Log.d(Constant.TAG, "App open ad is already showing.")
    onShowAdCompleteListener?.onShowAdComplete()
    return
  }

  // If the app open ad is not available yet, invoke the callback.
  if (!isAdAvailable()) {
    Log.d(Constant.TAG, "App open ad is not ready yet.")
    onShowAdCompleteListener?.onShowAdComplete()
    return
  }

  appOpenAd?.adEventCallback =
    object : AppOpenAdEventCallback {
      override fun onAdShowedFullScreenContent() {
        Log.d(Constant.TAG, "App open ad showed.")
      }

      override fun onAdDismissedFullScreenContent() {
        Log.d(Constant.TAG, "App open ad dismissed.")
        appOpenAd = null
        isShowingAd = false
        onShowAdCompleteListener?.onShowAdComplete()
        loadAd(activity)
      }

      override fun onAdFailedToShowFullScreenContent(
        fullScreenContentError: FullScreenContentError
      ) {
        appOpenAd = null
        isShowingAd = false
        Log.w(Constant.TAG, "App open ad failed to show: $fullScreenContentError")
        onShowAdCompleteListener?.onShowAdComplete()
        loadAd(activity)
      }

      override fun onAdImpression() {
        Log.d(Constant.TAG, "App open ad recorded an impression.")
      }

      override fun onAdClicked() {
        Log.d(Constant.TAG, "App open ad recorded a click.")
      }
    }

  isShowingAd = true
  appOpenAd?.show(activity)
}

Java

/**
 * Show the ad if one isn't already showing.
 *
 * @param activity the activity that shows the app open ad.
 * @param onShowAdCompleteListener the listener to be notified when an app open ad is complete.
 */
public void showAdIfAvailable(
    @NonNull Activity activity, @Nullable OnShowAdCompleteListener onShowAdCompleteListener) {
  // If the app open ad is already showing, do not show the ad again.
  if (isShowingAd) {
    Log.d(Constant.TAG, "App open ad is already showing.");
    if (onShowAdCompleteListener != null) {
      onShowAdCompleteListener.onShowAdComplete();
    }
    return;
  }

  // If the app open ad is not available yet, invoke the callback.
  if (!isAdAvailable()) {
    Log.d(Constant.TAG, "App open ad is not ready yet.");
    if (onShowAdCompleteListener != null) {
      onShowAdCompleteListener.onShowAdComplete();
    }
    return;
  }

  appOpenAd.setAdEventCallback(
      new AppOpenAdEventCallback() {
        @Override
        public void onAdShowedFullScreenContent() {
          Log.d(Constant.TAG, "App open ad shown.");
        }

        @Override
        public void onAdDismissedFullScreenContent() {
          Log.d(Constant.TAG, "App open ad dismissed.");
          appOpenAd = null;
          isShowingAd = false;
          if (onShowAdCompleteListener != null) {
            onShowAdCompleteListener.onShowAdComplete();
          }
          loadAd(activity);
        }

        @Override
        public void onAdFailedToShowFullScreenContent(
            @NonNull FullScreenContentError fullScreenContentError) {
          appOpenAd = null;
          isShowingAd = false;
          Log.w(Constant.TAG, "App open ad failed to show: " + fullScreenContentError);
          if (onShowAdCompleteListener != null) {
            onShowAdCompleteListener.onShowAdComplete();
          }
          loadAd(activity);
        }

        @Override
        public void onAdImpression() {
          Log.d(Constant.TAG, "App open ad recorded an impression.");
        }

        @Override
        public void onAdClicked() {
          Log.d(Constant.TAG, "App open ad recorded a click.");
        }
      });

  isShowingAd = true;
  appOpenAd.show(activity);
}

AppOpenAdEventCallback gère les événements tels que l'affichage, l'échec d'affichage ou la fermeture de l'annonce.

Prendre en compte l'expiration des annonces

Pour vous assurer de ne pas diffuser une annonce expirée, ajoutez une méthode à AppOpenAdManager qui vérifie le temps écoulé depuis le chargement de la référence de votre annonce. Utilisez ensuite cette méthode pour vérifier si l'annonce est toujours valide.

Kotlin

object AppOpenAdManager {
  // ...
  /** Keep track of the time an app open ad is loaded to make sure you don't show an expired ad. */
  private var loadTime: Long = 0;
  
  /**
   * Load an ad.
   *
   * @param context a context used to perform UI-related operations (e.g. display Toast messages).
   *   Loading the app open ad itself does not require a context.
   */
  fun loadAd(context: Context) {
    // Do not load ad if there is an unused ad or one is already loading.
    if (isLoadingAd || isAdAvailable()) {
      Log.d(Constant.TAG, "App open ad is either loading or has already loaded.")
      return
    }

    isLoadingAd = true
    AppOpenAd.load(
      AdRequest.Builder(AppOpenFragment.AD_UNIT_ID).build(),
      object : AdLoadCallback<AppOpenAd> {
        /**
         * Called when an app open ad has loaded.
         *
         * @param ad the loaded app open ad.
         */
        override fun onAdLoaded(ad: AppOpenAd) {
          // Called when an ad has loaded.
          appOpenAd = ad
          isLoadingAd = false
          loadTime = Date().time
          Log.d(Constant.TAG, "App open ad loaded.")
        }

        /**
         * Called when an app open ad has failed to load.
         *
         * @param loadAdError the error.
         */
        override fun onAdFailedToLoad(loadAdError: LoadAdError) {
          isLoadingAd = false
          Log.w(Constant.TAG, "App open ad failed to load: $loadAdError")
        }
      },
    )
  }

  // ...

  /** Check if ad was loaded more than n hours ago. */
  private fun wasLoadTimeLessThanNHoursAgo(numHours: Long): Boolean {
    val dateDifference: Long = Date().time - loadTime
    val numMilliSecondsPerHour: Long = 3600000
    return dateDifference < numMilliSecondsPerHour * numHours
  }

  /** Check if ad exists and can be shown. */
  private fun isAdAvailable(): Boolean {
    // App open ads expire after four hours. Ads rendered more than four hours after request time
    // are no longer valid and may not earn revenue.
    return appOpenAd != null && wasLoadTimeLessThanNHoursAgo(4)
  }
}

Java

public class AppOpenAdManager {
  // ...
  /** Keep track of the time an app open ad is loaded to make sure you don't show an expired ad. */
  private long loadTime = 0;
  
  /**
   * Load an ad.
   *
   * @param context a context used to perform UI-related operations (e.g. display Toast messages).
   *     Loading the app open ad itself does not require a context.
   */
  public void loadAd(@NonNull Context context) {
    // Do not load ad if there is an unused ad or one is already loading.
    if (isLoadingAd || isAdAvailable()) {
      Log.d(Constant.TAG, "App open ad is either loading or has already loaded.");
      return;
    }

    isLoadingAd = true;
    AppOpenAd.load(
        new AdRequest.Builder(AppOpenFragment.AD_UNIT_ID).build(),
        new AdLoadCallback<AppOpenAd>() {
          @Override
          public void onAdLoaded(@NonNull AppOpenAd ad) {
            appOpenAd = ad;
            isLoadingAd = false;
            loadTime = new Date().getTime();
            Log.d(Constant.TAG, "App open ad loaded.");
          }

          @Override
          public void onAdFailedToLoad(@NonNull LoadAdError loadAdError) {
            isLoadingAd = false;
            Log.w(Constant.TAG, "App open ad failed to load: " + loadAdError);
          }
        });
  }

  // ...

  /** Check if ad was loaded more than n hours ago. */
  private boolean wasLoadTimeLessThanNHoursAgo(long numHours) {
    long dateDifference = new Date().getTime() - loadTime;
    long numMilliSecondsPerHour = 3600000L;
    return dateDifference < numMilliSecondsPerHour * numHours;
  }

  /** Check if ad exists and can be shown. */
  private boolean isAdAvailable() {
    // App open ads expire after four hours. Ads rendered more than four hours after request time
    // are no longer valid and may not earn revenue.
    return appOpenAd != null && wasLoadTimeLessThanNHoursAgo(4);
  }
}

Suivre l'activité en cours

Pour afficher l'annonce, vous aurez besoin d'un contexte Activity. Pour suivre l'activité la plus récente utilisée, inscrivez-vous et implémentez Application.ActivityLifecycleCallbacks.

Kotlin

class MyApplication : Application(), Application.ActivityLifecycleCallbacks {

  private var currentActivity: Activity? = null

  override fun onCreate() {
    super<Application>.onCreate()
    registerActivityLifecycleCallbacks(this)
  }

  /** ActivityLifecycleCallback methods. */
  override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {}

  override fun onActivityStarted(activity: Activity) {
    currentActivity = activity
  }

  override fun onActivityResumed(activity: Activity) {}

  override fun onActivityPaused(activity: Activity) {}

  override fun onActivityStopped(activity: Activity) {}

  override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) {}

  override fun onActivityDestroyed(activity: Activity) {}

  // ...
}

Java

public class MyApplication extends Application
  implements Application.ActivityLifecycleCallbacks {

  private Activity currentActivity;

  @Override
  public void onCreate() {
    super.onCreate();
    registerActivityLifecycleCallbacks(this);
  }

  /** ActivityLifecycleCallback methods. */
  @Override
  public void onActivityCreated(@NonNull Activity activity, @Nullable Bundle bundle) {}

  @Override
  public void onActivityStarted(@NonNull Activity activity) {
    currentActivity = activity;
  }

  @Override
  public void onActivityResumed(@NonNull Activity activity) {}

  @Override
  public void onActivityPaused(@NonNull Activity activity) {}

  @Override
  public void onActivityStopped(@NonNull Activity activity) {}

  @Override
  public void onActivitySaveInstanceState(@NonNull Activity activity, @NonNull Bundle bundle) {}

  @Override
  public void onActivityDestroyed(@NonNull Activity activity) {}

  // ...
}

registerActivityLifecycleCallbacks vous permet d'écouter tous les événements Activity. En écoutant le moment où les activités sont démarrées et détruites, vous pouvez garder une trace d'une référence à l'Activity actuel, que vous utiliserez ensuite pour présenter votre annonce App Open.

Écouter les événements de mise au premier plan de l'application

Pour écouter les événements de premier plan de l'application, procédez comme suit :

Ajouter les bibliothèques à votre fichier Gradle

Pour être informé des événements de premier plan de l'application, vous devez enregistrer un DefaultLifecycleObserver. Ajoutez sa dépendance au fichier build au niveau de votre application :

Kotlin

  dependencies {
    implementation("com.google.android.libraries.ads.mobile.sdk:ads-mobile-sdk:0.21.0-beta01")
    implementation("androidx.lifecycle:lifecycle-process:2.8.3")
  }

Groovy

  dependencies {
    implementation 'com.google.android.libraries.ads.mobile.sdk:ads-mobile-sdk:0.21.0-beta01'
    implementation 'androidx.lifecycle:lifecycle-process:2.8.3'
  }

Implémenter l'interface d'observateur du cycle de vie

Vous pouvez écouter les événements de mise au premier plan en implémentant l'interface DefaultLifecycleObserver.

Implémentez onStart() pour afficher l'annonce à l'ouverture de l'application.

Kotlin

class MyApplication :
  Application(), Application.ActivityLifecycleCallbacks, DefaultLifecycleObserver {

  private var currentActivity: Activity? = null

  override fun onCreate() {
    super<Application>.onCreate()
    registerActivityLifecycleCallbacks(this)
    ProcessLifecycleOwner.get().lifecycle.addObserver(this)
  }

  /**
  * DefaultLifecycleObserver method that shows the app open ad when the app moves to foreground.
  */
  override fun onStart(owner: LifecycleOwner) {
    currentActivity?.let { activity ->
      AppOpenAdManager.showAdIfAvailable(activity, null)
    }
  }

  // ...
}

Java

public class MyApplication extends Application
  implements Application.ActivityLifecycleCallbacks, DefaultLifecycleObserver {

  private Activity currentActivity;

  @Override
  public void onCreate() {
    super.onCreate();
    registerActivityLifecycleCallbacks(this);
    ProcessLifecycleOwner.get().getLifecycle().addObserver(this);
  }

  /**
  * DefaultLifecycleObserver method that shows the app open ad when the app moves to foreground.
  */
  @Override
  public void onStart(@NonNull LifecycleOwner owner) {
    if (currentActivity == null) {
      return;
    }

    AppOpenAdManager.getInstance().showAdIfAvailable(currentActivity, null);
  }

  // ...
}

Démarrages à froid et écrans de chargement

Jusqu'à présent, la documentation suppose que vous n'affichez des annonces à l'ouverture d'une application que lorsque les utilisateurs mettent votre application au premier plan alors qu'elle est suspendue en mémoire. Les "démarrages à froid" se produisent lorsque votre application est lancée, mais n'a pas été suspendue précédemment en mémoire.

Un démarrage à froid se produit, par exemple, lorsqu'un utilisateur ouvre votre application pour la première fois. Avec les démarrages à froid, vous n'aurez pas d'annonce à l'ouverture d'application précédemment chargée et prête à être diffusée immédiatement. Le délai entre le moment où vous demandez une annonce et celui où vous la recevez peut créer une situation où les utilisateurs peuvent utiliser brièvement votre application avant d'être surpris par une annonce hors contexte. Cette pratique est à éviter, car elle nuit à l'expérience utilisateur.

La méthode recommandée pour utiliser les annonces à l'ouverture d'une application lors d'un démarrage à froid consiste à utiliser un écran de chargement pour charger les éléments de votre jeu ou de votre application, et à n'afficher l'annonce qu'à partir de l'écran de chargement. Si votre application a fini de se charger et a redirigé l'utilisateur vers le contenu principal de votre application, n'affichez pas l'annonce.

Bonnes pratiques

Les annonces à l'ouverture d'une application vous aident à monétiser l'écran de chargement de votre application, lorsque l'application est lancée pour la première fois et lors des changements d'application. Toutefois, il est important de garder à l'esprit les bonnes pratiques afin que vos utilisateurs apprécient d'utiliser votre application. Il est préférable de :

  • Attendez que les utilisateurs aient ouvert votre application quelques fois avant de diffuser votre première annonce à l'ouverture.
  • Affichez des annonces à l'ouverture de votre application lorsque vos utilisateurs doivent attendre que celle-ci se charge.
  • Si votre écran de chargement se trouve sous l'annonce à l'ouverture d'une application et qu'il finit de charger avant la fermeture de l'annonce, vous pouvez le fermer dans la méthode onAdDismissedFullScreenContent().

Exemple

Téléchargez et exécutez l'application exemple qui montre comment utiliser le SDK Google Mobile Ads (bêta).