Anúncios de abertura do app

Selecione a plataforma: Android iOS Unity Flutter

Este guia é destinado aos publishers que integram anúncios de abertura do app.

Os anúncios de abertura do app são um formato especial destinado a publishers que querem gerar receita com as telas de carregamento. Eles podem ser fechados pelos usuários a qualquer momento e podem ser mostrados quando os usuários trazem seu app para o primeiro plano.

Observação: o formato específico varia de acordo com a região.

Os anúncios nesse formato mostram automaticamente uma pequena área de branding para que as pessoas saibam que estão no seu app. Eles aparecem assim:

Em geral, estas são as etapas necessárias para implementar anúncios de abertura do app:

1. Crie uma classe de gerenciamento que carregue um anúncio antes que ele precise aparecer.
2. Mostre o anúncio durante os eventos de primeiro plano do app.
3. Processe os callbacks de apresentação.

Pré-requisitos

• Siga as instruções de configuração no nosso guia para iniciantes.
• Saiba como configurar seu aparelho como um dispositivo de teste.

Sempre usar anúncios de teste

Ao criar e testar seus apps, use anúncios de teste em vez de anúncios de produção ativos. Caso contrário, sua conta poderá ser suspensa.

A maneira mais fácil de carregar anúncios de teste é usar nosso ID de bloco de anúncios de teste dedicado para anúncios de abertura do app:

/21775744923/example/app-open

Eles foram configurados especialmente para retornar anúncios de teste em todas as solicitações, e você pode usá-los nos seus próprios apps durante a programação, os testes e a depuração. Só não se esqueça de substituí-lo pelo ID do seu bloco de anúncios antes de publicar o app.

Para mais informações sobre como os anúncios de teste do SDK para dispositivos móveis funcionam, consulte Anúncios de teste.

Implementar uma classe de gerenciamento

Como o anúncio precisa aparecer rápido, é melhor carregá-lo com antecedência. Assim, você terá um anúncio pronto para ser veiculado quando o usuário entrar no app. Implemente uma classe de gerenciamento para fazer solicitações antes de precisar exibir um anúncio.

Crie uma nova classe singleton chamada 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/admanager/answer/9351867
  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/admanager/answer/9351867
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

Implemente o protocolo 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;
@end
AppOpenAdManager.h

Carregar um anúncio

A próxima etapa é carregar um anúncio de abertura do app:

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

Mostrar um anúncio

A próxima etapa é mostrar um anúncio de abertura de app. Se nenhum anúncio estiver disponível, tente carregar um novo.

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 {
    print("App open ad will be displayed.")
    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

Mostrar o anúncio durante eventos em primeiro plano do app

Quando o aplicativo é ativado, chame showAdIfAvailable() para mostrar um anúncio, se disponível, ou carregue um novo.

Importante: se você usar o recurso Scenes, implemente o método sceneDidBecomeActive: no seu UISceneDelegate.

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

Processar callbacks de apresentação

Para receber notificações sobre eventos de apresentação, atribua GADFullScreenContentDelegate à propriedade "fullScreenContentDelegate" do anúncio retornado:

Swift

appOpenAd?.fullScreenContentDelegate = self
AppOpenAdManager.swift

Objective-C

self.appOpenAd.fullScreenContentDelegate = self;
AppOpenAdManager.m

Especificamente, solicite o próximo anúncio de abertura do app assim que o primeiro terminar de ser apresentado. O código a seguir mostra como implementar o protocolo no arquivo 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

Considerar a validade dos anúncios

Importante: os anúncios de abertura do app expiram após quatro horas. Os anúncios renderizados mais de quatro horas após o momento da solicitação não são mais válidos nem geram receita.

Para não veicular uma publicidade expirada, adicione um método ao delegado do app que verifique o tempo decorrido desde que a referência foi carregada.

No AppOpenAdManager, adicione uma propriedade Date chamada loadTime e defina essa propriedade quando o anúncio for carregado. Em seguida, adicione um método que retorne true se menos de um determinado número de horas tiverem passado desde o carregamento. Confira a validade da referência do anúncio antes de tentar mostrá-lo.

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 self.appOpenAd && [self wasLoadTimeLessThanNHoursAgo:kTimeoutInterval];
}
AppOpenAdManager.m

Inicializações a frio e telas de carregamento

A documentação pressupõe que você só mostra anúncios de abertura quando os usuários colocam o app em primeiro plano enquanto ele está suspenso na memória. As inicializações a frio ocorrem quando o app é iniciado sem estar suspenso.

Um exemplo disso é quando um usuário abre seu app pela primeira vez. Com esse tipo de inicialização, não existe um anúncio de abertura do app carregado pronto para ser mostrado imediatamente. A demora entre a solicitação de um anúncio e o recebimento dele poderá criar uma situação em que os usuários conseguem usar seu app brevemente antes de serem surpreendidos por um anúncio fora de contexto. Evite essa experiência ruim do usuário.

A melhor maneira de usar anúncios de abertura do app em inicializações a frio é ter uma tela de carregamento para abrir os recursos do jogo ou app e mostrar o anúncio apenas nessa tela. Se o app terminar de carregar e direcionar o usuário para o conteúdo principal, não mostre o anúncio.

Importante: para continuar carregando recursos do app enquanto o anúncio de abertura está sendo exibido, sempre faça isso em uma linha de execução de segundo plano.

Práticas recomendadas

O Google criou os anúncios de abertura do app para ajudar você a monetizar a tela de carregamento, mas é importante seguir as práticas recomendadas para que os usuários gostem de usar seu aplicativo. Não se esqueça de:

• Só mostrar o primeiro anúncio de abertura depois que os usuários tenham utilizado seu app algumas vezes.
• Mostrar esses anúncios enquanto os usuários estão esperando o carregamento do app.
• Se o carregamento da tela abaixo do anúncio de abertura do app terminar antes que o anúncio seja dispensado, convém dispensar essa tela no método adDidDismissFullScreenContent.

Exemplo completo no GitHub

Swift Objective-C

Próximas etapas

Saiba mais sobre a privacidade do usuário.