Annonces à l'ouverture d'une application

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

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

Remarque :Un format spécifique peut varier selon les régions.

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 d'une application :

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

1. Créez une classe de gestion qui charge une annonce avant de devoir l'afficher.
2. Afficher l'annonce pendant les événements de mise en avant de l'application.
3. Gérer les rappels de présentation

Prérequis

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

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é aux annonces à l'ouverture d'une application:

ca-app-pub-3940256099942544/5575463023

Il a été spécialement configuré pour renvoyer des annonces de test pour chaque requête. Vous pouvez l'utiliser 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 gestion

Votre annonce doit s'afficher rapidement. Il est donc préférable de la charger avant que vous n'ayez besoin de la diffuser. Vous aurez ainsi une annonce prête à être diffusée dès que l'utilisateur accédera à votre application. Implémentez une classe de gestion pour envoyer des demandes d'annonces avant de devoir les diffuser.

Créez une classe singleton appelée AppOpenAdManager et renseignez-la comme suit :

Swift

class AppOpenAdManager: NSObject {
  var appOpenAd: GADAppOpenAd?
  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 GADAppOpenAd.load(
      withAdUnitID: "ca-app-pub-3940256099942544/5575463023", request: GADRequest())
  } 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;
             }];
}

Afficher une annonce

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

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(fromRootViewController: 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 pendant les événements de premier plan de l'application

Lorsque l'application devient active, appelez showAdIfAvailable() pour afficher une annonce si une 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 d'une application, vous devez vous appuyer sur GADFullScreenContentDelegate pour gérer certains événements de présentation. En particulier, vous devez demander la prochaine annonce à l'ouverture de l'application une fois que la première a pris fin.

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

Swift

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

  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 GADAppOpenAd.load(
        withAdUnitID: "ca-app-pub-3940256099942544/5575463023", request: GADRequest())
      appOpenAd?.fullScreenContentDelegate = self
    } catch {
      print("App open ad failed to load with error: \(error.localizedDescription)")
    }
    isLoadingAd = false
  }

  // ...

  // MARK: - GADFullScreenContentDelegate methods

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

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

  func ad(
    _ ad: GADFullScreenPresentingAd,
    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 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 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 votre référence d'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 la diffuser.

Swift

class AppOpenAdManager: NSObject, GADFullScreenContentDelegate {
  var appOpenAd: GADAppOpenAd?
  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 GADAppOpenAd.load(
        withAdUnitID: "ca-app-pub-3940256099942544/5575463023", request: GADRequest())
      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 ne diffusez des annonces à l'ouverture d'une application que lorsque les utilisateurs mettent votre application au premier plan lorsqu'elle est suspendue en mémoire. Les "démarrages à froid" se produisent lorsque votre application est lancée, mais qu'elle n'a pas été suspendue en mémoire auparavant.

Un exemple de démarrage à froid est lorsqu'un utilisateur ouvre votre application pour la première fois. Avec les démarrages à froid, vous n'aurez pas d'annonce d'ouverture d'application précédemment chargée prête à être diffusée immédiatement. Le délai entre le moment où vous demandez une annonce et celui où vous recevez une réponse peut empêcher les utilisateurs d'utiliser brièvement votre application avant d'être surpris par une annonce hors contexte. Cette pratique doit être évitée, car elle constitue une mauvaise expérience utilisateur.

La meilleure façon d'utiliser les annonces à l'ouverture d'une application lors des démarrages à froid consiste à utiliser un écran de chargement pour charger les composants de votre jeu ou de votre application, et à n'afficher l'annonce que depuis l'écran de chargement. Si le chargement de votre application est terminé et qu'elle a redirigé l'utilisateur vers le contenu principal, n'affichez pas l'annonce.

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

Bonnes pratiques

Google a conçu les annonces à l'ouverture d'une 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 aient plaisir à utiliser votre application. Assurez-vous d'effectuer les opérations suivantes:

• Attendez que les utilisateurs aient ouvert votre application quelques fois avant de diffuser votre première annonce à l'ouverture.
• Diffuser des annonces à l'ouverture de l'application lorsque vos utilisateurs attendent que votre application 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