Per iniziare

Questa guida è rivolta ai publisher che intendono monetizzare un'app C++ con AdMob e non utilizzano Firebase. Se hai intenzione di includere Firebase nella tua app (o ti stai prendendo in considerazione), consulta la versione AdMob con Firebase di questa guida.

L'integrazione dell'SDK Google Mobile Ads C++ in un'app è il primo passo da compiere 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 C++ unisce gli SDK Google Mobile Ads per iOS e Android ed è disponibile solo su tali piattaforme. L'SDK Google Mobile Ads C++ utilizza i costrutti Firebase C++ per supportare le operazioni asincrone, pertanto risiede nello spazio dei nomi firebase::gma.

Se è la prima volta che consulti questa guida, ti consigliamo di scaricare e seguire l'utilizzo dell'app Google Mobile Ads per i test C++.

Prerequisiti

Android

  • Utilizzare Android Studio 3.2 o versioni successive
  • Assicurati che il file di build dell'app utilizzi i seguenti valori:
    • A minSdkVersion di 16 o più
    • compileSdkVersion di 28 o superiore

iOS

  • Utilizza Xcode 13 o superiore
  • Scegliere come target iOS 10.0 o versioni successive

Configura l'app nell'account AdMob

Registra la tua app come app AdMob completando i seguenti passaggi:

  1. Accedi o registrati a un account AdMob.

  2. Registra la tua app con AdMob. Questo passaggio crea un'app AdMob con un ID app AdMob univoco necessario in seguito in questa guida.

Installa l'SDK Google Mobile Ads per C++

Poiché l'SDK C++ di Google Mobile Ads risiede nello spazio dei nomi firebase::gma, scarica l'SDK Firebase C++, quindi decomprimilo in una directory a tua scelta.

L'SDK Firebase C++ non è specifico di una piattaforma, ma richiede configurazioni di librerie specifiche.

Android

  1. Nel file gradle.properties del tuo progetto, specifica la posizione dell'SDK non compresso:

      systemProp.firebase_cpp_sdk.dir=full-path-to-SDK
    
  2. Nel file settings.gradle del tuo progetto, aggiungi i seguenti contenuti:

      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"
    
  3. Nel file Gradle del tuo modulo (a livello di app), solitamente di app/build.gradle, aggiungi i seguenti contenuti, che includono la dipendenza dalla libreria per l'SDK C++ di Google Mobile Ads.

      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
      }
    
  4. Nel file CMakeLists.txt del tuo progetto, aggiungi i contenuti seguenti.

      # 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}")
    
  5. Sincronizza la tua app per assicurarti che tutte le dipendenze abbiano le versioni necessarie.

Ecco fatto! La tua app C++ è configurata per utilizzare l'SDK C++ di Google Mobile Ads senza altri servizi Firebase.

iOS

I passaggi di questa sezione sono un esempio di come aggiungere l'SDK C++ di Google Mobile Ads al tuo progetto iOS.

  1. Ottieni CocoaPods 1 o versioni successive eseguendo:

    sudo gem install cocoapods --pre
    
  2. Aggiungi il pod Google Mobile Ads dall'SDK non compresso.

    1. Crea un Podfile se non ne hai già uno:

      cd your-app-directory
      pod init
      
    2. Nel podfile, aggiungi il pod per l'SDK Google Mobile Ads C++:

        pod 'Google-Mobile-Ads-SDK'
      
    3. Installa il pod, quindi apri il file .xcworkspace in Xcode.

      pod install
      open your-app.xcworkspace
      
    4. Aggiungi i seguenti framework dall'SDK Firebase C++ al progetto:

      • xcframeworks/firebase.xcframework
      • xcframeworks/firebase_gma.xcframework

Ecco fatto! La tua app C++ è configurata per utilizzare l'SDK C++ di Google Mobile Ads senza altri servizi Firebase.

Configurare l'ID app AdMob per l'app

Android

Segui il passaggio 3 della sezione Configura l'app come descritto nella guida dell'SDK Mobile Ads per Android, poi torna in questa pagina iniziale di C++.

iOS

Segui il passaggio Aggiorna il tuo file Info.plist come descritto nella guida dell'SDK Mobile Ads per iOS, quindi torna in questa pagina iniziale di C++.

Inizializzare l'SDK Google Mobile Ads

Prima di caricare gli annunci, chiedi all'app di inizializzare l'SDK C++ di Google Mobile Ads chiamando firebase::gma::Initialize() per inizializzare l'SDK e completare un firebase::Future al termine dell'inizializzazione (o dopo un timeout di 30 secondi). Questa operazione deve essere eseguita una sola volta, idealmente al momento del lancio dell'app.

Gli annunci possono essere precaricati dagli SDK Google Mobile Ads C++ o dagli SDK dei partner di mediazione al momento della chiamata Initialize(). Se devi ottenere il consenso degli utenti nello Spazio economico europeo (SEE), impostare flag specifici per le richieste (ad esempio tag_for_child_directed_treatment o tag_for_under_age_of_consent) o intraprendere altre azioni prima di caricare gli annunci, assicurati di farlo richiamando firebase::gma::SetRequestConfiguration() prima di inizializzare l'SDK C++ di Google Mobile Ads. Per scoprire di più, consulta la nostra guida relativa 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 di metodo

Un Future fornisce un modo per determinare lo stato di completamento delle chiamate del metodo asincrono.

Ad esempio, quando la tua app chiama firebase::gma::Initialize(), viene creata e restituita una nuova firebase::Future. La tua app può quindi eseguire il polling del status() di Future per determinare quando l'inizializzazione è stata completata. Al termine, l'app può richiamare result() per ottenere il risultato AdapterInitializationStatus.

I metodi che restituiscono un Future hanno un metodo "ultimo risultato" corrispondente che le app possono utilizzare per recuperare 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 è completo e il codice di errore è firebase::gma::kAdErrorCodeNone, l'operazione è stata completata correttamente.

Puoi anche registrare callback da richiamare quando viene completato un Future. In alcuni casi, il callback verrà eseguito in un thread diverso, quindi assicurati che il codice sia sicuro per il thread. Questo snippet di codice utilizza un puntatore 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 C++ di Google Mobile Ads ora è importato e ora puoi implementare un annuncio. AdMob offre vari formati degli annunci per consentirti di scegliere quello più adatto all'esperienza utente della tua app.

Annunci rettangolari 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 essere aggiornati automaticamente dopo un determinato periodo di tempo. Se non hai mai utilizzato la pubblicità per il mobile, sono un ottimo punto di partenza.

Implementare gli annunci banner

Interstitial

Annunci a schermo intero che coprono l'interfaccia di un'app fino alla chiusura dall'utente. Vengono usati al meglio nelle pause naturali del 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 l'interazione con annunci e sondaggi demo. Categoria relativa alla monetizzazione delle app free-to-play.

Implementare gli annunci con premio