Buka konsol

Memigrasikan Aplikasi Parse pada Android ke Firebase

Jika Anda pengguna Parse yang mencari Backend alternatif sebagai solusi Layanan, Firebase dapat menjadi pilihan ideal bagi aplikasi Android Anda.

Panduan ini berisi penjelasan mengenai cara menggabungkan layanan spesifik ke dalam aplikasi Anda. Untuk mengetahui petunjuk penyiapan dasar Firebase, baca panduan Penyiapan Android.

Google Analytics for Firebase

Google Analytics for Firebase adalah solusi gratis untuk pengukuran aplikasi, yang memberikan insight mengenai penggunaan aplikasi dan interaksi pengguna. Analytics menggabungkan berbagai fitur Firebase dan menyediakan laporan tak terbatas hingga 500 peristiwa berbeda yang dapat Anda tentukan menggunakan Firebase SDK.

Lihat dokumentasi Google Analytics for Firebase untuk mempelajari lebih lanjut.

Strategi Migrasi yang Disarankan

Menggunakan berbagai penyedia analisis merupakan skenario umum yang mudah diterapkan pada Google Analytics for Firebase. Cukup tambahkan penyedia analisis ke aplikasi Anda untuk memanfaatkan data dari peristiwa dan properti pengguna yang dikumpulkan Analytics secara otomatis, seperti pembukaan aplikasi untuk pertama kali, update aplikasi, model perangkat, usia.

Untuk peristiwa kustom dan properti pengguna, Anda dapat menggunakan strategi penulisan ganda menggunakan Analytics Parse dan Google Analytics for Firebase guna mencatat peristiwa dan properti ke dalam log, sehingga Anda dapat meluncurkan solusi baru secara bertahap.

Perbandingan Kode

Analytics 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 for Firebase

// 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 adalah database NoSQL yang di-host di cloud. Data disimpan sebagai JSON dan disinkronkan secara real-time pada setiap klien yang terhubung.

Baca Dokumen Firebase Realtime Database untuk mempelajari lebih lanjut.

Perbedaan dengan Data Parse

Objek

Dalam Parse, Anda menyimpan ParseObject, atau subkelasnya, yang berisi key-value pair dari data yang kompatibel dengan JSON. Data tersebut tidak berskema, yang berarti Anda tidak perlu menentukan kunci yang ada di setiap ParseObject.

Semua data Firebase Realtime Database disimpan sebagai objek JSON, dan tidak ada kesamaan untuk ParseObject. Anda cukup melakukan penulisan ke nilai jenis pohon JSON yang terkait dengan jenis JSON yang tersedia. Anda dapat menggunakan objek Java untuk menyederhanakan pembacaan dan penulisan dari database.

Berikut adalah contoh cara menyimpan skor tertinggi dalam sebuah game.

Parse
@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 mengetahui detail selengkapnya, baca panduan Membaca dan Menulis Data di Android.

Hubungan Antardata

Sebuah ParseObject dapat memiliki hubungan dengan ParseObject yang lain: setiap objek dapat menggunakan objek lain sebagai nilai.

Dalam Firebase Realtime Database, hubungan sebaiknya dinyatakan menggunakan struktur data rata yang membagi data ke dalam lokasi yang terpisah, sehingga dapat didownload secara efisien dalam panggilan yang terpisah.

Berikut adalah contoh cara membuat struktur hubungan antara postingan di aplikasi blog dan penulisnya.

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

Tata letak data berikut ini adalah 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 mengetahui detail selengkapnya, baca panduan Membuat Struktur Database.

Membaca Data

Dalam Parse, Anda membaca data menggunakan ID dari objek Parse tertentu, atau menjalankan kueri menggunakan ParseQuery.

Dalam Firebase, Anda mengambil data dengan memasang listener asinkron ke referensi database. Listener dipicu satu kali untuk status awal data dan dipicu kembali ketika data berubah, sehingga Anda tidak perlu menambahkan kode untuk mengetahui apakah datanya berubah.

Berikut adalah contoh cara mengambil skor untuk pemain tertentu, berdasarkan contoh yang diberikan di bagian "Objek".

Parse
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 mengetahui detail selengkapnya mengenai jenis listener peristiwa yang tersedia, serta cara mengurutkan dan memfilter data, baca panduan Membaca dan Menulis Data di Android.

Strategi Migrasi yang Disarankan

Pikirkan Ulang Data Anda

Firebase Realtime Database dioptimalkan untuk menyinkronkan data dalam waktu milidetik pada semua klien yang terhubung, dan struktur data yang dihasilkan berbeda dari data inti Parse. Artinya, langkah pertama saat akan melakukan migrasi adalah mempertimbangkan perubahan yang dibutuhkan data Anda, termasuk:

  • Cara memetakan objek Parse Anda ke data Firebase
  • Cara memisahkan data melalui lokasi yang berbeda, jika Anda memiliki hubungan induk-turunan, sehingga data tersebut dapat didownload secara efisien dalam panggilan yang terpisah.

Migrasikan Data Anda

Setelah menentukan cara membuat struktur data di Firebase, Anda harus merencanakan cara menangani waktu selama aplikasi harus melakukan penulisan ke kedua database tersebut. Pilihan untuk 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 ke Firebase), beserta kode Anda yang mendeteksi perubahan pada Firebase dan menyinkronkan perubahan tersebut dengan Parse. Sebelum dapat mulai menggunakan versi yang baru, Anda harus:

  • Mengubah Data Parse yang ada ke struktur Firebase yang baru, dan menulisnya ke Firebase Realtime Database.
  • Menulis fungsi Parse Cloud Code yang menggunakan Firebase REST API untuk melakukan penulisan ke perubahan Firebase Realtime Database yang dibuat di Data Parse oleh klien lama.
  • Menulis dan menerapkan kode yang mendeteksi perubahan pada Firebase, lalu menyinkronkannya dengan database Parse.

Skenario ini memastikan pemisahan yang jelas antara kode baru dan kode lama, dan tetap menyederhanakan klien. Tantangan dari skenario ini adalah menangani set data besar dalam ekspor awal, dan memastikan bahwa sinkronisasi dua arah tidak menghasilkan perulangan yang tak terbatas.

Penulisan Ganda

Dalam skenario ini, Anda menulis versi baru dari aplikasi yang menggunakan Firebase dan Parse, menggunakan Parse Cloud Code untuk menyinkronkan perubahan yang dilakukan klien lama dari Data Parse ke Firebase Realtime Database. Jika ada cukup orang yang bermigrasi dari versi aplikasi khusus Parse, Anda dapat menghapus kode Parse dari versi penulisan ganda.

Skenario ini tidak membutuhkan kode server apa pun. Kerugiannya adalah data yang tidak diakses tidak akan dimigrasikan, dan ukuran aplikasi Anda akan meningkat karena penggunaan kedua SDK.

Firebase Authentication

Firebase Authentication dapat melakukan autentikasi pengguna menggunakan sandi dan penyedia identitas gabungan populer seperti Google, Facebook, dan Twitter. Firebase Authentication juga menyediakan library UI yang menyimpan investasi penting Anda, untuk menerapkan serta mengelola pengalaman autentikasi penuh bagi aplikasi Anda di seluruh platform.

Baca Dokumentasi Firebase Authentication untuk mempelajari lebih lanjut.

Perbedaan Dengan Parse Auth

Parse menyediakan class pengguna khusus yang disebut ParseUser, yang otomatis menangani fungsi yang diperlukan untuk mengelola akun pengguna. ParseUser adalah subkelas ParseObject, yang berarti data pengguna tersedia di Data Parse dan dapat diperluas dengan kolom tambahan seperti ParseObject lainnya.

Sebuah FirebaseUser memiliki kumpulan tetap properti dasar—ID unik, alamat email utama, nama, dan URL foto—yang tersimpan dalam database project pengguna secara terpisah. Properti tersebut dapat diupdate 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 adalah contoh cara mendaftarkan pengguna dan menambahkan kolom nomor telepon tambahan.

Parse
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 tersebut ke dalam project Firebase menggunakan perintah auth:import Firebase CLI.

Pertama-tama, ekspor database pengguna Anda dari konsol Parse atau database yang Anda host sendiri. Misalnya, file JSON yang diekspor dari konsol Parse mungkin akan 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",
  ...
}

Selanjutnya, ubah file yang diekspor tersebut menjadi format yang diperlukan oleh Firebase CLI. Gunakan objectId pengguna Parse Anda sebagai localId pengguna Firebase Anda. Selain itu, base64 mengenkode nilai bcryptPassword dari Parse dan menggunakannya di kolom passwordHash. Misalnya:

{
  "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 tersebut dengan Firebase CLI, dengan menentukan bcrypt sebagai algoritme hash:

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

Migrasikan Data Pengguna

Jika akan menyimpan data tambahan untuk pengguna, Anda dapat memigrasikannya ke Firebase Realtime Database menggunakan strategi yang dijelaskan di bagian migrasi data. Jika Anda melakukan migrasi akun menggunakan alur yang dijelaskan di bagian migrasi akun, akun Firebase Anda akan memiliki ID yang sama dengan akun Parse Anda, sehingga memudahkan Anda melakukan migrasi dan memproduksi kembali setiap hubungan yang terkunci dengan ID pengguna.

Firebase Cloud Messaging

Firebase Cloud Messaging (FCM) adalah solusi pengiriman pesan lintas platform, yang memungkinkan Anda untuk mengirim pesan dan notifikasi secara tepercaya tanpa biaya. Notifications Composer adalah layanan gratis yang dikembangkan di Firebase Cloud Messaging, memungkinkan developer aplikasi seluler membuat notifikasi ke pengguna target.

Untuk mempelajari lebih lanjut, silakan lihat dokumentasi Firebase Cloud Messaging.

Perbedaan dengan Parse Push Notification

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

Notifications Composer menyediakan segmen pengguna yang telah ditetapkan berdasarkan informasi seperti aplikasi, versi aplikasi, dan bahasa perangkat. Anda dapat membangun segmen pengguna yang lebih kompleks menggunakan peristiwa dan properti Google Analytics for Firebase untuk membangun audience. Baca panduan bantuan audience untuk mempelajari lebih lanjut. Informasi penargetan ini tidak terlihat dalam Firebase Realtime Database.

Strategi Migrasi yang Disarankan

Melakukan Migrasi Token Perangkat

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

Anda dapat memperoleh token baru dengan menambahkan FCM SDK ke aplikasi Anda. Namun, hal ini mungkin dapat membatalkan validasi token yang digunakan oleh Parse SDK untuk menerima notifikasi. Jika ingin menghindari hal tersebut, Anda dapat menyiapkan Parse SDK untuk menggunakan ID pengirim Parse dan ID pengirim Anda. Dengan cara ini, Anda tidak akan membatalkan validasi token yang digunakan oleh Parse SDK. Namun, perlu diperhatikan bahwa solusi ini mungkin akan berhenti berfungsi jika Parse menutup project-nya.

Melakukan Migrasi Saluran ke Topik FCM

Jika Anda menggunakan saluran Parse untuk mengirim notifikasi, Anda dapat melakukan migrasi ke topik FCM, yang menyediakan mode penayang-pelanggan yang sama. Untuk menangani transisi dari Parse ke FCM, Anda dapat menulis versi aplikasi baru yang menggunakan Parse SDK untuk berhenti berlangganan dari saluran Parse, dan FCM SDK untuk berlangganan ke topik FCM yang terkait. Dalam versi aplikasi ini, Anda harus menonaktifkan penerimaan notifikasi di Parse SDK, sehingga akan menghapus hal 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 ke topik "Giants", Anda akan melakukan hal 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 mengirimkan pesan ke saluran Parse dan topik FCM yang sesuai, sehingga mendukung pengguna versi lama maupun baru. Jika sudah ada cukup pengguna yang bermigrasi dari versi aplikasi khusus Parse, Anda dapat mengakhiri masa berlaku versi tersebut dan mulai melakukan pengiriman menggunakan FCM saja.

Untuk mempelajari lebih lanjut, lihat dokumentasi topik FCM.

Firebase Remote Config

Firebase Remote Config adalah layanan cloud yang dapat digunakan untuk mengubah perilaku dan tampilan aplikasi tanpa mengharuskan pengguna mendownload update aplikasi. Ketika menggunakan Remote Config, Anda membuat nilai default dalam aplikasi yang mengontrol perilaku dan tampilan aplikasi. Anda nantinya dapat menggunakan Firebase console untuk mengganti nilai default dalam aplikasi untuk semua pengguna aplikasi, atau untuk segmen basis pengguna Anda.

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

Untuk mempelajari lebih lanjut mengenai Firebase Remote Config, baca Pengantar Remote Config.

Perbedaan dengan Parse Config

Dengan konfigurasi Parse, Anda dapat menambahkan pasangan key-value pair ke aplikasi di Dasbor Parse Config, lalu mengambil ParseConfig pada klien. Setiap instance ParseConfig yang Anda dapatkan akan selalu tetap. Ketika Anda mengambil ParseConfig yang baru di masa mendatang dari jaringan, instance ParseConfig yang ada tidak akan berubah. Namun, instance baru akan dibuat dan tersedia melalui getCurrentConfig().

Dengan Firebase Remote Config, Anda akan membuat pasangan key-value pair default dalam aplikasi yang dapat diganti dari Firebase console. Anda juga dapat menggunakan berbagai aturan dan kondisi, guna menyediakan variasi terhadap pengalaman pengguna aplikasi untuk berbagai segmen basis pengguna. Firebase Remote Config menerapkan class tunggal yang menyediakan key-value pair untuk aplikasi Anda. Mulanya, class tunggal tersebut menampilkan nilai default yang Anda tetapkan dalam aplikasi. Anda dapat mengambil kumpulan nilai yang baru dari server kapan saja untuk aplikasi Anda secara mudah. Setelah kumpulan baru tersebut berhasil diambil, Anda dapat memilih waktu pengaktifannya agar nilai yang baru tersedia pada aplikasi.

Strategi Migrasi yang Disarankan

Anda dapat melakukan pemindahan ke Firebase Remote Config dengan menyalin key-value pair Parse config Anda ke Firebase console, kemudian menerapkan versi baru aplikasi yang menggunakan Firebase Remote Config.

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

Perbandingan Kode

Parse

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