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

‫1. היי!

ה-codelab המעשי הזה הוא חלק מיחידה 1: תחילת העבודה בקורס בנושא יסודות Android (גרסה 2). אתם יכולים להפיק את המקסימום מהקורס הזה אם תעברו על ה-Codelabs ברצף:

• לרשימה המלאה של Codelabs בקורס, ראו Codelabs ל-Android Developer Fundamentals (V2).
• לפרטים על הקורס, כולל קישורים לכל הפרקים, האפליקציות והשקפים, ראו Android Developer Fundamentals (גרסה 2).

מבוא

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

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

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

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

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

אתם אמורים להיות מסוגלים:

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

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

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

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

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

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

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

3. 3. משימה 1: הוספת קריאות חוזרות (callback) במחזור החיים לשתי פעילויות

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

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

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

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

1. פותחים את פרויקט שתי הפעילויות ב-Android Studio, ופותחים את MinActivity בחלונית 'פרויקט' > Android.
2. בשיטת onCreate() , מוסיפים את הצהרות היומן הבאות:

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

1. מוסיפים שינוי מברירת המחדל לקריאה החוזרת (callback) של onStart() , עם הצהרה ביומן של האירוע הזה:

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

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

1. משתמשים בשיטה onStart() כתבנית כדי להטמיע את הקריאות החוזרות של מחזור החיים onPause() , onאתחל() , onResume() , onStop() ו-onDestroy()

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

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

D/MainActivity: -------
D/MainActivity: onCreate
D/MainActivity: onStart
D/MainActivity: onResume

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

לאחר שהטמעתם את שיטות הקריאה החוזרת של מחזור החיים עבור MinActivity, בצעו את אותה פעולה עבור SecondActivity.

1. פותחים את SecondActivity.
2. בחלק העליון של המחלקה, מוסיפים ערך קבוע למשתנה LOG_TAG:

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

1. הוסף לפעילות השנייה את הקריאה החוזרת (callback) וההצהרות ביומן של מחזור החיים. (אפשר להעתיק ולהדביק את שיטות הקריאה החוזרת מ-MainActivity.)
2. מוסיפים הצהרת יומן לשיטת ReturnReply() ממש לפני שיטת סיום (()):

Log.d(LOG_TAG, "End SecondActivity");

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

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

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

• שימוש באפליקציה כרגיל (שליחת הודעה, מענה עם הודעה אחרת).
• השתמשו בלחצן 'הקודם' כדי לחזור מהפעילות השנייה לפעילות הראשית.
• משתמשים בחץ למעלה בסרגל האפליקציות כדי לחזור מהפעילות השנייה לפעילות הראשית.
• מסובבים את המכשיר גם בפעילות הראשית וגם בפעילות השנייה בזמנים שונים באפליקציה כדי לראות מה קורה * ביומן ובמסך.
• לוחצים על לחצן הסקירה הכללית (הלחצן המרובע שמימין לדף הבית) וסוגרים את האפליקציה (מקישים על ה-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: שמירה ושחזור של מצב המופע של הפעילות

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

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

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

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

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

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

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

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

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

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

1. פתח את ראשי הפעילות.
2. מוסיפים את הטמעת השלד הזו של onSaveInstanceState() לפעילות, או משתמשים ב-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, הלחצן) בכל שלב, מפריסת ברירת המחדל.

שים לב: המערכת תשמור את המצב של רכיבי View מסוימים, כמו התוכן של EditText.

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

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

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

1. בשיטת onCreate() , אחרי שהמשתנים של View מאותחלים באמצעות findViewById(), מוסיפים בדיקה כדי לוודא ש-SavedInstanceState אינו ריק.

// 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) {
}

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

1. בתוך הבדיקה, מקבלים את סטטוס החשיפה הנוכחי (True או False) מהחבילה באמצעות המפתח reply_visible.

if (savedInstanceState != null) {
    boolean isVisible = 
                     savedInstanceState.getBoolean("reply_visible");
}

1. מוסיפים בדיקה מתחת לשורה הקודמת לגבי המשתנה הגלוי.

if (isVisible) {
}

אם יש מפתח response_visible בחבילה הכוללת (ולכן הוא גלוי הוא true), תצטרכו לשחזר את המצב.

1. בתוך הבדיקה גלויה, הפוך את הכותרת לגלויה.

mReplyHeadTextView.setVisibility(View.VISIBLE);

1. מקבלים את הודעת הטקסט לתשובה מהחבילה עם המפתח '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 ריקים.
• לחצן 'הוספת פריט' בפעילות הראשית מפעיל פעילות נוספת שמכילה רשימה של פריטי קניות נפוצים (גבינה, אורז, תפוחים וכו'). אפשר להשתמש ברכיבי הלחצן כדי להציג את הפריטים.
• כשבוחרים פריט, המשתמש חוזר לפעילות העיקרית ו-TextView ריק מעדכן את הפריט שנבחר.

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

6. סיכום

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