Ten przewodnik jest przeznaczony dla wydawców, którzy wdrażają 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. Reklamy wyświetlane przy otwarciu aplikacji mogą być w każdej chwili zamykane przez użytkowników. Reklamy wyświetlane przy otwarciu aplikacji mogą się pojawiać, gdy użytkownicy przenoszą 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ń przejścia aplikacji na pierwszy plan.
- Obsługa wywołań zwrotnych prezentacji.
Wymagania wstępne
- Postępuj zgodnie z instrukcjami konfiguracji, które znajdziesz w naszym przewodniku dla początkujących.
- Wiedzieć, jak skonfigurować urządzenie jako urządzenie testowe.
Zawsze testuj za pomocą reklam testowych
Podczas tworzenia i testowania aplikacji używaj reklam testowych zamiast reklam produkcyjnych. Jeśli tego nie zrobisz, Twoje konto może zostać zawieszone.
Najłatwiejszym sposobem wczytywania reklam testowych jest użycie specjalnego identyfikatora jednostki reklamowej testowej w przypadku reklam otwierających aplikację:
ca-app-pub-3940256099942544/5575463023
Został on specjalnie skonfigurowany tak, aby zwracać reklamy testowe w przypadku każdego żądania. Możesz go używać w swoich aplikacjach podczas kodowania, testowania i debugowania. Pamiętaj tylko, aby przed opublikowaniem aplikacji zastąpić go identyfikatorem swojej jednostki reklamowej.
Więcej informacji o działaniu reklam testowych w pakiecie SDK do reklam mobilnych znajdziesz w artykule Reklamy testowe.
Implementowanie klasy menedżera
Reklama powinna wyświetlać się szybko, dlatego najlepiej jest ją wczytać, zanim będzie potrzebna. Dzięki temu reklama będzie gotowa do wyświetlenia, gdy tylko użytkownik otworzy Twoją aplikację. Wdróż klasę menedżera, aby wysyłać żądania reklam przed momentem, w którym chcesz je wyświetlić.
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()
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;
}
i wdrożyć 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)
}
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;
@end
Wczytywanie reklamy
Następny krok to 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
}
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];
}];
}
Wyświetlanie reklamy
Następnym krokiem jest wyświetlenie reklamy 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
}
}
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;
}
Wyświetlanie reklamy podczas zdarzeń przeniesienia aplikacji na pierwszy plan
Gdy aplikacja stanie się aktywna, wywołaj funkcję 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()
}
Objective-C
- (void) applicationDidBecomeActive:(UIApplication *)application {
// Show the app open ad when the app is foregrounded.
[AppOpenAdManager.sharedInstance showAdIfAvailable];
}
Obsługa wywołań zwrotnych prezentacji
Aby otrzymywać powiadomienia o wydarzeniach związanych z prezentacją, musisz przypisać obiekt GADFullScreenContentDelegate do właściwości fullScreenContentDelegate zwróconej reklamy:
Swift
appOpenAd?.fullScreenContentDelegate = self
Objective-C
self.appOpenAd.fullScreenContentDelegate = self;
W szczególności musisz wysłać żądanie następnej reklamy wyświetlanej przy otwarciu aplikacji, gdy pierwsza zakończy wyświetlanie. Poniższy kod pokazuje, jak wdrożyć 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()
}
}
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];
}
Uwzględnij czas 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 odwołania do reklamy.
W AppOpenAdManager dodaj właściwość Date o nazwie loadTime i ustaw ją, gdy reklama się załaduje. 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 jej odwołanie 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)
}
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];
}
Uruchamianie „na zimno” i ekrany wczytywania
Dokumentacja zakłada, że reklamy wyświetlane przy otwarciu aplikacji są wyświetlane tylko wtedy, gdy użytkownicy przywracają aplikację do pierwszego planu, gdy jest ona zawieszona w pamięci. „Uruchomienia na zimno” występują, gdy aplikacja jest uruchamiana, ale nie została wcześniej zawieszona w pamięci.
Przykładem uruchomienia „na zimno” jest sytuacja, gdy użytkownik otwiera aplikację po raz pierwszy. W przypadku uruchamiania „na zimno” nie masz 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 bez kontekstu. Należy tego unikać, ponieważ negatywnie wpływa to na wrażenia użytkowników.
Najlepszym sposobem na używanie reklam wyświetlanych przy otwarciu aplikacji podczas uruchamiania „na zimno” jest użycie ekranu wczytywania do wczytania zasobów gry lub aplikacji i wyświetlanie reklamy tylko na tym ekranie. Jeśli aplikacja została wczytana i użytkownik został przekierowany do głównej treści aplikacji, nie wyświetlaj reklamy.
Sprawdzone metody
Reklamy wyświetlane przy otwarciu aplikacji zostały stworzone przez Google, aby pomóc Ci zarabiać na ekranie wczytywania aplikacji. Pamiętaj jednak o sprawdzonych metodach, dzięki którym użytkownicy będą chętnie korzystać z Twojej aplikacji. Zadbaj o to, aby:
- Poczekaj z wyświetleniem pierwszej reklamy przy otwarciu aplikacji, aż użytkownicy kilka razy skorzystają z Twojej aplikacji.
- Wyświetlaj 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 w GitHubie
Dalsze kroki
Dowiedz się więcej o prywatności użytkowników.