Wenn Sie ein Parse-Benutzer sind und nach einer alternativen Backend-as-a-Service-Lösung suchen, ist Firebase möglicherweise die ideale Wahl für Ihre Android-App.
In dieser Anleitung wird beschrieben, wie Sie bestimmte Dienste in Ihre App integrieren. Grundlegende Anleitungen zur Firebase-Einrichtung finden Sie im Android-Setup- Leitfaden.
Google Analytics
Google Analytics ist eine kostenlose App-Messlösung, die Einblicke in die App-Nutzung und das Nutzerengagement bietet. Analytics lässt sich in alle Firebase-Funktionen integrieren und bietet Ihnen unbegrenzte Berichte für bis zu 500 verschiedene Ereignisse, die Sie mit dem Firebase SDK definieren können.
Weitere Informationen finden Sie in den Google Analytics-Dokumenten .
Vorgeschlagene Migrationsstrategie
Die Verwendung verschiedener Analyseanbieter ist ein häufiges Szenario, das problemlos auf Google Analytics anwendbar ist. Fügen Sie es einfach zu Ihrer App hinzu, um von Ereignissen und Benutzereigenschaften zu profitieren, die Analytics automatisch erfasst, wie z. B. erstes Öffnen, App-Update, Gerätemodell, Alter.
Für benutzerdefinierte Ereignisse und Benutzereigenschaften können Sie eine Double-Write-Strategie anwenden, indem Sie sowohl Parse Analytics als auch Google Analytics verwenden, um Ereignisse und Eigenschaften zu protokollieren, was Ihnen die schrittweise Einführung der neuen Lösung ermöglicht.
Code-Vergleich
Analysen analysieren
// Start collecting data
ParseAnalytics.trackAppOpenedInBackground(getIntent());
Map<String, String> dimensions = new HashMap<String, String>();
// Define ranges to bucket data points into meaningful segments
dimensions.put("priceRange", "1000-1500");
// Did the user filter the query?
dimensions.put("source", "craigslist");
// Do searches happen more often on weekdays or weekends?
dimensions.put("dayType", "weekday");
// Send the dimensions to Parse along with the 'search' event
ParseAnalytics.trackEvent("search", dimensions);
Google Analytics
// Obtain the FirebaseAnalytics instance and start collecting data
mFirebaseAnalytics = FirebaseAnalytics.getInstance(this);
Bundle params = new Bundle();
// Define ranges to bucket data points into meaningful segments
params.putString("priceRange", "1000-1500");
// Did the user filter the query?
params.putString("source", "craigslist");
// Do searches happen more often on weekdays or weekends?
params.putString("dayType", "weekday");
// Send the event
mFirebaseAnalytics.logEvent("search", params);
Firebase-Echtzeitdatenbank
Die Firebase Realtime Database ist eine in der NoSQL-Cloud gehostete Datenbank. Die Daten werden als JSON gespeichert und in Echtzeit mit jedem verbundenen Client synchronisiert.
Weitere Informationen finden Sie in der Dokumentation zur Firebase-Echtzeitdatenbank .
Unterschiede zu Parse-Daten
Objekte
In Parse speichern Sie ein ParseObject oder eine Unterklasse davon, die Schlüssel-Wert-Paare JSON-kompatibler Daten enthält. Die Daten sind schemalos, was bedeutet, dass Sie nicht angeben müssen, welche Schlüssel in jedem ParseObject vorhanden sind.
Alle Daten der Firebase-Echtzeitdatenbank werden als JSON-Objekte gespeichert und es gibt kein Äquivalent für ParseObject ; Sie schreiben einfach Werte von Typen in den JSON-Baum, die den verfügbaren JSON-Typen entsprechen. Sie können Java-Objekte verwenden, um das Lesen und Schreiben aus der Datenbank zu vereinfachen.
Im Folgenden finden Sie ein Beispiel dafür, wie Sie die Highscores für ein Spiel speichern können.
Analysieren
@ParseClassName("GameScore")
public class GameScore {
public GameScore() {}
public GameScore(Long score, String playerName, Boolean cheatMode) {
setScore(score);
setPlayerName(playerName);
setCheatMode(cheatMode);
}
public void setScore(Long score) {
set("score", score);
}
public Long getScore() {
return getLong("score");
}
public void setPlayerName(String playerName) {
set("playerName", playerName);
}
public String getPlayerName() {
return getString("playerName");
}
public void setCheatMode(Boolean cheatMode) {
return set("cheatMode", cheatMode);
}
public Boolean getCheatMode() {
return getBoolean("cheatMode");
}
}
// Must call Parse.registerSubclass(GameScore.class) in Application.onCreate
GameScore gameScore = new GameScore(1337, "Sean Plott", false);
gameScore.saveInBackground();
Feuerbasis
// Assuming we defined the GameScore class as:
public class GameScore {
private Long score;
private String playerName;
private Boolean cheatMode;
public GameScore() {}
public GameScore(Long score, String playerName, Boolean cheatMode) {
this.score = score;
this.playerName = playerName;
this.cheatMode = cheatMode;
}
public Long getScore() {
return score;
}
public String getPlayerName() {
return playerName;
}
public Boolean getCheatMode() {
return cheatMode;
}
}
// We would save it to our list of high scores as follows:
DatabaseReference mFirebaseRef = FirebaseDatabase.getInstance().getReference();
GameScore score = new GameScore(1337, "Sean Plott", false);
mFirebaseRef.child("scores").push().setValue(score);
Beziehungen zwischen Daten
Ein ParseObject kann eine Beziehung zu einem anderen ParseObject haben: Jedes Objekt kann andere Objekte als Werte verwenden.
In der Firebase-Echtzeitdatenbank werden Beziehungen besser mithilfe flacher Datenstrukturen ausgedrückt, die die Daten in separate Pfade aufteilen, sodass sie in separaten Aufrufen effizient heruntergeladen werden können.
Im Folgenden finden Sie ein Beispiel dafür, wie Sie die Beziehung zwischen Beiträgen in einer Blogging-App und ihren Autoren strukturieren könnten.
Analysieren
// Create the author
ParseObject myAuthor = new ParseObject("Author");
myAuthor.put("name", "Grace Hopper");
myAuthor.put("birthDate", "December 9, 1906");
myAuthor.put("nickname", "Amazing Grace");
// Create the post
ParseObject myPost = new ParseObject("Post");
myPost.put("title", "Announcing COBOL, a New Programming Language");
// Add a relation between the Post and the Author
myPost.put("parent", myAuthor);
// This will save both myAuthor and myPost
myPost.saveInBackground();
Feuerbasis
DatabaseReference firebaseRef = FirebaseDatabase.getInstance().getReference();
// Create the author
Map<String, String> myAuthor = new HashMap<String, String>();
myAuthor.put("name", "Grace Hopper");
myAuthor.put("birthDate", "December 9, 1906");
myAuthor.put("nickname", "Amazing Grace");
// Save the author
String myAuthorKey = "ghopper";
firebaseRef.child('authors').child(myAuthorKey).setValue(myAuthor);
// Create the post
Map<String, String> post = new HashMap<String, String>();
post.put("author", myAuthorKey);
post.put("title", "Announcing COBOL, a New Programming Language");
firebaseRef.child('posts').push().setValue(post);
Das folgende Datenlayout ist das Ergebnis.
{
// Info about the authors
"authors": {
"ghopper": {
"name": "Grace Hopper",
"date_of_birth": "December 9, 1906",
"nickname": "Amazing Grace"
},
...
},
// Info about the posts: the "author" fields contains the key for the author
"posts": {
"-JRHTHaIs-jNPLXOQivY": {
"author": "ghopper",
"title": "Announcing COBOL, a New Programming Language"
}
...
}
}
Weitere Informationen finden Sie im Leitfaden „Strukturieren Sie Ihre Datenbank“ .Daten lesen
In Parse lesen Sie Daten entweder mithilfe der ID eines bestimmten Parse-Objekts oder indem Sie Abfragen mithilfe ParseQuery ausführen.
In Firebase rufen Sie Daten ab, indem Sie einen asynchronen Listener an eine Datenbankreferenz anhängen. Der Listener wird einmal für den Anfangszustand der Daten und dann noch einmal ausgelöst, wenn sich die Daten ändern. Sie müssen also keinen Code hinzufügen, um festzustellen, ob sich die Daten geändert haben.
Im Folgenden finden Sie ein Beispiel dafür, wie Sie Punktestände für einen bestimmten Spieler abrufen können, basierend auf dem Beispiel im Abschnitt „Objekte“ .
Analysieren
ParseQuery<ParseObject> query = ParseQuery.getQuery("GameScore");
query.whereEqualTo("playerName", "Dan Stemkoski");
query.findInBackground(new FindCallback<ParseObject>() {
public void done(List<ParseObject> scoreList, ParseException e) {
if (e == null) {
for (ParseObject score: scoreList) {
Log.d("score", "Retrieved: " + Long.toString(score.getLong("score")));
}
} else {
Log.d("score", "Error: " + e.getMessage());
}
}
});
Feuerbasis
DatabaseReference mFirebaseRef = FirebaseDatabase.getInstance().getReference();
Query mQueryRef = mFirebaseRef.child("scores").orderByChild("playerName").equalTo("Dan Stemkoski");
// This type of listener is not one time, and you need to cancel it to stop
// receiving updates.
mQueryRef.addChildEventListener(new ChildEventListener() {
@Override
public void onChildAdded(DataSnapshot snapshot, String previousChild) {
// This will fire for each matching child node.
GameScore score = snapshot.getValue(GameScore.class);
Log.d("score", "Retrieved: " + Long.toString(score.getScore());
}
});
Vorgeschlagene Migrationsstrategie
Überdenken Sie Ihre Daten
Die Firebase-Echtzeitdatenbank ist für die Synchronisierung von Daten in Millisekunden auf allen verbundenen Clients optimiert. Die resultierende Datenstruktur unterscheidet sich von den Parse-Kerndaten. Das bedeutet, dass der erste Schritt Ihrer Migration darin besteht, zu überlegen, welche Änderungen Ihre Daten erfordern, einschließlich:
- Wie Ihre Parse-Objekte Firebase-Daten zugeordnet werden sollen
- Wenn Sie über Eltern-Kind-Beziehungen verfügen, erfahren Sie, wie Sie Ihre Daten auf verschiedene Pfade aufteilen, damit sie in separaten Aufrufen effizient heruntergeladen werden können.
Migrieren Sie Ihre Daten
Nachdem Sie entschieden haben, wie Sie Ihre Daten in Firebase strukturieren möchten, müssen Sie planen, wie Sie mit dem Zeitraum umgehen, in dem Ihre App in beide Datenbanken schreiben muss. Ihre Auswahl ist:
Hintergrundsynchronisierung
In diesem Szenario haben Sie zwei Versionen der App: die alte Version, die Parse verwendet, und eine neue Version, die Firebase verwendet. Synchronisierungen zwischen den beiden Datenbanken werden von Parse Cloud Code (Parse to Firebase) durchgeführt, wobei Ihr Code auf Änderungen in Firebase lauscht und diese Änderungen mit Parse synchronisiert. Bevor Sie die neue Version nutzen können, müssen Sie:
- Konvertieren Sie Ihre vorhandenen Parse-Daten in die neue Firebase-Struktur und schreiben Sie sie in die Firebase-Echtzeitdatenbank.
- Schreiben Sie Parse-Cloud-Code-Funktionen, die die Firebase-REST-API verwenden, um von alten Clients in den Parse-Daten vorgenommene Änderungen in die Firebase-Echtzeitdatenbank zu schreiben.
- Schreiben und implementieren Sie Code, der auf Änderungen in Firebase lauscht und diese mit der Parse-Datenbank synchronisiert.
Dieses Szenario gewährleistet eine saubere Trennung von altem und neuem Code und hält die Clients einfach. Die Herausforderungen dieses Szenarios bestehen darin, große Datensätze beim ersten Export zu verarbeiten und sicherzustellen, dass die bidirektionale Synchronisierung keine unendliche Rekursion erzeugt.
Doppeltes Schreiben
In diesem Szenario schreiben Sie eine neue Version der App, die sowohl Firebase als auch Parse verwendet, und verwenden Parse Cloud Code, um von alten Clients vorgenommene Änderungen aus den Parse-Daten mit der Firebase-Echtzeitdatenbank zu synchronisieren. Wenn genügend Personen von der Nur-Parse-Version der App migriert sind, können Sie den Parse-Code aus der Double-Write-Version entfernen.
Für dieses Szenario ist kein serverseitiger Code erforderlich. Die Nachteile bestehen darin, dass Daten, auf die nicht zugegriffen wird, nicht migriert werden und dass die Größe Ihrer App durch die Verwendung beider SDKs zunimmt.
Firebase-Authentifizierung
Firebase Authentication kann Benutzer mithilfe von Passwörtern und beliebten Verbundidentitätsanbietern wie Google, Facebook und Twitter authentifizieren. Es stellt außerdem UI-Bibliotheken bereit, um Ihnen die erheblichen Investitionen zu ersparen, die für die Implementierung und Aufrechterhaltung einer vollständigen Authentifizierungserfahrung für Ihre App auf allen Plattformen erforderlich sind.
Weitere Informationen finden Sie in den Dokumenten zur Firebase-Authentifizierung .
Unterschiede zu Parse Auth
Parse stellt eine spezielle Benutzerklasse namens ParseUser bereit, die automatisch die für die Benutzerkontenverwaltung erforderlichen Funktionen übernimmt. ParseUser ist eine Unterklasse von ParseObject , was bedeutet, dass Benutzerdaten in Parse Data verfügbar sind und wie jedes andere ParseObject um zusätzliche Felder erweitert werden können.
Ein FirebaseUser verfügt über einen festen Satz grundlegender Eigenschaften – eine eindeutige ID, eine primäre E-Mail-Adresse, einen Namen und eine Foto-URL – die in der Benutzerdatenbank eines separaten Projekts gespeichert sind. Diese Eigenschaften können vom Benutzer aktualisiert werden. Sie können dem FirebaseUser Objekt keine anderen Eigenschaften direkt hinzufügen. Stattdessen können Sie die zusätzlichen Eigenschaften in Ihrer Firebase-Echtzeitdatenbank speichern.
Im Folgenden finden Sie ein Beispiel dafür, wie Sie einen Benutzer registrieren und ein zusätzliches Telefonnummernfeld hinzufügen können.
Analysieren
ParseUser user = new ParseUser();
user.setUsername("my name");
user.setPassword("my pass");
user.setEmail("email@example.com");
// other fields can be set just like with ParseObject
user.put("phone", "650-253-0000");
user.signUpInBackground(new SignUpCallback() {
public void done(ParseException e) {
if (e == null) {
// Hooray! Let them use the app now.
} else {
// Sign up didn't succeed. Look at the ParseException
// to figure out what went wrong
}
}
});
Feuerbasis
FirebaseAuth mAuth = FirebaseAuth.getInstance();
mAuth.createUserWithEmailAndPassword("email@example.com", "my pass")
.continueWithTask(new Continuation<AuthResult, Task<Void>> {
@Override
public Task<Void> then(Task<AuthResult> task) {
if (task.isSuccessful()) {
FirebaseUser user = task.getResult().getUser();
DatabaseReference firebaseRef = FirebaseDatabase.getInstance().getReference();
return firebaseRef.child("users").child(user.getUid()).child("phone").setValue("650-253-0000");
} else {
// User creation didn't succeed. Look at the task exception
// to figure out what went wrong
Log.w(TAG, "signInWithEmail", task.getException());
}
}
});
Vorgeschlagene Migrationsstrategie
Konten migrieren
Um Benutzerkonten von Parse zu Firebase zu migrieren, exportieren Sie Ihre Benutzerdatenbank in eine JSON- oder CSV-Datei und importieren Sie die Datei dann mit dem Befehl auth:import der Firebase-CLI in Ihr Firebase-Projekt.
Exportieren Sie zunächst Ihre Benutzerdatenbank aus der Parse-Konsole oder Ihrer selbst gehosteten Datenbank. Eine aus der Parse-Konsole exportierte JSON-Datei könnte beispielsweise wie folgt aussehen:
{ // Username/password user
"bcryptPassword": "$2a$10$OBp2hxB7TaYZgKyTiY48luawlTuYAU6BqzxJfpHoJMdZmjaF4HFh6",
"email": "user@example.com",
"username": "testuser",
"objectId": "abcde1234",
...
},
{ // Facebook user
"authData": {
"facebook": {
"access_token": "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
"expiration_date": "2017-01-02T03:04:05.006Z",
"id": "1000000000"
}
},
"username": "wXyZ987654321StUv",
"objectId": "fghij5678",
...
}
Anschließend wandeln Sie die exportierte Datei in das von der Firebase-CLI benötigte Format um. Verwenden Sie die objectId Ihrer Parse-Benutzer als localId Ihrer Firebase-Benutzer. Außerdem kodiert Base64 die bcryptPassword Werte von Parse und verwendet sie im Feld passwordHash . Zum Beispiel:
{
"users": [
{
"localId": "abcde1234", // Parse objectId
"email": "user@example.com",
"displayName": "testuser",
"passwordHash": "JDJhJDEwJE9CcDJoeEI3VGFZWmdLeVRpWTQ4bHVhd2xUdVlBVTZCcXp4SmZwSG9KTWRabWphRjRIRmg2",
},
{
"localId": "fghij5678", // Parse objectId
"displayName": "wXyZ987654321StUv",
"providerUserInfo": [
{
"providerId": "facebook.com",
"rawId": "1000000000", // Facebook ID
}
]
}
]
}
Importieren Sie abschließend die transformierte Datei mit der Firebase-CLI und geben Sie dabei bcrypt als Hash-Algorithmus an:
firebase auth:import account_file.json --hash-algo=BCRYPT
Benutzerdaten migrieren
Wenn Sie zusätzliche Daten für Ihre Benutzer speichern, können Sie diese mithilfe der im Abschnitt zur Datenmigration beschriebenen Strategien zur Firebase Realtime Database migrieren. Wenn Sie Konten mit dem im Abschnitt „Kontenmigration“ beschriebenen Ablauf migrieren, haben Ihre Firebase-Konten dieselben IDs wie Ihre Parse-Konten, sodass Sie alle durch die Benutzer-ID verschlüsselten Beziehungen einfach migrieren und reproduzieren können.
Firebase Cloud-Messaging
Firebase Cloud Messaging (FCM) ist eine plattformübergreifende Messaging-Lösung, mit der Sie Nachrichten und Benachrichtigungen zuverlässig und kostenlos übermitteln können. Der Notifications Composer ist ein kostenloser Dienst, der auf Firebase Cloud Messaging basiert und gezielte Benutzerbenachrichtigungen für Entwickler mobiler Apps ermöglicht.
Weitere Informationen finden Sie in den Firebase Cloud Messaging-Dokumenten .
Unterschiede zu Parse-Push-Benachrichtigungen
Jede Parse-Anwendung, die auf einem für Benachrichtigungen registrierten Gerät installiert ist, verfügt über ein zugehöriges Installation , in dem Sie alle Daten speichern, die für gezielte Benachrichtigungen erforderlich sind. Installation ist eine Unterklasse von ParseUser , was bedeutet, dass Sie Ihren Installation beliebige zusätzliche Daten hinzufügen können.
Der Notifications Composer stellt vordefinierte Benutzersegmente basierend auf Informationen wie App, App-Version und Gerätesprache bereit. Mithilfe von Google Analytics-Ereignissen und -Eigenschaften können Sie komplexere Benutzersegmente erstellen, um Zielgruppen aufzubauen. Weitere Informationen finden Sie im Hilfeleitfaden für Zielgruppen . Diese Targeting-Informationen sind in der Firebase-Echtzeitdatenbank nicht sichtbar.
Vorgeschlagene Migrationsstrategie
Gerätetoken migrieren
Zum Zeitpunkt des Verfassens dieses Artikels verwendet das Parse Android SDK eine ältere Version der FCM-Registrierungstokens, die nicht mit den vom Notifications Composer angebotenen Funktionen kompatibel ist.
Sie können ein neues Token erhalten, indem Sie das FCM SDK zu Ihrer App hinzufügen. Dies kann jedoch dazu führen, dass das vom Parse SDK zum Empfangen von Benachrichtigungen verwendete Token ungültig wird. Wenn Sie dies vermeiden möchten, können Sie das Parse SDK so einrichten, dass sowohl die Absender-ID von Parse als auch Ihre Absender-ID verwendet werden. Auf diese Weise machen Sie das vom Parse SDK verwendete Token nicht ungültig. Beachten Sie jedoch, dass diese Problemumgehung nicht mehr funktioniert, wenn Parse sein Projekt beendet.
Kanäle zu FCM-Themen migrieren
Wenn Sie Parse-Kanäle zum Senden von Benachrichtigungen verwenden, können Sie zu FCM-Themen migrieren, die dasselbe Herausgeber-Abonnenten-Modell bieten. Um den Übergang von Parse zu FCM zu bewältigen, können Sie eine neue Version der App schreiben, die das Parse SDK zum Abbestellen von Parse-Kanälen und das FCM SDK zum Abonnieren entsprechender FCM-Themen verwendet. In dieser Version der App sollten Sie den Empfang von Benachrichtigungen im Parse SDK deaktivieren und Folgendes aus dem Manifest Ihrer App entfernen:
<service android:name="com.parse.PushService" />
<receiver android:name="com.parse.ParsePushBroadcastReceiver"
android:exported="false">
<intent-filter>
<action android:name="com.parse.push.intent.RECEIVE" />
<action android:name="com.parse.push.intent.DELETE" />
<action android:name="com.parse.push.intent.OPEN" />
</intent-filter>
</receiver>
<receiver android:name="com.parse.GcmBroadcastReceiver"
android:permission="com.google.android.c2dm.permission.SEND">
<intent-filter>
<action android:name="com.google.android.c2dm.intent.RECEIVE" />
<action android:name="com.google.android.c2dm.intent.REGISTRATION" />
<!--
IMPORTANT: Change "com.parse.starter" to match your app's package name.
-->
<category android:name="com.parse.starter" />
</intent-filter>
</receiver>
<!--
IMPORTANT: Change "YOUR_SENDER_ID" to your GCM Sender Id.
-->
<meta-data android:name="com.parse.push.gcm_sender_id"
android:value="id:YOUR_SENDER_ID" />;
Wenn Ihr Benutzer beispielsweise das Thema „Riesen“ abonniert hat, würden Sie Folgendes tun:
ParsePush.unsubscribeInBackground("Giants", new SaveCallback() {
@Override
public void done(ParseException e) {
if (e == null) {
FirebaseMessaging.getInstance().subscribeToTopic("Giants");
} else {
// Something went wrong unsubscribing
}
}
});
Mit dieser Strategie können Sie Nachrichten sowohl an den Parse-Kanal als auch an das entsprechende FCM-Thema senden und so Benutzer sowohl alter als auch neuer Versionen unterstützen. Wenn genügend Benutzer von der Nur-Parse-Version der App migriert sind, können Sie diese Version beenden und mit dem Senden nur über FCM beginnen.
Weitere Informationen finden Sie in den FCM-Themendokumenten .
Firebase-Remote-Konfiguration
Firebase Remote Config ist ein Cloud-Dienst, mit dem Sie das Verhalten und Erscheinungsbild Ihrer App ändern können, ohne dass Benutzer ein App-Update herunterladen müssen. Wenn Sie Remote Config verwenden, erstellen Sie In-App-Standardwerte, die das Verhalten und Erscheinungsbild Ihrer App steuern. Anschließend können Sie die Firebase-Konsole später verwenden, um In-App-Standardwerte für alle App-Benutzer oder für Segmente Ihrer Benutzerbasis zu überschreiben.
Firebase Remote Config kann bei Ihren Migrationen sehr nützlich sein, wenn Sie verschiedene Lösungen testen und mehr Clients dynamisch zu einem anderen Anbieter verlagern möchten. Wenn Sie beispielsweise über eine Version Ihrer App verfügen, die sowohl Firebase als auch Parse für die Daten verwendet, können Sie eine zufällige Perzentilregel verwenden, um zu bestimmen, welche Clients aus Firebase lesen, und den Prozentsatz schrittweise erhöhen.
Weitere Informationen zu Firebase Remote Config finden Sie in der Einführung zu Remote Config .
Unterschiede zur Parse-Konfiguration
Mit der Parse-Konfiguration können Sie Ihrer App im Parse-Konfigurations-Dashboard Schlüssel/Wert-Paare hinzufügen und dann die ParseConfig auf dem Client abrufen. Jede ParseConfig Instanz, die Sie erhalten, ist immer unveränderlich. Wenn Sie in Zukunft eine neue ParseConfig aus dem Netzwerk abrufen, wird dadurch keine vorhandene ParseConfig Instanz geändert, sondern stattdessen eine neue erstellt und über getCurrentConfig() verfügbar gemacht.
Mit Firebase Remote Config erstellen Sie In-App-Standardeinstellungen für Schlüssel/Wert-Paare, die Sie über die Firebase-Konsole überschreiben können, und Sie können Regeln und Bedingungen verwenden, um verschiedenen Segmenten Ihrer Benutzerbasis Variationen der Benutzererfahrung Ihrer App bereitzustellen. Firebase Remote Config implementiert eine Singleton-Klasse, die die Schlüssel/Wert-Paare für Ihre App verfügbar macht. Zunächst gibt der Singleton die Standardwerte zurück, die Sie in der App definieren. Sie können zu jedem für Ihre App geeigneten Zeitpunkt einen neuen Satz Werte vom Server abrufen. Nachdem der neue Satz erfolgreich abgerufen wurde, können Sie auswählen, wann er aktiviert werden soll, um die neuen Werte für die App verfügbar zu machen.
Vorgeschlagene Migrationsstrategie
Sie können zu Firebase Remote Config wechseln, indem Sie die Schlüssel/Wert-Paare Ihrer Parse-Konfiguration in die Firebase-Konsole kopieren und dann eine neue Version der App bereitstellen, die Firebase Remote Config verwendet.
Wenn Sie sowohl mit Parse Config als auch mit Firebase Remote Config experimentieren möchten, können Sie eine neue Version der App bereitstellen, die beide SDKs verwendet, bis genügend Benutzer von der reinen Parse-Version migriert sind.
Code-Vergleich
Analysieren
ParseConfig.getInBackground(new ConfigCallback() {
@Override
public void done(ParseConfig config, ParseException e) {
if (e == null) {
Log.d("TAG", "Yay! Config was fetched from the server.");
} else {
Log.e("TAG", "Failed to fetch. Using Cached Config.");
config = ParseConfig.getCurrentConfig();
}
// Get the message from config or fallback to default value
String welcomeMessage = config.getString("welcomeMessage", "Welcome!");
}
});
Feuerbasis
mFirebaseRemoteConfig = FirebaseRemoteConfig.getInstance();
// Set defaults from an XML resource file stored in res/xml
mFirebaseRemoteConfig.setDefaults(R.xml.remote_config_defaults);
mFirebaseRemoteConfig.fetch()
.addOnSuccessListener(new OnSuccessListener<Void>() {
@Override
public void onSuccess(Void aVoid) {
Log.d("TAG", "Yay! Config was fetched from the server.");
// Once the config is successfully fetched it must be activated before newly fetched
// values are returned.
mFirebaseRemoteConfig.activateFetched();
}
})
.addOnFailureListener(new OnFailureListener() {
@Override
public void onFailure(@NonNull Exception exception) {
Log.e("TAG", "Failed to fetch. Using last fetched or default.");
}
})
// ...
// When this is called, the value of the latest fetched and activated config is returned;
// if there's none, the default value is returned.
String welcomeMessage = mFirebaseRemoteConfig.getString("welcomeMessage");