Tutoriel: Optimiser la monétisation hybride à l'aide d'AdMob, de Google Analytics et de Firebase

Étape 3: Configurez Firebase Remote Config pour diffuser des expériences publicitaires spécifiques

À la fin de la dernière étape, vous avez découvert les audiences Google Analytics. Dans cette étape, vous allez créer un paramètre booléen Remote Config (appelée ad_control_switch), qui exploite les options "Acheteurs" audience cible. Vous allez Ajoutez ensuite au code de votre application la logique correspondant à ce qu'elle doit afficher en fonction la valeur de ce paramètre.

Configurer les paramètres et conditions Remote Config dans la console Firebase

1. Dans la console Firebase, ouvrez votre projet Firebase.

2. Dans le volet de gauche, développez la section Engagement, puis sélectionnez Remote Config (Configuration à distance).

3. Cliquez sur Créer une configuration (ou sur Ajouter un paramètre si vous avez déjà utilisé Remote Config auparavant).

4. Dans le panneau Créer un paramètre, procédez comme suit :

   1. Dans le champ Nom du paramètre, saisissez ad_control_switch.

   2. Dans le menu déroulant Data type, sélectionnez Booléen.

   3. Cliquez sur Créer, puis sélectionnez Créer une condition.

5. Dans la boîte de dialogue Définir une nouvelle condition, procédez comme suit:

   1. Dans le champ Nom, saisissez Purchasers Group (ou tout autre nom nom identifiable de la condition).

   2. Dans le menu déroulant S'applique si, sélectionnez Audiences d'utilisateurs.

   3. Dans le menu déroulant Sélectionner des audiences, sélectionnez Acheteurs.

   4. Cliquez sur Save condition (Enregistrer la condition).

6. De retour dans le panneau Créer un paramètre, procédez comme suit:

   1. Pour la valeur de Groupe d'acheteurs, sélectionnez false.

   2. Dans le champ Valeur par défaut, sélectionnez true.

7. Cliquez sur Enregistrer, puis sur Publier les modifications.

Cette configuration vérifiera si l'utilisateur se trouve dans la catégorie "Acheteurs" audience (en d'autres termes, il s'agit d'un utilisateur payant):

• Si l'utilisateur se trouve dans la catégorie "Acheteurs" audience, alors Remote Config renvoyer la valeur de false pour le paramètre ad_control_switch.

• Si l'utilisateur ne figure pas dans la liste "Acheteurs" audience, puis Remote Config renverra la valeur true pour le paramètre ad_control_switch.

Dans les étapes suivantes, vous allez implémenter Remote Config dans votre application pour gérer ces valeurs de paramètres.

Ajouter le SDK Remote Config à votre application

Avant d'utiliser Remote Config dans le code de votre application, ajoutez le SDK Remote Config au codebase de votre application. Notez que votre application doit déjà inclure le SDK Google Mobile Ads (AdMob) et le SDK Google Analytics pour Firebase des étapes précédentes de ce tutoriel.

pod 'Firebase/RemoteConfig'

implementation 'com.google.firebase:firebase-config:22.0.0'

flutter pub add firebase_remote_config

Configurer l'instance Remote Config

Pour que votre application puisse utiliser les valeurs de paramètre Remote Config, configurez Remote Config afin de pouvoir récupérer de nouvelles valeurs pour l'application cliente Compute Engine.

Dans cet exemple, Remote Config est configuré pour rechercher un nouveau paramètre. 1 fois par heure.

remoteConfig = RemoteConfig.remoteConfig()
let settings = RemoteConfigSettings()
settings.minimumFetchInterval = 3600
remoteConfig.configSettings = settings

remoteConfig = Firebase.remoteConfig
val configSettings = remoteConfigSettings {
    minimumFetchIntervalInSeconds = 3600
}
remoteConfig.setConfigSettingsAsync(configSettings)

mFirebaseRemoteConfig = FirebaseRemoteConfig.getInstance();
FirebaseRemoteConfigSettings configSettings = new FirebaseRemoteConfigSettings.Builder()
        .setMinimumFetchIntervalInSeconds(3600)
        .build();
mFirebaseRemoteConfig.setConfigSettingsAsync(configSettings);

remoteConfig = FirebaseRemoteConfig.instance;
  final configSettings = FirebaseRemoteConfigSettings(
    minimumFetchInterval: Duration(hours: 1),
  );
  await remoteConfig.setConfigSettings(configSettings);

  // Use the `onConfigUpdated` callback to listen for changes to the config settings.
  remoteConfig.onConfigUpdated.listen((_) {
    print('Config settings confirmed');
  });

var remoteConfig = FirebaseRemoteConfig.DefaultInstance;
var configSettings = new ConfigSettings {
  MinimumFetchInternalInMilliseconds =
        (ulong)(new TimeSpan(1, 0, 0).TotalMilliseconds)
};
remoteConfig.SetConfigSettingsAsync(configSettings)
        .ContinueWithOnMainThread(task => {
          Debug.Log("Config settings confirmed");
}

Extraire et activer Remote Config

Récupérez et activez le paramètre Remote Config pour qu'il puisse commencer à l'utiliser les nouvelles valeurs de paramètres.

Vous devez effectuer cet appel le plus tôt possible dans la phase de chargement de votre application. Comme cet appel est asynchrone, vous aurez besoin d'extraire la valeur Remote Config à l'avance pour que votre application sache si une annonce doit être diffusée.

remoteConfig.fetch() { (status, error) -> Void in
  if status == .success {
    print("Config fetched!")
    self.remoteConfig.activate() { (changed, error) in
      // ...
    }
  } else {
    print("Config not fetched")
    print("Error: \(error?.localizedDescription ?? "No error available.")")
  }
  self.loadAdUnit()
}

remoteConfig.fetchAndActivate()
        .addOnCompleteListener(this) { task ->
            if (task.isSuccessful) {
                val updated = task.result
                Log.d(TAG, "Config params updated: $updated")
            } else {
                Log.d(TAG, "Config params failed to update")
            }
            loadAdUnit()
        }

mFirebaseRemoteConfig.fetchAndActivate()
        .addOnCompleteListener(this, new OnCompleteListener<Boolean>() {
            @Override
            public void onComplete(@NonNull Task<Boolean> task) {
                if (task.isSuccessful()) {
                    boolean updated = task.getResult();
                    Log.d(TAG, "Config params updated: " + updated);
                } else {
                    Log.d(TAG, "Config params failed to update");
                }
                loadAdUnit();
            }
        });

remoteConfig = FirebaseRemoteConfig.instance;

// Fetch and activate the latest Remote Config values.
final updated = await remoteConfig.fetchAndActivate();

// Check if the config params were updated successfully.
if (updated) {
  print('Config params updated');
} else {
  print('Config params failed to update');
}

// Load the ad unit.
_loadAdUnit();

remoteConfig.FetchAndActivateAsync().ContinueWithOnMainThread(task => {
  if (task.IsFaulted) {
    Debug.LogWarning("Config params failed to update");
  } else {
    Debug.Log("Config params updated: " + task.Result);
  }
  LoadAdUnit();
});

Votre application est maintenant configurée pour gérer le paramètre Remote Config que vous avez créé précédemment dans cette étape.

Utiliser la valeur du paramètre Remote Config

Utilisez la valeur Remote Config préchargée dans la fonction loadAdUnit() pour déterminer si l'instance d'application doit effectuer l'une des opérations suivantes:

• La valeur du paramètre ad_control_switch est résolue en true: affichez le une annonce interstitielle (car l'utilisateur est un utilisateur non payant).

• La valeur du paramètre ad_control_switch est résolue en false : n'affichez pas l'annonce (car l'utilisateur est un utilisateur payant).

private func loadAdUnit() {
  let showAds = remoteConfig["ad_control_switch"].boolValue

  if showAds {
    // Load interstitial ad (implemented ad unit)
    // per AdMob instructions (the first step of this tutorial).
  } else {
    // Don't show ads.
  }
}

private fun loadAdUnit() {
  var showAds = remoteConfig.getBoolean(ad_control_switch)

  if (showAds) {
      // Load interstitial ad (implemented ad unit)
      // per AdMob instructions (the first step of this tutorial).
    } else {
      // Don't show ads.
    }
}

private void loadAdUnit() {
    boolean showAds =
      mFirebaseRemoteConfig.getBoolean(ad_control_switch);

    if (showAds) {
      // Load interstitial ad (implemented ad unit)
      // per AdMob instructions (the first step of this tutorial).
    } else {
      // Don't show ads.
    }
}

void _loadAdUnit() {
  bool showAds = remoteConfig.getBool(ad_control_switch);

  if (showAds) {
    // Load interstitial ad (implemented ad unit)
    // per AdMob instructions (the first step of this tutorial).
  } else {
    // Don't show ads.
  }
}

void LoadAdUnit() {
  bool showAds =
      remoteConfig.GetValue("ad_control_switch").BooleanValue;

  if (showAds) {
    // Load interstitial ad (implemented ad unit)
    // per AdMob instructions (the first step of this tutorial).
  } else {
    // Don't show ads.
  }
}

Publier votre application

Étant donné que la logique d'affichage ou non de l'annonce dépend de votre codebase, vous devez publier une nouvelle version de votre application contenant cette logique.

Si vous avez suivi les étapes de ce tutoriel, votre application devrait démarrer immédiatement proposer une expérience publicitaire personnalisée dans l'application à vos utilisateurs. Vous pouvez surveiller Revenus publicitaires dans votre compte AdMob et dans Google Analytics tableaux de bord (dans la console Firebase ou l'interface utilisateur Google Analytics).

C'est tout ! Vous avez terminé le tutoriel sur l'optimisation de la monétisation hybride à l'aide de AdMob, Google Analytics et Firebase.

Ressources associées

• Consultez d'autres guides de solution:

  • Tester l'adoption du format d'annonce à l'aide de Firebase
  • Optimiser la fréquence des annonces avec Firebase

• Regardez une série de vidéos : Optimiser les revenus de votre application avec Firebase etAdMob

arrow_back_iosÉtape 2: Configurez Google Analytics