Android Kotlin Fundamentals 05.3: קישור נתונים עם ViewModel ו-LiveData

Lab Lab זה הוא חלק מקורס Android Kotlin Fundamentals. כדי להפיק את המקסימום מהקורס הזה, יש לפעול ברצף לפי קודי שיעור ה-Lab. כל שיעורי Lab של הקורסים מופיעים בדף הנחיתה של Lab Kotlin Fundamentals ל-Android Lab.

Lablab זה הוא חלק מסדרה של ארבעה קודים שמלמדת על ViewModel ועל LiveData. ViewModel ו-LiveData הם רכיבי ארכיטקטורה של Android, שהם ספריות ורכיבים אחרים שעוזרים לכם לתכנן אפליקציות חזקות, ניתנות לבדיקה ולתחזוקה.

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

• 5.1 : תצוגות של דגם ודגם ViewModel
• 5.2 : בודקים של LiveData ו-LiveData
• 5.3 : קישור נתונים עם ViewModel ו-LiveData
• 5.4 : טרנספורמציות Live Data

מבוא

בשיעורי ה-Labs הקודמים בשיעור הזה, שיפרנו את הקוד לאפליקציה GuessTheWord. האפליקציה משתמשת עכשיו באובייקטים ViewModel, כך שנתוני האפליקציה שמרו על שינויים בתצורת המכשיר כמו סיבובי מסך ושינויים בזמינות המקלדת. הוספת גם LiveData שניתן לתעד, כך שהצפיות יקבלו הודעה באופן אוטומטי במקרה של שינויים בנתונים.

במעבדה זו, אתם ממשיכים לעבוד עם אפליקציית GuessTheWord. אתם מקשרים את הכיתות ל-ViewModel באפליקציה כדי שהתצוגות בפריסה שלכם יתקשרו ישירות עם האובייקטים ViewModel. (עד עכשיו, האפליקציות שלך ניהלו תקשורת עקיפה עם ViewModel, באמצעות קטעי האפליקציה.) לאחר שילוב של קישור נתונים עם אובייקטים מסוג ViewModel, אין יותר צורך בגורמים המטפלים בקליקים במקטעים של האפליקציה. לכן, יש להסיר אותם.

בנוסף, עליך לשנות את האפליקציה GuessTheWord כדי להשתמש ב-LiveData כמקור לקישור נתונים כדי ליידע את ממשק המשתמש לגבי שינויים בנתונים, בלי להשתמש בשיטות תצפית של LiveData.

דברים שחשוב לדעת

• איך ליצור אפליקציות בסיסיות ל-Android ב-Kotlin.
• איך פועלים מחזורי חיים ומקטעים חלקיים.
• איך להשתמש באובייקטים ViewModel באפליקציה.
• איך לאחסן נתונים באמצעות LiveData בViewModel.
• איך להוסיף שיטות תצפית שיתייחסו לשינויים בנתונים של LiveData.

מה תלמדו

• איך משתמשים ברכיבים של ספריית קישור הנתונים.
• איך לשלב את ViewModel עם קישור נתונים.
• איך לשלב את LiveData עם קישור נתונים.
• כיצד להשתמש בקישורי האזנה כדי להחליף את רכיב ההאזנה של הקליקים בשבר.
• איך מוסיפים עיצוב מחרוזת לביטויים שמחייבים נתונים?

הפעולות שתבצעו:

• התצוגות בפריסות GuessTheWord מתקשרות באופן עקיף עם אובייקטים של ViewModel, באמצעות בקרי ממשק משתמש (מקטעים) כדי להעביר מידע. במעבדת קוד זו, אתם מקשרים את התצוגות המפורטות של האפליקציה לאובייקטים של ViewModel, כך שהצפיות יתקשרו ישירות עם האובייקטים ViewModel.
• צריך לשנות את האפליקציה כך שייעשה שימוש ב-LiveData כמקור שמחייב את הנתונים. לאחר השינוי, האובייקטים ב-LiveData יקבלו הודעה על כך בממשק המשתמש לגבי שינויים בנתונים, ואין יותר צורך בשיטות הצופה LiveData.

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

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

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

השחקן הראשון מנגן את המילה, והיזהר לא לומר את המילה עצמה.

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

במעבדה הזו, אתם משפרים את אפליקציית GuessTheWord על ידי שילוב של קישור נתונים עם LiveData באובייקטים ViewModel. הפעולה הזו מאפשרת אוטומציה של התקשורת בין התצוגות בפריסה ובאובייקטים של ViewModel, והיא מאפשרת לפשט את הקוד באמצעות LiveData.

מסך – כותרת

מסך המשחק

מסך הניקוד

במשימה הזו תאתרו את קוד הסימן להפעלה והרצה של שיעור ה-Lab הזה. אפשר להשתמש באפליקציית GuessTheWord שיצרתם ב-Codelab הקודם כקוד למתחילים, או להוריד אפליקציה למתחילים.

1. (אופציונלי) אם אינכם משתמשים בקוד מ-codelab הקודם, הורידו את הקוד למתחילים ל-codelab זה. מבטלים את דחיסת הקוד ופותחים את הפרויקט ב-Android Studio.
2. מפעילים את האפליקציה ומשחקים במשחק.
3. שימו לב שהלחצן הבנתי מציג את המילה הבאה ומגדיל את הציון במילה אחת, ואילו הלחצן דילוג מציג את המילה הבאה ומוריד את התוצאה במילה אחת. הלחצן סיום המשחק מסתיים.
4. עוברים בין כל המילים ושימו לב שהאפליקציה מנווטת באופן אוטומטי למסך הניקוד.

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

ארכיטקטורת אפליקציה נוכחית

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

למשל:

• הלחצן הבנתי מוגדר כתצוגת Button בקובץ הפריסה game_fragment.xml.
• כשהמשתמש מקיש על הלחצן הבנתי, event listener בקטע GameFragment GameFragment מתקשר ל-click listener המתאים ב-GameViewModel.
• הניקוד מתעדכן ב-GameViewModel.

התצוגה Button וה-GameViewModel לא יוצרים קשר ישיר – הם צריכים את event listener בGameFragment.

מודל תצוגה שהועבר לקישור הנתונים

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

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

במשימה הזו, משייכים את הכיתות GameViewModel ו-ScoreViewModel לפריסות ה-XML התואמות שלהן. כמו כן, אתם מגדירים קישורים למאזינים כדי לטפל באירועי קליקים.

שלב 1: הוספת קישור נתונים ל-GameViewModel

בשלב זה, משייכים את GameViewModel לקובץ הפריסה המתאים, game_fragment.xml.

1. בקובץ game_fragment.xml, מוסיפים משתנה של קישור נתונים מסוג GameViewModel. אם יש שגיאות ב-Android Studio, מנקים את הפרויקט ובונים אותו מחדש.

<layout ...>

   <data>

       <variable
           name="gameViewModel"
           type="com.example.android.guesstheword.screens.game.GameViewModel" />
   </data>
  
   <androidx.constraintlayout...

2. בקובץ GameFragment, צריך להעביר את GameViewModel לאיגוד הנתונים.
   
   לשם כך, יש להקצות את viewModel למשתנה binding.gameViewModel, שעליו הצהרת בשלב הקודם. צריך להזין את הקוד בתוך onCreateView(), אחרי האתחול של הסימן viewModel. אם יש שגיאות ב-Android Studio, מנקים את הפרויקט ובונים אותו מחדש.

// Set the viewmodel for databinding - this allows the bound layout access 
// to all the data in the ViewModel
binding.gameViewModel = viewModel

שלב 2: שימוש בקישורי האזנה לטיפול באירועים

קישורי האזנה הם ביטויים מחייבים שפועלים כאשר אירועים כמו onClick(), onZoomIn() או onZoomOut() מופעלים. קישורי האזנה נכתבים כביטויים של למדה.

קישור הנתונים יוצר event listener ומגדיר את ה-lister בתצוגה. כאשר האירוע שהאזנת לו קורה, המאזינים בוחנים את הביטוי של למדה. קישורי האזנה פועלים עם הפלאגין של Android Gradle מגרסה 2.0 ואילך. למידע נוסף, ניתן לקרוא את המאמר פריסות וביטויים מחייבים.

בשלב זה, מחליפים את המאזינים של הקליקים ב-GameFragment בקישורי ההאזנה בקובץ game_fragment.xml.

1. ב-game_fragment.xml, יש להוסיף את המאפיין onClick ל-skip_button. יש להגדיר ביטוי מחייב ולהתקשר לשיטה onSkip() ב-GameViewModel. ביטוי הקישור הזה נקרא קישור מאזינים.

<Button
   android:id="@+id/skip_button"
   ...
   android:onClick="@{() -> gameViewModel.onSkip()}"
   ... />

2. באופן דומה, מקשרים את אירוע הקליק של correct_button לשיטה onCorrect() בGameViewModel.

<Button
   android:id="@+id/correct_button"
   ...
   android:onClick="@{() -> gameViewModel.onCorrect()}"
   ... />

3. מקשרים את אירוע הקליק אל end_game_button לשיטה onGameFinish() בGameViewModel.

<Button
   android:id="@+id/end_game_button"
   ...
   android:onClick="@{() -> gameViewModel.onGameFinish()}"
   ... />

4. ב-GameFragment, מסירים את ההצהרות שמגדירות את המאזינים של הקליקים, ומסירים את הפונקציות שאליהן המאזינים לוחצים. אין לך יותר צורך בהם.

קוד להסרה:

binding.correctButton.setOnClickListener { onCorrect() }
binding.skipButton.setOnClickListener { onSkip() }
binding.endGameButton.setOnClickListener { onEndGame() }

/** Methods for buttons presses **/
private fun onSkip() {
   viewModel.onSkip()
}
private fun onCorrect() {
   viewModel.onCorrect()
}
private fun onEndGame() {
   gameFinished()
}

שלב 3: מוסיפים קישור נתונים ל-ScoreViewModel

בשלב זה, משייכים את ScoreViewModel לקובץ הפריסה המתאים, score_fragment.xml.

1. בקובץ score_fragment.xml, מוסיפים משתנה מחייב מסוג ScoreViewModel. שלב זה דומה למה שעשית עבור GameViewModel למעלה.

<layout ...>
   <data>
       <variable
           name="scoreViewModel"
           type="com.example.android.guesstheword.screens.score.ScoreViewModel" />
   </data>
   <androidx.constraintlayout.widget.ConstraintLayout

2. ב-score_fragment.xml, יש להוסיף את המאפיין onClick ל-play_again_button. מגדירים קישור האזנה ומתקשרים לשיטה onPlayAgain() בScoreViewModel.

<Button
   android:id="@+id/play_again_button"
   ...
   android:onClick="@{() -> scoreViewModel.onPlayAgain()}"
   ... />

3. ב-ScoreFragment, בתוך onCreateView(), מפעילים את ה-viewModel. לאחר מכן מפעילים את binding.scoreViewModel המשתנה המחייב.

viewModel = ...
binding.scoreViewModel = viewModel

4. ב-ScoreFragment, יש להסיר את הקוד שמגדיר את ה-click listener של playAgainButton. אם ב-Android Studio מוצגת שגיאה, מנקים את הפרויקט ובונים אותו מחדש.

קוד להסרה:

binding.playAgainButton.setOnClickListener {  viewModel.onPlayAgain()  }

5. עליך להפעיל את האפליקציה שלך. האפליקציה אמורה לפעול כרגיל, אבל עכשיו הלחצנים מוצגים ישירות עם האובייקטים ViewModel. התצוגות לא כוללות יותר תקשורת באמצעות הלחצן של לחיצה על לחצנים ב-ScoreFragment.

פתרון בעיות הקשורות להודעות שגיאה שקשורות לנתונים

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

אם מופיעה הודעת שגיאה קריטית:

1. מעיינים בהודעה בקפידה בחלונית Build ב-Android Studio. אם מיקום מסוים מסתיים בעוד databinding, יש שגיאה בקישור הנתונים.
2. בקובץ ה-XML לפריסה, בודקים אם יש שגיאות במאפייני onClick שנעשה בהם שימוש בקישור נתונים. מחפשים את הפונקציה שביטוי ה-lamba מתקשר אליה ומוודאים שהיא קיימת.
3. בקטע <data> של ה-XML, בודקים את האיות של המשתנה של קישור הנתונים.

לדוגמה, חשוב לשים לב לאיות שגוי של שם הפונקציה onCorrect() בערך המאפיין הבא:

android:onClick="@{() -> gameViewModel.onCorrectx()}"

שים לב גם לשגיאת האיות של gameViewModel בקטע <data> של קובץ ה-XML:

<data>
   <variable
       name="gameViewModelx"
       type="com.example.android.guesstheword.screens.game.GameViewModel" />
</data>

Android Studio לא מזהה שגיאות כאלה עד הידור האפליקציה, ולאחר מכן המהדר מציג הודעת שגיאה כמו:

error: cannot find symbol
import com.example.android.guesstheword.databinding.GameFragmentBindingImpl"

symbol:   class GameFragmentBindingImpl
location: package com.example.android.guesstheword.databinding

קישור הנתונים פועל היטב עם LiveData שמשמש לאובייקטים של ViewModel. סיימת להוסיף את קישור הנתונים לאובייקטים של ViewModel, ועכשיו אתה יכול לשלב את LiveData.

במשימה הזו עליך לשנות את האפליקציה GuessTheWord כדי להשתמש ב-LiveData כמקור לקישור נתונים כדי ליידע את ממשק המשתמש לגבי שינויים בנתונים, בלי להשתמש בשיטות הצופה LiveData.

שלב 1: הוספת המילה LiveData לקובץ Game_snippet.xml

בשלב זה, אתם מקשרים את תצוגת הטקסט הנוכחית של המילים ישירות לאובייקט LiveData בViewModel.

1. ב-game_fragment.xml, יש להוסיף את המאפיין android:text לתצוגת הטקסט word_text.

יש להגדיר אותו לאובייקט LiveData, word מתוך GameViewModel, באמצעות המשתנה המחייב, gameViewModel.

<TextView
   android:id="@+id/word_text"
   ...
   android:text="@{gameViewModel.word}"
   ... />

לתשומת ליבך, אין צורך להשתמש ב-word.value. במקום זאת, אפשר להשתמש באובייקט LiveData בפועל. האובייקט LiveData מציג את הערך הנוכחי של word. אם הערך של word הוא null, האובייקט LiveData יציג מחרוזת ריקה.

2. ב-GameFragment, אחרי onCreateView(), אחרי האתחול של ה-gameViewModel, מגדירים את הפעילות הנוכחית כבעלים של מחזור החיים של המשתנה binding. פעולה זו מגדירה את היקף האובייקט של LiveData שלמעלה, ומאפשרת לאובייקט לעדכן באופן אוטומטי את התצוגות בפריסה game_fragment.xml.

binding.gameViewModel = ...
// Specify the current activity as the lifecycle owner of the binding.
// This is used so that the binding can observe LiveData updates
binding.lifecycleOwner = this

3. ב-GameFragment, יש להסיר את הצופה מהLiveData של word.

קוד להסרה:

/** Setting up LiveData observation relationship **/
viewModel.word.observe(this, Observer { newWord ->
   binding.wordText.text = newWord
})

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

שלב 2: מוסיפים את LiveLive ניקוד לקובץ Score_snippet.xml

בשלב זה, מתבצע איגוד של LiveData score לתצוגת טקסט הציון בקטע הקוד של הציון.

1. ב-score_fragment.xml, אפשר להוסיף את המאפיין android:text לתצוגת הטקסט של הניקוד. מקצים את scoreViewModel.score למאפיין text. מאחר שה-score הוא מספר שלם, יש להמיר אותו למחרוזת באמצעות String.valueOf().

<TextView
   android:id="@+id/score_text"
   ...
   android:text="@{String.valueOf(scoreViewModel.score)}"
   ... />

2. ב-ScoreFragment, אחרי האתחול של המאפיין scoreViewModel, מגדירים את הפעילות הנוכחית כבעלים של מחזור החיים של המשתנה binding.

binding.scoreViewModel = ...
// Specify the current activity as the lifecycle owner of the binding.
// This is used so that the binding can observe LiveData updates
binding.lifecycleOwner = this

3. ב-ScoreFragment, יש להסיר את הצופה מהאובייקט score.

קוד להסרה:

// Add observer for score
viewModel.score.observe(this, Observer { newScore ->
   binding.scoreText.text = newScore.toString()
})

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

שלב 3: הוספת פורמט של מחרוזת עם איגוד נתונים

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

1. בstring.xml, יש להוסיף את המחרוזות הבאות שישמשו לפורמט של תצוגות הטקסט word ו-score. %s וה-%d הם ה-placeholders של המילה הנוכחית ושל הציון הנוכחי.

<string name="quote_format">\"%s\"</string>
<string name="score_format">Current Score: %d</string>

2. ב-game_fragment.xml, יש לעדכן את המאפיין text של תצוגת הטקסט word_text כדי להשתמש במשאב המחרוזת quote_format. הצלחה בgameViewModel.word. פעולה זו מעבירה את המילה הנוכחית כארגומנט במחרוזת העיצוב.

<TextView
   android:id="@+id/word_text"
   ...
   android:text="@{@string/quote_format(gameViewModel.word)}"
   ... />

3. עיצוב תצוגת הטקסט score באופן דומה ל-word_text. ב-game_fragment.xml, יש להוסיף את המאפיין text לתצוגת הטקסט score_text. יש להשתמש במשאב המחרוזת score_format, שמקבל ארגומנט מספרי אחד, שמיוצג על ידי ה-placeholder %d. יש להעביר את האובייקט LiveData, score, כארגומנט למחרוזת העיצוב הזו.

<TextView
   android:id="@+id/score_text"
   ...
   android:text="@{@string/score_format(gameViewModel.score)}"
   ... />

4. בקטגוריה GameFragment, בתוך השיטה onCreateView(), צריך להסיר את קוד התצפית של score.

קוד להסרה:

viewModel.score.observe(this, Observer { newScore ->
   binding.scoreText.text = newScore.toString()
})

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

מעולה! שילבת את LiveData ואת ViewModel באפליקציה כדי לשייך נתונים. התצוגות המפורטות בפריסה הזו יכולות לתקשר עם ViewModel באופן ישיר, בלי להשתמש ברכיבי handler של קליקים בקטע הקוד. בנוסף, השתמשת באובייקטים של LiveData כמקור לקישור הנתונים כדי ליידע את ממשק המשתמש באופן אוטומטי לגבי שינויים בנתונים, ללא שיטות התצפית של LiveData.

פרויקט של Android Studio: GuessTheWord

• ספריית קישור הנתונים פועלת בצורה חלקה עם רכיבי ארכיטקטורה של Android כמו ViewModel וLiveData.
• הפריסות באפליקציה שלכם יכולות לקשר את הנתונים ברכיבי הארכיטקטורה, שכבר עוזרים לכם לנהל את מחזור החיים של בקר ממשק המשתמש ולהודיע על שינויים בנתונים.

הצגה של נתוני מודל מודל

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

איך משייכים ViewModel לפריסה:

• בקובץ הפריסה, מוסיפים משתנה של קישור נתונים מסוג ViewModel.

   <data>

       <variable
           name="gameViewModel"
           type="com.example.android.guesstheword.screens.game.GameViewModel" />
   </data>

• בקובץ GameFragment, יש להעביר את GameViewModel לאיגוד הנתונים.
  

binding.gameViewModel = viewModel

קישורי האזנה

• קישורי האזנה הם ביטויים מחייבים שפועלים כאשר אירועי קליק כמו onClick() מופעלים.
• קישורי האזנה נכתבים כביטויים של למדה.
• שימוש בפונקציות event listener מחליף את פונקציות ה-click listener בשלט של ממשק המשתמש בפקדי ההאזנה בקובץ הפריסה.
• קישור הנתונים יוצר event listener ומגדיר את ה-lister בתצוגה.

 android:onClick="@{() -> gameViewModel.onSkip()}"

הוספה של LiveData לקישור נתונים

• אובייקטים של LiveData יכולים לשמש כמקור לקישור נתונים כדי ליידע את ממשק המשתמש באופן אוטומטי לגבי שינויים בנתונים.
• אתם יכולים לקשר את התצוגה ישירות לאובייקט LiveData ב-ViewModel. כאשר LiveData ב-ViewModel משתנה, ניתן לעדכן את התצוגות בפריסה באופן אוטומטי, ללא שיטות הבקר בבקרי ממשק המשתמש.

android:text="@{gameViewModel.word}"

• כדי שמשתנה הנתונים (LiveData) יפעל, יש להגדיר את הפעילות הנוכחית (בקר ממשק המשתמש) כבעלים של מחזור החיים של המשתנה binding בבקר ממשק המשתמש.

binding.lifecycleOwner = this

פורמט מחרוזת עם איגוד נתונים

• באמצעות קישור נתונים, אפשר לעצב משאב מחרוזת באמצעות placeholders כמו %s למחרוזות ו-%d למספרים שלמים.
• כדי לעדכן את המאפיין text של התצוגה המפורטת, יש להעביר את האובייקט LiveData בתור ארגומנט למחרוזת הפורמט.

 android:text="@{@string/quote_format(gameViewModel.word)}"

קורס אוניברסיטה:

• פיתוח אפליקציות ל-Android באמצעות Kotlin

התיעוד של מפתח Android:

• פריסות וביטויים מחייבים
• הצגה של תצוגות פריסה לפי רכיבי ארכיטקטורה
• קישורי האזנה

בקטע הזה מפורטות מטלות שיעורי בית אפשריות לתלמידים שעובדים עם קוד Lab הזה, במסגרת קורס בהדרכת מורה. למורה יש אפשרות לבצע את הפעולות הבאות:

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

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

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

מענה על השאלות האלה

שאלה 1

אילו מבין המשפטים הבאים לא נכונים לגבי קישורי האזנה?

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

שאלה 2

נניח שהאפליקציה כוללת את משאב המחרוזת הבא:
<string name="generic_name">Hello %s</string>

איזה מהביטויים הבאים הוא התחביר הנכון לעיצוב המחרוזת, באמצעות הביטוי שמקשר את הנתונים?

• android:text= "@{@string/generic_name(user.name)}"
• android:text= "@{string/generic_name(user.name)}"
• android:text= "@{@generic_name(user.name)}"
• android:text= "@{@string/generic_name,user.name}"

שאלה 3

מתי מתבצעת הערכה של ביטוי שמקשר בין פונקציות ההאזנה?

• כאשר הנתונים המאוחסנים ב-LiveData משתנים
• כאשר פעילות נוצרת מחדש על ידי שינוי של הגדרה
• כאשר אירוע כמו onClick() קורה
• כשהפעילות עוברת לרקע

לשיעור הבא: 5.4: טרנספורמציות ב-LiveData

קישורים למעבדות אחרות של הקוד בקורס הזה זמינים בדף הנחיתה של Android Kotlin Fundamentals Codelabs.