Ce guide est destiné aux éditeurs qui souhaitent monétiser une application C++ avec AdMob sans utiliser Firebase. Si vous envisagez d'inclure Firebase dans votre application (ou si vous envisagez de le faire), consultez plutôt la version AdMob avec Firebase de ce guide.
L'intégration du SDK C++ Google Mobile Ads à une application est la première étape pour diffuser des annonces et générer des revenus. Une fois le SDK intégré, vous pouvez choisir un format d'annonce (interstitiel ou avec récompense, par exemple), puis suivre les étapes d'implémentation.
Le SDK C++ Google Mobile Ads inclut les SDK Google Mobile Ads pour iOS et Android, et n'est disponible que sur ces plates-formes. Le SDK C++ Google Mobile Ads utilise les constructions Firebase C++ pour permettre les opérations asynchrones. Il se trouve donc dans l'espace de noms firebase::gma
.
Si vous consultez ce guide pour la première fois, nous vous recommandons de le télécharger et de suivre les instructions de l'application de test C++ Google Mobile Ads.
Conditions préalables
Android
- Utiliser Android Studio 3.2 ou version ultérieure
- Assurez-vous que le fichier de compilation de votre application utilise les valeurs suivantes :
minSdkVersion
égal à 16 ou pluscompileSdkVersion
égal à 28 ou plus
iOS
- Utilisez Xcode 13 ou une version ultérieure
- Cibler iOS 10.0 ou version ultérieure
Configurer votre application dans votre compte AdMob
Pour enregistrer votre application en tant qu'application AdMob, procédez comme suit:
Connectez-vous à un compte AdMob ou créez-en un.
Enregistrez votre application auprès d'AdMob. Cette étape permet de créer une application AdMob avec un ID d'application AdMob unique, plus loin dans ce guide.
Installer le SDK C++ Google Mobile Ads
Étant donné que le SDK C++ Google Mobile Ads se trouve dans l'espace de noms firebase::gma
, téléchargez le SDK Firebase C++, puis décompressez-le dans le répertoire de votre choix.
Le SDK Firebase C++ n'est pas spécifique à la plate-forme, mais nécessite des configurations de bibliothèque spécifiques à la plate-forme.
Android
Nous vous recommandons d'utiliser CMake, mais vous pouvez trouver des instructions pour ndk-build dans notre guide de démarrage général du SDK Firebase C++ pour associer libfirebase_app.a
et libfirebase_gma.a
à votre application.
Dans le fichier
gradle.properties
de votre projet, spécifiez l'emplacement du SDK décompressé:systemProp.firebase_cpp_sdk.dir=FULL_PATH_TO_SDK
Dans le fichier
settings.gradle
de votre projet, ajoutez le contenu suivant: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"
Dans votre fichier Gradle de votre module (au niveau de l'application), généralement
app/build.gradle
, ajoutez le contenu suivant, qui inclut la dépendance de la bibliothèque pour le SDK C++ 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 }
Ajoutez le contenu suivant au fichier
CMakeLists.txt
de votre projet.# 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}")
Synchronisez votre application pour vous assurer que toutes les dépendances disposent des versions nécessaires.
iOS
Les étapes de cette section montrent comment ajouter le SDK C++ Google Mobile Ads à votre projet iOS.
Obtenez CocoaPods version 1 ou ultérieure en exécutant la commande suivante:
sudo gem install cocoapods --pre
Ajoutez la série d'annonces Google Mobile Ads à partir du SDK décompressé.
Créez un fichier Podfile si vous n'en avez pas déjà un:
cd APP_DIRECTORY
pod init
Ajoutez le pod correspondant au SDK C++ Google Mobile Ads à votre fichier Podfile:
pod 'Google-Mobile-Ads-SDK'
Installez le pod, puis ouvrez le fichier
.xcworkspace
dans Xcode.pod install
open APP.xcworkspace
Ajoutez les frameworks suivants à partir du SDK Firebase C++ au projet:
xcframeworks/firebase.xcframework
xcframeworks/firebase_gma.xcframework
Vous avez terminé. Votre application C++ est configurée pour utiliser le SDK C++ Google Mobile Ads sans aucun autre service Firebase.
Configurer l'ID d'application AdMob de votre application
Android
Suivez l'étape 3 de la section Configurer votre application comme décrit dans le guide Android sur le SDK Mobile Ads, puis revenez sur cette page.
iOS
Suivez l'étape Mettez à jour votre fichier Info.plist comme décrit dans le guide iOS du SDK Mobile Ads, puis revenez sur cette page.
Initialiser le SDK Google Mobile Ads
Avant de charger des annonces, demandez à votre application d'initialiser le SDK C++ Google Mobile Ads en appelant firebase::gma::Initialize()
, qui initialise le SDK et termine une firebase::Future
une fois l'initialisation terminée (ou après un délai de 30 secondes). Cette opération ne doit être effectuée qu'une seule fois, idéalement au lancement de l'application.
Les annonces peuvent être préchargées par le SDK C++ Google Mobile Ads ou les SDK des partenaires de médiation lors de l'appel de Initialize()
. Si vous devez obtenir le consentement des utilisateurs de l'Espace économique européen (EEE), définissez des indicateurs propres à la requête (tels que tag_for_child_directed_treatment
ou tag_for_under_age_of_consent
) ou prenez les mesures nécessaires avant de charger des annonces, assurez-vous d'effectuer cette opération en appelant firebase::gma::SetRequestConfiguration()
avant d'initialiser le SDK C++ Google Mobile Ads. Pour en savoir plus, consultez notre guide sur le ciblage.
Voici un exemple d'appel de 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.
}
Utiliser un Future
pour surveiller l'état d'avancement d'un appel de méthode
Un Future
vous permet de déterminer l'état d'avancement de vos appels de méthode asynchrones.
Par exemple, lorsque votre application appelle firebase::gma::Initialize()
, une firebase::Future
est créée et renvoyée. Votre application peut ensuite interroger le status()
de Future
pour déterminer quand l'initialisation est terminée.
Une fois l'opération terminée, votre application peut appeler result()
pour obtenir le AdapterInitializationStatus
obtenu.
Les méthodes qui renvoient un Future
ont une méthode "dernier résultat" correspondante que les applications peuvent utiliser pour récupérer le Future
le plus récent pour une action donnée. Par exemple, firebase::gma::Initialize()
possède une méthode correspondante appelée firebase::gma::InitializeLastResult()
, qui renvoie un élément Future
que votre application peut utiliser pour vérifier l'état du dernier appel à firebase::gma::Initialize()
.
Si l'état de Future
est terminé et que son code d'erreur est firebase::gma::kAdErrorCodeNone
, l'opération a abouti.
Vous pouvez également enregistrer des rappels à invoquer lorsqu'une Future
est terminée. Dans certains cas, le rappel sera exécuté dans un autre thread. Assurez-vous donc que votre code est thread-safe. Cet extrait de code utilise un pointeur de fonction pour le rappel:
// 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.
}
}
Sélectionnez un format d'annonce
Le SDK Google Mobile Ads C++ est importé et vous êtes prêt à implémenter une annonce. AdMob propose différents formats d'annonces afin que vous puissiez choisir celui qui convient le mieux à l'expérience utilisateur de votre application.
Bannière
Annonces rectangulaires qui s'affichent en haut ou en bas de l'écran de l'appareil. Les bannières restent à l'écran lorsque les utilisateurs interagissent avec l'application. Elles peuvent s'actualiser automatiquement au bout d'un certain temps. Si vous faites vos premiers pas dans la publicité mobile, c'est un bon point de départ.
Interstitiel
Annonces en plein écran qui couvrent l'interface d'une application jusqu'à ce qu'elles soient fermées par l'utilisateur. Ils sont particulièrement adaptés à des pauses naturelles dans le flux d'exécution d'une application, par exemple entre deux niveaux d'un jeu ou juste après la fin d'une tâche.
Implémenter des annonces interstitielles
Accordé
Annonces qui récompensent les utilisateurs pour avoir regardé des vidéos courtes, et interagi avec des annonces jouables et des enquêtes. Permet de monétiser les applications sans frais.