Wenn Sie Parse-Nutzer 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 diesem Leitfaden wird beschrieben, wie Sie bestimmte Dienste in Ihre App einbinden. Eine grundlegende Anleitung zur Einrichtung von Firebase finden Sie im Android-Einrichtungsleitfaden.
Google Analytics
Google Analytics ist eine kostenlose App-Analyselösung, mit der sich Informationen zur App-Nutzung und zu Interaktionen der Nutzer gewinnen lassen. Analytics lässt sich in Firebase-Funktionen einbinden und bietet unbegrenzte Berichterstellung für bis zu 500 verschiedene Ereignisse, die Sie mit dem Firebase SDK definieren können.
Weitere Informationen finden Sie in der Google Analytics-Dokumentation.
Vorgeschlagene Migrationsstrategie
Die Verwendung verschiedener Analyseanbieter ist ein gängiges Szenario, das sich leicht auf Google Analytics anwenden lässt. Fügen Sie sie einfach Ihrer App hinzu, um von Ereignissen und Nutzereigenschaften zu profitieren, die Analytics automatisch erfasst werden, z. B. „Erste Aktivierung“, „App-Update“, „Gerätemodell“ und „Alter“.
Bei benutzerdefinierten Ereignissen und Nutzereigenschaften können Sie eine Doppelschreibstrategie verwenden, bei der sowohl Parse Analytics als auch Google Analytics zum Protokollieren von Ereignissen und Eigenschaften verwendet werden. So können Sie die neue Lösung nach und nach einführen.
Codevergleich
Parse Analytics
// 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 Realtime Database
Die Firebase Realtime Database ist eine in der Cloud gehostete NoSQL-Datenbank. Die Daten werden als JSON gespeichert und in Echtzeit mit jedem verbundenen Client synchronisiert.
Weitere Informationen finden Sie in der Firebase Realtime Database-Dokumentation.
Unterschiede zu „Daten analysieren“
Objekte
In Parse speichern Sie eine ParseObject
oder eine Unterklasse davon, die Schlüssel/Wert-Paare von JSON-kompatiblen Daten enthält. Die Daten sind schemalos, d. h., Sie müssen nicht angeben, welche Schlüssel für jede ParseObject
vorhanden sind.
Alle Firebase Realtime Database-Daten werden als JSON-Objekte gespeichert. Für ParseObject
gibt es kein Äquivalent. Sie schreiben einfach Werte von Typen in den JSON-Baum, die den verfügbaren JSON-Typen entsprechen.
Mit Java-Objekten können Sie das Lesen und Schreiben aus der Datenbank vereinfachen.
Im folgenden Beispiel wird gezeigt, wie Sie die Highscores für ein Spiel speichern können.
Parsen
@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();
Firebase
// 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 Realtime Database werden Beziehungen besser mit flachen Datenstrukturen ausgedrückt, die die Daten in separate Pfade aufteilen, damit 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önnen.
Parsen
// 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();
Firebase
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" } ... } }
Daten lesen
In Parse können Sie Daten entweder mit der ID eines bestimmten Parse-Objekts oder mithilfe von Abfragen mit ParseQuery
lesen.
In Firebase rufen Sie Daten ab, indem Sie einer Datenbankreferenz einen asynchronen Listener zuordnen. Der Listener wird einmal für den anfänglichen Status der Daten und dann bei jeder Änderung der Daten ausgelöst. Sie müssen also keinen Code hinzufügen, um zu ermitteln, ob sich die Daten geändert haben.
Im folgenden Beispiel wird gezeigt, wie du anhand des Beispiels im Abschnitt Objekte Punkte für einen bestimmten Spieler abrufen kannst.
Parsen
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());
}
}
});
Firebase
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
Daten neu überdenken
Die Firebase Realtime Database ist für die Synchronisierung von Daten in Millisekunden über alle verbundenen Clients optimiert. Die resultierende Datenstruktur unterscheidet sich von den Parse-Kerndaten. Das bedeutet, dass Sie im ersten Schritt der Migration überlegen müssen, welche Änderungen an Ihren Daten erforderlich sind. Dazu gehören:
- So sollten Ihre Parse-Objekte Firebase-Daten zugeordnet werden
- Wenn Sie über Eltern-Kind-Beziehungen verfügen, können Sie Ihre Daten auf verschiedene Pfade aufteilen, damit sie in separaten Aufrufen effizient heruntergeladen werden können.
Daten migrieren
Nachdem Sie sich 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. Sie haben folgende Auswahlmöglichkeiten:
Hintergrundsynchronisierung
In diesem Szenario haben Sie zwei Versionen der App: die alte Version, die Parse verwendet, und eine neue Version, die Firebase verwendet. Die Synchronisierung zwischen den beiden Datenbanken wird von Parse Cloud Code (Parse zu Firebase) verwaltet. Ihr Code überwacht Änderungen in Firebase und synchronisiert diese Änderungen mit Parse. Bevor Sie die neue Version verwenden können, müssen Sie Folgendes tun:
- Konvertieren Sie Ihre vorhandenen Parse-Daten in die neue Firebase-Struktur und schreiben Sie sie in die Firebase Realtime Database.
- Parse Cloud Code-Funktionen schreiben, die mit der Firebase REST API Änderungen an den Parse-Daten von alten Clients in die Firebase Realtime Database schreiben
- Schreiben und bereitstellen Sie Code, der Änderungen in Firebase überwacht und mit der Parse-Datenbank synchronisiert.
Dieses Szenario sorgt für eine klare 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 dafür zu sorgen, dass die bidirektionale Synchronisierung keine unendliche Rekursion generiert.
Doppelschreiben
In diesem Szenario schreiben Sie eine neue Version der App, die sowohl Firebase als auch Parse verwendet. Mit Parse Cloud Code werden Änderungen, die von alten Clients an den Parse-Daten vorgenommen wurden, mit der Firebase Realtime Database synchronisiert. Wenn genügend Nutzer von der Parse-only-Version der App migriert sind, können Sie den Parse-Code aus der Version mit doppeltem Schreiben entfernen.
Für dieses Szenario ist kein serverseitiger Code erforderlich. Nachteile sind, dass Daten, auf die nicht zugegriffen wird, nicht migriert werden und dass die Größe Ihrer App durch die Verwendung beider SDKs erhöht wird.
Firebase Authentication
Firebase Authentication kann Nutzer mithilfe von Passwörtern und gängigen föderierten Identitätsanbietern wie Google, Facebook und Twitter authentifizieren. Außerdem bietet es UI-Bibliotheken, mit denen Sie die erheblichen Kosten sparen, die für die Implementierung und Pflege einer vollständigen Authentifizierung für Ihre App auf allen Plattformen erforderlich sind.
Weitere Informationen finden Sie in der Firebase Authentication-Dokumentation.
Unterschiede zu Parse Auth
Parse bietet eine spezielle Nutzerklasse namens ParseUser
, die die für die Nutzerkontoverwaltung erforderlichen Funktionen automatisch verarbeitet. ParseUser
ist eine Unterklasse der ParseObject
. Das bedeutet, dass Nutzerdaten in „Daten analysieren“ verfügbar sind und wie bei jeder anderen ParseObject
mit zusätzlichen Feldern erweitert werden können.
Ein FirebaseUser
hat eine feste Reihe grundlegender Properties – eine eindeutige ID, eine primäre E-Mail-Adresse, einen Namen und eine Foto-URL –, die in der Nutzerdatenbank eines separaten Projekts gespeichert und vom Nutzer aktualisiert werden können. Andere Attribute können nicht direkt zum FirebaseUser
-Objekt hinzugefügt werden. Stattdessen können Sie die zusätzlichen Attribute in Ihrem Firebase Realtime Database speichern.
Im folgenden Beispiel wird gezeigt, wie Sie einen Nutzer registrieren und ein zusätzliches Feld für die Telefonnummer hinzufügen.
Parsen
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
}
}
});
Firebase
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
Wenn Sie Nutzerkonten von Parse zu Firebase migrieren möchten, exportieren Sie Ihre Nutzerdatenbank in eine JSON- oder CSV-Datei und importieren Sie die Datei dann mit dem Befehl auth:import
der Firebase-Befehlszeile in Ihr Firebase-Projekt.
Exportieren Sie zuerst Ihre Nutzerdatenbank aus der Parse Console oder Ihrer selbst gehosteten Datenbank. Eine aus der Parse Console exportierte JSON-Datei könnte beispielsweise so 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", ... }
Transformieren Sie die exportierte Datei dann in das Format, das von der Firebase-Befehlszeile benötigt wird. Verwenden Sie die objectId
Ihrer Parse-Nutzer als localId
Ihrer Firebase-Nutzer. Codieren Sie außerdem die bcryptPassword
-Werte aus Parse mit Base64 und verwenden Sie sie im Feld passwordHash
. 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 die transformierte Datei abschließend mit der Firebase CLI und geben Sie bcrypt als Hash-Algorithmus an:
firebase auth:import account_file.json --hash-algo=BCRYPT
Nutzerdaten migrieren
Wenn Sie zusätzliche Daten für Ihre Nutzer speichern, können Sie diese mithilfe der im Abschnitt Datenmigration beschriebenen Strategien zu Firebase Realtime Database migrieren. Wenn Sie Konten mithilfe des im Abschnitt Migration von Konten beschriebenen Ablaufs migrieren, haben Ihre Firebase-Konten dieselben IDs wie Ihre Parse-Konten. So können Sie alle Beziehungen, die anhand der Nutzer-ID sortiert sind, ganz einfach migrieren und reproduzieren.
Firebase Cloud Messaging
Firebase Cloud Messaging (FCM) ist eine plattformübergreifende Messaging-Lösung, mit der Sie zuverlässig und kostenlos Nachrichten und Benachrichtigungen zustellen können. Der Benachrichtigungs-Editor ist ein kostenloser Dienst, der auf Firebase Cloud Messaging basiert und App-Entwicklern die Möglichkeit bietet, gezielte Nutzerbenachrichtigungen zu senden.
Weitere Informationen finden Sie in der Firebase Cloud Messaging-Dokumentation .
Unterschiede zu Parse-Push-Benachrichtigungen
Jede Parse-Anwendung, die auf einem für Benachrichtigungen registrierten Gerät installiert ist, ist mit einem Installation
-Objekt verknüpft, in dem alle Daten gespeichert werden, die für die Ausrichtung von Benachrichtigungen erforderlich sind.
Installation
ist eine abgeleitete Klasse von ParseUser
. Das bedeutet, dass Sie Ihren Installation
-Instanzen beliebige zusätzliche Daten hinzufügen können.
Der Benachrichtigungs-Designer bietet vordefinierte Nutzersegmente basierend auf Informationen wie App, App-Version und Gerätesprache. Mithilfe von Google Analytics-Ereignissen und Google Analytics-Eigenschaften können Sie komplexere Nutzersegmente erstellen, um Zielgruppen zu bilden. Weitere Informationen finden Sie im Hilfeartikel zu Zielgruppen. Diese Targeting-Informationen sind in der Firebase Realtime Database nicht sichtbar.
Vorgeschlagene Migrationsstrategie
Gerätetokens migrieren
Zum Zeitpunkt der Erstellung dieses Artikels verwendet das Parse Android SDK eine ältere Version der FCM-Registrierungstokens, die nicht mit den Funktionen des Benachrichtigungs-Composers kompatibel ist.
Sie können ein neues Token erhalten, indem Sie Ihrer App das FCM SDK hinzufügen. Dies kann jedoch dazu führen, dass das Token ungültig wird, das vom Parse SDK zum Empfangen von Benachrichtigungen verwendet wird. Wenn Sie das vermeiden möchten, können Sie das Parse SDK so einrichten, dass sowohl die Absender-ID von Parse als auch Ihre Absender-ID verwendet wird. So wird das vom Parse SDK verwendete Token nicht ungültig. Beachten Sie jedoch, dass diese Problemumgehung nicht mehr funktioniert, wenn Parse sein Projekt einstellt.
Kanäle zu FCM-Themen migrieren
Wenn Sie Parse-Channels zum Senden von Benachrichtigungen verwenden, können Sie zu FCM-Themen migrieren, die dasselbe Publisher-Abonnenten-Modell bieten. Um die Umstellung von Parse auf FCM zu ermöglichen, können Sie eine neue Version der App erstellen, in der mit dem Parse SDK der Abmeldevorgang von Parse-Kanälen und mit dem FCM SDK die Anmeldung für entsprechende FCM-Themen gesteuert wird. In dieser Version der App sollten Sie den Empfang von Benachrichtigungen über das Parse-SDK deaktivieren. Entfernen Sie dazu Folgendes aus dem Manifest Ihrer App:
<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 Nutzer beispielsweise das Thema „Riesen“ abonniert hat, gehen Sie so vor:
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 Nutzer der alten und der neuen Version unterstützen. Sobald genügend Nutzer von der Version der App migriert sind, die nur zum Parsen dient, können Sie diese Version einstellen und nur noch mit FCM senden.
Weitere Informationen finden Sie in den FCM-Dokumenten zu Themen.
Firebase Remote Config
Firebase Remote Config ist ein Cloud-Dienst, mit dem Sie das Verhalten und das Design Ihrer App ändern können, ohne dass Nutzer ein App-Update herunterladen müssen. Dabei erstellen Sie In-App-Standardwerte, mit denen Verhalten und Aussehen der App festgelegt werden. Später können Sie diese Werte dann über die Firebase Console für alle oder nur für einen Teil Ihrer App-Nutzer überschreiben.
Firebase Remote Config kann bei Migrationen sehr nützlich sein, wenn Sie verschiedene Lösungen testen und mehr Kunden dynamisch zu einem anderen Anbieter migrieren möchten. Wenn Sie beispielsweise eine Version Ihrer App haben, die sowohl Firebase als auch Parse für die Daten verwendet, können Sie mit einer zufälligen Prozentregel festlegen, welche Clients Daten aus Firebase lesen, und den Prozentsatz schrittweise erhöhen.
Weitere Informationen zu Firebase Remote Config finden Sie in der Remote Config-Einführung.
Unterschiede zu „Parse Config“
Mit Parse Config können Sie Ihrer App im Parse Config-Dashboard Schlüssel/Wert-Paare hinzufügen und dann die ParseConfig
auf dem Client abrufen. Jede ParseConfig
-Instanz, die Sie abrufen, ist immer unveränderlich. Wenn Sie in Zukunft eine neue ParseConfig
aus dem Netzwerk abrufen, wird keine vorhandene ParseConfig
-Instanz geändert, sondern es wird eine neue erstellt und über getCurrentConfig()
verfügbar gemacht.
Mit Firebase Remote Config können Sie In-App-Standardwerte für Schlüssel/Wert-Paare erstellen, die Sie über die Firebase Console überschreiben können. Außerdem können Sie mithilfe von Regeln und Bedingungen Variationen der App-Nutzerumgebung für verschiedene Nutzersegmente bereitstellen. Firebase Remote Config implementiert eine Singleton-Klasse, die die Schlüssel/Wert-Paare für Ihre App verfügbar macht. Anfangs gibt das Singleton die Standardwerte zurück, die Sie in der App definieren. Sie können jederzeit einen neuen Satz von Werten vom Server abrufen. Nachdem der neue Satz erfolgreich abgerufen wurde, können Sie auswählen, wann er aktiviert werden soll, damit die neuen Werte für die App verfügbar sind.
Vorgeschlagene Migrationsstrategie
Sie können zu Firebase Remote Config wechseln, indem Sie die Schlüssel/Wert-Paare Ihrer Parse-Konfiguration in die Firebase Console kopieren und dann eine neue Version der App mit Firebase Remote Config bereitstellen.
Wenn Sie sowohl Parse Config als auch Firebase Remote Config ausprobieren möchten, können Sie eine neue Version der App bereitstellen, die beide SDKs verwendet, bis genügend Nutzer von der Version mit nur Parse migriert sind.
Codevergleich
Parsen
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!");
}
});
Firebase
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");