डेटा सेव करें

वेब कंटेनर इंस्टॉल करने से पहले

रीयलटाइम डेटाबेस का इस्तेमाल करने से पहले, आपको ये काम करने होंगे:

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

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

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

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

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

डेटा सहेजा जा रहा है

Firebase रीयल टाइम डेटाबेस में डेटा लिखने के पांच तरीके हैं:

तरीका	सामान्य इस्तेमाल
SetValueAsync()	बताए गए पाथ में डेटा लिखें या बदलें, जैसे कि users/<user-id>/<username>.
SetRawJsonValueAsync()	डेटा को रॉ Json से बदलें या रॉ 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() का इस्तेमाल किया जा सकता है. उदाहरण के लिए, आपके पास एक उपयोगकर्ता क्लास हो सकती है, जो इस तरह दिखती है:

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() तरीके का इस्तेमाल करें. जब भी तय Firebase संदर्भ में किसी नए बच्चे को जोड़ा जाता है, तब Push() वाला तरीका एक यूनीक कुंजी जनरेट करता है. सूची में मौजूद हर नए एलिमेंट के लिए, अपने-आप जनरेट होने वाली इन कुंजियों का इस्तेमाल करके, कई क्लाइंट एक ही समय में बच्चों को एक ही जगह पर जोड़ सकते हैं. इससे, उन्हें एक ही समय पर अलग-अलग कोड लिखने की सुविधा नहीं मिलती. 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<string, Object> ToDictionary() {
        Dictionary<string, Object> result = new Dictionary<string, Object>();
        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<string, Object> entryValues = entry.ToDictionary();

    Dictionary<string, Object> childUpdates = new Dictionary<string, Object>();
    childUpdates["/scores/" + key] = entryValues;
    childUpdates["/user-scores/" + userId + "/" + key] = entryValues;

    mDatabase.UpdateChildrenAsync(childUpdates);
}

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

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

डेटा मिटाना

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

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

जानें कि आपका डेटा कब अपलोड किया जाता है.

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

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

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

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

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

    leaderBoardRef.RunTransaction(mutableData => {
      List<object> leaders = mutableData.Value as List<object>

      if (leaders == null) {
        leaders = new List<object>();
      } else if (mutableData.ChildrenCount >= MaxScores) {
        long minScore = long.MaxValue;
        object minVal = null;
        foreach (var child in leaders) {
          if (!(child is Dictionary<string, object>)) continue;
          long childScore = (long)
                      ((Dictionary<string, object>)child)["score"];
          if (childScore < minScore) {
            minScore = childScore;
            minVal = child;
          }
        }
        if (minScore > 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<string, object> newScoreMap =
                       new Dictionary<string, object>();
      newScoreMap["score"] = score;
      newScoreMap["email"] = email;
      leaders.Add(newScoreMap);
      mutableData.Value = leaders;
      return TransactionResult.Success(mutableData);
    });
}

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

डेटा को ऑफ़लाइन सेव करने की अनुमति दें

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

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

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

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

अगले चरण

• अपने रीयलटाइम डेटाबेस से डेटा वापस पाना
• डेटा को स्ट्रक्चर करने का तरीका जानें