रूट नियंत्रक का उपयोग करके iOS- अनुप्रयोगों में नेविगेशन का संगठन

अधिकांश मोबाइल एप्लिकेशन में एक दर्जन से अधिक स्क्रीन, जटिल बदलाव, साथ ही साथ आवेदन के कुछ हिस्सों को अर्थ और उद्देश्य से अलग किया जाता है। इसलिए, आवेदन के लिए सही नेविगेशन संरचना को व्यवस्थित करने की आवश्यकता है, जो लचीली, सुविधाजनक, एक्स्टेंसिबल होगी, आवेदन के विभिन्न भागों में आरामदायक पहुंच प्रदान करेगी, और सिस्टम संसाधनों के बारे में भी सावधान रहेगी।

इस लेख में, हम एप्लिकेशन में नेविगेशन को इस तरह से डिजाइन करेंगे जैसे कि सबसे आम त्रुटियों से बचने के लिए जो मेमोरी लीक की ओर जाता है, वास्तुकला को बर्बाद करता है और नेविगेशन संरचना को तोड़ता है।

अधिकांश अनुप्रयोगों में कम से कम दो भाग होते हैं: प्रमाणीकरण (पूर्व-लॉगिन) और निजी भाग (पोस्ट-लॉगिन)। कुछ अनुप्रयोगों में एक अधिक जटिल संरचना हो सकती है, एक ही लॉगिन के साथ कई प्रोफाइल, आवेदन शुरू करने के बाद सशर्त संक्रमण (डीपलिंक), आदि।

व्यवहार में, एप्लिकेशन को नेविगेट करने के लिए मुख्य रूप से दो दृष्टिकोणों का उपयोग किया जाता है:

1. दोनों प्रस्तुति नियंत्रकों (वर्तमान) और नेविगेशन नियंत्रकों (धक्का) के लिए एक नेविगेशन स्टैक, वापस जाने की क्षमता के बिना। इस दृष्टिकोण के कारण पिछले सभी ViewControllers स्मृति में बने रहते हैं।
2. Window.rootViewController टॉगल का उपयोग करता है। इस दृष्टिकोण के साथ, पिछले सभी ViewControllers स्मृति में नष्ट हो जाते हैं, लेकिन यह UI के दृष्टिकोण से सबसे अच्छा नहीं दिखता है। इसके अलावा, यदि आवश्यक हो तो यह आपको आगे और पीछे जाने की अनुमति नहीं देता है।

अब देखते हैं कि आप आसानी से बनाए रखने योग्य संरचना कैसे बना सकते हैं, जो आपको स्पेगेटी कोड और आसान नेविगेशन के बिना, आवेदन के विभिन्न भागों के बीच मूल रूप से स्विच करने की अनुमति देता है।

आइए कल्पना करें कि हम एक आवेदन लिख रहे हैं:

• प्राइमरी स्क्रीन ( स्प्लैश स्क्रीन ): यह पहली स्क्रीन है जिसे आप देखते हैं, जैसे ही एप्लिकेशन शुरू होता है, आप उदाहरण के लिए, एनीमेशन जोड़ सकते हैं या प्राथमिक एपीआई अनुरोध कर सकते हैं।
• प्रमाणीकरण भाग : लॉगिन, पंजीकरण, पासवर्ड रीसेट, ईमेल पुष्टि, आदि। उपयोगकर्ता का कार्य सत्र आमतौर पर सहेजा जाता है, इसलिए हर बार आवेदन शुरू होने पर लॉगिन दर्ज करने की आवश्यकता नहीं होती है।
• मुख्य भाग : मुख्य अनुप्रयोग का व्यावसायिक तर्क

आवेदन के इन सभी भागों को एक दूसरे से अलग किया जाता है और प्रत्येक अपने स्वयं के नेविगेशन स्टैक में मौजूद होते हैं। इसलिए, हमें निम्नलिखित बदलावों की आवश्यकता हो सकती है:

• स्प्लैश स्क्रीन -> प्रमाणीकरण स्क्रीन , यदि सक्रिय उपयोगकर्ता का वर्तमान सत्र अनुपस्थित है।
• स्पलैश स्क्रीन -> मुख्य स्क्रीन, यदि उपयोगकर्ता पहले ही आवेदन में लॉग इन कर चुका है और एक सक्रिय सत्र है।
• उपयोगकर्ता द्वारा लॉग आउट करने की स्थिति में मुख्य स्क्रीन -> प्रमाणीकरण स्क्रीन

मूल सेटिंग

जब आवेदन शुरू होता है, तो हमें रूटव्यूकंट्रोलर को इनिशियलाइज़ करना होगा, जिसे पहले लोड किया जाएगा। यह कोड और इंटरफ़ेस बिल्डर के माध्यम से दोनों किया जा सकता है। XCode में एक नया प्रोजेक्ट बनाएं और यह सब पहले से ही डिफ़ॉल्ट रूप से हो जाएगा: main.storyboard पहले से ही window.rootViewController से बंधा है।

लेकिन लेख के मुख्य विषय पर ध्यान केंद्रित करने के लिए, हम अपनी परियोजना में स्टोरीबोर्ड का उपयोग नहीं करेंगे। इसलिए, main.storyboard को हटाएं, और लक्ष्य -> ​​सामान्य -> ​​परिनियोजन जानकारी के अंतर्गत "मुख्य इंटरफ़ेस" फ़ील्ड को भी साफ़ करें:



अब AppDelegate में didFinishLaunchingWithOptions विधि को बदलते हैं ताकि यह इस तरह दिखे :

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool { window = UIWindow(frame: UIScreen.main.bounds) window?.rootViewController = RootViewController() window?.makeKeyAndVisible() return true } 

अब एप्लिकेशन सबसे पहले RootViewController लॉन्च करेगा। मूल ViewController को RootViewController का नाम दें :

 class RootViewController: UIViewController { } 

यह आवेदन के विभिन्न वर्गों के बीच सभी संक्रमणों के लिए जिम्मेदार मुख्य नियंत्रक होगा। इसलिए, हर बार जब हम संक्रमण करना चाहते हैं, तो हमें इसके लिए एक लिंक की आवश्यकता होगी। ऐसा करने के लिए, AppDelegate में एक्सटेंशन जोड़ें:

 extension AppDelegate { static var shared: AppDelegate { return UIApplication.shared.delegate as! AppDelegate } var rootViewController: RootViewController { return window!.rootViewController as! RootViewController } } 

इस मामले में एक विकल्प की मजबूर पुनर्प्राप्ति उचित है, क्योंकि रूटव्यूकंट्रोलर नहीं बदलता है, और यदि यह दुर्घटना से होता है, तो आवेदन दुर्घटना एक सामान्य स्थिति है।

तो, अब हमारे पास एप्लिकेशन में कहीं से RootViewController का लिंक है:

 let rootViewController = AppDelegate.shared.rootViewController 

अब हम कुछ और कंट्रोलर बनाते हैं जिनकी हमें आवश्यकता होती है: स्प्लैश व्यू कॉन्ट्रोलर, लॉगइन व्यू कॉन्ट्रोलर, और मेनव्यूकंट्रोलर ।

स्प्लैश स्क्रीन पहली स्क्रीन है जो एक उपयोगकर्ता एप्लिकेशन शुरू करने के बाद देखेगा। इस समय, सभी आवश्यक एपीआई अनुरोध आमतौर पर किए जाते हैं, उपयोगकर्ता सत्र गतिविधि की जांच की जाती है, आदि। चल रही पृष्ठभूमि क्रियाओं को प्रदर्शित करने के लिए, UIActivityIndicatorView का उपयोग करें:

 class SplashViewController: UIViewController { private let activityIndicator = UIActivityIndicatorView(activityIndicatorStyle: .whiteLarge) override func viewDidLoad() { super.viewDidLoad() view.backgroundColor = UIColor.white view.addSubview(activityIndicator) activityIndicator.frame = view.bounds activityIndicator.backgroundColor = UIColor(white: 0, alpha: 0.4) makeServiceCall() } private func makeServiceCall() { } } 

एपीआई अनुरोधों का अनुकरण करने के लिए, DispatchQueue.main.asyncAfter विधि को 3 सेकंड की देरी से जोड़ें:

 private func makeServiceCall() { activityIndicator.startAnimating() DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + .seconds(3)) { self.activityIndicator.stopAnimating() } } 

हमारा मानना ​​है कि इन अनुरोधों में उपयोगकर्ता सत्र भी निर्धारित है। हमारे आवेदन में, हम इसके लिए UserDefaults का उपयोग करते हैं:

 private func makeServiceCall() { activityIndicator.startAnimating() DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + .seconds(3)) { self.activityIndicator.stopAnimating() if UserDefaults.standard.bool(forKey: “LOGGED_IN”) { // navigate to protected page } else { // navigate to login screen } } } 

प्रोग्राम के रिलीज़ संस्करण में उपयोगकर्ता सत्र की स्थिति को बचाने के लिए आप निश्चित रूप से UserDefaults का उपयोग नहीं करेंगे। हम अपनी परियोजना में स्थानीय सेटिंग्स का उपयोग समझ को आसान बनाने के लिए करते हैं और लेख के मुख्य विषय से आगे नहीं जाने के लिए।

एक LoginViewController बनाएं। इसका उपयोग उपयोगकर्ता को प्रमाणित करने के लिए किया जाएगा यदि वर्तमान उपयोगकर्ता सत्र निष्क्रिय है। आप अपने कस्टम UI को कंट्रोलर में जोड़ सकते हैं, लेकिन मैं यहां केवल नेविगेशन बार में स्क्रीन शीर्षक और लॉगिन बटन जोड़ूंगा।

 class LoginViewController: UIViewController { override func viewDidLoad() { super.viewDidLoad() view.backgroundColor = UIColor.white title = "Login Screen" let loginButton = UIBarButtonItem(title: "Log In", style: .plain, target: self, action: #selector(login)) navigationItem.setLeftBarButton(loginButton, animated: true) } @objc private func login() { // store the user session (example only, not for the production) UserDefaults.standard.set(true, forKey: "LOGGED_IN") // navigate to the Main Screen } } 

और अंत में, MainViewController एप्लिकेशन का मुख्य नियंत्रक बनाएं:

 class MainViewController: UIViewController { override func viewDidLoad() { super.viewDidLoad() view.backgroundColor = UIColor.lightGray // to visually distinguish the protected part title = “Main Screen” let logoutButton = UIBarButtonItem(title: “Log Out”, style: .plain, target: self, action: #selector(logout)) navigationItem.setLeftBarButton(logoutButton, animated: true) } @objc private func logout() { // clear the user session (example only, not for the production) UserDefaults.standard.set(false, forKey: “LOGGED_IN”) // navigate to the Main Screen } } 

रूट नेविगेशन

अब वापस RootViewController पर जाएं ।
जैसा कि हमने पहले कहा, रूटव्यूकंट्रोलर एकमात्र ऐसी वस्तु है जो विभिन्न स्वतंत्र नियंत्रक ढेर के बीच संक्रमण के लिए जिम्मेदार है। आवेदन की वर्तमान स्थिति से अवगत होने के लिए, हम एक चर बनाएंगे जिसमें हम वर्तमान ViewController को संग्रहीत करेंगे:

 class RootViewController: UIViewController { private var current: UIViewController } 

क्लास इनिशियलाइज़र को जोड़ें और पहला ViewController बनाएं जिसे हम एप्लिकेशन शुरू होने पर लोड करना चाहते हैं। हमारे मामले में, यह SplashViewController होगा:

 class RootViewController: UIViewController { private var current: UIViewController init() { self.current = SplashViewController() super.init(nibName: nil, bundle: nil) } } 

ViewDidLoad में, वर्तमान दृश्यकारक को RootViewController में जोड़ें :

 class RootViewController: UIViewController { ... override func viewDidLoad() { super.viewDidLoad() addChildViewController(current) // 1 current.view.frame = view.bounds // 2 view.addSubview(current.view) // 3 current.didMove(toParentViewController: self) // 4 } } 

एक बार जब हम चाइल्ड व्यू कॉन्ट्रोलर (1) जोड़ते हैं, तो हम current.view.frame को view.bounds (2) पर सेट करके इसके आकार को समायोजित करते हैं।

यदि हम इस लाइन को छोड़ देते हैं, तो दृश्यकार्ट्रोलर को अभी भी अधिकांश मामलों में सही ढंग से रखा जा सकता है, लेकिन फ़्रेम का आकार बदलने पर समस्याएँ हो सकती हैं।

एक नया सबव्यू (3) जोड़ें और didMove (toParentViewController :) विधि को कॉल करें। यह ऐड कंट्रोलर ऑपरेशन को पूरा करेगा। जैसे ही RootViewController बूट होता है , उसके तुरंत बाद SplashViewController प्रदर्शित होता है।

अब आप एप्लिकेशन में नेविगेशन के लिए कई तरीके जोड़ सकते हैं। हम बिना किसी एनीमेशन के LoginViewController को प्रदर्शित करेंगे, MainViewController उपयोगकर्ता को चिकनी डिमिंग के साथ एनीमेशन का उपयोग करेगा, और उपयोगकर्ता के डिस्कनेक्ट करने पर स्क्रीन के संक्रमण का स्लाइड प्रभाव होगा।

 class RootViewController: UIViewController { ... func showLoginScreen() { let new = UINavigationController(rootViewController: LoginViewController()) // 1 addChildViewController(new) // 2 new.view.frame = view.bounds // 3 view.addSubview(new.view) // 4 new.didMove(toParentViewController: self) // 5 current.willMove(toParentViewController: nil) // 6 current.view.removeFromSuperview()] // 7 current.removeFromParentViewController() // 8 current = new // 9 } 

LoginViewController (1) बनाएं, चाइल्ड कंट्रोलर (2), सेट फ्रेम (3) के रूप में जोड़ें। सबव्यू (4) के रूप में LoginController के दृश्य जोड़ें और didMove (5) विधि को कॉल करें। अगला, विलोव (6) विधि का उपयोग करके हटाने के लिए वर्तमान नियंत्रक तैयार करें। अंत में, पर्यवेक्षण (7) से वर्तमान दृश्य को हटा दें, और रूटव्यूकंट्रोलर (8) से वर्तमान नियंत्रक को हटा दें। वर्तमान नियंत्रक (9) के मूल्य को अपडेट करना याद रखें।

अब हम switchToMainScreen विधि बनाते हैं:

 func switchToMainScreen() { let mainViewController = MainViewController() let mainScreen = UINavigationController(rootViewController: mainViewController) ... } 

संक्रमण को अलग करने के लिए एक अलग विधि की आवश्यकता होती है:

 private func animateFadeTransition(to new: UIViewController, completion: (() -> Void)? = nil) { current.willMove(toParentViewController: nil) addChildViewController(new) transition(from: current, to: new, duration: 0.3, options: [.transitionCrossDissolve, .curveEaseOut], animations: { }) { completed in self.current.removeFromParentViewController() new.didMove(toParentViewController: self) self.current = new completion?() //1 } } 

यह विधि बहुत हद तक ShowLoginScreen के समान है, लेकिन एनीमेशन पूरा होने के बाद सभी अंतिम चरण किए जाते हैं। संक्रमण के अंत की कॉलिंग विधि को सूचित करने के लिए, बहुत अंत में हम क्लोजर (1) कहते हैं।

अब switchToMainScreen विधि का अंतिम संस्करण इस तरह दिखेगा:

 func switchToMainScreen() { let mainViewController = MainViewController() let mainScreen = UINavigationController(rootViewController: mainViewController) animateFadeTransition(to: mainScreen) } 

और अंत में, चलिए आखिरी तरीका बनाते हैं जो MainViewController से LoginViewController के संक्रमण के लिए जिम्मेदार होगा:

 func switchToLogout() { let loginViewController = LoginViewController() let logoutScreen = UINavigationController(rootViewController: loginViewController) animateDismissTransition(to: logoutScreen) } 

AnimateDismissTransition विधि स्लाइड एनीमेशन प्रदान करता है:

 private func animateDismissTransition(to new: UIViewController, completion: (() -> Void)? = nil) { new.view.frame = CGRect(x: -view.bounds.width, y: 0, width: view.bounds.width, height: view.bounds.height) current.willMove(toParentViewController: nil) addChildViewController(new) transition(from: current, to: new, duration: 0.3, options: [], animations: { new.view.frame = self.view.bounds }) { completed in self.current.removeFromParentViewController() new.didMove(toParentViewController: self) self.current = new completion?() } } 

ये एनीमेशन के सिर्फ दो उदाहरण हैं, उसी दृष्टिकोण का उपयोग करके आप किसी भी जटिल एनिमेशन को बना सकते हैं जिसकी आपको आवश्यकता है

कॉन्फ़िगरेशन को पूरा करने के लिए, SplashViewController, LoginViewController और MainViewController से एनिमेशन के साथ विधि कॉल जोड़ें:

 class SplashViewController: UIViewController { ... private func makeServiceCall() { if UserDefaults.standard.bool(forKey: “LOGGED_IN”) { // navigate to protected page AppDelegate.shared.rootViewController.switchToMainScreen() } else { // navigate to login screen AppDelegate.shared.rootViewController.switchToLogout() } } } class LoginViewController: UIViewController { ... @objc private func login() { ... AppDelegate.shared.rootViewController.switchToMainScreen() } } class MainViewController: UIViewController { ... @objc private func logout() { ... AppDelegate.shared.rootViewController.switchToLogout() } } 

संकलन करें, एप्लिकेशन चलाएं और दो तरीकों से इसके संचालन की जांच करें:

- जब उपयोगकर्ता के पास पहले से ही एक सक्रिय चालू सत्र हो (लॉग इन)
- जब कोई सक्रिय सत्र नहीं होता है और प्रमाणीकरण की आवश्यकता होती है

दोनों मामलों में, आपको स्प्लैशस्क्रीन को लोड करने के तुरंत बाद, वांछित स्क्रीन पर एक संक्रमण देखना चाहिए।



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