Comienza

Puedes usar AdMob para mostrar anuncios en tus apps de C++. En esta guía, se muestra cómo realizar la integración con Firebase y la interacción con el SDK de Google Mobile Ads.

Si es la primera vez que usas esta guía, es recomendable que descargues la app de pruebas de AdMob y la uses para seguir los temas que se tratan aquí.

Integración a Firebase

1. Sigue los pasos que se indican en la sección Configuración para iOS o Configuración para Android a fin de agregar AdMob y Firebase a tu app de C++.

   Nota: Si usas la app de pruebas de AdMob, los pasos que se describen a continuación ya se llevaron a cabo. Deberías poder ejecutar la app de pruebas.

2. Incluye los siguientes encabezados en el código C++ de tu app:

   #include "firebase/admob.h"
   #include "firebase/admob/types.h"
   #include "firebase/app.h"
   #include "firebase/future.h"
   

3. Agrega el siguiente fragmento al código C++ de tu app para inicializar la biblioteca de AdMob con tu ID de app de AdMob (este código debe ejecutarse antes de crear una vista de banner o un anuncio intersticial):

   #if defined(__ANDROID__)
   // Create the Firebase app.
   firebase::App* app =
       firebase::App::Create(firebase::AppOptions(),
                             your_jni_env,
                             your_android_activity);
   
   // Your Android AdMob app ID.
   const char* kAdMobAppID = "ca-app-pub-XXXXXXXXXXXXXXXX~NNNNNNNNNN";
   #else
   // Create the Firebase app.
   firebase::App* app =
       firebase::App::Create(firebase::AppOptions());
   
   // Your iOS AdMob app ID.
   const char* kAdMobAppID = "ca-app-pub-XXXXXXXXXXXXXXXX~NNNNNNNNNN";
   #endif  // __ANDROID__
   
   // Initialize the AdMob library with your AdMob app ID.
   firebase::admob::Initialize(*app, kAdMobAppID);
   

Nota: Los ID de app de AdMob son identificadores únicos que se asignan a las apps para dispositivos móviles cuando se registran en tu cuenta de AdMob. Cuando se inicializa el SDK de anuncios de Google para dispositivos móviles durante el lanzamiento de la app, este puede recuperar la configuración de nivel de app para realizar tareas de configuración lo antes posible. Esto puede ayudar a reducir la latencia de la solicitud de anuncio inicial.

Interactúa con el SDK de Google Mobile Ads

Configura los ID de bloques de anuncios

Cuando escribas código de C++ que sea compatible tanto con iOS como con Android, es posible que necesites usar directivas de preprocesador para definir el código que solo debe compilarse para un SO específico. Para mostrar anuncios intersticiales y de banner tanto en iOS como en Android, se recomienda que crees un nuevo ID de bloque de anuncios para cada SO y cada colocación única de anuncio. Los siguientes ID de bloques de anuncio se crearon para iOS y Android y se configuraron para publicar anuncios de prueba en todos los casos:

#if defined(__ANDROID__)
// Android ad unit IDs
const char* kBannerAdUnit = "ca-app-pub-3940256099942544/6300978111";
const char* kInterstitialAdUnit = "ca-app-pub-3940256099942544/1033173712";
#else
// iOS ad unit IDs
const char* kBannerAdUnit = "ca-app-pub-3940256099942544/2934735716";
const char* kInterstitialAdUnit = "ca-app-pub-3940256099942544/4411468910";
#endif

Configura una vista de banner

Agrega el siguiente encabezado al código de C++ de tu app:

#include "firebase/admob/banner_view.h"

Declara y crea una instancia de un objeto BannerView:

firebase::admob::BannerView* banner_view;
banner_view = new firebase::admob::BannerView();

Crea un AdSize e inicializa la vista de banner:

firebase::admob::AdSize ad_size;
ad_size.ad_size_type = firebase::admob::kAdSizeStandard;
ad_size.width = 320;
ad_size.height = 50;
// my_ad_parent is a reference to an iOS UIView or an Android Activity.
// This is the parent UIView or Activity of the banner view.
banner_view->Initialize(static_cast<firebase::admob::AdParent>(my_ad_parent), kBannerAdUnit, ad_size);

Configura un anuncio intersticial

Agrega el siguiente encabezado al código de C++ de tu app:

#include "firebase/admob/interstitial_ad.h"

Declara y crea una instancia de un objeto InterstitialAd:

firebase::admob::InterstitialAd* interstitial_ad;
interstitial_ad = new firebase::admob::InterstitialAd();

Inicializa el anuncio intersticial:

// my_ad_parent is a reference to an iOS UIView or an Android Activity.
// This is the parent UIView or Activity of the interstitial ad.
interstitial_ad->Initialize(static_cast<firebase::admob::AdParent>(my_ad_parent), kInterstitialAdUnit);

Crea una solicitud de anuncio de AdMob

La biblioteca de AdMob te permite proporcionar información de orientación personalizada a una solicitud de anuncio. Para ello, debes configurar los miembros de un struct AdRequest. Luego, el struct se pasa al método BannerView::LoadAd() o InterstitialAd::LoadAd().

Para obtener información general sobre cómo orientar y personalizar las solicitudes de anuncios, consulta las guías de orientación para iOS y Android.

Este es el struct AdRequest que usan BannerView y InterstitialAd para solicitar un anuncio:

struct AdRequest {
  const char **test_device_ids;
  unsigned int test_device_id_count;
  const char **keywords;
  unsigned int keyword_count;
  const KeyValuePair *extras;
  unsigned int extras_count;
  int birthday_day;
  int birthday_month;
  int birthday_year;
  Gender gender;
  ChildDirectedTreatmentState tagged_for_child_directed_treatment;
};

Declara e inicializa el struct AdRequest:

// Initialize all the AdRequest struct member values to zero.
firebase::admob::AdRequest my_ad_request = {};

El siguiente código define los valores miembro del struct AdRequest para agregar información de orientación a las solicitudes de anuncio:

// If the app is aware of the user's gender, it can be added to the
// targeting information. Otherwise, "unknown" should be used.
my_ad_request.gender = firebase::admob::kGenderUnknown;

// The user's birthday, if known. Note that months are indexed from one.
my_ad_request.birthday_day = 10;
my_ad_request.birthday_month = 11;
my_ad_request.birthday_year = 1976;

// Additional keywords to be used in targeting.
static const char* kKeywords[] = {"AdMob", "C++", "Fun"};
my_ad_request.keyword_count = sizeof(kKeywords) / sizeof(kKeywords[0]);
my_ad_request.keywords = kKeywords;

// "Extra" key value pairs can be added to the request as well.
static const firebase::admob::KeyValuePair kRequestExtras[] = {
    {"the_name_of_an_extra", "the_value_for_that_extra"}};
my_ad_request.extras_count = sizeof(kRequestExtras) / sizeof(kRequestExtras[0]);
my_ad_request.extras = kRequestExtras;

// Register the device IDs associated with any devices that will be used to
// test your app. Below are sample test device IDs used for making the ad request.
static const char* kTestDeviceIDs[] =
    {"2077ef9a63d2b398840261c8221a0c9b",
     "098fe087d987c9a878965454a65654d7"};
my_ad_request.test_device_id_count =
    sizeof(kTestDeviceIDs) / sizeof(kTestDeviceIDs[0]);
my_ad_request.test_device_ids = kTestDeviceIDs;

Pasa el struct AdRequest a los métodos BannerView::LoadAd() y Interstitial::LoadAd():

banner_view->LoadAd(my_ad_request);
interstitial_ad->LoadAd(my_ad_request);

Note: A single `AdRequest` struct can be reused for multiple calls.

Usa interfaces Future para supervisar el estado de las llamadas al método

Las interfaces Future te ofrecen una manera de conocer el estado de las llamadas a los métodos BannerView o InterstitialAd anteriores. Cuando se realiza una llamada al método InterstitialAd::LoadAd(), por ejemplo, se crea y se muestra una nueva interfaz Future. Las apps solo pueden consultar el estado de la interfaz Future para determinar cuándo se cargó el anuncio. Una vez finalizada la interfaz Future, el anuncio intersticial está listo para mostrarse en el siguiente punto de detención natural de la app.

La mayoría de los métodos de las clases BannerView y InterstitialAd tienen un método "LastResult" correspondiente que las apps pueden usar para recuperar la interfaz Future más reciente de una acción específica. Por ejemplo, al método InterstitialAd::LoadAd() le corresponde el método denominado InterstitialAd::LoadAdLastResult(), que muestra una interfaz Future que puede usarse para verificar el estado de la última llamada al método InterstitialAd::LoadAd().

De manera similar, las apps pueden usar el método BannerView::InitializeLastResult() para obtener una interfaz Future que represente el estado (y el código de error, si corresponde) de la última llamada al método BannerView::Initialize(). Si su estado está completo y su código de error es firebase::admob::kAdMobErrorNone, puedes llamar al método BannerView::Show() para que la vista del banner sea visible:

if (banner_view->InitializeLastResult().status() ==
    firebase::kFutureStatusComplete &&
    banner_view->InitializeLastResult().error() ==
    firebase::admob::kAdMobErrorNone) {
  banner_view->Show();
}

Una vez que se complete el estado de la interfaz Future para la última llamada al método BannerView::Show(), tendrás todo listo para cargar un anuncio en la vista de banner:

if (banner_view->ShowLastResult().status() ==
    firebase::kFutureStatusComplete &&
    banner_view->ShowLastResult().error() ==
    firebase::admob::kAdMobErrorNone) {
  banner_view->LoadAd(my_ad_request);
}

En el caso de los anuncios intersticiales, usa el método InterstitialAd::InitializeLastResult() para obtener una interfaz Future que represente el estado (y el código de error, si corresponde) de la última llamada al método InterstitialAd::Initialize(). Si su estado está completo y su código de error es firebase::admob::kAdMobErrorNone, tienes todo listo para cargar el anuncio intersticial:

if (interstitial_ad->InitializeLastResult().status() ==
    firebase::kFutureStatusComplete &&
    interstitial_ad->InitializeLastResult().error() ==
    firebase::admob::kAdMobErrorNone) {
  interstitial_ad->LoadAd(my_ad_request);
}

Una vez que se complete el estado de la interfaz Future para la última llamada al método InterstitialAd::LoadAd(), tendrás todo listo para mostrar el anuncio intersticial en el siguiente punto de detención natural en tu app:

if (interstitial_ad->LoadAdLastResult().status() ==
    firebase::kFutureStatusComplete &&
    interstitial_ad->LoadAdLastResult().error() ==
    firebase::admob::kAdMobErrorNone) {
  interstitial_ad->Show();
}

También puedes registrar devoluciones de llamada que se invocarán cuando se complete una interfaz Future. Este fragmento de código usa un marcador de función para la devolución de llamada:

// Initialize the interstitial ad.
interstitial_ad->Initialize(static_cast<firebase::admob::AdParent>(my_ad_parent), kInterstitialAdUnit);

// Registers the OnCompletion callback. user_data is a pointer that is passed verbatim
// to the callback as a void*. In this example, we pass the interstitial ad object to be
// used in the OnCompletionCallback function.
interstitial_ad->InitializeLastResult().OnCompletion(OnCompletionCallback, interstitial_ad /*user_data*/);

// The OnCompletion callback function.
static void OnCompletionCallback(const firebase::Future<void>& future, void* user_data) {
  // Called when the Future is completed for the last call to the InterstitialAd::Initialize()
  // method. If the error code is firebase::admob::kAdMobErrorNone, then you're ready to
  // load the interstitial ad.
  firebase::admob::InterstitialAd *interstitial_ad = static_cast<firebase::admob::InterstitialAd*>(user_data);
  if (future.error() == firebase::admob::kAdMobErrorNone) {
    interstitial_ad->LoadAd(my_ad_request);
  }
}

Usa un objeto de escucha para recibir notificaciones sobre los eventos del ciclo de vida de los anuncios

AdMob proporciona una clase abstracta BannerView::Listener que puedes extender y pasar al método BannerView::SetListener() para recibir notificaciones sobre los cambios en el estado de presentación y el cuadro de límite de una vista de banner. También hay una clase similar llamada InterstitialAd::Listener para los anuncios intersticiales, que se puede extender para recibir notificaciones sobre los cambios en el estado de presentación de un anuncio intersticial.

En el siguiente ejemplo, se muestra la implementación de una clase que extiende la clase BannerView::Listener (puede usarse una implementación similar para los anuncios intersticiales):

class ExampleBannerViewListener
    : public firebase::admob::BannerView::Listener {
public:
  ExampleBannerViewListener() {}

  void OnPresentationStateChanged(
      firebase::admob::BannerView* banner_view,
      firebase::admob::BannerView::PresentationState state) override {
    // This method gets called when the banner view's presentation
    // state changes.
  }

  void OnBoundingBoxChanged(
      firebase::admob::BannerView* banner_view,
      firebase::admob::BoundingBox box) override {
    // This method gets called when the banner view's bounding box
    // changes.
  }
};

¿Qué sigue?

Descubre cómo monetizar tu app con AdMob y asegúrate de reemplazar los ID de bloques de anuncios de prueba que se usan en esta guía por tus propios ID de bloques de anuncios.