Жизнен цикъл в мобилната разработка: какво е, какви етапи и как работи

Жизнен цикъл на приложението (App Lifecycle)

Преди да разгледаме жизнения цикъл на отделните екрани, е важно да разберем жизнения цикъл на цялото приложение. В iOS приложението преминава през пет състояния: Not Running (не работи), Inactive (на фон, не приема събития), Active (активно), Background (на фон, кодът се изпълнява) и Suspended (на фон, кодът е спрян). Тези състояния се управляват в AppDelegate чрез методите applicationDidFinishLaunching, applicationDidBecomeActive, applicationWillResignActive, applicationDidEnterBackground и applicationWillTerminate.

В Android еквивалентът е Application Lifecycle, който се проследява чрез интерфейса Application.ActivityLifecycleCallbacks. Въпреки това, Android се фокусира повече върху жизнения цикъл на Activity — отделен екран на приложението. Това е така, защото Android приложението може да се състои от множество Activities, всяко със собствен цикъл.

Съвременният подход в Android е използването на ProcessLifecycleOwner от библиотеката lifecycle-process. Той позволява проследяване на състоянието на целия процес без обвързване с конкретна Activity. В iOS за проследяване на състоянието на приложението се използва UISceneDelegate (от iOS 13) или AppDelegate. SceneDelegate обработва множество прозорци (multiwindow) на iPad. Разбирането на App Lifecycle е особено важно за IT Sectr при разработване на приложения с фонова синхронизация, стрийминг и VoIP разговори.

Activity Lifecycle в Android

Activity е основният компонент на Android приложението, представляващ един екран. Activity има ясно дефиниран жизнен цикъл, управляван от операционната система в отговор на действия на потребителя и системни събития (завъртане на екрана, входящо повикване, липса на памет).

Какво да правим

Важно: onSaveInstanceState се извиква преди onStop за запазване на временното състояние. Възстановяването се случва в onCreate чрез Bundle savedInstanceState или чрез SavedStateHandle в ViewModel. Без правилно обработване на жизнения цикъл, приложението ще загуби всички незапазени данни при завъртане на екрана.

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    }
    override fun onSaveInstanceState(outState: Bundle) {
        super.onSaveInstanceState(outState)
        outState.putString("draft", draftText)
    }
    override fun onDestroy() {
        super.onDestroy()
        // Отписка от всех подписок
    }
}

Activity Lifecycle в Jetpack Compose

В Jetpack Compose жизненият цикъл на Activity остава непроменен, но Compose предоставя допълнителни инструменти: Композиция, съзнаваща жизнения цикъл чрез LifecycleOwner, ефекти LifecycleEventEffect и DisposableEffect за автоматично почистване на ресурси при унищожаване.

Fragment Lifecycle в детайли

Fragment в Android живее вътре в Activity и има свой собствен жизнен цикъл, който частично се припокрива с Activity, но добавя нови методи. Fragment могат да бъдат добавяни, заменяни, премахвани без унищожаване на Activity, което ги прави по-гъвкави, но и по-сложни.

Основни методи на Fragment Lifecycle: onAttach — Fragment прикрепен към Activity (първо извикване); onCreate — инициализация на данни; onCreateView — създаване на View; onViewCreated — View създадена, UI може да се конфигурира; onStart — Fragment видим; onResume — Fragment на фокус; onPause — Fragment губи фокус; onStop — Fragment не е видим; onDestroyView — View се унищожава; onDestroy — Fragment се унищожава; onDetach — Fragment отделен от Activity.

Основна разлика от Activity: onCreateView и onDestroyView могат да бъдат извикани няколко пъти (например при превключване на TabLayout), докато onCreate се извиква веднъж. Съответно, инициализацията на View трябва да се прави в onViewCreated, а не в onCreateView. Ресурсите, свързани с View (като адаптери на RecyclerView), трябва да се почистват в onDestroyView.

ViewController Lifecycle в iOS

UIViewController е базовият клас за управление на екрани в iOS. Неговият жизнен цикъл се състои от последователност от методи, които UIKit извиква автоматично. Разбирането на този цикъл е критично важно за правилна инициализация на UI, управление на данни и памет.

Типично използване

Важно: viewDidLoad се извиква само веднъж в живота на View Controller. За актуализиране на данни при всяко появяване използвайте viewWillAppear. Ако се абонирате за NotificationCenter в viewWillAppear, не забравяйте да се отпишете в viewDidDisappear, за да избегнете изтичане на памет.

SwiftUI Lifecycle

SwiftUI управлява жизнения цикъл на View чрез структури View. Вместо callback методи, SwiftUI използва модификатори onAppear и onDisappear. За глобални състояния на приложението се използва App Lifecycle чрез протоколите App и Scene. SwiftUI автоматично управлява създаването и унищожаването на View въз основа на състояние, което опростява разработката, но изисква разбиране на идентичността и живота на View.

struct ContentView: View {
    var body: some View {
        Text("Hello")
            .onAppear {
                print("View появилась")
            }
            .onDisappear {
                print("View исчезла")
            }
    }
}

LifecycleOwner и LifecycleObserver в Android

LifecycleOwner е интерфейс от Android Architecture Components, който маркира обект, имащ жизнен цикъл (Activity, Fragment). LifecycleObserver е интерфейс, който позволява на обект да се абонира за събития на LifecycleOwner. Заедно те формират основата на реактивното управление на жизнения цикъл в съвременната Android разработка.

Вместо изрично извикване на методи в onStart/onStop, се препоръчва използването на DefaultLifecycleObserver (замяна на остарелия LifecycleObserver с анотации @OnLifecycleEvent). Това е подходът, който Google популяризира за ViewModel и други компоненти, които трябва да реагират на жизнения цикъл, без да имат директни референции към Activity или Fragment.

class MyObserver : DefaultLifecycleObserver {
    override fun onStart(owner: LifecycleOwner) {
        // Подписка на обновления
    }
    override fun onStop(owner: LifecycleOwner) {
        // Отписка
    }
}

В IT Sectr използваме LifecycleOwner във всички Android проекти. ViewModel се абонира за LifecycleOwner на Activity чрез viewModelScope и lifecycleScope, което гарантира автоматично отменяне на корутините при унищожаване на Activity. Това предотвратява изтичане на памет и прави кода по-чист и по-безопасен.