Esta guía está destinada a los publicadores que integran anuncios de aplicación abierta.
Los anuncios de aplicación abierta son un formato de anuncio especial destinado a los publicadores que desean monetizar sus pantallas de carga de aplicación. Los usuarios pueden cerrar los anuncios de aplicación abierta en cualquier momento. Los anuncios de aplicación abierta se pueden mostrar cuando los usuarios llevan la aplicación al primer plano.
Los anuncios de aplicación abierta muestran automáticamente un área pequeña de la marca para que los usuarios sepan que están en tu aplicación. A continuación, te mostramos un ejemplo de cómo se ve un anuncio de aplicación abierta:
En términos generales, estos son los pasos necesarios para implementar anuncios de aplicación abierta:
- Crea una clase de administrador que cargue un anuncio antes de que debas mostrarlo.
- Muestra el complemento durante los eventos de la app que se muestran en primer plano.
- Maneja las devoluciones de llamada de presentación.
Requisitos previos
- Sigue las instrucciones de configuración que aparecen en nuestra guía de introducción.
- Descubre cómo configurar tu dispositivo como dispositivo de prueba.
Realizar pruebas siempre con anuncios de prueba
Cuando compiles y pruebes tus apps, asegúrate de usar anuncios de prueba en lugar de anuncios publicados en producción. De lo contrario, podría suspenderse tu cuenta.
La forma más fácil de cargar anuncios de prueba es usar nuestro ID de unidad de anuncios de prueba exclusivo para los anuncios de aplicación abierta:
/21775744923/example/app-open
Se configuró especialmente para mostrar anuncios de prueba en cada solicitud, y puedes usarlo en tus propias apps mientras codificas, pruebas y depuras. Solo asegúrate de reemplazarlo con tu propio ID de unidad de anuncios antes de publicar la app.
Consulta Anuncios de prueba para obtener más información sobre cómo funcionan estos anuncios del SDK de anuncios para dispositivos móviles.
Implementar una clase de administrador
Tu anuncio debería mostrarse rápidamente, por lo que es mejor cargarlo antes de tener que mostrarlo. De esa manera, tendrás un anuncio listo para publicarse en cuanto el usuario ingrese a tu app. Implementa una clase de administrador para realizar solicitudes de anuncios antes de que debas mostrar el anuncio.
Crea una nueva clase singleton llamada AppOpenAdManager y complétala de la siguiente manera:
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
Carga un anuncio
El siguiente paso es completar el método 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;
}];
}
Mostrar un anuncio
El siguiente paso es completar el método showAdIfAvailable(). Si no hay ningún anuncio disponible, el método intenta cargar un anuncio.
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];
}
Muestra el anuncio durante los eventos de la aplicación en primer plano
Cuando se active la aplicación, llama a showAdIfAvailable() para mostrar un anuncio si hay uno disponible, o para cargar uno nuevo.
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
Cómo controlar devoluciones de llamada de presentación
Cuando tu app muestra un anuncio de aplicación abierta, debes utilizar GADFullScreenContentDelegate para controlar ciertos eventos de presentación. En particular, querrás solicitar el próximo anuncio de aplicación abierta una vez que se termine de presentar el primero.
En tu clase AppOpenAdManager, agrega lo siguiente:
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
Ten en cuenta el vencimiento de los anuncios
Para asegurarte de no mostrar un anuncio vencido, puedes agregar un método al delegado de la app que verifique el tiempo transcurrido desde que se cargó la referencia de tu anuncio.
En tu AppOpenAdManager, agrega una propiedad Date llamada loadTime y configura la propiedad cuando se cargue tu anuncio. Luego, puedes agregar un método que muestre true si transcurrieron menos de unas horas desde que se cargó tu anuncio. Asegúrate
de verificar la validez de la referencia del anuncio antes de intentar publicarlo.
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
Inicios en frío y pantallas de carga
En la documentación, se supone que solo muestras anuncios de aplicación abierta cuando los usuarios colocan la app en primer plano cuando está suspendida en la memoria. Los "inicios en frío" ocurren cuando se inicia tu app, pero no se suspendió con anterioridad en la memoria.
Un ejemplo de inicio en frío es cuando un usuario abre tu app por primera vez. Con los inicios en frío, no tendrás un anuncio de aplicación abierta previamente cargado que esté listo para mostrarse de inmediato. La demora entre el momento en que solicitas un anuncio y el momento en que recibes el anuncio puede generar una situación en la que los usuarios pueden usar tu app brevemente antes de que un anuncio fuera de contexto los sorprenda. Esto debe evitarse porque se trata de una mala experiencia del usuario.
La forma preferida de usar anuncios de aplicación abierta en inicios en frío es usar una pantalla de carga para cargar tu juego o tus elementos de app, y mostrar solo el anuncio desde la pantalla de carga. Si tu app terminó de cargarse y envió al usuario al contenido principal de tu app, no muestres el anuncio.
Prácticas recomendadas
Google creó anuncios de aplicación abierta para ayudarte a monetizar la pantalla de carga de tu app. Sin embargo, es importante que tengas en cuenta las prácticas recomendadas para que los usuarios disfruten de tu app. Asegúrate de hacer lo siguiente:
- Espera a mostrar tu primer anuncio de aplicación abierta hasta que los usuarios la hayan usado varias veces.
- Muestra anuncios de aplicación abierta durante los momentos en que los usuarios estarían esperando que se cargue la app.
- Si tienes una pantalla de carga debajo del anuncio de aplicación abierta y esta termina de cargarse antes de que se descarte el anuncio, te recomendamos descartarla en el método
adDidDismissFullScreenContent.
Ejemplo completo en GitHub
Objective‐C de Swift
Próximos pasos
Obtén más información sobre la privacidad del usuario.