יכולת תצפית מתייחסת ליכולת של אובייקט להודיע לאחרים על שינויים בנתונים שלו. ספריית Data Binding מאפשרת להפוך אובייקטים, שדות או אוספים לניתנים לצפייה.
אפשר להשתמש בכל אובייקט לקישור נתונים, אבל שינוי האובייקט לא גורם לעדכון אוטומטי של ממשק המשתמש. אתם יכולים להשתמש בקישור נתונים כדי לתת לאובייקטים של הנתונים את היכולת להודיע לאובייקטים אחרים (שנקראים מאזינים) כשהנתונים שלהם משתנים. יש שלושה סוגים של מחלקות שניתנות למעקב: שדות, אוספים ואובייקטים.
כשקושרים אחד מהאובייקטים האלה של נתונים גלויים לממשק המשתמש, ומשנים מאפיין של אובייקט הנתונים, ממשק המשתמש מתעדכן באופן אוטומטי.
שדות שניתן לצפות בהם
אם למחלקות שלכם יש רק כמה מאפיינים, יכול להיות שלא כדאי להשקיע מאמץ ביצירת מחלקות שמטמיעות את הממשק של Observable. במקרה כזה, אתם יכולים להשתמש במחלקה הגנרית Observable ובמחלקות הספציפיות הבאות כדי להפוך שדות לניתנים לצפייה:
ObservableBooleanObservableByteObservableCharObservableShortObservableIntObservableLongObservableFloatObservableDoubleObservableParcelable
שדות ניתנים לצפייה הם אובייקטים ניתנים לצפייה שמכילים שדה אחד. הגרסאות הפרימיטיביות מונעות boxing ו-unboxing במהלך פעולות גישה. כדי להשתמש במנגנון הזה, יוצרים מאפיין public final בשפת התכנות Java או מאפיין לקריאה בלבד ב-Kotlin, כמו בדוגמה הבאה:
Kotlin
class User { val firstName = ObservableField<String>() val lastName = ObservableField<String>() val age = ObservableInt() }
Java
private static class User { public final ObservableField<String> firstName = new ObservableField<>(); public final ObservableField<String> lastName = new ObservableField<>(); public final ObservableInt age = new ObservableInt(); }
כדי לגשת לערך השדה, משתמשים בשיטות אחזור הנתונים set() ו-get() או בתחביר המאפיינים של Kotlin:
Kotlin
user.firstName = "Google" val age = user.age
Java
user.firstName.set("Google"); int age = user.age.get();
אוספים גלויים
באפליקציות מסוימות נעשה שימוש במבנים דינמיים כדי לשמור נתונים. אוספים שניתנים לצפייה מאפשרים גישה למבנים האלה באמצעות מפתח. הכיתה ObservableArrayMap שימושית כשהמפתח הוא מסוג הפניה, כמו String, כפי שמוצג בדוגמה הבאה:
Kotlin
ObservableArrayMap<String, Any>().apply { put("firstName", "Google") put("lastName", "Inc.") put("age", 17) }
Java
ObservableArrayMap<String, Object> user = new ObservableArrayMap<>(); user.put("firstName", "Google"); user.put("lastName", "Inc."); user.put("age", 17);
בפריסה, אפשר למצוא את המפה באמצעות מפתחות המחרוזת, כמו בדוגמה הבאה:
<data>
<import type="android.databinding.ObservableMap"/>
<variable name="user" type="ObservableMap<String, Object>"/>
</data>
…
<TextView
android:text="@{user.lastName}"
android:layout_width="wrap_content"
android:layout_height="wrap_content"/>
<TextView
android:text="@{String.valueOf(1 + (Integer)user.age)}"
android:layout_width="wrap_content"
android:layout_height="wrap_content"/>
הכיתה ObservableArrayList שימושית כשהמפתח הוא מספר שלם, באופן הבא:
Kotlin
ObservableArrayList<Any>().apply { add("Google") add("Inc.") add(17) }
Java
ObservableArrayList<Object> user = new ObservableArrayList<>(); user.add("Google"); user.add("Inc."); user.add(17);
בפריסה, אפשר לגשת לרשימה דרך האינדקסים, כמו בדוגמה הבאה:
<data>
<import type="android.databinding.ObservableList"/>
<import type="com.example.my.app.Fields"/>
<variable name="user" type="ObservableList<Object>"/>
</data>
…
<TextView
android:text='@{user[Fields.LAST_NAME]}'
android:layout_width="wrap_content"
android:layout_height="wrap_content"/>
<TextView
android:text='@{String.valueOf(1 + (Integer)user[Fields.AGE])}'
android:layout_width="wrap_content"
android:layout_height="wrap_content"/>
אובייקטים שניתן לצפות בהם
מחלקה שמטמיעה את הממשק Observable מאפשרת רישום של מאזינים שרוצים לקבל התראות על שינויים במאפיינים מהאובייקט שניתן לצפייה.
בממשק של Observable יש מנגנון להוספה ולהסרה של מאזינים, אבל אתם מחליטים מתי לשלוח התראות. כדי להקל על הפיתוח, ספריית קישור הנתונים מספקת את המחלקה BaseObservable, שמטמיעה את מנגנון הרישום של המאזין. מחלקת הנתונים שמטמיעה את BaseObservable אחראית להודיע כשהמאפיינים משתנים. כדי לעשות את זה, מקצים הערה מסוג Bindable ל-getter וקוראים ל-method notifyPropertyChanged() ב-setter, כמו בדוגמה הבאה:
Kotlin
class User : BaseObservable() { @get:Bindable var firstName: String = "" set(value) { field = value notifyPropertyChanged(BR.firstName) } @get:Bindable var lastName: String = "" set(value) { field = value notifyPropertyChanged(BR.lastName) } }
Java
private static class User extends BaseObservable { private String firstName; private String lastName; @Bindable public String getFirstName() { return this.firstName; } @Bindable public String getLastName() { return this.lastName; } public void setFirstName(String firstName) { this.firstName = firstName; notifyPropertyChanged(BR.firstName); } public void setLastName(String lastName) { this.lastName = lastName; notifyPropertyChanged(BR.lastName); } }
קישור הנתונים יוצר מחלקה בשם BR בחבילת המודול, שמכילה את המזהים של המשאבים שמשמשים לקישור הנתונים. ההערה Bindable יוצרת רשומה בקובץ המחלקה BR במהלך הקומפילציה. אם אי אפשר לשנות את המחלקה הבסיסית של מחלקות הנתונים, אתם יכולים להטמיע את הממשק Observable באמצעות אובייקט PropertyChangeRegistry כדי לרשום מאזינים ולשלוח להם התראות ביעילות.
אובייקטים שמודעים למחזור החיים
אפשר גם לקשר את הפריסות באפליקציה למקורות של קישור נתונים, שמעדכנים באופן אוטומטי את ממשק המשתמש לגבי שינויים בנתונים. כך, הקישורים שלכם מודעים למחזור החיים ומופעלים רק כשממשק המשתמש גלוי במסך.
קישור נתונים תומך ב-StateFlow וב-LiveData. למידע נוסף על השימוש ב-LiveData בקישור נתונים, קראו את המאמר שימוש ב-LiveData כדי להודיע לממשק המשתמש על שינויים בנתונים.
שימוש ב-StateFlow
אם האפליקציה שלכם משתמשת ב-Kotlin עם coroutines, אתם יכולים להשתמש באובייקטים של StateFlow כמקור הקישור של הנתונים. כדי להשתמש באובייקט StateFlow עם מחלקת הקישור, צריך לציין בעלים של מחזור חיים כדי להגדיר את ההיקף של האובייקט StateFlow. בדוגמה הבאה, הפעילות מוגדרת כבעלים של מחזור החיים אחרי שנוצר מופע של מחלקת הקישור:
class ViewModelActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
// Inflate view and obtain an instance of the binding class.
val binding: UserBinding = DataBindingUtil.setContentView(this, R.layout.user)
// Specify the current activity as the lifecycle owner.
binding.lifecycleOwner = this
}
}
כמו שמתואר במאמר קישור תצוגות פריסה לרכיבי ארכיטקטורה, קישור נתונים פועל בצורה חלקה עם אובייקטים מסוג ViewModel. אפשר להשתמש ב-StateFlow וב-ViewModel ביחד באופן הבא:
class ScheduleViewModel : ViewModel() {
private val _username = MutableStateFlow<String>("")
val username: StateFlow<String> = _username
init {
viewModelScope.launch {
_username.value = Repository.loadUserName()
}
}
}
בפריסה, מקצים את המאפיינים והשיטות של האובייקט ViewModel לתצוגות המתאימות באמצעות ביטויי קישור, כמו בדוגמה הבאה:
<TextView
android:id="@+id/name"
android:text="@{viewmodel.username}" />
ממשק המשתמש מתעדכן באופן אוטומטי בכל פעם שערך השם של המשתמש משתנה.
השבתת התמיכה ב-StateFlow
באפליקציות שמשתמשות ב-Kotlin וב-AndroidX, התמיכה ב-StateFlow נכללת באופן אוטומטי עם קישור הנתונים. כלומר, אם יחסי התלות של coroutines לא זמינים, הם נכללים באופן אוטומטי באפליקציה.
כדי להפסיק להשתמש בפונקציונליות הזו, צריך להוסיף את הקוד הבא לקובץ build.gradle:
מגניב
android { ... dataBinding { addKtx = false } }
Kotlin
android { ... dataBinding { addKtx = false } }
לחלופין, אפשר להשבית את StateFlow באופן גלובלי בפרויקט על ידי הוספת השורה הבאה לקובץ gradle.properties:
מגניב
android.defaults.databinding.addKtx = false
Kotlin
android.defaults.databinding.addKtx = false
מקורות מידע נוספים
איפה אפשר למצוא מידע נוסף על קישור נתונים?
דוגמאות
פוסטים בבלוגים
מומלץ בשבילכם
- הערה: טקסט הקישור מוצג כש-JavaScript מושבת
- מודול Saved State ל-ViewModel
- קישור תצוגות פריסה לרכיבי ארכיטקטורה
- סקירה כללית על ספריית העימוד