Ir a la consola

Primeros pasos

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++.

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

Interactúa con el SDK de Google Mobile Ads

Configura los ID de bloque 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 ubicació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 un objeto BannerView y crea una instancia de él:

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 un objeto InterstitialAd y crea una instancia de él:

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

Con la biblioteca de AdMob, puedes proporcionar información de orientación personalizada para una solicitud de anuncio. Para ello, debes configurar los miembros de un struct AdRequest. 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 Interstitial::LoadAd() y BannerView::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 controlar 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 ejecuta 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 interrupción natural de la app.

La mayoría de los métodos de las clases InterstitialAd y BannerView 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 estado es "Complete" y el código de error es firebase::admob::kAdMobErrorNone, ya puedes hacer visible la vista del banner mediante una llamada al método BannerView::Show():

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

Una vez que el estado de la interfaz Future de la última llamada al método BannerView::Show() sea "Complete", podrás cargar un anuncio en la vista del 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, puedes usar 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 el estado es "Complete" y el código de error es firebase::admob::kAdMobErrorNone, ya puedes 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 el estado de la interfaz Future de la última llamada al método InterstitialAd::LoadAd() sea "Complete", podrás mostrar el anuncio intersticial en el siguiente punto de interrupción natural de la 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 agente de escucha para recibir notificaciones sobre los eventos del ciclo de vida de los anuncios

AdMob proporciona una clase abstracta BannerView::Listener que se puede extender y pasar al método BannerView::SetListener() para recibir notificaciones sobre los cambios en el estado de presentación de la vista del banner y su cuadro de limitación. 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.

El siguiente ejemplo 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.