‫Android Kotlin Fundamentals 05.3: Data binding with ViewModel and LiveData

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

מבוא

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

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

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

מה שכדאי לדעת

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

מה תלמדו

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

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

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

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

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

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

השחקן הראשון מדגים את המילה, ומשתדל לא לומר אותה.

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

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

מסך – כותרת

מסך המשחק

מסך הציון

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

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

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

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

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

לדוגמה:

  • הלחצן הבנתי מוגדר כתצוגה Button בקובץ הפריסה game_fragment.xml.
  • כשהמשתמש מקיש על הלחצן Got It (הבנתי), מאזין לקליקים ב-fragment‏ GameFragment קורא למאזין לקליקים התואם ב-GameViewModel.
  • הציון מתעדכן בGameViewModel.

התצוגה Button והרכיב GameViewModel לא מתקשרים ישירות – הם צריכים את מאזין הלחיצות שנמצא ב-GameFragment.

ViewModel שמועבר אל קשירת הנתונים

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

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

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

שלב 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...
  1. בקובץ 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: שימוש בקשרי listener לטיפול באירועים

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

ה-Data binding יוצר listener ומגדיר אותו בתצוגה. כשהאירוע המאזין מתרחש, המאזין מעריך את ביטוי ה-lambda. קישורי מאזינים פועלים עם Android Gradle Plugin מגרסה 2.0 ואילך. מידע נוסף זמין במאמר Layouts and binding expressions.

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

  1. ב-game_fragment.xml, מוסיפים את המאפיין onClick אל skip_button. מגדירים ביטוי של קישור ומבצעים קריאה ל-method‏ onSkip() ב-GameViewModel. ביטוי הקישור הזה נקרא listener binding.
<Button
   android:id="@+id/skip_button"
   ...
   android:onClick="@{() -> gameViewModel.onSkip()}"
   ... />
  1. באופן דומה, מקשרים את אירוע הלחיצה של correct_button לשיטה onCorrect() ב-GameViewModel.
<Button
   android:id="@+id/correct_button"
   ...
   android:onClick="@{() -> gameViewModel.onCorrect()}"
   ... />
  1. מקשרים את אירוע הלחיצה של end_game_button לשיטה onGameFinish() ב-GameViewModel.
<Button
   android:id="@+id/end_game_button"
   ...
   android:onClick="@{() -> gameViewModel.onGameFinish()}"
   ... />
  1. ב-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
  1. ב-score_fragment.xml, מוסיפים את המאפיין onClick אל play_again_button. מגדירים listener binding ומבצעים קריאה ל-method‏ onPlayAgain() ב-ScoreViewModel.
<Button
   android:id="@+id/play_again_button"
   ...
   android:onClick="@{() -> scoreViewModel.onPlayAgain()}"
   ... />
  1. ב-ScoreFragment, בתוך onCreateView(), מאתחלים את viewModel. לאחר מכן מאתחלים את משתנה הקישור binding.scoreViewModel.
viewModel = ...
binding.scoreViewModel = viewModel
  1. ב-ScoreFragment, מסירים את הקוד שמגדיר את מאזין הקליקים עבור playAgainButton. אם מוצגת שגיאה ב-Android Studio, צריך לנקות את הפרויקט ולבנות אותו מחדש.

קוד להסרה:

binding.playAgainButton.setOnClickListener {  viewModel.onPlayAgain()  }
  1. מריצים את האפליקציה. האפליקציה אמורה לפעול כמו קודם, אבל עכשיו התצוגות של הלחצנים מתקשרות ישירות עם אובייקטים של ViewModel. התצוגות כבר לא מתקשרות באמצעות מטפלי לחיצות על לחצנים ב-ScoreFragment.

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

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

אם מופיעה הודעת שגיאה לא ברורה:

  1. צריך לבדוק בקפידה את ההודעה בחלונית Build ב-Android Studio. אם מופיע מיקום שמסתיים ב-databinding, יש שגיאה בקישור הנתונים.
  2. בקובץ ה-XML של הפריסה, בודקים אם יש שגיאות במאפייני onClick שמשתמשים בקשירת נתונים. מחפשים את הפונקציה שהביטוי למבדה קורא לה, ומוודאים שהיא קיימת.
  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 observer.

שלב 1: מוסיפים את word LiveData לקובץ game_fragment.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 מציג מחרוזת ריקה.

  1. ב-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
  1. ב-GameFragment, מסירים את המשקיף מהחשבון LiveData word.

קוד להסרה:

/** Setting up LiveData observation relationship **/
viewModel.word.observe(this, Observer { newWord ->
   binding.wordText.text = newWord
})
  1. מפעילים את האפליקציה ומשחקים במשחק. עכשיו המילה הנוכחית מתעדכנת בלי שימוש בשיטת observer בבקר של ממשק המשתמש.

שלב 2: מוסיפים את ה-LiveData של הניקוד לקובץ score_fragment.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)}"
   ... />
  1. ב-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
  1. ב-ScoreFragment, מסירים את האובייקט observer עבור האובייקט score.

קוד להסרה:

// Add observer for score
viewModel.score.observe(this, Observer { newScore ->
   binding.scoreText.text = newScore.toString()
})
  1. מפעילים את האפליקציה ומשחקים במשחק. שימו לב שהציון בקטע הציון מוצג בצורה נכונה, ללא רכיב Observer בקטע הציון.

שלב 3: הוספת עיצוב מחרוזות באמצעות קישור נתונים

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

  1. ב-string.xml, מוסיפים את המחרוזות הבאות, שישמשו לעיצוב תצוגות הטקסט word ו-score. ‫%s ו-%d הם placeholders למילה הנוכחית ולציון הנוכחי.
<string name="quote_format">\"%s\"</string>
<string name="score_format">Current Score: %d</string>
  1. ב-game_fragment.xml, מעדכנים את מאפיין text של תצוגת הטקסט word_text כך שישתמש במשאב המחרוזת quote_format. עברו את gameViewModel.word. הפונקציה מעבירה את המילה הנוכחית כארגומנט למחרוזת הפורמט.
<TextView
   android:id="@+id/word_text"
   ...
   android:text="@{@string/quote_format(gameViewModel.word)}"
   ... />
  1. מעצבים את תצוגת הטקסט 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)}"
   ... />
  1. בכיתה GameFragment, בתוך ה-method‏ onCreateView(), מסירים את קוד ה-observer‏ score.

קוד להסרה:

viewModel.score.observe(this, Observer { newScore ->
   binding.scoreText.text = newScore.toString()
})
  1. מנקים, בונים מחדש ומריצים את האפליקציה, ואז משחקים במשחק. שימו לב שהמילה הנוכחית והניקוד מפורמטים במסך המשחק.

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

פרויקט Android Studio: ‏ GuessTheWord
  • ספריית Data Binding פועלת בצורה חלקה עם רכיבי ארכיטקטורה של Android כמו ViewModel ו-LiveData.
  • הפריסות באפליקציה יכולות להיות קשורות לנתונים ברכיבי הארכיטקטורה, שכבר עוזרים לכם לנהל את מחזור החיים של בקר ממשק המשתמש ולשלוח התראות על שינויים בנתונים.

קישור נתונים של ViewModel

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

כדי לשייך ViewModel לפריסה:

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

       <variable
           name="gameViewModel"
           type="com.example.android.guesstheword.screens.game.GameViewModel" />
   </data>
  • בקובץ GameFragment, מעבירים את GameViewModel לאיגוד הנתונים.
binding.gameViewModel = viewModel

קישורי Listener

  • listener bindings הם ביטויי binding בפריסה שמופעלים כשמופעלים אירועי קליק כמו onClick().
  • קישורי מאזינים נכתבים כביטויי למדה.
  • באמצעות listener bindings, מחליפים את click listeners בבקרי ממשק המשתמש ב-listener bindings בקובץ הפריסה.
  • ה-Data binding יוצר listener ומגדיר אותו בתצוגה. 
 android:onClick="@{() -> gameViewModel.onSkip()}"

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

  • אפשר להשתמש באובייקטים מסוג LiveData כמקור לקשירת נתונים, כדי שהממשק יקבל באופן אוטומטי התראות על שינויים בנתונים.
  • אפשר לקשר את התצוגה ישירות לאובייקט LiveData ב-ViewModel. כשערך ה-LiveData ב-ViewModel משתנה, אפשר לעדכן באופן אוטומטי את התצוגות בפריסה, בלי שיטות האובזרבר בבקרי ממשק המשתמש.
android:text="@{gameViewModel.word}"
  • כדי שהתכונה LiveData data binding תפעל, צריך להגדיר את הפעילות הנוכחית (הפקד של ממשק המשתמש) כבעלים של מחזור החיים של המשתנה binding בפקד של ממשק המשתמש.
binding.lifecycleOwner = this

עיצוב מחרוזות באמצעות קישור נתונים

  • באמצעות קשירת נתונים, אפשר לעצב משאב מחרוזת עם placeholders כמו %s למחרוזות ו-%d למספרים שלמים.
  • כדי לעדכן את מאפיין text של התצוגה, מעבירים את אובייקט LiveData כארגומנט למחרוזת הפורמט.
 android:text="@{@string/quote_format(gameViewModel.word)}"

קורס ב-Udacity:

מסמכי תיעוד למפתחי Android:

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

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

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

אם אתם עובדים על ה-codelab הזה לבד, אתם יכולים להשתמש במשימות האלה כדי לבדוק את הידע שלכם.

עונים על השאלות הבאות

שאלה 1

איזו מההצהרות הבאות לא נכונה לגבי listener bindings?

  • listener bindings הם ביטויי binding שמופעלים כשמתרחש אירוע.
  • הקישורים של Listener פועלים עם כל הגרסאות של הפלאגין Android Gradle.
  • קישורי מאזינים נכתבים כביטויי למדה.
  • listener bindings דומים ל-method references, אבל הם מאפשרים להריץ ביטויים שרירותיים של data-binding.

שאלה 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

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