Anuncios para inicio de aplicación

Selecciona la plataforma: Android iOS Unity Flutter

Esta guía está dirigida a los publicadores que integran anuncios para inicio de aplicación.

Los anuncios para inicio de aplicación son un formato de anuncio especial diseñado para los publicadores que quieren monetizar las pantallas de carga de sus apps. Los usuarios pueden cerrarlos en cualquier momento y pueden verlos cuando ponen la app en primer plano.

Los anuncios para inicio de aplicación muestran automáticamente un área pequeña de desarrollo de la marca para que los usuarios sepan que están en tu app. A continuación, se muestra un ejemplo de cómo se ve un anuncio para inicio de aplicación:

A grandes rasgos, estos son los pasos necesarios para implementar anuncios para inicio de aplicación:

  1. Crear una clase de administrador que cargue un anuncio antes de que necesites mostrarlo
  2. Mostrar el anuncio durante los eventos en primer plano de la app
  3. Controlar las devoluciones de llamada de la presentación

Requisitos previos

Haz siempre una comprobación con anuncios de prueba

Al compilar y verificar tus apps, asegúrate de usar anuncios de prueba en vez de anuncios activos en fase de producción. De lo contrario, se podría suspender tu cuenta.

La forma más sencilla de cargar anuncios de prueba es usar nuestro ID de unidad de anuncios de prueba exclusivo para los anuncios para inicio de aplicación:

ca-app-pub-3940256099942544/5575463023

Está configurado especialmente para devolver anuncios de prueba en cada solicitud, y puedes usarlo en tus propias apps durante las tareas de programación, prueba y depuración. Solo asegúrate de reemplazarlo por tu propio ID de unidad de anuncios antes de publicar la app.

Consulta la página Habilita los anuncios de prueba para obtener más información sobre cómo funcionan esos anuncios del SDK de anuncios para dispositivos móviles.

Implementa una clase de administrador

Tu anuncio se debería mostrar rápidamente, por lo que es mejor que lo cargues antes de que tengas que mostrarlo. De esa manera, el anuncio estará listo para publicarse en cuanto el usuario ingrese a tu app. Implementa una clase de administrador para realizar solicitudes de anuncios antes de que necesites mostrarlos.

Crea una nueva clase singleton llamada 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

Luego, implementa su 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

Carga un anuncio

El siguiente paso es cargar un anuncio para inicio de aplicación:

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

Muestra un anuncio

El siguiente paso es mostrar un anuncio para inicio de aplicación. Si no hay anuncios disponibles, intenta cargar uno nuevo.

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

Muestra el anuncio durante los eventos en primer plano de la app

Cuando la aplicación se activa, llama a showAdIfAvailable() para mostrar un anuncio (si hay uno disponible) o carga uno nuevo.

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

Controla las devoluciones de llamada de la presentación

Para recibir notificaciones de eventos de presentación, debes asignar GADFullScreenContentDelegate a la propiedad de fullScreenContentDelegate del anuncio devuelto:

Swift

appOpenAd?.fullScreenContentDelegate = self
AppOpenAdManager.swift

Objective-C

self.appOpenAd.fullScreenContentDelegate = self;
AppOpenAdManager.m

En particular, deberás solicitar el próximo anuncio para inicio de aplicación una vez que finalice la presentación del primero. En el siguiente código, se muestra cómo implementar el protocolo en tu archivo 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

Ten en cuenta el vencimiento de los anuncios

Para asegurarte de no mostrar un anuncio vencido, puedes agregar al delegado de la app un método que verifique el tiempo transcurrido desde que se cargó la referencia del anuncio.

En AppOpenAdManager, agrega una propiedad Date llamada loadTime y configúrala cuando se cargue el anuncio. Luego, puedes agregar un método que devuelva true si transcurre menos de una cierta cantidad de horas desde que se carga el anuncio. Asegúrate de verificar la validez de la referencia del anuncio antes de intentar mostrarlo.

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

Inicios en frío y pantallas de carga

En la documentación se asume que solo muestras anuncios para inicio de aplicación cuando los usuarios ponen tu app en primer plano mientras está suspendida en la memoria. Los "inicios en frío" se producen cuando se inicia tu app sin que esta haya estado suspendida en la memoria previamente.

Un ejemplo de inicio en frío es cuando un usuario abre la app por primera vez. Con los inicios en frío, no tendrás un anuncio para inicio de aplicación cargado previamente que esté listo para mostrarse de inmediato. La demora entre el momento en que solicitas un anuncio y el momento en que lo recibes podría generar un espacio de tiempo en el que los usuarios puedan usar brevemente tu app antes de que los sorprenda un anuncio fuera de contexto. Esto se debe evitar, porque genera una mala experiencia del usuario.

La mejor manera de publicar anuncios para inicios en frío de la aplicación es implementar una pantalla para cargar los recursos de tu juego o aplicación, y mostrar el anuncio solo desde esa pantalla de carga. No muestres el anuncio si tu app ya terminó de cargarse y llevó al usuario al contenido principal.

Prácticas recomendadas

Google creó los anuncios para inicio de aplicación para ayudarte a monetizar la pantalla de carga de tu app, pero es importante que tengas en cuenta las prácticas recomendadas para que los usuarios disfruten de usar tu producto. Asegúrate de hacer lo siguiente:

  • Para mostrar tu primer anuncio para inicio de aplicación, espera hasta que los usuarios hayan usado la app algunas veces.
  • Muestra anuncios para inicio de aplicación en los momentos en que los usuarios estén esperando a que se cargue la app.
  • Si debajo del anuncio para inicio de aplicación tienes una pantalla de carga y esta termina de cargarse antes de que se descarte el anuncio, es conveniente que descartes la pantalla en el método adDidDismissFullScreenContent.

Ejemplo completo en GitHub

Swift Objective-C

Próximos pasos

Obtén más información sobre la privacidad del usuario.