.onDisappear: कार्य सिद्धांत और SwiftUI में उपयोग

.onDisappear क्या है?

.onDisappear SwiftUI में एक View मॉडिफायर है जो Void क्लोज़र लेता है और View को पदानुक्रम से हटाए जाने पर इसे निष्पादित करता है। .onAppear के साथ यह स्क्रीन का पूर्ण जीवनचक्र बनाता है: प्रकटन — कार्य — गायब होना। Apple ने onDisappear को SwiftUI के साथ iOS 13 में UIKit के viewDidDisappear के एनालॉग के रूप में पेश किया।

वाक्यात्मक रूप से, .onDisappear onAppear के समान है: यह किसी भी View को संशोधित करता है और एक क्लोज़र संलग्न करता है जिसे SwiftUI रेंडरर View हटाए जाने पर कॉल करता है। UIKit के विपरीत, जहाँ viewDidDisappear केवल संक्रमण एनिमेशन पूरा होने के बाद ही सक्रिय होता है, SwiftUI में onDisappear एनिमेशन समाप्त होने से पहले — View के हटाने के लिए चिह्नित होने के क्षण में कॉल किया जा सकता है।

onDisappear सिंटैक्स

मूल सिंटैक्स onDisappear का onAppear जितना ही संक्षिप्त है। मॉडिफायर कोई अतिरिक्त पैरामीटर नहीं लेता — केवल क्लोज़र, जो मुख्य थ्रेड पर सिंक्रोनस रूप से निष्पादित होता है।

struct DetailView: View {
    var body: some View {
        Text("Detail Screen")
            .onDisappear {
                print("DetailView स्क्रीन से गायब हो गया")
            }
    }
}

.onDisappear कैसे काम करता है

कॉल तंत्र onDisappear onAppear के विपरीत है: चाइल्ड तत्व पहले onDisappear प्राप्त करते हैं, फिर पैरेंट। यह child-first नियम सुनिश्चित करता है कि पैरेंट के संसाधन मुक्त होने से पहले चाइल्ड संसाधन मुक्त हो जाएँ। यदि कोई चाइल्ड तत्व पैरेंट डेटा पर निर्भर है, तो उसे पैरेंट संदर्भ के बिना सही ढंग से समाप्त होने में सक्षम होना चाहिए।

SwiftUI onDisappear को तब कॉल करता है जब View रेंडर ग्राफ़ से हटा दिया जाता है। ट्रिगर में शामिल हैं: NavigationStack से pop, TabView स्विचिंग, मोडल डिसमिस (sheet/fullScreenCover), या सशर्त रूप से प्रदर्शित View (if/switch)। List और ScrollView में, onDisappear तब कॉल होता है जब सेल प्रीफ़ेच बफ़र से बाहर स्क्रॉल होती है।

Child-first कॉल क्रम

Child-first क्रम का अर्थ है कि यदि VStack में तीन चाइल्ड View हैं, तो onDisappear पहले प्रत्येक चाइल्ड के लिए उल्टे क्रम में कॉल होता है, फिर पैरेंट के लिए। यह उचित सफाई के लिए महत्वपूर्ण है: चाइल्ड टाइमर पैरेंट ViewModel द्वारा साझा संसाधन मुक्त करने से पहले रद्द हो जाते हैं।

struct ParentView: View {
    var body: some View {
        VStack {
            ChildView(id: "A")
            ChildView(id: "B")
        }
        .onDisappear {
            print("Parent onDisappear — अंतिम")
        }
    }
}

struct ChildView: View {
    let id: String
    var body: some View {
        Text("Child \(id)")
            .onDisappear {
                print("Child \(id) onDisappear")
            }
    }
}

कंसोल आउटपुट: Child B onDisappear, Child A onDisappear, Parent onDisappear — अंतिम। onAppear की तुलना में उल्टा क्रम सही सफाई श्रृंखला सुनिश्चित करता है।

.onDisappear कब कॉल किया जाता है

कॉल परिदृश्य onDisappear कंटेनर प्रकार पर निर्भर करते हैं। NavigationStack में, onDisappear pop-to-root, सामान्य pop-back या स्वाइप (interactivePopGestureRecognizer) द्वारा स्क्रीन खारिज करने पर सक्रिय होता है। TabView में, टैब स्विच करने से छिपे टैब के लिए onDisappear और दिखाए गए टैब के लिए onAppear कॉल होता है — दोनों मॉडिफायर लगभग एक साथ सक्रिय होते हैं।

Sheet और fullScreenCover में, onDisappear प्रोग्रामेटिक डिसमिस (@Environment(\.dismiss) के माध्यम से) या नीचे की ओर स्वाइप जेस्चर पर कॉल होता है। महत्वपूर्ण विवरण: यदि sheet खोला गया था लेकिन उपयोगकर्ता ने ऐप स्विच किया, तो onDisappear वास्तविक बंद होने तक कॉल नहीं होता।

.onDisappear उदाहरण

मुख्य उपयोग मामले onDisappear के संसाधन सफाई, स्थिति सहेजना और ट्रैकिंग हैं। onAppear के विपरीत, onDisappear कार्य निकास पर निष्पादित होते हैं और डुप्लिकेशन जाँच की आवश्यकता नहीं होती क्योंकि View एक बार गायब होता है।

स्थिति सहेजना और टाइमर रद्द करना

स्थिति सहेजना onDisappear में विशेष रूप से फ़ॉर्म के लिए उपयोगी है जहाँ स्क्रीन छोड़ने पर डेटा सहेजा जाना चाहिए। स्क्रीन पर वापस लौटने पर लीक से बचने के लिए टाइमर और Combine सब्सक्रिप्शन onDisappear में रद्द किए जाते हैं।

struct FormView: View {
    @State private var draftText = ""
    @State private var timer: Timer?
    
    var body: some View {
        TextField("Enter text", text: $draftText)
            .onAppear {
                timer = Timer.scheduledTimer(withTimeInterval: 60, repeats: true) { _ in
                    saveDraft()
                }
            }
            .onDisappear {
                timer?.invalidate()
                timer = nil
                saveDraft()
            }
    }
    
    private func saveDraft() {
        UserDefaults.standard.set(draftText, forKey: "draft")
    }
}

टाइमर रद्द करना onDisappear में स्क्रीन बंद होने के बाद कोड निष्पादन को रोकता है। रद्द किए बिना, टाइमर @State को अपडेट करने का प्रयास कर सकता है जो अब वर्तमान View से संबंधित नहीं है, जिससे रनटाइम चेतावनी उत्पन्न होती है।

स्क्रीन पर समय ट्रैकिंग

स्क्रीन पर ठहराव अवधि एक क्लासिक ट्रैकिंग परिदृश्य है। onAppear में समय रिकॉर्ड करें, onDisappear में अंतर की गणना करें और सत्र अवधि के साथ एक विश्लेषण इवेंट भेजें।

struct TrackedView: View {
    @State private var appearTime: Date?
    
    var body: some View {
        Text("Tracked Screen")
            .onAppear {
                appearTime = Date()
                Analytics.shared.logEvent("screen_view", params: ["screen": "TrackedView"])
            }
            .onDisappear {
                if let start = appearTime {
                    let duration = Date().timeIntervalSince(start)
                    Analytics.shared.logEvent("screen_close", params: [
                        "screen": "TrackedView",
                        "duration_ms": Int(duration * 1000)
                    ])
                }
            }
    }
}

.onDisappear बनाम .onAppear — अंतर

मुख्य अंतर onDisappear और onAppear के बीच कॉल क्रम और निष्पादन गारंटी है। onAppear View को पदानुक्रम में जोड़े जाने पर कॉल होता है और पुनर्निर्माण पर फिर से कॉल हो सकता है। onDisappear हटाने पर कॉल होता है और केवल सामान्य बंद होने पर सक्रिय होने की गारंटी है, क्रैश परिदृश्यों में नहीं।

WWDC 2024 के अनुसार, Apple onDisappear को सफाई बिंदु के रूप में मानने की सलाह देता है, डेटा कमिट बिंदु के रूप में नहीं। महत्वपूर्ण डेटा (भुगतान, पंजीकरण) वास्तविक समय में सहेजा जाना चाहिए, न कि View गायब होने के क्षण में, क्योंकि ऐप मिनिमाइज़ होने पर onDisappear कॉल की गारंटी नहीं है।

अनुशंसा: onDisappear का उपयोग केवल गैर-महत्वपूर्ण सफाई और ट्रैकिंग के लिए करें। डेटा स्थिरता के लिए, AppDelegate में scenePhase या applicationWillTerminate सूचनाओं का उपयोग करें।

सामान्य उपयोग परिदृश्य

परिदृश्य 1: YouTube-जैसी प्लेबैक. वीडियो विवरण स्क्रीन पर, onDisappear UserDefaults में प्लेबैक स्थिति सहेजता है। पुनः खोलने पर, onAppear UserDefaults से स्थिति पुनर्स्थापित करता है, जिससे निरंतर देखने का अनुभव मिलता है।

परिदृश्य 2: Combine सब्सक्रिप्शन रद्द करना. यदि ViewModel Combine पब्लिशर्स का उपयोग करता है, तो onDisappear cancellable?.cancel() के माध्यम से सब्सक्रिप्शन रद्द करता है। यह स्क्रीन छोड़ने के बाद UI अपडेट को रोकता है, जो पेजिनेशन वाली सूचियों और खोज क्वेरी के लिए विशेष रूप से महत्वपूर्ण है।

परिदृश्य 3: WebSocket बंद करना. रीयल-टाइम कनेक्शन वाले ऐप्स (मैसेंजर, कोटेशन फ़ीड) में, onDisappear बैटरी और डेटा बचाने के लिए WebSocket कनेक्शन बंद करता है। स्क्रीन पर वापस लौटने पर onAppear में पुनः कनेक्शन होता है।

onDisappear में WebSocket बंद करना

WebSocket एक विशिष्ट संसाधन है जिसे स्क्रीन छोड़ने पर बंद करने की आवश्यकता होती है। नीचे दिए गए उदाहरण में, onDisappear सॉकेट को डिस्कनेक्ट करता है और onAppear इसे पुनः कनेक्ट करता है, जो कई स्क्रीन वाले ऐप्स के लिए महत्वपूर्ण डेटा बचत प्रदान करता है।

struct ChatView: View {
    @StateObject private var socket = WebSocketManager()
    
    var body: some View {
        ChatListView(messages: socket.messages)
            .onAppear {
                socket.connect()
            }
            .onDisappear {
                socket.disconnect()
            }
    }
}

महत्वपूर्ण: TabView टैब के बीच स्विच करते समय, वर्तमान टैब का onDisappear और अगले टैब का onAppear लगभग एक साथ सक्रिय होते हैं। WebSocket के लिए यह डिस्कनेक्ट-कनेक्ट चक्र का कारण बन सकता है जो अनावश्यक लोड पैदा करता है। समाधान विलंब का उपयोग करना या जाँचना है कि क्या अगली स्क्रीन पर सॉकेट की आवश्यकता है।