App-Start-Anzeigen

Dieser Leitfaden richtet sich an Publisher, die App-Start-Anzeigen integrieren.

App-Start-Anzeigen sind ein spezielles Anzeigenformat für Publisher, App-Ladebildschirme. App-Start-Anzeigen können jederzeit von Ihren Nutzern geschlossen werden. App-Start-Anzeigen können ausgeliefert werden, wenn Nutzer Ihre App im Vordergrund zeigen.

Bei App-Start-Anzeigen wird automatisch ein kleiner Markenbereich eingeblendet, damit Nutzer wissen, dass sie sich für Ihre App. Hier sehen Sie ein Beispiel für eine App-Start-Anzeige:

Folgende Schritte sind erforderlich, um App-Start-Anzeigen zu implementieren:

  1. Erstellen Sie eine Manager-Klasse, mit der eine Anzeige geladen wird, bevor Sie sie einblenden müssen.
  2. Anzeige bei App-Vordergrund-Ereignissen anzeigen
  3. Präsentations-Callbacks verarbeiten

Vorbereitung

Immer mit Testanzeigen testen

Verwenden Sie beim Entwickeln und Testen Ihrer Apps nur Testanzeigen, Live-Produktionsanzeigen. Andernfalls kann Ihr Konto gesperrt werden.

Am einfachsten lassen sich Testanzeigen mit unserer Testanzeigenblock-ID für Apps laden. Anzeigen öffnen:

ca-app-pub-3940256099942544/5575463023

Sie wurde speziell so konfiguriert, dass bei jeder Anfrage Testanzeigen zurückgegeben werden. können Sie es beim Programmieren, Testen und Debuggen in Ihren eigenen Apps verwenden. Machen Sie einfach ersetzen Sie sie vor dem Veröffentlichen Ihrer App durch Ihre Anzeigenblock-ID.

Weitere Informationen zur Funktionsweise von Testanzeigen des Mobile Ads SDK finden Sie unter Test Anzeigen:

Managerklasse implementieren

Ihre Anzeige sollte schnell ausgeliefert werden. Laden Sie sie daher am besten schon, bevor sie ausgeliefert werden soll. So haben Sie eine Anzeige, die sofort ausgeliefert werden kann, für Ihre App. Manager-Klasse implementieren, um bei Bedarf Anzeigenanfragen im Voraus zu senden damit die Anzeige ausgeliefert wird.

Erstellen Sie eine neue Singleton-Klasse mit dem Namen AppOpenAdManager und füllen Sie sie so aus: folgt:

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

Anzeige laden

Im nächsten Schritt füllen Sie die Methode loadAd() aus.

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;
             }];
}

Anzeige einblenden

Im nächsten Schritt füllen Sie die Methode showAdIfAvailable() aus. Wenn keine Anzeige versucht die Methode, eine Anzeige zu laden.

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];
}

Anzeige bei App-Vordergrund-Ereignissen ausliefern

Wenn die Anwendung aktiv wird, rufen Sie showAdIfAvailable() auf, um eine Anzeige zu schalten, wenn eine verfügbar ist oder lädt eine neue.

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

Präsentations-Callbacks verarbeiten

Wenn in Ihrer App eine App-Start-Anzeige eingeblendet wird, sollten Sie sich auf die GADFullScreenContentDelegate zur Verarbeitung bestimmter Präsentationsereignisse. In muss die nächste App-Start-Anzeige angefordert werden, sobald die Präsentation beendet.

Fügen Sie in Ihrem AppOpenAdManager-Kurs Folgendes hinzu:

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

Ablauf von Anzeigen berücksichtigen

Damit keine abgelaufenen Anzeigen ausgeliefert werden, können Sie dem App-Bevollmächtigten eine Methode hinzufügen. zur Überprüfung der seit dem Laden der Anzeigenreferenz verstrichenen Zeit.

Fügen Sie in AppOpenAdManager die Date-Property loadTime hinzu und legen Sie Property beim Laden Ihrer Anzeige. Sie können dann eine Methode hinzufügen, die true zurückgibt, wenn Seit dem Laden der Anzeige sind weniger als eine bestimmte Anzahl von Stunden vergangen. Achten Sie darauf, Sie prüfen die Gültigkeit des Anzeigenverweises, bevor Sie versuchen, die Anzeige zu schalten.

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

Kaltstarts und Ladebildschirme

In der Dokumentation wird davon ausgegangen, dass App-Start-Anzeigen nur ausgeliefert werden, wenn Nutzer App im Vordergrund ausführen, wenn sie im Arbeitsspeicher ausgesetzt wird. „Kaltstarts“ treten auf, wenn Ihre App wurde gestartet, aber zuvor nicht im Arbeitsspeicher gesperrt.

Ein Beispiel für einen Kaltstart ist, wenn ein Nutzer Ihre App zum ersten Mal öffnet. Bei Kaltstarts gibt es keine bereits geladene App-Start-Anzeige, die sofort geschaltet werden. Die Verzögerung zwischen der Anzeigenanfrage und dem Erhalt der Anzeige kann dazu führen, dass Nutzende Ihre App kurz verwenden können, wenn sie von einer Anzeige überrascht werden, die außerhalb des Kontexts liegt. Dies sollte vermieden werden, schlechte User Experience ausmacht.

App-Start-Anzeigen werden bei Kaltstarts vorzugsweise mit einem Ladebildschirm eingesetzt. Ihre Spiel- oder App-Assets zu laden und die Anzeige nur Bildschirm. Wenn der Ladevorgang Ihrer App abgeschlossen ist und der Nutzer zur Hauptseite weitergeleitet wurde: App-Content enthält, zeigen Sie die Anzeige nicht.

Best Practices

Google hat App-Start-Anzeigen erstellt, damit Sie den Ladebildschirm Ihrer App monetarisieren können. sollten Sie die Best Practices im Hinterkopf behalten, damit Ihre Nutzenden für Ihre App. Gehen Sie dabei so vor:

  • Mit der Auslieferung Ihrer ersten App-Start-Anzeige warten Sie, bis Nutzer Ihre ein paar Mal die App herunter.
  • App-Start-Anzeigen zu Zeiten ausliefern, in denen die Nutzer sonst warten würden bis Ihre App geladen ist.
  • Wenn unter der App-Start-Anzeige und der Ladebildschirm vor dem Schließen der Anzeige abgeschlossen ist, sollten Sie Ladebildschirms in der Methode adDidDismissFullScreenContent.

Vollständiges Beispiel auf GitHub

Swift Objective-C

Nächste Schritte

Weitere Informationen zum Datenschutz für Nutzer