Jika Anda pengguna Parse yang mencari Backend alternatif sebagai solusi Layanan, Firebase dapat menjadi pilihan ideal bagi aplikasi Android Anda.
Panduan ini menjelaskan cara mengintegrasikan layanan tertentu ke aplikasi Anda. Untuk mengetahui petunjuk penyiapan Firebase dasar, lihat panduan Penyiapan Android.
Google Analytics
Google Analytics adalah solusi pengukuran aplikasi gratis yang memberikan insight mengenai penggunaan aplikasi dan interaksi pengguna. Analytics terintegrasi dengan berbagai fitur Firebase dan menyediakan pelaporan tak terbatas hingga 500 peristiwa berbeda yang dapat Anda tentukan menggunakan Firebase SDK.
Baca dokumentasi Google Analytics untuk mempelajari lebih lanjut.
Strategi Migrasi yang Disarankan
Menggunakan berbagai penyedia analisis adalah skenario umum yang mudah diterapkan pada Google Analytics. Cukup tambahkan penyedia analisis ke aplikasi Anda untuk memanfaatkan 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 Parse Analytics dan Google Analytics untuk mencatat peristiwa dan properti ke dalam log sehingga Anda dapat meluncurkan solusi baru secara bertahap.
Perbandingan Kode
Parse Analytics
// Start collecting data
ParseAnalytics.trackAppOpenedInBackground(getIntent());
Map<String, String> dimensions = new HashMap<String, String>();
// Define ranges to bucket data points into meaningful segments
dimensions.put("priceRange", "1000-1500");
// Did the user filter the query?
dimensions.put("source", "craigslist");
// Do searches happen more often on weekdays or weekends?
dimensions.put("dayType", "weekday");
// Send the dimensions to Parse along with the 'search' event
ParseAnalytics.trackEvent("search", dimensions);
Google Analytics
// Obtain the FirebaseAnalytics instance and start collecting data
mFirebaseAnalytics = FirebaseAnalytics.getInstance(this);
Bundle params = new Bundle();
// Define ranges to bucket data points into meaningful segments
params.putString("priceRange", "1000-1500");
// Did the user filter the query?
params.putString("source", "craigslist");
// Do searches happen more often on weekdays or weekends?
params.putString("dayType", "weekday");
// Send the event
mFirebaseAnalytics.logEvent("search", params);
Firebase Realtime Database
Firebase Realtime Database adalah database NoSQL yang dihosting di cloud. Data disimpan sebagai JSON dan disinkronkan secara real-time pada setiap klien yang terhubung.
Baca dokumentasi Firebase Realtime Database untuk mempelajari lebih lanjut.
Perbedaan dengan Data Parse
Objek
Dalam Parse, Anda menyimpan ParseObject, atau subclass-nya, yang berisi key-value pair dari data yang kompatibel dengan JSON. Data tersebut tidak memiliki skema, sehingga Anda tidak perlu menentukan kunci yang terdapat di setiap ParseObject.
Semua data Firebase Realtime Database disimpan sebagai objek JSON, dan tidak ada kesamaan untuk ParseObject; Anda cukup menuliskan nilai yang terkait dengan jenis JSON yang tersedia ke hierarki JSON.
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);
Hubungan Antardata
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 beberapa jalur, 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 menambahkan pemroses asinkron ke referensi database. Pemroses 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());
}
});
Strategi Migrasi yang Disarankan
Memikirkan 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 ke jalur yang berbeda-beda jika Anda memiliki hubungan induk-turunan, sehingga data tersebut dapat didownload secara efisien dalam panggilan yang terpisah.
Memigrasikan 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, lalu 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 men-deploy 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 sisi server apa pun. Kekurangannya 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 mengurangi biaya yang diperlukan 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 fungsionalitas yang diperlukan untuk mengelola akun pengguna. ParseUser adalah subclass ParseObject, yang berarti data pengguna tersedia di Data Parse dan dapat dilengkapi dengan kolom tambahan seperti ParseObject lainnya.
FirebaseUser memiliki rangkaian properti dasar yang tetap—ID unik, alamat email utama, nama, dan URL foto—yang disimpan di database pengguna dalam project terpisah. Properti tersebut dapat diperbarui oleh pengguna. Anda tidak dapat menambahkan langsung properti lain ke objek FirebaseUser, tetapi 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
Memigrasikan Akun
Untuk memigrasikan akun pengguna dari Parse ke Firebase, ekspor database pengguna ke file JSON atau CSV, lalu impor file tersebut ke project Firebase menggunakan perintah auth:import Firebase CLI.
Pertama-tama, ekspor database pengguna dari konsol Parse atau database yang Anda hosting 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, enkode nilai bcryptPassword dari Parse dalam format base64, lalu gunakan di kolom passwordHash. 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 tersebut dengan Firebase CLI, dengan menentukan bcrypt sebagai algoritme hash:
firebase auth:import account_file.json --hash-algo=BCRYPT
Memigrasikan Data Pengguna
Jika 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 akan memiliki ID yang sama dengan akun Parse Anda, sehingga memudahkan Anda memigrasikan dan mereproduksi setiap hubungan yang dikuncikan oleh 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 tanpa biaya yang dikembangkan di Firebase Cloud Messaging, yang memungkinkan developer aplikasi seluler membuat notifikasi untuk pengguna target.
Untuk mempelajari lebih lanjut, baca dokumentasi Firebase Cloud Messaging.
Perbedaan dengan Parse Push Notification
Setiap aplikasi Parse yang diinstal di perangkat yang terdaftar untuk menerima notifikasi memiliki objek Installation terkait, tempat Anda menyimpan semua data yang diperlukan untuk menargetkan notifikasi.
Installation adalah subclass ParseUser, yang berarti Anda dapat menambahkan data tambahan yang diinginkan ke instance Installation.
Notifications Composer menyediakan segmen pengguna bawaan berdasarkan informasi seperti aplikasi, versi aplikasi, dan bahasa perangkat. Anda dapat membangun segmen pengguna yang lebih kompleks menggunakan peristiwa dan properti Google Analytics 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.
Memigrasikan 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. Saat menggunakan Remote Config, Anda membuat nilai default dalam aplikasi yang mengontrol perilaku dan tampilan aplikasi. Kemudian, Anda bisa menggunakan Firebase console untuk mengganti nilai default dalam aplikasi untuk semua pengguna aplikasi atau 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 persentasenya.
Untuk mempelajari Firebase Remote Config lebih lanjut, baca Pengantar Remote Config.
Perbedaan dengan Parse Config
Dengan konfigurasi Parse, Anda dapat menambahkan key-value pair ke aplikasi di Parse Config Dashboard, lalu mengambil ParseConfig pada klien. Setiap instance ParseConfig yang Anda dapatkan selalu bersifat tidak dapat diubah. Jika di masa mendatang Anda mengambil ParseConfig baru dari jaringan, instance ParseConfig yang ada tidak akan berubah. Namun, instance baru akan dibuat dan tersedia melalui getCurrentConfig()
Dengan Firebase Remote Config, Anda membuat key-value pair default dalam aplikasi yang dapat diganti dari Firebase console. Anda juga dapat menggunakan aturan dan kondisi untuk memberikan variasi pengalaman pengguna aplikasi ke berbagai segmen basis pengguna. Firebase Remote Config menerapkan class singleton yang membuat key-value pair tersedia bagi aplikasi Anda. Awalnya singleton menampilkan nilai default yang Anda tentukan dalam aplikasi. Anda dapat mengambil kumpulan nilai baru dari server kapan saja sesuai waktu yang paling tepat untuk aplikasi Anda. Setelah kumpulan baru berhasil diambil, Anda dapat memilih kapan harus mengaktifkannya untuk membuat nilai baru tersedia untuk aplikasi.
Strategi Migrasi yang Disarankan
Anda dapat melakukan pemindahan ke Firebase Remote Config dengan menyalin key-value pair konfigurasi Parse Anda ke Firebase console, kemudian men-deploy versi baru aplikasi yang menggunakan Firebase Remote Config.
Jika ingin bereksperimen dengan Parse Config dan Firebase Remote Config, Anda dapat men-deploy 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");