Android Kotlin Fundamentals 04.2: מצבים מורכבים של מחזור חיים

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

מבוא

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

מה כבר צריך לדעת

• מהי פעילות ואיך ליצור פעילות באפליקציה.
• היסודות של מחזורי החיים של Activity ו-Fragment, וקריאות חוזרות (callbacks) שמופעלות כשפעילות עוברת בין מצבים.
• איך לעקוף את שיטות הקריאה החוזרת של מחזור החיים של onCreate() ושל onStop() כדי לבצע פעולות בזמנים שונים בפעילות או במחזור החיים של שבר.

מה תלמדו

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

מה צריך לעשות

• משנים את אפליקציית DessertClicker כך שתכלול פונקציית טיימר, ומתחילים ומפסיקים את הטיימר הזה במחזור החיים של הפעילות.
• עליך לשנות את האפליקציה לשימוש בספריית מחזור החיים של Android, ולהמיר את הכיתה ל-DessertTimer לצופה במחזור החיים.
• כדאי להגדיר את גשר ניפוי הבאגים ב-Android (adb) ולהשתמש בו כדי לדמות את כיבוי התהליך של האפליקציה ואת הקריאה החוזרת (callback) על מחזור החיים.
• צריך להשתמש בשיטה onSaveInstanceState() כדי לשמור נתוני אפליקציות שעשויים ללכת לאיבוד אם האפליקציה תיסגר באופן בלתי צפוי. יש להוסיף קוד כדי לשחזר את הנתונים האלה כאשר האפליקציה מופעלת מחדש.

ב-codelab זה תרחיבו את אפליקציית DessertClicker מ-codelab הקודם. מוסיפים טיימר ברקע ולאחר מכן ממירים את האפליקציה לשימוש בספריית מחזור החיים של Android.

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

שלב 1: הגדרת טיימר לקינוח

1. פותחים את אפליקציית DessertClicker ממעבדת הקוד האחרונה. (ניתן להוריד את DessertClickerLogs כאן אם האפליקציה לא מותקנת במכשיר).
2. בתצוגה Project (פרויקט), מרחיבים את java > com.example.android.dessertclicker ופותחים את DessertTimer.kt. הערה: נכון לעכשיו, כל הקוד מוזכר בתגובה, ולכן הוא לא פועל כחלק מהאפליקציה.
3. בוחרים את כל הקוד בחלון העורך. בוחרים באפשרות Code > תגובה עם Line Response או מקישים על Control+/ (Command+/ ב-Mac). הפקודה הזו לא מבטלת את הקוד כולו בקובץ. (ייתכן שמערכת Android Studio תציג שגיאות הפניה שלא נפתרו עד לבנות את האפליקציה מחדש).
4. שימו לב: הכיתה DessertTimer כוללת את startTimer() ואת stopTimer(), שמפעילים ומפסיקים את הטיימר. כאשר startTimer() פועל, הטיימר מדפיס הודעת יומן לכל שנייה, עם המספר הכולל של השניות שבהן הזמן פעלו. השיטה stopTimer() מפסיקה את הטיימר ואת דוחות היומן.
   

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

5. פתיחת MainActivity.kt בחלק העליון של הכיתה, מתחת למשתנה dessertsSold, מוסיפים משתנה לטיימר:
   

private lateinit var dessertTimer : DessertTimer;

6. יש לגלול למטה אל onCreate() וליצור אובייקט DessertTimer חדש, מיד לאחר הקריאה אל setOnClickListener():
   

dessertTimer = DessertTimer()

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

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

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

1. בשיעור MainActivity, מתחילים את הטיימר בקריאה החוזרת (onStart()):
   

override fun onStart() {
   super.onStart()
   dessertTimer.startTimer()

   Timber.i("onStart called")
}

2. הפסקת הטיימר בonStop():
   

override fun onStop() {
   super.onStop()
   dessertTimer.stopTimer()

   Timber.i("onStop Called")
}

3. הידור והפעלה של האפליקציה. ב-Android Studio, לוחצים על החלונית Logcat . בתיבת החיפוש של Logcat, מזינים dessertclicker. מסנן זה יסנן לפי הכיתות MainActivity וגם DessertTimer. חשוב לציין שברגע שהאפליקציה מתחילה, הטיימר מתחיל לפעול מיד.
   
4. לוחצים על הלחצן הקודם ומציינים שהטיימר מפסיק שוב. הטיימר מפסיק כי הפעילות וגם הטיימר ששולטים הרוסים.
5. יש להשתמש במסך התגובות האחרונות כדי לחזור לאפליקציה. לתשומת ליבך, ב-Logcat הטיימר מופעל מחדש מ-0.
6. לוחצים על הלחצן שיתוף. שימו לב שהטיימר ב-Logcat עדיין פועל.
   
   
7. לוחצים על הלחצן דף הבית. שימו לב ב-Logcat שהטיימר מפסיק לפעול.
8. מסך 'אחרונים' מאפשר לחזור לאפליקציה. חשוב לשים לב ב-Logcat שהטיימר מופעל שוב מהמקום שבו הופסק.
9. בעוד MainActivity, יש להוסיף את השיחה אל stopTimer() בשיטת onStop(). התגובה stopTimer() מציגה את המקרה שבו התחלת פעולה באפליקציה onStart(), אבל חשוב לזכור לעצור אותה שוב בעוד onStop().
10. הידור והפעלה של האפליקציה, ולחיצה על לחצן דף הבית אחרי שהטיימר מתחיל. האפליקציה פועלת ברקע, אבל הטיימר פועל וממשיך במשאבי המערכת. המשך ההפעלה של הטיימר הוא דליפת זיכרון לאפליקציה שלך, וככל הנראה לא ההתנהגות הרצויה.
    
    הדפוס הכללי הוא שכאשר מגדירים או מתחילים משהו בקריאה חוזרת (callback), מתבצעת עצירה או הסרה של הפעולה הזו בקריאה החוזרת (callback). כך אפשר להימנע מלהפעיל פריטים כשהם לא צריכים אותם יותר.

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

11. יש לבטל את ההערה על השורה ב-onStop() שבה מפסיקים את הטיימר.
12. יש לחתוך ולהדביק את שיחת startTimer() מ-onStart() ל-onCreate(). השינוי הזה מדגים את המקרה שבו גם אתה מפעיל ומשאב משאב ב-onCreate(), במקום להשתמש ב-onCreate() כדי להפעיל אותו וגם ב-onStart() כדי להפעיל אותו.
13. מכינים את האפליקציה ומפעילים אותה. שימו לב שהטיימר מתחיל לפעול, כפי שציפיתם.
14. לוחצים על 'דף הבית' כדי להפסיק את השימוש באפליקציה. הטיימר מפסיק לפעול, כפי שציפיתם.
15. במסך האחרון, אפשר להשתמש במסך האחרון כדי לחזור לאפליקציה. לתשומת ליבך, הטיימר לא מתחיל שוב במקרה הזה, כי onCreate() מופעל רק כשהאפליקציה מתחילה – היא לא נשלחת כשאפליקציה חוזרת לחזית.

נקודות עיקריות שכדאי לזכור:

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

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

באפליקציה מורכבת יותר של Android, אפשר להגדיר הרבה דברים ב-onStart() או ב-onCreate() ולנתק אותם מ-onStop() או מ-onDestroy(). לדוגמה, ייתכן שיהיו לכם אנימציות, מוזיקה, חיישנים או טיימרים שאתם צריכים גם להגדיר ולפרוע מהם, וגם להתחיל ולהפסיק את השידור. אם שוכחים את התג, הבאג עלול לגרום לבאגים ולכאבי ראש.

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

ספריית מחזור החיים כוללת שלושה חלקים עיקריים:

• בעלים של מחזור חיים, שהם הרכיבים שיש להם (ולכן גם "owner"). Activity וגם Fragment הם בעלים של מחזור חיים. בעלי מחזור החיים מטמיעים את הממשק LifecycleOwner.
• המחלקה Lifecycle, שמחזיקה את המצב בפועל של בעלי מחזור החיים ומפעילה אירועים כאשר מתרחשים שינויים במחזור החיים.
• צופים במחזור החיים, המתעדים את מצב מחזור החיים ומבצעים משימות כאשר מחזור החיים משתנה. צופים במחזור חיים מטמיעים את הממשק LifecycleObserver.

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

שלב 1: הופכים את טיימר הקינוח למחזור חיים

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

1. פותחים את הכיתה ב-DesertTimer.kt.
2. משנים את חתימת הכיתה של הכיתה ב-DessertTimer כדי להיראות כך:
   

class DessertTimer(lifecycle: Lifecycle) : LifecycleObserver {

הגדרת הכיתה החדשה עושה זאת:

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

3. מתחת למשתנה runnable, מוסיפים בלוק init להגדרת הכיתה. בבלוק init, יש להשתמש בשיטה addObserver() כדי לחבר את האובייקט של מחזור החיים שהועבר מהבעלים (הפעילות) לכיתה הזו (הצופה).
   

 init {
   lifecycle.addObserver(this)
}

4. יש להוסיף הערה לstartTimer() באמצעות ה@OnLifecycleEvent annotation, ולהשתמש באירוע ON_START של מחזור החיים. כל אירועי מחזור החיים שצופים במחזור החיים יכולים לראות הם בקטגוריה Lifecycle.Event.

@OnLifecycleEvent(Lifecycle.Event.ON_START)
fun startTimer() {

5. חוזרים על הפעולה של stopTimer(), באמצעות האירוע ON_STOP:

@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
fun stopTimer()

שלב 2: משנים את הפעילות הראשית

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

1. פתיחת MainActivity בשיטה onCreate(), יש לשנות את האתחול של DessertTimer כך שיכלול את this.lifecycle:

dessertTimer = DessertTimer(this.lifecycle)

הנכס lifecycle של הפעילות מכיל את האובייקט Lifecycle שבבעלותו.

2. יש להסיר את השיחה אל startTimer() בעוד onCreate(), ואת השיחה אל stopTimer() בעוד onStop(). אין צורך לומר ל-DessertTimer מה לעשות בפעילות הזו יותר, כי DessertTimer צופה עכשיו במחזור החיים עצמו ומתעדכן באופן אוטומטי כאשר מצב מחזור החיים משתנה. כל מה שצריך לעשות בהתקשרות החוזרת הזו הוא לתעד הודעה.
3. הידור והפעלה של האפליקציה ופתיחת יומן הרישום. שימו לב שהטיימר התחיל לפעול, כצפוי.
4. לוחצים על הלחצן הראשי כדי להעביר את האפליקציה לרקע. שימו לב שהטיימר הפסיק לפעול כצפוי.

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

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

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

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

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

הערה: לפני שמתחילים, צריך לוודא שאתם מפעילים אמולטור או מכשיר שתומך ב-API 28 ואילך.

שלב 1: משתמשים ב-Adb כדי לדמות סגירת תהליך

ממשק הגישור של Android (adb) הוא כלי שורת פקודה שמאפשר לך לשלוח הוראות לאמולטורים ולמכשירים המחוברים למחשב. בשלב זה, צריך להשתמש ב-adb כדי לסגור את תהליך האפליקציה ולראות מה קורה כש-Android משביתה את האפליקציה.

1. הידור והפעלה של האפליקציה. לוחצים על קאפקייק כמה פעמים.
2. לוחצים על לחצן הבית כדי להעביר את האפליקציה לרקע. האפליקציה שלך מופסקת, והאפליקציה עשויה להיסגר אם מערכת Android תדרוש את המשאבים המשמשים אותה.
3. ב-Android Studio, לוחצים על הכרטיסייה Terminal כדי לפתוח את המסוף של שורת הפקודה.
4. יש להקליד adb וללחוץ על Return.
   
   אם מופיע הרבה פלט שמתחיל ב-Android Debug Bridge version X.XX.X ומסתיים ב-tags to be used by logcat (see logcat —halp), הכול בסדר. אם במקום זאת מופיע הכיתוב adb: command not found, יש לוודא שהפקודה adb זמינה בנתיב הביצוע. לקבלת הוראות, אפשר לעיין ב "הוספת adb בנתיב הביצוע
5. אפשר להעתיק את התגובה הזו ולהדביק אותה בשורת הפקודה וללחוץ על Return:
   

adb shell am kill com.example.android.dessertclicker

פקודה זו מורה לכל המכשירים המחוברים או האמולטורים להפסיק את התהליך עם שם החבילה של dessertclicker, אבל רק אם האפליקציה פועלת ברקע. מאחר שהאפליקציה שלך פועלת ברקע, לא מוצג שום דבר במכשיר או במסך האמולטור כדי לציין שהתהליך שלך הופסק. ב-Android Studio, לוחצים על הכרטיסייה Run כדי להציג את ההודעה "Applicationפת." לוחצים על הכרטיסייה Logcat כדי לראות שהקריאה החוזרת של onDestroy() מעולם לא הופעלה — הפעילות שלכם פשוט הסתיימה.

6. מסך 'אחרונים' מאפשר לחזור לאפליקציה. האפליקציה מופיעה לאחרונה, גם אם היא הועברה לרקע או הופסקה לגמרי. כשמשתמשים במסך האחרון כדי לחזור לאפליקציה, הפעילות מתחילה מחדש. הפעילות עוברת דרך כל הקבוצה של קריאה חוזרת (callback) למחזור חיים, כולל onCreate().
7. הערה: כשהאפליקציה מופעלת מחדש, היא מאפסת את "score" (גם את מספר הקינוחים שנמכרו וגם את הסכום הכולל בדולרים) לערכי ברירת המחדל (0). אם Android כבה את האפליקציה, למה היא לא שמרה את המדינה?
   
   אם מערכת ההפעלה תפעיל מחדש את האפליקציה עבורך, מערכת Android תנסה כמיטב יכולתה לאפס את האפליקציה למצב הקודם. Android לוקח את המצב של חלק מהתצוגות ושומר אותו בחבילה כאשר יוצאים מהפעילות. הנה כמה דוגמאות לנתונים שנשמרים באופן אוטומטי: הטקסט שלהם ב-EditText (כל עוד יש להם מזהה בפריסה) וערימה האחורית של הפעילות.
   
   לפעמים, מערכת ההפעלה Android לא יודעת על כל הנתונים שלך. לדוגמה, אם יש לך משתנה מותאם אישית כמו revenue באפליקציית DessertClicker, מערכת ההפעלה של Android לא יודעת פרטים על הנתונים האלה או על החשיבות שלהם לפעילות שלך. תצטרכו להוסיף את הנתונים האלה לחבילה בעצמכם.

שלב 2: משתמשים ב-onSaveInstanceState() כדי לשמור נתוני חבילות

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

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

1. ב-MainActivity, אפשר לבטל את הקריאה החוזרת (onSaveInstanceState()) חזרה ולהוסיף הצהרת יומן של Timber.
   

override fun onSaveInstanceState(outState: Bundle) {
   super.onSaveInstanceState(outState)

   Timber.i("onSaveInstanceState Called")
}

הערה: יש שתי שינויים של onSaveInstanceState(), אחד עם פרמטר outState בלבד, ואחד עם פרמטרים של outState ו-outPersistentState. יש להשתמש בפרמטר שמופיע בקוד שלמעלה עם הפרמטר היחיד outState.

2. הידור והפעלה של האפליקציה, ולחיצה על הלחצן דף הבית כדי להעביר אותה לרקע. חשוב לציין שההתקשרות החוזרת של onSaveInstanceState() מתבצעת רק אחרי onPause() ו-onStop():
   
3. בחלק העליון של הקובץ, ממש לפני הגדרת הכיתה, מוסיפים את הקבועים הבאים:

const val KEY_REVENUE = "revenue_key"
const val KEY_DESSERT_SOLD = "dessert_sold_key"
const val KEY_TIMER_SECONDS = "timer_seconds_key"

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

4. יש לגלול למטה אל onSaveInstanceState() ולראות את הפרמטר outState, מסוג Bundle.
   
   חבילה היא אוסף של צמדי מפתח/ערך, שבהם המפתחות הם תמיד מחרוזות. אפשר להוסיף לחבילה ערכים מהדור הישן, כמו int ו-boolean.
   המערכת הזו שומרת את החבילה הזו ב-RAM, לכן מומלץ לשמור על כמות קטנה של נתונים בחבילה. גם גודל החבילה הזו מוגבל, אבל הגודל משתנה ממכשיר למכשיר. באופן כללי, מומלץ לאחסן הרבה פחות מ-100,000, אחרת עלול לסכן את האפליקציה שלך עם השגיאה TransactionTooLargeException.
   
5. ב-onSaveInstanceState(), מזינים את הערך revenue (מספר שלם) בחבילה עם השיטה putInt():
   

outState.putInt(KEY_REVENUE, revenue)

השיטה putInt() (ושיטות דומות מהמחלקה Bundle כמו putFloat() ו-putString() מקבלות שני ארגומנטים: מחרוזת למפתח (קבוע KEY_REVENUE) והערך בפועל לשמירה.

6. חוזרים על אותו תהליך עם מספר הקינוחים שנמכרים ואת הסטטוס של הטיימר:

outState.putInt(KEY_DESSERT_SOLD, dessertsSold)
outState.putInt(KEY_TIMER_SECONDS, dessertTimer.secondsCount)

שלב 3: משתמשים ב-onCreate() כדי לשחזר את נתוני החבילה

1. גוללים למעלה עד onCreate() ובודקים את החתימה של השיטה:

override fun onCreate(savedInstanceState: Bundle) {

חשוב לשים לב שהערך onCreate() מקבל Bundle בכל פעם שמתקשרים אליו. לאחר הפעלה מחדש של הפעילות עקב כיבוי התהליך, החבילה ששמרתם מועברת אל onCreate(). אם הפעילות מתחילה מחדש, החבילה הזו ב-onCreate() היא null. לכן, אם החבילה היא לא null, זה אומר שאתם &יוצרים מחדש את הפעילות מנקודה קודמת.

הערה: אם הפעילות נוצרת מחדש, השיחה החוזרת ב-onRestoreInstanceState() תיקרא אחרי onStart(), גם אם החבילה תופיע. ברוב המקרים, מתבצע שחזור של מצב הפעילות ב-onCreate(). אבל אם בוצעה קריאה אל onRestoreInstanceState() אחרי onStart(), אם יהיה צורך לשחזר מצב כלשהו אחרי השיחה של onCreate(), תהיה לך אפשרות להשתמש ב-onRestoreInstanceState().

2. יש להוסיף את הקוד הזה אל onCreate(), לאחר הגדרת DessertTimer:
   

if (savedInstanceState != null) {
   revenue = savedInstanceState.getInt(KEY_REVENUE, 0)
}

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

לתשומת ליבך, המפתח שבו השתמשת כאן (KEY_REVENUE) הוא אותו מפתח שבו השתמשת ל-putInt(). כדי לוודא שמשתמשים באותו מפתח בכל פעם, מומלץ להגדיר את המפתחות האלה כקבועים. משתמשים ב-getInt() כדי להוציא את הנתונים מהחבילה, בדיוק כמו שמשתמשים ב-putInt() כדי להעביר את הנתונים לחבילה. השיטה getInt() מקבלת שני ארגומנטים:

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

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

3. יש להוסיף שיטות getInt() כדי לשחזר את מספר הקינוחים שנמכרו ואת ערך הטיימר:

if (savedInstanceState != null) {
   revenue = savedInstanceState.getInt(KEY_REVENUE, 0)dessertsSold = savedInstanceState.getInt(KEY_DESSERT_SOLD, 0)
   dessertTimer.secondsCount =
       savedInstanceState.getInt(KEY_TIMER_SECONDS, 0)
}

4. הידור והפעלה של האפליקציה. יש ללחוץ על קאפקייק לפחות חמש פעמים עד שהוא ישתנה לסופגניות. לוחצים על 'דף הבית' כדי להעביר את האפליקציה לרקע.
5. בכרטיסייה Terminal ב-Android Studio, מפעילים את adb כדי לסגור את תהליך האפליקציה.
   

adb shell am kill com.example.android.dessertclicker

6. המסך 'אחרונים' מאפשר לחזור לאפליקציה. לתשומת ליבך, בפעם הזו האפליקציה תחזיר את ההכנסה הנכונה ואת ערכי הקינוחים שנמכרו מהחבילה. עם זאת, חשוב לזכור שהקינוח חזר לעוגייה. נותר עוד דבר אחד לעשות כדי לוודא שהאפליקציה תחזור ממצב שבו היא נסגרה.
7. ב-MainActivity, צריך לבדוק את שיטת showCurrentDessert(). לתשומת ליבכם, השיטה הזו קובעת איזו תמונת קינוח תוצג בפעילות על סמך המספר הנוכחי של קינוחים שנמכרים ורשימת הקינוחים במשתנה allDesserts.
   

for (dessert in allDesserts) {
   if (dessertsSold >= dessert.startProductionAmount) {
       newDessert = dessert
   }
    else break
}

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

8. בעוד onCreate(), בבלוק שמשחזר את המצב מהחבילה, יש להתקשר אל showCurrentDessert():
   

 if (savedInstanceState != null) {
   revenue = savedInstanceState.getInt(KEY_REVENUE, 0)
   dessertsSold = savedInstanceState.getInt(KEY_DESSERT_SOLD, 0)
   dessertTimer.secondsCount = 
      savedInstanceState.getInt(KEY_TIMER_SECONDS, 0)
   showCurrentDessert()                   
}

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

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

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

שלב 1: הצגה של סבב המכשירים וקריאה חוזרת (callback) של מחזור החיים

1. הידור והפעלה של האפליקציה ופותחים את Logcat.
2. מסובבים את המכשיר או את האמולטור למצב פריסה לרוחב. ניתן לסובב את האמולטור שמאלה או ימינה באמצעות לחצני הסיבוב, או באמצעות Control ומקשי החצים (Command ומקשי חיצים ב-Mac).
   
3. בודקים את הפלט ב-Logcat. סינון של הפלט ב-MainActivity.
   חשוב לשים לב שכאשר המכשיר או האמולטור מסובבים את המסך, המערכת מתקשרת לכל התקשרות חזרה במחזור החיים כדי להשבית את הפעילות. לאחר מכן, בזמן שהפעילות נוצרת מחדש, המערכת מתקשרת לכל הקריאה החוזרת על מחזור החיים כדי להתחיל את הפעילות.
4. ב-MainActivity, הגיב על כל שיטת onSaveInstanceState().
5. הידור והפעלת האפליקציה שלך שוב. לוחצים כמה פעמים על הקאפקייקס ומסובבים את המכשיר או את האמולטור. הפעם כאשר המכשיר מסובב והפעילות מושבתת ונוצרת מחדש, הפעילות מתחילה עם ערכי ברירת המחדל.
   
   כאשר שינוי הגדרה מתרחש, Android משתמש באותה חבילת מצב מופע שעליה למדת במשימה הקודמת, כדי לשמור ולשחזר את מצב האפליקציה. כמו במקרה של סגירת תהליך, יש להשתמש באפליקציה onSaveInstanceState() כדי להוסיף לחבילה את נתוני האפליקציה. לאחר מכן יש לשחזר את הנתונים ב-onCreate() כדי להימנע מאובדן נתונים של מצב פעילות אם המכשיר מסובב.
6. ב-MainActivity, מבטלים את התגובה לשיטה onSaveInstanceState(), מפעילים את האפליקציה, לוחצים על קאפקייק וסובבים את האפליקציה או המכשיר. שימו לב הפעם שנתוני הקינוחים נשמרים בסבב הפעילויות.

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

טיפים בנושא מחזור החיים

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

ספרייה של מחזור חיים

• אפשר להשתמש בספרייה של מחזור החיים של Android כדי לשנות את בקרת מחזור החיים מהפעילות או מקטע הקוד לרכיב האמיתי, שבו צריך להיות מודעים למחזור החיים.
• בעלים של מחזור חיים הם רכיבים שיש להם מחזורי חיים (ולכן גם מירכאות, "), כולל Activity ו-Fragment. בעלי מחזור החיים מטמיעים את הממשק LifecycleOwner.
• צופים במחזור חיים חוזרים לשים לב למצב הנוכחי של מחזור החיים ולבצע משימות כאשר מחזור החיים משתנה. צופים במחזור חיים מטמיעים את הממשק LifecycleObserver.
• אובייקטים מסוג Lifecycle מכילים את המצבים האלה של מחזור החיים, והם מפעילים אירועים כאשר מחזור החיים משתנה.

כדי ליצור קורס המבוסס על מחזור החיים:

• מטמיעים את הממשק של LifecycleObserver בכיתות שצריכות להיות מודעים למחזור החיים.
• מפעילים את מחזור הצפייה של מחזור החיים באובייקט מחזור החיים מהפעילות או מקטע הקוד.
• בכיתה של הצופים במחזור החיים, יש להוסיף הערות המבוססות על מחזור החיים של מחזור החיים של מחזור החיים.
  
  לדוגמה, @OnLifecycleEvent(Lifecycle.Event.ON_START)ההערה מציינת שהשיטה צופה באירוע onStart של מחזור החיים.

עיבוד של פעולות השבתה ושמירה של מצב הפעילות

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

שימור פעילות ומצב שבר

• כשהאפליקציה מופעלת ברקע, מיד אחרי שמתבצעת קריאה ל-onStop(), נתוני האפליקציה נשמרים בחבילה. חלק מנתוני האפליקציות, כמו התוכן של EditText, נשמרים באופן אוטומטי.
• החבילה היא מופע של Bundle, שהוא אוסף של מפתחות וערכים. המפתחות הם תמיד מחרוזות.
• אפשר להשתמש בהתקשרות החוזרת (onSaveInstanceState()) כדי לשמור נתונים אחרים בחבילה שרוצים לשמור, גם אם האפליקציה כובתה באופן אוטומטי. כדי להוסיף נתונים לחבילה, יש להשתמש בשיטות החבילה שמתחילות ב-put, כמו putInt().
• אפשר לקבל בחזרה את הנתונים מהחבילה בשיטה onRestoreInstanceState(), או נפוץ יותר ב-onCreate(). לשיטה onCreate() יש פרמטר savedInstanceState שמכיל את החבילה.
• אם המשתנה savedInstanceState מכיל null, הפעילות התחילה ללא חבילת מדינה ואין נתוני מדינה שיש לאחזר.
• כדי לאחזר נתונים מהחבילה עם מפתח, יש להשתמש בשיטות Bundle שמתחילות ב-get, כמו getInt().

שינויים בתצורה

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

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

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

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

• פעילויות (מדריך API)
• Activity (הפניה ל-API)
• הסבר על מחזור החיים של הפעילות
• טיפול במחזורי חיים עם רכיבים הקשורים למחזור חיים
• LifecycleOwner
• Lifecycle
• LifecycleObserver
• onSaveInstanceState()
• שינויים בתצורת הכינוי
• שמירת מצבי ממשק משתמש

אחר:

• Timber (GitHub)

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

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

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

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

שינוי אפליקציה

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

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

שאלה 1

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

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

שאלה 2

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

• onDestroy()
• onStop()
• onPause()
• onSaveInstanceState()

שאלה 3

כדי ליצור ידע מחזורי מחזורי בכיתה באמצעות ספריית מחזור החיים של Android, איזה ממשק צריך להטמיע בכיתה?

• Lifecycle
• LifecycleOwner
• Lifecycle.Event
• LifecycleObserver

שאלה 4

באילו נסיבות, שיטת onCreate() בפעילות שלך מקבלת Bundle (כלומר, ה-Bundle אינו null)? ייתכן שתהיה יותר מתשובה אחת.

• לאחר הפעלה מחדש של המכשיר, הפעילות מתחילה מחדש.
• הפעילות מתחילה מאפס.
• הפעילות תתחדש לאחר החזרה מהרקע.
• המכשיר מופעל מחדש.

מעבר לשיעור הבא: 5.1: ViewModel ו-ViewModelManufacturer

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