Reklamy wyświetlane przy otwarciu aplikacji

Ten przewodnik jest przeznaczony dla wydawców, którzy chcą zintegrować reklamy wyświetlane przy otwarciu aplikacji.

Reklamy wyświetlane przy otwarciu aplikacji to specjalny format reklam przeznaczony dla wydawców, którzy chcą zarabiać na ekranach wczytywania aplikacji. Użytkownicy mogą w każdej chwili zamknąć reklamy wyświetlane przy otwarciu aplikacji. Reklamy wyświetlane przy otwarciu aplikacji mogą się wyświetlać, gdy użytkownicy przełączają aplikację na pierwszy plan.

Reklamy wyświetlane przy otwarciu aplikacji automatycznie wyświetlają nieduże pole z oznaczeniem marki, dzięki czemu użytkownicy wiedzą, że znajdują się w Twojej aplikacji. Oto przykład reklamy wyświetlanej przy otwarciu aplikacji:

Oto ogólny przegląd kroków wymaganych do wdrożenia reklam wyświetlanych przy otwarciu aplikacji:

Utwórz klasę menedżera, która wczytuje reklamę, zanim będzie trzeba ją wyświetlić.
Wyświetlaj reklamę podczas zdarzeń przełączania aplikacji na pierwszy plan.
Obsługuj wywołania zwrotne prezentacji.

Wymagania wstępne

Skonfiguruj Google Mobile Ads SDK.
Dowiedz się, jak skonfigurować urządzenie jako urządzenie testowe.

Zawsze testuj za pomocą reklam testowych

Podczas tworzenia i testowania aplikacji używaj reklam testowych, a nie reklam aktywnych. Jeśli tego nie zrobisz, Twoje konto może zostać zawieszone.

Najłatwiejszym sposobem na wczytanie reklam testowych jest użycie naszego specjalnego identyfikatora jednostki reklamowej testowej dla reklam wyświetlanych przy otwarciu aplikacji:

ca-app-pub-3940256099942544/5575463023

Został on specjalnie skonfigurowany tak, aby zwracać reklamy testowe w odpowiedzi na każde żądanie. Możesz go używać w swoich aplikacjach podczas kodowania, testowania i debugowania. Pamiętaj tylko, aby przed opublikowaniem aplikacji zastąpić go własnym identyfikatorem jednostki reklamowej.

Więcej informacji o tym, jak działają Google Mobile Ads SDK reklamy testowe, znajdziesz w artykule Test Ads.

Implementowanie klasy menedżera

Reklama powinna wyświetlać się szybko, dlatego najlepiej wczytać ją, zanim będzie trzeba ją wyświetlić. Dzięki temu będziesz mieć gotową reklamę, gdy tylko użytkownik otworzy Twoją aplikację. Zaimplementuj klasę menedżera, aby wysyłać żądania reklam przed wyświetleniem reklamy.

Utwórz nową klasę singleton o nazwie 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()AppOpenAdManager.swift

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;
}AppOpenAdManager.m

Zaimplementuj protokół 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)
}AppOpenAdManager.swift

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;
@endAppOpenAdManager.h

Wczytywanie reklamy

Następnym krokiem jest wczytanie reklamy wyświetlanej przy otwarciu aplikacji:

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
}AppOpenAdManager.swift

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];
  }];
}AppOpenAdManager.m

Wyświetlanie reklamy

Następnym krokiem jest wyświetlenie reklamy wyświetlanej przy otwarciu aplikacji. Jeśli żadna reklama nie jest dostępna, spróbuj wczytać nową.

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
  }
}AppOpenAdManager.swift

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;
}AppOpenAdManager.m

Wyświetlanie reklamy podczas zdarzeń przełączania aplikacji na pierwszy plan

Gdy aplikacja stanie się aktywna, wywołaj metodę showAdIfAvailable(), aby wyświetlić reklamę, jeśli jest dostępna, lub wczytać nową.

Swift

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

Objective-C

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

Obsługa wywołań zwrotnych prezentacji

Aby otrzymywać powiadomienia o zdarzeniach prezentacji, musisz przypisać GADFullScreenContentDelegate do właściwości `fullScreenContentDelegate` zwróconej reklamy:

Swift

appOpenAd?.fullScreenContentDelegate = selfAppOpenAdManager.swift

Objective-C

self.appOpenAd.fullScreenContentDelegate = self;AppOpenAdManager.m

W szczególności musisz poprosić o następną reklamę wyświetlaną przy otwarciu aplikacji, gdy pierwsza zakończy wyświetlanie. Poniższy kod pokazuje, jak zaimplementować protokół w pliku 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()
  }
}AppOpenAdManager.swift

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];
}AppOpenAdManager.m

Uwzględnianie czasu wygaśnięcia reklamy

Aby uniknąć wyświetlania wygasłych reklam, możesz dodać do delegata aplikacji metodę, która sprawdza czas, jaki upłynął od wczytania odniesienia do reklamy.

W AppOpenAdManager dodaj właściwość Date o nazwie loadTime i ustaw ją, gdy reklama się wczyta. Następnie możesz dodać metodę, która zwraca wartość true, jeśli od wczytania reklamy minęło mniej niż określona liczba godzin. Zanim spróbujesz wyświetlić reklamę, sprawdź, czy odniesienie do niej jest prawidłowe.

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)
}AppOpenAdManager.swift

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];
}AppOpenAdManager.m

Uruchamianie „na zimno” i ekrany wczytywania

W dokumentacji zakłada się, że reklamy wyświetlane przy otwarciu aplikacji są wyświetlane tylko wtedy, gdy użytkownicy przełączają aplikację na pierwszy plan, gdy jest ona zawieszona w pamięci. „Uruchamianie na zimno” występuje, gdy aplikacja jest uruchamiana, ale nie była wcześniej zawieszona w pamięci.

Przykładem uruchamiania na zimno jest sytuacja, gdy użytkownik otwiera aplikację po raz pierwszy. W przypadku uruchamiania na zimno nie będziesz mieć wcześniej wczytanej reklamy wyświetlanej przy otwarciu aplikacji, która jest gotowa do natychmiastowego wyświetlenia. Opóźnienie między wysłaniem żądania reklamy a otrzymaniem odpowiedzi może spowodować, że użytkownicy będą mogli przez chwilę korzystać z aplikacji, zanim zaskoczy ich reklama wyświetlona w nieodpowiednim kontekście. Należy tego unikać, ponieważ jest to złe doświadczenie użytkownika.

Preferowanym sposobem używania reklam wyświetlanych przy otwarciu aplikacji podczas uruchamiania „na zimno” jest użycie ekranu wczytywania do wczytania zasobów gry lub aplikacji i wyświetlania reklamy tylko na ekranie wczytywania. Jeśli aplikacja została wczytana i przekierowała użytkownika do głównej treści, nie wyświetlaj reklamy.

Sprawdzone metody

Reklamy wyświetlane przy otwarciu aplikacji zostały opracowane przez Google, aby pomóc Ci zarabiać na ekranie wczytywania aplikacji. Pamiętaj jednak o sprawdzonych metodach, aby użytkownicy mogli cieszyć się korzystaniem z Twojej aplikacji. Pamiętaj, aby:

poczekać z wyświetleniem pierwszej reklamy wyświetlanej przy otwarciu aplikacji, aż użytkownicy skorzystają z niej kilka razy;
wyświetlać reklamy wyświetlane przy otwarciu aplikacji w czasie, gdy użytkownicy czekają na wczytanie aplikacji;
jeśli ekran wczytywania znajduje się pod reklamą wyświetlaną przy otwarciu aplikacji i wczyta się przed zamknięciem reklamy, możesz go zamknąć, korzystając z metody adDidDismissFullScreenContent.

Pełny przykład na GitHubie

Swift Objective-C

Dalsze kroki

Dowiedz się więcej o prywatności użytkowników.

Reklamy wyświetlane przy otwarciu aplikacji Zadbaj o dobrą organizację dzięki kolekcji Zapisuj i kategoryzuj treści zgodnie ze swoimi preferencjami.

Wymagania wstępne

Zawsze testuj za pomocą reklam testowych

Implementowanie klasy menedżera

Swift

Objective-C

Swift

Objective-C

Wczytywanie reklamy

Swift

Objective-C

Wyświetlanie reklamy

Swift

Objective-C

Wyświetlanie reklamy podczas zdarzeń przełączania aplikacji na pierwszy plan

Swift

Objective-C

Obsługa wywołań zwrotnych prezentacji

Swift

Objective-C

Swift

Objective-C

Uwzględnianie czasu wygaśnięcia reklamy

Swift

Objective-C

Uruchamianie „na zimno” i ekrany wczytywania

Sprawdzone metody

Pełny przykład na GitHubie

Dalsze kroki

Reklamy wyświetlane przy otwarciu aplikacji