לשמור מידע

לפני שאתה מתחיל

לפני שתוכל להשתמש מסד זמן אמת , עליך:

  • רשום את פרויקט Unity שלך והגדר אותו לשימוש ב- Firebase.

    • אם פרויקט האחדות שלך כבר משתמש ב- Firebase, הוא כבר רשום ומוגדר ל- Firebase.

    • אם אין לך פרויקט אחדות, אתה יכול להוריד אפליקציה לדוגמא .

  • מוסיפים את SDK האחדות Firebase (במיוחד, FirebaseDatabase.unitypackage ) לפרויקט האחדות שלך.

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

שמירת נתונים

יש חמש שיטות לכתיבת נתונים למאגר המידע בזמן אמת של Firebase:

שיטה שימושים נפוצים
SetValueAsync() כתוב או להחליף נתונים נתיב מוגדר, כגון users/<user-id>/<username> .
SetRawJsonValueAsync() כתוב או להחליף נתונים עם גלם JSON, כגון users/<user-id>/<username> .
Push() הוסף לרשימת הנתונים. בכל פעם שאתם קוראים Push() , Firebase מייצר מפתח ייחודי שיכול לשמש גם מזהה ייחודי, כגון user-scores/<user-id>/<unique-score-id> .
UpdateChildrenAsync() עדכן חלק מהמפתחות לנתיב מוגדר מבלי להחליף את כל הנתונים.
RunTransaction() עדכן נתונים מורכבים שעלולים להיפגם על ידי עדכונים מקבילים.

קבל מסד נתונים

כדי לכתוב נתונים למסד הנתונים, אתה צריך מופע של 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 מוקלד, אתה יכול להשתמש מובנה JsonUtility.ToJson() כדי להמיר את האובייקט כדי גלם JSON ולקרוא SetRawJsonValueAsync() . לדוגמה, ייתכן שיש לך מחלקת משתמשים שנראתה כך:

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

עדכן שדות ספציפיים

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

שימושים דוגמה זו Push() כדי ליצור רשומה הצומת המכיל ערכים עבור כל המשתמשים /scores/$key ובמקביל לאחזר את המפתח עם Key . המפתח לאחר מכן ניתן להשתמש כדי ליצור ערך שני הציוני של המשתמש על /user-scores/$userid/$key .

באמצעות נתיבים אלה, אתה יכול לבצע עדכונים סימולטני ליעדים רבים בעץ JSON עם שיחה אחת כדי UpdateChildrenAsync() , כגון איך בדוגמה זו יוצרת את הרשומה החדשה בשני המקומות. עדכונים סימולטניים המתבצעים בדרך זו הם אטומיים: או שכל העדכונים מצליחים או כל העדכונים נכשלים.

מחק נתונים

הדרך הפשוטה ביותר נתונים המחיקה היא להתקשר RemoveValue() על הפניה למיקום של הנתונים.

אתה גם יכול למחוק ידי ציון null כערך לעוד פעולת הכתיבה כגון SetValueAsync() או UpdateChildrenAsync() . אתה יכול להשתמש בטכניקה זו עם UpdateChildrenAsync() כדי למחוק ילדים מרובים בשיחת API יחידה.

דע מתי הנתונים שלך מחויבים.

כדי לדעת מתי הנתונים שלך מחויבים לשרת Firebase Realtime Database, אתה יכול להוסיף המשך. שניהם 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);
    });
}

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

כתוב נתונים במצב לא מקוון

אם לקוח מאבד את חיבור הרשת שלו, האפליקציה שלך תמשיך לתפקד כראוי.

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

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

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

הצעדים הבאים