איך משתמשים במחזור החיים ובמצב של הפעילות

1. היי!

סדנת הקוד המעשית הזו היא חלק מיחידת 1: תחילת העבודה בקורס Android Developer Fundamentals (גרסה 2). כדי להפיק את המקסימום מהקורס, מומלץ לעבוד על הקודאבים לפי הסדר:

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

מבוא

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

IDouble trouble

לכל שלב במחזור החיים של פעילות יש שיטה מתאימה של קריאה חוזרת (callback): onCreate(),‏ onStart(),‏ onPause() וכו'. כשמצב הפעילות משתנה, מתבצעת קריאה ל-method ה-callback המשויך. כבר ראינו אחת מהשיטות האלה: onCreate(). ‏ שינוי של אחת משיטות ה-call back של מחזור החיים בכיתות ה-Activity מאפשר לשנות את התנהגות ברירת המחדל של הפעילות בתגובה לפעולות של משתמשים או של המערכת.

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

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

דרישות מוקדמות

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

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

הנושאים שתלמד

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

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

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

2. סקירה כללית של האפליקציה

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

3. 3. משימה 1: מוסיפים קריאות חזרה מחזור חיים ל-TwoActivities

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

1.1 (אופציונלי) מעתיקים את הפרויקט TwoActivities

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

1.2 הטמעת קריאות חוזרות (callbacks) ב-MainActivity

  1. פותחים את הפרויקט TwoActivities ב-Android Studio ופותחים את MainActivity בחלונית Project‏ > Android.
  2. בשיטה onCreate()‎, מוסיפים את משפטי היומן הבאים:
Log.d(LOG_TAG, "-------");
Log.d(LOG_TAG, "onCreate");
  1. מוסיפים שינוי מברירת המחדל ל-onStart()‏ (קריאה חוזרת), עם הצהרה ביומן לגבי האירוע הזה:
@Override
public void onStart(){
    super.onStart();
    Log.d(LOG_TAG, "onStart");
}

קיצור דרך: בוחרים באפשרות Code (קוד) > Override Methods (שינוי שיטות) ב-Android Studio. תופיע תיבת דו-שיח עם כל השיטות האפשריות שאפשר לשנות בכיתה. בחירה של שיטת קריאה חוזרת אחת או יותר מהרשימה תוסיף תבנית מלאה לשיטות האלה, כולל הקריאה הנדרשת לסופר-קלאס.

  1. שימוש בשיטה onStart()‎ בתור תבנית להטמעת פונקציות ה-call back של מחזור החיים onPause(),‏ onRestart(),‏ onResume(),‏ onStop() ו-onDestroy()‎

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

  1. מריצים את האפליקציה.
  2. לוחצים על הכרטיסייה Logcat בחלק התחתון של Android Studio כדי להציג את חלונית Logcat. אמורות להופיע שלוש הודעות ביומן שמציגות את שלושת מצבי מחזור החיים שהפעילות עברה כשהיא התחילה:
D/MainActivity: -------
D/MainActivity: onCreate
D/MainActivity: onStart
D/MainActivity: onResume

1.3 הטמעת קריאות חוזרות (callbacks) במחזור החיים ב-SecondActivity

אחרי שמטמיעים את שיטות ה-call back של מחזור החיים ב-MainActivity, צריך לעשות את אותו הדבר ב-SecondActivity.

  1. פותחים את SecondActivity.
  2. בחלק העליון של הכיתה, מוסיפים קבוע למשתנה LOG_TAG:
private static final String LOG_TAG = SecondActivity.class.getSimpleName();
  1. מוסיפים את פונקציות ה-call back של מחזור החיים ואת הצהרות היומן ל-Activity השני. (אפשר להעתיק ולהדביק את שיטות הקריאה החוזרת מ-MainActivity).
  2. מוסיפים הצהרת יומן לשיטה returnReply()‎ ממש לפני השיטה finish()‎:
Log.d(LOG_TAG, "End SecondActivity");

1.4 בודקים את היומן בזמן שהאפליקציה פועלת**

  1. מריצים את האפליקציה.
  2. לוחצים על הכרטיסייה Logcat בחלק התחתון של Android Studio כדי להציג את חלונית Logcat.
  3. מזינים 'פעילות' בתיבת החיפוש. ה-logcat של Android יכול להיות ארוך ומבלבל מאוד. מאחר שמשתנה LOG_TAG בכל כיתה מכיל את המילים MainActivity או SecondActivity, מילת המפתח הזו מאפשרת לסנן את היומן רק לדברים שמעניינים אתכם.

IDouble trouble

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

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

טיפ: אם אתם מריצים את האפליקציה במהדמ, אתם יכולים לדמות סיבוב באמצעות Control+F11 או Control+Function+F11.

קוד הפתרון של משימה 1

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

MainActivity

בקטעי הקוד הבאים מוצג הקוד שנוסף ב-MainActivity, אבל לא הכיתה כולה.

השיטה onCreate():

@Override
protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // Log the start of the onCreate() method.
        Log.d(LOG_TAG, "-------");
        Log.d(LOG_TAG, "onCreate");

        // Initialize all the view variables.
        mMessageEditText = findViewById(R.id.editText_main);
        mReplyHeadTextView = findViewById(R.id.text_header_reply);
        mReplyTextView = findViewById(R.id.text_message_reply);
}

שיטות מחזור החיים האחרות:

@Override
protected void onStart() {
        super.onStart();
        Log.d(LOG_TAG, "onStart");
}

@Override
protected void onPause() {
        super.onPause();
        Log.d(LOG_TAG, "onPause");
}

@Override
protected void onRestart() {
        super.onRestart();
        Log.d(LOG_TAG, "onRestart");
}

@Override
protected void onResume() {
        super.onResume();
        Log.d(LOG_TAG, "onResume");
}

@Override
protected void onStop() {
        super.onStop();
        Log.d(LOG_TAG, "onStop");
}

@Override
protected void onDestroy() {
        super.onDestroy();
        Log.d(LOG_TAG, "onDestroy");
}

SecondActivity

בקטעי הקוד הבאים מוצג הקוד שנוסף ב-SecondActivity, אבל לא הכיתה כולה.

בחלק העליון של הכיתה SecondActivity:

private static final String LOG_TAG = SecondActivity.class.getSimpleName();

השיטה returnReply():

public void returnReply(View view) {
        String reply = mReply.getText().toString();
        Intent replyIntent = new Intent();
        replyIntent.putExtra(EXTRA_REPLY, reply);
        setResult(RESULT_OK, replyIntent);
        Log.d(LOG_TAG, "End SecondActivity");
        finish();
}

שיטות מחזור החיים האחרות:

כנ"ל כמו ב-MainActivity שלמעלה.

4. 4. משימה 2: שמירה ושחזור של מצב המכונה של הפעילות

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

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

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

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

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

2.1 שמירת המצב של מופע הפעילות באמצעות onSaveInstanceState()‎

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

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

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

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

  1. פותחים את MainActivity.
  2. מוסיפים את ההטמעה הזו של השלד של onSaveInstanceState() ל-Activity, או משתמשים באפשרות Code > Override Methods כדי להוסיף שינוי של השלד.
@Override
public void onSaveInstanceState(Bundle outState) {
          super.onSaveInstanceState(outState);
}
  1. בודקים אם הכותרת גלויה כרגע, ואם כן, מוסיפים את מצב החשיפה הזה לחבילת המצב באמצעות השיטה putBoolean()‎ והמפתח 'reply_visible'.
 if (mReplyHeadTextView.getVisibility() == View.VISIBLE) {
        outState.putBoolean("reply_visible", true);
    }

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

  1. בתוך אותה בדיקה, מוסיפים את הטקסט של התשובה לחבילה.
outState.putString("reply_text",mReplyTextView.getText().toString());

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

שומרים את המצב של רכיבי התצוגה שעשויים להשתנות אחרי יצירת הפעילות. אפשר ליצור מחדש את שאר רכיבי התצוגה באפליקציה (EditText, ‏ Button) מפריסת ברירת המחדל בכל שלב.

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

2.2 שחזור המצב של מופע הפעילות ב-onCreate()‎

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

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

  1. בשיטה onCreate(), אחרי שמשתני התצוגה מופעלים באמצעות findViewById(), מוסיפים בדיקה כדי לוודא ש-savedInstanceState לא null.
// Initialize all the view variables.
mMessageEditText = findViewById(R.id.editText_main);
mReplyHeadTextView = findViewById(R.id.text_header_reply);
mReplyTextView = findViewById(R.id.text_message_reply);

// Restore the state.
if (savedInstanceState != null) {
}

כשיוצרים את ה-Activity, המערכת מעבירה את ה-Bundle של המצב ל-onCreate()‎ כארגומנט היחיד שלו. בפעם הראשונה שמפעילים את onCreate() והאפליקציה מופעלת, ה-Bundle הוא null – אין מצב קיים בפעם הראשונה שהאפליקציה מופעלת. בקריאות הבאות ל-onCreate()‏, החבילה מאוכלסת בנתונים ששמרתם ב-onSaveInstanceState().

  1. בתוך הבדיקה הזו, מקבלים את החשיפה הנוכחית (true או false) מה-Bundle באמצעות המפתח 'reply_visible'.
if (savedInstanceState != null) {
    boolean isVisible = 
                     savedInstanceState.getBoolean("reply_visible");
}
  1. מוסיפים בדיקה מתחת לשורה הקודמת עבור המשתנה isVisible.
if (isVisible) {
}

אם המפתח reply_visible מופיע בחבילת המצב (ולכן הערך של isVisible הוא true), תצטרכו לשחזר את המצב.

  1. בתוך הבדיקה isVisible, מגדירים שהכותרת תהיה גלויה.
mReplyHeadTextView.setVisibility(View.VISIBLE);
  1. מקבלים את הודעת התשובה בטקסט מה-Bundle באמצעות המפתח 'reply_text', ומגדירים את TextView של התשובה כך שיציג את המחרוזת הזו.
mReplyTextView.setText(savedInstanceState.getString("reply_text"));
  1. מגדירים גם את TextView של התשובה כגלוי:
mReplyTextView.setVisibility(View.VISIBLE);
  1. מריצים את האפליקציה. מנסים לסובב את המכשיר או את הסימולטור כדי לוודא שההודעה בתשובה (אם יש כזו) נשארת במסך אחרי יצירת הפעילות מחדש.

קוד הפתרון של המשימה 2

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

MainActivity

בקטעי הקוד הבאים מוצג הקוד שנוסף ב-MainActivity, אבל לא הכיתה כולה.

השיטה onSaveInstanceState():

@Override
public void onSaveInstanceState(Bundle outState) {
   super.onSaveInstanceState(outState);
   // If the heading is visible, message needs to be saved.
   // Otherwise we're still using default layout.
   if (mReplyHeadTextView.getVisibility() == View.VISIBLE) {
       outState.putBoolean("reply_visible", true);
       outState.putString("reply_text", 
                      mReplyTextView.getText().toString());
   }
}

השיטה onCreate():

@Override
protected void onCreate(Bundle savedInstanceState) {
   super.onCreate(savedInstanceState);
   setContentView(R.layout.activity_main);

   Log.d(LOG_TAG, "-------");
   Log.d(LOG_TAG, "onCreate");

   // Initialize all the view variables.
   mMessageEditText = findViewById(R.id.editText_main);
   mReplyHeadTextView = findViewById(R.id.text_header_reply);
   mReplyTextView = findViewById(R.id.text_message_reply);

   // Restore the saved state. 
   // See onSaveInstanceState() for what gets saved.
   if (savedInstanceState != null) {
       boolean isVisible = 
                     savedInstanceState.getBoolean("reply_visible");
       // Show both the header and the message views. If isVisible is
       // false or missing from the bundle, use the default layout.
       if (isVisible) {
           mReplyHeadTextView.setVisibility(View.VISIBLE);
           mReplyTextView.setText(savedInstanceState
                                  .getString("reply_text"));
           mReplyTextView.setVisibility(View.VISIBLE);
       }
   }
}

הפרויקט המלא:

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

5. תכנות

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

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

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

6. סיכום

  • מחזור החיים של פעילות הוא קבוצה של מצבים שבהם הפעילות עוברת, החל מהיצירה הראשונה שלה ועד שהמערכת של Android מחזירה לעצמה את המשאבים של הפעילות הזו.
  • כשהמשתמש מנווט מפעילות אחת לאחרת, בתוך האפליקציה ומחוצה לה, כל פעילות עוברת בין המצבים במחזור החיים שלה.
  • לכל מצב במחזור החיים של הפעילות יש שיטת קריאה חוזרת (callback) תואמת שאפשר לשנות בכיתה Activity.
  • שיטות מחזור החיים הן onCreate(), ‏ onStart(), ‏ onPause(), ‏ onRestart(), ‏ onResume(), ‏ onStop(), ‏ onDestroy().
  • שינוי של שיטת קריאה חוזרת (callback) במחזור החיים מאפשר לכם להוסיף התנהגות שמתרחשת כשהפעילות עוברת למצב הזה.
  • אפשר להוסיף שיטות שריון לסוגי הכיתות ב-Android Studio באמצעות Code (קוד) > Override (החלפה).
  • שינויים בהגדרות המכשיר, כמו רוטציה, גורמים להרס הפעילות וליצירה מחדש שלה כאילו היא חדשה.
  • חלק ממצב הפעילות נשמר כשמשנים את ההגדרות, כולל הערכים הנוכחיים של אלמנטים מסוג EditText. לגבי כל שאר הנתונים, עליכם לשמור אותם בעצמכם באופן מפורש.
  • שומרים את המצב של מופע הפעילות בשיטה onSaveInstanceState().
  • נתוני מצב המכונה נשמרים כצמדי מפתח/ערך פשוטים ב-Bundle. משתמשים בשיטות של Bundle כדי להוסיף נתונים ל-Bundle ולהוציא ממנו נתונים.
  • משחזרים את מצב המכונה ב-onCreate(), שהיא הדרך המועדפת, או ב-onRestoreInstanceState(). חזרה