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.

Remarque : Le format peut varier d'une région à l'autre.

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

• Suivez les instructions de configuration décrites dans notre guide de démarrage.
• Savoir configurer votre appareil en tant qu'appareil de test.

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 et remplissez-la comme suit :

Swift

class AppOpenAdManager: NSObject {
  var appOpenAd: AppOpenAd?
  var isLoadingAd = false.
  var isShowingAd = false

  static let shared = AppOpenAdManager()

  private func loadAd() async {
    // TODO: Implement loading an ad.
  }

  func showAdIfAvailable() {
    // TODO: Implement showing an ad.
  }

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

Objective-C

@interface AppOpenAdManager ()
@property(nonatomic, strong) GADAppOpenAd *appOpenAd;
@property(nonatomic, assign) BOOL isLoadingAd;
@property(nonatomic, assign) BOOL isShowingAd;

@end

@implementation AppOpenAdManager

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

- (void)loadAd {
  // TODO: Implement loading an ad.
}

// Add this method to the .h file.
- (void)showAdIfAvailable {
  // TODO: Implement showing an ad.
}

- (BOOL)isAdAvailable {
  // Check if ad exists and can be shown.
  return self.appOpenAd != nil;
}

@end

Charger une annonce

L'étape suivante consiste à remplir la méthode loadAd().

Swift

private 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())
  } catch {
    print("App open ad failed to load with error: \(error.localizedDescription)")
  }
  isLoadingAd = false
}

Objective-C

- (void)loadAd {
  // Do not load ad if there is an unused ad or one is already loading.
  if (self.isLoadingAd || [self isAdAvailable]) {
    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(@"Failed to load app open ad: %@", error);
                 return;
               }
               self.appOpenAd = appOpenAd;
             }];
}

Diffuser une annonce

L'étape suivante consiste à remplir la méthode showAdIfAvailable(). Si aucune annonce n'est disponible, la méthode tente d'en charger une.

Swift

func showAdIfAvailable() {
  // If the app open ad is already showing, do not show the ad again.
  guard !isShowingAd else { return }

  // If the app open ad is not available yet but is supposed to show, load
  // a new ad.
  if !isAdAvailable() {
    Task {
      await loadAd()
    }
    return
  }

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

Objective-C

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

  // If the app open ad is not available yet but is supposed to show, load a
  // new ad.
  if (![self isAdAvailable]) {
    [self loadAd];
    return;
  }

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

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.

Important : Si vous utilisez des scènes, implémentez plutôt la méthode sceneDidBecomeActive: dans votre UISceneDelegate.

Swift

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {
  // ...

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

Objective-C

@implementation AppDelegate
// ...

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

@end

Gérer les rappels de présentation

Lorsque votre application affiche une annonce à l'ouverture, vous devez vous appuyer sur GADFullScreenContentDelegate pour gérer certains événements de présentation. En particulier, vous devez demander la prochaine annonce d'ouverture d'application une fois que la première a fini de s'afficher.

Dans votre classe AppOpenAdManager, ajoutez les éléments suivants :

Swift

class AppOpenAdManager: NSObject, FullScreenContentDelegate {
  // ...

  private 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
    } catch {
      print("App open ad failed to load with error: \(error.localizedDescription)")
    }
    isLoadingAd = false
  }

  // ...

  // MARK: - FullScreenContentDelegate methods

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

  func adDidDismissFullScreenContent(_ ad: FullScreenPresentingAd) {
    appOpenAd = nil
    isShowingAd = false
    // Reload an ad.
    Task {
      await loadAd()
    }
  }

  func ad(
    _ ad: FullScreenPresentingAd,
    didFailToPresentFullScreenContentWithError error: Error
  ) {
    appOpenAd = nil
    isShowingAd = false
    // Reload an ad.
    Task {
      await loadAd()
    }
  }
}

Objective-C

@interface AppOpenAdManager () <GADFullScreenContentDelegate>
@property(nonatomic, strong) GADAppOpenAd *appOpenAd
@property(nonatomic, assign) BOOL isLoadingAd;
@property(nonatomic, assign) BOOL isShowingAd;

@end

@implementation AppOpenAdManager

// ...

- (void)loadAd {
  // Do not load ad if there is an unused ad or one is already loading.
  if (self.isLoadingAd || [self isAdAvailable]) {
    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(@"Failed to load app open ad: %@", error);
                 return;
               }
               self.appOpenAd = appOpenAd;
               self.appOpenAd.fullScreenContentDelegate = self;
             }];
}

- (BOOL)isAdAvailable {
  // Check if ad exists and can be shown.
  return self.appOpenAd != nil;
}

// ...

#pragma mark - GADFullScreenContentDelegate methods

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

- (void)adDidDismissFullScreenContent:(nonnull id<GADFullScreenPresentingAd>)ad {
  self.appOpenAd = nil;
  self.isShowingAd = NO;
  // Reload an ad.
  [self loadAd];
}

- (void)ad:(nonnull id<GADFullScreenPresentingAd>)ad
    didFailToPresentFullScreenContentWithError:(nonnull NSError *)error {
  self.appOpenAd = nil;
  self.isShowingAd = NO;
  // Reload an ad.
  [self loadAd];
}

@end

Prendre en compte l'expiration des annonces

Important : Les annonces à l'ouverture d'une application expirent au bout de quatre heures. Les annonces diffusées plus de quatre heures après l'heure de la demande ne seront plus valides et ne pourront pas générer de revenus.

Pour vous assurer de ne pas diffuser une annonce expirée, 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

class AppOpenAdManager: NSObject, FullScreenContentDelegate {
  var appOpenAd: AppOpenAd?
  var isLoadingAd = false.
  var isShowingAd = false
  var loadTime: Date?
  let fourHoursInSeconds = TimeInterval(3600 * 4)

  // ...

  private 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)")
    }
    isLoadingAd = false
  }

  private func wasLoadTimeLessThanFourHoursAgo() -> Bool {
    guard let loadTime = loadTime else { return false }
    // Check if ad was loaded more than four hours ago.
    return Date().timeIntervalSince(loadTime) < fourHoursInSeconds
  }

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

Objective-C

static NSTimeInterval const fourHoursInSeconds = 3600 * 4;

@interface AppOpenAdManager () <GADFullScreenContentDelegate>
@property(nonatomic, strong) GADAppOpenAd *appOpenAd
@property(nonatomic, assign) BOOL isLoadingAd;
@property(nonatomic, assign) BOOL isShowingAd;
@property(weak, nonatomic) NSDate *loadTime;

@end

@implementation AppOpenAdManager

// ...

- (void)loadAd {
  // Do not load ad if there is an unused ad or one is already loading.
  if (self.isLoadingAd || [self isAdAvailable]) {
    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(@"Failed to load app open ad: %@", error);
                 return;
               }
               self.appOpenAd = appOpenAd;
               self.appOpenAd.fullScreenContentDelegate = self;
               self.loadTime = [NSDate date];
             }];
}

- (BOOL)wasLoadTimeLessThanFourHoursAgo {
  // Check if ad was loaded more than four hours ago.
  return [[NSDate Date] timeIntervalSinceDate:self.loadTime] < fourHoursInSeconds;
}

- (BOOL)isAdAvailable {
  // Check if ad exists and can be shown.
  return self.appOpenAd != nil && [self wasLoadTimeLessThanFourHoursAgo];
}

@end

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.

Important : Pour continuer à charger les éléments de l'application pendant l'affichage de l'annonce à l'ouverture, vous devez toujours charger les éléments dans un thread d'arrière-plan.

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