PracticU

Fragment Lifecycle

בלי כתוביותעם כתוביות
PracticU › קורס פיתוח אפליקציות - לאנדרואיד - Android - ב-JAVA › Fragment Lifecycle
מילון מושגים:
Fragment - ב-Android, רכיב ממשק הניתן לשימוש חוזר בתוך Activity, שמייצג חלק ממסך או התנהגות.
Activity - ב-Android, רכיב שמייצג מסך יחיד של האפליקציה שאיתו המשתמש מתקשר.
אירוע - התרחשות שהמערכת מזהה ויכולה להגיב לה, כמו לחיצת עכבר, הקשה או סיום פעולה.
לייאאוט - ארגון וסידור הרכיבים החזותיים על המסך או בדף, כמו מיקום כפתורים, טקסט ותמונות.
View - רכיב שאחראי על הצגת המידע למשתמש (התצוגה) בדפוס MVC. גם טבלה וירטואלית מבוססת שאילתה במסד נתונים.
ArrayList - מבנה נתונים של רשימה דינמית שגודלה משתנה, הנפוץ בשפות כמו Java ו-C#.

Fragment Lifecycle
לפרגמנט יש מחזור חיים משלה, במקביל למחזור החיים של האקטיביטי. ההרצאה עוברת על התרשים מתוך התיעוד של אנדרואיד ומסבירה מה קורה בכל שלב.
איך זה עובד
1. הוספה לאקטיביטי: מתחילים ב-onAttach, ואחריו onCreate, onCreateView ו-onActivityCreated. האחרון מבלבל, כי האקטיביטי כבר קיימת. האירוע פשוט מופעל כשהפרגמנט משתלבת איתה. לאחר מכן onStart ו-onResume, והפרגמנט פעילה ומקבלת אירועים מהמשתמש.
2. הרס מלא: כשהפרגמנט מוסרת, מוחלפת או שהמשתמש חוזר אחורה, מתבצעים onPause, onStop, onDestroyView, onDestroy ו-onDetach.
3. הכנסה ל-back stack: כשמציגים פרגמנט נוספת מעליה, אפשר להכניס את הראשונה ל-back stack, והיא תיחשב כמו אקטיביטי בתוכו. לדוגמה שלושה מסכים ברצף: שם, כרטיס אשראי ואישור קנייה.
4. מה קורה לפרגמנט ב-back stack: מתבצעים onPause, onStop ו-onDestroyView. בלחיצה על Back חוזרים ל-onCreateView, ואז onActivityCreated, onStart ו-onResume.
ההבדל בין onCreate ל-onCreateView
באקטיביטי ה-layout מוגדר ב-onCreate, אבל בפרגמנט זה תפקיד onCreateView, שמנפחת (inflate) את ה-view ומחזירה אותו. ב-onCreate של הפרגמנט מגדירים נתונים שהיא צריכה פעם אחת, כמו adapter או ArrayList של רשימה, ואחר כך ה-view משתמש בהם.
בהרצאות הבאות נראה אילו אירועים משמשים לאיזה קוד.
אחרי ההרצאה אפשר לקרוא את תרשים מחזור החיים של פרגמנט ולדעת איפה למקם קוד.
השיעור הבא בקורס: שימוש ב-Fragment בעזרת XML

פרקי ההרצאה: Fragment Lifecycle

  1. 00:00

    תרשים ה-Life Cycle בדוקומנטציה

  2. 00:39

    אירועים בהוספת Fragment ל-Activity

  3. 01:37

    אירועים בהריסת Fragment

  4. 02:16

    הכנסת Fragment ל-Back Stack

  5. 03:11

    חזרה מה-Back Stack ל-onCreateView

תמלול ההרצאה: Fragment Lifecycle

הטקסט המלא של הדקות הראשונות בהרצאה «Fragment Lifecycle» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.

  1. 00:01

    בואו נתבונן ב-Fragment Life Cycle. אמרנו של-Fragment יש Life Cycle במקביל ל-Activity ובנוסף ל-Life Cycle של Activity. אז יש לנו כאן איזשהו מאמר מהדוקומנטציה של אנדרואיד שפשוט מפרט ממש שלב-שלב מה-Life Cycle של-Fragment.

  2. 00:23

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

  3. 00:39

    אז ברגע שהוספנו את הפרגמנט לאקטיביטי, אז יש לנו פה את onAttach, onCreate, onCreateView, onActivityCreated, שזה קצת מבלבל מפני שהאקטיביטי כבר מוכנה, אז איך זה יכול להיות שהיא נוצרת?

  4. 00:56

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

  5. 01:16

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

  6. 01:30

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

  7. 01:51

    אם זה קורה, אז מה שקורה זה שיש לנו פה onPause, onStop, onDestroyView, onDestroy, onDetach, ואז הפרגמנט נחשבת כנהרסת לחלוטין, נהרסה לחלוטין.

  8. 02:07

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

  9. 02:29

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

  10. 02:53

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

  11. 03:04

    ואנחנו רוצים לאפשר ליוזר לחזור אחורה בין הפריגמנטים. אז אנחנו יכולים לגרום לפריגמנט להיכנס גם לבקסטק. במצב כזה, מה שקורה לפריגמנט שנכנסה לבקסטק, יש לנו onPause, onStop ו-onDestroyView.

  12. 03:21

    כאשר ה-user מבצע back מהפריגמנט העליונה וחוזר בחזרה לפריגמנט שאנחנו מדברים עליה, אז אנחנו רואים פה את הקו הזה, ואנחנו חוזרים בחזרה ל-onCreateView, ואז ממשיכים onActivityCreated, onStart, onResume, והפריגמנט מוצגת.

  13. 03:41

    אז יש לנו פה כל מיני אירועים של life cycle של פריגמנט, וחשוב רק לעשות או להבהיר דגש בין onCreate ל-onCreateView.

לקורס המלא: קורס פיתוח אפליקציות לאנדרואיד

ההרצאה הקודמת: הסבר על Fragment

ההרצאה הבאה: שימוש ב-Fragment בעזרת XML

הרצאות קשורות מקורסים אחרים

  • פונקציות Lifecycle Hooks

קורסים נוספים במסלול

  • קורס יסודות התכנות - שפת JAVA - קורס ג'אווה למתחילים
  • קורס פיתוח אפליקציות - לאייפון iPhone iOS - ב-Swift-Xcode
  • קורס פלאטר - Flutter - שפת DART של גוגל למובייל - פיתוח אפליקציות לאנדרואיד ואייפון
  • קורס PhoneGap - פיתוח אפליקציות לאנדרואיד ואייפון