O Google tem o compromisso de promover a igualdade racial para as comunidades negras. Saiba como.

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 a AdMob e o Firebase ao app 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 um código 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 SO específico. Para exibir anúncios de banner e 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 instancie um objeto BannerView:

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 instancie um objeto InterstitialAd:

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 definindo os membros de um struct AdRequest. O struct é transmitido para o método 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.

Veja o struct AdRequest usado por BannerView e InterstitialAd para fazer uma solicitação de 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;
};

Declare e inicialize 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.

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

Futures fornecem uma maneira de determinar o status de conclusão das chamadas de método BannerView ou InterstitialAd anteriores. 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 têm um método de "último resultado" correspondente que os apps podem usar para recuperar o Future mais recente de uma 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().

Da mesma forma, os apps podem usar o método BannerView::InitializeLastResult() para receber um Future que representa o status (e o código de erro, se houver) da última chamada para o método BannerView::Initialize(). Se o status estiver completo e o código do erro for firebase::admob::kAdMobErrorNone, você estará pronto para tornar o banner visível chamando o método BannerView::Show():

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

Quando o status do Future da última chamada para o método BannerView::Show() for concluído, você estará pronto para 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 que representa o status (e o código de erro, se houver) da última chamada para o método InterstitialAd::Initialize(). Se o status estiver completo e o código de erro for firebase::admob::kAdMobErrorNone, você estará 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);
}

Quando o status do Future da última chamada para o método InterstitialAd::LoadAd() for concluído, você estará pronto para exibir o anúncio intersticial no próximo ponto de parada natural no seu 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 fornece uma classe BannerView::Listener abstrata que é possível estender e passar para o método BannerView::SetListener() para gerar notificações sobre alterações no estado de apresentação e na caixa delimitadora da visualização do banner. Uma classe InterstitialAd::Listener abstrata semelhante também é fornecida para anúncios intersticiais que podem ser estendidos para gerar notificações sobre alterações no estado de apresentação de um anúncio intersticial.

Veja abaixo um exemplo de implementação de uma classe que estende a classe BannerView::Listener (uma implementação semelhante pode ser usada 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.
  }
};

A seguir

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