Annunci apertura app

Questa guida è rivolta ai publisher che integrano gli annunci apertura app.

Gli annunci apertura app sono un formato di annuncio speciale destinato ai publisher che intendono monetizzare le schermate di caricamento dell'app. Gli annunci apertura app possono essere chiusi dai tuoi utenti in qualsiasi momento. Gli annunci apertura app possono essere mostrati quando gli utenti portano la tua app in primo piano.

Nota: il formato specifico può variare in base alla regione.

Gli annunci apertura app mostrano automaticamente una piccola area di branding in modo che gli utenti sappiano di trovarsi nella tua app. Ecco un esempio di annuncio apertura app:

In linea generale, ecco i passaggi necessari per implementare gli annunci apertura app:

1. Aggiungi metodi a AppDelegate per caricare e visualizzare un GADAppOpenAd.
2. Rileva gli eventi in primo piano nell'app.
3. Gestire i callback di presentazione.

Prerequisiti

• Segui le istruzioni di configurazione nella Guida introduttiva.
• Scopri come configurare il tuo dispositivo come dispositivo di prova.

Esegui sempre il test con gli annunci di prova

Quando crei e testi le tue app, assicurati di utilizzare annunci di prova anziché annunci attivi di produzione. In caso contrario, l'account potrebbe essere sospeso.

Il modo più semplice per caricare gli annunci di prova è utilizzare il nostro ID unità pubblicitaria di prova dedicato per gli annunci apertura app:

ca-app-pub-3940256099942544/5662855259

È stato appositamente configurato per restituire annunci di prova per ogni richiesta e puoi utilizzarlo nelle tue app durante la programmazione, il test e il debug. Assicurati di sostituirlo con il tuo ID unità pubblicitaria prima di pubblicare l'app.

Per ulteriori informazioni su come funzionano gli annunci di prova dell'SDK Mobile Ads, consulta l'articolo Annunci di prova.

Modificare la delega dell'app

Gli annunci apertura app vengono mostrati quando l'applicazione viene avviata o quando gli utenti portano l'applicazione in primo piano. Per assicurarti che sia disponibile un annuncio da mostrare quando un utente apre la tua app, ti consigliamo di fare riferimento a un annuncio pronto per l'uso.

Ciò significa che devi precaricare le GADAppOpenAd prima di poter pubblicare l'annuncio. In questo modo, l'annuncio apertura app sarà pronto per la pubblicazione la prossima volta che l'app verrà aperta. Per facilitare l'utilizzo di un unico riferimento all'annuncio, aggiungi la proprietà e i metodi seguenti a AppDelegate.h:

#import <GoogleMobileAds/GoogleMobileAds.h>
#import <UIKit/UIKit.h>
@interface AppDelegate : UIResponder <UIApplicationDelegate>

@property(strong, nonatomic) UIWindow* window;
@property(strong, nonatomic) GADAppOpenAd* appOpenAd;

- (void)requestAppOpenAd;
- (void)tryToPresentAd;

@end

Tieni presente che devi rendere i metodi di richiesta e presentazione accessibili al di fuori del tuo corso AppDelegate in modo da poterli chiamare dal tuo UISceneDelegate per i dispositivi con iOS 13 e versioni successive. Ne parleremo più in dettaglio più avanti.

In AppDelegate.m, aggiungi il metodo requestAppOpenAd:

- (void)requestAppOpenAd {
  self.appOpenAd = nil;
  [GADAppOpenAd loadWithAdUnitID:@"ca-app-pub-3940256099942544/5662855259"
                         request:[GADRequest request]
                     orientation:UIInterfaceOrientationPortrait
               completionHandler:^(GADAppOpenAd *_Nullable appOpenAd, NSError *_Nullable error) {
                 if (error) {
                   NSLog(@"Failed to load app open ad: %@", error);
                   return;
                 }
                 self.appOpenAd = appOpenAd;
               }];
}

Questo metodo invia una richiesta per caricare un nuovo GADAppOpenAd. In caso di esito positivo, la proprietà viene impostata su AppDelegate in modo che l'annuncio sia pronto per essere utilizzato dagli utenti che portano l'app in primo piano.

È necessario impostare l'orientamento. Se l'orientamento è impostato su UIInterfaceOrientationUnknown, GADAppOpenAd assume un orientamento verticale. Se volete progettare un layout orizzontale, assicuratevi di specificare che è necessario un orientamento orizzontale passando per UIInterfaceOrientationLandscapeLeft o UIInterfaceOrientationLandscapeRight al metodo di richiesta.

A questo punto, aggiungi un metodo per visualizzare l'annuncio dalla AppDelegate.

- (void)tryToPresentAd {
  if (self.appOpenAd) {
    UIViewController *rootController = self.window.rootViewController;
    [self.appOpenAd presentFromRootViewController:rootController];
  } else {
    // If you don't have an ad ready, request one.
    [self requestAppOpenAd];
  }
}

Questo metodo verifica la presenza di un annuncio e, se esiste e può essere mostrato dal controller della visualizzazione principale, mostrerà l'annuncio sui tuoi contenuti esistenti. Se non è disponibile alcun annuncio, il metodo effettua una nuova richiesta.

Rileva gli eventi in primo piano nell'app

Quando un utente accede alla tua app per la prima volta, è improbabile che tu disponga di un riferimento annuncio pronto per essere utilizzato. Devi invece usare il metodo tryToPresentAd definito sopra, che mostra un annuncio se disponibile, o richiedine uno nuovo. Questo metodo deve essere chiamato ogni volta che la tua app entra in primo piano. Puoi eseguire questa operazione eseguendo l'override del metodo applicationDidBecomeActive: nel tuo AppDelegate:

- (void)applicationDidBecomeActive:(UIApplication *)application {
  [self tryToPresentAd];
}

Punto chiave: se utilizzi Scene, chiama tryToPresentAd nel metodo sceneDidBecomeActive: del tuo UISceneDelegate.

Gestire i callback di presentazione

Quando nella tua app viene mostrato un annuncio apertura app, devi utilizzare GADFullScreenContentDelegate per gestire determinati eventi di presentazione. In particolare, dovrai richiedere il prossimo annuncio apertura app al termine della presentazione.

Apporta le seguenti modifiche al file AppDelegate.h:

#import <GoogleMobileAds/GoogleMobileAds.h>
#import <UIKit/UIKit.h>
@interface AppDelegate
    : UIResponder <UIApplicationDelegate, GADFullScreenContentDelegate>

@property(strong, nonatomic) UIWindow* window;
@property(strong, nonatomic) GADAppOpenAd* appOpenAd;

- (void)requestAppOpenAd;
- (void)tryToPresentAd;

@end

Quindi, nel tuo file AppDelegate.m, aggiungi le seguenti righe:

- (void)requestAppOpenAd {
  self.appOpenAd = nil;
  [GADAppOpenAd loadWithAdUnitID:@"ca-app-pub-3940256099942544/5662855259"
                         request:[GADRequest request]
                     orientation:UIInterfaceOrientationPortrait
               completionHandler:^(GADAppOpenAd *_Nullable appOpenAd, NSError *_Nullable error) {
                 if (error) {
                   NSLog(@"Failed to load app open ad: %@", error);
                   return;
                 }
                 self.appOpenAd = appOpenAd;
                 self.appOpenAd.fullScreenContentDelegate = self;
               }];
}

#pragma mark - GADFullScreenContentDelegate

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

}

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

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

Questi callback gestiscono diversi eventi del ciclo di vita dell'annuncio apertura app.

Considera la scadenza dell'annuncio

Punto chiave: gli annunci apertura app scadono dopo quattro ore. Gli annunci visualizzati oltre quattro ore dopo l'ora della richiesta non saranno più validi e potrebbero non generare entrate.

Per assicurarti di non mostrare un annuncio scaduto, puoi aggiungere al delegato dell'app un metodo per controllare il tempo trascorso dal caricamento del riferimento annuncio.

In AppDelegate.h, aggiungi una proprietà NSDate:

#import <GoogleMobileAds/GoogleMobileAds.h>
#import <UIKit/UIKit.h>
@interface AppDelegate : UIResponder <UIApplicationDelegate>

@property(strong, nonatomic) UIWindow* window;
@property(strong, nonatomic) GADAppOpenAd* appOpenAd;
@property(weak, nonatomic) NSDate *loadTime;

- (void)requestAppOpenAd;
- (void)tryToPresentAd;

@end

Puoi quindi aggiungere un metodo che restituisca true se è trascorso meno di un certo numero di ore dal caricamento dell'annuncio.

In AppDelegate.m aggiungi il seguente metodo:

- (BOOL)wasLoadTimeLessThanNHoursAgo:(int)n {
  NSDate *now = [NSDate date];
  NSTimeInterval timeIntervalBetweenNowAndLoadTime = [now timeIntervalSinceDate:self.loadTime];
  double secondsPerHour = 3600.0;
  double intervalInHours = timeIntervalBetweenNowAndLoadTime / secondsPerHour;
  return intervalInHours < n;
}

Il passaggio successivo consiste nell'impostare la proprietà loadTime quando viene caricato l'annuncio:

- (void)requestAppOpenAd {
  self.appOpenAd = nil;
  [GADAppOpenAd loadWithAdUnitID:@"ca-app-pub-3940256099942544/5662855259"
                         request:[GADRequest request]
                     orientation:UIInterfaceOrientationPortrait
               completionHandler:^(GADAppOpenAd *_Nullable appOpenAd, NSError *_Nullable error) {
                 if (error) {
                   NSLog(@"Failed to load app open ad: %@", error);
                   return;
                 }
                 self.appOpenAd = appOpenAd;
                 self.appOpenAd.fullScreenContentDelegate = self;
                 self.loadTime = [NSDate date];
               }];
}

Infine, assicurati di controllare la validità del riferimento dell'annuncio prima di provare a mostrarlo:

- (void)tryToPresentAd {
  if (self.appOpenAd && [self wasLoadTimeLessThanNHoursAgo:4]) {
    UIViewController *rootController = self.window.rootViewController;
    [self.appOpenAd presentFromRootViewController:rootController];
  } else {
    // If you don't have an ad ready, request one.
    [self requestAppOpenAd];
  }
}

Avvio a freddo e caricamento delle schermate

La documentazione riportata sopra presuppone che tu mostri annunci apertura app solo quando gli utenti mettono in primo piano la tua app quando è sospesa in memoria. Gli "avvii a freddo" si verificano quando l'app viene avviata, ma non è stata sospesa in memoria in precedenza.

Un esempio di avvio a freddo è quando un utente apre la tua app per la prima volta. Con gli avvii a freddo, non avrai un annuncio apertura app caricato in precedenza pronto per essere mostrato immediatamente. Il ritardo tra la richiesta di un annuncio e la ricezione di un annuncio può creare una situazione in cui gli utenti possono utilizzare brevemente la tua app prima di essere sorpresi da un annuncio fuori contesto. Questo andrebbe evitato perché è un'esperienza utente negativa.

Il modo migliore per usare gli annunci apertura app in avvii a freddo è usare una schermata di caricamento per caricare gli asset del gioco o dell'app e mostrare l'annuncio solo dalla schermata di caricamento. Se l'app ha completato il caricamento e ha indirizzato l'utente ai contenuti principali dell'app, non mostrare l'annuncio.

Punto chiave :per continuare a caricare gli asset per app mentre è visualizzato l'annuncio apertura app, devi sempre caricarli in un thread in background.

Best practice

Google ha creato annunci apertura app per aiutarti a monetizzare la schermata di caricamento dell'app. Tuttavia, è importante tenere presente le best practice per consentire agli utenti di utilizzare la tua app. Assicurati di:

• Attendi il primo annuncio apertura app fino a quando gli utenti non hanno utilizzato l'app alcune volte.
• Mostra gli annunci apertura app nei momenti in cui gli utenti stanno aspettando il caricamento dell'app.
• Se è stata visualizzata una schermata di caricamento sotto l'annuncio apertura app e il caricamento della schermata di caricamento viene completato prima che l'annuncio venga ignorato, puoi ignorare la schermata di caricamento nel metodo adDidDismissFullScreenContent.

Completa l'esempio su GitHub

Swift Obiettivo-C

Passaggi successivi

Scopri di più sulla privacy degli utenti.