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 alle Firebase-Funktionen einbinden und bietet Ihnen Berichte für bis zu 500 verschiedene Ereignisse erstellen, 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 anwenden lässt Google Analytics Fügen Sie sie einfach Ihrer App hinzu, um von Ereignissen und Nutzereigenschaften zu profitieren, Analytics erhebt automatisch, z. B. erstes Öffnen, 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
Analytics parsen
// 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
Firebase Realtime Database ist eine in der Cloud gehostete NoSQL-Datenbank. Die Daten werden im JSON-Format in Echtzeit mit jedem verbundenen Client synchronisiert.
Weitere Informationen finden Sie in der Firebase Realtime Database-Dokumentation.
Unterschiede zu Parse-Daten
Objekte
In Parse speichern Sie eine ParseObject oder eine Unterklasse davon, die Schlüssel/Wert-Paare enthält.
von JSON-kompatiblen Daten. Die Daten sind schemalos, d. h., Sie müssen nicht angeben, welche Schlüssel
ist für jeden ParseObject vorhanden.
Alle Firebase Realtime Database-Daten werden als JSON-Objekte gespeichert. Für
ParseObject; schreiben Sie einfach in die JSON-Baumwerte der Typen,
mit den verfügbaren JSON-Typen.
Mit Java-Objekten können Sie das Lesen und Schreiben aus der Datenbank vereinfachen.
Das folgende Beispiel zeigt, 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 mit einem anderen ParseObject haben: beliebige
-Objekt kann andere Objekte als Werte verwenden.
Im Firebase Realtime Database werden Beziehungen mit flachen Datenstrukturen besser ausgedrückt, die Die Daten werden in separate Pfade aufgeteilt, sodass sie in separaten Aufrufen effizient heruntergeladen werden können.
Das folgende Beispiel zeigt, wie Sie die Beziehung zwischen Posts in einem Blogging-App und ihre Autoren.
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 Ergebnis ist das folgende Datenlayout.
{
// 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 ParseQuery-Abfragen lesen.
In Firebase rufen Sie Daten ab, indem Sie einen asynchronen Listener an eine Datenbankreferenz anhängen. Die Listener wird einmal für den anfänglichen Status der Daten und 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.
Das folgende Beispiel zeigt, wie Sie Punktzahlen für einen bestimmten Spieler basierend auf dem Beispiel aus dem Abschnitt Objekte.
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 überdenken
Firebase Realtime Database ist so optimiert, dass Daten in Millisekunden auf allen verbundenen und die resultierende Datenstruktur unterscheidet sich von den Parse-Kerndaten. Das bedeutet, dass der Der erste Schritt der Migration besteht darin, zu überlegen, welche Änderungen für Ihre Daten erforderlich sind, darunter:
- Zuordnung Ihrer Parse-Objekte zu Firebase-Daten
- Wie können Sie bei hierarchischen Beziehungen Ihre Daten auf verschiedene Pfade aufteilen, kann es effizient in separaten Aufrufen heruntergeladen werden.
Daten migrieren
Nachdem Sie sich entschieden haben, wie Sie Ihre Daten in Firebase strukturieren möchten, müssen Sie planen, wie die Zeit, in der Ihre Anwendung 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. Synchronisierungen zwischen den beiden Datenbanken werden von Parse Cloud Code (Parse in Firebase) ausführen, wobei Ihr Code Änderungen in Firebase überwacht und diese mit Parse synchronisiert. 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 mithilfe der Firebase REST API in die Firebase Realtime Database Änderungen, die von alten Clients in den Parse-Daten vorgenommen wurden.
- Code schreiben und bereitstellen, der Änderungen in Firebase überwacht und mit dem Parser synchronisiert Datenbank.
Dieses Szenario sorgt für eine klare Trennung von altem und neuem Code und sorgt für eine einfache Nutzung der Clients. Die Herausforderungen dieses Szenarios sind der Umgang mit großen Datasets beim ersten Export und bei der bidirektionalen Synchronisierung keine unendliche Rekursion generiert wird.
Doppelt schreiben
In diesem Szenario schreiben Sie eine neue Version der App, die sowohl Firebase als auch Parse verwendet. Dabei verwenden Sie Cloud Code parsen, um Änderungen zu synchronisieren, die von alten Clients aus den Parse-Daten mit dem Firebase Realtime Database 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. Ihre Nachteile sind, dass Daten, auf die zugegriffen wird, nicht migriert und die Größe Ihrer App erhöht sich durch die Nutzung beider SDKs.
Firebase Authentication
Firebase Authentication kann Nutzer mithilfe von Passwörtern und beliebten Anbietern föderierter Identität authentifizieren wie Google, Facebook und Twitter. Außerdem bietet es UI-Bibliotheken, mit denen Sie die wichtigen die für die Implementierung und Aufrechterhaltung einer umfassenden Authentifizierung für Ihre App auf Plattformen.
Weitere Informationen finden Sie in der Firebase Authentication-Dokumentation.
Unterschiede zur Parse Auth
Parse stellt eine spezielle Nutzerklasse namens ParseUser bereit, die automatisch
Funktionen, die für die
Nutzerkontenverwaltung erforderlich sind. ParseUser ist eine Unterklasse der ParseObject. Das bedeutet, dass Nutzerdaten in den „Parsen von Daten“-Daten verfügbar sind und wie bei jeder anderen ParseObject mit zusätzlichen Feldern erweitert werden können.
Eine FirebaseUser hat einen festen Satz grundlegender Eigenschaften: eine eindeutige ID, eine primäre E-Mail-Adresse,
einen Namen und eine Foto-URL – gespeichert in der Nutzerdatenbank eines separaten Projekts können diese Eigenschaften durch
Nutzenden. Sie können dem FirebaseUser-Objekt keine anderen Eigenschaften direkt hinzufügen.
können Sie die zusätzlichen Properties in der Datei Firebase Realtime Database speichern.
Das folgende Beispiel zeigt, wie Sie einen Nutzer registrieren und ein zusätzliches Telefonnummernfeld hinzufügen können.
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
Um Nutzerkonten von Parse zu Firebase zu migrieren, exportieren Sie Ihre Nutzerdatenbank nach
JSON- oder CSV-Datei an und importieren Sie diese Datei mithilfe des
auth:import von Firebase CLI
.
Exportieren Sie zuerst Ihre Nutzerdatenbank aus der Parse Console oder Ihrer selbst gehosteten Datenbank. Eine aus der Parse-Konsole exportierte JSON-Datei sieht möglicherweise wie zum Beispiel so:
{ // 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 für Firebase erforderliche Format.
Befehlszeile. Verwenden Sie die objectId Ihrer Parse-Nutzer als
localId Ihrer Firebase-Nutzer. Außerdem codieren Sie mit Base64
bcryptPassword-Werte aus Parse und verwenden sie im passwordHash
ein. 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 schließlich die transformierte Datei mit der Firebase CLI und geben Sie dabei „bcrypt“ an. als Hash-Algorithmus verwenden:
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 zu Firebase Realtime Database migrieren. mithilfe der im Abschnitt Datenmigration beschriebenen Strategien. Beim Migrieren wie im Abschnitt Migration von Konten beschrieben, Firebase-Konten haben dieselben IDs wie Ihre Parse-Konten, sodass Sie sie einfach migrieren und reproduzieren können. alle durch die User-ID angegebenen Beziehungen.
Firebase Cloud Messaging
Firebase Cloud Messaging (FCM) ist eine plattformübergreifende Messaging-Lösung, mit der Sie Nachrichten und Benachrichtigungen kostenlos zu übermitteln. Notifications Composer ist ein kostenloser Dienst, der entwickelt wurde, auf Firebase Cloud Messaging, mit der zielgerichtete Nutzerbenachrichtigungen für Entwickler mobiler Apps aktiviert werden.
Weitere Informationen finden Sie in den Firebase Cloud Messaging-Dokumenten .
Unterschiede zum Parsen von Push-Benachrichtigungen
Jeder Parse-Anwendung, die auf einem für Benachrichtigungen registrierten Gerät installiert ist, ist ein
Installation-Objekt, in dem alle für das Targeting von Benachrichtigungen erforderlichen Daten gespeichert werden.
Installation ist eine abgeleitete Klasse von ParseUser. Sie können also
alle zusätzlichen Daten, die Sie an Ihre Installation-Instanzen senden möchten.
Notifications Composer stellt vordefinierte Nutzersegmente basierend auf Informationen wie App, App-Version und Gerät bereit Sprache. Mit Google Analytics-Ereignissen und -Properties können Sie komplexere Nutzersegmente erstellen Zielgruppen aufbauen. Zielgruppen ansehen in der Hilfe. Diese Targeting-Informationen sind in der Firebase Realtime Database nicht sichtbar.
Vorgeschlagene Migrationsstrategie
Gerätetokens migrieren
Beim Verfassen dieses Artikels verwendet das Parse Android SDK eine ältere Version von FCM. Registrierungstokens, die nicht mit den Funktionen von Notifications Composer kompatibel sind.
Sie können ein neues Token anfordern, indem Sie Ihrer App das FCM SDK hinzufügen. Allerdings Dies könnte das Token ungültig machen, 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. Auf diese Weise entwerten Sie das vom Parse SDK verwendete Token nicht, Beachten Sie jedoch, dass diese Problemumgehung nicht mehr funktioniert, wenn Parse sein Projekt beendet.
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 solltest du den Empfang von Benachrichtigungen auf folgenden Geräten deaktivieren: das Parse SDK. Dabei wird Folgendes aus dem Manifest deiner App entfernt:
<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 „Giants“ abonniert hat, zum Thema haben, würden Sie zum Beispiel 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 den entsprechenden Thema FCM, das Nutzer der alten und der neuen Version unterstützt. Wenn genügend Nutzer aus der Nur parse-Version der App. Sie können diese Version einstellen und nur noch über FCM senden.
Weitere Informationen finden Sie in der FCM Themendokumentation um mehr zu erfahren.
Firebase Remote Config
Firebase Remote Config ist ein Cloud-Dienst, mit dem Sie das Verhalten und die Darstellung Ihrer ohne dass Nutzer ein App-Update herunterladen müssen. Bei Verwendung von Remote Config erstellen Sie In-App- Standardwerte, die das Verhalten und Erscheinungsbild Ihrer App steuern. Später können Sie das Firebase Console, um In-App-Standardwerte für alle App-Nutzer oder für Segmente Ihrer Nutzerbasis zu überschreiben.
Firebase Remote Config kann während der Migration sehr nützlich sein, wenn Sie verschiedene Lösungen zu entwickeln und in der Lage zu sein, mehr Kunden dynamisch zu einem anderen Anbieter zu verschieben. 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 findest du in der Einführung in Remote Config.
Unterschiede zur Parse-Konfiguration
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
get immer unveränderlich ist. Wenn Sie in Zukunft eine neue ParseConfig aus dem
werden keine ParseConfig-Instanzen geändert, sondern
erstellen Sie eine neue und stellen Sie sie über getCurrentConfig() zur Verfügung.
Mit Firebase Remote Config erstellen Sie In-App-Standardeinstellungen für Schlüssel/Wert-Paare, die Sie überschreiben können über die Firebase Console aus. Mithilfe von Regeln und Bedingungen können Sie User Experience auf verschiedene Segmente Ihrer Nutzerbasis ausrichten. 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 der Parse-Konfiguration kopieren in der Firebase Console und stellen dann eine neue Version der App bereit, 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, die beide SDKs verwendet, bis genügend Nutzer von der reinen Parse-Version 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");