אם אתה משתמש Parse שמחפש פתרון אחורי כשירות חלופי, Firebase עשוי להיות הבחירה האידיאלית עבור אפליקציית Android שלך.
מדריך זה מתאר כיצד לשלב שירותים ספציפיים באפליקציה שלך. להוראות הגדרה בסיסיות של Firebase, עיין במדריך ההתקנה של Android .
גוגל ניתוח נתונים
Google Analytics הוא פתרון למדידת אפליקציה בחינם, המספק תובנות לגבי השימוש באפליקציה ומעורבות המשתמשים. Analytics משתלב בין תכונות Firebase ומספק לך דיווח בלתי מוגבל עבור עד 500 אירועים שונים שתוכל להגדיר באמצעות Firebase SDK.
עיין במסמכים של Google Analytics למידע נוסף.
אסטרטגיית הגירה מוצעת
שימוש בספקי ניתוח שונים הוא תרחיש נפוץ שחל בקלות על Google Analytics. פשוט הוסף אותו לאפליקציה שלך כדי ליהנות מאירועים ומנכסי משתמש ש-Analytics אוספת אוטומטית, כמו פתיחה ראשונה, עדכון אפליקציה, דגם מכשיר, גיל.
עבור אירועים מותאמים אישית ונכסי משתמש, אתה יכול להשתמש באסטרטגיית כתיבה כפולה באמצעות ניתוח אנליטיקס ו-Google 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);
גוגל ניתוח נתונים
// 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
מסד הנתונים בזמן אמת של Firebase הוא מסד נתונים המתארח בענן NoSQL. הנתונים מאוחסנים כ-JSON ומסונכרנים בזמן אמת לכל לקוח מחובר.
עיין במסמכים של Firebase Realtime Database למידע נוסף.
הבדלים עם נתוני ניתוח
חפצים
ב-Parse אתה מאחסן ParseObject , או תת-מחלקה שלו, שמכיל זוגות מפתח-ערך של נתונים תואמי JSON. הנתונים הם ללא סכמה, מה שאומר שאינך צריך לציין אילו מפתחות קיימים בכל ParseObject .
כל נתוני Firebase Realtime Database מאוחסנים כאובייקטי JSON, ואין מקבילה עבור ParseObject ; אתה פשוט כותב לעץ ה-JSON ערכי סוגים התואמים לסוגי ה-JSON הזמינים. אתה יכול להשתמש באובייקטי Java כדי לפשט את הקריאה והכתיבה ממסד הנתונים.
להלן דוגמה כיצד תוכל לשמור את הציונים הגבוהים למשחק.
לְנַתֵחַ
@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);
יחסים בין נתונים
ל- ParseObject יכול להיות קשר עם ParseObject אחר: כל אובייקט יכול להשתמש באובייקטים אחרים כערכים.
ב-Firebase Realtime Database, יחסים מתבטאים טוב יותר באמצעות מבני נתונים שטוחים המפצלים את הנתונים לנתיבים נפרדים, כך שניתן להוריד אותם ביעילות בשיחות נפרדות.
להלן דוגמה לאופן שבו תוכל לבנות את הקשר בין פוסטים באפליקציית בלוגים לבין מחבריהם.
לְנַתֵחַ
// 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);
פריסת הנתונים הבאה היא התוצאה.
{
// 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"
}
...
}
}
לפרטים נוספים, עיין במדריך מבנה את מסד הנתונים שלך .קריאת נתונים
ב-Parse אתה קורא נתונים באמצעות המזהה של אובייקט Parse ספציפי, או ביצוע שאילתות באמצעות ParseQuery .
ב-Firebase, אתה מאחזר נתונים על ידי צירוף מאזין אסינכרוני להפניה למסד נתונים. המאזין מופעל פעם אחת עבור המצב ההתחלתי של הנתונים ושוב כאשר הנתונים משתנים, כך שלא תצטרך להוסיף שום קוד כדי לקבוע אם הנתונים השתנו.
להלן דוגמה לאופן שבו אתה יכול לאחזר תוצאות עבור שחקן מסוים, בהתבסס על הדוגמה המוצגת בסעיף "אובייקטים" .
לְנַתֵחַ
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());
}
});
אסטרטגיית הגירה מוצעת
שקול מחדש את הנתונים שלך
מסד הנתונים בזמן אמת של Firebase מותאם לסנכרון נתונים באלפיות שניות בכל הלקוחות המחוברים, ומבנה הנתונים המתקבל שונה מנתוני הליבה של Parse. המשמעות היא שהשלב הראשון של ההגירה שלך הוא לשקול אילו שינויים נדרשים הנתונים שלך, כולל:
- כיצד אובייקטי ה-Perse שלך צריכים למפות לנתוני Firebase
- אם יש לך יחסי הורים וילדים, כיצד לפצל את הנתונים שלך על פני נתיבים שונים כך שניתן יהיה להוריד אותם ביעילות בשיחות נפרדות.
העבר את הנתונים שלך
לאחר שתחליט כיצד לבנות את הנתונים שלך ב-Firebase, עליך לתכנן כיצד לטפל בתקופה שבה האפליקציה שלך צריכה לכתוב לשני מסדי הנתונים. הבחירות שלך הן:
סנכרון ברקע
בתרחיש זה, יש לך שתי גרסאות של האפליקציה: הגרסה הישנה המשתמשת ב-Parse וגרסה חדשה המשתמשת ב-Firebase. סנכרון בין שני מסדי הנתונים מטופל על ידי Parse Cloud Code (Parse to Firebase), כאשר הקוד שלך מאזין לשינויים ב-Firebase ומסנכרן את השינויים הללו עם Parse. לפני שתוכל להתחיל להשתמש בגרסה החדשה, עליך:
- המר את נתוני הניתוח הקיימים שלך למבנה Firebase החדש, וכתוב אותם ל-Firebase Realtime Database.
- כתוב פונקציות Parse Cloud Code המשתמשות ב-Firebase REST API כדי לכתוב ל-Firebase Realtime Database שינויים שבוצעו ב-Perse Data על ידי לקוחות ישנים.
- כתוב ופריסה קוד שמאזין לשינויים ב-Firebase ומסנכרן אותם למסד הנתונים של Parse.
תרחיש זה מבטיח הפרדה נקייה בין קוד ישן לחדש, ושומר על פשטות של הלקוחות. האתגרים של תרחיש זה הם טיפול במערכי נתונים גדולים בייצוא הראשוני, והבטחה שהסנכרון הדו-כיווני לא יוצר רקורסיה אינסופית.
כתיבה כפולה
בתרחיש זה, אתה כותב גרסה חדשה של האפליקציה שמשתמשת גם ב-Firebase וגם ב-Parse, תוך שימוש ב-Parse Cloud Code כדי לסנכרן שינויים שבוצעו על ידי לקוחות ישנים מ-Perse Data ל-Firebase Realtime Database. כאשר מספיק אנשים עברו מגרסת ה- Parse בלבד של האפליקציה, תוכלו להסיר את קוד ה- Parse מגרסת הכתיבה הכפולה.
תרחיש זה אינו דורש שום קוד בצד השרת. החסרונות שלה הם שהנתונים שאין להם גישה לא מועברים, ושגודל האפליקציה שלך גדל על ידי השימוש בשני ערכות ה-SDK.
אימות Firebase
אימות Firebase יכול לאמת משתמשים באמצעות סיסמאות וספקי זהות מאוחדים פופולריים כמו גוגל, פייסבוק וטוויטר. זה גם מספק ספריות ממשק משתמש כדי לחסוך לך את ההשקעה המשמעותית הנדרשת ליישום ולתחזק חווית אימות מלאה עבור האפליקציה שלך בכל הפלטפורמות.
עיין במסמכי האימות של Firebase למידע נוסף.
הבדלים עם ניתוח אישור
Parse מספקת מחלקה מיוחדת של משתמשים בשם ParseUser המטפלת באופן אוטומטי בפונקציונליות הנדרשת לניהול חשבון משתמש. ParseUser הוא תת-מחלקה של ParseObject , כלומר נתוני משתמש זמינים ב-Parse Data וניתן להרחיב אותם עם שדות נוספים כמו כל ParseObject אחר.
ל- FirebaseUser יש קבוצה קבועה של מאפיינים בסיסיים - מזהה ייחודי, כתובת דוא"ל ראשית, שם וכתובת URL של תמונה - המאוחסנת במסד הנתונים של המשתמשים של פרויקט נפרד; מאפיינים אלה יכולים להתעדכן על ידי המשתמש. לא ניתן להוסיף מאפיינים אחרים לאובייקט FirebaseUser ישירות; במקום זאת, תוכל לאחסן את המאפיינים הנוספים במסד הנתונים שלך בזמן אמת של Firebase.
להלן דוגמה לאופן שבו תוכל לרשום משתמש ולהוסיף שדה נוסף של מספר טלפון.
לְנַתֵחַ
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());
}
}
});
אסטרטגיית הגירה מוצעת
העבר חשבונות
כדי להעביר חשבונות משתמש מ-Parse ל-Firebase, ייצא את מסד הנתונים של המשתמשים שלך לקובץ JSON או CSV, ולאחר מכן ייבא את הקובץ לפרויקט Firebase שלך באמצעות הפקודה auth:import של Firebase CLI.
ראשית, ייצא את מסד הנתונים של המשתמש שלך ממסוף Parse או מסד הנתונים המתארח בעצמך. לדוגמה, קובץ JSON שיוצא ממסוף Parse עשוי להיראות כך:
{ // 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",
...
}
לאחר מכן, הפוך את הקובץ המיוצא לפורמט הנדרש על ידי Firebase CLI. השתמש ב- objectId של משתמשי Parse שלך בתור ה- localId של משתמשי Firebase שלך. כמו כן, base64 מקודד את ערכי bcryptPassword מ- Parse והשתמש בהם בשדה passwordHash . לדוגמה:
{
"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
}
]
}
]
}
לבסוף, ייבא את הקובץ שעבר טרנספורמציה עם Firebase CLI, תוך ציון bcrypt בתור אלגוריתם ה-hash:
firebase auth:import account_file.json --hash-algo=BCRYPT
העבר נתוני משתמש
אם אתה מאחסן נתונים נוספים עבור המשתמשים שלך, אתה יכול להעביר אותם אל Firebase Realtime Database באמצעות האסטרטגיות המתוארות בסעיף העברת הנתונים . אם אתה מעביר חשבונות באמצעות הזרימה המתוארת בסעיף העברת חשבונות , לחשבונות Firebase שלך יש את אותם מזהים של חשבונות Parse שלך, מה שמאפשר לך להעביר בקלות ולשחזר כל קשר שנקבע על ידי מזהה המשתמש.
Firebase Cloud Messaging
Firebase Cloud Messaging (FCM) הוא פתרון הודעות חוצה פלטפורמות המאפשר לך להעביר באופן אמין הודעות והתראות ללא עלות. ה-Notifications composer הוא שירות ללא עלות הבנוי על Firebase Cloud Messaging המאפשר הודעות ממוקדות של משתמשים למפתחי אפליקציות לנייד.
עיין במסמכים של Firebase Cloud Messaging למידע נוסף.
הבדלים עם ניתוח הודעות דחיפה
לכל אפליקציית Parse המותקנת במכשיר הרשום להתראות יש אובייקט Installation משויך, שבו אתה מאחסן את כל הנתונים הדרושים למיקוד התראות. Installation היא תת-מחלקה של ParseUser , מה שאומר שאתה יכול להוסיף כל מידע נוסף שתרצה למופעי Installation שלך.
מחבר ההתראות מספק פלחי משתמשים מוגדרים מראש על סמך מידע כמו אפליקציה, גרסת אפליקציה ושפת המכשיר. אתה יכול לבנות פלחי משתמשים מורכבים יותר באמצעות אירועים ונכסים של Google Analytics כדי לבנות קהלים. עיין במדריך העזרה לקהלים כדי ללמוד עוד. מידע מיקוד זה אינו גלוי במסד הנתונים בזמן אמת של Firebase.
אסטרטגיית הגירה מוצעת
העברת אסימוני מכשיר
בזמן כתיבת שורות אלה, ה-Parse Android SDK משתמש בגרסה ישנה יותר של אסימוני הרישום של FCM, שאינם תואמים לתכונות המוצעות על ידי מחבר ההודעות.
אתה יכול לקבל אסימון חדש על ידי הוספת FCM SDK לאפליקציה שלך; עם זאת, הדבר עלול לבטל את תוקף האסימון המשמש את ה- Parse SDK לקבלת הודעות. אם אתה רוצה להימנע מכך, אתה יכול להגדיר את ה- Parse SDK כך שישתמש גם במזהה השולח של Parse וגם במזהה השולח שלך. בדרך זו אינך מבטל את תוקף האסימון המשמש את ה- Parse SDK, אך שים לב שעקיפה זו תפסיק לפעול כאשר Parse יכבה את הפרויקט שלו.
העברת ערוצים לנושאי FCM
אם אתה משתמש בערוצים של ניתוח לשליחת הודעות, תוכל לעבור לנושאים של FCM, המספקים את אותו מודל של בעל מנוי. כדי לטפל במעבר מ-Parse ל-FCM, אתה יכול לכתוב גרסה חדשה של האפליקציה שמשתמשת ב-Parse SDK כדי לבטל את המנוי לערוצים של Parse וב-FCM SDK כדי להירשם לנושאים המתאימים של FCM. בגרסה זו של האפליקציה, עליך להשבית את קבלת ההתראות ב-Parse SDK, ולהסיר את הדברים הבאים מהמניפסט של האפליקציה שלך:
<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" />;
לדוגמה, אם המשתמש שלך רשום לנושא "ענקים", תעשה משהו כמו:
ParsePush.unsubscribeInBackground("Giants", new SaveCallback() {
@Override
public void done(ParseException e) {
if (e == null) {
FirebaseMessaging.getInstance().subscribeToTopic("Giants");
} else {
// Something went wrong unsubscribing
}
}
});
באמצעות אסטרטגיה זו, אתה יכול לשלוח הודעות הן לערוץ ניתוח והן לנושא ה-FCM המתאים, לתמוך במשתמשים בגרסה הישנה והחדשה כאחד. כאשר מספיק משתמשים עברו מגרסת ה-Parse-בלבד של האפליקציה, תוכל לבטל את הגרסה הזו ולהתחיל לשלוח באמצעות FCM בלבד.
עיין במסמכים בנושאי FCM למידע נוסף.
תצורה מרחוק של Firebase
Firebase Remote Config הוא שירות ענן המאפשר לך לשנות את ההתנהגות והמראה של האפליקציה שלך מבלי לדרוש מהמשתמשים להוריד עדכון אפליקציה. בעת שימוש ב-Remote Config, אתה יוצר ערכי ברירת מחדל בתוך האפליקציה השולטים בהתנהגות ובמראה האפליקציה שלך. לאחר מכן, תוכל להשתמש במסוף Firebase מאוחר יותר כדי לעקוף ערכי ברירת מחדל בתוך האפליקציה עבור כל משתמשי האפליקציה או עבור פלחים מבסיס המשתמשים שלך.
Firebase Remote Config יכול להיות שימושי מאוד במהלך ההגירות שלך במקרים שבהם אתה רוצה לבדוק פתרונות שונים ולהיות מסוגל להעביר באופן דינמי יותר לקוחות לספק אחר. לדוגמה, אם יש לך גרסה של האפליקציה שלך שמשתמשת גם ב-Firebase וגם ב-Parse עבור הנתונים, תוכל להשתמש בכלל אחוזון אקראי כדי לקבוע אילו לקוחות קוראים מ-Firebase, ולהגדיל בהדרגה את האחוז.
למידע נוסף על Firebase Remote Config, עיין במבוא של Remote Config .
הבדלים עם ניתוח תצורת
עם Parse config אתה יכול להוסיף צמדי מפתח/ערך לאפליקציה שלך ב-Parse Config Dashboard, ולאחר מכן להביא את ParseConfig בלקוח. כל מופע ParseConfig שאתה מקבל הוא תמיד בלתי ניתן לשינוי. כאשר אתה מאחזר ParseConfig חדש בעתיד מהרשת, הוא לא ישנה אף מופע ParseConfig קיים, אלא יצור מופע חדש ויהפוך אותו לזמין באמצעות getCurrentConfig() .
עם Firebase Remote Config אתה יוצר ברירת מחדל בתוך האפליקציה עבור צמדי מפתח/ערך שאתה יכול לעקוף ממסוף Firebase, ותוכל להשתמש בכללים ובתנאים כדי לספק וריאציות על חוויית המשתמש של האפליקציה שלך לפלחים שונים של בסיס המשתמשים שלך. Firebase Remote Config מיישמת מחלקה יחידה שהופך את צמדי המפתח/ערך לזמינים לאפליקציה שלך. בתחילה הסינגלטון מחזיר את ערכי ברירת המחדל שאתה מגדיר בתוך האפליקציה. אתה יכול להביא סט ערכים חדש מהשרת בכל רגע שנוח לאפליקציה שלך; לאחר הבאת הסט החדש בהצלחה, תוכל לבחור מתי להפעיל אותו כדי להפוך את הערכים החדשים לזמינים לאפליקציה.
אסטרטגיית הגירה מוצעת
אתה יכול לעבור ל-Firebase Remote Config על-ידי העתקת צמדי המפתח/ערך של תצורת ה-Parse שלך למסוף Firebase, ולאחר מכן פריסת גרסה חדשה של האפליקציה המשתמשת ב-Firebase Remote Config.
אם ברצונך להתנסות גם ב-Parse Config וגם ב-Firebase Remote Config, תוכל לפרוס גרסה חדשה של האפליקציה שמשתמשת בשני ה-SDKs עד שדי משתמשים יעברו מהגרסת Parse only.
השוואת קוד
לְנַתֵחַ
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");