Dieser Leitfaden richtet sich an Publisher, die eine C++ App mit AdMob ohne Firebase monetarisieren möchten. Wenn Sie Firebase in Ihre App einbinden möchten oder dies in Betracht ziehen, lesen Sie stattdessen die Version AdMob mit Firebase in diesem Leitfaden.
Die Einbindung des Google Mobile Ads C++ SDK in eine App ist der erste Schritt, um Anzeigen auszuliefern und Umsatz zu erzielen. Nach der Integration des SDK können Sie ein Anzeigenformat wie Interstitial oder Anzeigen mit Prämie auswählen und der Anleitung zur Implementierung folgen.
Das Google Mobile Ads C++ SDK umschließt die Google Mobile Ads SDKs für iOS und Android und ist nur auf diesen Plattformen verfügbar. Das Google Mobile Ads C++ SDK unterstützt Firebase C++-Konstrukte zur Unterstützung asynchroner Vorgänge und befindet sich daher im Namespace firebase::gma
.
Wenn Sie diese Anleitung zum ersten Mal durchlesen, sollten Sie sie herunterladen und die C++-Test-App für Google Mobile Ads verwenden.
Voraussetzungen
Android
- Sie verwenden Android Studio 3.2 oder höher.
- Die Build-Datei Ihrer App muss die folgenden Werte enthalten:
minSdkVersion
von 16 oder höhercompileSdkVersion
von 28 oder höher
iOS
- Verwenden Sie Xcode 13 oder höher.
- Ausrichtung auf iOS 10.0 oder höher
App in Ihrem AdMob-Konto einrichten
So registrieren Sie Ihre App als AdMob-App:
Melden Sie sich in einem AdMob-Konto an oder registrieren Sie sich für.
Registrieren Sie Ihre App bei AdMob. In diesem Schritt wird eine AdMob-App mit einer eindeutigen AdMob-App-ID erstellt, die später in diesem Leitfaden benötigt wird.
Google Mobile Ads C++ SDK installieren
Da sich das Google Mobile Ads C++ SDK im Namespace firebase::gma
befindet, müssen Sie das Firebase C++ SDK herunterladen und in ein Verzeichnis Ihrer Wahl entpacken.
Das Firebase C++ SDK ist nicht plattformspezifisch, erfordert jedoch plattformspezifische Bibliothekskonfigurationen.
Android
Wir empfehlen die Verwendung von CMake. Eine Anleitung für „ndk-build“ finden Sie in unserem allgemeinen Startleitfaden für das Firebase C++ SDK, um libfirebase_app.a
und libfirebase_gma.a
mit Ihrer App zu verknüpfen.
Geben Sie in der Datei
gradle.properties
Ihres Projekts den Speicherort des entpackten SDK an:systemProp.firebase_cpp_sdk.dir=FULL_PATH_TO_SDK
Fügen Sie der Datei
settings.gradle
Ihres Projekts den folgenden Inhalt hinzu:def firebase_cpp_sdk_dir = System.getProperty('firebase_cpp_sdk.dir') gradle.ext.firebase_cpp_sdk_dir = "$firebase_cpp_sdk_dir" includeBuild "$firebase_cpp_sdk_dir"
Fügen Sie der Gradle-Datei des Moduls (auf App-Ebene) – in der Regel
app/build.gradle
– den folgenden Inhalt hinzu. Darin ist auch die Bibliotheksabhängigkeit für das Google Mobile Ads C++ SDK enthalten.android.defaultConfig.externalNativeBuild.cmake { arguments "-DFIREBASE_CPP_SDK_DIR=$gradle.firebase_cpp_sdk_dir" } # Add the dependency for the Google Mobile Ads C++ SDK apply from: "$gradle.firebase_cpp_sdk_dir/Android/firebase_dependencies.gradle" firebaseCpp.dependencies { gma }
Fügen Sie der Datei
CMakeLists.txt
Ihres Projekts den folgenden Inhalt hinzu.# Add Firebase libraries to the target using the function from the SDK. add_subdirectory(${FIREBASE_CPP_SDK_DIR} bin/ EXCLUDE_FROM_ALL) # Add the Google Mobile Ads C++ SDK. # The Firebase C++ library `firebase_app` is required, # and it must always be listed last. set(firebase_libs firebase_gma firebase_app ) target_link_libraries(${target_name} "${firebase_libs}")
Synchronisieren Sie Ihre Anwendung, damit alle Abhängigkeiten die erforderlichen Versionen haben.
iOS
Die Schritte in diesem Abschnitt sind ein Beispiel dafür, wie Sie Ihrem iOS-Projekt das Google Mobile Ads C++ SDK hinzufügen.
Führen Sie folgenden Befehl aus, um CocoaPods Version 1 oder höher abzurufen:
sudo gem install cocoapods --pre
Fügen Sie den Google Mobile Ads-Pod aus dem entpackten SDK hinzu.
Erstellen Sie eine Podfile-Datei, falls Sie noch keine haben:
cd APP_DIRECTORY
pod init
Fügen Sie der Podfile-Datei die Pods für das Google Mobile Ads C++ SDK, das Google User Messaging Platform SDK und das minimale Firebase Core SDK hinzu, das für das GMA C++ SDK erforderlich ist:
pod 'Firebase/CoreOnly' pod 'Google-Mobile-Ads-SDK' pod 'GoogleUserMessagingPlatform'
Installieren Sie die Pods und öffnen Sie dann die Datei
.xcworkspace
in Xcode.pod install
open APP.xcworkspace
Fügen Sie dem Projekt die folgenden Frameworks aus dem Firebase C++ SDK hinzu:
xcframeworks/firebase.xcframework
xcframeworks/firebase_gma.xcframework
Fertig! Ihre C++ App ist so konfiguriert, dass das Google Mobile Ads C++ SDK ohne andere Firebase-Dienste verwendet wird.
AdMob-App-ID der App konfigurieren
Android
Führen Sie Schritt 3 unter App konfigurieren aus, wie im Mobile Ads SDK-Leitfaden für Android beschrieben, und kehren Sie dann zu dieser Seite zurück.
iOS
Folgen Sie dem Schritt Info.plist aktualisieren im Mobile Ads SDK-Leitfaden für iOS und kehren Sie dann zu dieser Seite zurück.
Google Mobile Ads SDK initialisieren
Bevor Anzeigen geladen werden, muss Ihre App das Google Mobile Ads C++ SDK initialisieren. Rufen Sie dazu firebase::gma::Initialize()
auf. Dadurch wird das SDK initialisiert und ein firebase::Future
wird ausgeführt, sobald die Initialisierung abgeschlossen ist (oder nach einer Zeitüberschreitung von 30 Sekunden). Dieser Vorgang muss nur einmal durchgeführt werden, idealerweise beim Start der App.
Anzeigen können nach dem Aufruf von Initialize()
vom Google Mobile Ads C++ SDK oder dem SDK von Vermittlungspartnern vorab geladen werden. Wenn Sie die Einwilligung von Nutzern im Europäischen Wirtschaftsraum (EWR) einholen, anfragespezifische Flags wie tag_for_child_directed_treatment
oder tag_for_under_age_of_consent
festlegen oder anderweitig vor dem Laden von Anzeigen Maßnahmen ergreifen müssen, müssen Sie firebase::gma::SetRequestConfiguration()
aufrufen, bevor Sie das Google Mobile Ads C++ SDK initialisieren. Weitere Informationen finden Sie in unserem Leitfaden zum Targeting.
Hier ein Beispiel für den Aufruf von Initialize()
:
Android
// Initialize the Google Mobile Ads library
firebase::InitResult result;
Future<AdapterInitializationStatus> future =
firebase::gma::Initialize(jni_env, j_activity, &result);
if (result != kInitResultSuccess) {
// Initialization immediately failed, most likely due to a missing
// dependency. Check the device logs for more information.
return;
}
// Monitor the status of the future.
// See "Use a Future to monitor the completion status of a method call" below.
if (future.status() == firebase::kFutureStatusComplete &&
future.error() == firebase::gma::kAdErrorCodeNone) {
// Initialization completed.
} else {
// Initialization on-going, or an error has occurred.
}
iOS
// Initialize the Google Mobile Ads library.
firebase::InitResult result;
Future<AdapterInitializationStatus> future =
firebase::gma::Initialize(&result);
if (result != kInitResultSuccess) {
// Initialization immediately failed, most likely due to a missing
// dependency. Check the device logs for more information.
return;
}
// Monitor the status of the future.
// See "Use a Future to monitor the completion status of a method call" below.
if (future.status() == firebase::kFutureStatusComplete &&
future.error() == firebase::gma::kAdErrorCodeNone) {
// Initialization completed.
} else {
// Initialization on-going, or an error has occurred.
}
Future
verwenden, um den Abschlussstatus eines Methodenaufrufs zu überwachen
Mit Future
können Sie den Abschlussstatus Ihrer asynchronen Methodenaufrufe ermitteln.
Wenn Ihre Anwendung beispielsweise firebase::gma::Initialize()
aufruft, wird ein neues firebase::Future
erstellt und zurückgegeben. Ihre App kann dann das status()
von Future
abfragen, um festzustellen, wann die Initialisierung abgeschlossen ist.
Anschließend kann Ihre Anwendung result()
aufrufen, um die resultierende AdapterInitializationStatus
abzurufen.
Methoden, die eine Future
zurückgeben, haben eine entsprechende Methode für das "letzte Ergebnis", mit der Apps den neuesten Future
für eine bestimmte Aktion abrufen können. Für firebase::gma::Initialize()
gibt es beispielsweise eine entsprechende Methode namens firebase::gma::InitializeLastResult()
, die ein Future
zurückgibt, mit dem Ihre Anwendung den Status des letzten Aufrufs von firebase::gma::Initialize()
prüfen kann.
Wenn der Status von Future
abgeschlossen ist und der Fehlercode firebase::gma::kAdErrorCodeNone
lautet, wurde der Vorgang erfolgreich abgeschlossen.
Sie können auch Callbacks registrieren, die aufgerufen werden, wenn ein Future
abgeschlossen ist. In einigen Fällen wird der Callback in einem anderen Thread ausgeführt. Achten Sie daher darauf, dass Ihr Code threadsicher ist. In diesem Code-Snippet wird ein Funktionszeiger für den Callback verwendet:
// Registers the OnCompletion callback. user_data is a pointer that is passed verbatim
// to the callback as a void*. This allows you to pass any custom data to the callback
// handler. In this case, the app has no data, so you must pass nullptr.
firebase::gma::InitializeLastResult().OnCompletion(OnCompletionCallback,
/*user_data=*/nullptr);
// The OnCompletion callback function.
static void OnCompletionCallback(
const firebase::Future<AdapterInitializationStatus>& future, void* user_data) {
// Called when the Future is completed for the last call to firebase::gma::Initialize().
// If the error code is firebase::gma::kAdErrorCodeNone,
// then the SDK has been successfully initialized.
if (future.error() == firebase::gma::kAdErrorCodeNone) {
// success!
} else {
// failure.
}
}
Anzeigenformat auswählen
Das Google Mobile Ads C++ SDK wurde importiert und Sie können eine Anzeige implementieren. AdMob bietet eine Reihe verschiedener Anzeigenformate, sodass Sie dasjenige auswählen können, das am besten zur Nutzererfahrung Ihrer App passt.
Banner
Rechteckige Anzeigen, die oben oder unten auf dem Bildschirm des Geräts eingeblendet werden. Banneranzeigen bleiben auf dem Bildschirm, während Nutzer mit der App interagieren, und können nach einer bestimmten Zeit automatisch aktualisiert werden. Wenn Sie neu in der mobilen Werbung sind, sind diese ein guter Ausgangspunkt.
Interstitial
Vollbildanzeigen, die die Benutzeroberfläche einer App verdecken, bis sie vom Nutzer geschlossen werden. Sie werden am besten bei natürlichen Pausen im Ausführungsfluss einer App eingesetzt, z. B. zwischen Leveln eines Spiels oder kurz nach Abschluss einer Aufgabe.
Interstitial-Anzeigen implementieren
Verfügbar
Anzeigen, bei denen Nutzer für das Ansehen von Kurzvideos und die Interaktion mit spielbaren Anzeigen und Umfragen belohnt werden. Wird zur Monetarisierung kostenloser Apps verwendet.