Catch up on everthing we announced at this year's Firebase Summit. Learn more

Zaczynaj

Za pomocą AdMob możesz wyświetlać reklamy w swoich aplikacjach C++. Z tego przewodnika dowiesz się, jak przeprowadzić integrację z Firebase i korzystać z pakietu SDK do reklam mobilnych Google.

Jeśli jest to twój pierwszy raz przeżywa tego przewodnika, zaleca się pobranie i podążać za pomocą aplikacji testowej AdMob .

Zintegruj z Firebase

  1. Wykonaj czynności opisane w konfiguracji dla iOS lub konfigurację dla Androida sekcji, aby dodać AdMob i Firebase do C ++ aplikacji.

  2. Uwzględnij następujące nagłówki w kodzie C++ swojej aplikacji:

    #include "firebase/admob.h"
    #include "firebase/admob/types.h"
    #include "firebase/app.h"
    #include "firebase/future.h"
    
  3. Dodaj następujące elementy do kodu C++ w swojej aplikacji, aby zainicjować bibliotekę AdMob przy użyciu identyfikatora aplikacji AdMob (ten kod należy wykonać przed utworzeniem widoku banera lub reklamy pełnoekranowej):

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

Wejdź w interakcję z pakietem SDK do reklam mobilnych Google

Skonfiguruj identyfikatory jednostek reklamowych

Podczas pisania kodu w języku C++, który jest obsługiwany zarówno w systemie iOS, jak i Android, może być konieczne użycie dyrektyw preprocesora w celu zdefiniowania kodu, który powinien być kompilowany tylko w określonym systemie operacyjnym. W przypadku wyświetlania banerów i reklam pełnoekranowych w systemach iOS i Android zaleca się utworzenie nowego identyfikatora jednostki reklamowej dla każdego systemu operacyjnego i każdego unikalnego miejsca docelowego reklamy. Poniższe identyfikatory jednostek reklamowych zostały utworzone dla systemów iOS i Android i są skonfigurowane tak, aby zawsze wyświetlać reklamy testowe:

#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

Skonfiguruj widok banera

Dodaj następujący nagłówek do kodu C++ swojej aplikacji:

#include "firebase/admob/banner_view.h"

Zadeklarować i instancji BannerView obiektu:

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

Załóż AdSize i zainicjować widoku banera:

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

Skonfiguruj reklamę pełnoekranową

Dodaj następujący nagłówek do kodu C++ swojej aplikacji:

#include "firebase/admob/interstitial_ad.h"

Zadeklarować i instancję InterstitialAd obiektu:

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

Zainicjuj reklamę pełnoekranową:

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

Utwórz żądanie reklamy AdMob

Biblioteka AdMob umożliwia dostarczanie do żądania reklamy informacji o kierowaniu niestandardowym. Odbywa się to poprzez ustawienie członkami AdRequest struktury. Struct jest następnie przekazywany do BannerView::LoadAd() lub InterstitialAd::LoadAd() sposobu.

Ogólne informacje na temat kierowania i dostosowanie żądań reklamy, sprawdź nasze iOS i Android Skierowanie przewodników.

Oto AdRequest struct używany przez BannerView i InterstitialAd złożyć wniosek reklam:

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

Zadeklarować i zainicjować AdRequest struct:

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

Poniższy kod ustawia wartości członkiem AdRequest struct dodać kierowanie informacji do żądania reklamy:

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

Przepuścić AdRequest struct do BannerView::LoadAd() i Interstitial::LoadAd() metod:

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

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

Użyj Futures do monitorowania stanu zakończenia wywołań metod

Futures dostarczyć sposób określenia stanu zaawansowania poprzedniego BannerView lub InterstitialAd wywołań metod. Gdy połączenie jest wykonane z InterstitialAd::LoadAd() metody, na przykład nową przyszłość jest tworzona i wrócił. Aplikacje mogą sondować stan przyszłości, aby określić, kiedy reklama została załadowana. Gdy przyszłość dobiegnie końca, reklama pełnoekranowa jest gotowa do wyświetlenia w następnym naturalnym punkcie zatrzymania w Twojej aplikacji.

Większość metod w BannerView i InterstitialAd klas mają odpowiednią „Ostatni wynik” metody, które aplikacje mogą używać do pobierania najnowszego przyszłość dla danego działania. InterstitialAd::LoadAd() sposobu, na przykład, ma odpowiednią metodę zwaną InterstitialAd::LoadAdLastResult() . Zwraca przyszłości, która może być użyta do sprawdzenia stanu ostatniego wywołania InterstitialAd::LoadAd() metody.

Podobnie, aplikacje mogą korzystać z BannerView::InitializeLastResult() metodę, aby uzyskać Future reprezentujący stan (i kod błędu, jeśli w ogóle) od ostatniego wywołania BannerView::Initialize() metody. Jeśli jego stan jest kompletny, a jego kod błędu firebase::admob::kAdMobErrorNone , to jesteś gotowy, aby widok baner widoczny poprzez wywołanie BannerView::Show() metodę:

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

Po statusu ostatniego połączenia do przyszłości za BannerView::Show() metoda jest kompletna, to jesteś gotowy, aby załadować reklamę w widoku banera:

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

Dla reklam pełnoekranowych, należy użyć InterstitialAd::InitializeLastResult() metodę, aby uzyskać Future reprezentujący stan (i kod błędu, jeśli w ogóle) od ostatniego wywołania InterstitialAd::Initialize() metody. Jeśli jego stan jest kompletny, a jego kod błędu firebase::admob::kAdMobErrorNone , to jesteś gotowy, aby załadować reklamy pełnoekranowej:

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

Po statusu ostatniego połączenia do przyszłości za InterstitialAd::LoadAd() metoda jest kompletna, to jesteś gotowy do wyświetlania reklam pełnoekranowych w następnym naturalnego punktu zatrzymania w aplikacji:

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

Możesz także zarejestrować wywołania zwrotne, które będą wywoływane po zakończeniu Future. Ten fragment kodu używa wskaźnika funkcji do wywołania zwrotnego:

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

Użyj detektora, aby otrzymywać powiadomienia o zdarzeniach cyklu życia reklamy

AdMob zapewnia abstrakcyjne BannerView::Listener klasy, które można rozszerzyć i przejść do BannerView::SetListener() metody, aby otrzymywać powiadomienia o zmianach transparentem widoku danych i prezentacji stanu Obwiednia. Podobna streszczenie InterstitialAd::Listener klasa jest również przewidziane dla pełnoekranowych reklam, które mogą zostać rozszerzone, aby otrzymywać powiadomienia o zmianach stanu prezentacji pełnoekranowej reklamy.

Poniżej znajduje się przykład implementacja klasy, która rozszerza BannerView::Listener klasy (podobna realizacja może być stosowany do reklam pełnoekranowych):

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

Co dalej

Dowiedz się, jak zarabiać na swoją aplikację z AdMob i upewnij się, aby zastąpić identyfikatory jednostek reklamowych testy stosowane w tym podręczniku własnymi identyfikatorami jednostek reklamowych.