Activity Lifecycle: ce este, onCreate onStart onResume în Android

Ce este Activity Lifecycle

Activity Lifecycle (ciclul de viață al Activity) este un automat de stări prin care trece fiecare ecran al aplicației Android de la momentul creării până la distrugerea completă. Sistemul Android gestionează acest proces pe baza acțiunilor utilizatorului: deschiderea aplicației, minimizarea, rotirea ecranului, răspunsul la un apel primit, comutarea între aplicații și încheierea lucrului.

Înțelegerea ciclului de viață este necesară pentru fiecare dezvoltator Android, deoarece sistemul poate distruge Activity în orice moment din cauza lipsei de memorie — iar aplicația trebuie să-și restabilească corect starea. Conform datelor Google Android Vitals (2025), aplicațiile care nu gestionează salvarea stării în onSaveInstanceState() prezintă cu 42% mai multe crash-uri la recrearea Activity.

Ciclul de viață include șase metode principale de callback: onCreate(), onStart(), onResume(), onPause(), onStop(), onDestroy(). În plus, există metoda onRestart(), care este apelată înainte de onStart(), când Activity revine din starea oprită. Fiecare metodă are un scop și un timp de execuție strict definite — sistemul le apelează secvențial, iar dezvoltatorul poate suprascrie oricare dintre ele pentru a-și executa propria logică.

Ciclul poate fi împărțit în trei etape cheie: întreaga durată de viață (onCreate → onDestroy), durata de viață vizibilă (onStart → onStop) și durata de viață în prim-plan (onResume → onPause). Înțelegerea acestor trei niveluri ajută la distribuirea corectă a codului de inițializare și eliberare a resurselor.

Metodele ciclului de viață Activity

Fiecare metodă a ciclului de viață îndeplinește o sarcină strict definită. Sistemul le apelează într-o ordine fixă, iar dezvoltatorul ar trebui să suprascrie doar acele metode care sunt necesare pentru logica specifică. Nu se recomandă apelarea directă a metodelor ciclului de viață — de aceasta se ocupă Android Runtime.

Schema generală de apeluri

Secvența tipică la lansarea aplicației: onCreate → onStart → onResume. La apăsarea butonului „Înapoi”: onPause → onStop → onDestroy. La minimizare: onPause → onStop, apoi la revenire: onRestart → onStart → onResume.

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    }

    override fun onStart() {
        super.onStart()
    }

    override fun onResume() {
        super.onResume()
    }

    override fun onPause() {
        super.onPause()
    }

    override fun onStop() {
        super.onStop()
    }

    override fun onDestroy() {
        super.onDestroy()
    }

    override fun onRestart() {
        super.onRestart()
    }
}

Fiecare metodă suprascrisă trebuie să apeleze versiunea super — fără aceasta, sistemul nu va putea finaliza corect tranziția între stări. Această regulă este stipulată în documentația Android Developers și verificată de regulile lint din Android Studio.

Trei niveluri ale ciclului de viață

Primul nivel — întreaga durată de viață (entire lifetime): perioada dintre onCreate și onDestroy. Aici se execută inițializarea unică și eliberarea finală a resurselor globale. Al doilea nivel — durata de viață vizibilă (visible lifetime): între onStart și onStop. Activity este vizibilă pe ecran, dar poate fi parțial acoperită de o altă fereastră. Al treilea nivel — durata de viață în prim-plan (foreground lifetime): între onResume și onPause. Activity se află în vârful stivei de sarcini și interacționează cu utilizatorul.

onCreate — crearea Activity

onCreate() — prima și singura metodă obligatorie a ciclului de viață Activity. Este apelată de sistem o singură dată la crearea instanței Activity. Această metodă primește parametrul savedInstanceState: Bundle?, care conține starea salvată anterior, dacă Activity este recreată după distrugere — de exemplu, la rotirea ecranului.

În interiorul onCreate se execută următoarele sarcini: inițializarea interfeței utilizatorului prin setContentView() cu transmiterea resursei de layout, legarea elementelor View prin findViewById(), configurarea adaptoarelor pentru RecyclerView și ViewPager, restaurarea stării din savedInstanceState, inițializarea ViewModel și LiveData, configurarea ascultătorilor de clicuri și gesturi. Metoda ar trebui să se finalizeze cât mai repede posibil — operațiile de lungă durată blochează redarea primului cadru, ceea ce crește timpul de pornire a aplicației.

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_profile)

    val userNameText: TextView = findViewById(R.id.user_name)
    val loadButton: Button = findViewById(R.id.load_button)

    if (savedInstanceState != null) {
        userNameText.text = savedInstanceState.getString("user_name")
    }

    loadButton.setOnClickListener {
        loadUserProfile()
    }
}

Dacă Activity este creată pentru prima dată, savedInstanceState este null. La recrearea după rotirea ecranului, Bundle conține datele salvate în onSaveInstanceState(). Verificarea pentru null — practică standard pentru restaurarea corectă a UI fără pierderea datelor introduse de utilizator.

onStart — apariția pe ecran

onStart() este apelat imediat după onCreate() sau după onRestart(), când Activity devine vizibilă pentru utilizator. În această stare, Activity nu se află încă în prim-plan și nu poate interacționa cu utilizatorul, dar interfața sa de utilizator este deja vizibilă pe ecran. De exemplu, la lansarea aplicației, între apelul onStart și onResume, sistemul redă primul cadru al interfeței.

În metoda onStart se execută de obicei următoarele acțiuni: pornirea animațiilor care ar trebui să ruleze cât Activity este vizibilă; înregistrarea receptoarelor de transmisie (BroadcastReceiver); conectarea la serviciile de geolocalizare și senzori; actualizarea datelor din ViewModel sau Room. Aici se realizează, de asemenea, legarea la serviciile Bound prin bindService(), dacă aplicația utilizează o arhitectură client-server în cadrul procesului.

override fun onStart() {
    super.onStart()
    val locationManager = getSystemService(Context.LOCATION_SERVICE) as LocationManager
    locationManager.requestLocationUpdates(
        LocationManager.GPS_PROVIDER,
        5000L,
        10f,
        locationListener
    )
}

override fun onStop() {
    super.onStop()
    val locationManager = getSystemService(Context.LOCATION_SERVICE) as LocationManager
    locationManager.removeUpdates(locationListener)
}

Regulă importantă: resursele conectate în onStart trebuie eliberate în onStop. Aceasta garantează că atunci când Activity nu este vizibilă pe ecran, nu consumă baterie și resurse de sistem. Google Play Store verifică aplicațiile pentru scurgeri de LocationListener și alte servicii de sistem la moderarea actualizărilor.

onResume — obținerea focusului

onResume() — starea în care Activity se află în prim-plan și este gata să interacționeze cu utilizatorul. Aceasta este starea de lucru a ecranului: sistemul transmite Activity focusul de intrare, iar toate evenimentele de atingere, introducere de la tastatură și gesturi sunt direcționate către acest ecran. Metoda onResume este apelată de fiecare dată când Activity revine în prim-plan — după finalizarea unei alte Activity, după închiderea unei ferestre de dialog, după deblocarea dispozitivului.

În onResume se execută: reluarea animațiilor care au fost suspendate în onPause; deschiderea camerei și a altor resurse exclusive; înregistrarea ascultătorilor de senzori (accelerometru, giroscop); pornirea timerelor și a cronometrului pentru UI; actualizarea conținutului ecranului cu date actuale. În perechea onResume / onPause se lucrează cu resurse care ar trebui să fie active doar la focus — de exemplu, recunoașterea continuă a vocii sau captura video.

override fun onResume() {
    super.onResume()
    cameraHolder.openCamera()
    animator.resume()
    sensorManager.registerListener(
        stepCounter,
        sensorManager.getDefaultSensor(Sensor.TYPE_STEP_COUNTER),
        SensorManager.SENSOR_DELAY_NORMAL
    )
}

override fun onPause() {
    super.onPause()
    cameraHolder.closeCamera()
    animator.pause()
    sensorManager.unregisterListener(stepCounter)
}

Diferența dintre onStart și onResume este semnificativă: Activity poate fi vizibilă (onStart), dar nu activă (onResume) — de exemplu, atunci când deasupra ei este afișată o fereastră de dialog sau un ecran de blocare transparent. Exact în onResume, nu în onStart, trebuie deschise resursele exclusive care necesită acces monopol.

onPause — pierderea focusului

onPause() este apelat când Activity pierde focusul de intrare, dar rămâne parțial vizibilă. Scenarii tipice: deschiderea unei ferestre de dialog, apăsarea butonului „Aplicații recente”, un apel primit, apăsarea butonului „Acasă” (în acest caz, după onPause va urma onStop). Metoda onPause — ultimul loc fiabil pentru salvarea datelor pe care utilizatorul nu ar trebui să le piardă.

În onPause se execută: salvarea ciornelor de e-mailuri și formularelor în Room sau SharedPreferences; oprirea animațiilor și a redării video; închiderea camerei și eliberarea resurselor exclusive; anularea operațiilor costisitoare, necritice pentru fundal. Metoda onPause ar trebui să se finalizeze în mai puțin de 100 de milisecunde — sistemul blochează tranziția la următoarea Activity până când onPause returnează controlul, iar depășirea limitei duce la ANR (Application Not Responding).

override fun onPause() {
    super.onPause()
    val editor = SharedPreferences.Manager ...
    editor.putString("draft_text", draftEditText.text.toString())
    editor.apply()
    videoView.pause()
    cameraHolder.release()
}

Important: onPause se execută în firul UI, prin urmare orice operații blocante, cum ar fi scrierea în baza de date prin Room cu o interogare sincronă, trebuie înlocuite cu operații asincrone (corutine) sau executate în firul de fundal. Utilizați apply() în loc de commit() pentru SharedPreferences — apply scrie datele asincron și nu blochează firul UI.

onStop — ascunderea de pe ecran

onStop() este apelat când Activity încetează să mai fie vizibilă pentru utilizator. Acest lucru se întâmplă în următoarele cazuri: Activity este complet acoperită de o altă Activity; utilizatorul a apăsat butonul „Acasă” sau a comutat la o altă aplicație; Activity se finalizează (va fi apelat ulterior onDestroy). În starea onStop, Activity rămâne în memorie și păstrează toate câmpurile sale — nu este distrusă, dar nici activă.

În onStop se execută: dezabonarea de la BroadcastReceiver înregistrate în onStart; deconectarea de la serviciile Bound; eliberarea LocationListener, SensorListener și a altor ascultători de sistem; oprirea operațiilor de lungă durată în fundal care nu sunt necesare când aplicația este ascunsă; salvarea stării curente a UI în Bundle prin onSaveInstanceState(), dacă nu a fost făcută în onPause.

override fun onStop() {
    super.onStop()
    unregisterReceiver(connectivityReceiver)
    unbindService(serviceConnection)
    if (isChangingConfigurations()) {
        Log.d("Lifecycle", "Activitatea este recreată din cauza configurației")
    }
}

Sistemul poate distruge Activity în starea onStop fără a apela onDestroy în caz de lipsă de memorie. Prin urmare, toate datele critice trebuie salvate înainte de trecerea în onStop. Steagul isChangingConfigurations() permite determinarea dacă apelul onStop este legat de rotirea ecranului — în acest caz, Activity va fi recreată, nu finalizată.

onDestroy — distrugerea Activity

onDestroy() — ultima metodă a ciclului de viață, apelată înainte de distrugerea completă a Activity. Sistemul apelează onDestroy în două cazuri: Activity se finalizează prin apelul finish() sau utilizatorul apasă butonul „Înapoi”; Activity este distrusă de sistem din cauza unei schimbări de configurare (de exemplu, rotirea ecranului) și va fi creată din nou. Metoda onDestroy permite executarea curățării finale a resurselor: deconectarea firelor de execuție și a corutinelor, închiderea cursorilor și socket-urilor deschise permanent, eliberarea memoriei native prin NDK.

override fun onDestroy() {
    super.onDestroy()
    backgroundJob.cancel()
    dbHelper.close()
    if (isFinishing) {
        Log.d("Lifecycle", "Activitatea se termină definitiv")
    } else {
        Log.d("Lifecycle", "Activitatea va fi recreată")
    }
}

Notă importantă: apelul onDestroy nu este garantat dacă procesul aplicației a fost ucis de sistem (out-of-memory kill). Prin urmare, nu vă puteți baza pe onDestroy pentru salvarea datelor — această sarcină se rezolvă în onPause sau onStop. Proprietatea isFinishing permite deosebirea finalizării Activity prin finish() de recreerea la schimbarea configurării.

onRestart — revenirea din starea oprită

onRestart() este apelat înainte de onStart(), când Activity revine din starea oprită (onStop) înapoi în prim-plan. Acest lucru se întâmplă atunci când utilizatorul redeschide aplicația din meniul „Recente” sau revine la Activity apăsând „Înapoi” în ecranul copil. Metoda onRestart permite executarea unei logici diferite de onCreate — de exemplu, actualizarea datelor care s-ar fi putut schimba în timp ce Activity era ascunsă.

override fun onRestart() {
    super.onRestart()
    refreshDataFromNetwork()
    Log.d("Lifecycle", "Activitatea este repornită din stivă")
}

Scenariu tipic: utilizatorul a deschis aplicația, a comutat la o altă sarcină, iar după o oră s-a întors. În onRestart, aplicația poate verifica actualitatea datelor și, dacă a trecut mult timp, poate propune reîncărcarea conținutului. Acest lucru îmbunătățește experiența utilizatorului și reduce probabilitatea afițării informațiilor învechite.

Rotirea ecranului și salvarea stării

Rotirea ecranului — cel mai frecvent scenariu de recreere a Activity. În mod implicit, Android distruge Activity curentă și creează una nouă la fiecare schimbare de orientare. Dacă starea nu este salvată, utilizatorul va pierde toate datele introduse. În acest scop, Android oferă două mecanisme: onSaveInstanceState() pentru date serializabile și ViewModel pentru date care supraviețuiesc modificărilor de configurare.

onSaveInstanceState și onRestoreInstanceState

onSaveInstanceState() este apelat înainte de distrugerea Activity pentru salvarea stării temporare. Datele salvate sunt transmise în onCreate prin parametrul savedInstanceState și în metoda onRestoreInstanceState(), care este apelată după onStart. Bundle are o limită de dimensiune — aproximativ 500 KB, prin urmare volumele mari de date (de exemplu, bitmap-uri) se salvează prin ViewModel.

<!-- AndroidManifest.xml — fixarea orientării -->
<activity android:name=".MainActivity"
    android:configChanges="orientation|screenSize" />

Fixarea orientării prin android:configChanges previne recreerea Activity, dar este considerat un anti-pattern dacă aplicația trebuie să suporte ambele orientări. Recomandarea modernă a Google — utilizarea ViewModel împreună cu onSaveInstanceState pentru datele pe care utilizatorul le introduce în UI.

Ciclul de viață al Fragmentului

Fragment are propriul ciclu de viață, similar cu Activity, dar cu metode suplimentare: onAttach, onCreate, onCreateView, onViewCreated, onStart, onResume, onPause, onStop, onDestroyView, onDestroy, onDetach. Fragment există întotdeauna în interiorul Activity, iar ciclul său de viață este legat de ciclul de viață al Activity-container. Dacă Activity este distrusă, Fragment o urmează.

Diferența principală: Fragment gestionează nu doar starea componentului, ci și ierarhia View. Metoda onCreateView returnează View-ul rădăcină al fragmentului, iar onDestroyView — distruge această ierarhie. Acest lucru permite Fragmentului să supraviețuiască recreerii Activity la rotirea ecranului: Fragment este păstrat, iar View-ul său este creat din nou în onCreateView.

class ProfileFragment : Fragment() {
    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View {
        return inflater.inflate(R.layout.fragment_profile, container, false)
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        val avatarImage: ImageView = view.findViewById(R.id.avatar_image)
        loadAvatar(avatarImage)
    }
}

Înțelegerea diferenței dintre onCreate și onCreateView este critică: onCreate este apelat o singură dată pe durata de viață a Fragmentului (chiar și la recrearea View-ului), iar onCreateView — de fiecare dată când Fragment creează sau recrează ierarhia sa View. Inițializarea datelor se execută în onCreate, iar legarea UI — în onViewCreated.

LifecycleObserver și Jetpack

LifecycleObserver — component al bibliotecii Android Jetpack care permite reacționarea la modificările ciclului de viață fără a suprascrie metode în Activity sau Fragment. În loc să duplice codul în fiecare metodă a ciclului de viață, dezvoltatorul creează o clasă separată cu adnotări @OnLifecycleEvent și o transmite la lifecycle.addObserver().

Jetpack oferă, de asemenea, clasa LifecycleOwner — o interfață implementată de AppCompatActivity și Fragment. Orice obiect care implementează LifecycleOwner poate gestiona abonamentele LiveData, corutinele prin lifecycleScope și munca WorkManager în legătură cu ciclul de viață. Aceasta este piatra de temelie a arhitecturii moderne Android bazate pe MVVM și Jetpack.

class MyLocationObserver(private val context: Context) : DefaultLifecycleObserver {
    override fun onStart(owner: LifecycleOwner) {
        startLocationUpdates()
    }

    override fun onStop(owner: LifecycleOwner) {
        stopLocationUpdates()
    }
}

// În Activity:
lifecycle.addObserver(MyLocationObserver(this))

Utilizarea DefaultLifecycleObserver simplifică testarea, reduce duplicarea codului și face logica ciclului de viață reutilizabilă între diferite ecrane. Este înlocuitorul modern al suprascrierii manuale a onStart/onStop în fiecare Activity. În aplicațiile Android dezvoltate de IT Sectr, folosim LifecycleObserver pentru geolocalizare, scanare Bluetooth și analitică — aceasta reduce cantitatea de cod boilerplate cu 30–40%.