Coordinator: मुख्य अवधारणाएँ, iOS नेविगेशन के लिए कोऑर्डिनेटर पैटर्न

Coordinator क्या है: नेविगेशन पैटर्न का सार

Coordinator — एक पैटर्न है जो iOS एप्लिकेशन में नेविगेशन की जिम्मेदारी लेता है। मानक UIKit में, ViewController स्वयं ट्रांज़िशन प्रबंधित करता है: present, push, show segue — सभी नेविगेशन विधियाँ UIViewController से कॉल की जाती हैं। Coordinator इस तर्क को बाहर निकालता है: ViewController एक घटना की रिपोर्ट करता है (जैसे, «उपयोगकर्ता ने लॉगिन बटन दबाया»), Coordinator तय करता है कि आगे कौन सी स्क्रीन दिखानी है। ViewController केवल UI तर्क के साथ रहता है और नेविगेशन को कोऑर्डिनेटर को सौंपता है।

पैटर्न संरचना — CoordinatorProtocol जिसमें start() और finish() विधियाँ हैं। start() — flow की शुरुआत: पहला ViewController बनाना और प्रदर्शित करना। finish() — पैरेंट कोऑर्डिनेटर को सूचना के साथ flow का समापन। Router — UINavigationController (या UISplitViewController) के ऊपर एक आवरण, जो show, push, pop, dismiss विधियाँ प्रदान करता है। कोऑर्डिनेटर सीधे UINavigationController के साथ काम नहीं करता — केवल Router के माध्यम से। यह नेविगेशन का परीक्षण करने और UI फ्रेमवर्क बदलने की अनुमति देता है।

Coordinator द्वारा हल की जाने वाली समस्याएँ — Massive View Controller (नेविगेशन कंट्रोलर के बढ़ने का एक सामान्य कारण है)। मानक UIKit में, ViewController में prepareForSegue, नेविगेशन delegates, unwind segues की हैंडलिंग होती है। Coordinator इसे समाप्त करता है। Storyboard में Segues स्क्रीन के बीच स्थिर कनेक्शन हैं, Coordinator शर्तों के साथ गतिशील नेविगेशन प्रदान करता है। नेविगेशन का परीक्षण संभव हो जाता है: बिना UI के Coordinator का परीक्षण Router कॉल के अनुक्रम की जाँच करके किया जा सकता है।

Swift में Coordinator: Router और Flow के साथ कार्यान्वयन

Swift में मूल Coordinator — Router के लिए एक संबद्ध प्रकार और start/finish विधियों वाला एक प्रोटोकॉल। Router — UINavigationController को अमूर्त करने वाला प्रोटोकॉल। Router का ठोस कार्यान्वयन UINavigationController को आवरण करता है और उसे विधियाँ सौंपता है। Coordinator init में Router स्वीकार करता है और नेविगेशन के लिए इसका उपयोग करता है। चाइल्ड कोऑर्डिनेटर जीवनचक्र प्रबंधन के लिए childCoordinators सरणी में संग्रहीत किए जाते हैं।

// Router — नेविगेशन अमूर्तता
protocol RouterProtocol: AnyObject {
    func push(_ viewController: UIViewController, animated: Bool)
    func pop(animated: Bool)
    func present(_ viewController: UIViewController, animated: Bool)
    func dismiss(animated: Bool)
}

final class NavigationRouter: RouterProtocol {
    private let navigationController: UINavigationController

    init(navigationController: UINavigationController) {
        self.navigationController = navigationController
    }

    func push(_ vc: UIViewController, animated: Bool) {
        navigationController.pushViewController(vc, animated: animated)
    }

    func pop(animated: Bool) {
        navigationController.popViewController(animated: animated)
    }

    func present(_ vc: UIViewController, animated: Bool) {
        navigationController.present(vc, animated: animated)
    }

    func dismiss(animated: Bool) {
        navigationController.dismiss(animated: animated)
    }
}

// Coordinator — flow प्रबंधन
protocol CoordinatorProtocol: AnyObject {
    var childCoordinators: [CoordinatorProtocol] { get set }
    var router: RouterProtocol { get }
    func start()
    func finish()
}

class AuthCoordinator: CoordinatorProtocol {
    var childCoordinators: [CoordinatorProtocol] = []
    let router: RouterProtocol

    init(router: RouterProtocol) {
        self.router = router
    }

    func start() {
        let loginVC = LoginViewController()
        loginVC.onLogin = { [weak self] in
            self?.showHome()
        }
        router.push(loginVC, animated: true)
    }

    private func showHome() {
        let homeCoordinator = HomeCoordinator(router: router)
        childCoordinators.append(homeCoordinator)
        homeCoordinator.start()
    }

    func finish() {
        childCoordinators.removeAll()
        router.pop(animated: true)
    }
}

AppDelegate/SceneDelegate में Coordinator बनाना — AppDelegate या SceneDelegate UINavigationController बनाता है, इसे NavigationRouter में आवरण करता है, एक रूट Coordinator (AppCoordinator) बनाता है और start() कॉल करता है। AppCoordinator तय करता है कि एप्लिकेशन की स्थिति के आधार पर onboarding, लॉगिन या मुख्य स्क्रीन दिखानी है या नहीं। Coordinator नेविगेशन के लिए एकमात्र प्रवेश बिंदु है, ViewController अन्य स्क्रीन के बारे में नहीं जानता।

चाइल्ड Coordinator और कोऑर्डिनेटर पदानुक्रम

कोऑर्डिनेटर पदानुक्रम — AppCoordinator → AuthCoordinator/MainCoordinator → ProfileCoordinator/SettingsCoordinator। चाइल्ड कोऑर्डिनेटर पैरेंट द्वारा बनाया जाता है और childCoordinators सरणी में संग्रहीत किया जाता है। जब चाइल्ड कोऑर्डिनेटर अपना काम पूरा करता है, तो वह पैरेंट पर finish() कॉल करता है, और पैरेंट इसे childCoordinators से हटा देता है। यह मेमोरी लीक को रोकता है: Coordinator के पास ViewController पर एक मजबूत संदर्भ होता है (Router के माध्यम से), और childCoordinators से हटाए बिना ऑब्जेक्ट मुक्त नहीं होगा।

// Coordinator -> Parent संचार के लिए Delegate
protocol AuthCoordinatorDelegate: AnyObject {
    func authCoordinatorFinished(_ coordinator: AuthCoordinator)
}

class AuthCoordinator: CoordinatorProtocol {
    weak var delegate: AuthCoordinatorDelegate?

    func finish() {
        delegate?.authCoordinatorFinished(self)
    }
}

// AppCoordinator — पैरेंट
class AppCoordinator: AuthCoordinatorDelegate {
    func startAuthFlow() {
        let authCoordinator = AuthCoordinator(router: router)
        authCoordinator.delegate = self
        childCoordinators.append(authCoordinator)
        authCoordinator.start()
    }

    func authCoordinatorFinished(_ coordinator: AuthCoordinator) {
        childCoordinators.removeAll { $0 is AuthCoordinator }
        startMainFlow()
    }
}

childCoordinators का प्रबंधन — Coordinator को सरणी से निकालना इसे मुक्त करने का एकमात्र तरीका है। यदि आप पूर्ण हुए Coordinator को हटाना भूल जाते हैं, तो यह अपने ViewControllers सहित मेमोरी में रहता है। अनुशंसित तरीके: पैरेंट का didMove(toParent:), समाप्ति पर callback, या स्वचालित हटाने के लिए Combine publisher। Coordinator पैटर्न सूचना तंत्र निर्दिष्ट नहीं करता — delegate, closure या Combine — चुनाव डेवलपर पर निर्भर है।

कोऑर्डिनेटरों के बीच डेटा स्थानांतरित करने के तरीके

delegate के माध्यम से डेटा स्थानांतरण — चाइल्ड Coordinator एक delegate प्रोटोकॉल को परिभाषित करता है जिसमें विधियाँ होती हैं जिनके माध्यम से परिणाम पारित किए जाते हैं: func authCoordinator(_:didLoginWith user: User)। पैरेंट प्रोटोकॉल को लागू करता है और चाइल्ड flow पूरा होने पर डेटा प्राप्त करता है। यह टाइप-सेफ और स्पष्ट है। कमी: प्रत्येक चाइल्ड Coordinator के लिए एक अलग प्रोटोकॉल लिखना आवश्यक है। 10+ Coordinator वाली परियोजनाओं के लिए यह फ़ाइलों में वृद्धि की ओर ले जाता है।

Result प्रकार के माध्यम से डेटा स्थानांतरण — finish विधि Result स्वीकार करती है, जहाँ Output flow परिणाम का जेनेरिक प्रकार है। Coordinator

— संबद्ध परिणाम प्रकार के साथ एक जेनेरिक। callback के साथ start(): start(completion: @escaping (Output) -> Void)। यह कोड को छोटा करता है: प्रत्येक coordinator के लिए अलग प्रोटोकॉल लिखने की आवश्यकता नहीं है। RxSwift/Combine: Coordinator PassthroughSubject/Publisher के माध्यम से परिणाम प्रकाशित करता है। चुनाव टीम के आर्किटेक्चरल दृष्टिकोण पर निर्भर करता है।

साझा डेटा परत — Coordinator सीधे डेटा स्थानांतरित नहीं करते, बल्कि एक साझा सेवा/रिपॉजिटरी का उपयोग करते हैं। AuthCoordinator टोकन को Keychain/UserDefaults में सहेजता है, ProfileCoordinator वहाँ से पढ़ता है। Coordinator प्रत्यक्ष कॉल के बजाय साझा स्थिति (Dependency Injection कंटेनर) के माध्यम से संवाद करते हैं। यह Coordinator के बीच युग्मन को कम करता है, लेकिन साझा स्थिति पर अंतर्निहित निर्भरताएँ बनाता है।

Coordinator की Router, VIPER और MVVM-C से तुलना

Coordinator बनाम Router — Router Coordinator का एक घटक है जो UINavigationController को अमूर्त करता है। Coordinator flow के लिए जिम्मेदार है (कौन सी स्क्रीन दिखानी है), Router — यांत्रिकी के लिए (कैसे दिखाना है: push/present)। Router «कैसे» है, Coordinator «क्या» है। आप Router का उपयोग Coordinator के बिना कर सकते हैं (जैसे, Navigator सिंगलटन), लेकिन Coordinator बिना Router के केवल एक अलग अमूर्तता वाला ViewController है। आमतौर पर दोनों पैटर्न एक साथ उपयोग किए जाते हैं।

Coordinator बनाम VIPER — VIPER में नेविगेशन के लिए जिम्मेदार Wireframe घटक है — Coordinator के अनुरूप। VIPER में, Wireframe मॉड्यूल का हिस्सा है, Coordinator मॉड्यूल के ऊपर एक अलग परत है। VIPER मॉड्यूल (View-Interactor-Presenter-Entity-Router) नेविगेशन को मॉड्यूल के हिस्से के रूप में शामिल करता है। Coordinator मॉड्यूल के लिए बाहरी है: वह मॉड्यूल बनाता और जोड़ता है, लेकिन उनका हिस्सा नहीं है। Coordinator विभिन्न flow में स्क्रीन के पुन: उपयोग के लिए अधिक लचीला है।

MVVM-C — Coordinator के साथ MVVM का विस्तार। ViewModel सीधे Coordinator के बारे में नहीं जानता — ViewController ViewModel के माध्यम से नेविगेशन सौंपता है, ViewModel एक प्रोटोकॉल के माध्यम से coordinator को कॉल करता है। MVVM-C SwiftUI के साथ iOS परियोजनाओं के लिए मानक दृष्टिकोण है: Coordinator NavigationStack या fullScreenCover प्रबंधित करता है, ViewModel स्थिति प्रकाशित करके coordinator को कॉल करता है। Apple SwiftUI के लिए Coordinator की अनुशंसा नहीं करता — NavigationStack और NavigationPath अंतर्निहित नेविगेशन तंत्र हैं।

// MVVM-C: ViewModel प्रोटोकॉल के माध्यम से Coordinator को कॉल करता है
protocol AuthNavigationProtocol: AnyObject {
    func showMainScreen()
    func showForgotPassword()
}

class AuthViewModel: ObservableObject {
    weak var navigation: AuthNavigationProtocol?

    func loginTapped() {
        // तर्क...
        navigation?.showMainScreen()
    }
}