Reklamy pełnoekranowe

Reklamy pełnoekranowe zajmują cały ekran aplikacji, dopóki użytkownik ich nie zamknie. Takie reklamy wyświetlają się zwykle w naturalnych momentach przejściowych w aplikacji, np. między działaniami lub podczas przerwy między poziomami gry. Gdy aplikacja wyświetla reklamę pełnoekranową, użytkownik może ją kliknąć, aby przejść do miejsca docelowego, lub zamknąć i wrócić do aplikacji. Przykład.

Z tego przewodnika dowiesz się, jak zintegrować reklamy pełnoekranowe z aplikacją na iOS.

Wymagania wstępne

• Pakiet SDK do reklam mobilnych Google w wersji 8.0.0 lub nowszej.
• Zapoznaj się z przewodnikiem dla początkujących.

Zawsze testuj reklamy za pomocą reklam testowych

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

Najłatwiejszym sposobem wczytywania reklam testowych jest użycie dedykowanego identyfikatora testowej jednostki reklamowej na potrzeby reklam przejściowych na iOS:
/21775744923/example/interstitial

Jest 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 własnym identyfikatorem jednostki reklamowej.

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

Implementacja

Oto główne kroki, które należy wykonać, aby zintegrować reklamy pełnoekranowe:

1. Wczytaj reklamę.
2. Rejestrowanie wywołań zwrotnych.
3. wyświetlić reklamę,

Wczytywanie reklamy

Ładowanie reklamy odbywa się za pomocą metody load(adUnitID:request) w klasie GAMInterstitialAd.

Swift

import GoogleMobileAds
import UIKit

class ViewController: UIViewController {

  private var interstitial: GAMInterstitialAd?

  override func viewDidLoad() {
    super.viewDidLoad()

    Task {
      do {
        interstitial = try await GAMInterstitialAd.load(
          withAdUnitID: "/21775744923/example/interstitial", request: GAMRequest())
      } catch {
        print("Failed to load interstitial ad with error: \(error.localizedDescription)")
      }
    }
  }
}

SwiftUI

import GoogleMobileAds

class InterstitialViewModel: NSObject, GADFullScreenContentDelegate {
  private var interstitialAd: GADInterstitialAd?

  func loadAd() async {
    do {
      interstitialAd = try await GADInterstitialAd.load(
        withAdUnitID: "ca-app-pub-3940256099942544/4411468910", request: GADRequest())
      interstitialAd?.fullScreenContentDelegate = self
    } catch {
      print("Failed to load interstitial ad with error: \(error.localizedDescription)")
    }
  }
InterstitialViewModel.swift

Objective-C

@import GoogleMobileAds;
@import UIKit;

@interface ViewController ()

@property(nonatomic, strong) GAMInterstitialAd *interstitial;

@end

@implementation ViewController

- (void)viewDidLoad {
  [super viewDidLoad];
  GAMRequest *request = [GAMRequest request];
  [GAMInterstitialAd loadWithAdManagerAdUnitID:@"/21775744923/example/interstitial"
      request:request
      completionHandler:^(GAMInterstitialAd *ad, NSError *error) {
    if (error) {
      NSLog(@"Failed to load interstitial ad with error: %@", [error localizedDescription]);
      return;
    }
    self.interstitial = ad;
  }];
}

Wskazówka: przed wyświetleniem reklam możesz użyć wywołań wczytywania reklam, aby utworzyć pamięć podręczną z wstępnie załadowanymi reklamami. Dzięki temu w razie potrzeby reklamy będą mogły być wyświetlane bez opóźnień. Reklamy tracą ważność po godzinie, dlatego co godzinę należy wyczyścić pamięć podręczną i załadować nowe reklamy.

Rejestrowanie wywołań zwrotnych

Aby otrzymywać powiadomienia o zdarzeniach związanych z prezentacją, musisz zaimplementować protokół GADFullScreenContentDelegate i przypisać go do właściwości fullScreenContentDelegate zwracanej reklamy. Protokół GADFullScreenContentDelegate obsługuje wywołania zwrotne w przypadku wyświetlenia reklamy (udanego lub nieudanego) oraz jej odrzucenia. Poniższy kod pokazuje, jak zastosować protokół i przypisać go do reklamy:

Swift

import GoogleMobileAds
import UIKit

class ViewController: UIViewController, GADFullScreenContentDelegate {

  private var interstitial: GAMInterstitialAd?

  override func viewDidLoad() {
    super.viewDidLoad()

    Task {
      do {
        interstitial = try await GAMInterstitialAd.load(
          withAdUnitID: "/21775744923/example/interstitial", request: GAMRequest())
        interstitial?.fullScreenContentDelegate = self
      } catch {
        print("Failed to load interstitial ad with error: \(error.localizedDescription)")
      }
    }
  }

  /// Tells the delegate that the ad failed to present full screen content.
  func ad(_ ad: GADFullScreenPresentingAd, didFailToPresentFullScreenContentWithError error: Error) {
    print("Ad did fail to present full screen content.")
  }

  /// Tells the delegate that the ad will present full screen content.
  func adWillPresentFullScreenContent(_ ad: GADFullScreenPresentingAd) {
    print("Ad will present full screen content.")
  }

  /// Tells the delegate that the ad dismissed full screen content.
  func adDidDismissFullScreenContent(_ ad: GADFullScreenPresentingAd) {
    print("Ad did dismiss full screen content.")
  }
}

SwiftUI

Przypisz do zwróconej reklamy właściwość fullScreenContentDelegate:

interstitialAd?.fullScreenContentDelegate = self
InterstitialViewModel.swift

Wdrożenie protokołu:

func adDidRecordImpression(_ ad: GADFullScreenPresentingAd) {
  print("\(#function) called")
}

func adDidRecordClick(_ ad: GADFullScreenPresentingAd) {
  print("\(#function) called")
}

func ad(
  _ ad: GADFullScreenPresentingAd,
  didFailToPresentFullScreenContentWithError error: Error
) {
  print("\(#function) called")
}

func adWillPresentFullScreenContent(_ ad: GADFullScreenPresentingAd) {
  print("\(#function) called")
}

func adWillDismissFullScreenContent(_ ad: GADFullScreenPresentingAd) {
  print("\(#function) called")
}

func adDidDismissFullScreenContent(_ ad: GADFullScreenPresentingAd) {
  print("\(#function) called")
  // Clear the interstitial ad.
  interstitialAd = nil
}
InterstitialViewModel.swift

Objective-C

@import GoogleMobileAds;
@import UIKit;

@interface ViewController () <GADFullScreenContentDelegate>

@property(nonatomic, strong) GAMInterstitialAd *interstitial;

@end

@implementation ViewController

- (void)viewDidLoad {
  [super viewDidLoad];
  GAMRequest *request = [GAMRequest request];
  [GAMInterstitialAd loadWithAdManagerAdUnitID:@"/21775744923/example/interstitial"
      request:request
      completionHandler:^(GAMInterstitialAd *ad, NSError *error) {
    if (error) {
      NSLog(@"Failed to load interstitial ad with error: %@", [error localizedDescription]);
      return;
    }
    self.interstitial = ad;
    self.interstitial.fullScreenContentDelegate = self;
  }];
}

/// Tells the delegate that the ad failed to present full screen content.
- (void)ad:(nonnull id<GADFullScreenPresentingAd>)ad
didFailToPresentFullScreenContentWithError:(nonnull NSError *)error {
    NSLog(@"Ad did fail to present full screen content.");
}

/// Tells the delegate that the ad will present full screen content.
- (void)adWillPresentFullScreenContent:(nonnull id<GADFullScreenPresentingAd>)ad {
    NSLog(@"Ad will present full screen content.");
}

/// Tells the delegate that the ad dismissed full screen content.
- (void)adDidDismissFullScreenContent:(nonnull id<GADFullScreenPresentingAd>)ad {
  NSLog(@"Ad did dismiss full screen content.");
}

GAMInterstitialAd to obiekt jednorazowego użytku. Oznacza to, że po wyświetleniu reklamy pełnoekranowej nie można jej wyświetlić ponownie. Najlepszym rozwiązaniem jest wczytywanie kolejnej reklamy pełnoekranowej w metodie adDidDismissFullScreenContent: w GADFullScreenContentDelegate, aby następna reklama pełnoekranowa zaczęła się wczytywać, gdy tylko zamkniesz poprzednią.

Wyświetlanie reklamy

Reklamy pełnoekranowe powinny wyświetlać się w naturalnych przerwach w aplikacji. Dobrym przykładem jest przerwa między poziomami w grze lub po wykonaniu zadania przez użytkownika.

Swift

guard let interstitial = interstitial else {
  return print("Ad wasn't ready.")
}

// The UIViewController parameter is an optional.
interstitial.present(fromRootViewController: nil)

SwiftUI

Odbieraj zdarzenia interfejsu użytkownika w widoku, aby określić, kiedy wyświetlić reklamę.

var body: some View {
  // ...
  }
  .onChange(of: countdownTimer.isComplete) { newValue in
    showGameOverAlert = newValue
  }
  .alert(isPresented: $showGameOverAlert) {
    Alert(
      title: Text("Game Over"),
      message: Text("You lasted \(countdownTimer.countdownTime) seconds"),
      dismissButton: .cancel(
        Text("OK"),
        action: {
          viewModel.showAd()
        }))
InterstitialContentView.swift

Wyświetl reklamę pełnoekranową z poziomu widoku:

func showAd() {
  guard let interstitialAd = interstitialAd else {
    return print("Ad wasn't ready.")
  }

  interstitialAd.present(fromRootViewController: nil)
}
InterstitialViewModel.swift

Objective-C

if (self.interstitial) {
  // The UIViewController parameter is nullable.
  [self.interstitial presentFromRootViewController:nil];
} else {
  NSLog(@"Ad wasn't ready");
}

Sprawdzone metody

Zastanów się, czy reklamy pełnoekranowe są odpowiednim typem reklamy dla Twojej aplikacji.

Reklamy pełnoekranowe działają najlepiej w aplikacjach, w których występują naturalne punkty przejścia. Taki punkt może powstać na przykład po zakończeniu zadania w aplikacji, takiego jak udostępnienie zdjęcia lub ukończenie poziomu gry. Użytkownik spodziewa się przerwy w działaniu, więc łatwo jest wyświetlić reklamę pełnoekranową bez zakłócania jego doświadczeń. Zastanów się, w jakich momentach w przebiegu aplikacji wyświetlać reklamy pełnoekranowe i jak użytkownik prawdopodobnie na nie zareaguje.

Pamiętaj, aby wstrzymać działanie podczas wyświetlania reklamy pełnoekranowej.

Dostępne są różne typy reklam pełnoekranowych: tekstowe, graficzne, wideo i inne. Pamiętaj, aby podczas wyświetlania przez aplikację reklamy interaktywnej wstrzymywać korzystanie z niektórych zasobów, aby reklama mogła z nich korzystać. Jeśli na przykład wywołasz wyświetlanie reklamy interaktywnej, zatrzymaj wszelkie dźwięki generowane przez aplikację. Możesz wznowić odtwarzanie dźwięku w obiekcie adDidDismissFullScreenContent:, który zostanie wywołany, gdy użytkownik zakończy interakcję z reklamą. Dodatkowo rozważ tymczasowe wstrzymanie intensywnych obliczeń (np. pętli gry) podczas wyświetlania reklamy. Dzięki temu użytkownik nie będzie mieć problemów z powolnym działaniem grafiki lub z zawieszaniem się filmu.

Zaplanuj odpowiedni czas wczytywania.

Podobnie jak w przypadku reklam pełnoekranowych ważne jest, aby wyświetlać je w odpowiednim momencie, ale też trzeba pamiętać, aby użytkownik nie musiał czekać na ich załadowanie. Wczytanie reklamy z wyprzedzeniem, zanim zamierzasz ją wyświetlić, może zapewnić, że w momencie wyświetlenia reklamy w Twojej aplikacji będzie ona w pełni załadowana.

Nie zalewaj użytkownika reklamami.

Chociaż zwiększanie częstotliwości wyświetlania reklam pełnekranowych w aplikacji może wydawać się świetnym sposobem na zwiększenie przychodów, może też pogorszyć wrażenia użytkowników i obniżyć współczynnik klikalności. Zadbaj o to, aby użytkownicy nie byli zbyt często przerywane, ponieważ uniemożliwia im to korzystanie z aplikacji.

Nie używaj wywołania zwrotnego po zakończeniu wczytywania, aby wyświetlić reklamę pełnoekranową.

Może to spowodować niewygodę użytkowników. Zamiast tego pobierz reklamę z wyprzedzeniem, zanim będzie trzeba ją wyświetlić. Następnie sprawdź metodę canPresentFromRootViewController:error: w GAMInterstitialAd, aby dowiedzieć się, czy jest ona gotowa do wyświetlenia.

Przykłady w GitHub

Wyświetl pełne przykłady reklam pełnoekranowych w wybranym języku:

• Swift
• SwiftUI
• Objective-C

Dalsze kroki

• Dowiedz się więcej o kierowaniu reklam i wytycznych dotyczących banerów na całą stronę.
• Dowiedz się więcej o prywatności użytkowników.