A tevékenység életciklusának és állapotának használata

1. Üdvözöljük

Ez a gyakorlati kódlaboratórium az 1. rész része: Kezdje el az Android Developer Fundamentals (2. verzió) tanfolyamot. A legtöbb értéket akkor hozhatja ki ebből a kurzusból, ha sorban végigdolgozza a kódlaboratóriumokat:

  • A tanfolyam kódlaboratóriumainak teljes listáját lásd: Codelabs for Android Developer Fundamentals (V2).
  • A kurzussal kapcsolatos részletekért, beleértve az összes koncepciófejezetre, alkalmazásra és diákra mutató hivatkozásokat, tekintse meg az Android Developer Fundamentals (2. verzió) című részt.

Bevezetés

Ebben a gyakorlatban többet megtudhat a tevékenység életciklusáról. Az életciklus azon állapotok összessége, amelyekben egy tevékenység a teljes élettartama alatt lehet, a létrehozásától kezdve egészen addig, amíg megsemmisül, és a rendszer visszaszerzi erőforrásait. Miközben a felhasználó az alkalmazásban végzett tevékenységek között navigál (valamint az alkalmazásba be- és kilép), a tevékenységek életciklusuk különböző állapotai között váltanak át.

Kettős baj

Egy tevékenység életciklusának minden szakaszához tartozik egy megfelelő visszahívási metódus: onCreate(), onStart(), onPause() és így tovább. Amikor egy tevékenység állapota megváltozik, a rendszer meghívja a hozzá tartozó visszahívási metódust. A következő módszerek egyikét már láttad: onCreate(). Az életciklus-visszahívási metódusok bármelyikének felülbírálásával a tevékenységosztályokban módosíthatja a tevékenység alapértelmezett viselkedését a felhasználói vagy rendszerműveletek hatására.

A tevékenység állapota az eszközkonfiguráció változásaira is reagálhat, például amikor a felhasználó álló helyzetből fekvő helyzetbe forgatja az eszközt. Amikor ezek a konfigurációs változások megtörténnek, a tevékenység megsemmisül, és alapértelmezett állapotában újra létrejön, és a felhasználó elveszítheti a tevékenységbe bevitt információkat. A felhasználók összezavarásának elkerülése érdekében fontos, hogy az alkalmazást a váratlan adatvesztés elkerülése érdekében fejlessze. Később ebben a gyakorlatban kísérletezhet a konfigurációs módosításokkal, és megtanulhatja, hogyan őrizheti meg a tevékenység állapotát az eszközkonfiguráció változásaira és a tevékenység életciklusának egyéb eseményeire reagálva.

Ebben a gyakorlatban naplózási nyilatkozatokat ad hozzá a TwoActivities alkalmazáshoz, és megfigyelheti a tevékenységek életciklusának változásait az alkalmazás használata során. Ezután elkezd dolgozni ezekkel a változtatásokkal, és megvizsgálja, hogyan kezelheti a felhasználói bevitelt ilyen körülmények között.

Előfeltételek

Képesnek kell lennie a következőkre:

  • Hozzon létre és futtasson alkalmazásprojektet az Android Studióban .
  • Adjon hozzá naplókivonatokat az alkalmazáshoz, és tekintse meg ezeket a naplókat a Logcat ablaktáblában.
  • Értse meg a tevékenységet és a szándékot, és dolgozzon velük, és kényelmesen kommunikáljon velük.

Mit fogsz tanulni

  • Hogyan működik a tevékenység életciklusa.
  • Amikor egy tevékenység elindul, szünetel, leáll, és megsemmisül.
  • A tevékenységváltozásokhoz kapcsolódó életciklus-visszahívási módszerekről.
  • Olyan műveletek (például konfigurációs változások) hatása, amelyek tevékenység életciklus-eseményekhez vezethetnek.
  • A tevékenység állapotának megőrzése az életciklus-események során.

Mit fogsz csinálni

  • Adjon hozzá kódot a TwoActivities alkalmazáshoz az előző gyakorlatból, hogy megvalósítsa a különböző tevékenység-életciklus-visszahívásokat, és naplózási utasításokat is tartalmazzon.
  • Figyelje meg az állapotváltozásokat az alkalmazás futása során, és amikor az alkalmazásban lévő egyes tevékenységeket használja.
  • Módosítsa az alkalmazást, hogy megőrizze egy olyan tevékenység példányállapotát, amelyet a rendszer váratlanul újra létrehoz a felhasználói viselkedés vagy az eszköz konfigurációjának változása miatt.

2. Az alkalmazás áttekintése

Ebben a gyakorlatban hozzáadhatja a TwoActivities alkalmazást. Az alkalmazás nagyjából ugyanúgy néz ki és viselkedik, mint a legutóbbi kódlaboratóriumban. Két tevékenység-megvalósítást tartalmaz, és lehetővé teszi a felhasználó számára, hogy küldjön egymás között. Az ebben a gyakorlatban az alkalmazáson végrehajtott változtatások nem befolyásolják annak látható felhasználói viselkedését.

3. 3. 1. feladat: Életciklus-visszahívások hozzáadása a TwoActivities-hez

Ebben a feladatban végrehajtja az összes tevékenység életciklus-visszahívási metódusát, hogy üzeneteket nyomtasson a logcat rendszerbe, amikor ezeket a metódusokat hívják. Ezek a naplóüzenetek lehetővé teszik, hogy megtekinthesse, mikor változik meg a Tevékenység-életciklus állapota, és hogy ezek az életciklus-állapot-változások hogyan befolyásolják az alkalmazást a futás során.

1.1 (Opcionális) Másolja ki a TwoActivities projektet

A gyakorlatban szereplő feladatokhoz módosítani fogja a meglévő TwoActivities projektet, amelyet az előző gyakorlatban épített fel. Ha szeretné megőrizni az előző TwoActivities projektet, kövesse a Függelék: Segédprogramok lépéseit a projekt másolatának elkészítéséhez.

1.2 A visszahívások implementálása a MainActivity programba

  1. Nyissa meg a TwoActivities projektet az Android Studióban, és nyissa meg a MainActivity-t a Projekt > Android panelen.
  2. Az onCreate() metódusban adja hozzá a következő naplóutasításokat: 
Log.d(LOG_TAG, "-------");
Log.d(LOG_TAG, "onCreate");
  1. Adjon hozzá egy felülbírálást az onStart() visszahíváshoz, egy utasítással az esemény naplójába: 
@Override
public void onStart(){
    super.onStart();
    Log.d(LOG_TAG, "onStart");
}

Parancsikonként válassza a Kód > Módszerek felülírása lehetőséget az Android Studio alkalmazásban. Megjelenik egy párbeszédpanel az összes lehetséges módszerrel, amelyet felülbírálhat az osztályban. Egy vagy több visszahívási metódus kiválasztása a listából egy teljes sablont szúr be ezekhez a metódusokhoz, beleértve a szuperosztály szükséges hívását.

  1. Használja az onStart() metódust sablonként az onPause(), onRestart(), onResume(), onStop() és onDestroy() életciklus-visszahívások megvalósításához.

Az összes visszahívási módszer ugyanazokkal az aláírásokkal rendelkezik (a név kivételével). Ha a másolás és beillesztés onStart() segítségével létrehozza ezeket a többi visszahívási metódust, ne felejtse el frissíteni a tartalmat, hogy a megfelelő metódus hívja meg a szuperosztályban, és naplózza a megfelelő metódust.

  1. Futtassa az alkalmazást.
  2. Kattintson a Logcat fülre az Android Studio alján a Logcat panel megjelenítéséhez. Három naplóüzenetet kell látnia, amelyek azt a három életciklus-állapotot mutatják, amelyeken a tevékenység átment a kezdetekkor: 
D/MainActivity: -------
D/MainActivity: onCreate
D/MainActivity: onStart
D/MainActivity: onResume

1.3 Életciklus-visszahívások megvalósítása a SecondActivityben

Most, hogy megvalósította a MainActivity életciklus-visszahívási metódusait, tegye ugyanezt a SecondActivity esetében is.

  1. Nyissa meg a SecondActivity-t.
  2. Az osztály tetején adjon hozzá egy állandót a LOG_TAG változóhoz: 
private static final String LOG_TAG = SecondActivity.class.getSimpleName();
  1. Adja hozzá az életciklus-visszahívásokat és a naplókimutatásokat a második tevékenységhez. (A visszahívási metódusokat a MainActivity-ből másolhatja és illesztheti be.)
  2. Adjon hozzá egy naplóutasítást a returnReply() metódushoz közvetlenül a finish() metódus előtt: 
Log.d(LOG_TAG, "End SecondActivity");

1.4 Figyelje meg a naplót, miközben az alkalmazás fut**

  1. Futtassa az alkalmazást.
  2. Kattintson a Logcat fülre az Android Studio alján a Logcat panel megjelenítéséhez.
  3. Írja be a tevékenységet a keresőmezőbe. Az Android logcat nagyon hosszú és zsúfolt lehet. Mivel az egyes osztályok LOG_TAG változója vagy a MainActivity vagy a SecondActivity szavakat tartalmazza, ez a kulcsszó lehetővé teszi, hogy csak az Önt érdeklő dolgokra szűrje a naplót.

Kettős baj

Kísérletezzen az alkalmazás használatával, és vegye figyelembe, hogy az életciklus-események, amelyek különböző műveletekre reagálnak. Különösen az alábbi dolgokat próbálja ki:

  • Használja a szokásos módon az alkalmazást (üzenet küldése, válaszadás másik üzenettel).
  • A Vissza gombbal léphet vissza a második tevékenységről a fő tevékenységre.
  • Használja az alkalmazássáv felfelé mutató nyilat a második tevékenységről a fő tevékenységre való visszatéréshez.
  • Forgassa el az eszközt a fő és a második tevékenységben is különböző időpontokban az alkalmazásban, és figyelje meg, mi történik * a naplóban és a képernyőn.
  • Nyomja meg az áttekintés gombot (a négyzet alakú gomb a Kezdőlaptól jobbra), és zárja be az alkalmazást (koppintson az X-re).
  • Térjen vissza a kezdőképernyőre, és indítsa újra az alkalmazást.

TIPP: Ha az alkalmazást emulátorban futtatja, szimulálhatja a forgatást a Control+F11 vagy a Control+Function+F11 billentyűkombinációval.

1. feladat megoldási kódja

A következő kódrészletek az első feladat megoldási kódját mutatják.

MainActivity

A következő kódrészletek a MainActivityben hozzáadott kódot mutatják, de nem a teljes osztályt.

Az onCreate() metódus:

@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);
}

A többi életciklus módszer:

@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

A következő kódrészletek a SecondActivityben hozzáadott kódot mutatják, de nem a teljes osztályt.

A SecondActivity osztály tetején:

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

A returnReply() metódus:

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();
}

A többi életciklus módszer:

Ugyanaz, mint a fenti MainActivity esetében.

4. 4. 2. feladat: Mentse el és állítsa vissza a Tevékenységpéldány állapotát

A rendszererőforrásoktól és a felhasználói viselkedéstől függően előfordulhat, hogy az alkalmazás minden tevékenysége sokkal gyakrabban semmisül meg és rekonstruálódik, mint gondolná.

Lehet, hogy észrevette ezt a viselkedést az utolsó részben, amikor elforgatta az eszközt vagy az emulátort. Az eszköz elforgatása egy példa az eszközkonfiguráció megváltoztatására. Bár az elforgatás a leggyakoribb, minden konfigurációmódosítás azt eredményezi, hogy az aktuális tevékenység megsemmisül, és úgy jön létre, mintha új lenne. Ha nem veszi figyelembe ezt a viselkedést a kódban, akkor konfigurációs változás esetén a tevékenység elrendezése visszatérhet alapértelmezett megjelenéséhez és kezdeti értékéhez, és a felhasználók elveszíthetik helyüket, adataikat vagy előrehaladásuk állapotát az alkalmazásod.

Az egyes tevékenységek állapotát a rendszer kulcs/érték párok halmazaként tárolja a Tevékenységpéldány állapotnak nevezett Bundle objektumban. A rendszer elmenti az alapértelmezett állapotinformációkat a példányállapot-csomagba közvetlenül a tevékenység leállítása előtt, és átadja ezt a köteget az új tevékenységpéldánynak a visszaállításhoz.

Annak érdekében, hogy ne veszítsen adatot egy tevékenységben, amikor azt váratlanul megsemmisítik és újra létrehozzák, implementálnia kell az onSaveInstanceState() metódust. A rendszer meghívja ezt a metódust az Ön tevékenységében (onPause() és onStop() között), ha fennáll annak a lehetősége, hogy a tevékenységet megsemmisítik és újra létrehozzák.

A példányállapotban mentett adatok csak az adott tevékenység ezen példányára vonatkoznak az aktuális alkalmazásmunka során. Amikor leállít és újraindít egy új alkalmazás-munkamenetet, a tevékenységpéldány állapota elvész, és a tevékenység visszaáll az alapértelmezett megjelenésre. Ha felhasználói adatokat kell mentenie az alkalmazásmunkamenetek között, használja a megosztott beállításokat vagy egy adatbázist. Mindkettőről egy későbbi gyakorlatban tanulhat.

2.1 Mentse el az Activity példány állapotát az onSaveInstanceState() paranccsal

Talán észrevette, hogy az eszköz elforgatása egyáltalán nem befolyásolja a második tevékenység állapotát. Ennek az az oka, hogy a második tevékenység-elrendezés és állapot az elrendezésből és az azt aktiváló Intentből jön létre. Még ha a tevékenységet újra létrehozzák, az Intent továbbra is ott van, és az Intent adatai továbbra is használatban vannak minden alkalommal, amikor a második tevékenység onCreate() metódusát hívják.

Ezenkívül észreveheti, hogy minden tevékenységnél az üzenetbe vagy a válasz szerkesztése szövegelemekbe beírt szövegek megmaradnak az eszköz elforgatásakor is. Ennek az az oka, hogy az elrendezés egyes nézetelemeinek állapotinformációit a rendszer automatikusan menti a konfigurációs módosítások során, és az EditText aktuális értéke az egyik ilyen eset.

Tehát az egyetlen tevékenységi állapot, amely érdekli, a válaszfejléc TextView elemei és a válaszszöveg a fő tevékenységben. Mindkét TextView elem alapértelmezés szerint láthatatlan; csak akkor jelennek meg, ha a második tevékenységből visszaküld egy üzenetet a fő tevékenységnek.

Ebben a feladatban kódot ad hozzá a két TextView elem példányállapotának megőrzéséhez az onSaveInstanceState() segítségével.

  1. Nyissa meg a MainActivity elemet.
  2. Adja hozzá az onSaveInstanceState() váz-megvalósítását a tevékenységhez, vagy használja a Code > Override Methods parancsot egy váz-felülbírálat beszúrásához. 
@Override
public void onSaveInstanceState(Bundle outState) {
          super.onSaveInstanceState(outState);
}
  1. Ellenőrizze, hogy a fejléc jelenleg látható-e, és ha igen, tegye a láthatósági állapotot a Bundle állapotba a putBoolean() metódussal és a "reply_visible" kulccsal. 
 if (mReplyHeadTextView.getVisibility() == View.VISIBLE) {
        outState.putBoolean("reply_visible", true);
    }

Ne feledje, hogy a válasz fejléce és szövege láthatatlannak van jelölve, amíg nem érkezik válasz a második tevékenységből. Ha a fejléc látható, akkor vannak válaszadatok, amelyeket el kell menteni. Ne feledje, hogy minket csak ez a láthatósági állapot érdekel – a fejléc tényleges szövegét nem kell menteni, mert ez a szöveg soha nem változik.

  1. Ugyanezen a csekken belül adja hozzá a válaszszöveget a köteghez. 
outState.putString("reply_text",mReplyTextView.getText().toString());

Ha a fejléc látható, feltételezhető, hogy maga a válaszüzenet is látható. Nem kell tesztelnie vagy mentenie a válaszüzenet aktuális láthatósági állapotát. Csak az üzenet tényleges szövege kerül a "válasz_szöveg" kulcsú Bundle állapotba.

Csak azoknak a nézetelemeknek az állapotát menti, amelyek a tevékenység létrehozása után változhatnak. Az alkalmazásban lévő többi nézetelem (a Szerkesztési szöveg, a Gomb) bármikor újra létrehozható az alapértelmezett elrendezésből.

Vegye figyelembe, hogy a rendszer elmenti néhány Nézet elem állapotát, például az EditText tartalmát.

2.2 Állítsa vissza a Activity példány állapotát az onCreate()

Miután elmentette a tevékenységpéldány állapotát, azt is vissza kell állítania a tevékenység újbóli létrehozásakor. Ezt megteheti az onCreate(), vagy az onRestoreInstanceState() visszahívás megvalósításával, amely a tevékenység létrehozása után az onStart() után kerül meghívásra.

A Tevékenység állapot visszaállításának legtöbbször az onCreate() a legjobb helye, hogy a felhasználói felület, beleértve az állapotot is, a lehető leghamarabb elérhető legyen. Néha célszerű ezt az onRestoreInstanceState() segítségével megtenni, miután az összes inicializálást elvégezték, vagy megengedni az alosztályoknak, hogy eldöntsék, használják-e az alapértelmezett megvalósítást.

  1. Az onCreate() metódusban, miután a nézetváltozókat inicializálták a findViewById() paraméterrel, adjon hozzá egy tesztet, hogy megbizonyosodjon arról, hogy a savedInstanceState nem 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) {
}

A tevékenység létrehozásakor a rendszer az állapotcsomagot az onCreate()-nek adja át egyetlen argumentumként. Az onCreate() első meghívásakor és az alkalmazás elindításakor a Bundle nulla – az alkalmazás első indításakor nincs létező állapot. Az onCreate() későbbi hívásai egy köteget tartalmaznak az onSaveInstanceState() paraméterben tárolt adatokkal.

  1. Az ellenőrzésen belül a „reply_visible” kulccsal vegye ki az aktuális láthatóságot (igaz vagy hamis) a csomagból. 
if (savedInstanceState != null) {
    boolean isVisible = 
                     savedInstanceState.getBoolean("reply_visible");
}
  1. Adjon hozzá egy tesztet az előző sor alá az isVisible változóhoz. 
if (isVisible) {
}

Ha van egy reply_visible kulcs az állapotcsomagban (és ezért az isVisible igaz), akkor vissza kell állítania az állapotot.

  1. Az isVisible tesztben tegye láthatóvá a fejlécet. 
mReplyHeadTextView.setVisibility(View.VISIBLE);
  1. Szerezze be a szöveges válaszüzenetet a csomagból a „reply_text” kulccsal, és állítsa be a válasz TextView-t úgy, hogy az ezt a karakterláncot jelenítse meg. 
mReplyTextView.setText(savedInstanceState.getString("reply_text"));
  1. Tedd láthatóvá a TextView választ is: 
mReplyTextView.setVisibility(View.VISIBLE);
  1. Futtassa az alkalmazást. Próbálja meg elforgatni az eszközt vagy az emulátort, hogy a válaszüzenet (ha van) a képernyőn maradjon a tevékenység újbóli létrehozása után.

2. feladat megoldási kódja

A következő kódrészletek a feladat megoldási kódját mutatják.

MainActivity

A következő kódrészletek a MainActivityben hozzáadott kódot mutatják, de nem a teljes osztályt.

Az onSaveInstanceState() metódus: 

@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());
   }
}

Az onCreate() metódus: 

@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);
       }
   }
}

A teljes projekt:

Android Studio Project: TwoActivitiesLifecycle

5. Kódolás

Kihívás: Hozzon létre egy egyszerű bevásárlólista-alkalmazást, amelynek fő tevékenysége a felhasználó által összeállított listához tartozik, egy másik tevékenység pedig a gyakori bevásárló cikkek listájához.

  • A fő tevékenységnek tartalmaznia kell az elkészítendő listát, amelynek tíz üres TextView elemből kell állnia.
  • A fő tevékenységen lévő Elem hozzáadása gomb egy második tevékenységet indít el, amely a gyakori vásárlási cikkek listáját tartalmazza (sajt, rizs, alma stb.). Használja a gombelemeket az elemek megjelenítéséhez.
  • Egy elem kiválasztása visszaállítja a felhasználót a fő tevékenységhez, és frissít egy üres TextView-t, hogy tartalmazza a kiválasztott elemet.

Használjon szándékot az információk egyik tevékenységből a másikba való átadásához. Győződjön meg arról, hogy a bevásárlólista aktuális állapota mentésre kerül, amikor a felhasználó elforgatja a készüléket.

6. Összegzés

  • A Tevékenység-életciklus azon állapotok halmaza, amelyeken a tevékenység áttelepül, kezdve az első létrehozásával és akkor ér véget, amikor az Android rendszer visszakéri az adott tevékenységhez szükséges erőforrásokat.
  • Ahogy a felhasználó az egyik tevékenységről a másikra, valamint az alkalmazáson belül és kívül navigál, minden tevékenység a tevékenység életciklusának állapotai között mozog.
  • A tevékenység életciklusában minden állapothoz tartozik egy megfelelő visszahívási metódus, amelyet felülbírálhat a tevékenységosztályában.
  • Az életciklus metódusai: onCreate(), onStart(), onPause(), onRestart(), onResume(), onStop(), onDestroy().
  • Az életciklus-visszahívási módszer felülbírálása lehetővé teszi olyan viselkedés hozzáadását, amely akkor fordul elő, amikor a tevékenység ebbe az állapotba kerül.
  • Csontváz-felülbírálási módszereket adhat az osztályokhoz az Android Studióban a Kód > Felülbírálás menüponttal.
  • Az eszközkonfiguráció megváltoztatása, például az elforgatás azt eredményezi, hogy a tevékenység megsemmisül, és újból létrejön, mintha új lenne.
  • A tevékenység állapot egy része megmarad a konfiguráció módosításakor, beleértve az EditText elemek aktuális értékeit is. Minden egyéb adat esetében kifejezetten saját magának kell mentenie az adatokat.
  • Mentse a tevékenységpéldányállapotot az onSaveInstanceState() metódusban.
  • A példányállapot-adatok egyszerű kulcs/érték párokként kerülnek tárolásra egy kötegben. Használja a Bundle metódusokat, hogy adatokat helyezzen be a kötegbe, és adatokat vonjon vissza onnan.
  • Állítsa vissza a példányállapotot az onCreate() vagy onRestoreInstanceState() segítségével, amely az előnyben részesített módszer. Vissza