Anleitung: Hybride Monetarisierung mit AdMob, Google Analytics und Firebase optimieren

Schritt 3: Firebase Remote Config so einrichten, dass bestimmte Anzeigenformate ausgeliefert werden

Einführung: Hybridmonetarisierung mit AdMob, Google Analytics und Firebase optimieren

Schritt 1: Mit AdMob neue Anzeigenblöcke für die Anzeige erstellen

Schritt 2: Google Analytics einrichten

Schritt 3: Firebase Remote Config einrichten, um bestimmte Anzeigenformate zu präsentieren

Am Ende des letzten Schritts haben Sie Google Analytics-Zielgruppen kennengelernt. In diesem Schritt erstellen Sie einen booleschen Remote Config-Parameter (ad_control_switch), der die Zielgruppe „Käufer“ nutzt. Fügen Sie dann dem Code Ihrer App die Logik hinzu, die festlegt, was basierend auf dem Wert dieses Parameters angezeigt werden soll.

Remote Config-Parameter und ‑Bedingungen in der Firebase-Konsole einrichten

1. Öffnen Sie in der Firebase Console Ihr Firebase-Projekt.

2. Maximieren Sie im linken Bereich den Bereich Interagieren und wählen Sie Remote-Konfiguration aus.

3. Klicken Sie auf Konfiguration erstellen oder auf Parameter hinzufügen, wenn Sie Remote Config bereits verwendet haben.

4. Führen Sie im Bereich Parameter erstellen die folgenden Schritte aus:

   1. Geben Sie im Feld Parametername ad_control_switch ein.

   2. Wählen Sie im Drop-down-Menü Data type die Option Boolescher Wert aus.

   3. Klicken Sie auf Neu erstellen und wählen Sie Neue Bedingung erstellen aus.

5. Führen Sie im Dialogfeld Neue Bedingung definieren die folgenden Schritte aus:

   1. Geben Sie im Feld Name Purchasers Group oder einen anderen leicht erkennbaren Namen für die Bedingung ein.

   2. Wählen Sie im Drop-down-Menü Gilt, wenn… die Option Nutzerzielgruppe(n) aus.

   3. Wählen Sie im Drop-down-Menü Zielgruppe(n) auswählen die Option Käufer aus.

   4. Klicken Sie auf Bedingung speichern.

6. Führen Sie im Bereich Parameter erstellen die folgenden Schritte aus:

   1. Wählen Sie für den Wert von Käufergruppe die Option false aus.

   2. Wählen Sie für den Standardwert die Option true aus.

7. Klicken Sie auf Speichern und dann auf Änderungen veröffentlichen.

Bei dieser Konfiguration wird geprüft, ob der Nutzer zur Zielgruppe „Käufer“ gehört, also ein zahlender Nutzer ist:

• Wenn der Nutzer zur Zielgruppe „Käufer“ gehört, gibt Remote Config den Wert von false für den Parameter ad_control_switch zurück.

• Wenn sich der Nutzer nicht in der Zielgruppe „Käufer“ befindet, gibt Remote Config den Wert von true für den Parameter ad_control_switch zurück.

In den folgenden Schritten implementierst du Remote Config in deiner App, um diese Parameterwerte zu verarbeiten.

Fügen Sie Ihrer App das Remote Config SDK hinzu.

Bevor Sie Remote Config in Ihrem Anwendungscode verwenden, fügen Sie der Codebasis Ihrer App das Remote Config SDK hinzu. Ihre App sollte bereits das Google Mobile Ads SDK (AdMob) und das Google Analytics for Firebase SDK aus den vorherigen Schritten dieses Leitfadens enthalten.

Swift Android Flutter Einheit

Fügen Sie Ihrem Podfile den Remote Config-Pod hinzu und installieren Sie ihn:

pod 'Firebase/RemoteConfig'

Fügen Sie der Datei build.gradle die Abhängigkeit von der Bibliothek Remote Config hinzu:

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

Führen Sie im Stammverzeichnis Ihres Flutter-Projekts den folgenden Befehl aus, um das Remote Config-Plug-in zu installieren:

flutter pub add firebase_remote_config

Laden Sie das neueste Firebase Unity SDK herunter und installieren Sie es. Fügen Sie dann Ihrem Projekt das Remote Config-Paket hinzu:
FirebaseRemoteConfig.unitypackage

Instanz Remote Config konfigurieren

Damit Ihre App die Parameterwerte von Remote Config verwenden kann, konfigurieren Sie die Remote Config-Instanz so, dass neue Werte für die Client-App-Instanz abgerufen werden können.

In diesem Beispiel ist Remote Config so konfiguriert, dass einmal pro Stunde nach neuen Parameterwerten gesucht wird.

Swift KotlinJava Flutter Einheit

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

Remote Config abrufen und aktivieren

Rufen Sie den Parameter Remote Config ab und aktivieren Sie ihn, damit die neuen Parameterwerte verwendet werden können.

Sie sollten diesen Aufruf so früh wie möglich in der Ladephase Ihrer App ausführen, da er asynchron ist und Sie den Remote Config-Wert vorab abrufen müssen, damit Ihre App weiß, ob eine Anzeige präsentiert werden soll.

Swift KotlinJava Flutter Einheit

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

Ihre App ist jetzt so konfiguriert, dass der Parameter Remote Config verarbeitet wird, den Sie in diesem Schritt erstellt haben.

Parameterwert „Remote Config“ verwenden

Verwenden Sie den vorab abgerufenen Remote Config-Wert in der loadAdUnit()-Funktion, um zu bestimmen, ob die App-Instanz Folgendes tun soll:

• Der Parameterwert ad_control_switch wird in true aufgelöst: Interstitial-Anzeige ausliefern (da der Nutzer kein zahlender Nutzer ist).

• Der Parameterwert ad_control_switch wird in false aufgelöst: Anzeige nicht anzeigen, da der Nutzer ein zahlender Nutzer ist.

Swift KotlinJava Flutter Einheit

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.
  }
}

Hinweis: Im Produktionscode sollten Sie auch eine Typ- und Null-Prüfung für die abgerufenen Remote Config-Parameterwerte hinzufügen.

App veröffentlichen

Da sich die Logik für die Auslieferung der Anzeige in Ihrer Codebasis befindet, müssen Sie eine neue Version Ihrer App veröffentlichen, die diese Logik enthält.

Wenn Sie die Schritte in dieser Anleitung ausgeführt haben, sollten Ihre Nutzer in Ihrer App sofort personalisierte In-App-Anzeigen sehen. Sie können Ihren Werbeumsatz sowohl in Ihrem AdMob-Konto als auch in den Google Analytics-Dashboards (entweder in der Firebase-Konsole oder in der Google Analytics-Benutzeroberfläche) im Blick behalten.

Geschafft! Sie haben die Anleitung zur Optimierung der hybriden Monetarisierung mit AdMob, Google Analytics und Firebase abgeschlossen.

Weitere Informationen

• Weitere Lösungsleitfäden:

  • Verwendung von Anzeigenformaten mit Firebase testen
  • Anzeigenhäufigkeit mit Firebase optimieren

• Videoreihe ansehen: App-Umsatz mit Firebase undAdMob

---

Schritt 2: Google Analytics einrichten

---