डेटा सेव करें

शुरू करने से पहले

Realtime Database का इस्तेमाल करने से पहले, आपको ये काम करने होंगे:

  • अपना Unity प्रोजेक्ट रजिस्टर करें और उसे Firebase का इस्तेमाल करने के लिए कॉन्फ़िगर करें.

    • अगर आपका Unity प्रोजेक्ट पहले से ही Firebase का इस्तेमाल करता है, तो इसका मतलब है कि वह पहले से ही Firebase के लिए रजिस्टर और कॉन्फ़िगर किया गया है.

    • अगर आपके पास कोई Unity प्रोजेक्ट नहीं है, तो सैंपल ऐप्लिकेशन डाउनलोड किया जा सकता है.

  • अपने Unity प्रोजेक्ट में Firebase Unity SDK टूल (खास तौर पर, FirebaseDatabase.unitypackage) जोड़ें.

ध्यान दें कि अपने Unity प्रोजेक्ट में Firebase जोड़ने के लिए, Firebase कंसोल और अपने खुले हुए Unity प्रोजेक्ट, दोनों में टास्क पूरे करने होते हैं. उदाहरण के लिए, कंसोल से Firebase कॉन्फ़िगरेशन फ़ाइलें डाउनलोड करके, उन्हें अपने Unity प्रोजेक्ट में ले जाना.

डेटा सेव करना

Firebase Realtime Database में डेटा लिखने के पांच तरीके हैं:

तरीका सामान्य तौर पर क्वेरी की सूची का इस्तेमाल इस तरह किया जाता है
SetValueAsync() किसी तय पाथ, जैसे कि users/<user-id>/<username> में डेटा लिखें या बदलें.
SetRawJsonValueAsync() डेटा को रॉ Json के साथ लिखें या बदलें, जैसे कि users/<user-id>/<username>.
Push() डेटा की सूची में जोड़ें. हर बार Push() को कॉल करने पर, Firebase एक यूनीक पासकोड जनरेट करता है. इसका इस्तेमाल, user-scores/<user-id>/<unique-score-id> जैसे यूनीक आइडेंटिफ़ायर के तौर पर भी किया जा सकता है.
UpdateChildrenAsync() तय किए गए पाथ के लिए कुछ कुंजियों को अपडेट करें. ऐसा करने पर, पूरे डेटा को बदलने की ज़रूरत नहीं होती.
RunTransaction() जटिल डेटा को अपडेट करना, जो एक साथ होने वाले अपडेट की वजह से खराब हो सकता है.

DatabaseReference पाना

डेटाबेस में डेटा लिखने के लिए, आपके पास DatabaseReference का कोई इंस्टेंस होना चाहिए:

using Firebase;
using Firebase.Database;

public class MyScript: MonoBehaviour {
  void Start() {
    // Get the root reference location of the database.
    DatabaseReference reference = FirebaseDatabase.DefaultInstance.RootReference;
  }
}

किसी रेफ़रंस में डेटा लिखना, अपडेट करना या मिटाना

डेटा लिखने से जुड़ी बुनियादी कार्रवाइयां

डेटा को किसी तय रेफ़रंस में सेव करने के लिए, SetValueAsync() का इस्तेमाल किया जा सकता है. इससे उस पाथ में मौजूद किसी भी मौजूदा डेटा को बदल दिया जाता है. इस तरीके का इस्तेमाल करके, उपलब्ध JSON टाइप के हिसाब से टाइप पास किए जा सकते हैं. इसके लिए, यह तरीका अपनाएं:

  • string
  • long
  • double
  • bool
  • Dictionary<string, Object>
  • List<Object>

टाइप किए गए C# ऑब्जेक्ट का इस्तेमाल करने पर, ऑब्जेक्ट को रॉ JSON में बदलने और SetRawJsonValueAsync() को कॉल करने के लिए, पहले से मौजूद JsonUtility.ToJson() का इस्तेमाल किया जा सकता है. उदाहरण के लिए, आपके पास User क्लास इस तरह दिख सकती है:

public class User {
    public string username;
    public string email;

    public User() {
    }

    public User(string username, string email) {
        this.username = username;
        this.email = email;
    }
}

SetRawJsonValueAsync() की मदद से उपयोगकर्ता को जोड़ने के लिए, यह तरीका अपनाएं:

private void writeNewUser(string userId, string name, string email) {
    User user = new User(name, email);
    string json = JsonUtility.ToJson(user);

    mDatabaseRef.Child("users").Child(userId).SetRawJsonValueAsync(json);
}

इस तरह से SetValueAsync() या SetRawJsonValueAsync() का इस्तेमाल करने पर, तय की गई जगह पर मौजूद डेटा को बदल दिया जाता है. इसमें चाइल्ड नोड भी शामिल हैं. हालांकि, अब भी पूरे ऑब्जेक्ट को फिर से लिखे बिना, चाइल्ड को अपडेट किया जा सकता है. अगर आपको उपयोगकर्ताओं को अपनी प्रोफ़ाइल अपडेट करने की अनुमति देनी है, तो उपयोगकर्ता नाम को इस तरह अपडेट किया जा सकता है:

mDatabaseRef.Child("users").Child(userId).Child("username").SetValueAsync(name);

डेटा की सूची में जोड़ना

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

Push() तरीके से मिले नए डेटा के रेफ़रंस का इस्तेमाल करके, चाइल्ड की अपने-आप जनरेट हुई कुंजी की वैल्यू पाई जा सकती है या चाइल्ड के लिए डेटा सेट किया जा सकता है. Push() रेफ़रंस पर Key को कॉल करने से, अपने-आप जनरेट हुई कुंजी की वैल्यू दिखती है.

चुनिंदा फ़ील्ड अपडेट करना

किसी नोड के दूसरे चाइल्ड नोड को ओवरराइट किए बिना, एक साथ कई चाइल्ड नोड में लिखने के लिए, UpdateChildrenAsync() तरीके का इस्तेमाल करें.

UpdateChildrenAsync() को कॉल करते समय, कुंजी के लिए पाथ तय करके, कम लेवल की चाइल्ड वैल्यू अपडेट की जा सकती हैं. अगर डेटा को बेहतर तरीके से स्केल करने के लिए, एक से ज़्यादा जगहों पर सेव किया गया है, तो डेटा फ़ैन-आउट का इस्तेमाल करके, उस डेटा के सभी इंस्टेंस अपडेट किए जा सकते हैं. उदाहरण के लिए, किसी गेम में LeaderboardEntry क्लास इस तरह की हो सकती है:

public class LeaderboardEntry {
    public string uid;
    public int score = 0;

    public LeaderboardEntry() {
    }

    public LeaderboardEntry(string uid, int score) {
        this.uid = uid;
        this.score = score;
    }

    public Dictionary&ltstring, Object&gt ToDictionary() {
        Dictionary&ltstring, Object&gt result = new Dictionary&ltstring, Object&gt();
        result["uid"] = uid;
        result["score"] = score;

        return result;
    }
}

LeaderboardEntry बनाने और उसे हाल ही के स्कोर फ़ीड और उपयोगकर्ता की स्कोर सूची में एक साथ अपडेट करने के लिए, गेम इस तरह के कोड का इस्तेमाल करता है:

private void WriteNewScore(string userId, int score) {
    // Create new entry at /user-scores/$userid/$scoreid and at
    // /leaderboard/$scoreid simultaneously
    string key = mDatabase.Child("scores").Push().Key;
    LeaderBoardEntry entry = new LeaderBoardEntry(userId, score);
    Dictionary&ltstring, Object&gt entryValues = entry.ToDictionary();

    Dictionary&ltstring, Object&gt childUpdates = new Dictionary&ltstring, Object&gt();
    childUpdates["/scores/" + key] = entryValues;
    childUpdates["/user-scores/" + userId + "/" + key] = entryValues;

    mDatabase.UpdateChildrenAsync(childUpdates);
}

इस उदाहरण में, Push() का इस्तेमाल करके /scores/$key पर सभी उपयोगकर्ताओं की एंट्री वाले नोड में एंट्री बनाई गई है. साथ ही, Key की मदद से एक साथ कई कुंजियां भी वापस लाई गई हैं. इसके बाद, इस कुंजी का इस्तेमाल करके /user-scores/$userid/$key पर उपयोगकर्ता के स्कोर में दूसरी एंट्री बनाई जा सकती है.

इन पाथ का इस्तेमाल करके, UpdateChildrenAsync() को एक बार कॉल करके, JSON ट्री में एक साथ कई जगहों को अपडेट किया जा सकता है. उदाहरण के लिए, यह उदाहरण दोनों जगहों पर नई एंट्री कैसे बनाता है. एक साथ किए गए अपडेट, इस तरह से ऐटॉमिक होते हैं: या तो सभी अपडेट पूरे हो जाते हैं या सभी अपडेट पूरे नहीं हो पाते.

डेटा मिटाना

डेटा मिटाने का सबसे आसान तरीका यह है कि डेटा की जगह के रेफ़रंस पर RemoveValue() को कॉल करें.

SetValueAsync() या UpdateChildrenAsync() जैसे किसी अन्य लिखने वाले ऑपरेशन के लिए वैल्यू के तौर पर null तय करके भी मिटाया जा सकता है. एक ही एपीआई कॉल में कई बच्चों की जानकारी मिटाने के लिए, UpdateChildrenAsync() के साथ इस तकनीक का इस्तेमाल किया जा सकता है.

जानें कि आपका डेटा कब कमिट किया गया.

यह जानने के लिए कि आपका डेटा Firebase Realtime Database सर्वर पर कब कमिट किया गया है, आपके पास जारी रखने का विकल्प है. SetValueAsync() और UpdateChildrenAsync(), दोनों एक Task दिखाते हैं. इससे आपको यह पता चलता है कि कार्रवाई पूरी हो गई है या नहीं. अगर किसी वजह से कॉल पूरा नहीं हो पाता है, तो Tasks IsFaulted की वैल्यू 'सही' होगी. साथ ही, Exception प्रॉपर्टी से यह पता चलेगा कि कॉल पूरा न होने की वजह क्या है.

डेटा को लेन-देन के तौर पर सेव करना

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

उदाहरण के लिए, किसी गेम में उपयोगकर्ताओं को सबसे ज़्यादा पांच स्कोर के साथ लीडरबोर्ड अपडेट करने की अनुमति दी जा सकती है:

private void AddScoreToLeaders(string email, 
                               long score,
                               DatabaseReference leaderBoardRef) {

    leaderBoardRef.RunTransaction(mutableData =&gt {
      List&ltobject&gt leaders = mutableData.Value as List&ltobject>

      if (leaders == null) {
        leaders = new List&ltobject&gt();
      } else if (mutableData.ChildrenCount &gt= MaxScores) {
        long minScore = long.MaxValue;
        object minVal = null;
        foreach (var child in leaders) {
          if (!(child is Dictionary&ltstring, object&gt)) continue;
          long childScore = (long)
                      ((Dictionary&ltstring, object&gt)child)["score"];
          if (childScore &lt minScore) {
            minScore = childScore;
            minVal = child;
          }
        }
        if (minScore &gt score) {
          // The new score is lower than the existing 5 scores, abort.
          return TransactionResult.Abort();
        }

        // Remove the lowest score.
        leaders.Remove(minVal);
      }

      // Add the new high score.
      Dictionary&ltstring, object&gt newScoreMap =
                       new Dictionary&ltstring, object&gt();
      newScoreMap["score"] = score;
      newScoreMap["email"] = email;
      leaders.Add(newScoreMap);
      mutableData.Value = leaders;
      return TransactionResult.Success(mutableData);
    });
}

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

ऑफ़लाइन डेटा सेव करना

अगर किसी क्लाइंट का नेटवर्क कनेक्शन बंद हो जाता है, तो भी आपका ऐप्लिकेशन ठीक से काम करता रहेगा.

Firebase डेटाबेस से कनेक्ट किया गया हर क्लाइंट, किसी भी ऐक्टिव डेटा का अपना इंटरनल वर्शन मैनेज करता है. डेटा लिखने पर, वह सबसे पहले इस लोकल वर्शन में लिखा जाता है. इसके बाद, Firebase क्लाइंट उस डेटा को रिमोट डेटाबेस के सर्वर और अन्य क्लाइंट के साथ "बेहतरीन तरीके" से सिंक करता है.

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

कनेक्शन फिर से चालू होने के बाद, आपके ऐप्लिकेशन को इवेंट का सही सेट मिलता है, ताकि क्लाइंट किसी कस्टम कोड को लिखे बिना, सर्वर की मौजूदा स्थिति के साथ सिंक हो सके.

अगले चरण