Google is committed to advancing racial equity for Black communities. See how.
Diese Seite wurde von der Cloud Translation API übersetzt.
Switch to English

Migrieren Sie Ihre Parse Android App zu Firebase

Wenn Sie als Parse-Benutzer nach einer alternativen Backend as a Service-Lösung suchen, ist Firebase möglicherweise die ideale Wahl für Ihre Android-App.

In diesem Handbuch wird beschrieben, wie Sie bestimmte Dienste in Ihre App integrieren. Grundlegende Anweisungen zur Einrichtung von Firebase finden Sie im Android-Setup- Handbuch.

Google Analytics

Google Analytics ist eine kostenlose App-Messlösung, die Einblicke in die App-Nutzung und die Nutzerinteraktion bietet. Analytics ist in alle Firebase-Funktionen integriert 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 Analytics-Anbieter ist ein häufiges Szenario, das sich problemlos auf Google Analytics anwenden lässt. Fügen Sie es einfach Ihrer App hinzu, um von Ereignissen und Benutzereigenschaften zu profitieren, die Analytics automatisch erfasst, z. B. Erstes Öffnen, App-Update, Gerätemodell und Alter.

Für benutzerdefinierte Ereignisse und Benutzereigenschaften können Sie eine Doppelschreibstrategie verwenden, bei der sowohl Parse Analytics als auch Google Analytics zum Protokollieren von Ereignissen und Eigenschaften verwendet werden, sodass Sie die neue Lösung schrittweise einführen können.

Codevergleich

Analyse 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-Echtzeitdatenbank 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 den Firebase Realtime Database-Dokumenten .

Unterschiede zu Analysedaten

Objekte

In Parse speichern Sie ein ParseObject oder eine Unterklasse davon, die Schlüssel-Wert-Paare von JSON-kompatiblen Daten enthält. Die Daten sind schemenlos, dh Sie müssen nicht angeben, welche Schlüssel in jedem ParseObject .

Alle Firebase-Echtzeitdatenbankdaten werden als JSON-Objekte gespeichert, und es gibt kein Äquivalent für ParseObject . Sie schreiben einfach in die JSON-Baumwerte Werte von Typen, die den verfügbaren JSON-Typen entsprechen. Sie können Java-Objekte verwenden, um das Lesen und Schreiben aus der Datenbank zu vereinfachen.

Das Folgende ist 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);
 
Weitere Informationen finden Sie im Handbuch Lesen und Schreiben von Daten auf Android .

Beziehungen zwischen Daten

Ein ParseObject kann eine Beziehung zu einem anderen ParseObject : ParseObject Objekt kann andere Objekte als Werte verwenden.

In der Firebase-Echtzeitdatenbank werden Beziehungen besser durch flache Datenstrukturen ausgedrückt, die die Daten in separate Pfade aufteilen, sodass sie in separaten Aufrufen effizient heruntergeladen werden können.

Das folgende Beispiel zeigt, wie Sie die Beziehung zwischen Posts in einer Blogging-App und ihren Autoren strukturieren können.

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 Handbuch Strukturieren Ihrer Datenbank .

Daten lesen

In Parse lesen Sie Daten entweder mit der ID eines bestimmten Parse-Objekts oder führen Abfragen mit ParseQuery .

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 erneut ausgelöst, wenn sich die Daten ändern, sodass Sie keinen Code hinzufügen müssen, um festzustellen, ob sich die Daten geändert haben.

Das Folgende ist ein Beispiel dafür, wie Sie Punkte 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());
    }
});
 
Weitere Informationen zu verfügbaren Arten von Ereignis-Listenern sowie zum Bestellen und Filtern von Daten finden Sie im Handbuch Lesen und Schreiben von Daten auf Android .

Vorgeschlagene Migrationsstrategie

Überdenken Sie Ihre Daten

Die Firebase-Echtzeitdatenbank ist so optimiert, dass Daten in Millisekunden über alle verbundenen Clients hinweg synchronisiert werden. Die resultierende Datenstruktur unterscheidet sich von den Parse-Kerndaten. Dies bedeutet, dass der erste Schritt Ihrer Migration darin besteht, zu prüfen, welche Änderungen Ihre Daten erfordern, einschließlich:

  • Wie Ihre Parse-Objekte Firebase-Daten zugeordnet werden sollen
  • Wenn Sie Eltern-Kind-Beziehungen haben, 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 Ihre Daten in Firebase strukturiert werden sollen, müssen Sie planen, wie der Zeitraum behandelt werden soll, in dem Ihre App in beide Datenbanken schreiben muss. Sie haben folgende Möglichkeiten:

Hintergrundsynchronisation

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 Änderungen in Firebase abhört und diese Änderungen mit Parse synchronisiert. Bevor Sie die neue Version verwenden können, müssen Sie:

  • Konvertieren Sie Ihre vorhandenen Analysedaten 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 Änderungen in die Firebase Realtime Database zu schreiben, die von alten Clients in den Parse Data vorgenommen wurden.
  • Schreiben und Bereitstellen von Code, der Änderungen in Firebase abhört und 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 Datenmengen beim ersten Export zu verarbeiten und sicherzustellen, dass die bidirektionale Synchronisierung keine unendliche Rekursion erzeugt.

Double Write

In diesem Szenario schreiben Sie eine neue Version der App, die sowohl Firebase als auch Parse verwendet, und verwenden Parse Cloud Code, um Änderungen, die von alten Clients vorgenommen wurden, von den Parse-Daten in die Firebase-Echtzeitdatenbank zu synchronisieren. Wenn genügend Personen von der Nur-Analyse-Version der App migriert sind, können Sie den Analyse-Code aus der Double-Write-Version entfernen.

Dieses Szenario erfordert keinen serverseitigen Code. Die 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-Authentifizierung

Mit der Firebase-Authentifizierung können Benutzer mithilfe von Kennwörtern und beliebten Verbundidentitätsanbietern wie Google, Facebook und Twitter authentifiziert werden. Es bietet auch UI-Bibliotheken, mit denen Sie die erheblichen Investitionen sparen, 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 Firebase-Authentifizierungsdokumenten .

Unterschiede mit Parse Auth

Parse bietet eine spezielle Benutzerklasse namens ParseUser , die automatisch die für die Verwaltung von Benutzerkonten erforderlichen Funktionen verwaltet. ParseUser ist eine Unterklasse des ParseObject bedeutet, dass Benutzerdaten in den Parse-Daten verfügbar sind und wie jedes andere ParseObject um zusätzliche Felder erweitert werden ParseObject .

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.

Das folgende Beispiel zeigt, wie Sie einen Benutzer anmelden 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 nach 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 von der Parse-Konsole oder Ihrer selbst gehosteten Datenbank. Beispielsweise könnte eine aus der Parse-Konsole exportierte JSON-Datei folgendermaßen 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 dann die exportierte Datei in das von der Firebase-CLI erforderliche Format. Verwenden Sie die objectId Ihrer Parse-Benutzer als localId Ihrer Firebase-Benutzer. Außerdem codiert base64 die bcryptPassword Werte von Parse und verwendet sie im Feld passwordHash . Beispielsweise:

{
  "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 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 Datenmigration beschriebenen Strategien in die Firebase-Echtzeitdatenbank migrieren. Wenn Sie wandern Konten den Fluss in der beschriebenen Konten Migration Abschnitt, Ihre Konten Firebase die gleichen IDs Ihrer Parse haben Konten, so dass Sie leicht migrieren und alle Beziehungen durch den Benutzer - ID eingegeben zu reproduzieren.

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 bei Parse Push-Benachrichtigungen

Jeder Parse-Anwendung, die auf einem für Benachrichtigungen registrierten Gerät installiert ist, ist ein Installation , in dem Sie alle Daten speichern, die für die Ausrichtung auf Benachrichtigungen erforderlich sind. Installation ist eine Unterklasse von ParseUser bedeutet, dass Sie Ihren Installation beliebige zusätzliche Daten hinzufügen können.

Der Notifications Composer bietet vordefinierte Benutzersegmente basierend auf Informationen wie App, App-Version und Gerätesprache. Mithilfe von Google Analytics-Ereignissen und -Eigenschaften können Sie komplexere Benutzersegmente erstellen, um Zielgruppen zu erstellen. Weitere Informationen finden Sie in der Zielgruppenhilfe . Diese Targeting-Informationen sind in der Firebase-Echtzeitdatenbank nicht sichtbar.

Vorgeschlagene Migrationsstrategie

Gerätetoken migrieren

Zum Zeitpunkt des Schreibens verwendet das Parse Android SDK eine ältere Version der FCM-Registrierungstoken, 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 das vom Parse SDK zum Empfangen von Benachrichtigungen verwendete Token ungültig machen. 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 das Projekt herunterfährt.

Migrieren von Kanälen zu FCM-Themen

Wenn Sie zum Senden von Benachrichtigungen Parse-Kanäle verwenden, können Sie zu FCM-Themen migrieren, die dasselbe Publisher-Subscriber-Modell bereitstellen. Um den Übergang von Parse zu FCM zu handhaben, 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 Analysekanal als auch an das entsprechende FCM-Thema senden und Benutzer sowohl alter als auch neuer Versionen unterstützen. Wenn genügend Benutzer von der Nur-Analyse-Version der App migriert sind, können Sie diese Version beenden und nur mit FCM senden.

Weitere Informationen finden Sie in den Dokumenten zu FCM-Themen .

Firebase Remote Config

Firebase Remote Config ist ein Cloud-Dienst, mit dem Sie das Verhalten und das Erscheinungsbild Ihrer App ändern können, ohne dass Benutzer ein App-Update herunterladen müssen. Bei Verwendung von Remote Config erstellen Sie In-App-Standardwerte, die das Verhalten und das Erscheinungsbild Ihrer App steuern. Anschließend können Sie später die Firebase-Konsole verwenden, um In-App-Standardwerte für alle App-Benutzer oder für Segmente Ihrer Benutzerbasis zu überschreiben.

Firebase Remote Config kann während Ihrer Migrationen sehr nützlich sein, wenn Sie verschiedene Lösungen testen und mehr Clients dynamisch zu einem anderen Anbieter verschieben möchten. Wenn Sie beispielsweise eine Version Ihrer App haben, die sowohl Firebase als auch Parse für die Daten verwendet, können Sie mithilfe einer zufälligen Perzentilregel 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 mit 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 ParseConfig . Jede ParseConfig Instanz, die Sie erhalten, ist immer unveränderlich. Wenn Sie in Zukunft eine neue ParseConfig aus dem Netzwerk ParseConfig , wird keine vorhandene ParseConfig Instanz ParseConfig , sondern eine neue erstellt und über getCurrentConfig() verfügbar getCurrentConfig() .

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 Variationen der Benutzererfahrung Ihrer App für verschiedene Segmente Ihrer Benutzerbasis 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 jederzeit einen neuen Wertesatz vom Server abrufen, der für Ihre App günstig ist. 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 auf die Firebase-Konsole kopieren und anschließend 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 Nur-Parse-Version migriert sind.

Codevergleich

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