इस पेज का अनुवाद Cloud Translation API से किया गया है.

पार्स किए गए Android ऐप्लिकेशन को Firebase पर माइग्रेट करना

अगर आप एक पार्स उपयोगकर्ता हैं और सेवा समाधान, आपके Android ऐप्लिकेशन के लिए Firebase सबसे अच्छा विकल्प हो सकता है.

इस गाइड में आपके ऐप्लिकेशन के साथ खास सेवाओं को जोड़ने का तरीका बताया गया है. इसके लिए Firebase सेटअप के बुनियादी निर्देश, Android सेटअप पढ़ें.

Google Analytics

Google Analytics एक मुफ़्त ऐप्लिकेशन है, जो ऐप्लिकेशन के इस्तेमाल और उपयोगकर्ता का जुड़ाव. Analytics, Firebase की सभी सुविधाओं को इंटिग्रेट करता है और आपको अनलिमिटेड स्टोरेज की सुविधा देता है 500 अलग-अलग इवेंट के लिए रिपोर्टिंग की सुविधा देता है, जिन��हें Firebase SDK टूल का इस्तेमाल करके तय किया जा सकता है.

ज़्यादा जानने के लिए, Google Analytics दस्तावेज़ देखें.

माइग्रेशन के लिए सुझाई गई रणनीति

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

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

कोड की तुलना

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

ज़्यादा जानने के लिए, Firebase Realtime Database दस्तावेज़ देखें.

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

ऑब्जेक्ट

पार्स में आप एक ParseObject या उसकी सब-क्लास को स्टोर करते हैं, जिसमें की-वैल्यू पेयर होते हैं के हिसाब से फ़िल्टर किया गया है. यह डेटा स्कीमालेस होता है. इसका मतलब है कि आपको किन कुंजियों को तय करने की ज़रूरत नहीं होती है हर ParseObject पर मौजूद है.

Firebase Realtime Database का पूरा डेटा, JSON ऑब्जेक्ट के तौर पर सेव किया जाता है. इसके बराबर नहीं है ParseObject; 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);

ज़्यादा जानकारी के लिए, Android पर डेटा पढ़ें और उसमें बदलाव करें गाइड.

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

एक 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"
    }
    ...
  }
}

ज़्यादा जानकारी के लिए, अपने डेटाबेस का स्ट्रक्चर तैयार करें पढ़ें.

पढ़ने से जुड़ा डेटा

पार्स में आप किसी खास पार्स ऑब्जेक्ट के आईडी का इस्तेमाल करके डेटा पढ़ते हैं या 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());
    }
});

इवेंट लिसनर के उपलब्ध टाइप के बारे में ज़्यादा जानने के लिए और डेटा को ऑर्डर और फ़िल्टर करने के बारे में ज़्यादा जानने के लिए, Android पर डेटा पढ़ें और लिखें पढ़ें.

माइग्रेशन के लिए सुझाई गई रणनीति

अपने डेटा के बारे में फिर से सोचें

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

आपके पार्स ऑब्जेक्ट, Firebase डेटा पर किस तरह मैप होने चाहिए
अगर आपके माता-पिता और बच्चे के बीच का संबंध है, तो अपने डेटा को अलग-अलग पाथ में कैसे बांटें इसे अलग-अलग कॉल में बेहतर तरीके से डाउनलोड किया जा सकता है.

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

Firebase में अपने डेटा को व्यवस्थित करने के बाद, आपको यह तय करना होगा कि जिस दौरान आपके ऐप्लिकेशन को दोनों डेटाबेस में डेटा कॉपी करना पड़ता है. आपके पास ये विकल्प हैं:

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

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

अपने मौजूदा पार्स डेटा को नई Firebase संरचना में बदलें और उसे Firebase Realtime Database.
ऐसे पार्स क्लाउड कोड फ़ंक्शन लिखें जो पुराने क्लाइंट के पार्स डेटा में Firebase Realtime Database बदलाव किए गए.
ऐसा कोड लिखें और डिप्लॉय करें जो Firebase पर बदलावों को सुन सके और उन्हें पार्स में सिंक कर सके डेटाबेस.

इस स्थिति में, पुराने और नए कोड को साफ़ तौर पर अलग-अलग किया जा सकता है और क्लाइंट के काम को आसान बनाया जा सकता है. कॉन्टेंट बनाने इस स्थिति में सबसे बड़ी चुनौती, शुरुआती एक्सपोर्ट में बड़े डेटासेट को हैंडल करना है. साथ ही, यह पक्का करना भी है कि दो-तरफ़ा सिंक से बार-बार एक जैसी जानकारी जनरेट नहीं होती.

डबल राइट

इस स्थिति में, आपको ऐप्लिकेशन का एक नया वर्शन लिखना होगा. यह वर्शन, Firebase और पार्स, दोनों का इस्तेमाल करता होगा. पार्स डेटा से पुराने क्लाइंट के किए गए बदलावों को Firebase Realtime Database. जब ऐप्लिकेशन के केवल-पार्स वर्शन से काफ़ी लोग माइग्रेट कर लिए जाएंगे, तब आपने डबल राइट वर्शन से पार्स कोड को हटा सकते हैं.

इस स्थिति के लिए किसी सर्वर साइड कोड की ज़रूरत नहीं है. इसके नुकसान यह हैं कि को माइग्रेट नहीं किया गया है और यह कि दोनों SDK टूल के इस्तेमाल से आपके ऐप्लिकेशन का साइज़ बढ़ जाता है.

Firebase Authentication

Firebase Authentication, पासवर्ड और लोकप्रिय फ़��डरेटे�� ड�� ्र��वाइडर का इस्तेमाल करके, उपयोगकर्ताओं की पुष्टि कर सकता है जैसे कि Google, Facebook, और Twitter. यह आपको यूज़र इंटरफ़ेस (यूआई) लाइब्रेरी की सुविधा भी देता है, ताकि सभी प्लैटफ़ॉर्म पर अपने ऐप्लिकेशन के लिए, पुष्टि करने का पूरा अनुभव लागू करने और उसे बनाए रखने में ज़्यादा निवेश करना होगा सभी प्लैटफ़ॉर्म पर.

ज़्यादा जानने के लिए, Firebase Authentication दस्तावेज़ देखें.

पार्स करने की पुष्टि में अंतर

Parse, ParseUser नाम की एक खास उपयोगकर्ता क्लास उपलब्ध कराता है. यह उपयोगकर्ता की कैटगरी अपने-आप मैनेज करता है उपयोगकर्ता खाते के मैनेजमेंट के लिए ज़रूरी सुविधा. ParseUser, ParseObject का मतलब है कि उपयोगकर्ता का डेटा, पार्स डेटा में उपलब्ध है और इसे किसी भी अन्य ParseObject की तरह, अतिरिक्त फ़ील्ड.

FirebaseUser में बेसिक प्रॉपर्टी का एक तय सेट होता है—यूनीक आईडी, मुख्य ईमेल पता, कोई नाम और फ़ोटो का यूआरएल—जो किसी अलग प्रोजेक्ट के उपयोगकर्ता डेटाबेस में स्टोर किया गया हो; प्रॉपर्टी को अपडेट किया जा सकता है. उपयोगकर्ता है. FirebaseUser ऑब्जेक्ट में, सीधे तौर पर अन्य प्रॉपर्टी नहीं जोड़ी जा सकतीं; इसके बजाय, आप अतिरिक्त प्रॉपर्टी को अपने Firebase Realtime Database में सेव कर सकते हैं.

नीचे दिए गए उदाहरण में बताया गया है कि उपयोगकर्ता के खाते के लिए साइन अप कैसे किया जा सकता है और फ़ोन नंबर के लिए अलग से फ़ील्ड कैसे जोड़ा जा सकता है.

पार्स करें

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

माइग्रेशन के लिए सुझाई गई रणनीति

खाते माइग्रेट करें

उपयोगकर्ता खातों को पार्स से Firebase में माइग्रेट करने के लिए, अपने उपयोगकर्ता डेटाबेस को इसमें ��क्सपोर्ट करें: JSON या CSV फ़ाइल डाउनलोड करनी होगी, तो 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",
  ...
}

फिर, एक्सपोर्ट की गई फ़ाइल को Firebase के लिए ज़रूरी फ़ॉर्मैट में बदलें सीएलआई. पार्स करने वाले अपने उपयोगकर्ताओं के objectId का इस्तेमाल इस तौर पर करें: आपके Firebase उपयोगकर्ता में से localId. साथ ही, base64 कोड में पार्स से 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
        }
      ]
    }
  ]
}

आखिर में, bcrypt की जानकारी देते हुए, बदली गई फ़ाइल को Firebase सीएलआई के साथ इंपोर्ट करें इसे हैश एल्गोरिदम के तौर पर सेट करें:

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

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

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

Firebase Cloud Messaging

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

ज़्यादा जानने के लिए, Firebase Cloud Messaging दस्तावेज़ देखें.

पार्स पुश नोटिफ़िकेशन की सुविधा में अंतर

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

नोटिफ़िकेशन कंपोज़र ऐप्लिकेशन, ऐप्लिकेशन के वर्शन, और डिवाइस जैसी जानकारी के आधार पर पहले से तय उपयोगकर्ता सेगमेंट उपलब्ध कराता है भाषा. Google Analytics इवेंट और प्रॉपर्टी का इस्तेमाल करके, उपयोगकर्ताओं के ज़्यादा कॉम्प्लेक्स बनाए जा सकते हैं का इस्तेमाल करें. ऑडियंस देखें ज़्यादा जानने के लिए हमारी सहायता गाइड देखें. टारगेटिंग (विज्ञापन के लिए सही दर्शक चुनना) की ये जानकारी Firebase Realtime Database में नहीं दिखती है.

माइग्रेशन के लिए सुझाई गई रणनीति

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

लिखते समय, Android SDK को पार्स करें और FCM के पुराने वर्शन का इस्तेमाल किया जाता है रजिस्ट्रेशन टोकन, जो नोटिफ़िकेशन कंपोज़र की ऑफ़र की गई सुविधाओं के साथ काम नहीं करते.

आप अपने ऐप्लिकेशन में FCM SDK टूल जोड़कर, नया टोकन पा सकते हैं; हालांकि, इससे सूचनाएं पाने के लिए पार्स SDK टूल के इस्तेमाल किया गया टोकन अमान्य हो सकता है. अगर आपको इससे बचना है, तो पार्स SDK टूल को सेट अप करें. ऐसा करने पर, पार्स करने के दौरान भेजने वाले के दोनों आईडी का इस्तेमाल किया जा सकेगा भेजने वाले का आईडी डालें. इस तरीके से, पार्स SDK टूल के इस्तेमाल किए गए टोकन को अमान्य नहीं किया जाता. लेकिन ध्यान रखें कि जब Parse अपने प्रोजेक्ट को शट डाउन कर देगा तब यह वर्कअराउंड काम करना बंद कर देगा.

चैनलों को FCM विषयों पर माइग्रेट करना

अगर सूचनाएं भेजने के लिए पार्स चैनलों का इस्तेमाल किया जा रहा है, तो FCM विषयों पर माइग्रेट किया जा सकता है. सदस्यता लेने वाले पब्लिशर के मॉडल को अलग-अलग कर सकते हैं. पार्स से FCM में ट्रांज़िशन मैनेज करने के लिए, आपके पास नया वर्शन लिखने का विकल्प है यह ऐसे ऐप्लिकेशन का है जो पार्स चैनलों की सदस्यता छोड़ने के लिए पार्स SDK टूल का इस्तेमाल करता है. साथ ही, सदस्यता लेने के लिए FCM SDK टूल का इस्तेमाल करता है संबंधित FCM विषय. ऐप्लिकेशन के इस वर्शन में, आपको इन पर सूचनाएं पाने की सुविधा बंद करनी चाहिए पार्स 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 विषय, पुराने और नए, दोनों वर्शन के उपयोगकर्ताओं की मदद करता है. जब काफ़ी उपयोगकर्ता ऐप्लिकेशन के सिर्फ़ पार्स वर्शन को हटाने पर, उस वर्शन को बंद किया जा सकता है और सिर्फ़ FCM का इस्तेमाल करके मै��ेज भेजना ��ु��ू किया जा सकता है.

ज़्यादा जानकारी के लिए, FCM विषयों के दस्तावेज़ ज़्यादा जानने के लिए.

Firebase Remote Config

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

माइग्रेशन के दौरान, Firebase Remote Config उन मामलों में बहुत काम का हो सकता है जहां आपको इसकी जांच करनी हो अलग-अलग समाधान तैयार कर सकते हैं और डायनैमिक तौर पर ज़्यादा क्लाइंट को किसी दूसरी कंपनी पर शिफ़्ट कर सकते हैं. उदाहरण के लिए, अगर आपके ऐप्लिकेशन का कोई ऐसा वर्शन है जो डेटा के लिए Firebase और पार्स, दोनों का इस्तेमाल करता है, तो आप रैंडम पर्सेंटाइल नियम का इस्तेमाल कर सकते हैं. इससे यह तय किया जा सकता है कि Firebase से कौनसे क्लाइंट डेटा पढ़ते हैं और फिर प्रतिशत को धीरे-धीरे बढ़ाएं.

Firebase Remote Config के बारे में ज़्यादा जानने के लिए, यहां जाएं: Remote Config के बारे में जानकारी.

पार्स कॉन्फ़िगरेशन में अंतर

पार्स कॉन्फ़िगरेशन की मदद से, पार्स कॉन्फ़िगरेशन डैशबोर्ड पर अपने ऐप्लिकेशन में कुंजी/वैल्यू पेयर को जोड़ा जा सकता है. क्लाइंट पर ParseConfig फ़ेच करें. हर ParseConfig बार, जब आपने get हमेशा अपरिवर्तनीय होता है. जब आप आने वाले समय मेंParseConfig नेटवर्क, वह किसी मौजूदा ParseConfig इंस्टेंस में बदलाव न��ीं करेगा. इसके बजाय, वह ऐसा करेगा नया वीडियो बनाएं और उसे getCurrentConfig() के ज़रिए उपलब्ध कराएं.

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

माइग्रेशन के लिए सुझाई गई रणनीति

आपके पार्स कॉन्फ़िगरेशन के कुंजी/वैल्यू पेयर को कॉपी करके, Firebase Remote Config पर जाया जा सकता है Firebase कंसोल से कनेक्ट करें. इसके बाद, ऐप्लिकेशन का ऐसा नया वर्शन डिप्लॉय करें जो Firebase Remote Config का इस्तेमाल करता हो.

अगर आपको पार्स कॉन्फ़िगरेशन और Firebase Remote Config, दोनों के साथ एक्सपेरिमेंट करना है, तो ऐप्लिकेशन का नया वर्शन जो दोनों SDK टूल का इस्तेमाल तब तक करता हो, जब तक कि ज़रूरत के मुताबिक उपयोगकर्ता सिर्फ़ पार्स वर्शन से माइग्रेट नहीं हो जाते.

कोड की तुलना

पार्स करें

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