App Lifecycle: यह क्या है, iOS और Android में ऐप की अवस्थाएँ

App Lifecycle क्या है?

App Lifecycle एक सीमित अवस्था मशीन है जो मोबाइल ऐप की सभी संभावित अवस्थाओं और उनके बीच संक्रमण का वर्णन करती है। प्रत्येक अवस्था निर्धारित करती है कि ऐप कोड निष्पादित कर सकता है, UI प्रदर्शित कर सकता है और संसाधनों का उपभोग कर सकता है। iOS और Android के मॉडल समान लेकिन समान नहीं हैं — अंतर OS आर्किटेक्चर के कारण हैं: iOS सख्त मेमोरी नियंत्रण (suspended अवस्था) का उपयोग करता है, जबकि Android onSaveInstanceState के माध्यम से लचीला प्रक्रिया प्रबंधन का उपयोग करता है।

iOS में, जीवनचक्र अग्रभूमि/पृष्ठभूमि से कसकर जुड़ा होता है: ऐप या तो सक्रिय है या निलंबित। Android में, जीवनचक्र अधिक दानेदार है — एक Activity/विंडो 6+ अवस्थाओं से गुज़रती है, और प्रक्रिया का स्वयं ProcessLifecycleOwner के माध्यम से एक अतिरिक्त जीवनचक्र होता है। आधुनिक ऐप (2024 से) तेज़ी से जीवनचक्र-आधारित आर्किटेक्चर पैटर्न का उपयोग कर रहे हैं: SwiftUI Lifecycle (iOS 16+) .scenePhase पर्यावरण के माध्यम से, Compose Lifecycle LifecycleEventObserver के माध्यम से। ये पैटर्न स्वचालित रूप से संदर्भ स्विचिंग को संभालते हैं और मेमोरी लीक को रोकते हैं। Google के अनुसार, Android में उचित जीवनचक्र प्रबंधन पृष्ठभूमि कार्य के दौरान मेमोरी खपत को 30–40 % तक कम करता है।

iOS जीवनचक्र: AppDelegate और SceneDelegate

iOS में, ऐप जीवनचक्र UIApplicationDelegate वर्ग (AppDelegate) के माध्यम से प्रबंधित किया जाता है। मुख्य विधियाँ: application(_:didFinishLaunchingWithOptions:) — पहले लॉन्च पर आरंभीकरण; applicationDidBecomeActive — ऐप दृश्यमान और इंटरैक्शन के लिए तैयार; applicationWillResignActive — निष्क्रिय अवस्था में संक्रमण (इनकमिंग कॉल, नोटिफिकेशन शेड बंद करना); applicationDidEnterBackground — ऐप छिपा हुआ, डेटा सहेजने के लिए ~5 सेकंड; applicationWillEnterForeground — पृष्ठभूमि से वापसी; applicationWillTerminate — समाप्ति (केवल पुराने ऐप के लिए बिना suspended के कॉल किया जाता है)।

iOS 13 से शुरू करके, Apple ने iPad और macOS Catalyst पर बहु-विंडो ऐप का समर्थन करने के लिए SceneDelegate (UISceneDelegate) पेश किया। SceneDelegate प्रत्येक व्यक्तिगत दृश्य (विंडो) के जीवनचक्र का प्रबंधन करता है: scene(_:willConnectTo:options:) — दृश्य निर्माण; sceneDidBecomeActive — दृश्य सक्रिय; sceneWillResignActive — दृश्य फ़ोकस खोता है; sceneDidEnterBackground — दृश्य छिपा हुआ। AppDelegate वैश्विक घटनाओं (डेटा लोडिंग, पुश नोटिफिकेशन) को संभालता है, जबकि SceneDelegate प्रत्येक विंडो की UI स्थिति को संभालता है। SwiftUI में, जीवनचक्र को @Environment(\.scenePhase): .active, .inactive, .background पर्यावरण मान के माध्यम से संभाला जाता है — यह SwiftUI और UIKit ऐप दोनों के लिए एक एकीकृत API प्रदान करता है।

Android जीवनचक्र: Application और ProcessLifecycleOwner

Android में, जीवनचक्र Application वर्ग से शुरू होता है — एक सिंगलटन जो किसी भी Activity से पहले बनाया जाता है। Application.onCreate() विधि पहला प्रवेश बिंदु है, जिसका उपयोग वैश्विक आरंभीकरण (Analytics, DI, Crash Reporting) के लिए किया जाता है। उसके बाद, Activity अनुक्रम के साथ लॉन्च होती है: onCreate() → onStart() → onResume()। छोटा करने पर: onPause() → onStop() → onSaveInstanceState()। नष्ट होने पर: onDestroy()। वापस आने पर: onRestart() → onStart() → onResume()।

ProcessLifecycleOwner (AndroidX Lifecycle 2.2+ से) पूरी प्रक्रिया के जीवनचक्र को ट्रैक करता है, न कि किसी व्यक्तिगत Activity का। यह दो अवस्थाएँ प्रदान करता है: ON_RESUME (ऐप अग्रभूमि में) और ON_STOP (ऐप छिपा हुआ)। ProcessLifecycleOwner प्रक्रिया स्तर पर «ऐप पृष्ठभूमि में कब गया» की समस्या को हल करता है — यह SDK, लाइब्रेरी और मॉड्यूलर ऐप के लिए महत्वपूर्ण है। Jetpack Compose में, जीवनचक्र LifecycleEventObserver और collectAsStateWithLifecycle के माध्यम से प्रबंधित किया जाता है, जो पृष्ठभूमि मोड में स्वचालित रूप से डेटा संग्रह को निलंबित करता है। Android 14 (API 34) ने Service.onTimeout के माध्यम से अग्रभूमि सेवा जीवनचक्र अधिसूचना जोड़ी — सेवा को 6 घंटे के भीतर पूरा होना चाहिए, अन्यथा सिस्टम इसे जबरन रोक देता है।

iOS और Android जीवनचक्र की तुलना

मुख्य अंतर: iOS पृष्ठभूमि में प्रवेश करने के 5-10 सेकंड बाद ऐप को जबरन Suspended (कोड निष्पादन बंद) में स्थानांतरित करता है। Android लंबी अवधि के लिए पृष्ठभूमि कार्य (सेवाएँ, WorkManager) की अनुमति देता है, लेकिन Doze Mode (Android 6+) और पृष्ठभूमि प्रतिबंधों (Android 12+) की सीमाओं के साथ। Android में ProcessLifecycleOwner iOS में UIApplicationDidEnterBackgroundNotification के समतुल्य है, इस अंतर के साथ कि यह पृष्ठभूमि में किसी भी संक्रमण पर सक्रिय होता है, न कि केवल फ़ोकस खोने के बाद।

कोड उदाहरण

iOS: जीवनचक्र विधियों के साथ AppDelegate

सभी जीवनचक्र अवस्थाओं को संभालने वाला मूल AppDelegate कार्यान्वयन। पृष्ठभूमि में जाने पर डेटा सहेजना और वापस आने पर UI अपडेट करना।

import UIKit

@main
class AppDelegate: UIResponder, UIApplicationDelegate {

    func application(
        _ application: UIApplication,
        didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
    ) -> Bool {
        Analytics.shared.initialize()
        return true
    }

    func applicationDidBecomeActive(_ application: UIApplication) {
        NotificationCenter.default.post(name: .appDidBecomeActive, object: nil)
    }

    func applicationWillResignActive(_ application: UIApplication) {
        NotificationCenter.default.post(name: .appWillResignActive, object: nil)
    }

    func applicationDidEnterBackground(_ application: UIApplication) {
        CoreDataManager.shared.saveContext()
        UserDefaults.standard.synchronize()
    }

    func applicationWillEnterForeground(_ application: UIApplication) {
        NetworkManager.shared.refreshSession()
    }
}

AppDelegate केंद्रीय जीवनचक्र बिंदु है। applicationDidEnterBackground एक महत्वपूर्ण विधि है: iOS सहेजने के लिए ~5 सेकंड देता है। applicationDidBecomeActive — UI अपडेट करें, एनिमेशन पुनः शुरू करें। SceneDelegate (iOS 13+) के लिए, जीवनचक्र तर्क दृश्यों में वितरित किया जाता है: sceneDidBecomeActive / sceneDidEnterBackground व्यक्तिगत विंडो का प्रबंधन करते हैं।

iOS: SceneDelegate (iOS 13+)

बहु-विंडो iPad ऐप के लिए SceneDelegate। प्रत्येक दृश्य का अपना जीवनचक्र होता है, जो अन्य विंडो से स्वतंत्र होता है।

import UIKit

class SceneDelegate: UIResponder, UIWindowSceneDelegate {

    var window: UIWindow?

    func scene(
        _ scene: UIScene,
        willConnectTo session: UISceneSession,
        options connectionOptions: UIScene.ConnectionOptions
    ) {
        guard let windowScene = (scene as? UIWindowScene) else { return }
        window = UIWindow(windowScene: windowScene)
        window?.rootViewController = ViewController()
        window?.makeKeyAndVisible()
    }

    func sceneDidBecomeActive(_ scene: UIScene) {
        PlayerManager.shared.resume()
    }

    func sceneDidEnterBackground(_ scene: UIScene) {
        PlayerManager.shared.pause()
        CoreDataManager.shared.saveContext()
    }

    func sceneDidDisconnect(_ scene: UIScene) {
        PlayerManager.shared.cleanup()
    }
}

SceneDelegate एक व्यक्तिगत दृश्य के जीवनचक्र का प्रबंधन करता है। sceneDidBecomeActive / sceneDidEnterBackground एक विशिष्ट विंडो के लिए AppDelegate विधियों के समतुल्य हैं। sceneDidDisconnect दृश्य बंद होने पर कॉल किया जाता है (उपयोगकर्ता ने iPad पर विंडो बंद कर दी)। iOS 12 और नीचे के साथ संगतता के लिए, AppDelegate को SceneDelegate तर्क को दोहराना चाहिए। iOS 17+ में, आप scenePhase के आधार पर कार्यों को स्वचालित रूप से रोकने/फिर से शुरू करने के लिए @Observable का उपयोग कर सकते हैं।

Android: ProcessLifecycleOwner के साथ Application

ProcessLifecycleOwner ट्रैक करता है कि ऐब प्रक्रिया स्तर पर अग्रभूमि/पृष्ठभूमि में कब है। यह वैश्विक जीवनचक्र प्रबंधन के लिए इष्टतम दृष्टिकोण है।

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 ऐप स्तर पर पृष्ठभूमि में संक्रमण को ट्रैक करने का एकमात्र सही तरीका है। ON_START तब सक्रिय होता है जब ऐप दृश्यमान हो जाता है (अग्रभूमि), ON_STOP — जब पूरी तरह से छिपा होता है (पृष्ठभूमि)। Activity जीवनचक्र के विपरीत, ProcessLifecycleOwner किसी विशिष्ट स्क्रीन से बंधा नहीं है। Jetpack Compose के लिए, मैन्युअल अवलोकन के बजाय LifecycleResumeEffect या collectAsStateWithLifecycle का उपयोग करें।

Android: ViewModel के साथ Activity जीवनचक्र

ViewModel + Lifecycle जीवनचक्र प्रबंधन के लिए सही Android आर्किटेक्चर है। ViewModel स्वचालित रूप से onDestroy पर साफ़ हो जाता है, लीक को रोकता है।

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 — संसाधन मुक्त किए जा रहे हैं")
    }
}

// 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 — एनिमेशन रोके जा रहे हैं")
    }

    override fun onDestroy() {
        super.onDestroy()
        Logger.d("Activity destroyed — सफाई")
    }
}

ViewModel स्क्रीन रोटेशन से बचता है और केवल Activity के समाप्त होने पर नष्ट होता है। onCleared() संसाधनों को मुक्त करने और स्ट्रीम से सब्सक्रिप्शन हटाने का स्थान है। LiveData स्वचालित रूप से onPause पर अवलोकन रोकता है और onResume पर फिर से शुरू करता है — यह पृष्ठभूमि कार्य के दौरान लीक और क्रैश से सुरक्षा प्रदान करता है। Compose में, इसी उद्देश्य के लिए collectAsStateWithLifecycle() का उपयोग करें।