Annunci apertura app

Seleziona la piattaforma: Android (beta) Android iOS Unity Flutter

Gli annunci apertura app sono un formato di annuncio speciale destinato ai publisher che vogliono monetizzare le schermate di caricamento delle loro app. Gli annunci apertura app possono essere chiusi in qualsiasi momento e sono progettati per essere mostrati quando gli utenti portano la tua app in primo piano.

Gli annunci apertura app mostrano automaticamente una piccola area di branding, in modo che gli utenti sappiano di essere all'interno della tua app. Ecco un esempio di come appare un annuncio apertura app:

Prerequisiti

Prima di continuare, completa queste operazioni:

• Installa il plug-in Flutter 0.13.6 o versioni successive.
• Configura Google Mobile Ads Flutter Plugin. Nella tua app Flutter deve essere importato Google Mobile Ads Flutter Plugin.

Esegui sempre test con annunci di prova

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

Il modo più semplice per caricare gli annunci di prova è utilizzare gli ID delle unità pubblicitarie di prova dedicati per gli annunci con premio Android e iOS:

• /21775744923/example/app-open

Sono stati configurati appositamente per restituire annunci di prova per ogni richiesta e puoi utilizzarli liberamente nelle tue app durante la codifica, i test e il debug. Assicurati di sostituirli con il tuo ID unità pubblicitaria prima di pubblicare l'app.

Implementazione

I passaggi principali per integrare gli annunci apertura app sono:

1. Crea una classe di utilità che carichi un annuncio prima di doverlo visualizzare.
2. Carica un annuncio.
3. Registra i callback e mostra l'annuncio.
4. Iscriviti a AppStateEventNotifier.appStateStream per mostrare l'annuncio durante gli eventi di primo piano.

Crea una classe di utilità

Crea una nuova classe denominata AppOpenAdManager per caricare l'annuncio. Questa classe gestisce una variabile di istanza per tenere traccia di un annuncio caricato e dell'ID unità pubblicitaria per ogni piattaforma.

import 'package:google_mobile_ads/google_mobile_ads.dart';
import 'dart:io' show Platform;

class AppOpenAdManager {
  
  String adUnitId = '/21775744923/example/app-open';
  
  AppOpenAd? _appOpenAd;
  bool _isShowingAd = false;

  /// Load an AppOpenAd.
  void loadAd() {
    // We will implement this below.
  }

  /// Whether an ad is available to be shown.
  bool get isAdAvailable {
    return _appOpenAd != null;
  }
}

Carica un annuncio

L'annuncio apertura app deve essere pronto prima che gli utenti accedano all'app. Implementa una classe di utilità per effettuare richieste di annunci prima di dover mostrare l'annuncio.

Il caricamento di un annuncio viene eseguito utilizzando il metodo loadWithAdManagerAdRequest nella classe AppOpenAd. Il metodo di caricamento richiede un ID unità pubblicitaria, una modalità di orientamento, un oggetto AdManagerAdRequest e un gestore di completamento che viene chiamato quando il caricamento dell'annuncio ha esito positivo o negativo. L'oggetto AppOpenAd caricato viene fornito come parametro nel gestore di completamento. L'esempio seguente mostra come caricare un AppOpenAd.

public class AppOpenAdManager {
  ...

  /// Load an AppOpenAd.
  void loadAd() {
    AppOpenAd.loadWithAdManagerAdRequest(
      adUnitId: adUnitId,
      adManagerAdRequest: AdManagerAdRequest(),
      adLoadCallback: AppOpenAdLoadCallback(
        onAdLoaded: (ad) {
          _appOpenAd = ad;
        },
        onAdFailedToLoad: (error) {
          print('AppOpenAd failed to load: $error');
          // Handle the error.
        },
      ),
    );
  }
}

Mostra l'annuncio e gestisci i callback a schermo intero

Prima di mostrare l'annuncio, registra un FullScreenContentCallback per ogni evento dell'annuncio che vuoi ascoltare.

public class AppOpenAdManager {
  ...

  public void showAdIfAvailable() {
    if (!isAdAvailable) {
      print('Tried to show ad before available.');
      loadAd();
      return;
    }
    if (_isShowingAd) {
      print('Tried to show ad while already showing an ad.');
      return;
    }
    // Set the fullScreenContentCallback and show the ad.
    _appOpenAd!.fullScreenContentCallback = FullScreenContentCallback(
      onAdShowedFullScreenContent: (ad) {
        _isShowingAd = true;
        print('$ad onAdShowedFullScreenContent');
      },
      onAdFailedToShowFullScreenContent: (ad, error) {
        print('$ad onAdFailedToShowFullScreenContent: $error');
        _isShowingAd = false;
        ad.dispose();
        _appOpenAd = null;
      },
      onAdDismissedFullScreenContent: (ad) {
        print('$ad onAdDismissedFullScreenContent');
        _isShowingAd = false;
        ad.dispose();
        _appOpenAd = null;
        loadAd();
      },
    );
  }
}

Se un utente torna alla tua app dopo averla lasciata facendo clic su un annuncio apertura app, assicurati che non gli venga mostrato un altro annuncio apertura app.

Ascolta gli eventi di primo piano dell'app

Per ricevere una notifica degli eventi di primo piano dell'app, devi iscriverti a AppStateEventNotifier.appStateStream e ascoltare gli eventi foreground.

import 'package:app_open_example/app_open_ad_manager.dart';
import 'package:google_mobile_ads/google_mobile_ads.dart';

/// Listens for app foreground events and shows app open ads.
class AppLifecycleReactor {
  final AppOpenAdManager appOpenAdManager;

  AppLifecycleReactor({required this.appOpenAdManager});

  void listenToAppStateChanges() {
    AppStateEventNotifier.startListening();
    AppStateEventNotifier.appStateStream
        .forEach((state) => _onAppStateChanged(state));
  }

  void _onAppStateChanged(AppState appState) {
    // Try to show an app open ad if the app is being resumed and
    // we're not already showing an app open ad.
    if (appState == AppState.foreground) {
      appOpenAdManager.showAdIfAvailable();
    }
  }
}

Ora puoi aggiungere l'inizializzazione di AppLifecycleReactor e iniziare ad ascoltare le modifiche del ciclo di vita dell'app. Ad esempio, dalla home page:

import 'package:app_open_example/app_open_ad_manager.dart';
import 'package:flutter/material.dart';
import 'package:google_mobile_ads/google_mobile_ads.dart';

import 'app_lifecycle_reactor.dart';

void main() {
  WidgetsFlutterBinding.ensureInitialized();
  MobileAds.instance.initialize();
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'App Open Example',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: MyHomePage(title: 'App Open Demo Home Page'),
    );
  }
}

class MyHomePage extends StatefulWidget {
  MyHomePage({Key? key, required this.title}) : super(key: key);

  final String title;

  @override
  _MyHomePageState createState() => _MyHomePageState();
}

/// Example home page for an app open ad.
class _MyHomePageState extends State<MyHomePage> {
  int _counter = 0;
  late AppLifecycleReactor _appLifecycleReactor;

  @override
  void initState() {
    super.initState();
    
    AppOpenAdManager appOpenAdManager = AppOpenAdManager()..loadAd();
    _appLifecycleReactor = AppLifecycleReactor(
      appOpenAdManager: appOpenAdManager);
  }

Valuta la scadenza dell'annuncio

Per assicurarti di non mostrare un annuncio scaduto, aggiungi un timestamp a AppOpenAdManager in modo da poter controllare il tempo trascorso dal caricamento dell'annuncio. Poi, utilizza questo timestamp per verificare se l'annuncio è ancora valido.

/// Utility class that manages loading and showing app open ads.
class AppOpenAdManager {
  ...
  
  /// Maximum duration allowed between loading and showing the ad.
  final Duration maxCacheDuration = Duration(hours: 4);

  /// Keep track of load time so we don't show an expired ad.
  DateTime? _appOpenLoadTime;
  
  ...

  /// Load an AppOpenAd.
  void loadAd() {
    AppOpenAd.loadWithAdManagerAdRequest(
      adUnitId: adUnitId,
      orientation: AppOpenAd.orientationPortrait,
      adManagerAdRequest: AdManagerAdRequest(),
      adLoadCallback: AppOpenAdLoadCallback(
        onAdLoaded: (ad) {
          print('$ad loaded');
          _appOpenLoadTime = DateTime.now();
          _appOpenAd = ad;
        },
        onAdFailedToLoad: (error) {
          print('AppOpenAd failed to load: $error');
        },
      ),
    );
  }

  /// Shows the ad, if one exists and is not already being shown.
  ///
  /// If the previously cached ad has expired, this just loads and caches a
  /// new ad.
  void showAdIfAvailable() {
    if (!isAdAvailable) {
      print('Tried to show ad before available.');
      loadAd();
      return;
    }
    if (_isShowingAd) {
      print('Tried to show ad while already showing an ad.');
      return;
    }
    if (DateTime.now().subtract(maxCacheDuration).isAfter(_appOpenLoadTime!)) {
      print('Maximum cache duration exceeded. Loading another ad.');
      _appOpenAd!.dispose();
      _appOpenAd = null;
      loadAd();
      return;
    }
    // Set the fullScreenContentCallback and show the ad.
    _appOpenAd!.fullScreenContentCallback = FullScreenContentCallback(...);
    _appOpenAd!.show();
  }
}

Avvii a freddo e schermate di caricamento

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

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 e pronto per essere mostrato immediatamente. Il ritardo tra il momento in cui richiedi un annuncio e il momento in cui lo ricevi può creare una situazione in cui gli utenti possono utilizzare brevemente la tua app prima di essere sorpresi da un annuncio fuori contesto. Questo comportamento deve essere evitato perché offre una pessima esperienza utente.

Il modo preferito per utilizzare gli annunci apertura app negli avvii a freddo è utilizzare 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 inviato l'utente ai contenuti principali dell'app, non mostrare l'annuncio.

Best practice

Gli annunci apertura app ti aiutano a monetizzare la schermata di caricamento dell'app, al primo avvio dell'app e durante i cambi di app, ma è importante tenere presente le best practice in modo che gli utenti si divertano a utilizzare la tua app. È consigliabile:

• Mostrare il primo annuncio apertura app dopo che gli utenti hanno utilizzato l'app alcune volte.
• Mostrare gli annunci apertura app durante i periodi in cui gli utenti altrimenti dovrebbero attendere il caricamento dell'app.
• Se hai una schermata di caricamento sotto l'annuncio apertura app e il caricamento della schermata di caricamento viene completato prima che l'annuncio venga ignorato, potresti voler ignorare la schermata di caricamento nel gestore di eventi onAdDismissedFullScreenContent.