App Lifecycle: apa itu, status aplikasi di iOS dan Android

Apa itu App Lifecycle?

App Lifecycle — mesin status terbatas yang menggambarkan semua kemungkinan status aplikasi seluler dan transisi di antaranya. Setiap status menentukan apakah aplikasi dapat mengeksekusi kode, menampilkan UI, dan mengonsumsi sumber daya. iOS dan Android memiliki model yang serupa tetapi tidak identik — perbedaan disebabkan oleh arsitektur OS: iOS menggunakan kontrol memori ketat (status suspended), Android — manajemen proses fleksibel melalui onSaveInstanceState.

Di iOS lifecycle terikat erat dengan foreground/background: aplikasi baik aktif atau ditangguhkan. Di Android lifecycle lebih granular — Activity/Window melewati 6+ status, dan proses itu sendiri memiliki lifecycle tambahan melalui ProcessLifecycleOwner. Aplikasi modern (sejak 2024) semakin banyak menggunakan pola arsitektur berbasis lifecycle: SwiftUI Lifecycle (iOS 16+) melalui .scenePhase environment, Compose Lifecycle melalui LifecycleEventObserver. Pola-pola ini secara otomatis menangani peralihan konteks dan mencegah kebocoran memori. Menurut Google, pemrosesan lifecycle yang benar di Android mengurangi konsumsi memori sebesar 30–40% selama kerja latar belakang.

Siklus Hidup iOS: AppDelegate dan SceneDelegate

Di iOS lifecycle aplikasi dikelola melalui kelas UIApplicationDelegate (AppDelegate). Metode utama: application(_:didFinishLaunchingWithOptions:) — inisialisasi saat pertama kali dijalankan; applicationDidBecomeActive — aplikasi terlihat dan siap berinteraksi; applicationWillResignActive — transisi ke status tidak aktif (panggilan masuk, menutup tirai); applicationDidEnterBackground — aplikasi tersembunyi, ada ~5 detik untuk menyimpan data; applicationWillEnterForeground — kembali dari latar belakang; applicationWillTerminate — penghentian (hanya dipanggil untuk aplikasi lama tanpa suspended).

Mulai iOS 13, Apple memperkenalkan SceneDelegate (UISceneDelegate) untuk mendukung aplikasi multi-jendela di iPad dan macOS Catalyst. SceneDelegate mengelola lifecycle setiap adegan (jendela) secara terpisah: scene(_:willConnectTo:options:) — pembuatan adegan; sceneDidBecomeActive — adegan aktif; sceneWillResignActive — adegan kehilangan fokus; sceneDidEnterBackground — adegan tersembunyi. AppDelegate bertanggung jawab atas peristiwa global (memuat data, notifikasi push), dan SceneDelegate — untuk status UI setiap jendela. Di SwiftUI lifecycle dikelola melalui nilai lingkungan @Environment(\.scenePhase): .active, .inactive, .background — ini menyediakan API terpadu untuk aplikasi SwiftUI dan UIKit.

Siklus Hidup Android: Application dan ProcessLifecycleOwner

Di Android lifecycle dimulai dengan kelas Application — singleton yang dibuat sebelum Activity apa pun. Metode Application.onCreate() — titik masuk pertama, digunakan untuk inisialisasi global (Analytics, DI, Crash Reporting). Setelah itu Activity diluncurkan dengan urutan: onCreate() → onStart() → onResume(). Saat diminimalkan: onPause() → onStop() → onSaveInstanceState(). Saat dihancurkan: onDestroy(). Saat kembali: onRestart() → onStart() → onResume().

ProcessLifecycleOwner (dari AndroidX Lifecycle 2.2+) melacak lifecycle seluruh proses, bukan Activity individu. Menyediakan dua status: ON_RESUME (aplikasi di foreground) dan ON_STOP (aplikasi tersembunyi). ProcessLifecycleOwner memecahkan masalah "kapan aplikasi pergi ke latar belakang" di tingkat proses — ini penting untuk SDK, perpustakaan, dan aplikasi modular. Di Jetpack Compose lifecycle dikelola melalui LifecycleEventObserver dan collectAsStateWithLifecycle, yang secara otomatis menjeda pengumpulan data dalam mode latar belakang. Android 14 (API 34) menambahkan notifikasi tentang foreground service lifecycle melalui Service.onTimeout — layanan harus selesai dalam 6 jam, jika tidak sistem akan menghentikannya secara paksa.

Perbandingan lifecycle iOS dan Android

Perbedaan utama: iOS memaksa aplikasi ke Suspended (kode tidak dieksekusi) 5-10 detik setelah masuk ke latar belakang. Android mengizinkan kerja latar belakang (layanan, WorkManager) untuk waktu yang lebih lama, tetapi dengan batasan Doze Mode (Android 6+) dan batasan latar belakang (Android 12+). ProcessLifecycleOwner di Android — analog UIApplicationDidEnterBackgroundNotification di iOS dengan perbedaan bahwa ia dipicu pada setiap transisi ke latar belakang, bukan hanya setelah kehilangan fokus.

Contoh Kode

iOS: AppDelegate dengan metode lifecycle

Implementasi dasar AppDelegate dengan penanganan semua status siklus hidup. Menyimpan data saat transisi ke latar belakang dan memperbarui UI saat kembali.

import UIKit
@main
class AppDelegate: UIResponder, UIApplicationDelegate {
    func application(_: UIApplication, didFinishLaunchingWithOptions lo: [UIApplication.LaunchOptionsKey: Any]?) -> Bool { Analytics.shared.initialize(); return true }
    func applicationDidBecomeActive(_: UIApplication) { NotificationCenter.default.post(name: .appDidBecomeActive, object: nil) }
    func applicationWillResignActive(_: UIApplication) { NotificationCenter.default.post(name: .appWillResignActive, object: nil) }
    func applicationDidEnterBackground(_: UIApplication) { CoreDataManager.shared.saveContext(); UserDefaults.standard.synchronize() }
    func applicationWillEnterForeground(_: UIApplication) { NetworkManager.shared.refreshSession() }
}

AppDelegate — titik pusat lifecycle. applicationDidEnterBackground — metode kritis: iOS memberi ~5 detik untuk menyimpan data. applicationDidBecomeActive — perbarui UI, mulai ulang animasi. Untuk SceneDelegate (iOS 13+) logika lifecycle didistribusikan ke adegan: sceneDidBecomeActive / sceneDidEnterBackground mengelola jendela individual.

iOS: SceneDelegate (iOS 13+)

SceneDelegate untuk aplikasi multi-jendela iPad. Setiap adegan memiliki lifecycle sendiri, independen dari jendela lain.

import UIKit
class SceneDelegate: UIResponder, UIWindowSceneDelegate {
    var window: UIWindow?
    func scene(_: UIScene, willConnectTo s: UISceneSession, options o: UIScene.ConnectionOptions) {
        guard let ws = (_ as? UIWindowScene) else { return }
        window = UIWindow(windowScene: ws)
        window?.rootViewController = ViewController()
        window?.makeKeyAndVisible()
    }
    func sceneDidBecomeActive(_: UIScene) { PlayerManager.shared.resume() }
    func sceneDidEnterBackground(_: UIScene) { PlayerManager.shared.pause(); CoreDataManager.shared.saveContext() }
    func sceneDidDisconnect(_: UIScene) { PlayerManager.shared.cleanup() }
}

SceneDelegate mengelola lifecycle adegan individu. sceneDidBecomeActive / sceneDidEnterBackground — setara dengan metode AppDelegate untuk jendela tertentu. sceneDidDisconnect dipanggil saat adegan ditutup (pengguna menutup jendela di iPad). Untuk menjaga kompatibilitas dengan iOS 12 dan lebih lama, AppDelegate harus menduplikasi logika SceneDelegate. Di iOS 17+ Anda dapat menggunakan @Observable untuk menjeda/melanjutkan tugas secara otomatis berdasarkan scenePhase.

Android: Application dengan ProcessLifecycleOwner

ProcessLifecycleOwner melacak kapan aplikasi berada di foreground/background di tingkat proses. Ini adalah cara optimal untuk manajemen lifecycle global.

import android.app.Application
import androidx.lifecycle.ProcessLifecycleOwner
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleObserver
import androidx.lifecycle.OnLifecycleEvent
class MainApplication : Application() {
    override fun onCreate() { super.onCreate(); ProcessLifecycleOwner.get().lifecycle.addObserver(AppLifecycleObserver()) }
}
class AppLifecycleObserver : LifecycleObserver {
    @OnLifecycleEvent(Lifecycle.Event.ON_START) fun onEnterForeground() { Analytics.shared.onForeground(); NetworkMonitor.shared.start() }
    @OnLifecycleEvent(Lifecycle.Event.ON_STOP) fun onEnterBackground() { Analytics.shared.onBackground(); NetworkMonitor.shared.stop() }
}

ProcessLifecycleOwner — satu-satunya cara yang benar untuk melacak transisi ke latar belakang di tingkat aplikasi. ON_START dipicu saat aplikasi menjadi terlihat (foreground), ON_STOP — saat sepenuhnya tersembunyi (background). Tidak seperti Activity lifecycle, ProcessLifecycleOwner tidak terikat pada layar tertentu. Untuk Jetpack Compose gunakan LifecycleResumeEffect atau collectAsStateWithLifecycle sebagai pengganti pengamatan manual.

Android: Activity Lifecycle dengan ViewModel

ViewModel + Lifecycle — arsitektur Android yang benar untuk bekerja dengan lifecycle. ViewModel secara otomatis dibersihkan saat onDestroy, mencegah kebocoran memori.

import androidx.lifecycle.ViewModel
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
class TimerViewModel : ViewModel() {
    private val _time = MutableLiveData<Long>()
    val time: LiveData<Long> = _time
    private var startTime = System.currentTimeMillis()
    init { updateTime() }
    private fun updateTime() { _time.value = System.currentTimeMillis() - startTime }
    override fun onCleared() { super.onCleared(); Logger.d("ViewModel cleared — membebaskan sumber daya") }
}
// Di Activity
class TimerActivity : AppCompatActivity() {
    private val viewModel: TimerViewModel by viewModels()
    override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState); Logger.d("Activity created") }
    override fun onResume() { super.onResume(); viewModel.time.observe(this) { Logger.d("Time: $it") } }
    override fun onPause() { super.onPause(); Logger.d("Activity paused — menjeda animasi") }
    override fun onDestroy() { super.onDestroy(); Logger.d("Activity destroyed — pembersihan") }
}

ViewModel bertahan dari rotasi layar dan hanya dihancurkan saat finish() Activity. onCleared() — tempat untuk membebaskan sumber daya, berhenti berlangganan dari aliran. LiveData secara otomatis menjeda pengamatan saat onPause dan melanjutkan saat onResume — memberikan perlindungan terhadap kebocoran dan crash selama kerja latar belakang. Di Compose gunakan collectAsStateWithLifecycle() untuk tujuan yang sama.