Configurer des annonces à l'ouverture d'une application

Vertex AI Pipelines.

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

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

Pour en savoir plus, consultez les conseils concernant les annonces à l'ouverture d'une application.

Ce guide explique comment intégrer des annonces à l'ouverture d'une application dans une application Android.

Avant de commencer

Avant de continuer, procédez comme suit :

  • Configurer GMA Next-Gen SDK.
  • Utilisez l'ID du bloc d'annonces à l'ouverture d'une application test /6499/example/app-open.
    • Lorsque vous créez et testez votre application, assurez-vous d'utiliser des annonces tests plutôt que des annonces de production. Si vous n'utilisez pas l'ID du bloc d'annonces test, Google peut suspendre votre compte.
    • Avant de publier votre application, remplacez cet ID par l'ID de votre bloc d'annonces.
    • Pour en savoir plus sur les annonces tests GMA Next-Gen SDK, consultez Activer les annonces tests.

Comprendre le préchargement des annonces

Le préchargement des annonces dans GMA Next-Gen SDK automatise le chargement et la mise en cache des annonces.

Le préchargement des annonces offre les avantages suivants :

  • Gestion des références : conserve les références jusqu'à ce que les annonces soient diffusées.
  • Rechargement automatique : charge une nouvelle annonce lorsqu'une annonce est récupérée à partir du cache.
  • Nouvelles tentatives gérées : charge une nouvelle annonce lorsqu'une annonce ne parvient pas à se charger.
  • Gestion de l'expiration : actualise les annonces avant qu'elles n'expirent.
  • Optimisation du cache : optimise l'ordre du cache pour diffuser l'annonce la plus prioritaire.

Démarrer le préchargement des annonces

Pour commencer à précharger des annonces, appelez la méthode start une seule fois au démarrage de l'application. Une fois que vous avez appelé la méthode start, GMA Next-Gen SDK précharge automatiquement les annonces et retente les requêtes ayant échoué pour les configurations préchargées.

L'exemple suivant montre comment commencer à précharger des annonces :

Kotlin

private fun startPreloading(adUnitId: String) {
  val adRequest = AdRequest.Builder(adUnitId).build()
  val preloadConfig = PreloadConfiguration(adRequest)
  AppOpenAdPreloader.start(adUnitId, preloadConfig)
}

Java

private void startPreloading(String adUnitId) {
  AdRequest adRequest = new AdRequest.Builder(adUnitId).build();
  PreloadConfiguration preloadConfig = new PreloadConfiguration(adRequest);
  AppOpenAdPreloader.start(adUnitId, preloadConfig);
}

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

L'exemple précédent montre comment utiliser l'ID du bloc d'annonces comme ID de préchargement. Un ID de préchargement est un identifiant de chaîne que vous créez pour identifier une configuration de préchargement d'annonce. Si votre application nécessite plusieurs configurations de ciblage pour le même ID de bloc d'annonces, transmettez un identifiant de chaîne personnalisé.

Obtenir et afficher l'annonce préchargée

Lorsque vous souhaitez diffuser une annonce, appelez la méthode pollAd. GMA Next-Gen SDK récupère une annonce disponible et précharge automatiquement l'annonce suivante en arrière-plan. Si aucune annonce n'est disponible, GMA Next-Gen SDK n'en renvoie aucune.

Lorsque vous disposez d'un objet d'annonce disponible, appelez la méthode show pour afficher l'annonce. L'exemple suivant montre comment récupérer et afficher une annonce préchargée :

Kotlin

private fun pollAndShowAd(activity: Activity, adUnitId: String) {
  // Polling returns the next available ad and loads another ad in the background.
  val ad = AppOpenAdPreloader.pollAd(adUnitId)
  if (ad == null) {
    Log.e(TAG, "App open ad is not available.")
    return
  }

  // Interact with the ad object as needed.
  Log.d(TAG, "App open ad response info: ${ad.getResponseInfo()}")
  ad.adEventCallback =
    object : AppOpenAdEventCallback {
      override fun onAdImpression() {
        Log.d(TAG, "App open ad recorded an impression.")
      }
    }
  ad.show(activity)
}

Java

private void pollAndShowAd(Activity activity, String adUnitId) {
  // Polling returns the next available ad and loads another ad in the background.
  AppOpenAd ad = AppOpenAdPreloader.pollAd(adUnitId);

  // Interact with the ad object as needed.
  if (ad == null) {
    Log.e(TAG, "App open ad is not available.");
    return;
  }

  Log.d(TAG, "App open ad response info: " + ad.getResponseInfo());
  ad.setAdEventCallback(
      new AppOpenAdEventCallback() {
        @Override
        public void onAdImpression() {
          Log.d(TAG, "App open ad recorded an impression.");
        }
      });

  // Show the ad.
  ad.show(activity);
}

Évitez d'appeler la méthode pollAd tant que vous n'êtes pas prêt à diffuser une annonce. Pour lire les informations de réponse de l'annonce sans l'afficher, consultez Lire les informations de réponse.

Écouter les événements d'annonce

Avant de diffuser l'annonce, écoutez les événements d'annonce. L'exemple suivant montre comment enregistrer des rappels pour les événements d'annonce :

Kotlin

private fun listenToAdEvents() {
  // Listen for ad events.
  val ad = appOpenAd
  if (ad == null) {
    Log.e(TAG, "App open ad is not ready yet.")
    return
  }

  ad.adEventCallback =
    object : AppOpenAdEventCallback {
      override fun onAdShowedFullScreenContent() {
        // App open ad did show.
      }

      override fun onAdDismissedFullScreenContent() {
        // App open ad did dismiss.
        appOpenAd = null
      }

      override fun onAdFailedToShowFullScreenContent(
        fullScreenContentError: FullScreenContentError
      ) {
        // App open ad failed to show.
        Log.e(TAG, "App open ad failed to show: ${fullScreenContentError.message}")
      }

      override fun onAdImpression() {
        // App open ad did record an impression.
      }

      override fun onAdClicked() {
        // App open ad did record a click.
      }
    }
}

Java

private void listenToAdEvents() {
  // Listen for ad events.
  if (appOpenAd == null) {
    Log.e(TAG, "App open ad is not ready yet.");
    return;
  }

  appOpenAd.setAdEventCallback(
      new AppOpenAdEventCallback() {
        @Override
        public void onAdShowedFullScreenContent() {
          // App open ad did show.
        }

        @Override
        public void onAdDismissedFullScreenContent() {
          // App open ad did dismiss.
          appOpenAd = null;
        }

        @Override
        public void onAdFailedToShowFullScreenContent(
            @NonNull FullScreenContentError fullScreenContentError) {
          // App open ad failed to show.
          Log.e(TAG, "App open ad failed to show: " + fullScreenContentError.getMessage());
        }

        @Override
        public void onAdImpression() {
          // App open ad did record an impression.
        }

        @Override
        public void onAdClicked() {
          // App open ad did record a click.
        }
      });
}

Facultatif : Écouter les événements de préchargement

Lorsque vous commencez à précharger des annonces, enregistrez-vous pour les événements de préchargement afin d'être averti lorsque les annonces sont préchargées, ne parviennent pas à être préchargées ou lorsque le cache d'annonces est épuisé.

L'exemple suivant montre comment s'inscrire aux événements de préchargement d'annonces :

Kotlin

private fun startPreloadingWithCallback(adUnitId: String) {
  val preloadCallback =
    object : PreloadCallback {
      override fun onAdFailedToPreload(preloadId: String, adError: LoadAdError) {
        Log.d(TAG, "App open preload ad $preloadId failed to load with error: ${adError.message}")
      }

      override fun onAdsExhausted(preloadId: String) {
        Log.i(TAG, "App open preload ad $preloadId is not available")
      }

      override fun onAdPreloaded(preloadId: String, responseInfo: ResponseInfo) {
        Log.i(TAG, "App open preload ad $preloadId is available")
      }
    }
  val adRequest = AdRequest.Builder(adUnitId).build()
  val preloadConfig = PreloadConfiguration(adRequest)
  AppOpenAdPreloader.start(adUnitId, preloadConfig, preloadCallback)
}

Java

private void startPreloadingWithCallback(String adUnitId) {
  PreloadCallback preloadCallback =
      new PreloadCallback() {
        @Override
        public void onAdFailedToPreload(@NonNull String preloadId, @NonNull LoadAdError adError) {
          Log.d(
              TAG,
              String.format(
                  "App open preload ad %s failed to load with error: %s",
                  preloadId, adError.getMessage()));
        }

        @Override
        public void onAdsExhausted(@NonNull String preloadId) {
          Log.i(TAG, String.format("App open preload ad %s is not available", preloadId));
        }

        @Override
        public void onAdPreloaded(@NonNull String preloadId, @NonNull ResponseInfo responseInfo) {
          Log.i(TAG, String.format("App open preload ad %s is available", preloadId));
        }
      };
  AdRequest adRequest = new AdRequest.Builder(adUnitId).build();
  PreloadConfiguration preloadConfig = new PreloadConfiguration(adRequest);
  AppOpenAdPreloader.start(adUnitId, preloadConfig, preloadCallback);
}

Lorsqu'une annonce ne parvient pas à se charger, GMA Next-Gen SDK précharge automatiquement les annonces et retente les requêtes ayant échoué pour les configurations préchargées.

Facultatif : Vérifier la disponibilité des annonces

Si vous avez besoin de savoir si une annonce est disponible, vérifiez sa disponibilité. L'exemple suivant montre comment vérifier si une annonce préchargée est disponible :

Kotlin

private fun isAdAvailable(adUnitId: String): Boolean {
  return AppOpenAdPreloader.isAdAvailable(adUnitId)
}

Java

private boolean isAdAvailable(String adUnitId) {
  return AppOpenAdPreloader.isAdAvailable(adUnitId);
}

Facultatif : Définir la taille de la mémoire tampon

La taille de la mémoire tampon contrôle le nombre d'annonces préchargées conservées en mémoire. Par défaut, Google optimise la taille de la mémoire tampon pour équilibrer la consommation de mémoire et la latence de diffusion des annonces. Vous pouvez définir une taille de mémoire tampon personnalisée pour augmenter le nombre d'annonces conservées en mémoire. Nous vous recommandons une taille de mémoire tampon maximale de quatre.

L'exemple suivant montre comment définir une taille de mémoire tampon de quatre annonces préchargées :

Kotlin

private fun setBufferSize(adUnitId: String) {
  val adRequest = AdRequest.Builder(adUnitId).build()
  // Four is the recommended maximum buffer size.
  val preloadConfig = PreloadConfiguration(adRequest, bufferSize = 4)
  AppOpenAdPreloader.start(adUnitId, preloadConfig)
}

Java

private void setBufferSize(String adUnitId) {
  AdRequest adRequest = new AdRequest.Builder(adUnitId).build();
  // Four is the recommended maximum buffer size.
  PreloadConfiguration preloadConfig = new PreloadConfiguration(adRequest, 4);
  AppOpenAdPreloader.start(adUnitId, preloadConfig);
}

Limites du cache de préchargement

GMA Next-Gen SDK applique une limite à l'échelle de l'application sur le nombre total d'annonces préchargées pour tous les blocs d'annonces et tous les ID de préchargement :

  • Limite par défaut : Google conserve un maximum de six annonces préchargées en mémoire. Cette limite est partagée entre tous les formats et tous les ID de préchargement.
  • Nous vous recommandons de conserver une taille de mémoire tampon de deux ou trois par ID de préchargement.

Facultatif : Arrêter le préchargement des annonces

Si vous n'avez plus besoin de diffuser des annonces pour un ID de préchargement spécifique dans la session, vous pouvez arrêter le préchargement des annonces. Pour arrêter le chargement des annonces pour un ID de préchargement spécifique, appelez la méthode destroy avec un ID de préchargement. L'appel de la méthode destroy supprime du cache toutes les annonces préchargées associées à l'ID de préchargement.

L'exemple suivant montre comment arrêter le préchargement des annonces :

Kotlin

private fun stopPreloading(adUnitId: String) {
  // Stops the preloading and destroy preloaded ads.
  AppOpenAdPreloader.destroy(adUnitId)
}

Java

private void stopPreloading(String adUnitId) {
  // Stops the preloading and destroy preloaded ads.
  AppOpenAdPreloader.destroy(adUnitId);
}

Facultatif : Lire les informations de réponse

Lisez les informations de réponse de la prochaine annonce préchargée sans la supprimer du cache.

L'exemple suivant montre comment lire les informations de réponse de la prochaine annonce préchargée :

Kotlin

val responseInfo = AppOpenAdPreloader.peekAdResponseInfo(preloadId)
if (responseInfo == null) {
  Log.e(TAG, "Failed to peek ad response info.")
  return
}

Log.d(TAG, "Peeked ad response ID: ${responseInfo.responseId}")

Java

ResponseInfo responseInfo = AppOpenAdPreloader.peekAdResponseInfo(preloadId);
if (responseInfo == null) {
  Log.e(TAG, "Failed to peek ad response info.");
  return;
}

Log.d(TAG, "Peeked ad response ID: " + responseInfo.getResponseId());

Démarrages à froid et écrans de chargement

Un démarrage à froid se produit lorsque votre application se lance à partir de zéro, par exemple, lorsqu'un utilisateur ouvre votre application pour la première fois ou après un arrêt de la mémoire. Lors d'un démarrage à froid, vous ne disposez pas d'une annonce à l'ouverture d'une application précédemment chargée et prête à être diffusée immédiatement.

En raison des retards de demande d'annonces, les utilisateurs peuvent interagir avec votre application avant qu'une annonce à l'ouverture d'une application ne s'affiche. Pour éviter une mauvaise expérience utilisateur, diffusez les annonces à l'ouverture d'une application lors des démarrages à froid uniquement à partir d'un écran de chargement pendant le chargement des éléments d'application. Si le chargement des éléments est terminé et que l'utilisateur accède au contenu principal avant le chargement de l'annonce, ne l'affichez pas.

Chargez les éléments d'application sur un thread en arrière-plan afin que le chargement se poursuive pendant l'affichage de l'annonce.

Bonnes pratiques

Suivez ces bonnes pratiques pour les annonces à l'ouverture d'une application :

  • N'affichez votre première annonce à l'ouverture d'une application qu'après qu'un utilisateur a ouvert votre application plusieurs fois.
  • N'affichez les annonces à l'ouverture d'une application que pendant que les utilisateurs attendent le chargement de votre application.
  • Si votre écran de chargement se termine pendant l'affichage de l'annonce, fermez-le dans la méthode de rappel d'annonce ignorée.