Si të përdorni ciklin jetësor dhe gjendjen e Aktivitetit

1. Mirë se vini

Ky laborator praktik i kodeve është pjesë e Njësisë 1: Filloni në kursin Bazat e Zhvilluesve të Android (Versioni 2). Ju do të përfitoni më shumë nga ky kurs nëse punoni nëpër kodet në sekuencë:

  • Për listën e plotë të skedarëve të kodeve në kurs, shihni Codelabs for Android Developer Fundamentals (V2).
  • Për detaje rreth kursit, duke përfshirë lidhjet me të gjithë kapitujt e konceptit, aplikacionet dhe rrëshqitjet, shihni Bazat e Zhvilluesit të Android (Versioni 2).

Hyrje

Në këtë praktikë ju mësoni më shumë rreth ciklit jetësor të aktivitetit. Cikli i jetës është grupi i gjendjeve në të cilat një aktivitet mund të jetë gjatë gjithë jetës së tij, nga momenti kur krijohet deri në momentin kur shkatërrohet dhe sistemi rimerr burimet e tij. Ndërsa një përdorues lundron midis aktiviteteve në aplikacionin tuaj (si dhe brenda dhe jashtë aplikacionit tuaj), aktivitetet kalojnë midis gjendjeve të ndryshme në ciklin e tyre të jetës.

Probleme të dyfishta

Çdo fazë në ciklin jetësor të një aktiviteti ka një metodë përkatëse të kthimit të thirrjes: onCreate(), onStart(), onPause() dhe kështu me radhë. Kur një aktivitet ndryshon gjendjen, thirret metoda e lidhur me kthimin e thirrjes. Ju keni parë tashmë një nga këto metoda: onCreate(). Duke anashkaluar ndonjë nga metodat e kthimit të thirrjes së ciklit jetësor në klasat tuaja të aktivitetit, mund të ndryshoni sjelljen e paracaktuar të aktivitetit në përgjigje të veprimeve të përdoruesit ose të sistemit.

Gjendja e aktivitetit mund të ndryshojë gjithashtu në përgjigje të ndryshimeve të konfigurimit të pajisjes, për shembull kur përdoruesi e rrotullon pajisjen nga portreti në peizazh. Kur ndodhin këto ndryshime të konfigurimit, aktiviteti shkatërrohet dhe rikrijohet në gjendjen e tij të paracaktuar dhe përdoruesi mund të humbasë informacionin që ka futur në aktivitet. Për të shmangur konfuzionin e përdoruesve tuaj, është e rëndësishme që të zhvilloni aplikacionin tuaj për të parandaluar humbjen e papritur të të dhënave. Më vonë në këtë praktikë praktike ju eksperimentoni me ndryshimet e konfigurimit dhe mësoni se si të ruani gjendjen e një aktiviteti në përgjigje të ndryshimeve të konfigurimit të pajisjes dhe ngjarjeve të tjera të ciklit jetësor të aktivitetit.

Në këtë praktikë, ju shtoni deklarata të regjistrimit në aplikacionin TwoActivities dhe vëzhgoni ndryshimet e ciklit jetësor të aktivitetit ndërsa përdorni aplikacionin. Më pas filloni të punoni me këto ndryshime dhe të eksploroni se si të trajtoni të dhënat e përdoruesit në këto kushte.

Parakushtet

Ju duhet të jeni në gjendje të:

  • Krijoni dhe ekzekutoni një projekt aplikacioni në Android Studio .
  • Shtoni deklaratat e regjistrave në aplikacionin tuaj dhe shikoni ato regjistra në panelin Logcat.
  • Kuptoni dhe punoni me një Aktivitet dhe një Synim dhe jini të qetë duke bashkëvepruar me ta.

Çfarë do të mësoni

  • Si funksionon cikli i jetës së Aktivitetit.
  • Kur një Aktivitet fillon, ndalon, ndalon dhe shkatërrohet.
  • Rreth metodave të kthimit të thirrjes së ciklit të jetës që lidhen me ndryshimet e aktivitetit.
  • Efekti i veprimeve (të tilla si ndryshimet e konfigurimit) që mund të rezultojnë në ngjarje të ciklit jetësor të Aktivitetit.
  • Si të ruani gjendjen e aktivitetit përgjatë ngjarjeve të ciklit jetësor.

Çfarë do të bëni

  • Shtoni kodin në aplikacionin TwoActivities nga praktika e mëparshme për të zbatuar thirrjet e ndryshme të ciklit jetësor të Aktivitetit për të përfshirë deklaratat e regjistrimit.
  • Vëzhgoni ndryshimet e gjendjes ndërsa aplikacioni juaj funksionon dhe ndërsa ndërveproni me çdo aktivitet në aplikacionin tuaj.
  • Ndryshoni aplikacionin tuaj për të ruajtur gjendjen e shembullit të një aktiviteti që është rikrijuar papritur në përgjigje të sjelljes së përdoruesit ose ndryshimit të konfigurimit në pajisje.

2. Pasqyrë e aplikacionit

Në këtë praktikë, ju i shtoni aplikacionit TwoActivities . Aplikacioni duket dhe sillet afërsisht njësoj si në laboratorin e fundit të kodeve. Ai përmban dy implementime të Aktivitetit dhe i jep përdoruesit mundësinë për të dërguar mes tyre. Ndryshimet që i bëni aplikacionit në këtë praktikë nuk do të ndikojnë në sjelljen e dukshme të përdoruesit.

3. 3. Detyra 1: Shtoni thirrjet kthyese të ciklit jetësor në TwoActivities

Në këtë detyrë ju do të zbatoni të gjitha metodat e kthimit të thirrjes së ciklit jetësor të Aktivitetit për të printuar mesazhe në logcat kur ato metoda thirren. Këto mesazhe të regjistrit do t'ju lejojnë të shihni se kur ndryshon gjendjen e ciklit jetësor të Aktivitetit dhe se si këto ndryshime të gjendjes së ciklit jetësor ndikojnë në aplikacionin tuaj ndërsa ai funksionon.

1.1 (Opsionale) Kopjo projektin TwoActivities

Për detyrat në këtë praktikë, ju do të modifikoni projektin ekzistues TwoActivities që keni ndërtuar në praktikën e fundit. Nëse preferoni ta mbani të paprekur projektin e mëparshëm TwoActivities, ndiqni hapat në Shtojcën: Shërbimet për të bërë një kopje të projektit.

1.2 Zbatoni kthimet e thirrjeve në MainActivity

  1. Hapni projektin TwoActivities në Android Studio dhe hapni MainActivity në panelin Project > Android.
  2. Në metodën onCreate(), shtoni deklaratat e mëposhtme të regjistrit: 
Log.d(LOG_TAG, "-------");
Log.d(LOG_TAG, "onCreate");
  1. Shtoni një anulim për kthimin e thirrjes onStart(), me një deklaratë në regjistrin për atë ngjarje: 
@Override
public void onStart(){
    super.onStart();
    Log.d(LOG_TAG, "onStart");
}

Për një shkurtore, zgjidhni Kodi > Metodat e anashkalimit në Android Studio. Shfaqet një dialog me të gjitha metodat e mundshme që mund të anashkaloni në klasën tuaj. Zgjedhja e një ose më shumë metodave të kthimit të thirrjes nga lista fut një shabllon të plotë për ato metoda, duke përfshirë thirrjen e kërkuar në superklasë.

  1. Përdorni metodën onStart() si shabllon për të zbatuar thirrjet kthyese të ciklit jetësor onPause(), onRestart(), onResume(), onStop() dhe onDestroy().

Të gjitha metodat e kthimit të thirrjes kanë të njëjtat nënshkrime (përveç emrit). Nëse kopjoni dhe ngjitni onStart() për të krijuar këto metoda të tjera të kthimit të thirrjes, mos harroni të përditësoni përmbajtjen për të thirrur metodën e duhur në superclass dhe për të regjistruar metodën e duhur.

  1. Ekzekutoni aplikacionin tuaj.
  2. Klikoni në skedën Logcat në fund të Android Studio për të shfaqur panelin Logcat. Ju duhet të shihni tre mesazhe regjistri që tregojnë tre gjendjet e ciklit jetësor nëpër të cilat Aktiviteti ka kaluar kur filloi: 
D/MainActivity: -------
D/MainActivity: onCreate
D/MainActivity: onStart
D/MainActivity: onResume

1.3 Zbatoni thirrjet kthyese të ciklit jetësor në SecondActivity

Tani që keni zbatuar metodat e kthimit të thirrjes së ciklit jetësor për MainActivity, bëni të njëjtën gjë për SecondActivity.

  1. Hapni SecondActivity.
  2. Në krye të klasës, shtoni një konstante për ndryshoren LOG_TAG: 
private static final String LOG_TAG = SecondActivity.class.getSimpleName();
  1. Shtoni thirrjet kthyese të ciklit jetësor dhe deklaratat e regjistrit në Aktivitetin e dytë. (Mund të kopjoni dhe ngjitni metodat e kthimit të thirrjes nga MainActivity.)
  2. Shtoni një deklaratë regjistri në metodën returnReply() pak përpara metodës finish(): 
Log.d(LOG_TAG, "End SecondActivity");

1.4 Vëzhgoni regjistrin ndërsa aplikacioni funksionon**

  1. Ekzekutoni aplikacionin tuaj.
  2. Klikoni në skedën Logcat në fund të Android Studio për të shfaqur panelin Logcat.
  3. Futni Aktivitetin në kutinë e kërkimit. Logcat Android mund të jetë shumë i gjatë dhe i ngatërruar. Për shkak se ndryshorja LOG_TAG në secilën klasë përmban ose fjalët Aktiviteti kryesor ose SecondActivity, kjo fjalë kyçe ju lejon të filtroni regjistrin vetëm për gjërat që ju interesojnë.

Probleme të dyfishta

Eksperimentoni duke përdorur aplikacionin tuaj dhe vini re se ngjarjet e ciklit jetësor që ndodhin në përgjigje të veprimeve të ndryshme. Në veçanti, provoni këto gjëra:

  • Përdorni aplikacionin normalisht (dërgoni një mesazh, përgjigjuni me një mesazh tjetër).
  • Përdorni butonin Prapa për t'u kthyer nga Aktiviteti i dytë në Aktivitetin kryesor.
  • Përdorni shigjetën lart në shiritin e aplikacionit për t'u kthyer nga Aktiviteti i dytë në Aktivitetin kryesor.
  • Rrotulloni pajisjen si në aktivitetin kryesor ashtu edhe në atë të dytë në kohë të ndryshme në aplikacionin tuaj dhe vëzhgoni se çfarë ndodh në * regjistër dhe në ekran.
  • Shtypni butonin e përmbledhjes (butonin katror në të djathtë të Home) dhe mbyllni aplikacionin (prekni X).
  • Kthehuni në ekranin bazë dhe rinisni aplikacionin tuaj.

KËSHILLA: Nëse jeni duke e ekzekutuar aplikacionin tuaj në një emulator, mund të simuloni rrotullimin me Control+F11 ose Control+Function+F11.

Kodi i zgjidhjes së detyrës 1

Pjesët e mëposhtme të kodit tregojnë kodin e zgjidhjes për detyrën e parë.

Aktiviteti Kryesor

Pjesët e mëposhtme të kodit tregojnë kodin e shtuar në MainActivity, por jo të gjithë klasën.

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

Metodat e tjera të ciklit jetësor:

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

Veprimtaria e Dytë

Pjesët e mëposhtme të kodit tregojnë kodin e shtuar në SecondActivity, por jo të gjithë klasën.

Në krye të klasës SecondActivity:

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

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

Metodat e tjera të ciklit jetësor:

Njësoj si për MainActivity, më lart.

4. 4. Detyra 2: Ruani dhe rivendosni gjendjen e shembullit të aktivitetit

Në varësi të burimeve të sistemit dhe sjelljes së përdoruesit, çdo Aktivitet në aplikacionin tuaj mund të shkatërrohet dhe rindërtohet shumë më shpesh sesa mund të mendoni.

Ju mund ta keni vënë re këtë sjellje në seksionin e fundit kur keni rrotulluar pajisjen ose emulatorin. Rrotullimi i pajisjes është një shembull i një ndryshimi të konfigurimit të pajisjes. Megjithëse rrotullimi është më i zakonshmi, të gjitha ndryshimet e konfigurimit rezultojnë në shkatërrimin dhe rikrijimin e Aktivitetit aktual sikur të ishte i ri. Nëse nuk e keni parasysh këtë sjellje në kodin tuaj, kur ndodh një ndryshim konfigurimi, faqosja juaj e aktivitetit mund të kthehet në pamjen e paracaktuar dhe vlerat fillestare dhe përdoruesit tuaj mund të humbasin vendin e tyre, të dhënat e tyre ose gjendjen e përparimit të tyre në aplikacionin tuaj.

Gjendja e çdo Aktiviteti ruhet si një grup çiftesh çelësash/vlerash në një objekt Bundle të quajtur gjendje e shembullit të aktivitetit. Sistemi ruan informacionin e gjendjes së paracaktuar në "Bundle" të gjendjes së shembullit pak përpara se të ndalet "Aktiviteti" dhe ia kalon atë "Bundle" në instancën e re të "Aktivitetit" për ta rikthyer.

Për të shmangur humbjen e të dhënave në një Aktivitet kur ai shkatërrohet dhe rikrijohet papritur, ju duhet të zbatoni metodën onSaveInstanceState(). Sistemi e thërret këtë metodë në Aktivitetin tuaj (midis onPause() dhe onStop()) kur ekziston mundësia që Aktiviteti të shkatërrohet dhe rikrijohet.

Të dhënat që ruani në gjendjen e shembullit janë specifike vetëm për këtë shembull të këtij aktiviteti specifik gjatë sesionit aktual të aplikacionit. Kur ndaloni dhe rinisni një sesion të ri aplikacioni, gjendja e shembullit të aktivitetit humbet dhe Aktiviteti kthehet në pamjen e tij të paracaktuar. Nëse keni nevojë të ruani të dhënat e përdoruesit midis sesioneve të aplikacionit, përdorni preferencat e përbashkëta ose një bazë të dhënash. Ju mësoni për të dyja këto në një praktikë të mëvonshme.

2.1 Ruani gjendjen e shembullit të aktivitetit me onSaveInstanceState()

Ju mund të keni vënë re se rrotullimi i pajisjes nuk ndikon aspak në gjendjen e Aktivitetit të dytë. Kjo ndodh sepse paraqitja dhe gjendja e dytë e Aktivitetit krijohen nga faqosja dhe qëllimi që e aktivizoi atë. Edhe nëse Aktiviteti rikrijohet, qëllimi është ende aty dhe të dhënat në atë Intent përdoren ende sa herë që thirret metoda onCreate() në Aktivitetin e dytë.

Përveç kësaj, mund të vëreni se në çdo Aktivitet, çdo tekst që keni shkruar në mesazh ose në elementët e përgjigjes EditText ruhet edhe kur pajisja rrotullohet. Kjo është për shkak se informacioni i gjendjes së disa prej elementeve të View në paraqitjen tuaj ruhen automatikisht gjatë ndryshimeve të konfigurimit dhe vlera aktuale e një EditText është një nga ato raste.

Pra, e vetmja gjendje e Aktivitetit që ju intereson janë elementët TextView për kokën e përgjigjes dhe teksti i përgjigjes në Aktivitetin kryesor. Të dy elementët TextView janë të padukshëm si parazgjedhje; ato shfaqen vetëm pasi të dërgoni një mesazh në Aktivitetin kryesor nga Aktiviteti i dytë.

Në këtë detyrë ju shtoni kodin për të ruajtur gjendjen e shembullit të këtyre dy elementëve TextView duke përdorur onSaveInstanceState().

  1. Hapni MainActivity.
  2. Shtoni këtë implementim skeletor të onSaveInstanceState() në Aktivitet, ose përdorni Code > Override Methods për të futur një anulim të skeletit. 
@Override
public void onSaveInstanceState(Bundle outState) {
          super.onSaveInstanceState(outState);
}
  1. Kontrolloni për të parë nëse kreu është aktualisht i dukshëm, dhe nëse po vendoseni gjendjen e dukshmërisë në gjendjen Bundle me metodën putBoolean() dhe çelësin "reply_visible". 
 if (mReplyHeadTextView.getVisibility() == View.VISIBLE) {
        outState.putBoolean("reply_visible", true);
    }

Mos harroni se titulli i përgjigjes dhe teksti janë shënuar të padukshëm derisa të ketë një përgjigje nga Aktiviteti i dytë. Nëse titulli është i dukshëm, atëherë ka të dhëna të përgjigjes që duhet të ruhen. Vini re se ne jemi të interesuar vetëm për atë gjendje të dukshmërisë - teksti aktual i kokës nuk ka nevojë të ruhet, sepse ai tekst nuk ndryshon kurrë.

  1. Brenda të njëjtit kontroll, shtoni tekstin e përgjigjes në Pako. 
outState.putString("reply_text",mReplyTextView.getText().toString());

Nëse titulli është i dukshëm, mund të supozoni se vetë mesazhi i përgjigjes është gjithashtu i dukshëm. Nuk keni nevojë të provoni ose ruani gjendjen aktuale të dukshmërisë së mesazhit të përgjigjes. Vetëm teksti aktual i mesazhit shkon në paketën e gjendjes me tastin "përgjigje_tekst".

Ju ruani gjendjen e vetëm atyre elementeve të View që mund të ndryshojnë pasi të krijohet Aktiviteti. Elementët e tjerë të View në aplikacionin tuaj (EditText, Button) mund të rikrijohen nga faqosja e paracaktuar në çdo kohë.

Vini re se sistemi do të ruajë gjendjen e disa elementeve të View, siç është përmbajtja e EditText.

2.2 Rivendosni gjendjen e shembullit të aktivitetit në onCreate()

Pasi të keni ruajtur gjendjen e shembullit të Aktivitetit, duhet gjithashtu ta rivendosni atë kur Aktiviteti të rikrijohet. Këtë mund ta bëni ose në onCreate(), ose duke zbatuar kthimin e thirrjes onRestoreInstanceState(), i cili thirret pas onStart() pasi të krijohet Aktiviteti.

Në shumicën e rasteve, vendi më i mirë për të rivendosur gjendjen e Aktivitetit është në onCreate(), për t'u siguruar që UI, përfshirë gjendjen, të jetë i disponueshëm sa më shpejt të jetë e mundur. Ndonjëherë është e përshtatshme për ta bërë atë në onRestoreInstanceState() pasi të jetë kryer i gjithë inicializimi, ose të lejohen nënklasat të vendosin nëse do të përdorin zbatimin tuaj të paracaktuar.

  1. Në metodën onCreate(), pasi variablat View janë inicializuar me findViewById(), shtoni një test për t'u siguruar që savedInstanceState nuk është 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) {
}

Kur krijohet Aktiviteti juaj, sistemi ia kalon statusin Bundle në onCreate() si argumentin e tij të vetëm. Herën e parë që thirret onCreate() dhe fillon aplikacioni juaj, Pakoja është e pavlefshme—nuk ka asnjë gjendje ekzistuese herën e parë që fillon aplikacioni juaj. Thirrjet pasuese në onCreate() kanë një paketë të mbushur me të dhënat që keni ruajtur në onSaveInstanceState().

  1. Brenda atij kontrolli, nxirrni dukshmërinë aktuale (e vërtetë ose e rreme) nga Pakoja me çelësin "reply_visible". 
if (savedInstanceState != null) {
    boolean isVisible = 
                     savedInstanceState.getBoolean("reply_visible");
}
  1. Shtoni një test nën atë rresht të mëparshëm për variablin isVisible. 
if (isVisible) {
}

Nëse ka një çelës reply_visible në paketën e gjendjes (dhe është e dukshme është për rrjedhojë e vërtetë), do t'ju duhet të rivendosni gjendjen.

  1. Brenda testit isVisible, bëjeni kokën të dukshme. 
mReplyHeadTextView.setVisibility(View.VISIBLE);
  1. Merrni mesazhin e përgjigjes me tekst nga Pakoja me tastin "reply_text" dhe vendosni përgjigjen TextView që të tregojë atë varg. 
mReplyTextView.setText(savedInstanceState.getString("reply_text"));
  1. Bëjeni të dukshme edhe përgjigjen TextView: 
mReplyTextView.setVisibility(View.VISIBLE);
  1. Ekzekutoni aplikacionin. Provoni të rrotulloni pajisjen ose emulatorin për t'u siguruar që mesazhi i përgjigjes (nëse ka një të tillë) të mbetet në ekran pas rikrijimit të Aktivitetit.

Kodi i zgjidhjes së detyrës 2

Pjesët e mëposhtme të kodit tregojnë kodin e zgjidhjes për këtë detyrë.

Aktiviteti Kryesor

Pjesët e mëposhtme të kodit tregojnë kodin e shtuar në MainActivity, por jo të gjithë klasën.

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

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

Projekti i plotë:

Projekti Android Studio: TwoActivitiesLifecycle

5. Kodimi

Sfida: Krijoni një aplikacion të thjeshtë të listës së blerjeve me një aktivitet kryesor për listën që përdoruesi po ndërton dhe një aktivitet të dytë për një listë të artikujve të zakonshëm të blerjeve.

  • Aktiviteti kryesor duhet të përmbajë listën për t'u ndërtuar, e cila duhet të përbëhet nga dhjetë elementë bosh TextView.
  • Një buton "Shto artikull" në aktivitetin kryesor nis një aktivitet të dytë që përmban një listë të artikujve të zakonshëm të blerjeve (Djathë, Oriz, Mollë, etj.). Përdorni elementët e butonit për të shfaqur artikujt.
  • Zgjedhja e një artikulli e kthen përdoruesin në aktivitetin kryesor dhe përditëson një TextView bosh për të përfshirë artikullin e zgjedhur.

Përdorni një qëllim për të kaluar informacion nga një aktivitet në tjetrin. Sigurohuni që gjendja aktuale e listës së blerjeve të ruhet kur përdoruesi rrotullon pajisjen.

6. Përmbledhje

  • Cikli i jetës së Aktivitetit është një grup gjendjesh nëpër të cilat Aktiviteti migron, duke filluar kur krijohet për herë të parë dhe duke përfunduar kur sistemi Android rimerr burimet për atë aktivitet.
  • Ndërsa përdoruesi lundron nga një Aktivitet në tjetrin dhe brenda dhe jashtë aplikacionit tuaj, çdo Aktivitet lëviz midis gjendjeve në ciklin e jetës së Aktivitetit.
  • Çdo gjendje në ciklin jetësor të Aktivitetit ka një metodë përkatëse të kthimit të thirrjes që mund ta anashkaloni në klasën tuaj të Aktivitetit.
  • Metodat e ciklit jetësor janë onCreate(), onStart(), onPause(), onRestart(), onResume(), onStop(), onDestroy().
  • Mbështetja e një metode të kthimit të thirrjes së ciklit jetësor ju lejon të shtoni sjellje që ndodh kur Aktiviteti juaj kalon në atë gjendje.
  • Mund të shtoni metoda të anashkalimit të skeletit në klasat tuaja në Android Studio me Code > Override.
  • Ndryshimet e konfigurimit të pajisjes, si p.sh. rrotullimi, çojnë në shkatërrimin dhe rikrijimin e Aktivitetit sikur të ishte i ri.
  • Një pjesë e gjendjes Aktiviteti ruhet në një ndryshim konfigurimi, duke përfshirë vlerat aktuale të elementeve EditText. Për të gjitha të dhënat e tjera, duhet t'i ruani vetë ato në mënyrë eksplicite.
  • Ruaj gjendjen e shembullit të aktivitetit në metodën onSaveInstanceState().
  • Të dhënat e gjendjes së shembullit ruhen si çifte të thjeshta çelësi/vlere në një Pako. Përdorni metodat Bundle për të vendosur të dhëna dhe për t'i nxjerrë të dhënat përsëri nga Pakoja.
  • Rivendosni gjendjen e shembullit në onCreate(), që është mënyra e preferuar, ose onRestoreInstanceState(). Mbrapa