Active: iOS जीवन चक्र में Active अवस्था क्या है

Active: यह अवस्था क्या है

Active — मोबाइल एप्लिकेशन जीवन चक्र की एक अवस्था जिसमें यह अग्रगमण में होता है, डिवाइस स्क्रीन पर प्रदर्शित होता है और उपयोगकर्ता के साथ सक्रिय रूप से बातचीत करता है। इस अवस्था में, एप्लिकेशन सभी स्पर्श घटनाएँ, कीप्रेस, एक्सेलरोमीटर और जाइरोस्कोप डेटा प्राप्त करता है, और इंटरफ़ेस को रेंडर करने के लिए इसकी ग्राफिक्स प्रोसेसर तक पूर्ण पहुंच होती है।

iOS में, Active अवस्था पांच-अवस्था जीवन चक्र मॉडल का हिस्सा है: Not Running → Inactive → Active → Inactive → Background → Suspended → Not Running। Android में, समकक्ष onResume कॉल के बाद Activity की अवस्था है, जब Activity स्टैक के शिखर पर होती है और उपयोगकर्ता का इनपुट स्वीकार करती है। Active केवल वही अवस्था है जिसमें UI पूर्णतः इंटरैक्टिव है और जेस्चर्स, स्क्रॉलिंग, टैप और एनिमेशन पर प्रतिक्रिया करता है।

सिस्टम Active में एप्लिकेशन को CPU और RAM की सबसे उच्च प्राथमिकता देता है। इसका मतलब है कि संसाधन कम होने पर सिस्टम इस एप्लिकेशन को समाप्त नहीं करेगा — पहले बैकग्रॉंड और निलंबित प्रक्रियाओं को अनलॉड किया जाएगा। हालाँकि, एप्लिकेशन को बैटरी खत्म होने और CPU थ्रॉटलिंग से बचने के लिए संसाधनों का कुशलतापूर्वक उपयोग करना चाहिए।

उपयोगकर्ता के लिए, Active एप्लिकेशन के साथ काम करने की सामान्य अवस्था है। उपयोगकर्ता इंटरफ़ेस देखता है, बटन दबा सकता है, फ़ॉर्म भर सकता है, और फीड में स्क्रॉल कर सकता है। इस अवस्था का कोई भी विघ्न (कॉल, नूटिफिकेशन, Control Center के लिए ऊपर की ओर स्वाइप करना) एप्लिकेशन को Inactive में ले जाता है, जिसके बाद यह Active में लौट सकता है या Background में जा सकता है।

सिस्टम कैसे निर्धारित करता है कि एप्लिकेशन Active है

iOS अवस्था के प्रबंधन के लिए UIApplicationMain का उपयोग करता है। Active में संक्रमण करते समय, सिस्टम applicationDidBecomeActive को कॉल करता है। SwiftUI के लिए, समकक्ष तंत्र Environment के माध्यम से scenePhase का निरीक्षण करना है। Android, अग्रगमण में Activity के संकेतक के रूप में onResume का उपयोग करता है। दोनों दिखाटे गारंटी देते हैं कि एप्लिकेशन को अवस्था परिवर्तन की सूचना प्राप्त होती है और वह अपने व्यवहार को अनुकूलित कर सकता है।

iOS में Active: Swift, UIKit और SwiftUI

iOS में, Active अवस्था को UIApplicationDelegate के माध्यम से संभाला जाता है। मुख्य विधि applicationDidBecomeActive(_:) है। इसे एप्लिकेशन के पहली बार लॉन्च करने पर और Inactive से लौटने पर बुलाया जाता है। यह विधि उन कार्यों को फिर से शुरू करने के लिए आदर्श स्थान है जो Inactive में प्रवेश करने पर रोक दिए गए थे: एनिमेशन शुरू करना, टाइमर फिर से शुरू करना, सेंसर पुनर्आरंभ करना, सर्वर पर डेटा अपडेट की जाँच करना।

UIKit: AppDelegate और SceneDelegate

iOS 13 के साथ, Apple ने iPad पर एकाधिक विंडो को सपोर्ट करने के लिए UISceneDelegate पेश किया। इस मामले में, applicationDidBecomeActive को प्रत्येक व्यक्तिगत सीन के लिए sceneDidBecomeActive से बदल दिया जाता है। केवल एक स्क्रीन का समर्थन करने वाले एप्लिकेशन UIApplicationDelegate का उपयोग जारी रख सकते हैं। दोनों दिखाटे तब बुलाए जाते हैं जब एप्लिकेशन या सीन सक्रिय हो जाती है।

import UIKit

@main
class AppDelegate: UIResponder, UIApplicationDelegate {

    // एप्लिकेशन सक्रिय हो गया — कार्य फिर से शुरू करना
    func applicationDidBecomeActive(_ application: UIApplication) {
        resumeAnimations()
        restartTimers()
        refreshDataIfNeeded()
        startObservingSensors()
    }

    // एप्लिकेशन सक्रियता खो रहा है — रोकना
    func applicationWillResignActive(_ application: UIApplication) {
        pauseAnimations()
        stopTimers()
        saveDraftData()
    }

    private func resumeAnimations() {
        UIView.animate(withDuration: 0.3) {
            // UI एनिमेशन फिर से शुरू करना
        }
    }

    private func refreshDataIfNeeded() {
        let lastRefresh = UserDefaults.standard.object(forKey: "lastRefresh") as? Date ?? .distantPast
        if Date().timeIntervalSince(lastRefresh) > 300 {
            fetchDataFromServer()
        }
    }
}

कोड UIKit में Active का सही संभालन दिखाता है। applicationDidBecomeActive एनिमेशन, टाइमर फिर से शुरू करता है और जाँच करता है कि डेटा अपडेट की आवश्यकता है या नहीं। applicationWillResignActive हर उस चीज़ को रोक देता है जो संसाधनों का उपयोग कर सकती है और ड्राफ़्ट सहेज करता है। विधियों की ऐसी जोड़ी सुनिश्चित करती है कि एप्लिकेशन अवस्था परिवर्तनों का सही ढंग से जवाब देता है।

SwiftUI: scenePhase

SwiftUI में AppDelegate नहीं है — अवस्था प्रबंधन Environment<ScenePhase> के माध्यम से होता है। .active मान तब सेट होता है जब सीन अग्रगमण में और इंटरैक्टिव होती है। SwiftUI Active में लौटने पर स्वचालित रूप से एनिमेशन और अपडेट को पुनर्आरंभ करता है। डिवेलपर को केवल साइड इफेक्ट्स करने के लिए onChange की सदस्यता लेनी होती है

import SwiftUI

@main
struct ActiveDemoApp: App {
    @Environment(\.scenePhase) private var scenePhase

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
        .onChange(of: scenePhase) { oldPhase, newPhase in
            switch newPhase {
            case .active:
                print("सीन सक्रिय हो गई")
                resumeWork()
            case .inactive:
                print("सीन निष्क्रिय हो गई")
                pauseWork()
            case .background:
                print("सीन बैकग्रॉंड में चली गई")
                saveState()
            @unknown default:
                break
            }
        }
    }

    private func resumeWork() {
        // नेटवर्क अनुरोधों को फिर से शुरू करना, एनिमेशन
    }

    private func pauseWork() {
        // समय-संवेदनशील कार्यों को रोकना
    }

    private func saveState() {
        // एप्लिकेशन अवस्था सहेजना
    }
}

SwiftUI में, scenePhase एप्लिकेशन अवस्था के बारे में एकमात्र सत्य स्रोत है। onChange प्रत्येक संक्रमण पर कार्रवाई करने की अनुमति देता है। यह याद रखना महत्वपूर्ण है कि scenePhase केवल iOS 14+ पर और SwiftUI Lifecycle में उपलब्ध है। SwiftUI स्क्रीन वाले UIKit एप्लिकेशन के लिए, UIApplicationDelegate दिखाटे का उपयोग करें।

Active अवस्था में संक्रमण

Active तक कई मार्गों से पहुंचा जा सकता है। पहला और सबसे स्पष्ट है कोल्ड स्टार्ट: उपयोगकर्ता आइकन पर टैप करता है, एप्लिकेशन Not Running से Inactive होते हुए Active में जाता है। दूसरा है बैकग्रॉंड से लौटना: उपयोगकर्ता App Switcher के माध्यम से एप्लिकेशन में वापस जाता है, एप्लिकेशन Inactive से होकर Active हो जाता है। तीसरा है अस्थायी विघ्न से लौटना: उपयोगकर्ता कॉल समाप्त करता है, Control Center बंद करता है, या नूटिफिकेशन का जवाब देता है — एप्लिकेशन Inactive से Active में लौट आता है।

Active में संक्रमणों की श्रृंखला

Not Running → Inactive → Active — कोल्ड स्टार्ट। Background → Inactive → Active — बैकग्रॉंड से लौटना। Inactive → Active — अस्थायी विघ्न से लौटना। प्रत्येक मामले में, applicationDidBecomeActive को बुलाया जाता है, लेकिन संदर्भ भिन्न हो सकता है। कोल्ड स्टार्ट पर, Active से पहले didFinishLaunchingWithOptions को बुलाया जाता है; बैकग्रॉंड से लौटने पर, willEnterForeground को बुलाया जाता है। डिवेलपर अवस्था बहाली रणनीति चुनने के लिए इन अंतरों का उपयोग कर सकता है।

महत्वपूर्ण नोट: Suspended से लौटने पर, iOS didFinishLaunchingWithOptions को नहीं बुलाता है क्योंकि एप्लिकेशन पहले से ही मेमरी में लोड किया जा चुका था। इसका मतलब है कि इस विधि में रखा गया आरंभिक कोड दोबारा नहीं चलाया जाता। डिवेलपर अक्सर इसे भूल जाते हैं और महत्वपूर्ण तर्क को दोनों परिदृश्यों के लिए applicationWillEnterForeground या applicationDidBecomeActive में स्थानांतरित कर देते हैं।

Android में Active: Activity जीवन चक्र

Android में, Active का समकक्ष onResume() कॉल के बाद Activity की अवस्था है। Activity को सक्रिय माना जाता है जब यह अग्रगमण में होती है और उपयोगकर्ता का इनपुट स्वीकार करती है। यह अवस्था Activity स्टैक के शिखर से मेल खाती है। यदि कोई अन्य Activity ऊपर दिखाई देती है (भले ही आंशिक रूप से), तो वर्तमान Activity onPause अवस्था में चली जाती है — iOS Inactive का समकक्ष।

Android में एक मुख्य अंतर यह है कि एकाधिक Activities मल्टी-विंडो मोड (split screen, freeform) में एकसाथ सक्रिय हो सकती हैं। इस मामले में, जिस Activity के साथ उपयोगकर्ता बातचीत कर रहा है उसे सक्रिय माना जाता है, जबकि पड़ोसी रुकी हुई है (onPause)। iOS iPhone पर मल्टी-विंडो का समर्थन नहीं करता, केवल iPad पर UIScene के माध्यम से।

class MainActivity : AppCompatActivity() {

    override fun onResume() {
        super.onResume()
        // एप्लिकेशन सक्रिय हो गया — कार्य फिर से शुरू करना
        resumeCameraPreview()
        startLocationUpdates()
        activateSensors()
    }

    override fun onPause() {
        super.onPause()
        // एप्लिकेशन सक्रियता खो रहा है — संसाधन मुक्त करना
        releaseCamera()
        stopLocationUpdates()
        deactivateSensors()
    }

    private fun resumeCameraPreview() {
        // कैमरा प्रीव्यू शुरू करना (अनुमति आवश्यक)
        cameraProvider?.unbindAll()
        cameraProvider?.bindToLifecycle(
            this,
            cameraSelector,
            preview,
            imageAnalyzer
        )
    }

    private fun startLocationUpdates() {
        val locationRequest = LocationRequest.Builder(
            Priority.PRIORITY_HIGH_ACCURACY, 5000
        ).build()
        locationClient.requestLocationUpdates(
            locationRequest,
            locationCallback,
            Looper.getMainLooper()
        )
    }
}

कोड Android में onResume/onPause के माध्यम से Active संभालन दिखाता है। onResume कैमरा, जीओलोकेशन और सेंसर को फिर से शुरू करता है — वे संसाधन जो केवल तब सक्रिय होने चाहिए जब एप्लिकेशन उपयोगकर्ता को दिखाई दे। onPause बैटरी खत्म होने से बचने के लिए इन संसाधनों को मुक्त करता है। CameraX lifecycle-aware API onPause पर स्वचालित रूप से प्रीव्यू को रोक देता है।

Active के प्रबंधन के लिए सबसे अच्छी प्रथाएँ

पहला नियम — applicationDidBecomeActive या onResume में भारी संचालन न करें। डेटा लोडिंग, JSON पार्सिंग, डेटाबेस कार्य — यह सब असांक्रोनस होना चाहिए और मुख्य थ्रेड को ब्लॉक न करें। बैकग्रॉंड कार्यों के लिए iOS में GCD (DispatchQueue) और Kotlin में Coroutines का उपयोग करें। मुख्य थ्रेड को केवल UI अपडेट करना चाहिए और असांक्रोनस संचालन शुरू करने चाहिए।

दूसरा नियम — Active में हर वापसी पर अवस्था को सिंक करें। उपयोगकर्ता ने सिस्टम एप्लिकेशन में सेटिंग्स बदल दी होंगी, पुश नूटिफिकेशन प्राप्त किया होगा, या किसी अन्य एप्लिकेशन में डेटा अपडेट किया होगा। Active में संक्रमण करते समय कैश की प्रासंगिकता की जाँच करें — उपयोगकर्ता के अनुपस्थित रहने के दौरान डेटा पुराना हो गया हो सकता है।

तीसरा नियम — Active को एकमात्र अवस्था के रूप में न मानें। एप्लिकेशन Active को छोड़कर सीधे Not Running से Background में जा सकता है (यदि बैकग्रॉंड मोड में लॉन्च किया गया है)। iOS में, यह तब होता है जब content-available विकल्प के साथ पुश नूटिफिकेशन के माध्यम से लॉन्च किया जाता है। Android में, BroadcastReceiver के माध्यम से लॉन्च करने पर। UI संचालन करने से पहले हमेशा वर्तमान अवस्था की जाँच करें

चौथा नियम — onActivityResult के बजाय Android में Activity Result API का उपयोग करें। यह Activity के पुनर्निर्माण पर डेटा हानि के बिना सीधे Active अवस्था में कैमरा, गैलरी या अनुमति कॉल के परिणाम को संभालने की अनुमति देता है। iOS के लिए, सिस्टम डैलाग के लिए UIApplication.shared.open के साथ async/await का उपयोग करें।

import UIKit

final class ActiveStateManager {
    static let shared = ActiveStateManager()
    private var isActive = false

    func setActive(_ active: Bool) {
        isActive = active
        if active {
            NotificationCenter.default.post(name: .appDidBecomeActive, object: nil)
        }
    }

    func performWhenActive(_ block: @escaping () -> Void) {
        if isActive {
            block()
        } else {
            // Active में लौटने तक निष्पादन स्थागित करें
            NotificationCenter.default.addObserver(
                forName: .appDidBecomeActive,
                object: nil,
                queue: .main
            ) { _ in
                block()
            }
        }
    }
}

extension Notification.Name {
    static let appDidBecomeActive = Notification.Name("appDidBecomeActive")
}

कोड एक Active अवस्था प्रबंधक दिखाता है जो एप्लिकेशन के अन्य घटकों को वर्तमान सक्रिय अवस्था की जाँच करने की अनुमति देता है। performWhenActive यदि एप्लिकेशन सक्रिय है तो ब्लॉक को तुरंत निष्पादित करता है, या Active में लौटने तक निष्पादन को स्थागित कर देता है। यह उन सेवाओं के लिए उपयोगी है जो उपयोगकर्ता के एप्लिकेशन में लौटने के बाद कार्रवाई करना चाहती हैं।