Tutorial: ottimizzare la frequenza degli annunci AdMob

Passaggio 3: gestisci i valori dei parametri Remote Config nel codice dell'app


Introduzione: Ottimizza AdMob la frequenza degli annunci utilizzando Firebase
Passaggio 1: Utilizza AdMob per creare nuove varianti di unità pubblicitarie per i test
Passaggio 2: Configura un test A/B nella console Firebase

Passaggio 3: Gestisci i valori dei parametri Remote Config nel codice dell'app

Passaggio 4: Avvia il test A/B ed esamina i risultati nella console Firebase
Passaggio 5: Decidi se implementare il nuovo formato dell'annuncio


Al termine dell'ultimo passaggio, hai creato un parametro Remote Config (INTERSTITIAL_AD_KEY). In questo passaggio, aggiungerai la logica al codice dell'app per indicare cosa deve visualizzare l'app in base al valore di questo parametro.

Aggiungi gli SDK necessari

Prima di utilizzare Remote Config nel codice dell'applicazione, aggiungi sia l' Remote Config SDK sia l'SDK Firebase per Google Analytics ai file di build del progetto.

Swift

Aggiungi e installa i seguenti pod nel tuo podfile:

pod 'Google-Mobile-Ads-SDK'
pod 'Firebase/Analytics'
pod 'Firebase/RemoteConfig'

Objective-C

Aggiungi e installa i seguenti pod nel tuo podfile:

pod 'Google-Mobile-Ads-SDK'
pod 'Firebase/Analytics'
pod 'Firebase/RemoteConfig'

Android

Aggiungi le seguenti dipendenze della libreria al file build.gradle:

implementation 'com.google.android.gms:play-services-ads:25.2.0'
implementation 'com.google.firebase:firebase-analytics:23.2.0'
implementation 'com.google.firebase:firebase-config:23.1.0'

Unity

Scarica e installa l'SDK Firebase Unity, quindi aggiungi i seguenti pacchetti Unity al tuo progetto:

  • FirebaseAnalytics.unitypackage
  • FirebaseRemoteConfig.unitypackage

Configura l'istanza Remote Config

Per utilizzare i valori parametro di Remote Config, configura l' Remote Config istanza in modo che sia impostata per recuperare nuovi valori per l' istanza dell'app client.

In questo esempio, Remote Config è configurato per verificare la presenza di nuovi valori parametro una volta all'ora.

Swift 

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

Objective-C 

self.remoteConfig = [FIRRemoteConfig remoteConfig];
FIRRemoteConfigSettings *remoteConfigSettings = [[FIRRemoteConfigSettings alloc] init];
remoteConfigSettings.minimumFetchInterval = 3600;
self.remoteConfig.configSettings = remoteConfigSettings;

Java 

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

Kotlin 

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

Unity 

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");
}

Recupera e attiva Remote Config

Recupera e attiva i parametri Remote Config in modo che possano iniziare a utilizzare i nuovi valori parametro.

Ti consigliamo di effettuare questa chiamata il prima possibile durante la fase di caricamento dell'app poiché si tratta di una chiamata asincrona e l'app avrà bisogno del Remote Config valore precaricato per sapere quale annuncio mostrare.

Swift 

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()
}

Objective-C 

[self.remoteConfig fetchWithCompletionHandler:^(FIRRemoteConfigFetchStatus status, NSError *error) {
    if (status == FIRRemoteConfigFetchStatusSuccess) {
        NSLog(@"Config fetched!");
      [self.remoteConfig activateWithCompletion:^(BOOL changed, NSError * _Nullable error) {
        // ...
      }];
    } else {
        NSLog(@"Config not fetched");
        NSLog(@"Error %@", error.localizedDescription);
    }
    [self loadAdUnit];
}];

Java 

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();
            }
        });

Kotlin 

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()
        }

Unity 

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

L'app è ora pronta per gestire il parametro Remote Config che hai creato durante la configurazione del test A/B in precedenza in questo tutorial.

Utilizza il valore parametro Remote Config

Utilizza il valore Remote Config precaricato nella funzione loadAdUnit() per determinare quale variante di frequenza degli annunci deve essere mostrata per questa istanza dell'app.

Swift 

private func loadAdUnit() {
  let adUnitId = remoteConfig["INTERSTITIAL_AD_KEY"].stringValue;
  let request = GADRequest()
  GADInterstitialAd.load(withAdUnitID: adUnitId,
                               request: request,
                     completionHandler: { [self] ad, error in
                       if let error = error {
                         print("Failed to load: \(error.localizedDescription)")
                         return
                       }
                       interstitial = ad
                       // Register for callbacks.
                     }
  )
}

// Register for callbacks.

Objective-C 

- (void)loadAdUnit {
    NSString *adUnitId =
      self.remoteConfig[@"INTERSTITIAL_AD_KEY"].stringValue;

  GADRequest *request = [GADRequest request];
  [GADInterstitialAd loadAdWithAdUnitId:adUnitId
                         request:request
                         completionHandler:^(GADInterstitialAd *ad,
                             NSError *error) {
    if (error) {
      NSLog(@"Failed to load interstitial ad with error: %@",
        [error localizedDescription]);
      return;
    }

    self.interstitial = ad;
  }];
}

Java 

private void loadAdUnit() {
    String adUnitId =
      mFirebaseRemoteConfig.getString("INTERSTITIAL_AD_KEY");

    // Load Interstitial Ad (assume adUnitId not null)
    AdRequest adRequest = new AdRequest.Builder().build();

    InterstitialAd.load(this, adUnitId, adRequest, new
        InterstitialAdLoadCallback() {
          @Override
          public void onAdLoaded(@NonNull InterstitialAd intertitialAd) {
            mInterstitialAd = interstitialAd;
          }

          @Override
          public void onAdFailedToLoad(@NonNull LoadAdError loadAdError) {
            mInterstitialAd = null;
          }
    });
}

Kotlin 

private fun loadAdUnit() {
  String adUnitId = remoteConfig.getString("INTERSTITIAL_AD_KEY")
  var adRequest = AdRequestBuilder.Builder().build()

  AdRequestBuilder.load(this, adUnitId, adRequest, object :
    InterstitialAdLoadCallback() {
      override fun onAdFailedToLoad(adError: LoadAdError) {
        mInterstitialAd = null
      }

      override fun onAdLoaded(interstitialAd: InterstitialAd) {
        mInterstitialAd = interstitialAd
      }
    })
}

Unity 

void LoadAdUnit() {

  // Note that you may want to encode and parse two sets of ad unit IDs for
  // Android / iOS in the Unity implementation.
  String adUnitId = remoteConfig.GetValue("INTERSTITIAL_AD_KEY").StringValue;
  this.interstitial = new InterstitialAd(adUnitId);
}

Aggiungi altri controlli per il valore parametro

Esistono altre aree nel codice dell'applicazione in cui dovrai controllare il valore di questo Remote Config parametro per stabilire quale esperienza pubblicitaria verrà caricata. Ad esempio, puoi decidere se ricaricare un annuncio dopo che l'utente ha finito di visualizzare quello attuale.

Le chiamate di recupero e attivazione devono essere effettuate per prime per ottenere eventuali modifiche dei valori dei parametri, ad esempio se decidi di terminare o creare un nuovo esperimento.

Da qui, puoi sempre controllare il valore del parametro utilizzando le seguenti chiamate:

Swift 

remoteConfig["INTERSTITIAL_AD_KEY"].stringValue

Objective-C 

self.remoteConfig[@"INTERSTITIAL_AD_KEY"].stringValue;

Java 

mFirebaseRemoteConfig.getString(INTERSTITIAL_AD_KEY)

Kotlin 

remoteConfig.getString(INTERSTITIAL_AD_KEY)

Unity 

remoteConfig.GetValue("INTERSTITIAL_AD_KEY").StringValue

Queste chiamate restituiranno sempre lo stesso valore per un'istanza dell'app, a seconda che sia stata inserita nel gruppo di controllo o in uno dei nuovi gruppi di varianti di annunci, a meno che non siano state apportate modifiche nella Firebase console che sono state recuperate e attivate nelle chiamate precedenti.



Passaggio 2: configura un test A/B nella console Firebase Passaggio 4: avvia il test A/B ed esamina i risultati