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

Schritt 3: Firebase Remote Config für bestimmte Anzeigenformate einrichten

Einführung: Hybridoptimierung Monetarisierung mit AdMob, Google Analytics und Firebase

Schritt 1: Verwenden Sie AdMob, um neue Anzeigenblöcke für das Displaynetzwerk zu erstellen.

Schritt 2: Google Analytics einrichten

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

Im letzten Schritt haben Sie sich mit Google Analytics-Zielgruppen vertraut gemacht. In In diesem Schritt erstellen Sie einen über booleschen Wert Remote Config gesteuerten Parameter (ad_control_switch genannt), bei dem das Feld „Käufer“ Zielgruppe. Sie werden Dann fügen Sie Ihrem App-Code die entsprechende Logik hinzu, den Wert dieses Parameters.

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

1. Führen Sie in der Firebase-Konsole folgende Schritte aus: Öffnen Sie Ihr Firebase-Projekt.

2. Maximieren Sie im linken Bereich den Abschnitt Interagieren und wählen Sie Remote Config:

3. Klicken Sie auf Konfiguration erstellen (oder auf Parameter hinzufügen, falls Sie bereits Remote Config vorher).

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

   1. Geben Sie im Feld Parametername den Wert ad_control_switch ein.

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

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

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

   1. Geben Sie in das Feld Name Purchasers Group oder einen anderen identifizierbarer Name der Bedingung).

   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ühre im Bereich Parameter erstellen die folgenden Schritte aus:

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

   2. Wählen Sie als Standardwert die Option true aus.

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

Mit dieser Konfiguration wird geprüft, ob sich der Nutzer im Bereich „Käufer“ befindet Zielgruppe (d. h. zahlende Nutzer):

• Wenn sich der Nutzer im Bereich „Käufer“ Zielgruppe, dann macht Remote Config gibt den Wert von false für den Parameter ad_control_switch zurück.

• Wenn der Nutzer nicht unter "Käufer" aufgeführt ist Zielgruppe, danach Remote Config gibt 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.

Remote Config SDK zu deiner App hinzufügen

Bevor Sie Remote Config in Ihrem Anwendungscode verwenden, fügen Sie den Parameter Remote Config SDK zur Codebasis deiner App hinzu. Beachten Sie, dass Ihre App bereits haben das Google Mobile Ads (AdMob) SDK und die Google Analytics for Firebase SDK aus den vorherigen Schritten dieser Anleitung.

Swift

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

pod 'Firebase/RemoteConfig'

Android

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

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

Flutter

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

flutter pub add firebase_remote_config

Einheit

Aktuelle Version herunterladen und installieren Firebase Unity SDK und fügen Sie dann Remote Config-Paket zu Ihrem Projekt 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 nach einem neuen Parameter gesucht wird. Werte einmal pro Stunde.

Swift

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

Kotlin+KTX

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

Java

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

Flutter

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

Einheit

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.

Dieser Aufruf sollte so früh wie möglich in der Ladephase Ihrer App erfolgen. da dieser Aufruf asynchron ist und Sie den Wert Remote Config benötigen. Vorabgerufen, damit Ihre App erkennt, ob eine Anzeige ausgeliefert werden soll.

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

Kotlin+KTX

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

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

Flutter

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

Einheit

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

Deine App ist jetzt so konfiguriert, dass sie den Remote Config-Parameter verarbeitet, den du die Sie zuvor in diesem Schritt erstellt haben.

Parameterwert Remote Config verwenden

Verwenden Sie den vorab abgerufenen Wert Remote Config in der Funktion loadAdUnit(), um Bestimmen Sie, ob die Anwendungsinstanz einen der folgenden Schritte ausführen 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: Das Anzeige (da der Nutzer ein zahlender Nutzer ist).

Swift

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

Kotlin+KTX

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

Java

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

Flutter

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

Einheit

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 einen Typ und eine Nullprüfung für abgerufene Remote Config-Parameterwerte.

App veröffentlichen

Da die Logik für die Schaltung der Anzeige innerhalb Ihrer Codebasis liegt, müssen Sie veröffentlicht eine neue Version deiner App, die diese Logik enthält.

Wenn Sie die Schritte in dieser Anleitung befolgt haben, sollte Ihre App sofort starten mit maßgeschneiderten In-App-Anzeigen. 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! Du hast die Anleitung zur Optimierung der hybriden Monetarisierung abgeschlossen mit AdMob, Google Analytics und Firebase.

Weitere Informationen

• Weitere Lösungsleitfäden:

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

• Videoreihe ansehen: App-Umsatz mit Firebase optimieren und AdMob

---

Schritt 2: Google Analytics einrichten

---