Swift में इंटरनेट कनेक्टिविटी का पता लगाना और प्रबंधित करना: एक व्यावहारिक गाइड

Neo Ighodaro द्वारा

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

इस लेख में, हम देखेंगे कि Swift में इंटरनेट कनेक्शन मुद्दों का पता कैसे लगाया जाए, और इसे संभालने के कुछ तरीके।

यहां वह सैंपल एप्लिकेशन है जिसे हम बनाएंगे और यह विभिन्न इंटरनेट कनेक्टिविटी परिदृश्यों को कैसे संभालता है:

आवश्यकताएं

इस लेख में साथ चलने में सक्षम होने के लिए, आपको निम्नलिखित आवश्यकताओं की आवश्यकता होगी:

• आपकी मशीन पर Xcode इंस्टॉल।
• Swift प्रोग्रामिंग भाषा का ज्ञान।
• आपकी मशीन पर CocoaPods इंस्टॉल।

जब आपके पास उपरोक्त आवश्यकताएं हों, तो आइए गोता लगाएं।

हमारा वर्कस्पेस सेटअप करना

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

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

Xcode खोलें और एक नया प्रोजेक्ट सेट करें।

यह प्रोजेक्ट एक सरल प्लेग्राउंड होगा जिसके साथ हम प्रयोग कर सकते हैं।

कनेक्शन ऑफलाइन होने का पता लगाने के लिए हम Reachability.swift ** पैकेज का उपयोग करने जा रहे हैं। यह "क्लोजर्स के साथ Swift में पुनः लिखे गए Apple के Reachability के लिए एक प्रतिस्थापन" है।

अपना टर्मिनल खोलें और नीचे दिए गए कमांड को चलाएं:

$ pod init

यह एक नया Podfile बनाएगा जहां हम CocoaPods निर्भरता घोषित कर सकते हैं। Podfile खोलें और सामग्री को नीचे दिए गए कोड से बदलें:

platform :ios, '9.0'

target 'project_name' do use_frameworks! pod 'ReachabilitySwift' pod 'Alamofire'end

आपको बदलने की आवश्यकता है **project_name** अपने प्रोजेक्ट के नाम के साथ।

फाइल सेव करें और अपने प्रोजेक्ट में Pods इंस्टॉल करने के लिए नीचे दिए गए कमांड को चलाएं:

$ pod install

जब इंस्टॉलेशन पूरा हो जाए, तो अपने प्रोजेक्ट के रूट में *.xcworkspace फाइल खोलें। यह Xcode लॉन्च करेगा।

हमारा Network Reachability Manager बनाना

एक नया NetworkManager क्लास बनाएं। यह क्लास नेटवर्क स्टेटस को स्टोर करेगी और Reachability पैकेज का एक सरल प्रॉक्सी होगी। फाइल में, नीचे दिए गए कोड को पेस्ट करें:

import Foundation
import Reachability

class NetworkManager: NSObject {

 var reachability: Reachability!

 static let sharedInstance: NetworkManager = { return NetworkManager() }()

 override init() { super.init()

 // Reachability इनिशियलाइज़ करें reachability = Reachability()!

 // नेटवर्क स्टेटस के लिए ऑब्जर्वर रजिस्टर करें NotificationCenter.default.addObserver( self, selector: #selector(networkStatusChanged(_:)), name: .reachabilityChanged, object: reachability )

 do { // नेटवर्क स्टेटस नोटिफायर शुरू करें try reachability.startNotifier() } catch { print("Unable to start notifier") } }

 @objc func networkStatusChanged(_ notification: Notification) { // यहां वैश्विक स्तर पर कुछ करें! }

 static func stopNotifier() -> Void { do { // नेटवर्क स्टेटस नोटिफायर बंद करें try (NetworkManager.sharedInstance.reachability).startNotifier() } catch { print("Error stopping notifier") } }

 // नेटवर्क पहुंच योग्य है static func isReachable(completed: @escaping (NetworkManager) -> Void) { if (NetworkManager.sharedInstance.reachability).connection != .none { completed(NetworkManager.sharedInstance) } }

 // नेटवर्क पहुंच योग्य नहीं है static func isUnreachable(completed: @escaping (NetworkManager) -> Void) { if (NetworkManager.sharedInstance.reachability).connection == .none { completed(NetworkManager.sharedInstance) } }

 // नेटवर्क WWAN/सेल्युलर के माध्यम से पहुंच योग्य है static func isReachableViaWWAN(completed: @escaping (NetworkManager) -> Void) { if (NetworkManager.sharedInstance.reachability).connection == .cellular { completed(NetworkManager.sharedInstance) } }

 // नेटवर्क WiFi के माध्यम से पहुंच योग्य है static func isReachableViaWiFi(completed: @escaping (NetworkManager) -> Void) { if (NetworkManager.sharedInstance.reachability).connection == .wifi { completed(NetworkManager.sharedInstance) } }]

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

init मेथड में, हम Reachability का एक इंस्टेंस बनाते हैं और फिर NotificationCenter क्लास का उपयोग करके एक नोटिफिकेशन रजिस्टर करते हैं। अब, हर बार नेटवर्क स्टेटस बदलता है, NotificationCenter द्वारा निर्दिष्ट कॉलबैक (जो networkStatusChanged है) को कॉल किया जाएगा। हम इसका उपयोग वैश्विक स्तर पर कुछ करने के लिए कर सकते हैं जो नेटवर्क अनुपलब्ध होने पर सक्रिय होता है।

हमने अन्य हेल्पर फंक्शन्स परिभाषित किए हैं जो आम तौर पर हमारे इंटरनेट कनेक्शन की स्थिति के आधार पर कोड चलाना आसान बना देंगे। हमारे पास *isReachable*, *isUnreachable*, *isReachableViaWWAN* और *isReachableViaWiFi* हैं।

इन हेल्पर्स में से एक का उपयोग आम तौर पर इस तरह दिखेगा:

NetworkManager.isReachable { networkManagerInstance in print("Network is available")}

NetworkManager.isUnreachable { networkManagerInstance in print("Network is Unavailable")}

यह एक इवेंट लिसनर नहीं है और केवल एक बार चलेगा। रीयल-टाइम में नेटवर्क परिवर्तनों को चुनने के लिए लिसनर का उपयोग करने के लिए, आपको उपयोग करने की आवश्यकता होगी NetworkManager.sharedInstance.reachability.whenReachable. हम बाद में लेख में एक उदाहरण दिखाएंगे।

अब जब हमारे पास एक मैनेजर क्लास है, तो आइए देखें कि हम इसे एप्लिकेशन में कैसे उपयोग कर सकते हैं।

एप्लिकेशन लॉन्च पर नेटवर्क उपलब्धता को संभालना

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

LaunchViewController नामक एक नया कंट्रोलर बनाएं। हम स्टोरीबोर्ड पर पहले कंट्रोलर व्यू को लॉन्च कंट्रोलर के रूप में मानेंगे। हम यह पता लगाने की कोशिश करेंगे कि उपयोगकर्ता का डिवाइस ऑनलाइन है या नहीं, और यदि नहीं, तो हम इसे संभालने के लिए एक ऑफलाइन पेज बनाएंगे ताकि उपयोगकर्ता एप्लिकेशन में बिल्कुल भी न जाए।

LaunchController में, सामग्री को निम्नलिखित कोड से बदलें:

import UIKit

class LaunchViewController: UIViewController { let network: NetworkManager = NetworkManager.sharedInstance

 override func viewDidLoad() { super.viewDidLoad()

 NetworkManager.isUnreachable { _ in self.showOfflinePage() } }

 private func showOfflinePage() -> Void { DispatchQueue.main.async { self.performSegue( withIdentifier: "NetworkUnavailable", sender: self ) } }}

इस क्लास में, हम अपने NetworkManager के *isUnreachable* मेथड का उपयोग करते हैं जब नेटवर्क अनुपलब्ध होता है तो showOffline मेथड को फायर करने के लिए। आइए उस व्यू कंट्रोलर को बनाएं। OfflineViewController नामक एक नया व्यू कंट्रोलर बनाएं।

Main.storyboard फाइल खोलें और पहले व्यू के कस्टम क्लास को LaunchViewController पर सेट करें।

अगला, स्टोरीबोर्ड में एक नया व्यू कंट्रोलर बनाएं। इस नए व्यू कंट्रोलर के लिए कस्टम क्लास के रूप में OfflineViewController सेट करें। अब नए व्यू कंट्रोलर और LaunchViewController के बीच NetworkUnavailable नामक एक मैन्युअल सेग्यू बनाएं। जब आप पूरा कर लें तो आपके पास कुछ ऐसा होना चाहिए:

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

अब आइए एक व्यू कंट्रोलर बनाएं जो कनेक्शन होने पर दिखाई दे।

डिवाइस ऑनलाइन आने पर इवेंट्स को संभालना

अब जब हमने एक Offline View Controller बनाया है और यह डिवाइस ऑफलाइन होने पर काम करता है, तो आइए संभालें कि जब डिवाइस वापस ऑनलाइन आता है तो क्या होता है।

Offline View Controller के नीचे स्टोरीबोर्ड पर एक नया नेविगेशन व्यू कंट्रोलर बनाएं। हम एक कंट्रोलर बनाएंगे जो लेटेस्ट Reddit पोस्ट प्रदर्शित करता है। PostsTableViewController नामक एक नया व्यू कंट्रोलर क्लास बनाएं। अब इसे नेविगेशन व्यू कंट्रोलर से जुड़े व्यू कंट्रोलर के लिए कस्टम क्लास बनाएं।

अब नेविगेशन व्यू कंट्रोलर से लॉन्च व्यू कंट्रोलर और Offline View Controller तक MainController नामक एक मैन्युअल सेग्यू बनाएं। आपके पास कुछ ऐसा होना चाहिए:

अब, LaunchViewController क्लास खोलें और viewDidLoad मेथड के नीचे निम्नलिखित जोड़ें:

NetworkManager.isReachable { _ in self.showMainPage()}

फिर कंट्रोलर में नीचे दिए गए मेथड को जोड़ें:

private func showMainPage() -> Void { DispatchQueue.main.async { self.performSegue( withIdentifier: "MainController", sender: self ) }}

यह सुनिश्चित करेगा कि जब ऐप लॉन्च होता है, तो यह कनेक्टिविटी की जांच करेगा और फिर, यदि कनेक्शन उपलब्ध है, तो यह PostsTableViewController प्रस्तुत करेगा। अन्यथा यह OfflineViewController प्रस्तुत करेगा।

बढ़िया! लेकिन क्या होता है जब उपयोगकर्ता OfflineViewController पर पहुंच गया है और फिर नेटवर्क वापस ऑनलाइन आता है? आइए उस परिदृश्य को संभालें।

OfflineViewController खोलें और कोड को नीचे दिए गए कोड से बदलें:

import UIKit

class OfflineViewController: UIViewController { let network = NetworkManager.sharedInstance

 override func viewDidLoad() { super.viewDidLoad()

 // यदि नेटवर्क पहुंच योग्य है तो मेन कंट्रोलर दिखाएं network.reachability.whenReachable = { _ in self.showMainController() } }

 override func viewWillAppear(_ animated: Bool) { super.viewWillAppear(animated)

 navigationController?.setNavigationBarHidden(true, animated: animated) }

 override func viewWillDisappear(_ animated: Bool) { super.viewWillDisappear(animated)

 navigationController?.setNavigationBarHidden(false, animated: animated) }

 private func showMainController() -> Void { DispatchQueue.main.async { self.performSegue(withIdentifier: "MainController", sender: self) } }}

उपरोक्त कंट्रोलर में, आप viewDidLoad मेथड में देख सकते हैं, कि हमने whenReachable कंप्लीशन को मेन कंट्रोलर दिखाने के लिए सेट किया है। इसका मतलब है कि, जब तक यह ऑफलाइन है, आप देखते हैं कि डिवाइस कब वापस ऑनलाइन आता है। जब यह होता है, तो PostsTableViewController प्रस्तुत करें।

हम viewWillAppear और viewWillDisappear मेथड्स को भी ओवरराइड करते हैं ताकि यह सुनिश्चित हो सके कि नेविगेशन बार Offline View Controller पर दिखाई न दे।

Swift में Reddit API से पोस्ट्स प्राप्त करना

अब आइए वह लॉजिक जोड़ें जो Reddit से डेटा प्राप्त करेगा और हमारे PostsTableViewController पर प्रदर्शित करेगा। फाइल खोलें और सामग्री को नीचे दिए गए कोड से बदलें:

import UIKit
import Alamofire

struct RedditPost { let title: String! let subreddit: String!}

class PostsTableViewController: UITableViewController { var posts = [RedditPost]()

 let network = NetworkManager.sharedInstance

 override func viewDidLoad() { super.viewDidLoad() navigationItem.title = "Latest Posts"

 // पोस्ट्स प्राप्त करें और फिर टेबल रीलोड करें fetchPosts { posts in self.posts = posts self.tableView.reloadData() } }

 private func fetchPosts(completion: @escaping (_ posts: [RedditPost]) -> Void) -> Void { // Reddit API को अनुरोध भेजें Alamofire.request("https://api.reddit.com").validate().responseJSON { response in switch response.result { case .success(let JSON): let data = JSON as! [String:AnyObject] guard let children = data["data"]!["children"] as? [AnyObject] else { return } var posts = [RedditPost]()

 // Reddit पोस्ट्स के माध्यम से लूप करें और फिर पोस्ट्स सरणी में एक पोस्ट असाइन करें for child in 0...children.count-1 { let post = children[child]["data"] as! [String: AnyObject]

 posts.append(RedditPost( title: post["title"] as! String, subreddit: "/r/" + (post["subreddit"] as! String) )) }

 DispatchQueue.main.async { completion(posts) } case .failure(let error): print(error) } } }

 override func didReceiveMemoryWarning() { super.didReceiveMemoryWarning() }

 // MARK: - Table view data source override func numberOfSections(in tableView: UITableView) -> Int { return 1 }

 // उपलब्ध पोस्ट्स की संख्या लौटाएं override func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int { return self.posts.count }

 override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell { let cell = tableView.dequeueReusableCell(withIdentifier: "PostCell", for: indexPath) let post = posts[indexPath.row] as RedditPost cell.textLabel?.text = post.title cell.detailTextLabel?.text = post.subreddit return cell }}

fetchPosts मेथड में, हम Reddit API को GET अनुरोध भेजने के लिए Alamofire का उपयोग करते हैं। हम फिर प्रतिक्रिया को पार्स करते हैं और इसे फाइल के शीर्ष पर बनाए गए RedditPost स्ट्रक्ट में जोड़ते हैं। यह उस डेटा को सुसंगत बनाता है जिसे हम tableView को पास कर रहे हैं।

डिवाइस ऑफलाइन होने पर इवेंट्स को संभालना

अब, आइए एक और परिदृश्य को संभालें। कल्पना करें कि लेटेस्ट Reddit पोस्ट्स देखते समय, आप कनेक्टिविटी खो देते हैं। क्या होता है? आइए फिर से ऑफलाइन पेज दिखाएं जब ऐसा होता है।

जैसा कि पहले किया गया था, PostsTableViewController से OfflineViewController तक NetworkUnavailable नामक एक मैन्युअल सेग्यू बनाएं। अब viewDidLoad मेथड के नीचे इस कोड को जोड़ें:

network.reachability.whenUnreachable = { reachability in self.showOfflinePage()}

अब कंट्रोलर में नीचे दिए गए मेथड को जोड़ें:

private func showOfflinePage() -> Void { DispatchQueue.main.async { self.performSegue(withIdentifier: "NetworkUnavailable", sender: self) }}

यह सुनेगा जब डिवाइस ऑफलाइन जाता है और, यदि ऐसा होता है, तो यह showOfflinePage करेगा।

बस इतना ही! हम अपने NetworkManager का उपयोग करके Swift में ऑफलाइन और ऑनलाइन इवेंट्स को संभालने में सक्षम हैं।

निष्कर्ष

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

इस प्लेग्राउंड का सोर्स कोड GitHub पर उपलब्ध है।

यह लेख पहली बार Pusher पर प्रकाशित हुआ था।

मुफ्त में कोड करना सीखें। freeCodeCamp के ओपन सोर्स करिकुलम ने 40,000 से अधिक लोगों को डेवलपर के रूप में नौकरी पाने में मदद की है। शुरू करें