Google is committed to advancing racial equity for Black communities. See how.
דף זה תורגם על ידי Cloud Translation API.
Switch to English

העבר את אפליקציית ה- Android שלך לנתח ל- Firebase

אם אתה משתמש ב- Parse שמחפש Backend חלופי כפתרון שירות, Firebase עשוי להיות הבחירה האידיאלית עבור אפליקציית Android שלך.

מדריך זה מתאר כיצד לשלב שירותים ספציפיים באפליקציה שלך. לקבלת הוראות התקנה בסיסיות של Firebase, עיין במדריך ההתקנה של אנדרואיד .

גוגל ניתוח נתונים

Google Analytics הוא פיתרון מדידת אפליקציות בחינם המספק תובנה לגבי השימוש באפליקציות ומעורבות המשתמשים. Analytics משתלב בין תכונות Firebase ומספק לך דיווח ללא הגבלה עבור עד 500 אירועים ברורים שתוכל להגדיר באמצעות Firebase SDK.

עיין במסמכי Google Analytics למידע נוסף.

אסטרטגיית הגירה מוצעת

השימוש בספקי ניתוח שונים הוא תרחיש נפוץ החל בקלות על גוגל אנליטיקס. פשוט הוסף אותה לאפליקציה שלך כדי ליהנות מאירועים ומאפייני משתמש ש- Analytics אוסף אוטומטית, כמו פתיחה ראשונה, עדכון אפליקציה, דגם מכשיר, גיל.

עבור אירועים מותאמים אישית ונכסי משתמש, אתה יכול להשתמש באסטרטגיית כתיבה כפולה באמצעות Parse 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 Realtime הוא מסד נתונים המתארח בענן של NoSQL. הנתונים נשמרים כ- JSON ומסונכרנים בזמן אמת לכל לקוח מחובר.

עיין במסמכי מסד הנתונים בזמן אמת של Firebase למידע נוסף.

ההבדלים בנתוני ניתוח

חפצים

ב- ParseObject אתה שומר ParseObject , או תת-סוג שלו, המכיל זוגות ערכי מפתח של נתונים תואמי JSON. הנתונים ParseObject , מה שאומר שאינך צריך לציין אילו מפתחות קיימים בכל ParseObject .

כל נתוני מסד הנתונים בזמן אמת של Firebase נשמרים כאובייקטים של 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();
 
בסיס אש
 // 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, יחסים מתבטאים טוב יותר באמצעות מבני נתונים שטוחים המפצלים את הנתונים לנתיבים נפרדים, כך שניתן יהיה להוריד אותם ביעילות בשיחות נפרדות.

להלן דוגמה לאופן בו אתה יכול לבנות את הקשר בין פוסטים באפליקציית בלוגים למחברים שלהם.

לְנַתֵחַ
 // 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();
 
בסיס אש
 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 אתה קורא נתונים באמצעות מזהה של אובייקט ParseQuery ספציפי, או ביצוע שאילתות באמצעות 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());
        }
    }
});
 
בסיס אש
 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. משמעות הדבר היא שהצעד הראשון בהגירה שלך הוא לשקול אילו שינויים הנתונים שלך דורשים, כולל:

  • כיצד על אובייקטי ה- Parse שלך ​​למפות לנתוני Firebase
  • אם יש לך יחסי הורה וילד, כיצד לפצל את הנתונים שלך בין נתיבים שונים כך שניתן יהיה להוריד אותם ביעילות בשיחות נפרדות.

העבר את הנתונים שלך

לאחר שתחליט כיצד לבנות את הנתונים שלך ב- Firebase, עליך לתכנן כיצד לטפל בתקופה בה האפליקציה שלך צריכה לכתוב לשני מסדי הנתונים. הבחירות שלך הן:

סנכרון רקע

בתרחיש זה, יש לך שתי גרסאות של האפליקציה: הגרסה הישנה המשתמשת ב- Parse וגירסה חדשה המשתמשת ב- Firebase. הסנכרון בין שני מסדי הנתונים מנוהל על ידי קוד ענן של Parse (ניתוח ל- Firebase), כאשר הקוד שלך מקשיב לשינויים ב- Firebase וסנכרון השינויים האלה עם Parse. לפני שתוכל להתחיל להשתמש בגירסה החדשה, עליך:

  • המר את נתוני הניתוח הקיימים למבנה Firebase החדש, וכתוב אותם למאגר Firebase Realtime.
  • כתוב פונקציות קוד ענן של קוד המשתמשות בממשק ה- API של Firebase REST כדי לכתוב שינויים במסד הנתונים בזמן אמת של Firebase שבוצעו בנתוני הניתוח על ידי לקוחות ישנים.
  • כתוב ופרוס קוד שמאזין לשינויים ב- Firebase וסנכרן אותם עם מסד הנתונים Parse.

תרחיש זה מבטיח הפרדה נקייה של קוד ישן וחדש, ושומר על לקוחות פשוטים. האתגרים של תרחיש זה הם טיפול במערכי נתונים גדולים בייצוא הראשוני, והבטיחה כי הסנכרון הדו כיווני לא יוצר רקורסיה אינסופית.

כתיבה כפולה

בתרחיש זה אתה כותב גרסה חדשה של האפליקציה המשתמשת הן ב- Firebase והן ב- Parse, תוך שימוש ב- Code Cloud Code כדי לסנכרן שינויים שביצעו לקוחות ישנים מהנתונים לנתח למאגר Firebase Realtime. כאשר מספיק אנשים עברו מגירסת ה- Parse בלבד של האפליקציה, תוכלו להסיר את קוד ה- Parse מגירסת הכתיבה הכפולה.

תרחיש זה אינו מצריך קוד צד לשרת. חסרונותיה הם כי נתונים שלא ניגשים אליהם אינם מועברים, וכי גודל האפליקציה שלך מוגדל על ידי השימוש בשני SDKs.

אימות בסיס אש

אימות של בסיס Firebase יכול לאמת משתמשים באמצעות סיסמאות וספקי זהות פופולריים כמו גוגל, פייסבוק וטוויטר. הוא גם מספק ספריות ממשק משתמש כדי לחסוך לכם את ההשקעה המשמעותית הנדרשת ליישום ולתחזוקה של חווית אימות מלאה עבור האפליקציה שלכם בכל הפלטפורמות.

עיין במסמכי האימות של Firebase למידע נוסף.

הבדלים עם אותות ניתוח

Parse מספקת כיתת משתמשים מיוחדת בשם ParseUser המטפלת אוטומטית בפונקציונליות הנדרשת לניהול חשבון משתמש. ParseUser הוא תת-סוג של ParseObject , כלומר נתוני משתמש זמינים בנתוני ParseObject וניתן להרחיב אותם עם שדות נוספים כמו כל ParseObject אחר.

ל- FirebaseUser יש קבוצה קבועה של מאפיינים בסיסיים - מזהה ייחודי, כתובת דוא"ל ראשית, שם וכתובת אתר לתמונה - המאוחסנים במסד נתונים של משתמש בפרויקט נפרד; ניתן לעדכן את המאפיינים הללו על ידי המשתמש. אינך יכול להוסיף מאפיינים אחרים לאובייקט FirebaseUser ישירות; במקום זאת, אתה יכול לאחסן את המאפיינים הנוספים במסד הנתונים של Firebase Realtime.

להלן דוגמה לאופן ההרשמה למשתמש ולהוסיף שדה מספר טלפון נוסף.

לְנַתֵחַ
 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
        }
    }
});
 
בסיס אש
 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 של המשתמשים שלך ב- localId כ- localId של המשתמשים שלך ב- Firebase. כמו כן, base64 מקודד את ערכי bcryptPassword מ- bcryptPassword ומשתמש בהם בשדה 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 באמצעות האסטרטגיות המתוארות בסעיף העברת הנתונים . אם אתה מעביר חשבונות באמצעות הזרימה המתוארת בסעיף העברת החשבונות , לחשבונות ה- Firebase שלך ​​יש אותם מזהים של חשבונות ה- Parse שלך, ומאפשרים לך להעביר ולהעתיק בקלות את כל היחסים שקשורים למזהה המשתמש.

העברת אש בענן

Firebase Cloud Messaging (FCM) הוא פיתרון העברת הודעות בין פלטפורמות המאפשר לך לספק באופן מהימן הודעות והודעות ללא עלות. מלחין ההודעות הוא שירות חינמי הבנוי ב- Firebase Cloud Messaging המאפשר התראות משתמשים ממוקדות למפתחי אפליקציות סלולריות.

למידע נוסף, עיין במסמכי ההודעות בענן Firebase .

הבדלים עם הודעות על Push ניתוח

לכל יישום Parse המותקן בהתקן הרשום להתראות יש אובייקט Installation משויך, בו אתה מאחסן את כל הנתונים הדרושים למיקוד התראות. Installation היא תת-משנה של ParseUser , כלומר תוכל להוסיף כל מידע נוסף שתרצה ParseUser Installation שלך.

מלחין ההודעות מספק פלחי משתמש מוגדרים מראש על בסיס מידע כמו אפליקציה, גרסת אפליקציה ושפת מכשירים. אתה יכול לבנות פלחי משתמשים מורכבים יותר באמצעות אירועים ונכסים של Google Analytics לבניית קהלים. עיין במדריך העזרה לקהלים למידע נוסף. ידיעות מיקוד אלה אינן גלויות במסד הנתונים של Firebase Realtime.

אסטרטגיית הגירה מוצעת

סמלי מכשיר נודדים

בזמן הכתיבה ה- Parse Android SDK משתמש בגרסה ישנה יותר של אסימוני הרישום FCM, שאינם תואמים לתכונות שמציע מלחין ההודעות.

אתה יכול לקבל אסימון חדש על ידי הוספת FCM SDK ליישום שלך; עם זאת, הדבר עשוי לפסול את האסימון המשמש את ה- SDK לניתוח לקבלת התראות. אם ברצונך להימנע מכך, באפשרותך להגדיר את ה- Parse SDK שישתמש גם במזהה השולח של Parse וגם במזהה השולח שלך. בדרך זו אינך מבטל את האסימון המשמש את ה- Parse SDK, אך היה מודע לכך שעקיפה זו תפסיק לפעול כאשר Parse יכבה את הפרויקט.

העברת ערוצים לנושאים של FCM

אם אתה משתמש בערוצי Parse בכדי לשלוח התראות, אתה יכול לעבור לנושאים של 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
        }
    }
});
 

באמצעות אסטרטגיה זו תוכלו לשלוח הודעות לערוץ Parse והן לנושא FCM המתאים, ולתמוך במשתמשים בגרסאות ישנות וחדשות כאחד. כאשר מספיק משתמשים עברו מגירסת ה- Parse בלבד של האפליקציה, תוכלו להשקיע גרסה זו ולהתחיל לשלוח באמצעות FCM בלבד.

עיין במסמכי הנושאים של FCM למידע נוסף.

תצורת מרחוק Firebase

Firebase Remote Config הוא שירות ענן המאפשר לשנות את התנהגות ומראה האפליקציה שלך מבלי לדרוש מהמשתמשים להוריד עדכון אפליקציה. בעת השימוש בתצורה מרחוק, אתה יוצר ערכי ברירת מחדל בתוך האפליקציה השולטים בהתנהגות והמראה של האפליקציה שלך. לאחר מכן תוכל להשתמש מאוחר יותר במסוף Firebase כדי לבטל את ערכי ברירת המחדל בתוך האפליקציה עבור כל משתמשי האפליקציות או עבור חלקים מבסיס המשתמש שלך.

Firebase Remote Config יכול להיות שימושי מאוד במהלך ההעברות במקרים בהם ברצונך לבדוק פתרונות שונים ולהיות מסוגל להעביר באופן דינמי יותר לקוחות לספק אחר. לדוגמה, אם יש לך גרסה של האפליקציה שלך המשתמשת הן ב- Firebase והן ב- Parse עבור הנתונים, אתה יכול להשתמש בכלל אחוזון אקראי כדי לקבוע אילו לקוחות קוראים מ- Firebase, ולהגדיל בהדרגה את האחוז.

למידע נוסף על קביעת תצורה מרחוק של Firebase, עיין במבוא לתצורת מרחוק .

הבדלים עם תצורת ניתוח

באמצעות Parse config אתה יכול להוסיף צמדי מפתח / ערך לאפליקציה שלך בלוח המחוונים של ParseConfig Config, ואז להביא את ParseConfig בלקוח. כל מופע ParseConfig שתקבל הוא תמיד בלתי ניתנת לשינוי. כאשר אתה מאחזר בעתיד רשת ParseConfig מהרשת, הוא לא ישנה אף מופע ParseConfig קיים, אלא במקום זאת ייצור חדש ויהפוך אותו לזמין דרך getCurrentConfig() .

באמצעות קביעת תצורה מרחוק של Firebase אתה יוצר ברירות מחדל בתוך האפליקציה לזוגות מפתח / ערך שאתה יכול לעקוף ממסוף Firebase, ותוכל להשתמש בכללים ותנאים כדי לספק וריאציות בחוויית המשתמש של האפליקציה שלך לקטעים שונים בבסיס המשתמש שלך. Firebase Remote Config מיישם חוג סינגלטון שהופך את זוגות המפתחות / הערכים לזמינים לאפליקציה שלך. בתחילה הסינגלטון מחזיר את ערכי ברירת המחדל שאתה מגדיר בתוך האפליקציה. אתה יכול להביא מערך ערכים חדש מהשרת בכל רגע שנוח לאפליקציה שלך; לאחר שהמערכה החדשה תושג בהצלחה, תוכלו לבחור מתי להפעיל אותה כדי להפוך את הערכים החדשים לזמינים לאפליקציה.

אסטרטגיית הגירה מוצעת

אתה יכול לעבור ל- Firebase Remote Config על ידי העתקת זוגות המפתח / ערכים של תצורת ה- Parse שלך ​​למסוף Firebase ואז פריסת גרסה חדשה של האפליקציה המשתמשת ב- Firebase Remote Config.

אם ברצונך להתנסות הן ב- Parse Config והן ב- Firebase Remote Config, באפשרותך לפרוס גרסה חדשה של האפליקציה המשתמשת בשני SDKs עד שדי משתמשים יגרו מגרסת ה- 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!");
    }
});
 

בסיס אש

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