Google berkomitmen untuk mendorong terwujudnya keadilan ras bagi komunitas Kulit Hitam. Lihat caranya.

Migrasikan Aplikasi Android Parse Anda ke Firebase

Tetap teratur dengan koleksi Simpan dan kategorikan konten berdasarkan preferensi Anda.

Jika Anda adalah pengguna Parse yang mencari solusi Backend sebagai Layanan alternatif, Firebase mungkin menjadi pilihan ideal untuk aplikasi Android Anda.

Panduan ini menjelaskan cara mengintegrasikan layanan tertentu ke dalam aplikasi Anda. Untuk petunjuk penyiapan Firebase dasar, lihat panduan Penyiapan Android .

Google Analytics

Google Analytics adalah solusi pengukuran aplikasi gratis yang memberikan wawasan tentang penggunaan aplikasi dan keterlibatan pengguna. Analytics terintegrasi di seluruh fitur Firebase dan memberi Anda pelaporan tak terbatas hingga 500 peristiwa berbeda yang dapat Anda tentukan menggunakan SDK Firebase.

Lihat dokumen Google Analytics untuk mempelajari lebih lanjut.

Strategi Migrasi yang Disarankan

Menggunakan penyedia analitik yang berbeda adalah skenario umum yang mudah diterapkan ke Google Analytics. Cukup tambahkan ke aplikasi Anda untuk mendapatkan manfaat dari peristiwa dan properti pengguna yang dikumpulkan Analytics secara otomatis, seperti pertama kali dibuka, pembaruan aplikasi, model perangkat, usia.

Untuk peristiwa khusus dan properti pengguna, Anda dapat menerapkan strategi penulisan ganda menggunakan Parse Analytics dan Google Analytics untuk mencatat peristiwa dan properti, yang memungkinkan Anda meluncurkan solusi baru secara bertahap.

Perbandingan Kode

Analisis Parse

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

Basis Data Waktu Nyata Firebase

Firebase Realtime Database adalah database yang dihosting cloud NoSQL. Data disimpan sebagai JSON dan disinkronkan secara real time ke setiap klien yang terhubung.

Lihat dokumen Firebase Realtime Database untuk mempelajari lebih lanjut.

Perbedaan Dengan Parse Data

Objek

Di Parse, Anda menyimpan ParseObject , atau subkelasnya, yang berisi pasangan nilai kunci dari data yang kompatibel dengan JSON. Datanya tanpa skema, yang berarti Anda tidak perlu menentukan kunci apa yang ada di setiap ParseObject .

Semua data Firebase Realtime Database disimpan sebagai objek JSON, dan tidak ada yang setara dengan ParseObject ; Anda cukup menulis ke jenis nilai pohon JSON yang sesuai dengan jenis JSON yang tersedia. Anda dapat menggunakan objek Java untuk menyederhanakan membaca dan menulis dari database.

Berikut ini adalah contoh bagaimana Anda dapat menyimpan skor tinggi untuk sebuah permainan.

Mengurai
@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);
Untuk detail selengkapnya, lihat panduan Baca dan Tulis Data di Android .

Hubungan Antar Data

ParseObject dapat memiliki hubungan dengan ParseObject lain : objek apa pun dapat menggunakan objek lain sebagai nilai.

Di Firebase Realtime Database, hubungan lebih baik diekspresikan menggunakan struktur data datar yang membagi data menjadi jalur terpisah, sehingga dapat diunduh secara efisien dalam panggilan terpisah.

Berikut ini adalah contoh bagaimana Anda dapat menyusun hubungan antara postingan di aplikasi blog dan penulisnya.

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

Berikut tata letak data hasilnya.

{
  // 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"
    }
    ...
  }
}
Untuk detail lebih lanjut, periksa panduan Struktur Database Anda .

Membaca Data

Di Parse Anda membaca data menggunakan ID objek Parse tertentu, atau mengeksekusi kueri menggunakan ParseQuery .

Di Firebase, Anda mengambil data dengan melampirkan listener asinkron ke referensi database. Listener dipicu sekali untuk status awal data dan sekali lagi saat data berubah, jadi Anda tidak perlu menambahkan kode apa pun untuk menentukan apakah data berubah.

Berikut ini adalah contoh bagaimana Anda dapat mengambil skor untuk pemain tertentu, berdasarkan contoh yang disajikan di bagian "Objek" .

Mengurai
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());
    }
});
Untuk detail selengkapnya tentang jenis pendengar acara yang tersedia dan tentang cara memesan dan memfilter data, lihat panduan Baca dan Tulis Data di Android .

Strategi Migrasi yang Disarankan

Pikirkan Kembali Data Anda

Firebase Realtime Database dioptimalkan untuk menyinkronkan data dalam milidetik di semua klien yang terhubung, dan struktur data yang dihasilkan berbeda dari data inti Parse. Ini berarti bahwa langkah pertama migrasi Anda adalah mempertimbangkan perubahan apa yang diperlukan data Anda, termasuk:

  • Bagaimana objek Parse Anda harus dipetakan ke data Firebase
  • Jika Anda memiliki hubungan orang tua-anak, cara membagi data Anda di jalur yang berbeda sehingga dapat diunduh secara efisien dalam panggilan terpisah.

Migrasikan Data Anda

Setelah Anda memutuskan cara menyusun data di Firebase, Anda perlu merencanakan cara menangani periode saat aplikasi Anda perlu menulis ke kedua database. Pilihan Anda adalah:

Sinkronisasi Latar Belakang

Dalam skenario ini, Anda memiliki dua versi aplikasi: versi lama yang menggunakan Parse dan versi baru yang menggunakan Firebase. Sinkronisasi antara dua database ditangani oleh Parse Cloud Code (Parse to Firebase), dengan kode Anda mendengarkan perubahan di Firebase dan menyinkronkan perubahan tersebut dengan Parse. Sebelum Anda dapat mulai menggunakan versi baru, Anda harus:

  • Konversikan Data Parse yang ada ke struktur Firebase baru, dan tulis ke Firebase Realtime Database.
  • Tulis fungsi Parse Cloud Code yang menggunakan Firebase REST API untuk menulis ke Firebase Realtime Database perubahan yang dibuat di Data Parse oleh klien lama.
  • Tulis dan terapkan kode yang mendengarkan perubahan pada Firebase dan menyinkronkannya ke database Parse.

Skenario ini memastikan pemisahan yang bersih antara kode lama dan baru, dan membuat klien tetap sederhana. Tantangan skenario ini adalah menangani kumpulan data besar dalam ekspor awal, dan memastikan bahwa sinkronisasi dua arah tidak menghasilkan rekursi tak terbatas.

Tulis Ganda

Dalam skenario ini, Anda menulis versi baru aplikasi yang menggunakan Firebase dan Parse, menggunakan Parse Cloud Code untuk menyinkronkan perubahan yang dibuat oleh klien lama dari Data Parse ke Firebase Realtime Database. Ketika cukup banyak orang telah bermigrasi dari versi aplikasi Parse saja, Anda dapat menghapus kode Parse dari versi tulis ganda.

Skenario ini tidak memerlukan kode sisi server apa pun. Kerugiannya adalah data yang tidak diakses tidak dimigrasikan, dan ukuran aplikasi Anda bertambah dengan penggunaan kedua SDK.

Otentikasi Firebase

Firebase Authentication dapat mengautentikasi pengguna menggunakan kata sandi dan penyedia identitas federasi populer seperti Google, Facebook, dan Twitter. Ini juga menyediakan perpustakaan UI untuk menghemat investasi signifikan yang diperlukan untuk menerapkan dan memelihara pengalaman autentikasi penuh untuk aplikasi Anda di semua platform.

Lihat dokumen Firebase Authentication untuk mempelajari lebih lanjut.

Perbedaan Dengan Parse Auth

Parse menyediakan kelas pengguna khusus yang disebut ParseUser yang secara otomatis menangani fungsionalitas yang diperlukan untuk manajemen akun pengguna. ParseUser adalah subkelas dari ParseObject , yang berarti data pengguna tersedia di Data Parse dan dapat diperluas dengan bidang tambahan seperti ParseObject lainnya .

FirebaseUser memiliki kumpulan properti dasar yang tetap—ID unik, alamat email utama, nama, dan URL foto—yang disimpan dalam database pengguna proyek terpisah; properti tersebut dapat diperbarui oleh pengguna. Anda tidak dapat menambahkan properti lain ke objek FirebaseUser secara langsung; sebagai gantinya, Anda dapat menyimpan properti tambahan di Firebase Realtime Database.

Berikut ini adalah contoh bagaimana Anda dapat mendaftarkan pengguna dan menambahkan bidang nomor telepon tambahan.

Mengurai
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());
            }
        }
    });

Strategi Migrasi yang Disarankan

Migrasi Akun

Untuk memigrasikan akun pengguna dari Parse ke Firebase, ekspor database pengguna Anda ke file JSON atau CSV, lalu impor file ke proyek Firebase Anda menggunakan perintah auth:import dari Firebase CLI.

Pertama, ekspor database pengguna Anda dari konsol Parse atau database yang dihosting sendiri. Misalnya, file JSON yang diekspor dari konsol Parse mungkin terlihat seperti berikut:

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

Kemudian, ubah file yang diekspor ke format yang diperlukan oleh Firebase CLI. Gunakan objectId pengguna Parse Anda sebagai localId pengguna Firebase Anda. Juga, base64 menyandikan nilai bcryptPassword dari Parse dan menggunakannya di bidang passwordHash . Sebagai contoh:

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

Terakhir, impor file yang diubah dengan Firebase CLI, tentukan bcrypt sebagai algoritme hash:

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

Migrasikan Data Pengguna

Jika Anda menyimpan data tambahan untuk pengguna, Anda dapat memigrasikannya ke Firebase Realtime Database menggunakan strategi yang dijelaskan di bagian migrasi data . Jika Anda memigrasikan akun menggunakan alur yang dijelaskan di bagian migrasi akun , akun Firebase Anda memiliki id yang sama dengan akun Parse Anda, memungkinkan Anda untuk dengan mudah memigrasi dan mereproduksi hubungan apa pun yang dikunci oleh id pengguna.

Perpesanan Cloud Firebase

Firebase Cloud Messaging (FCM) adalah solusi perpesanan lintas platform yang memungkinkan Anda mengirimkan pesan dan notifikasi secara andal tanpa biaya. Notifications Composer adalah layanan tanpa biaya yang dibangun di atas Firebase Cloud Messaging yang memungkinkan notifikasi pengguna yang ditargetkan untuk developer aplikasi seluler.

Lihat dokumen Firebase Cloud Messaging untuk mempelajari lebih lanjut.

Perbedaan Dengan Parse Push Notifications

Setiap aplikasi Parse yang diinstal pada perangkat yang terdaftar untuk notifikasi memiliki objek Installation terkait, tempat Anda menyimpan semua data yang diperlukan untuk menargetkan notifikasi. Installation adalah subkelas ParseUser , yang berarti Anda dapat menambahkan data tambahan apa pun yang Anda inginkan ke instance Installation Anda.

Notifications Composer menyediakan segmen pengguna yang telah ditentukan sebelumnya berdasarkan informasi seperti aplikasi, versi aplikasi, dan bahasa perangkat. Anda dapat membuat segmen pengguna yang lebih kompleks menggunakan peristiwa dan properti Google Analytics untuk membangun audiens. Lihat panduan bantuan audiens untuk mempelajari lebih lanjut. Informasi penargetan ini tidak terlihat di Firebase Realtime Database.

Strategi Migrasi yang Disarankan

Memigrasikan Token Perangkat

Pada saat penulisan, Parse Android SDK menggunakan versi lama dari token pendaftaran FCM, tidak kompatibel dengan fitur yang ditawarkan oleh Notifications composer.

Anda bisa mendapatkan token baru dengan menambahkan FCM SDK ke aplikasi Anda; namun, ini mungkin membatalkan token yang digunakan oleh Parse SDK untuk menerima notifikasi. Jika Anda ingin menghindarinya, Anda dapat mengatur Parse SDK untuk menggunakan ID pengirim Parse dan ID pengirim Anda. Dengan cara ini Anda tidak membatalkan token yang digunakan oleh Parse SDK, tetapi perlu diketahui bahwa solusi ini akan berhenti bekerja ketika Parse menutup proyeknya.

Memigrasi Saluran Ke Topik FCM

Jika Anda menggunakan saluran Parse untuk mengirim notifikasi, Anda dapat bermigrasi ke topik FCM, yang menyediakan model penerbit-pelanggan yang sama. Untuk menangani transisi dari Parse ke FCM, Anda dapat menulis versi baru aplikasi yang menggunakan Parse SDK untuk berhenti berlangganan saluran Parse dan FCM SDK untuk berlangganan topik FCM yang sesuai. Dalam versi aplikasi ini, Anda harus menonaktifkan penerimaan notifikasi di Parse SDK, dengan menghapus yang berikut dari manifes aplikasi Anda:

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

Misalnya, jika pengguna Anda berlangganan topik "Raksasa", Anda akan melakukan sesuatu seperti:

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

Dengan menggunakan strategi ini, Anda dapat mengirim pesan ke saluran Parse dan topik FCM yang sesuai, mendukung pengguna versi lama dan baru. Jika cukup banyak pengguna yang telah bermigrasi dari versi aplikasi hanya Parse, Anda dapat menghentikan versi tersebut dan mulai mengirim menggunakan FCM saja.

Lihat dokumen topik FCM untuk mempelajari lebih lanjut.

Konfigurasi Jarak Jauh Firebase

Firebase Remote Config adalah layanan cloud yang memungkinkan Anda mengubah perilaku dan tampilan aplikasi tanpa mengharuskan pengguna mengunduh pembaruan aplikasi. Saat menggunakan Remote Config, Anda membuat nilai default dalam aplikasi yang mengontrol perilaku dan tampilan aplikasi Anda. Kemudian, Anda nanti dapat menggunakan Firebase console untuk mengganti nilai default dalam aplikasi untuk semua pengguna aplikasi atau untuk segmen basis pengguna Anda.

Firebase Remote Config bisa sangat berguna selama migrasi Anda jika Anda ingin menguji solusi yang berbeda dan dapat secara dinamis memindahkan lebih banyak klien ke penyedia yang berbeda. Misalnya, jika Anda memiliki versi aplikasi yang menggunakan Firebase dan Parse untuk data, Anda dapat menggunakan aturan persentil acak untuk menentukan klien mana yang membaca dari Firebase, dan secara bertahap meningkatkan persentasenya.

Untuk mempelajari lebih lanjut tentang Firebase Remote Config, lihat pengantar Remote Config .

Perbedaan Dengan Parse Config

Dengan Parse config, Anda dapat menambahkan pasangan kunci/nilai ke aplikasi Anda di Dasbor Parse Config, lalu mengambil ParseConfig di klien. Setiap instance ParseConfig yang Anda dapatkan selalu tidak berubah. Saat Anda mengambil ParseConfig baru di masa mendatang dari jaringan, itu tidak akan mengubah instance ParseConfig yang ada, tetapi akan membuat yang baru dan membuatnya tersedia melalui getCurrentConfig() .

Dengan Firebase Remote Config, Anda membuat default dalam aplikasi untuk pasangan kunci/nilai yang dapat Anda ganti dari Firebase console, dan Anda dapat menggunakan aturan dan ketentuan untuk memberikan variasi pada pengalaman pengguna aplikasi Anda ke berbagai segmen basis pengguna Anda. Firebase Remote Config mengimplementasikan kelas tunggal yang membuat pasangan kunci/nilai tersedia untuk aplikasi Anda. Awalnya singleton mengembalikan nilai default yang Anda tetapkan dalam aplikasi. Anda dapat mengambil set nilai baru dari server kapan saja sesuai dengan aplikasi Anda; setelah set baru berhasil diambil, Anda dapat memilih kapan harus mengaktifkannya untuk membuat nilai baru tersedia untuk aplikasi.

Strategi Migrasi yang Disarankan

Anda dapat pindah ke Firebase Remote Config dengan menyalin key/value pair dari konfigurasi Parse Anda ke Firebase console, lalu men-deploy versi baru aplikasi yang menggunakan Firebase Remote Config.

Jika Anda ingin bereksperimen dengan Parse Config dan Firebase Remote Config, Anda dapat menerapkan versi baru aplikasi yang menggunakan kedua SDK hingga cukup banyak pengguna yang bermigrasi dari versi Parse only.

Perbandingan Kode

Mengurai

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