Reklamy wyświetlane przy otwarciu aplikacji

Ten przewodnik jest przeznaczony dla wydawców, którzy integrują 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 przenoszą aplikację na pierwszy plan.

Uwaga: konkretne formaty mogą się różnić w zależności od regionu.

Reklamy wyświetlane przy otwarciu aplikacji automatycznie wyświetlają mały obszar marki, dzięki czemu użytkownicy wiedzą, że wyświetlają się w Twojej aplikacji do aplikacji. Oto przykład, jak wygląda reklama wyświetlana przy otwarciu aplikacji:

Oto czynności, które należy wykonać, aby wdrożyć reklamy wyświetlane przy otwarciu aplikacji:

1. Utwórz klasę menedżera, która wczytuje reklamę, zanim trzeba będzie ją wyświetlić.
2. Pokazuj reklamę podczas zdarzeń na pierwszym planie aplikacji.
3. Obsługa wywołań zwrotnych prezentacji.

Wymagania wstępne

• Postępuj zgodnie z instrukcjami konfiguracji, które znajdziesz w artykule Pierwsze kroki. .
• Dowiedz się, jak skonfigurować urządzenie jako testowy urządzenia.

Zawsze korzystaj z reklam testowych

Podczas tworzenia i testowania aplikacji używaj reklam testowych, a nie reklam, aktywne reklamy. Jeśli tego nie zrobisz, możemy zawiesić Twoje konto.

Najłatwiejszym sposobem wczytywania reklam testowych jest użycie dedykowanego testowego identyfikatora jednostki reklamowej dla aplikacji otwieranie reklam:

/21775744923/example/app-open

Został on specjalnie skonfigurowany tak, aby wyświetlać reklamy testowe w odpowiedzi na każde żądanie. do wykorzystania we własnych aplikacjach przy kodowaniu, testowaniu i debugowaniu. Po prostu zrób zastąp go identyfikatorem jednostki reklamowej przed opublikowaniem aplikacji.

Więcej informacji o działaniu reklam testowych w pakiecie SDK do reklam mobilnych znajdziesz w artykule Testowanie Reklamy.

Wdrażanie zajęć menedżera

Twoja reklama powinna się szybko wyświetlać, więc najlepiej jest ją załadować, zanim trzeba będzie go wyświetlić. Dzięki temu reklama będzie gotowa do wyświetlenia, gdy tylko użytkownik wejdzie do niej do aplikacji. Zaimplementuj zajęcia menedżera, aby wysyłać żądania reklamy z wyprzedzeniem , aby wyświetlić reklamę.

Utwórz nową pojedynczą klasę o nazwie AppOpenAdManager i wypełnij ją jako następujące:

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

Wczytywanie reklamy

Następnym krokiem jest wypełnienie metody 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: "/21775744923/example/app-open", request: GAMRequest())
  } 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:@"/21775744923/example/app-open"
                       request:[GAMRequest 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;
             }];
}

Wyświetlanie reklamy

Następnym krokiem jest wypełnienie metody showAdIfAvailable(). Jeśli żadna reklama nie jest próbuje wczytać reklamę.

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

Wyświetlaj reklamę podczas zdarzeń na pierwszym planie aplikacji

Gdy aplikacja stanie się aktywna, wywołaj showAdIfAvailable(), aby wyświetlić reklamę, jeśli która jest dostępna lub wczytuje nowy.

Ważne: jeśli używasz Sceny, zastosuj sceneDidBecomeActive: w 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

Obsługa wywołań zwrotnych prezentacji

Przy wyświetlaniu reklamy wyświetlanej przy otwarciu aplikacji należy polegać GADFullScreenContentDelegate do obsługi określonych zdarzeń prezentacji. W warto wysyłać żądania kolejnej reklamy wyświetlanej przy otwarciu aplikacji, zakończy prezentację.

Do zajęć (AppOpenAdManager) dodaj:

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: "/21775744923/example/app-open", request: GAMRequest())
      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:@"/21775744923/example/app-open"
                       request:[GAMRequest 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

Weź pod uwagę czas wygaśnięcia reklamy

Ważne: reklamy wyświetlane przy otwarciu aplikacji przekroczą limit czasu po 4 godzinach. Reklamy renderowane ponad 4 godziny od momentu przesłania prośby utraci ważność i może nie generować przychodów.

Aby mieć pewność, że nie będzie wyświetlać wygasłej reklamy, możesz dodać metodę dla osoby, która przekazała Ci dostęp do aplikacji. który sprawdza czas, który upłynął od załadowania odwołania reklamy.

W tabeli AppOpenAdManager dodaj właściwość Date o nazwie loadTime i ustaw po wczytaniu reklamy. Następnie możesz dodać metodę, która zwraca true, jeśli upłynęło mniej niż pewną liczbę godzin od wczytania reklamy. Upewnij się, sprawdzasz poprawność odwołania do reklamy przed próbą jej wyświetlenia.

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: "/21775744923/example/app-open", request: GAMRequest())
      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:@"/21775744923/example/app-open"
                       request:[GAMRequest 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

Uruchomienia „na zimno” i ekrany wczytywania

W dokumentacji zakładamy, że reklamy wyświetlane przy otwarciu aplikacji wyświetlają się aplikacji na pierwszym planie, gdy jest zawieszona w pamięci. „Uruchomienia „na zimno” występują, gdy aplikacja została uruchomiona, ale nie była wcześniej zawieszona w pamięci.

Przykładem uruchomienia „na zimno” jest uruchomienie aplikacji przez użytkownika po raz pierwszy. W przypadku uruchomienia „na zimno” nie masz już wczytanej wcześniej reklamy wyświetlanej przy otwarciu aplikacji, będą widoczne od razu. Czas upływający między żądaniem reklamy a jej otrzymaniem może spowodować, że użytkownicy będą mogli przez krótki czas korzystać z aplikacji, że zaskoczyła Cię reklama wyręta z kontekstu. Należy tego unikać, ponieważ jest to co pogarsza wrażenia użytkowników.

Preferowany sposób wyświetlania reklam wyświetlanych przy otwarciu aplikacji przy uruchomieniach „na zimno” to użycie ekranu wczytywania. aby wczytać grę lub komponenty z linkiem do aplikacji i wyświetlać reklamę tylko ekranu. Jeśli aplikacja została wczytana i przekierowała użytkownika na stronę główną treści aplikacji, nie wyświetlaj reklamy.

Ważne: aby można było kontynuować ładowanie komponentów z linkiem do aplikacji podczas wyświetlane zasoby należy zawsze ładować w wątku w tle.

Sprawdzone metody

Firma Google stworzyła reklamy wyświetlane przy otwarciu aplikacji, aby pomóc Ci zarabiać na ekranie wczytywania aplikacji, ale ważne jest stosowanie sprawdzonych metod, aby użytkownicy byli zadowoleni do aplikacji. Wykonaj te czynności:

• Pierwsza reklama wyświetlana przy otwarciu aplikacji powinna być wyświetlana dopiero wtedy, gdy użytkownicy skorzystają ze kilka razy aplikację.
• Wyświetlaj reklamy wyświetlane przy otwarciu aplikacji w czasie, gdy użytkownicy na innych czekali , by Twoja aplikacja się załadowała.
• Jeśli pod reklamą wyświetlaną przy otwarciu aplikacji wyświetla się ekran wczytywania, zakończy się wczytywanie przed zamknięciem reklamy, możesz ekran wczytywania w metodzie adDidDismissFullScreenContent.

Kompletny przykład w GitHubie

Swift Objective-C

Dalsze kroki

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