Annonces à l'ouverture d'une application

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

Ce guide est destiné aux éditeurs qui intègrent des annonces à l'ouverture d'une application.

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. Vos utilisateurs peuvent fermer les annonces à l'ouverture d'application à tout moment. Les annonces à l'ouverture d'une application peuvent s'afficher lorsque les 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 :

Voici les étapes à suivre pour implémenter les annonces à l'ouverture d'une application :

  1. Créez une classe de gestionnaire qui charge une annonce avant que vous n'ayez besoin de l'afficher.
  2. Afficher l'ajout lors des événements de mise au premier plan de l'application.
  3. Gérez les rappels de présentation.

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 lors de l'ouverture de l'application :

ca-app-pub-3940256099942544/5575463023

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

Implémenter une classe de gestionnaire

Votre annonce doit s'afficher rapidement. Il est donc préférable de la charger avant de devoir la diffuser. De cette façon, vous aurez une annonce prête à être diffusée dès que l'utilisateur entrera dans votre application. Implémentez une classe de gestionnaire pour effectuer des demandes d'annonces avant d'avoir besoin de les afficher.

Créez une classe singleton appelée AppOpenAdManager :

Swift

class AppOpenAdManager: NSObject {
  /// The app open ad.
  var appOpenAd: AppOpenAd?
  /// Maintains a reference to the delegate.
  weak var appOpenAdManagerDelegate: AppOpenAdManagerDelegate?
  /// Keeps track of if an app open ad is loading.
  var isLoadingAd = false
  /// Keeps track of if an app open ad is showing.
  var isShowingAd = false
  /// Keeps track of the time when an app open ad was loaded to discard expired ad.
  var loadTime: Date?
  /// For more interval details, see https://support.google.com/admob/answer/9341964
  let timeoutInterval: TimeInterval = 4 * 3_600

  static let shared = AppOpenAdManager()

Objective-C

@interface AppOpenAdManager ()

/// The app open ad.
@property(nonatomic, strong, nullable) GADAppOpenAd *appOpenAd;
/// Keeps track of if an app open ad is loading.
@property(nonatomic, assign) BOOL isLoadingAd;
/// Keeps track of if an app open ad is showing.
@property(nonatomic, assign) BOOL isShowingAd;
/// Keeps track of the time when an app open ad was loaded to discard expired ad.
@property(nonatomic, strong, nullable) NSDate *loadTime;

@end

/// For more interval details, see https://support.google.com/admob/answer/9341964
static const NSInteger kTimeoutInterval = 4;

@implementation AppOpenAdManager

+ (nonnull AppOpenAdManager *)sharedInstance {
  static AppOpenAdManager *instance = nil;
  static dispatch_once_t onceToken;
  dispatch_once(&onceToken, ^{
    instance = [[AppOpenAdManager alloc] init];
  });
  return instance;
}

Implémentez son protocole AppOpenAdManagerDelegate :

Swift

protocol AppOpenAdManagerDelegate: AnyObject {
  /// Method to be invoked when an app open ad life cycle is complete (i.e. dismissed or fails to
  /// show).
  func appOpenAdManagerAdDidComplete(_ appOpenAdManager: AppOpenAdManager)
}

Objective-C

@protocol AppOpenAdManagerDelegate <NSObject>
/// Method to be invoked when an app open ad life cycle is complete (i.e. dismissed or fails to
/// show).
- (void)adDidComplete;
@end

Charger une annonce

L'étape suivante consiste à charger une annonce App Open :

Swift

func loadAd() async {
  // Do not load ad if there is an unused ad or one is already loading.
  if isLoadingAd || isAdAvailable() {
    return
  }
  isLoadingAd = true

  do {
    appOpenAd = try await AppOpenAd.load(
      with: "ca-app-pub-3940256099942544/5575463023", request: Request())
    appOpenAd?.fullScreenContentDelegate = self
    loadTime = Date()
  } catch {
    print("App open ad failed to load with error: \(error.localizedDescription)")
    appOpenAd = nil
    loadTime = nil
  }
  isLoadingAd = false
}

Objective-C

- (void)loadAd {
  // Do not load ad if there is an unused ad or one is already loading.
  if ([self isAdAvailable] || self.isLoadingAd) {
    return;
  }
  self.isLoadingAd = YES;

  [GADAppOpenAd loadWithAdUnitID:@"ca-app-pub-3940256099942544/5575463023"
                         request:[GADRequest request]
               completionHandler:^(GADAppOpenAd * _Nullable appOpenAd, NSError * _Nullable error) {
    self.isLoadingAd = NO;
    if (error) {
      NSLog(@"App open ad failed to load with error: %@", error);
      self.appOpenAd = nil;
      self.loadTime = nil;
      return;
    }
    self.appOpenAd = appOpenAd;
    self.appOpenAd.fullScreenContentDelegate = self;
    self.loadTime = [NSDate date];
  }];
}

Diffuser une annonce

L'étape suivante consiste à afficher une annonce d'ouverture d'application. Si aucune annonce n'est disponible, essayez d'en charger une nouvelle.

Swift

func showAdIfAvailable() {
  // If the app open ad is already showing, do not show the ad again.
  if isShowingAd {
    return print("App open ad is already showing.")
  }

  // If the app open ad is not available yet but is supposed to show, load
  // a new ad.
  if !isAdAvailable() {
    print("App open ad is not ready yet.")
    // The app open ad is considered to be complete in this example.
    appOpenAdManagerDelegate?.appOpenAdManagerAdDidComplete(self)
    // Load a new ad.
    return
  }

  if let appOpenAd {
    appOpenAd.present(from: nil)
    isShowingAd = true
  }
}

Objective-C

- (void)showAdIfAvailable {
  // If the app open ad is already showing, do not show the ad again.
  if (self.isShowingAd) {
    NSLog(@"App open ad is already showing.");
    return;
  }

  // If the app open ad is not available yet but is supposed to show, load
  // a new ad.
  if (![self isAdAvailable]) {
    NSLog(@"App open ad is not ready yet.");
    // The app open ad is considered to be complete in this example.
    [self adDidComplete];
    // Load a new ad.
    return;
  }

  [self.appOpenAd presentFromRootViewController:nil];
  self.isShowingAd = YES;
}

Afficher l'annonce lors des événements de mise au premier plan de l'application

Lorsque l'application devient active, appelez showAdIfAvailable() pour afficher une annonce si elle est disponible ou en charger une nouvelle.

Swift

func applicationDidBecomeActive(_ application: UIApplication) {
  // Show the app open ad when the app is foregrounded.
  AppOpenAdManager.shared.showAdIfAvailable()
}

Objective-C

- (void) applicationDidBecomeActive:(UIApplication *)application {
  // Show the app open ad when the app is foregrounded.
  [AppOpenAdManager.sharedInstance showAdIfAvailable];
}

Gérer les rappels de présentation

Pour recevoir des notifications pour les événements de présentation, vous devez attribuer GADFullScreenContentDelegate à la propriété fullScreenContentDelegate de l'annonce renvoyée :

Swift

appOpenAd?.fullScreenContentDelegate = self

Objective-C

self.appOpenAd.fullScreenContentDelegate = self;

En particulier, vous devez demander la prochaine annonce à l'ouverture de l'application une fois que la première a fini de s'afficher. Le code suivant montre comment implémenter le protocole dans votre fichier AppOpenAdManager :

Swift

func adDidRecordImpression(_ ad: FullScreenPresentingAd) {
  print("App open ad recorded an impression.")
}

func adDidRecordClick(_ ad: FullScreenPresentingAd) {
  print("App open ad recorded a click.")
}

func adWillDismissFullScreenContent(_ ad: FullScreenPresentingAd) {
  print("App open ad will be dismissed.")
}

func adWillPresentFullScreenContent(_ ad: FullScreenPresentingAd) {
  print("App open ad will be presented.")
}

func adDidDismissFullScreenContent(_ ad: FullScreenPresentingAd) {
  print("App open ad was dismissed.")
  appOpenAd = nil
  isShowingAd = false
  appOpenAdManagerDelegate?.appOpenAdManagerAdDidComplete(self)
  Task {
    await loadAd()
  }
}

func ad(
  _ ad: FullScreenPresentingAd,
  didFailToPresentFullScreenContentWithError error: Error
) {
  print("App open ad failed to present with error: \(error.localizedDescription)")
  appOpenAd = nil
  isShowingAd = false
  appOpenAdManagerDelegate?.appOpenAdManagerAdDidComplete(self)
  Task {
    await loadAd()
  }
}

Objective-C

- (void)adDidRecordImpression:(nonnull id<GADFullScreenPresentingAd>)ad {
  NSLog(@"App open ad recorded an impression.");
}

- (void)adDidRecordClick:(nonnull id<GADFullScreenPresentingAd>)ad {
  NSLog(@"App open ad recorded a click.");
}

- (void)adWillPresentFullScreenContent:(nonnull id<GADFullScreenPresentingAd>)ad {
  NSLog(@"App open ad will be presented.");
}

- (void)adWillDismissFullScreenContent:(nonnull id<GADFullScreenPresentingAd>)ad {
  NSLog(@"App open ad will be dismissed.");
}

- (void)adDidDismissFullScreenContent:(nonnull id<GADFullScreenPresentingAd>)ad {
  NSLog(@"App open ad was dismissed.");
  self.appOpenAd = nil;
  self.isShowingAd = NO;
  [self adDidComplete];
  [self loadAd];
}

- (void)ad:(nonnull id<GADFullScreenPresentingAd>)ad
    didFailToPresentFullScreenContentWithError:(nonnull NSError *)error {
  NSLog(@"App open ad failed to present with error: %@", error.localizedDescription);
  self.appOpenAd = nil;
  self.isShowingAd = NO;
  [self adDidComplete];
  [self loadAd];
}

Prendre en compte l'expiration des annonces

Pour vous assurer de ne pas diffuser une annonce arrivée à expiration, vous pouvez ajouter une méthode au délégué d'application qui vérifie le temps écoulé depuis le chargement de la référence de votre annonce.

Dans votre AppOpenAdManager, ajoutez une propriété Date appelée loadTime et définissez-la lorsque votre annonce se charge. Vous pouvez ensuite ajouter une méthode qui renvoie true si moins d'un certain nombre d'heures se sont écoulées depuis le chargement de votre annonce. Veillez à vérifier la validité de votre référence d'annonce avant d'essayer de diffuser l'annonce.

Swift

private func wasLoadTimeLessThanNHoursAgo(timeoutInterval: TimeInterval) -> Bool {
  // Check if ad was loaded more than n hours ago.
  if let loadTime = loadTime {
    return Date().timeIntervalSince(loadTime) < timeoutInterval
  }
  return false
}

private func isAdAvailable() -> Bool {
  // Check if ad exists and can be shown.
  return appOpenAd != nil && wasLoadTimeLessThanNHoursAgo(timeoutInterval: timeoutInterval)
}

Objective-C

- (BOOL)wasLoadTimeLessThanNHoursAgo:(int)n {
  // Check if ad was loaded more than n hours ago.
  NSDate *now = [NSDate date];
  NSTimeInterval timeIntervalBetweenNowAndLoadTime = [now timeIntervalSinceDate:self.loadTime];
  double secondsPerHour = 3600.0;
  double intervalInHours = timeIntervalBetweenNowAndLoadTime / secondsPerHour;
  return intervalInHours < n;
}

- (BOOL)isAdAvailable {
  // Check if ad exists and can be shown.
  return _appOpenAd && [self wasLoadTimeLessThanNHoursAgo:kTimeoutInterval];
}

Démarrages à froid et écrans de chargement

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 interstitielle déjà 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

Google a conçu les annonces lors de l'ouverture de l'application pour vous aider à monétiser l'écran de chargement de votre application. Toutefois, il est important de garder à l'esprit les bonnes pratiques pour que vos utilisateurs apprécient votre application. Veillez à :

  • 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 adDidDismissFullScreenContent.

Exemple complet sur GitHub

Swift Objective-C

Étapes suivantes

En savoir plus sur la confidentialité des utilisateurs