Android Kotlin Fundamentals 02.2: הוספת אינטראקטיביות של משתמש

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

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

מעבדי הקוד בסדרה הזו הם:

• 2.1 פריסה לינארית באמצעות עורך הפריסה
• 2.2 הוספת אינטראקטיביות של משתמש
• 2.3 הגבלת הפריסה באמצעות עורך הפריסה
• 2.4 מידע בסיסי בנוגע לקישור נתונים

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

• יצירת אפליקציה בסיסית ל-Android ב-Kotlin.
• הפעלת אפליקציה ל-Android באמולטור או במכשיר.
• יצירת פריסה לינארית באמצעות Android Studio Editor .
• יצירת אפליקציה פשוטה המשתמשת ב-LinearLayout, ב-TextView, ב-ScrollView ובלחצן עם handler של קליקים.

מה תלמדו

• כיצד לקבל קלט ממשתמשים באמצעות תצוגה של EditText
• כיצד להגדיר טקסט לתצוגה מפורטת TextView באמצעות הטקסט מהתצוגה EditText.
• איך לעבוד עם View ועם ViewGroup.
• איך משנים את הרשאות הגישה של View.

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

• הוספת אינטראקטיביות לאפליקציה aboutMe, שמקורה ב-Codelab קודם.
• יש להוסיף EditText כדי שהמשתמש יוכל להזין טקסט.
• מוסיפים Button ומטמיעים את הגורם המטפל בקליקים.

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

במשימה הזו מוסיפים שדה קלט EditText כדי לאפשר למשתמש להזין כינוי.

שלב 1: מתחילים

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

אפליקציות מעניינות יותר אם המשתמש יכול לבצע פעולות באפליקציה, למשל אם המשתמש יכול להזין טקסט. כדי לקבל קלט טקסט, מערכת Android מספקת ווידג'ט של ממשק משתמש (UI) שנקרא עריכת טקסט. אפשר להגדיר טקסט עריכה באמצעות EditText, סיווג משנה של TextView. טקסט עריכה מאפשר למשתמש להזין ולשנות קלט טקסט, כפי שמוצג בצילום המסך שבהמשך.

שלב 2: הוספת TextText

1. ב-Android Studio, פותחים את קובץ הפריסה activity_main.xml בכרטיסייה עיצוב.
2. בחלונית לוח הצבעים, לוחצים על טקסט.
   
   
   
   Ab TextView, שהוא TextView, מופיע בחלק העליון של רשימת רכיבי הטקסט בחלונית לוח הצבעים. מתחת ל-Ab TextView יש כמה תצוגות של EditText.
   
   בחלונית לוח הצבעים אפשר לראות איך הסמל של TextView מציג את האותיות Ab ללא קו תחתון. עם זאת, הסמלים של EditText מציגים את אבג עם קו תחתון. הקו התחתון מציין שהתצוגה ניתנת לעריכה.
   
   לכל אחת מתצוגות EditText, Android מגדיר מאפיינים שונים, והמערכת מציגה את שיטת הקלט הרגישה המתאימה (כמו מקלדת במסך).
3. גוררים טקסט עריכה של PlainText אל עץ הרכיבים ומציבים אותו מתחת ל-name_text ומעל ל-star_image.
   
   
   
4. בחלונית מאפיינים אפשר להגדיר את המאפיינים הבאים בתצוגה EditText.

מאפיין	ערך
id	nickname_edit
layout_width	match_parent (ברירת מחדל)
layout_height	wrap_content (ברירת מחדל)

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

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

שלב 1: הוספת טקסט של רמז

1. צריך להוסיף משאב מחרוזת חדש לרמז בקובץ string.xml.

<string name="what_is_your_nickname">What is your Nickname?</string>

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

2. בחלונית מאפיינים אפשר להגדיר את המאפיינים הבאים לתצוגה המפורטת EditText:

מאפיין	ערך
style	NameStyle
textAlignment	(מרכז)
hint	@string/what_is_your_nickname

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

שלב 2: מגדירים את מאפיין InputType

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

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

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

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

הגדרת סוג הקלט לשדה הכינוי:

1. יש להגדיר את המאפיין inputType לערך textPersonName לטקסט העריכה של nickname_edit.
2. בחלונית עץ הרכיבים, מופיעה אזהרה לגבי autoFillHints. האזהרה הזו לא חלה על האפליקציה הזו והיא לא נכללת בהיקף של קוד ה-Lab הזה. אפשר להתעלם ממנה. (מידע נוסף על מילוי אוטומטי זמין במאמר אופטימיזציה של האפליקציה למילוי אוטומטי).
   
3. בחלונית מאפיינים, מאמתים את הערכים של המאפיינים הבאים בתצוגה המפורטת EditText:

מאפיין	ערך
id	nickname_edit
layout_width	match_parent (ברירת מחדל)
layout_height	wrap_content (ברירת מחדל)
style	@style/NameStyle
inputType	textPersonName
hint	"@string/what_is_your_nickname"
text	(ריק)

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

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

שלב 1: הוספת לחצן 'סיום'

1. גוררים לחצן מהחלונית לוח הצבעים אל עץ הרכיבים. ממקמים את הלחצן שמתחת לטקסט nickname_edit של העריכה.
   
   
2. יוצרים משאב מחרוזת חדש בשם done. מזינים למחרוזת ערך של Done,

<string name="done">Done</string>

3. בחלונית מאפיינים אפשר להגדיר את המאפיינים הבאים בתצוגה החדשה שנוספה ל-Button:

מאפיין	ערכים
id	done_button
text	@string/done
layout_gravity	center_horizontal
layout_width	wrap_content

המאפיין layout_gravity מרכז את התצוגה בפריסת ההורה שלה, LinearLayout.

4. שינוי הסגנון ל-Widget.AppCompat.Button.Colored, שהוא אחד מהסגנונות המוגדרים מראש שמערכת Android מספקת. אפשר לבחור את הסגנון מהתפריט הנפתח או מהחלון משאבים.
   
   
   
   הסגנון הזה משנה את צבע הלחצן להדגשה, colorAccent. הצבע המשני מוגדר בקובץ res/values/colors.xml.
   
   
   

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

קובץ colors.xml לדוגמה:

<?xml version="1.0" encoding="utf-8"?>
<resources>
   <color name="colorPrimary">#008577</color>
   <color name="colorPrimaryDark">#00574B</color>
   <color name="colorAccent">#D81B60</color>
</resources>

שלב 2: עיצוב הלחצן 'סיום'

1. בחלונית מאפיינים, מוסיפים שוליים בחלק העליון על ידי בחירה באפשרות Layout_Margin > Top. הגדרה של השוליים העליונים לערך layout_margin, המוגדרת בקובץ dimens.xml.
   
   
   
2. צריך להגדיר את המאפיין fontFamily כroboto בתפריט הנפתח.
   
   
   
3. עוברים לכרטיסייה טקסט ומאמתים את קוד ה-XML שנוצר עבור הלחצן החדש שנוסף.
   

<Button
   android:id="@+id/done_button"
   style="@style/Widget.AppCompat.Button.Colored"
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"
   android:layout_gravity="center_horizontal"
   android:layout_marginTop="@dimen/layout_margin"
   android:fontFamily="@font/roboto"
   android:text="@string/done" />

שלב 3: משנים את המשאב של הצבע

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

1. יש לפתוח את res/values/colors.xml ולשנות את הערך של colorAccent ל-#76bf5e.
   

<color name="colorAccent">#76bf5e</color>

ניתן לראות את הצבע התואם לקוד ה-HEX, בשוליים השמאליים של עורך הקבצים.

שימו לב לשינוי בצבע הלחצן בעורך העיצוב.

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

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

שלב 1: הוספת ה-TextView אל הכינוי

1. גוררים תצוגת טקסט מהחלונית לוח צבעים לעץ הרכיבים. ממקמים את תצוגת הטקסט מתחת ל-done_button ומעל ל-star_image.
   
   

2. בחלונית מאפיינים אפשר להגדיר את המאפיינים הבאים לתצוגה המפורטת החדשה ב-TextView:

מאפיין	ערך
id	nickname_text
style	NameStyle
textAlignment	(מרכז)

שלב 2: משנים את הרשאות הגישה לתצוגת הטקסט

אפשר להציג או להסתיר צפיות באפליקציה באמצעות המאפיין visibility. למאפיין הזה יש אחד משלושה ערכים:

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

1. בחלונית מאפיינים, מגדירים את ה-visibility של תצוגת הטקסט nickname_text ל-gone, כי לא רוצים שהאפליקציה תופיע בתצוגה הראשונה של הטקסט הזה.
   
   
   
   שימו לב שכשמשנים את המאפיין בחלונית מאפיינים, התצוגה nickname_text נעלמת מעורך העיצוב. התצוגה מוסתרת בתצוגה המקדימה של הפריסה.
2. משנים את ערך המאפיין text של התצוגה המפורטת nickname_text למחרוזת ריקה.

קוד ה-XML שנוצר עבור TextView אמור להיראות כך:

<TextView
   android:id="@+id/nickname_text"
   style="@style/NameStyle"
   android:layout_width="match_parent"
   android:layout_height="wrap_content"
   android:textAlignment="center"
   android:visibility="gone"
   android:text="" />

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

פונקציית handler של קליק באובייקט Button (או בכל תצוגה אחרת) מציינת את הפעולה שיש לבצע כשמקישים על הלחצן (תצוגה). הפונקציה שמטפלת באירוע הקליק צריכה להטמיע ב-Activity שמארח את הפריסה עם הלחצן (תצוגה).

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

private fun clickHandlerFunction(viewThatIsClicked: View) {
// Add code to perform the button click event
}

אפשר לצרף את הפונקציה של חיישן הקליקים לאירועי לחיצה על לחצן בשתי דרכים:

• בפריסה של ה-XML, אפשר להוסיף את המאפיין android:onClick לרכיב <Button>. למשל:

<Button
   android:id="@+id/done_button"
   android:text="@string/done"
   ...
   android:onClick="clickHandlerFunction"/>

OR

• אפשר לעשות זאת באופן פרוגרמטי בזמן ריצה, בonCreate() מתוך Activity. לשם כך, יש להתקשר למספר setOnClickListener. למשל:

myButton.setOnClickListener {
   clickHanderFunction(it)
}

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

הפונקציה של מפעיל הקליקים, שנקראת addNickname, תבצע את הפעולות הבאות:

• קבל את הטקסט מטקסט העריכה של nickname_edit.
• הגדרת הטקסט בתצוגת הטקסט nickname_text.
• הסתרה של טקסט העריכה ושל הלחצן.
• הצגת הכינוי TextView.

שלב 1: הוספת event listener

1. ב-Android Studio, בתיקייה java פותחים את הקובץ MainActivity.kt.
2. ב-MainActivity.kt, מתוך המחלקה MainActivity, מוסיפים פונקציה בשם addNickname. יש לכלול פרמטר קלט בשם view מסוג View. הפרמטר view הוא View שבו הפונקציה מופעלת. במקרה כזה, view יהיה מופע של הלחצן סיום.

private fun addNickname(view: View) {
}

3. בפונקציה addNickname, משתמשים ב-findViewById() כדי לקבל הפניה לטקסט nickname_edit ולערוך את nickname_text.

val editText = findViewById<EditText>(R.id.nickname_edit)
val nicknameTextView = findViewById<TextView>(R.id.nickname_text)

4. יש להגדיר את הטקסט בתצוגת הטקסט nicknameTextView שהמשתמש הזין בeditText, כדי לקבל את הטקסט מנכס text.

nicknameTextView.text = editText.text

5. הסתרת המאפיין EditText של הכינוי על ידי הגדרת הנכס visibility של editText כ-View.GONE.

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

editText.visibility = View.GONE

6. כדי להסתיר את הלחצן סיום, מגדירים את הנכס visibility כ-View.GONE. האסמכתה של הלחצן& היא 2#99; view.

view.visibility = View.GONE

7. בסוף הפונקציה addNickname, אפשר להציג את הכינוי TextView על ידי הגדרת המאפיין visibility כ-View.VISIBLE.

nicknameTextView.visibility = View.VISIBLE

שלב 2: צירוף לחצן ההאזנה ללחצן 'סיום'

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

1. בMainActivity.kt, בסוף הפונקציה onCreate(), מקבלים הפניה לתצוגה סיוםButton. צריך להשתמש בפונקציה findViewById() ולהתקשר אל setOnClickListener. יש להעביר הפניה לפונקציה של חיישן הקליקים, addNickname().

findViewById<Button>(R.id.done_button).setOnClickListener {
            addNickname(it)
        }

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

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

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

שלב 3: הסתרת המקלדת

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

1. ב-MainActivity.kt, בסוף הפונקציה addNickname(), מוסיפים את הקוד הבא. למידע נוסף על אופן הפעולה של הקוד הזה, ניתן לעיין בתיעוד של hideSoftInputFromWindow.

// Hide the keyboard.
val inputMethodManager = getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
inputMethodManager.hideSoftInputFromWindow(view.windowToken, 0)

2. מפעילים שוב את האפליקציה. הערה: אחרי שמקישים על סיום, המקלדת מוסתרת.

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

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

שלב 1: הוספת event listener

1. בMainActivity, מוסיפים פונקציה של האזנה לקליק שנקראת updateNickname(view: View) לתצוגת הטקסט של הכינוי.

private fun updateNickname (view: View) {
}

2. בתוך הפונקציה updateNickname, מקבלים הפניה לטקסט העריכה של nickname_edit, ומעיינים בלחצן הסיום. כדי לעשות זאת, צריך להשתמש בשיטה findViewById().

val editText = findViewById<EditText>(R.id.nickname_edit)
val doneButton = findViewById<Button>(R.id.done_button)

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

editText.visibility = View.VISIBLE
doneButton.visibility = View.VISIBLE
view.visibility = View.GONE

4. ב-MainActivity.kt, בסוף הפונקציה onCreate(), יש להתקשר אל setOnClickListener בתצוגת הטקסט nickname_text. יש להפנות לפונקציית חיישן הקליקים, שהיא updateNickname().

findViewById<TextView>(R.id.nickname_text).setOnClickListener {
   updateNickname(it)
}

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

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

שלב 2: הגדרת המיקוד לתצוגת עריכה של הטקסט והצגת המקלדת

1. בסוף הפונקציה updateNickname, מגדירים את המיקוד לתצוגה המפורטת EditText. יש להשתמש בשיטה requestFocus().

// Set the focus to the edit text.
editText.requestFocus()

2. בסוף הפונקציה updateNickname, צריך להוסיף קוד כדי שהמקלדת תהיה גלויה.

// Show the keyboard.
val imm = getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
imm.showSoftInput(editText, 0)

שלב 3: הוספת צבע רקע לכינוי של תצוגת הטקסט

1. יש להגדיר את צבע הרקע של תצוגת הטקסט nickname_text כ-@color/colorAccent ולהוסיף מרווח פנימי תחתון של @dimen/small_padding. שינויים אלה ישמשו כרמז למשתמש על כך שתצוגת הטקסט של הכינוי ניתנת ללחיצה.

android:background="@color/colorAccent"
android:paddingBottom="@dimen/small_padding"

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

עכשיו הגיע הזמן להראות את האפליקציה האינטראקטיבית MeMe לחברים!

פרויקט ב-Android Studio: מידע עלInteractiveInteractive

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

פונקציות מסוג Click listener

• אפשר להגדיר שכל תגובה ת להקיש על View על ידי הוספת event listener.
• הפונקציה שמגדירה את event listener מקבלת את ה-View שעליו לוחצים.

אפשר לצרף פונקציה של חיישן קליק ל-View באחת משתי דרכים:

• בפריסה של ה-XML, מוסיפים את המאפיין android:onClick לרכיב <View>.
• באופן פרוגרמטי, יש להשתמש בפונקציה setOnClickListener(View.OnClickListener) במערכת Activity המתאימה.

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

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

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

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

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

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

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

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

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

שאלה 1

מהי EditText סיווג משנה?

• View
• LinearLayout
• TextView
• Button

שאלה 2

אילו מהערכים של המאפיין הבא של visibility, אם הם הוגדרו בתצוגה מפורטת, הופכים אותם לתצוגה מוסתרת ולא תופסת מקום בפריסה?

• visible
• Invisible
• gone
• hide

שאלה 3

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

• True
• לא נכון

שאלה 4

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

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

מעבר לשיעור הבא: 2.3: הגבלת הפריסה באמצעות עורך הפריסה

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