Questa guida è rivolta ai publisher che vogliono monetizzare un'app C++ con AdMob, senza utilizzare Firebase. Se prevedi di includere Firebase nella tua app o se lo stai prendendo in considerazione, consulta la versione di questa guida AdMob con Firebase.
Integrare l'SDK Google Mobile Ads C++ in un'app è il primo passo per visualizzare gli annunci e generare entrate. Una volta integrato l'SDK, puoi scegliere un formato dell'annuncio, ad esempio interstitial o con premio, e seguire i passaggi per implementarlo.
L'SDK Google Mobile Ads per C++ esegue il wrapping degli SDK Google Mobile Ads per iOS e Android
ed è disponibile solo su queste piattaforme. L'SDK Google Mobile Ads C++ utilizza
costrutti Firebase C++ per supportare le operazioni asincrone, pertanto si trova
nello spazio dei nomi firebase::gma
.
Se è la prima volta che consulti questa guida, ti consigliamo di scaricare e seguire le istruzioni utilizzando l'app di test Google Mobile Ads C++.
Prerequisiti
Android
- Utilizzare Android Studio 3.2 o versioni successive
- Assicurati che il file di build dell'app utilizzi i seguenti valori:
- Un
minSdkVersion
di 16 o superiore - Un
compileSdkVersion
di 28 o superiore
- Un
iOS
- Utilizza Xcode 13 o versioni successive
- Target iOS 10.0 o versioni successive
Configurare l'app nell'account AdMob
Registra la tua app come app AdMob completando i seguenti passaggi:
Accedi o registrati per un account AdMob.
Registra la tua app con AdMob. Questo passaggio crea un'app AdMob con un ID app AdMob univoco, necessario in un secondo momento in questa guida.
Installa l'SDK Google Mobile Ads C++
Poiché l'SDK Google Mobile Ads C++ si trova nello spazio dei nomi firebase::gma
,
scarica l'SDK Firebase C++
e decomprimilo in una directory a tua scelta.
L'SDK Firebase C++ non è specifico per la piattaforma, ma richiede configurazioni di librerie specifiche per la piattaforma.
Android
Ti consigliamo di utilizzare CMake, ma puoi trovare le istruzioni per ndk-build nella nostra
Guida introduttiva all'SDK Firebase C++ per
collegare libfirebase_app.a
e libfirebase_gma.a
alla tua app.
Nel file
gradle.properties
del progetto, specifica la posizione dell'SDK decompresso:systemProp.firebase_cpp_sdk.dir=FULL_PATH_TO_SDK
Aggiungi i seguenti contenuti al file
settings.gradle
del progetto: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"
Al file Gradle del modulo (a livello di app), in genere
app/build.gradle
, aggiungi i seguenti contenuti, che includono la dipendenza della libreria per l'SDK Google Mobile Ads C++.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 }
Aggiungi i seguenti contenuti al file
CMakeLists.txt
del progetto.# 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}")
Sincronizza la tua app per assicurarti che tutte le dipendenze abbiano le versioni necessarie.
iOS
I passaggi descritti in questa sezione sono un esempio di come aggiungere l'SDK Google Mobile Ads C++ al tuo progetto iOS.
Scarica CocoaPods versione 1 o successive eseguendo:
sudo gem install cocoapods --pre
Aggiungi il pod Google Mobile Ads dall'SDK decompresso.
Crea un Podfile se non ne hai già uno:
cd APP_DIRECTORY
pod init
Al Podfile, aggiungi i pod per l'SDK Google Mobile Ads C++, l'SDK Google User Messaging Platform e l'SDK Firebase Core minimo (richiesto dall'SDK GMA C++):
pod 'Firebase/CoreOnly' pod 'Google-Mobile-Ads-SDK' pod 'GoogleUserMessagingPlatform'
Installa i pod, quindi apri il file
.xcworkspace
in Xcode.pod install
open APP.xcworkspace
Aggiungi al progetto i seguenti framework dell'SDK Firebase C++:
xcframeworks/firebase.xcframework
xcframeworks/firebase_gma.xcframework
Ecco fatto! La tua app C++ è configurata per utilizzare l'SDK Google Mobile Ads C++ senza altri servizi Firebase.
Configurare l'ID app AdMob della tua app
Android
Segui il passaggio 3 della sezione Configura l'app come descritto nella guida per Android dell'SDK Google Mobile Ads, poi torna a questa pagina.
iOS
Segui il passaggio Aggiorna il file Info.plist come descritto nella guida per iOS dell'SDK Mobile Ads e poi torna a questa pagina.
Inizializza l'SDK Google Mobile Ads
Prima di caricare gli annunci, l'app deve inizializzare l'SDK Google Mobile Ads C++ chiamando
firebase::gma::Initialize()
, che inizializza l'SDK e completa un
firebase::Future
una volta completata l'inizializzazione (o dopo un timeout di 30 secondi). Questa operazione deve essere eseguita una sola volta, idealmente all'avvio dell'app.
Gli annunci potrebbero essere precaricati dall'SDK Google Mobile Ads C++ o dagli SDK dei partner di mediazione
al momento della chiamata di Initialize()
. Se devi ottenere il consenso degli utenti nello
Spazio economico europeo (SEE), imposta eventuali flag specifici della richiesta (ad esempio
tag_for_child_directed_treatment
o tag_for_under_age_of_consent
) oppure
intervieni in altro modo prima di caricare gli annunci. Assicurati di farlo richiamando
firebase::gma::SetRequestConfiguration()
prima di inizializzare l'SDK Google Mobile
Ads C++. Per saperne di più, consulta la nostra guida al targeting.
Ecco un esempio di come chiamare 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.
}
Utilizza un Future
per monitorare lo stato di completamento di una chiamata al metodo
Un Future
ti consente di determinare lo stato di completamento delle chiamate
ai metodi asincroni.
Ad esempio, quando la tua app chiama firebase::gma::Initialize()
, viene creato e restituito un nuovo
firebase::Future
. La tua app può quindi eseguire il polling di
status()
di Future
per determinare quando l'inizializzazione è stata completata.
Una volta completata, l'app può richiamare result()
per ottenere il AdapterInitializationStatus
risultante.
I metodi che restituiscono un Future
hanno un metodo "ultimo risultato" corrispondente che
le app possono utilizzare per recuperare l'Future
più recente per una determinata azione. Ad esempio, firebase::gma::Initialize()
ha un metodo corrispondente chiamato firebase::gma::InitializeLastResult()
, che restituisce un Future
che la tua app può utilizzare per controllare lo stato dell'ultima chiamata a firebase::gma::Initialize()
.
Se lo stato di Future
è completato e il codice di errore è
firebase::gma::kAdErrorCodeNone
, l'operazione è stata completata
correttamente.
Puoi anche registrare i callback da richiamare al termine di un Future
. In
alcuni casi, il callback verrà eseguito in un thread diverso, quindi assicurati
che il codice sia thread-safe. Questo snippet di codice utilizza un puntatore a funzione per il
callback:
// 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.
}
}
Seleziona un formato dell'annuncio
L'SDK Google Mobile Ads C++ è ora importato e puoi implementare un annuncio. AdMob offre diversi formati di annunci, così puoi scegliere quello più adatto all'esperienza utente della tua app.
Banner
Annunci rettangolari che vengono visualizzati nella parte superiore o inferiore dello schermo del dispositivo. Gli annunci banner rimangono sullo schermo mentre gli utenti interagiscono con l'app e possono aggiornarsi automaticamente dopo un determinato periodo di tempo. Se non hai mai utilizzato la pubblicità mobile, sono un ottimo punto di partenza.
Implementare gli annunci banner
Interstitial
Annunci a schermo intero che coprono l'interfaccia di un'app finché non vengono chiusi dall'utente. Sono più adatti per le pause naturali nel flusso di esecuzione di un'app, ad esempio tra i livelli di un gioco o subito dopo il completamento di un'attività.
Implementare gli annunci interstitial
Con premio
Annunci che premiano gli utenti per la visione di brevi video e/o l'interazione con annunci demo e sondaggi. Utilizzato per monetizzare le app free-to-play.