Google is committed to advancing racial equity for Black communities. See how.
इस पेज का अनुवाद Cloud Translation API से किया गया है.
Switch to English

अपने Parse Android App को Firebase पर माइग्रेट करें

यदि आप एक पार्स उपयोगकर्ता हैं जो सेवा समाधान के रूप में एक वैकल्पिक बैकएंड की तलाश कर रहे हैं, तो फायरबेस आपके एंड्रॉइड ऐप के लिए आदर्श विकल्प हो सकता है।

यह मार्गदर्शिका बताती है कि अपने ऐप में विशिष्ट सेवाओं को कैसे एकीकृत किया जाए। बेसिक फायरबेस सेटअप निर्देशों के लिए, एंड्रॉइड सेटअप गाइड देखें।

गूगल विश्लेषिकी

Google Analytics एक निशुल्क ऐप माप समाधान है जो ऐप के उपयोग और उपयोगकर्ता के जुड़ाव पर अंतर्दृष्टि प्रदान करता है। Analytics फायरबेस की विशेषताओं को एकीकृत करता है और आपको 500 अलग-अलग घटनाओं के लिए असीमित रिपोर्टिंग प्रदान करता है जिसे आप फायरबेस एसडीके का उपयोग करके परिभाषित कर सकते हैं।

अधिक जानने के लिए Google Analytics डॉक्स देखें।

सुझाए गए प्रवासन की रणनीति

विभिन्न एनालिटिक्स प्रदाताओं का उपयोग करना एक सामान्य परिदृश्य है जो Google Analytics पर आसानी से लागू होता है। केवल उन घटनाओं और उपयोगकर्ता गुणों से लाभ उठाने के लिए इसे अपने ऐप में जोड़ें, जो Analytics स्वचालित रूप से इकट्ठा करता है, जैसे पहला ओपन, ऐप अपडेट, डिवाइस मॉडल, आयु।

कस्टम ईवेंट और उपयोगकर्ता गुणों के लिए, आप पार्स एनालिटिक्स और Google एनालिटिक्स दोनों का उपयोग करके इवेंट और प्रॉपर्टीज़ को लॉग इन करने के लिए एक डबल राइट स्ट्रेटेजी को नियुक्त कर सकते हैं, जो आपको नए समाधान को धीरे-धीरे रोल आउट करने की अनुमति देता है।

कोड तुलना

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

गूगल विश्लेषिकी

 // 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 एक NoSQL क्लाउड-होस्टेड डेटाबेस है। डेटा को JSON के रूप में संग्रहीत किया जाता है और प्रत्येक कनेक्ट किए गए क्लाइंट के लिए वास्तविक समय में सिंक्रनाइज़ किया जाता है।

अधिक जानने के लिए फायरबेस रियलटाइम डेटाबेस डॉक्स देखें।

पार्स डेटा के साथ अंतर

वस्तुओं

ParseObject आप एक ParseObject , या ParseObject एक उपवर्ग जमा करते हैं, जिसमें JSON- संगत डेटा के कुंजी-मूल्य जोड़े होते हैं। डेटा स्कीमालेस है, जिसका अर्थ है कि आपको यह निर्दिष्ट करने की आवश्यकता नहीं है कि प्रत्येक ParseObject पर क्या कुंजी मौजूद है।

सभी Firebase रीयलटाइम डेटाबेस डेटा को JSON ऑब्जेक्ट्स के रूप में संग्रहीत किया जाता है, और ParseObject लिए कोई समकक्ष नहीं है; आप बस JSON प्रकार के मानों को लिखते हैं जो उपलब्ध JSON प्रकारों के अनुरूप हैं। डेटाबेस से पढ़ने और लिखने को सरल बनाने के लिए आप जावा ऑब्जेक्ट का उपयोग कर सकते हैं।

निम्नलिखित एक उदाहरण है कि आप किसी गेम के लिए उच्च स्कोर कैसे बचा सकते हैं।

पार्स
 @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);
 
अधिक जानकारी के लिए, Android मार्गदर्शिका पर डेटा पढ़ें और लिखें

डेटा के बीच संबंध

एक ParseObject दूसरे ParseObject साथ संबंध हो सकता है: कोई भी वस्तु अन्य वस्तुओं को मान के रूप में उपयोग कर सकती है।

फायरबेस रियलटाइम डेटाबेस में, फ्लैट डेटा संरचनाओं का उपयोग करके संबंध बेहतर ढंग से व्यक्त किए जाते हैं जो डेटा को अलग-अलग रास्तों में विभाजित करते हैं, ताकि उन्हें अलग-अलग कॉल में कुशलता से डाउनलोड किया जा सके।

निम्नलिखित एक उदाहरण है कि आप ब्लॉगिंग ऐप और उनके लेखकों में पोस्ट के बीच संबंध कैसे बना सकते हैं।

पार्स
 // 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 में आप किसी विशिष्ट ParseQuery ऑब्जेक्ट की ID का उपयोग करके डेटा पढ़ते हैं, या ParseQuery का उपयोग करके क्वेरी निष्पादित करते हैं।

फायरबेस में, आप एक अतुल्यकालिक श्रोता को डेटाबेस संदर्भ में संलग्न करके डेटा पुनः प्राप्त करते हैं। श्रोता को डेटा की प्रारंभिक स्थिति के लिए एक बार ट्रिगर किया जाता है और फिर से जब डेटा बदलता है, तो आपको यह निर्धारित करने के लिए कोई कोड जोड़ने की आवश्यकता नहीं होगी कि क्या डेटा बदल गया है।

निम्नलिखित एक उदाहरण है कि आप "ऑब्जेक्ट" खंड में प्रस्तुत उदाहरण के आधार पर किसी विशेष खिलाड़ी के लिए स्कोर कैसे प्राप्त कर सकते हैं।

पार्स
 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());
    }
});
 
उपलब्ध श्रोताओं के प्रकारों के बारे में अधिक जानकारी के लिए और डेटा को कैसे ऑर्डर और फ़िल्टर किया जाए, इसके लिए Android गाइड पर डेटा पढ़ें और लिखें

सुझाए गए प्रवासन की रणनीति

अपना डेटा रीथिंक करें

Firebase रीयलटाइम डेटाबेस सभी जुड़े हुए ग्राहकों में मिलीसेकंड में डेटा सिंक करने के लिए अनुकूलित है, और परिणामस्वरूप डेटा संरचना पार्स कोर डेटा से अलग है। इसका मतलब यह है कि आपके प्रवास का पहला चरण यह विचार करना है कि आपके डेटा में क्या बदलाव आवश्यक हैं, जिनमें शामिल हैं:

  • आपके पार्स ऑब्जेक्ट्स को फायरबेस डेटा में मैप कैसे करना चाहिए
  • यदि आपके माता-पिता-बाल संबंध हैं, तो अपने डेटा को अलग-अलग रास्तों में कैसे विभाजित किया जाए ताकि इसे अलग-अलग कॉल में कुशलता से डाउनलोड किया जा सके।

अपना डेटा माइग्रेट करें

फायरबस में अपने डेटा की संरचना कैसे करें, यह तय करने के बाद, आपको यह योजना बनाने की आवश्यकता है कि उस अवधि को कैसे संभालना है जिसके दौरान आपके ऐप को दोनों डेटाबेस में लिखने की आवश्यकता है। आपकी पसंद हैं:

बैकग्राउंड सिंक

इस परिदृश्य में, आपके पास एप्लिकेशन के दो संस्करण हैं: पुराना संस्करण जो पार्स का उपयोग करता है और फायरबेज़ का उपयोग करने वाला एक नया संस्करण। दो डेटाबेस के बीच सिंक को पार्स क्लाउड कोड (पार्स टू फायरबेस) द्वारा नियंत्रित किया जाता है, आपका कोड फायरबेस पर परिवर्तन को सुनता है और पार्स के साथ उन परिवर्तनों को सिंक करता है। इससे पहले कि आप नए संस्करण का उपयोग शुरू कर सकें, आपको निम्न करना चाहिए:

  • अपने मौजूदा पार्स डेटा को नई फायरबेस संरचना में परिवर्तित करें, और इसे फायरबेस रियलटाइम डेटाबेस में लिखें।
  • Parse Cloud Code फ़ंक्शन लिखें जो पुराने क्लाइंट्स द्वारा Parse डेटा में किए गए Firebase रीयलटाइम डेटाबेस परिवर्तनों को लिखने के लिए Firebase REST API का उपयोग करते हैं।
  • कोड लिखें और तैनात करें जो फायरबेस पर परिवर्तन को सुनता है और उन्हें पार्स डेटाबेस पर सिंक करता है।

यह परिदृश्य पुराने और नए कोड का एक अलग पृथक्करण सुनिश्चित करता है और ग्राहकों को सरल बनाए रखता है। इस परिदृश्य की चुनौतियाँ प्रारंभिक निर्यात में बड़े डेटासेट को संभाल रही हैं, और यह सुनिश्चित करती हैं कि द्विदिश समकालिक अनंत पुनरावृत्ति उत्पन्न न करें।

डबल लिखें

इस परिदृश्य में, आप अनुप्रयोग का एक नया संस्करण लिखते हैं जो दोनों फायरबाउंड और पार्स का उपयोग करता है, पार्स क्लाउड कोड का उपयोग करके पार्स डेटा से फायरबेस रियलटाइम डेटाबेस में पुराने ग्राहकों द्वारा किए गए परिवर्तनों को सिंक करने के लिए। जब पर्याप्त लोग ऐप के पार्स-केवल संस्करण से चले गए हैं, तो आप पार्स कोड को डबल राइट संस्करण से हटा सकते हैं।

इस परिदृश्य को किसी भी सर्वर साइड कोड की आवश्यकता नहीं है। इसका नुकसान यह है कि जो डेटा एक्सेस नहीं होता है, वह माइग्रेट नहीं किया जाता है, और यह कि दोनों एसडीके के उपयोग से आपके ऐप का आकार बढ़ जाता है।

फायरबेस प्रमाणीकरण

फायरबेस प्रमाणीकरण गूगल, फेसबुक और ट्विटर जैसे पासवर्ड और लोकप्रिय फ़ेडरेटेड पहचान प्रदाताओं का उपयोग करके उपयोगकर्ताओं को प्रमाणित कर सकता है। यह आपको सभी प्लेटफार्मों में आपके ऐप के लिए पूर्ण प्रमाणीकरण अनुभव को लागू करने और बनाए रखने के लिए आवश्यक महत्वपूर्ण निवेश को बचाने के लिए यूआई लाइब्रेरी प्रदान करता है।

अधिक जानने के लिए Firebase प्रमाणीकरण डॉक्स देखें।

पार्स ऑथ के साथ अंतर

ParseUser नामक एक विशेष उपयोगकर्ता वर्ग प्रदान करता है जो स्वचालित रूप से उपयोगकर्ता खाता प्रबंधन के लिए आवश्यक कार्यक्षमता को संभालता है। ParseUser का एक उपवर्ग है, जिसका अर्थ है कि उपयोगकर्ता डेटा ParseObject डेटा में उपलब्ध है और किसी भी अन्य 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 CLI की ओर से auth:import आदेश का उपयोग करके फ़ाइल को अपने Firebase प्रोजेक्ट में auth:import

सबसे पहले, अपने उपयोगकर्ता डेटाबेस को पार्स कंसोल या अपने स्वयं के होस्ट किए गए डेटाबेस से निर्यात करें। उदाहरण के लिए, पार्स कंसोल से निर्यात की गई JSON फाइल निम्नलिखित की तरह दिख सकती है:

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

फिर, निर्यात की गई फ़ाइल को फायरबेस सीएलआई द्वारा आवश्यक प्रारूप में रूपांतरित करें। अपने पार्स उपयोगकर्ताओं के objectId का उपयोग अपने Firebase उपयोगकर्ताओं के localId के रूप में करें। इसके अलावा, बेस 64 एन्कोड 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 निर्दिष्ट करें:

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

उपयोगकर्ता डेटा माइग्रेट करें

यदि आप अपने उपयोगकर्ताओं के लिए अतिरिक्त डेटा संग्रहीत कर रहे हैं, तो आप इसे डेटा माइग्रेशन अनुभाग में वर्णित रणनीतियों का उपयोग करके फायरबेस रियलटाइम डेटाबेस में स्थानांतरित कर सकते हैं। यदि आप खातों के माइग्रेशन अनुभाग में वर्णित प्रवाह का उपयोग करके खातों को माइग्रेट करते हैं, तो आपके फायरबेस खातों में आपके पार्स खातों के समान आईडी होते हैं, जिससे आप उपयोगकर्ता आईडी द्वारा कुंजीबद्ध किसी भी संबंध को आसानी से माइग्रेट और पुन: उत्पन्न कर सकते हैं।

फायरबेस क्लाउड मेसेजिंग

फायरबेस क्लाउड मैसेजिंग (FCM) एक क्रॉस-प्लेटफ़ॉर्म मैसेजिंग सॉल्यूशन है जो आपको बिना किसी कीमत पर संदेश और सूचनाएं वितरित करने की सुविधा देता है। सूचना संगीतकार फायरबेस क्लाउड मैसेजिंग पर निर्मित एक मुफ्त सेवा है जो मोबाइल ऐप डेवलपर्स के लिए लक्षित उपयोगकर्ता सूचनाओं को सक्षम बनाता है।

अधिक जानने के लिए फायरबेस क्लाउड मैसेजिंग डॉक्स देखें।

पार्स पुश सूचनाओं के साथ अंतर

सूचनाओं के लिए पंजीकृत डिवाइस पर इंस्टॉल किए गए प्रत्येक पार्स एप्लिकेशन में एक संबद्ध Installation ऑब्जेक्ट होता है, जहां आप सूचनाओं को लक्षित करने के लिए आवश्यक सभी डेटा संग्रहीत करते हैं। Installation ParseUser का एक उपवर्ग है, जिसका अर्थ है कि आप अपने Installation इंस्टेंसेस में कोई भी अतिरिक्त डेटा जोड़ सकते हैं।

सूचना संगीतकार ऐप, ऐप संस्करण और डिवाइस भाषा जैसी जानकारी के आधार पर पूर्वनिर्धारित उपयोगकर्ता सेगमेंट प्रदान करता है। आप ऑडियंस बनाने के लिए Google Analytics ईवेंट और गुणों का उपयोग करके अधिक जटिल उपयोगकर्ता सेगमेंट बना सकते हैं। अधिक जानने के लिए ऑडियंस गाइड को देखें। ये लक्ष्यीकरण फायरबेस रियलटाइम डेटाबेस में दिखाई नहीं देते हैं।

सुझाए गए प्रवासन की रणनीति

माइग्रेटिंग डिवाइस टोकन

लेखन के समय, पार्स एंड्रॉइड एसडीके एफसीएम पंजीकरण टोकन के एक पुराने संस्करण का उपयोग करता है, अधिसूचना संगीतकार द्वारा प्रस्तुत सुविधाओं के अनुरूप नहीं है।

आप अपने ऐप में FCM SDK जोड़कर एक नया टोकन प्राप्त कर सकते हैं; हालाँकि, यह सूचना प्राप्त करने के लिए पार्स SDK द्वारा उपयोग किए गए टोकन को अमान्य कर सकता है। यदि आप उससे बचना चाहते हैं, तो आप पार्स की प्रेषक आईडी और अपनी प्रेषक आईडी दोनों का उपयोग करने के लिए पार्स एसडीके सेट कर सकते हैं। इस तरह से आप पार्स एसडीके द्वारा उपयोग किए जाने वाले टोकन को अमान्य नहीं करते हैं, लेकिन इस बात से अवगत रहें कि जब पार्स अपनी परियोजना को बंद कर देगा तो यह काम करना बंद कर देगा।

एफसीएम विषयों के लिए प्रवासन चैनल

यदि आप सूचनाएं भेजने के लिए पार्स चैनलों का उपयोग कर रहे हैं, तो आप FCM विषयों पर माइग्रेट कर सकते हैं, जो एक ही प्रकाशक-सब्सक्राइबर मॉडल प्रदान करते हैं। पार्स से एफसीएम तक के संक्रमण को संभालने के लिए, आप उस एप्लिकेशन का एक नया संस्करण लिख सकते हैं जो पार्स एसडीके का उपयोग करता है और पार्स चैनलों और एफसीएम एसडीके से संबंधित एफसीएम विषयों की सदस्यता के लिए सदस्यता समाप्त कर सकता है। एप्लिकेशन के इस संस्करण में आपको पार्स एसडीके पर सूचनाएं प्राप्त करने को अक्षम करना चाहिए, जो आपके ऐप के प्रदर्शन से निम्नलिखित को हटा देगा:

 <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 विषय डॉक्स देखें।

Firebase Remote Config

फायरबेस रिमोट कॉन्फ़िगरेशन एक क्लाउड सेवा है जो आपको उपयोगकर्ताओं को ऐप अपडेट डाउनलोड करने की आवश्यकता के बिना आपके ऐप के व्यवहार और उपस्थिति को बदलने की सुविधा देती है। रिमोट कॉन्फ़िगरेशन का उपयोग करते समय, आप इन-ऐप डिफ़ॉल्ट मान बनाते हैं जो आपके ऐप के व्यवहार और उपस्थिति को नियंत्रित करते हैं। उसके बाद, आप बाद में सभी ऐप उपयोगकर्ताओं के लिए या आपके उपयोगकर्ताबेस के खंडों में इन-ऐप डिफ़ॉल्ट मूल्यों को ओवरराइड करने के लिए फायरबेस कंसोल का उपयोग कर सकते हैं।

फायरबेस रिमोट कॉन्फिग आपके उन मामलों में माइग्रेशन के दौरान बहुत उपयोगी हो सकता है जहां आप विभिन्न समाधानों का परीक्षण करना चाहते हैं और गतिशील रूप से अधिक ग्राहकों को एक अलग प्रदाता में स्थानांतरित करने में सक्षम हो सकते हैं। उदाहरण के लिए, यदि आपके पास आपके ऐप का एक संस्करण है जो डेटा के लिए फायरबेस और पार्स दोनों का उपयोग करता है, तो आप यह निर्धारित करने के लिए एक यादृच्छिक प्रतिशत नियम का उपयोग कर सकते हैं कि कौन से क्लाइंट फायरबेस से पढ़ते हैं, और धीरे-धीरे प्रतिशत बढ़ाते हैं।

Firebase Remote Config के बारे में अधिक जानने के लिए, दूरस्थ विन्यास परिचय देखें

पार्स विन्यास के साथ अंतर

Parse config के साथ आप ParseConfig config डैशबोर्ड पर अपने ऐप में की / वैल्यू पेयर जोड़ सकते हैं और फिर ParseConfig को क्लाइंट पर ParseConfig । हर ParseConfig उदाहरण जो आपको मिलता है वह हमेशा अपरिवर्तनीय है। जब आप नेटवर्क से भविष्य में एक नया ParseConfig प्राप्त करते हैं, तो यह किसी भी मौजूदा ParseConfig उदाहरण को संशोधित नहीं करेगा, बल्कि इसके बजाय एक नया बना देगा और getCurrentConfig() माध्यम से उपलब्ध getCurrentConfig()

फायरबेस रिमोट कॉन्फिगरेशन के साथ आप उन कुंजी / वैल्यू पेयर के लिए इन-ऐप डिफॉल्ट बनाते हैं जिन्हें आप फायरबेस कंसोल से ओवरराइड कर सकते हैं, और आप अपने ऐप के उपयोगकर्ता अनुभव को अपने यूजरबेस के विभिन्न सेगमेंट में विविधता प्रदान करने के लिए नियमों और शर्तों का उपयोग कर सकते हैं। फायरबेस रिमोट कॉन्फिग एक सिंगलटन क्लास को कार्यान्वित करता है जो आपके ऐप के लिए कुंजी / मान जोड़े उपलब्ध कराता है। प्रारंभ में सिंगलटन उन डिफ़ॉल्ट मानों को लौटाता है जिन्हें आप ऐप में परिभाषित करते हैं। आप अपने ऐप के लिए सुविधाजनक किसी भी समय सर्वर से मूल्यों का एक नया सेट ला सकते हैं; नया सेट सफलतापूर्वक प्राप्त होने के बाद, आप चुन सकते हैं कि नए मूल्यों को ऐप में उपलब्ध कराने के लिए इसे कब सक्रिय करें।

सुझाए गए प्रवासन की रणनीति

आप Firebase कंसोल के लिए अपने Parse config की कुंजी / मान जोड़े की प्रतिलिपि बनाकर Firebase रिमोट कॉन्फिगरेशन पर जा सकते हैं, और फिर फायरबेस Remote config का उपयोग करने वाले ऐप के एक नए संस्करण को तैनात कर सकते हैं।

यदि आप पार्स कॉन्फिगर और फायरबेस रिमोट कॉन्फिगर दोनों के साथ प्रयोग करना चाहते हैं, तो आप ऐप के एक नए संस्करण को तैनात कर सकते हैं जो दोनों एसडीके का उपयोग करता है जब तक कि पर्याप्त उपयोगकर्ता केवल पार्स से माइग्रेट नहीं हुए हैं।

कोड तुलना

पार्स

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