Time to sync up! Tune in for Google I/O on May 14, 2024. Register now.

דף זה תורגם על ידי Cloud Translation API.

Android Kotlin Fundamentals 07.5: כותרות ב-RecyclerView

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

מבוא

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

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

כיצד לבנות ממשק משתמש בסיסי באמצעות פעילות, קטעים וצפיות
איך לנווט בין מקטעים, ואיך להשתמש ב-safeArgs כדי להעביר נתונים בין מקטעים.
הצגה של מודלים, הצגה של מפעלי מודלים, טרנספורמציות וLiveData ושל הבודקים שלהם.
איך יוצרים מסד נתונים של Room, יוצרים DAO ומגדירים ישויות.
איך להשתמש בשגרות באינטראקציות במסד נתונים ובמשימות ארוכות אחרות.
איך להטמיע RecyclerView בסיסי עם פריסת Adapter, ViewHolder ופריסת פריט.
איך להטמיע איגוד נתונים עבור RecyclerView.
איך ליצור מתאמים מחייבים ולהשתמש בהם כדי להמיר נתונים.
איך משתמשים ב-GridLayoutManager.
איך לתעד קליקים ולטפל בקליקים בפריטים ב-RecyclerView.

מה תלמדו

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

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

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

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

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

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

ב-Codelab הזה אפשר להוסיף כותרת לתצוגת הפריטים. המסך הראשי הסופי ייראה כך:

קוד Lab זה מלמד את העיקרון הכללי של הכללת פריטים המשתמשים בפריסות שונות ב-RecyclerView. אחת הדוגמאות הנפוצות לכך היא כותרות ברשימה או ברשת. לרשימה יכולה להיות כותרת אחת המתארת את תוכן הפריט. רשימה יכולה גם לכלול כותרות מרובות כדי לקבץ פריטים ולהפריד ביניהם ברשימה אחת.

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

שתי דרכים להוספת כותרות

ב-RecyclerView, כל פריט ברשימה תואם למספר אינדקס שמתחיל ב-0. למשל:

[הנתונים בפועל] -> [צפיות במודעה]

[0: SleepNight] -> [0: SleepNight]

[1: SleepNight] -> [1: SleepNight]

[2: SleepNight] -> [2: SleepNight]

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

[הנתונים בפועל] -> [צפיות במודעה]

[0: כותרת]

[0: SleepNight] -> [1: SleepNight]

[1: SleepNight] -> [2: SleepNight]

[2: SleepNight] -> [3: SleepNight.

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

[הנתונים בפועל] -> [צפיות במודעה]

[ 0: Header] -> [0: Header]

[1: SleepNight] -> [1: SleepNight]

[2: SleepNight] -> [2: SleepNight]

[3: SleepNight] -> [3: SleepNight]

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

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

שלב 1: יוצרים כיתה של DataItem

כדי ליצור תקציר של סוג הפריט ולאפשר למתאם להתמודד רק עם "items" אפשר ליצור מחלקה של בעלי נתונים שמייצגת SleepNight או Header. מערך הנתונים יהיה רשימה של פריטים של בעלי הנתונים.

יש לך אפשרות להוריד את האפליקציה למתחילים מ-GitHub, או להמשיך להשתמש באפליקציית SleepTracker שיצרת ב-Codelab הקודם.

מורידים את הקוד RecyclerViewHeaders-Starter מ-GitHub. הספרייה RecyclerViewHeaders-Starter מכילה את הגרסה למתחילים של אפליקציית SleepTracker הנדרשת ל-Codelab הזה. אם תרצו, תוכלו גם להמשיך עם האפליקציה שהסתיימה, מקוד הקוד הקודם.
פותחים את SleepNightAdapter.kt.
מתחת לרמה SleepNightListener, ברמה העליונה, מגדירים מחלקה sealed בשם DataItem שמייצגת פריט נתונים.

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

sealed class DataItem {

 }

בתוך גוף המחלקה DataItem, מגדירים שתי כיתות שמייצגות את הסוגים השונים של פריטי נתונים. הערך הראשון הוא SleepNightItem, שהוא wrapper מסביב ל-SleepNight, ולכן דרוש לו ערך יחיד שנקרא sleepNight. כדי להפוך אותו לחלק מהמחלקה האיטום, צריך להרחיב אותו ל-DataItem.

data class SleepNightItem(val sleepNight: SleepNight): DataItem()

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

object Header: DataItem()

בתוך DataItem, ברמת הכיתה, מגדירים נכס Long מסוג abstract בשם id. אם המתאם משתמש ב-DiffUtil כדי לקבוע אם פריט מסוים השתנה, DiffItemCallback צריך לדעת את המזהה של כל פריט. תוצג שגיאה כי SleepNightItem ו-Header צריכים לבטל את הנכס המופשט id.

abstract val id: Long

בעוד SleepNightItem, יש לעקוף את id כדי להחזיר את nightId.

override val id = sleepNight.nightId

ב-Header, יש לשנות את id כדי להחזיר את Long.MIN_VALUE, שהוא מספר קטן מאוד (כלומר, 2- ל-63). לכן, לעולם לא תהיה התנגשות עם nightId קיים.

override val id = Long.MIN_VALUE

הקוד הסופי אמור להיראות כך, והאפליקציה אמורה להיווצר ללא שגיאות.

sealed class DataItem {
    abstract val id: Long
    data class SleepNightItem(val sleepNight: SleepNight): DataItem()      {
        override val id = sleepNight.nightId
    }

    object Header: DataItem() {
        override val id = Long.MIN_VALUE
    }
}

שלב 2: יוצרים HoldViewer לכותרת

יוצרים את הפריסה של הכותרת בקובץ חדש של משאב פריסה בשם headline.xml שמציג TextView. אין כאן שום דבר מלהיב, אז הנה הקוד.

<?xml version="1.0" encoding="utf-8"?>
<TextView xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/text"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:textAppearance="?android:attr/textAppearanceLarge"
    android:text="Sleep Results"
    android:padding="8dp" />

יש לחלץ את "Sleep Results" במשאב מחרוזת ולקרוא לו header_text.

<string name="header_text">Sleep Results</string>

ב-SleepNightAdapter.kt, בתוך SleepNightAdapter, מעל לכיתה ViewHolder, יוצרים כיתה חדשה מסוג TextViewHolder. כיתה זו מנפחת את הפריסה textview.xml ומחזירה מופע TextViewHolder. מכיוון שכבר עשית זאת, הנה הקוד, ויהיה עליך לייבא את View ואת R:

    class TextViewHolder(view: View): RecyclerView.ViewHolder(view) {
        companion object {
            fun from(parent: ViewGroup): TextViewHolder {
                val layoutInflater = LayoutInflater.from(parent.context)
                val view = layoutInflater.inflate(R.layout.header, parent, false)
                return TextViewHolder(view)
            }
        }
    }

שלב 3: עדכון SleepNightAdapter

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

הגדרה של סוגי פריטים

ב-SleepNightAdapter.kt, ברמה העליונה, מתחת להצהרות ב-import ומעל SleepNightAdapter, מגדירים שני קבועים עבור סוגי התצוגות.

RecyclerView יצטרך לזהות את סוג התצוגה של כל פריט כדי שניתן יהיה להקצות אליו כראוי בעל תצוגה.

    private val ITEM_VIEW_TYPE_HEADER = 0
    private val ITEM_VIEW_TYPE_ITEM = 1

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

override fun getItemViewType(position: Int): Int {
        return when (getItem(position)) {
            is DataItem.Header -> ITEM_VIEW_TYPE_HEADER
            is DataItem.SleepNightItem -> ITEM_VIEW_TYPE_ITEM
        }
    }

עדכון ההגדרה של SleepNightAdapter

בהגדרה של SleepNightAdapter, יש לעדכן את הארגומנט הראשון של הפונקציה ListAdapter מ-SleepNight ל-DataItem.
בהגדרה של SleepNightAdapter, משנים את הארגומנט הכללי השני של ListAdapter מ-SleepNightAdapter.ViewHolder ל-RecyclerView.ViewHolder. ייתכן שיופיעו שגיאות הקשורות לעדכונים, וכותרת הכיתה אמורה להיראות כך בהמשך.

class SleepNightAdapter(val clickListener: SleepNightListener):
       ListAdapter<DataItem, RecyclerView.ViewHolder>(SleepNightDiffCallback()) {

עדכון onOnViewViewer()

יש לשנות את החתימה של onCreateViewHolder() כדי להחזיר RecyclerView.ViewHolder.

override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): RecyclerView.ViewHolder

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

override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): RecyclerView.ViewHolder {
        return when (viewType) {
            ITEM_VIEW_TYPE_HEADER -> TextViewHolder.from(parent)
            ITEM_VIEW_TYPE_ITEM -> ViewHolder.from(parent)
            else -> throw ClassCastException("Unknown viewType ${viewType}")
        }
    }

עדכון onBindViewHolder()

שינוי סוג הפרמטר onBindViewHolder() מ-ViewHolder ל-RecyclerView.ViewHolder.

override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int)

מוסיפים תנאי כדי להקצות נתונים לבעלי התצוגה המפורטת רק אם הבעלים הם ViewHolder.

        when (holder) {
            is ViewHolder -> {...}

יש להעביר את סוג האובייקט שהוחזר על ידי getItem() אל DataItem.SleepNightItem. הפונקציה onBindViewHolder() אמורה להיראות כך.

  override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int) {
        when (holder) {
            is ViewHolder -> {
                val nightItem = getItem(position) as DataItem.SleepNightItem
                holder.bind(nightItem.sleepNight, clickListener)
            }
        }
    }

עדכון קריאה חוזרת לשיחה (callback)

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

class SleepNightDiffCallback : DiffUtil.ItemCallback<DataItem>() {
    override fun areItemsTheSame(oldItem: DataItem, newItem: DataItem): Boolean {
        return oldItem.id == newItem.id
    }
    @SuppressLint("DiffUtilEquals")
    override fun areContentsTheSame(oldItem: DataItem, newItem: DataItem): Boolean {
        return oldItem == newItem
    }
}

מוסיפים ושולחים את הכותרת

בתוך ה-SleepNightAdapter, מתחת ל-onCreateViewHolder(), מגדירים פונקציה addHeaderAndSubmitList() כפי שמוצג בהמשך. פונקציה זו משתמשת ברשימה של SleepNight. במקום לשלוח את הרשימה submitList() באמצעות הפונקציה ListAdapter, יש להשתמש בפונקציה הזו כדי להוסיף כותרת, ולאחר מכן לשלוח את הרשימה.

fun addHeaderAndSubmitList(list: List<SleepNight>?) {}

בתוך addHeaderAndSubmitList(), אם הרשימה שהועברה היא null, יש להחזיר רק כותרת, אחרת לצרף את הכותרת לראש הרשימה, ולאחר מכן לשלוח את הרשימה.

val items = when (list) {
                null -> listOf(DataItem.Header)
                else -> listOf(DataItem.Header) + list.map { DataItem.SleepNightItem(it) }
            }
submitList(items)

פותחים את SleepTrackerFragment.kt ומשנים את הקריאה ל-submitList() ל-addHeaderAndSubmitList().

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

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

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

יש לשנות את addHeaderAndSubmitList() כדי להשתמש בשגרות:

ברמה העליונה בכיתה SleepNightAdapter, יש להגדיר CoroutineScope עם Dispatchers.Default.

private val adapterScope = CoroutineScope(Dispatchers.Default)

בעוד addHeaderAndSubmitList(), יש להפעיל שגרת מפתח ב-adapterScope כדי להשפיע על הרשימה. לאחר מכן יש לעבור להקשר של Dispatchers.Main כדי לשלוח את הרשימה, כפי שמוצג בקוד הבא.

 fun addHeaderAndSubmitList(list: List<SleepNight>?) {
        adapterScope.launch {
            val items = when (list) {
                null -> listOf(DataItem.Header)
                else -> listOf(DataItem.Header) + list.map { DataItem.SleepNightItem(it) }
            }
            withContext(Dispatchers.Main) {
                submitList(items)
            }
        }
    }

הקוד צריך לבנות ולהפעיל, ולא יהיה שום שינוי.

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

כדי לתקן את רוחב הכותרת, עליך לומר ל-GridLayoutManager מתי לכלול את הנתונים בכל העמודות. כדי לעשות זאת, אפשר להגדיר את SpanSizeLookup ב-GridLayoutManager. זהו אובייקט הגדרה שמשמש את GridLayoutManager כדי לקבוע בכמה טווחים להשתמש עבור כל פריט ברשימה.

פותחים את SleepTrackerFragment.kt.
עליך למצוא את הקוד עם ההגדרה manager, בסוף onCreateView().

val manager = GridLayoutManager(activity, 3)

מתחת ל-manager, מגדירים את manager.spanSizeLookup, כפי שמוצג עליך לבצע object כי setSpanSizeLookup לא מקבל למדה. כדי ליצור object בקוטלין, יש להקליד object : classname, במקרה הזה GridLayoutManager.SpanSizeLookup.

manager.spanSizeLookup = object : GridLayoutManager.SpanSizeLookup() {
}

ייתכן שתקבלו שגיאת מהדר כדי להתקשר לבנאי. אם בחרת לעשות זאת, פתח את תפריט ה-Intent באמצעות Option+Enter (Mac) או Alt+Enter (Windows) כדי להחיל את הקריאה לבנייה.

לאחר מכן תופיע הודעת שגיאה ב-object על כך שעליך לעקוף את השיטות. מציבים את הסמן על object, מקישים על Option+Enter (ב-Mac) או על Alt+Enter (ב-Windows) כדי לפתוח את תפריט הכוונות, ואז מבטלים את השיטה getSpanSize().

בגוף של getSpanSize(), יש להחזיר את גודל הטווח הנכון עבור כל מיקום. למיקום 0 יש טווח טווח 3, ולמיקומים האחרים יש גודל טווח 1. הקוד המלא אמור להיראות כמו הקוד הבא:

    manager.spanSizeLookup = object : GridLayoutManager.SpanSizeLookup() {
            override fun getSpanSize(position: Int) =  when (position) {
                0 -> 3
                else -> 1
            }
        }

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

android:textColor="@color/white_text_color"
android:layout_marginStart="16dp"
android:layout_marginTop="16dp"
android:layout_marginEnd="16dp"
android:background="@color/colorAccent"

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

מעולה! סיימת.

פרויקט ב-Android Studio: RecyclerViewHeaders

כותרת היא בדרך כלל פריט שמתפרס על פני רוחב של רשימה ופועל ככותרת או כמפריד. רשימה יכולה לכלול כותרת אחת שמתארת את תוכן הפריט, או כותרות מרובות כדי לקבץ פריטים ופריטים נפרדים זה מזה.
RecyclerView יכול להשתמש במספר מחזיקי תצוגות כדי לכלול קבוצת פריטים הטרוגרפית. לדוגמה, כותרות ופריטי רשימה.
אחת הדרכים להוסיף כותרות היא לשנות את המתאם כך שישתמש ב-ViewHolder אחר. כדי לעשות זאת, יש לבדוק את האינדקסים שבהם יש להציג את הכותרת. Adapter אחראית למעקב אחר הכותרת.
דרך נוספת להוספת כותרות היא שינוי מערך הנתונים לגיבוי (הרשימה) ברשת הנתונים, וזה מה שעשית ב-codelab זה.

אלו השלבים העיקריים להוספת כותרת:

כדי ליצור תקציר של הנתונים ברשימה: יוצרים DataItem עם כותרת או נתונים.
יש ליצור בעל תצוגה עם פריסה של הכותרת במתאם.
יש לעדכן את המתאם ואת השיטות שלו כדי להשתמש בכל סוג של RecyclerView.ViewHolder.
בonCreateViewHolder(), מחזירים את הסוג הנכון של בעלי צפייה בפריט הנתונים.
יש לעדכן את SleepNightDiffCallback כדי לעבוד עם הכיתה DataItem.
יש ליצור פונקציה ב-addHeaderAndSubmitList() שמשתמשת בפונקציות (corouts) כדי להוסיף את הכותרת למערך הנתונים, ואז לקרוא לפונקציה submitList().
יש להטמיע את GridLayoutManager.SpanSizeLookup() כדי להפוך את הכותרת העליונה לשלוש דפים נוספים בלבד.

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

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

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

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

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

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

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

שאלה 1

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

▦ מתאם יכול להשתמש במספר כיתות ב-ViewHolder כדי לשמור כותרות וסוגים שונים של נתונים.

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

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

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

שאלה 2

מתי להשתמש בשגרות עם RecyclerView? יש לבחור את כל ההצהרות הנכונות.

▚לעולם לא. RecyclerView הוא רכיב בממשק משתמש, ואסור להשתמש בשגרות.

▬ להשתמש בשגרת זמן למשימות ארוכות שיכולות להאט את ממשק המשתמש.

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

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

שאלה 3

מה אסור לך לעשות כשמשתמשים ביותר מViewHolder אחד?

▬ ב-ViewHolder, מספקים קובצי פריסה מרובים כדי להגדיל אותם לפי הצורך.

▬ ב-onCreateViewHolder(), מחזירים את הסוג הנכון של בעלי התצוגה המפורטת עבור הפריט.

▬ ב-onBindViewHolder(), מבצעים הכפפה לנתונים רק אם בעל התצוגה הוא הסוג הנכון של בעל התצוגה עבור הפריט.

הוספה יש לכלול את חתימת הכיתה של המתאם כדי לאשר את RecyclerView.ViewHolder.

מעבר לשיעור הבא: 8.1 קבלת נתונים מהאינטרנט

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