Przeprowadź migrację aplikacji Parse na Androida do Firebase

Jeśli jesteś użytkownikiem Parse i szukasz alternatywnego rozwiązania Backend jako usługa, Firebase może być idealnym wyborem dla Twojej aplikacji na Androida.

W tym przewodniku opisano, jak zintegrować określone usługi z aplikacją. Podstawowe instrukcje konfiguracji Firebase znajdziesz w przewodniku konfiguracji Androida .

Google Analytics

Google Analytics to bezpłatne rozwiązanie do pomiaru aplikacji, które zapewnia wgląd w wykorzystanie aplikacji i zaangażowanie użytkowników. Analytics integruje się z funkcjami Firebase i zapewnia nieograniczone raportowanie dla maksymalnie 500 różnych zdarzeń, które możesz zdefiniować za pomocą pakietu SDK Firebase.

Aby dowiedzieć się więcej, zobacz dokumentację Google Analytics .

Sugerowana strategia migracji

Korzystanie z różnych dostawców usług analitycznych to częsty scenariusz, który można łatwo zastosować w Google Analytics. Po prostu dodaj go do swojej aplikacji, aby korzystać ze zdarzeń i właściwości użytkownika zbieranych automatycznie przez Analytics, takich jak pierwsze uruchomienie, aktualizacja aplikacji, model urządzenia czy wiek.

W przypadku niestandardowych zdarzeń i właściwości użytkownika można zastosować strategię podwójnego zapisu, wykorzystując zarówno Parse Analytics, jak i Google Analytics do rejestrowania zdarzeń i właściwości, co pozwala na stopniowe wdrażanie nowego rozwiązania.

Porównanie kodu

Analizuj analizę

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

Baza danych czasu rzeczywistego Firebase

Baza danych Firebase Realtime Database to baza danych NoSQL hostowana w chmurze. Dane są przechowywane w formacie JSON i synchronizowane w czasie rzeczywistym z każdym podłączonym klientem.

Aby dowiedzieć się więcej, zobacz dokumentację bazy danych czasu rzeczywistego Firebase .

Różnice w analizie danych

Obiekty

W Parse przechowujesz ParseObject lub jego podklasę, która zawiera pary klucz-wartość danych zgodnych z JSON. Dane są pozbawione schematu, co oznacza, że ​​nie musisz określać, jakie klucze istnieją w każdym ParseObject .

Wszystkie dane bazy danych Firebase Realtime Database są przechowywane jako obiekty JSON i nie ma odpowiednika dla ParseObject ; po prostu zapisujesz do drzewa JSON wartości typów, które odpowiadają dostępnym typom JSON. Możesz używać obiektów Java, aby uprościć odczyt i zapis z bazy danych.

Poniżej znajduje się przykład, w jaki sposób można zapisać najlepsze wyniki w grze.

Analizować
@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();
Baza ogniowa
// 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);
Aby uzyskać więcej informacji, zapoznaj się z przewodnikiem dotyczącym odczytu i zapisu danych w systemie Android .

Relacje między danymi

Obiekt ParseObject może mieć relację z innym ParseObject : każdy obiekt może używać innych obiektów jako wartości.

W bazie danych Firebase Realtime Database relacje są lepiej wyrażane przy użyciu płaskich struktur danych, które dzielą dane na osobne ścieżki, dzięki czemu można je efektywnie pobrać w oddzielnych wywołaniach.

Poniżej znajduje się przykład tego, jak można uporządkować relacje między postami w aplikacji do blogowania a ich autorami.

Analizować
// 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();
Baza ogniowa
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);

Wynikiem jest następujący układ danych.

{
  // 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"
    }
    ...
  }
}
Aby uzyskać więcej informacji, zapoznaj się z przewodnikiem Strukturuj swoją bazę danych .

Odczyt danych

W Parse czytasz dane, używając identyfikatora konkretnego obiektu Parse lub wykonując zapytania za pomocą ParseQuery .

W Firebase pobierasz dane, dołączając asynchroniczny odbiornik do odwołania do bazy danych. Odbiornik jest uruchamiany raz dla początkowego stanu danych i ponownie, gdy dane się zmieniają, więc nie musisz dodawać żadnego kodu, aby określić, czy dane się zmieniły.

Poniżej znajduje się przykład, w jaki sposób można uzyskać wyniki dla konkretnego gracza, w oparciu o przykład przedstawiony w sekcji „Obiekty” .

Analizować
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());
        }
    }
});
Baza ogniowa
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());
    }
});
Aby uzyskać więcej informacji na temat dostępnych typów detektorów zdarzeń oraz sposobu porządkowania i filtrowania danych, zapoznaj się z przewodnikiem Odczyt i zapis danych w systemie Android .

Sugerowana strategia migracji

Przemyśl swoje dane

Baza danych Firebase Realtime Database jest zoptymalizowana pod kątem synchronizacji danych w milisekundach między wszystkimi podłączonymi klientami, a wynikowa struktura danych różni się od podstawowych danych Parse. Oznacza to, że pierwszym krokiem migracji jest rozważenie, jakich zmian wymagają Twoje dane, w tym:

  • Jak obiekty Parse powinny być mapowane na dane Firebase
  • Jeśli masz relacje rodzic-dziecko, jak podzielić dane na różne ścieżki, aby można je było efektywnie pobrać w oddzielnych wywołaniach.

Przenieś swoje dane

Gdy już zdecydujesz, jak uporządkować dane w Firebase, musisz zaplanować, jak obsłużyć okres, w którym aplikacja będzie musiała zapisywać dane w obu bazach danych. Twoje możliwości to:

Synchronizacja w tle

W tym scenariuszu masz dwie wersje aplikacji: starą wersję korzystającą z Parse i nową wersję korzystającą z Firebase. Synchronizacje między dwiema bazami danych są obsługiwane przez Parse Cloud Code (Parse do Firebase), przy czym Twój kod nasłuchuje zmian w Firebase i synchronizuje te zmiany z Parse. Zanim zaczniesz korzystać z nowej wersji, musisz:

  • Przekonwertuj istniejące dane analizy na nową strukturę Firebase i zapisz je w bazie danych czasu rzeczywistego Firebase.
  • Napisz funkcje kodu chmury Parse, które korzystają z interfejsu API REST Firebase do zapisywania w bazie danych Firebase Realtime Database zmian wprowadzonych w danych analizy przez starych klientów.
  • Napisz i wdróż kod, który nasłuchuje zmian w Firebase i synchronizuje je z bazą danych Parse.

Ten scenariusz zapewnia czyste oddzielenie starego i nowego kodu oraz zapewnia prostotę obsługi klientów. Wyzwania związane z tym scenariuszem polegają na obsłudze dużych zestawów danych w początkowym eksporcie i zapewnieniu, że synchronizacja dwukierunkowa nie generuje nieskończonej rekurencji.

Podwójny zapis

W tym scenariuszu piszesz nową wersję aplikacji, która korzysta zarówno z Firebase, jak i Parse, używając Parse Cloud Code do synchronizowania zmian wprowadzonych przez starych klientów z Parse Data z bazą danych Firebase Realtime Database. Gdy wystarczająca liczba osób przeprowadzi migrację z wersji aplikacji obsługującej tylko analizę, możesz usunąć kod analizy z wersji z podwójnym zapisem.

Ten scenariusz nie wymaga żadnego kodu po stronie serwera. Jego wadą jest to, że dane, do których nie ma dostępu, nie są migrowane, a rozmiar aplikacji zwiększa się w wyniku użycia obu pakietów SDK.

Uwierzytelnianie Firebase

Uwierzytelnianie Firebase może uwierzytelniać użytkowników przy użyciu haseł i popularnych dostawców tożsamości federacyjnej, takich jak Google, Facebook i Twitter. Udostępnia także biblioteki interfejsu użytkownika, które pozwalają zaoszczędzić znaczne inwestycje wymagane do wdrożenia i utrzymania pełnego uwierzytelniania aplikacji na wszystkich platformach.

Aby dowiedzieć się więcej, zobacz dokumentację dotyczącą uwierzytelniania Firebase .

Różnice w przypadku uwierzytelniania Parse

Parse udostępnia wyspecjalizowaną klasę użytkownika o nazwie ParseUser , która automatycznie obsługuje funkcjonalność wymaganą do zarządzania kontami użytkowników. ParseUser jest podklasą ParseObject , co oznacza, że ​​dane użytkownika są dostępne w Parse Data i mogą zostać rozszerzone o dodatkowe pola, tak jak każdy inny ParseObject .

FirebaseUser ma ustalony zestaw podstawowych właściwości — unikalny identyfikator, podstawowy adres e-mail, imię i nazwisko oraz adres URL zdjęcia — przechowywane w bazie danych użytkowników oddzielnego projektu; te właściwości mogą być aktualizowane przez użytkownika. Nie możesz bezpośrednio dodać innych właściwości do obiektu FirebaseUser ; zamiast tego możesz przechowywać dodatkowe właściwości w bazie danych Firebase Realtime Database.

Poniżej znajduje się przykład rejestracji użytkownika i dodania dodatkowego pola numeru telefonu.

Analizować
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
        }
    }
});
Baza ogniowa
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());
            }
        }
    });

Sugerowana strategia migracji

Przenieś konta

Aby przeprowadzić migrację kont użytkowników z Parse do Firebase, wyeksportuj bazę danych użytkowników do pliku JSON lub CSV, a następnie zaimportuj plik do projektu Firebase za pomocą polecenia auth:import interfejsu Firebase CLI.

Najpierw wyeksportuj bazę danych użytkowników z konsoli Parse lub własnej bazy danych. Na przykład plik JSON wyeksportowany z konsoli Parse może wyglądać następująco:

{ // 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",
  ...
}

Następnie przekształć wyeksportowany plik do formatu wymaganego przez interfejs CLI Firebase. Użyj objectId użytkowników Parse jako localId użytkowników Firebase. Ponadto base64 koduje wartości bcryptPassword z Parse i używa ich w polu passwordHash . Na przykład:

{
  "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
        }
      ]
    }
  ]
}

Na koniec zaimportuj przekształcony plik za pomocą interfejsu CLI Firebase, określając bcrypt jako algorytm mieszający:

firebase auth:import account_file.json --hash-algo=BCRYPT

Przenieś dane użytkownika

Jeśli przechowujesz dodatkowe dane dla swoich użytkowników, możesz przenieść je do bazy danych Firebase Realtime Database, korzystając ze strategii opisanych w sekcji dotyczącej migracji danych . Jeśli przeprowadzasz migrację kont, korzystając z procedury opisanej w sekcji migracji kont , Twoje konta Firebase mają te same identyfikatory co konta Parse, co pozwala na łatwą migrację i odtworzenie wszelkich relacji przypisanych do identyfikatora użytkownika.

Wiadomości w chmurze Firebase

Firebase Cloud Messaging (FCM) to wieloplatformowe rozwiązanie do przesyłania wiadomości, które umożliwia niezawodne i bezpłatne dostarczanie wiadomości i powiadomień. Kompozytor powiadomień to bezpłatna usługa oparta na Firebase Cloud Messaging, która umożliwia kierowanie powiadomień do użytkowników dla twórców aplikacji mobilnych.

Aby dowiedzieć się więcej, zobacz dokumentację Firebase Cloud Messaging .

Różnice w przypadku analizowania powiadomień push

Z każdą aplikacją Parse zainstalowaną na urządzeniu zarejestrowanym do powiadomień jest powiązany obiekt Installation , w którym przechowywane są wszystkie dane potrzebne do ukierunkowania powiadomień. Installation jest podklasą ParseUser , co oznacza, że ​​możesz dodać dowolne dodatkowe dane do instancji Installation .

Kreator powiadomień udostępnia predefiniowane segmenty użytkowników na podstawie informacji takich jak aplikacja, wersja aplikacji i język urządzenia. Możesz tworzyć bardziej złożone segmenty użytkowników, korzystając ze zdarzeń i właściwości Google Analytics w celu budowania odbiorców. Więcej informacji znajdziesz w przewodniku pomocy dla odbiorców . Te informacje o kierowaniu nie są widoczne w bazie danych Firebase Realtime.

Sugerowana strategia migracji

Migracja tokenów urządzeń

W chwili pisania tego tekstu zestaw Parse Android SDK korzysta ze starszej wersji tokenów rejestracyjnych FCM, która nie jest kompatybilna z funkcjami oferowanymi przez kompozytora powiadomień.

Możesz uzyskać nowy token, dodając FCM SDK do swojej aplikacji; może to jednak unieważnić token używany przez zestaw SDK Parse do odbierania powiadomień. Jeśli chcesz tego uniknąć, możesz skonfigurować zestaw SDK Parse tak, aby używał zarówno identyfikatora nadawcy Parse, jak i Twojego identyfikatora nadawcy. W ten sposób nie unieważnisz tokena używanego przez zestaw SDK Parse, ale pamiętaj, że to obejście przestanie działać, gdy Parse zamknie swój projekt.

Migracja kanałów do tematów FCM

Jeśli do wysyłania powiadomień używasz kanałów Parse, możesz przeprowadzić migrację do tematów FCM, które zapewniają ten sam model wydawca-subskrybent. Aby obsłużyć przejście z Parse do FCM, możesz napisać nową wersję aplikacji, która będzie używać zestawu SDK Parse do anulowania subskrypcji kanałów Parse oraz zestawu SDK FCM do subskrybowania odpowiednich tematów FCM. W tej wersji aplikacji należy wyłączyć otrzymywanie powiadomień w zestawie SDK Parse, usuwając następujące elementy z manifestu aplikacji:

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

Na przykład, jeśli Twój użytkownik subskrybuje temat „Giganci”, możesz zrobić coś takiego:

ParsePush.unsubscribeInBackground("Giants", new SaveCallback() {
    @Override
    public void done(ParseException e) {
        if (e == null) {
            FirebaseMessaging.getInstance().subscribeToTopic("Giants");
        } else {
            // Something went wrong unsubscribing
        }
    }
});

Korzystając z tej strategii, możesz wysyłać wiadomości zarówno do kanału Parse, jak i do odpowiedniego tematu FCM, wspierając użytkowników zarówno starych, jak i nowych wersji. Gdy wystarczająca liczba użytkowników przeprowadzi migrację z wersji aplikacji obsługującej tylko analizę, możesz wyłączyć tę wersję i rozpocząć wysyłanie wyłącznie przy użyciu FCM.

Aby dowiedzieć się więcej, zobacz dokumentację tematów FCM .

Zdalna konfiguracja Firebase

Firebase Remote Config to usługa w chmurze, która umożliwia zmianę zachowania i wyglądu aplikacji bez konieczności pobierania aktualizacji aplikacji przez użytkowników. Korzystając ze zdalnej konfiguracji, tworzysz domyślne wartości w aplikacji, które kontrolują zachowanie i wygląd Twojej aplikacji. Następnie możesz później użyć konsoli Firebase, aby zastąpić wartości domyślne w aplikacji dla wszystkich użytkowników aplikacji lub dla segmentów bazy użytkowników.

Zdalna konfiguracja Firebase może być bardzo przydatna podczas migracji w przypadkach, gdy chcesz przetestować różne rozwiązania i mieć możliwość dynamicznego przenoszenia większej liczby klientów do innego dostawcy. Na przykład, jeśli masz wersję aplikacji, która wykorzystuje do danych zarówno Firebase, jak i Parse, możesz użyć reguły losowego percentyla, aby określić, którzy klienci czytają z Firebase, i stopniowo zwiększać tę wartość procentową.

Aby dowiedzieć się więcej o Zdalnej konfiguracji Firebase, zobacz wprowadzenie do Zdalnej konfiguracji .

Różnice w konfiguracji analizy

Dzięki konfiguracji Parse możesz dodać pary klucz/wartość do swojej aplikacji na pulpicie nawigacyjnym Parse Config, a następnie pobrać ParseConfig na kliencie. Każda instancja ParseConfig , którą otrzymasz, jest zawsze niezmienna. Gdy w przyszłości pobierzesz nową instancję ParseConfig z sieci, nie zmodyfikuje ona żadnej istniejącej instancji ParseConfig , ale zamiast tego utworzy nową i udostępni ją za pomocą getCurrentConfig() .

Dzięki Firebase Remote Config możesz utworzyć w aplikacji wartości domyślne dla par klucz/wartość, które możesz zastąpić w konsoli Firebase, a także możesz używać reguł i warunków, aby zapewnić zróżnicowanie sposobu korzystania z aplikacji różnym segmentom użytkowników. Firebase Remote Config implementuje klasę singleton, która udostępnia Twojej aplikacji pary klucz/wartość. Początkowo singleton zwraca wartości domyślne zdefiniowane w aplikacji. Możesz pobrać nowy zestaw wartości z serwera w dowolnym momencie dogodnym dla Twojej aplikacji; po pomyślnym pobraniu nowego zestawu możesz wybrać, kiedy go aktywować, aby nowe wartości były dostępne w aplikacji.

Sugerowana strategia migracji

Możesz przejść do Firebase Remote Config, kopiując pary klucz/wartość konfiguracji Parse do konsoli Firebase, a następnie wdrażając nową wersję aplikacji korzystającą ze zdalnej konfiguracji Firebase.

Jeśli chcesz poeksperymentować zarówno z Parse Config, jak i Firebase Remote Config, możesz wdrożyć nową wersję aplikacji, która korzysta z obu pakietów SDK, dopóki wystarczająca liczba użytkowników nie przeprowadzi migracji z wersji Parse Only.

Porównanie kodu

Analizować

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

Baza ogniowa

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