Ir para o console

Primeiros passos

Use a AdMob para exibir anúncios nos seus aplicativos do C++. Este guia mostra como se integrar ao Firebase e interagir com o SDK de anúncios do Google para dispositivos móveis.

Se for a primeira vez que você consulta este guia, é recomendável fazer o download e acompanhar as etapas usando o aplicativo de teste da AdMob.

Integrar-se ao Firebase

  1. Para adicionar o AdMob e o Firebase ao aplicativo em C++, siga as etapas na seção Configuração para iOS ou Configuração para Android.

  2. Inclua estes cabeçalhos no código em C++ do app:

    #include "firebase/admob.h"
    #include "firebase/admob/types.h"
    #include "firebase/app.h"
    #include "firebase/future.h"
    
  3. Adicione o exemplo a seguir ao código em C++ no app para inicializar a biblioteca da AdMob com o ID do app da AdMob. Execute esse código antes de criar uma visualização de banner ou um anúncio 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);
    

Interagir com o SDK de anúncios do Google para dispositivos móveis

Configurar IDs de bloco de anúncios

Ao escrever código em C++ compatível com iOS e Android, talvez seja necessário usar diretivas de pré-processador para definir o código que deve ser compilado somente em um sistema operacional específico. Para exibir anúncios e banners intersticiais no iOS e no Android, é recomendável criar um ID novo de bloco de anúncios para cada sistema operacional e cada posicionamento exclusivo do anúncio. Estes IDs de blocos de anúncios foram criados para iOS e Android e estão configurados para sempre exibir anúncios de teste:

#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

Configurar uma visualização de banner

Adicione este cabeçalho ao código em C++ do aplicativo:

#include "firebase/admob/banner_view.h"

Declare e represente um objeto BannerView com uma instância:

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

Crie um AdSize e inicialize a visualização do 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);

Configurar um anúncio intersticial

Adicione este cabeçalho ao código em C++ do aplicativo:

#include "firebase/admob/interstitial_ad.h"

Declare e represente um objeto InterstitialAd com uma instância:

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

Inicialize o anúncio 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);

Criar uma solicitação de anúncio da AdMob

Na biblioteca da AdMob, você encontra informações de segmentação personalizada para uma solicitação de anúncio. Isso é feito ao definir os membros de um struct AdRequest. Em seguida, esse struct é transmitido para os métodos BannerView::LoadAd() ou InterstitialAd::LoadAd().

Para informações gerais sobre como segmentar e personalizar solicitações de anúncios, consulte nossos guias para iOS e Android.

Este é o struct AdRequest usado por BannerView e InterstitialAd para solicitar um anúncio:

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

Declarar e inicializar o struct AdRequest:

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

O código a seguir define os valores de membro do struct AdRequest para adicionar informações de segmentação à solicitação de anúncio:

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

Transmita o struct AdRequest para os métodos BannerView::LoadAd() e 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.

Use Futures para monitorar o status de conclusão das chamadas de método

Futures oferecem uma maneira de determinar o status de conclusão das chamadas anteriores de método BannerView ou InterstitialAd. Quando uma chamada é feita para o método InterstitialAd::LoadAd(), por exemplo, um novo Future é criado e retornado. Os aplicativos podem consultar o status do Future para determinar quando o anúncio foi carregado. Quando o Future for concluído, o anúncio intersticial estará pronto para ser exibido no próximo ponto natural de parada no aplicativo.

A maioria dos métodos nas classes BannerView e InterstitialAd tem um método "último resultado" correspondente que os aplicativos usam para recuperar o Future mais recente de determinada ação. O método InterstitialAd::LoadAd(), por exemplo, tem um método correspondente chamado InterstitialAd::LoadAdLastResult(). Ele retorna um Future que pode ser usado para verificar o status da última chamada para o método InterstitialAd::LoadAd().

De maneira similar, os aplicativos podem usar o método BannerView::InitializeLastResult() para receber um Future representando o status e o código de erro (se houver) da última chamada para o método BannerView::Initialize(). Se o status estiver concluído e o código de erro dele for firebase::admob::kAdMobErrorNone, você está pronto para tornar visível a visualização do banner chamando o método BannerView::Show():

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

Depois que o status do Future para a última chamada para o método BannerView::Show() for concluído, você conseguirá carregar um anúncio na visualização do banner:

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

Para anúncios intersticiais, use o método InterstitialAd::InitializeLastResult() para receber um Future representando o status e o código de erro (se houver) da última chamada para o método InterstitialAd::Initialize(). Se o status estiver concluído e o código de erro dele for firebase::admob::kAdMobErrorNone, você está pronto para carregar o anúncio intersticial:

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

Depois que o status do Future para a última chamada para o método InterstitialAd::LoadAd() for concluído, você conseguirá exibir o anúncio intersticial no próximo ponto natural de parada no aplicativo:

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

Além disso, você pode registrar retornos de chamada para serem invocados quando um Future for concluído. Este snippet de código usa um ponteiro de função para o retorno de chamada:

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

Usar um listener para ser notificado dos eventos do ciclo de vida do anúncio

A AdMob oferece uma classe BannerView::Listener abstrata que você pode estender e transmitir ao método BannerView::SetListener() e ser notificado sobre alterações no estado de apresentação e da caixa delimitadora da visualização de um banner. Uma classe abstrata semelhante InterstitialAd::Listener também é oferecida para anúncios intersticiais que podem ser estendidos e transmitidos para receber notificações sobre mudanças no estado de apresentação do anúncio intersticial.

Este é um exemplo de implementação de uma classe que estende a classe BannerView::Listener. É possível usar uma implementação semelhante para anúncios intersticiais.

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

Próximos artigos

Saiba como gerar receita com seu app usando a AdMob e substitua os códigos de bloco de anúncio de teste utilizados neste guia pelos seus próprios códigos.