Anuncios de aplicación abierta

Los anuncios de aplicación abierta son un formato de anuncio especial diseñado para los publicadores que desean monetizar sus pantallas de carga de aplicaciones. Los anuncios de aplicación abierta se pueden cerrar en cualquier momento y están diseñados para mostrarse cuando los usuarios llevan tu app al primer plano.

Los anuncios de aplicación abierta muestran automáticamente un área de desarrollo de la marca pequeña para que los usuarios sepan que están allí tu app. Este es un ejemplo de cómo se ve un anuncio de aplicación abierta:

Requisitos previos

• Complemento de Flutter 0.13.6 o posterior.
• Completa Comenzar. Tu app de Flutter ya debería haber importado el complemento de Google Mobile Ads para Flutter.

Probar siempre con anuncios de prueba

Cuando compiles y pruebes tus apps, asegúrate de usar anuncios de prueba en lugar de anuncios activos y en producción. De lo contrario, podría suspenderse tu cuenta.

La forma más sencilla de cargar anuncios de prueba es usar nuestros IDs de unidad de anuncios de prueba exclusivos para Anuncios recompensados para iOS y Android:

Android

ca-app-pub-3940256099942544/9257395921

iOS

ca-app-pub-3940256099942544/5575463023

Están configurados de forma especial para mostrar anuncios de prueba para cada solicitud. puedes usarlas en tus apps mientras codificas, pruebas y depuras. Solo asegúrate de reemplazarlos con tu propio ID de unidad de anuncios antes de publicar tu .

Implementación

Los pasos principales para integrar anuncios de aplicación abierta son los siguientes:

1. Crea una clase de utilidad que cargue un anuncio antes de que tengas que mostrarlo.
2. Carga un anuncio.
3. Regístrate para recibir devoluciones de llamada y muestra el anuncio.
4. Suscríbete a AppStateEventNotifier.appStateStream para mostrar el anuncio durante los eventos en primer plano.

Cómo crear una clase de utilidad

Crea una clase nueva llamada AppOpenAdManager para cargar el anuncio. Esta clase administra una variable de instancia para hacer el seguimiento de un anuncio cargado y el ID de la unidad de anuncios para cada plataforma.

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

class AppOpenAdManager {
  
  String adUnitId = Platform.isAndroid
    ? 'ca-app-pub-3940256099942544/9257395921'
    : 'ca-app-pub-3940256099942544/5575463023';
  
  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;
  }
}

Carga un anuncio

El anuncio de aplicación abierta debe estar listo antes de que los usuarios ingresen a la aplicación. Implementa un para realizar solicitudes de anuncios antes de cuándo debes mostrarlos.

Para cargar un anuncio, puedes utilizar el método load en la clase AppOpenAd. El método de carga requiere un ID de unidad de anuncios, una un objeto AdRequest y un objeto de finalización al que se llama cuando la carga de anuncios se realiza correctamente o falla. El tráfico cargado El objeto AppOpenAd se proporciona como parámetro en el controlador de finalización. El El siguiente ejemplo muestra cómo cargar una AppOpenAd.

public class AppOpenAdManager {
  ...

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

Muestra el anuncio y controla las devoluciones de llamada de pantalla completa

Antes de mostrar el anuncio, registra un FullScreenContentCallback para cada evento de anuncio que quieres escuchar.

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();
      },
    );
  }
}

Si un usuario vuelve a tu aplicación después de haberla dejado haciendo clic en una aplicación abierta asegúrese de que no se le muestren otros anuncios de aplicación abierta.

Cómo escuchar eventos en primer plano de la app

Para recibir notificaciones sobre eventos en primer plano de la app, debes suscribirte a AppStateEventNotifier.appStateStream y escucha eventos de 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();
    }
  }
}

Ahora puedes agregar, inicializar tu AppLifecycleReactor y comenzar a escuchar en el ciclo de vida de las apps. Por ejemplo, desde tu página principal:

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);
  }

Ten en cuenta el vencimiento de los anuncios

Punto clave: Después de cuatro horas, se agotará el tiempo de espera de las referencias de anuncios en la versión beta de aplicación abierta. Los anuncios renderizados más de cuatro horas después del momento de la solicitud dejarán de ser válidos. podrían no generar ingresos. Este límite de tiempo se está considerando cuidadosamente y podría cambio en futuras versiones beta del formato de aplicación abierta.

Para asegurarse de no mostrar un anuncio vencido, agregue una marca de tiempo al AppOpenAdManager para que pueda consultar cuánto tiempo transcurrió desde que se cargó su anuncio. Luego, utiliza esa marca de tiempo para verificar si el anuncio sigue siendo válido.

/// 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.load(
      adUnitId: adUnitId,
      orientation: AppOpenAd.orientationPortrait,
      adRequest: AdRequest(),
      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();
  }
}

Inicios en frío y pantallas de carga

Hasta ahora, en la documentación se supone que solo muestras anuncios de aplicación abierta cuando los usuarios primer plano de tu app cuando está suspendida en la memoria. "Inicios en frío" se producen cuando se inició tu app, pero no se suspendió anteriormente 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 se mostrará de inmediato. La demora entre el momento en que solicitas un anuncio y lo recibes puede crear una situación en la que los usuarios puedan usar brevemente tu app se sorprenden con un anuncio fuera de contexto. Esto se debe evitar porque es una experiencia del usuario deficiente.

La forma preferida de usar los anuncios de aplicación abierta durante inicios en frío es usar una pantalla de carga para cargar tus recursos de juego o app, y mostrar solo el anuncio en la pantalla. Si tu app terminó de cargarse y envió al usuario a la página principal contenido de tu app, no muestres el anuncio.

Punto clave: Para seguir cargando recursos de aplicación mientras se muestra el anuncio que se muestra, siempre debes cargar los recursos en un subproceso en segundo plano.

Prácticas recomendadas

Los anuncios de aplicación abierta te ayudan a monetizar la pantalla de carga de tu app cuando esta se encuentra por primera vez durante lanzamientos y cambios de apps, pero es importante mantener para que tus usuarios disfruten de usar tu app. Lo mejor es hacer lo siguiente:

• Muestra tu primer anuncio de aplicación abierta después de que los usuarios hayan utilizado tu aplicación unas cuantas veces.
• Muestra anuncios de aplicación abierta durante los momentos en los que, de otro modo, los usuarios estarían esperando que se cargue la aplicación.
• Si hay una pantalla de carga debajo del anuncio de aplicación abierta y tu pantalla de carga termine de cargarse antes de que se descarte el anuncio, quizás desee descartar sus cargando la pantalla en el controlador de eventos onAdDismissedFullScreenContent

Ejemplo completo en GitHub

Aplicación abierta