स्विफ्ट के साथ इंटरनेट कनेक्शन की जाँच करें


251

जब मैं अपने iPhone पर इंटरनेट कनेक्शन की जांच करने का प्रयास करता हूं तो मुझे त्रुटियों का एक गुच्छा मिलता है। क्या कोई मुझे इसे ठीक करने में मदद कर सकता है?

कोड:

import Foundation
import SystemConfiguration

public class Reachability {

class func isConnectedToNetwork() -> Bool {

    var zeroAddress = sockaddr_in()
    zeroAddress.sin_len = UInt8(sizeofValue(zeroAddress))
    zeroAddress.sin_family = sa_family_t(AF_INET)

    let defaultRouteReachability = withUnsafePointer(&zeroAddress) {
        SCNetworkReachabilityCreateWithAddress(nil, UnsafePointer($0))
    }

    var flags: SCNetworkReachabilityFlags = 0

    if SCNetworkReachabilityGetFlags(defaultRouteReachability, &flags) == 0 {
        return false
    }

    let isReachable = (flags & UInt32(kSCNetworkFlagsReachable)) != 0
    let needsConnection = (flags & UInt32(kSCNetworkFlagsConnectionRequired)) != 0

    return (isReachable && !needsConnection) ? true : false
}

}

कोड के साथ त्रुटियां:

त्रुटियाँ

यदि यह अपठनीय है, तो त्रुटि 1 कहती है:

'Int' 'SCNetworkReachabilityFlags' के लिए परिवर्तनीय नहीं है

त्रुटि 2 और 3:

आपूर्ति किए गए तर्कों को स्वीकार करने वाले 'init' के लिए अधिभार नहीं मिला


1
कोड जैसा मैंने यहां सुझाया था, वैसा ही दिखता है: stackoverflow.com/a/25623647/1187415 , इसलिए मैंने स्विफ्ट 2 के लिए एक अपडेट किया है
मार्टिन आर

2
मुझे यहां पूरी तरह से काम करने वाली स्विफ्ट 2 रिएचबिलिटी कार्यान्वयन मिल गया है ... github.com/ashleymills/Reachability.swift - संदर्भ के रूप में उपयोग करने के लिए स्वतंत्र महसूस करें।
एशले मिल्स

1
stackoverflow.com/a/25623647/1187415 अब स्विफ्ट 3, Xcode 8 बीटा 6. के लिए अपडेट किया गया है
मार्टिन आर

1
Apple एक आधिकारिक स्विफ्ट नमूना प्रदान करता है , और आप इसे CocoaPods पर प्राप्त कर सकते हैं । यह किसी भी स्विफ्ट परियोजना के साथ संगत है।
कूर

जवाबों:


368

टिप्पणियों में उल्लिखित 4 जी मुद्दे को हल करने के लिए मैंने @AshleyMills रीचैबिलिटी कार्यान्वयन का उपयोग एक संदर्भ के रूप में किया है और स्विफ्ट 3.1 के लिए रीचैबिलिटी को फिर से लिखा है:

अद्यतन: Xcode 10.1 • स्विफ्ट 4 या बाद में


Reachability.swift फ़ाइल

import Foundation
import SystemConfiguration

class Reachability {
    var hostname: String?
    var isRunning = false
    var isReachableOnWWAN: Bool
    var reachability: SCNetworkReachability?
    var reachabilityFlags = SCNetworkReachabilityFlags()
    let reachabilitySerialQueue = DispatchQueue(label: "ReachabilityQueue")
    init(hostname: String) throws {
        guard let reachability = SCNetworkReachabilityCreateWithName(nil, hostname) else {
            throw Network.Error.failedToCreateWith(hostname)
        }
        self.reachability = reachability
        self.hostname = hostname
        isReachableOnWWAN = true
        try start()
    }
    init() throws {
        var zeroAddress = sockaddr_in()
        zeroAddress.sin_len = UInt8(MemoryLayout<sockaddr_in>.size)
        zeroAddress.sin_family = sa_family_t(AF_INET)
        guard let reachability = withUnsafePointer(to: &zeroAddress, {
            $0.withMemoryRebound(to: sockaddr.self, capacity: 1) {
                SCNetworkReachabilityCreateWithAddress(nil, $0)
            }
        }) else {
            throw Network.Error.failedToInitializeWith(zeroAddress)
        }
        self.reachability = reachability
        isReachableOnWWAN = true
        try start()
    }
    var status: Network.Status {
        return  !isConnectedToNetwork ? .unreachable :
                isReachableViaWiFi    ? .wifi :
                isRunningOnDevice     ? .wwan : .unreachable
    }
    var isRunningOnDevice: Bool = {
        #if targetEnvironment(simulator)
            return false
        #else
            return true
        #endif
    }()
    deinit { stop() }
}

extension Reachability {

    func start() throws {
        guard let reachability = reachability, !isRunning else { return }
        var context = SCNetworkReachabilityContext(version: 0, info: nil, retain: nil, release: nil, copyDescription: nil)
        context.info = Unmanaged<Reachability>.passUnretained(self).toOpaque()
        guard SCNetworkReachabilitySetCallback(reachability, callout, &context) else { stop()
            throw Network.Error.failedToSetCallout
        }
        guard SCNetworkReachabilitySetDispatchQueue(reachability, reachabilitySerialQueue) else { stop()
            throw Network.Error.failedToSetDispatchQueue
        }
        reachabilitySerialQueue.async { self.flagsChanged() }
        isRunning = true
    }

    func stop() {
        defer { isRunning = false }
        guard let reachability = reachability else { return }
        SCNetworkReachabilitySetCallback(reachability, nil, nil)
        SCNetworkReachabilitySetDispatchQueue(reachability, nil)
        self.reachability = nil
    }

    var isConnectedToNetwork: Bool {
        return isReachable &&
               !isConnectionRequiredAndTransientConnection &&
               !(isRunningOnDevice && isWWAN && !isReachableOnWWAN)
    }

    var isReachableViaWiFi: Bool {
        return isReachable && isRunningOnDevice && !isWWAN
    }

    /// Flags that indicate the reachability of a network node name or address, including whether a connection is required, and whether some user intervention might be required when establishing a connection.
    var flags: SCNetworkReachabilityFlags? {
        guard let reachability = reachability else { return nil }
        var flags = SCNetworkReachabilityFlags()
        return withUnsafeMutablePointer(to: &flags) {
            SCNetworkReachabilityGetFlags(reachability, UnsafeMutablePointer($0))
            } ? flags : nil
    }

    /// compares the current flags with the previous flags and if changed posts a flagsChanged notification
    func flagsChanged() {
        guard let flags = flags, flags != reachabilityFlags else { return }
        reachabilityFlags = flags
        NotificationCenter.default.post(name: .flagsChanged, object: self)
    }

    /// The specified node name or address can be reached via a transient connection, such as PPP.
    var transientConnection: Bool { return flags?.contains(.transientConnection) == true }

    /// The specified node name or address can be reached using the current network configuration.
    var isReachable: Bool { return flags?.contains(.reachable) == true }

    /// The specified node name or address can be reached using the current network configuration, but a connection must first be established. If this flag is set, the kSCNetworkReachabilityFlagsConnectionOnTraffic flag, kSCNetworkReachabilityFlagsConnectionOnDemand flag, or kSCNetworkReachabilityFlagsIsWWAN flag is also typically set to indicate the type of connection required. If the user must manually make the connection, the kSCNetworkReachabilityFlagsInterventionRequired flag is also set.
    var connectionRequired: Bool { return flags?.contains(.connectionRequired) == true }

    /// The specified node name or address can be reached using the current network configuration, but a connection must first be established. Any traffic directed to the specified name or address will initiate the connection.
    var connectionOnTraffic: Bool { return flags?.contains(.connectionOnTraffic) == true }

    /// The specified node name or address can be reached using the current network configuration, but a connection must first be established.
    var interventionRequired: Bool { return flags?.contains(.interventionRequired) == true }

    /// The specified node name or address can be reached using the current network configuration, but a connection must first be established. The connection will be established "On Demand" by the CFSocketStream programming interface (see CFStream Socket Additions for information on this). Other functions will not establish the connection.
    var connectionOnDemand: Bool { return flags?.contains(.connectionOnDemand) == true }

    /// The specified node name or address is one that is associated with a network interface on the current system.
    var isLocalAddress: Bool { return flags?.contains(.isLocalAddress) == true }

    /// Network traffic to the specified node name or address will not go through a gateway, but is routed directly to one of the interfaces in the system.
    var isDirect: Bool { return flags?.contains(.isDirect) == true }

    /// The specified node name or address can be reached via a cellular connection, such as EDGE or GPRS.
    var isWWAN: Bool { return flags?.contains(.isWWAN) == true }

    /// The specified node name or address can be reached using the current network configuration, but a connection must first be established. If this flag is set
    /// The specified node name or address can be reached via a transient connection, such as PPP.
    var isConnectionRequiredAndTransientConnection: Bool {
        return (flags?.intersection([.connectionRequired, .transientConnection]) == [.connectionRequired, .transientConnection]) == true
    }
}

func callout(reachability: SCNetworkReachability, flags: SCNetworkReachabilityFlags, info: UnsafeMutableRawPointer?) {
    guard let info = info else { return }
    DispatchQueue.main.async {
        Unmanaged<Reachability>
            .fromOpaque(info)
            .takeUnretainedValue()
            .flagsChanged()
    }
}

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

struct Network {
    static var reachability: Reachability!
    enum Status: String {
        case unreachable, wifi, wwan
    }
    enum Error: Swift.Error {
        case failedToSetCallout
        case failedToSetDispatchQueue
        case failedToCreateWith(String)
        case failedToInitializeWith(sockaddr_in)
    }
}

प्रयोग

इसे अपने AppDelegate.swift में शुरू करें ।FishishLaunchingWithOptions विधि और किसी भी त्रुटि को हैंडल कर सकते हैं:

import UIKit
@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {
    var window: UIWindow?
    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        do {
            try Network.reachability = Reachability(hostname: "www.google.com")
        }
        catch {
            switch error as? Network.Error {
            case let .failedToCreateWith(hostname)?:
                print("Network error:\nFailed to create reachability object With host named:", hostname)
            case let .failedToInitializeWith(address)?:
                print("Network error:\nFailed to initialize reachability object With address:", address)
            case .failedToSetCallout?:
                print("Network error:\nFailed to set callout")
            case .failedToSetDispatchQueue?:
                print("Network error:\nFailed to set DispatchQueue")
            case .none:
                print(error)
            }
        }
        return true
    }
}

और एक दृश्य नियंत्रक नमूना:

import UIKit
class ViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
        NotificationCenter.default
            .addObserver(self,
                         selector: #selector(statusManager),
                         name: .flagsChanged,
                         object: nil)
        updateUserInterface()
    }
    func updateUserInterface() {
        switch Network.reachability.status {
        case .unreachable:
            view.backgroundColor = .red
        case .wwan:
            view.backgroundColor = .yellow
        case .wifi:
            view.backgroundColor = .green
        }
        print("Reachability Summary")
        print("Status:", Network.reachability.status)
        print("HostName:", Network.reachability.hostname ?? "nil")
        print("Reachable:", Network.reachability.isReachable)
        print("Wifi:", Network.reachability.isReachableViaWiFi)
    }
    @objc func statusManager(_ notification: Notification) {
        updateUserInterface()
    }
}

नमूना परियोजना


2
आपको एक्सकोड से `== 0` को निकालने की आवश्यकता है if SCNetworkReachabilityGetFlags(…)क्योंकि यह नवीनतम संस्करण में एक बूल देता है।
मेल्विन

64
यह @NickM के रूप में उल्लिखित सही नहीं है। सेल्यूलर कनेक्शन के लिए काम नहीं करेगा । यह प्रयोग न करें। मुझे आश्चर्य है कि इसमें बहुत सारे वोट हैं, शायद यह iOS 9 के रूप में नया है ... लेकिन मुझे ऐसा नहीं लगता।
जॉर्डन स्मिथ

1
IOS9 पर काम नहीं करता है, बहुत कठिन तरीके से पता चला है - स्टोर में ऐप ... तो मुझे लगता है कि भले ही यह 100% सटीक नहीं है और यह कुछ के लिए काम करता है, यह सबसे अच्छा असंगत है, इसलिए जो कोई भी मौके लेना चाहता है वह भी चाहता हो सकता है कुछ घोड़े या कुत्ते पर दांव लगाने के लिए अगर वे भाग्यशाली महसूस कर रहे हैं।
निक एम

2
@NickM - यह बताता है कि इतने वोट क्यों। @ सिंह IOS 9 के लिए अपने जवाब को अपडेट करने के लिए, एक ही जाल में ठोकर खाने वाले अन्य लोगों को बचाने के लिए यह एक अच्छा विचार हो सकता है। मैं यह पुष्टि कर सकता हूं कि यह iOS 9 पर काम नहीं करता है (कम से कम कुछ स्थितियों में) ... github.com/ashleymills/Reachability.swift में बदलना हालांकि ठीक काम करता है।
जॉर्डन स्मिथ

1
हाँ, मैं देख रहा हूँ कि यह iOS10 शाखा
ऐस ग्रीन

226

स्विफ्ट 3 के लिए, स्विफ्ट 4 (सेलुलर और वाई-फाई के साथ काम करना):

import SystemConfiguration

public class Reachability {

    class func isConnectedToNetwork() -> Bool {

        var zeroAddress = sockaddr_in(sin_len: 0, sin_family: 0, sin_port: 0, sin_addr: in_addr(s_addr: 0), sin_zero: (0, 0, 0, 0, 0, 0, 0, 0))
        zeroAddress.sin_len = UInt8(MemoryLayout.size(ofValue: zeroAddress))
        zeroAddress.sin_family = sa_family_t(AF_INET)

        let defaultRouteReachability = withUnsafePointer(to: &zeroAddress) {
            $0.withMemoryRebound(to: sockaddr.self, capacity: 1) {zeroSockAddress in
                SCNetworkReachabilityCreateWithAddress(nil, zeroSockAddress)
            }
        }

        var flags: SCNetworkReachabilityFlags = SCNetworkReachabilityFlags(rawValue: 0)
        if SCNetworkReachabilityGetFlags(defaultRouteReachability!, &flags) == false {
            return false
        }

        /* Only Working for WIFI
        let isReachable = flags == .reachable
        let needsConnection = flags == .connectionRequired

        return isReachable && !needsConnection
        */

        // Working for Cellular and WIFI
        let isReachable = (flags.rawValue & UInt32(kSCNetworkFlagsReachable)) != 0
        let needsConnection = (flags.rawValue & UInt32(kSCNetworkFlagsConnectionRequired)) != 0
        let ret = (isReachable && !needsConnection)

        return ret

    }
}

उपयोग:

if Reachability.isConnectedToNetwork(){
    print("Internet Connection Available!")
}else{
    print("Internet Connection not Available!")
}

3
यह समाधान + CoreTelephony (CTTelephonyNetworkInfo ()। CurrentRadioAccessTechnology) वर्तमान नेटवर्क प्रकार को प्राप्त करने के लिए सबसे अच्छा समाधान है, और बिना तीसरे पक्ष के काम पर निर्भर करने के लिए आवश्यक है।
अलेजांद्रो जिमेनेज अगूडो

3
तेजी से 3.1 के साथ सेलुलर और वाईफाई के लिए काम करता है! आईफोन 6 और 7. पर काम किए गए कार्य यदि सेल्युलर ऑफ मुझे मिलता है ".. कनेक्शन उपलब्ध नहीं है"। अगर मैं हवाई जहाज मोड चालू करता हूं तो वही मिलता है "... उपलब्ध नहीं"। अगर मैं सेलुलर बंद रखता हूँ और वाईफाई चालू करता हूँ तो मुझे ".. कनेक्शन उपलब्ध है" और अंत में अगर मैं वाईफाई बंद कर देता हूँ और सेलुलर को चालू करता हूँ तो मुझे ".. कनेक्शन उपलब्ध है"। ध्यान दें मेरा सेलुलर कनेक्शन एलटीई है
ब्रायन

1
नमस्ते, यह iOS 11 पर काम नहीं करता है, एक भौतिक उपकरण पर हवाई जहाज मोड। जब एयरप्लेन मोड पर सेट किया जाता है, isReachable अभी भी सच है ... किसी भी विचार क्यों?
लॉरेंस टैन

3
यह मेरे लिए सभी परिदृश्यों में सही काम कर रहा है। आईओएस 12 के साथ iPhone 6 पर चलने के साथ इसका परीक्षण भी किया गया है
r3dm4n

3
अगर मैं इंटरनेट कनेक्शन के बिना वाईफाई नेटवर्क से जुड़ा हुआ हूं तो यह काम नहीं करता है
नाथन बरेटो

58

अपनी परियोजना के भीतर एक नई स्विफ्ट फ़ाइल बनाएं, इसे नाम दें Reachability.swift। अपनी कक्षा बनाने के लिए इसमें निम्न कोड काटें और चिपकाएँ।

import Foundation
import SystemConfiguration

public class Reachability {

    class func isConnectedToNetwork() -> Bool {

        var zeroAddress = sockaddr_in(sin_len: 0, sin_family: 0, sin_port: 0, sin_addr: in_addr(s_addr: 0), sin_zero: (0, 0, 0, 0, 0, 0, 0, 0))
        zeroAddress.sin_len = UInt8(sizeofValue(zeroAddress))
        zeroAddress.sin_family = sa_family_t(AF_INET)

        let defaultRouteReachability = withUnsafePointer(&zeroAddress) {
            SCNetworkReachabilityCreateWithAddress(kCFAllocatorDefault, UnsafePointer($0))
        }

        var flags: SCNetworkReachabilityFlags = SCNetworkReachabilityFlags(rawValue: 0)
        if SCNetworkReachabilityGetFlags(defaultRouteReachability!, &flags) == false {
             return false
        }

        let isReachable = flags == .Reachable
        let needsConnection = flags == .ConnectionRequired

        return isReachable && !needsConnection

    }
}

आप इस कोड का उपयोग करके अपने प्रोजेक्ट में कहीं भी इंटरनेट कनेक्शन की जांच कर सकते हैं:

if Reachability.isConnectedToNetwork() {
    println("Internet connection OK")
} else {
    println("Internet connection FAILED")
}

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

if Reachability.isConnectedToNetwork() {
    println("Internet connection OK")
} else {
    println("Internet connection FAILED")
    var alert = UIAlertView(title: "No Internet Connection", message: "Make sure your device is connected to the internet.", delegate: nil, cancelButtonTitle: "OK")
    alert.show()
}

स्पष्टीकरण:

हम एक पुन: प्रयोज्य सार्वजनिक वर्ग और एक विधि बना रहे हैं जिसका उपयोग इंटरनेट कनेक्टिविटी की जांच के लिए परियोजना में कहीं भी किया जा सकता है। हमें फ़ाउंडेशन और सिस्टम कॉन्फ़िगरेशन फ़्रेमवर्क जोड़ने की आवश्यकता है।

पब्लिक क्लास रीचबिलिटी में, विधि isConnectedToNetwork() -> Bool { }इंटरनेट कनेक्टिविटी के बारे में एक बूल मान लौटाएगा। यदि हम मामले पर आवश्यक कार्रवाई करने के लिए एक लूप का उपयोग करते हैं। मुझे उम्मीद है कि यह पर्याप्त है। चीयर्स!


4
जब आप एक समाधान दे रहे हैं, तो कृपया इसे थोड़ा समझाने की कोशिश करें। समाधान देना महत्वपूर्ण नहीं है, लेकिन अपने पाठकों को समाधान समझना और इसकी अवधारणा अधिक महत्वपूर्ण है।
जी.भाईसेक

1
मैं iOS प्रोग्रामिंग के लिए नया हूं। हमें उद्देश्य के लिए C संरचना को आरंभ करने की आवश्यकता क्यों है। हम किस उदाहरण में C संरचनाओं का उपयोग कर सकते हैं?
G.Abhisek

1
मैंने इसे "viewdidload" पर केवल परीक्षण के लिए रखा। मैं ऐप खोलता हूं और ठीक है, इंटरनेट है, लेकिन जब मैं अपने इंटरनेट को शूट करता हूं, तो यह मुझे दिखाता है कि मेरे पास इंटरनेट है ... यह लगातार है? या मुझे हर बार "कॉल एक्शन" करना है?
डैनियल एरेन्तेस लवर्स ने

16
@AlvinGeorge सेलुलर नेटवर्क से कनेक्ट होने पर यह काम नहीं करता है । यह केवल वाईफ़ाई का उपयोग करते समय काम करता है। किसी और के लिए - आप अपने ऐप में इसका उपयोग नहीं करना चाहते हैं! @ एल्विन - क्या मैं आपको अपना उत्तर अपडेट करने, या हटाने का सुझाव दे सकता हूं? 19 वोटों के साथ यह अन्य डेवलपर्स के लिए बहुत भ्रामक है जो एक ही जाल में गिर सकते हैं।
जॉर्डन स्मिथ

@ जोर्डन: यह विधि नेटवर्क स्थिति के लिए डिफ़ॉल्ट ऐप्पल फ्रेमवर्क का उपयोग कर रही है। यह नए iOS संस्करणों के साथ बदल सकता है। इसलिए मैं आपको Ashely Mill के रीचैबिलिटी क्लास को जांचने और कार्यान्वित करने की सलाह देता हूं। मैंने एक निर्भरता मुक्त कार्यान्वयन किया है और ऊपर दिए गए लिंक को साझा किया है। कृपया एक नज़र डालें।
एजी

56

अगर कोई पहले से ही अल्मोफायर का उपयोग कर रहा है तो -

struct Connectivity {
  static let sharedInstance = NetworkReachabilityManager()!
  static var isConnectedToInternet:Bool {
      return self.sharedInstance.isReachable
    }
}

उपयोग:

if Connectivity.isConnectedToInternet {
     print("Connected")
 } else {
     print("No Internet")
}

1
Alamofire प्रलेखन से:> NetworkReachabilityManager वर्ग मेजबानों की पुन: सक्रियता परिवर्तन और WWAN और WiFi नेटवर्क इंटरफेस दोनों के लिए पते सुनता है। > एक नेटवर्क संचालन विफल क्यों हुआ, या कनेक्शन स्थापित होने पर नेटवर्क अनुरोधों को पुनः प्राप्त करने के बारे में पृष्ठभूमि की जानकारी का निर्धारण करने के लिए पुनर्संयोजन का उपयोग किया जा सकता है। इसका उपयोग किसी उपयोगकर्ता को नेटवर्क अनुरोध शुरू करने से रोकने के लिए नहीं किया जाना चाहिए, क्योंकि यह संभव है कि पुनःचुन्यता स्थापित करने के लिए प्रारंभिक अनुरोध की आवश्यकता हो।
fespinozacast

1
@fespinozacast अच्छी तरह से आप में इंटरनेट कनेक्शन कोड की जांच कर सकते NetworkReachabilityManager.swift है, जो पूरी तरह से ठीक है :)
जैक

15

मैंने कोको पॉड्स / डिपेंडेंसी मैनेजर के बिना एशले मिल के रीचबिलिटी क्लास को लागू करने की जाँच की है। परियोजना में रीचैबिलिटी निर्भरता मुक्त बनाने के लिए विचार है।

Xcode 7.2 - स्विफ्ट 2.1

1) https://github.com/ashleymills/Reachability.swift । प्रोजेक्ट में रीचैबिलिटी क्लास जोड़ें।

ध्यान दें: जोड़ते समय, कृपया सुनिश्चित करें कि 'यदि आवश्यक हो तो कॉपी आइटम' टिक किया हुआ है।

2) एक AppManager.swift वर्ग बनाएं। यह वर्ग सार्वजनिक मॉडल वर्ग के रूप में पूरा करेगा जहां सार्वजनिक तरीके और डेटा जोड़े जाएंगे और किसी भी कुलपति में इसका उपयोग किया जा सकता है।

//  AppManager.swift

import UIKit
import Foundation

class AppManager: NSObject{
    var delegate:AppManagerDelegate? = nil
    private var _useClosures:Bool = false
    private var reachability: Reachability?
    private var _isReachability:Bool = false
    private var _reachabiltyNetworkType :String?

    var isReachability:Bool {
        get {return _isReachability}
    }  
   var reachabiltyNetworkType:String {
    get {return _reachabiltyNetworkType! }
   }   




    // Create a shared instance of AppManager
    final  class var sharedInstance : AppManager {
        struct Static {
            static var instance : AppManager?
        }
        if !(Static.instance != nil) {
            Static.instance = AppManager()

        }
        return Static.instance!
    }

    // Reachability Methods
    func initRechabilityMonitor() {
        print("initialize rechability...")
        do {
            let reachability = try Reachability.reachabilityForInternetConnection()
            self.reachability = reachability
        } catch ReachabilityError.FailedToCreateWithAddress(let address) {
            print("Unable to create\nReachability with address:\n\(address)")
            return
        } catch {}
        if (_useClosures) {
            reachability?.whenReachable = { reachability in
                self.notifyReachability(reachability)
            }
            reachability?.whenUnreachable = { reachability in
                self.notifyReachability(reachability)
            }
        } else {
            self.notifyReachability(reachability!)
        }

        do {
            try reachability?.startNotifier()
        } catch {
            print("unable to start notifier")
            return
        }


    }        
    private func notifyReachability(reachability:Reachability) {
        if reachability.isReachable() {
            self._isReachability = true

//Determine Network Type 
      if reachability.isReachableViaWiFi() {   
        self._reachabiltyNetworkType = CONNECTION_NETWORK_TYPE.WIFI_NETWORK.rawValue
      } else {
        self._reachabiltyNetworkType = CONNECTION_NETWORK_TYPE.WWAN_NETWORK.rawValue
      }

        } else {
            self._isReachability = false
self._reachabiltyNetworkType = CONNECTION_NETWORK_TYPE.OTHER.rawValue

        }

        NSNotificationCenter.defaultCenter().addObserver(self, selector: "reachabilityChanged:", name: ReachabilityChangedNotification, object: reachability)
    }
    func reachabilityChanged(note: NSNotification) {
        let reachability = note.object as! Reachability
        dispatch_async(dispatch_get_main_queue()) {
            if (self._useClosures) {
                self.reachability?.whenReachable = { reachability in
                    self.notifyReachability(reachability)
                }
                self.reachability?.whenUnreachable = { reachability in
                    self.notifyReachability(reachability)
                }
            } else {
                self.notifyReachability(reachability)
            }
            self.delegate?.reachabilityStatusChangeHandler(reachability)
        }
    }
    deinit {
        reachability?.stopNotifier()
        if (!_useClosures) {
            NSNotificationCenter.defaultCenter().removeObserver(self, name: ReachabilityChangedNotification, object: nil)
        }
    }
}

3) एक प्रतिनिधि कक्षा बनाओ। कनेक्टिविटी स्थिति को सूचित करने के लिए मैं प्रतिनिधि पद्धति का उपयोग करता हूं।

//  Protocols.swift

import Foundation
@objc protocol AppManagerDelegate:NSObjectProtocol {

    func reachabilityStatusChangeHandler(reachability:Reachability)
}

4) UIViewController (वंशानुक्रम विधि) का मूल वर्ग बनाएं। अभिभावक वर्ग के पास ऐसी विधियाँ हैं जो सभी बच्चे कुलपतियों तक पहुँचती हैं।

//  UIappViewController.swift

    import UIKit

    class UIappViewController: UIViewController,AppManagerDelegate {
        var manager:AppManager = AppManager.sharedInstance

        override func viewDidLoad() {
            super.viewDidLoad()
            manager.delegate = self
        }
        override func didReceiveMemoryWarning() {
            super.didReceiveMemoryWarning()
        }
        func reachabilityStatusChangeHandler(reachability: Reachability) {
            if reachability.isReachable() {
                print("isReachable")
            } else {
                print("notReachable")
            }
        }
    }

5) AppDelegate में रियल टाइम इंटरनेट कनेक्टिविटी मॉनिटरिंग शुरू करें।

func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {
    AppManager.sharedInstance.initRechabilityMonitor()
return true
}

6) मैंने निरंतर एनम मानों को संग्रहीत करने के लिए एक स्विफ्ट फ़ाइल नाम AppReference जोड़ा है।

//  AppReference.swift

import Foundation

enum CONNECTION_NETWORK_TYPE : String {

  case WIFI_NETWORK = "Wifi"
  case WWAN_NETWORK = "Cellular"
  case OTHER = "Other"

}

7) ViewController पर (पूर्व। आप केवल एक एपीआई कॉल करना चाहते हैं यदि नेटवर्क उपलब्ध है)

//  ViewController.swift

        import UIKit

class ViewController: UIappViewController {
  var reachability:Reachability?

  override func viewDidLoad() {
    super.viewDidLoad()
    manager.delegate = self

    if(AppManager.sharedInstance.isReachability)
    {
      print("net available")
      //call API from here.

    } else {
      dispatch_async(dispatch_get_main_queue()) {
        print("net not available")
        //Show Alert
      }
    }


    //Determine Network Type
    if(AppManager.sharedInstance.reachabiltyNetworkType == "Wifi")
    {
      print(".Wifi")
    }
    else if (AppManager.sharedInstance.reachabiltyNetworkType == "Cellular")
    {
      print(".Cellular")
    }
    else {
      dispatch_async(dispatch_get_main_queue()) {
        print("Network not reachable")
      }
    }

  }
  override func viewWillAppear(animated: Bool) {
  }
  override func didReceiveMemoryWarning() {
  }
}

नमूना @ https://github.com/alvinreuben/Reachability-Sample पर डाउनलोड किया जा सकता है

स्विफ्ट में अपग्रेड 3.1- https://github.com/alvinvgeorge/Reachability-UpgradedToSwift3


चरण 4 में ... UIappViewController.swift, हमें इस वर्ग की आवश्यकता क्यों है !?
23:00 पर Learn2Code

UIappViewController.swift UICollectionViewController के साथ काम नहीं करता है, इसलिए यदि आपके पास एक ऐसा दृश्य है जो UICollectionViewController का है, तो आप UIappViewController का वारिस नहीं कर सकते !?
23:00 पर Learn2Code

12

Apple ने iOS12 में नेटवर्क फ्रेमवर्क पेश किया है।

import Foundation
import Network

class NetworkReachability {

   var pathMonitor: NWPathMonitor!
   var path: NWPath?
   lazy var pathUpdateHandler: ((NWPath) -> Void) = { path in
    self.path = path
    if path.status == NWPath.Status.satisfied {
        print("Connected")
    } else if path.status == NWPath.Status.unsatisfied {
        print("unsatisfied")
    } else if path.status == NWPath.Status.requiresConnection {
        print("requiresConnection")
    } 
}

let backgroudQueue = DispatchQueue.global(qos: .background)

init() {
    pathMonitor = NWPathMonitor()
    pathMonitor.pathUpdateHandler = self.pathUpdateHandler
    pathMonitor.start(queue: backgroudQueue)
   } 

 func isNetworkAvailable() -> Bool {
        if let path = self.path {
           if path.status == NWPath.Status.satisfied {
            return true
          }
        }
       return false
   }
 }

var पथ: NWPath nil है। हम इस संपत्ति को कैसे शुरू करते हैं?
वाइटा शापापोव

@VityaShurapov आपको pathUpdateHandler ब्लॉक में मिल रहा है।
योगेंद्र सिंह

यह फैंसी लग रहा है, लेकिन मुझे पता चला (कम से कम सिम्युलेटर पर) कि अगर मैं अपने लैपटॉप वाईफाई को बंद कर देता हूं, तो मुझे कॉलबैक मिलता है, लेकिन यह 'असंतुष्ट' कहता है, और उसके बाद कॉलबैक को कभी भी लागू नहीं किया जाता है।
zaitsman

जब सेलुलर चक्र चालू / बंद होता है, तो हैंडलर केवल एक बार चालू / बंद होता है। जब WiFi चालू / बंद होता है, तो मुझे चालू / बंद के लिए 2 समान ट्रिगर मिलते हैं (सभी गुण समान हैं)। ऐसा क्यों है?
जियोही

pathUpdateHandlerके साथ एक मजबूत संदर्भ पेश करेंगे self, [weak self]इसे हल करने के लिए जोड़ें :)
एंड्रिया डी मार्को

11

इसका प्रयोग Swift-5 + के लिए करें

import Foundation
import UIKit
import SystemConfiguration

public class InternetConnectionManager {


    private init() {

    }

    public static func isConnectedToNetwork() -> Bool {

        var zeroAddress = sockaddr_in()
        zeroAddress.sin_len = UInt8(MemoryLayout.size(ofValue: zeroAddress))
        zeroAddress.sin_family = sa_family_t(AF_INET)
        guard let defaultRouteReachability = withUnsafePointer(to: &zeroAddress, {

            $0.withMemoryRebound(to: sockaddr.self, capacity: 1) {

                SCNetworkReachabilityCreateWithAddress(nil, $0)

            }

        }) else {

            return false
        }
        var flags = SCNetworkReachabilityFlags()
        if !SCNetworkReachabilityGetFlags(defaultRouteReachability, &flags) {
            return false
        }
        let isReachable = (flags.rawValue & UInt32(kSCNetworkFlagsReachable)) != 0
        let needsConnection = (flags.rawValue & UInt32(kSCNetworkFlagsConnectionRequired)) != 0
        return (isReachable && !needsConnection)
    }

}

उपयोग:

InternetConnectionManager.isConnectedToNetwork{
    print("Connected")
}else{
    print("Not Connected")
}

या बस इसे frameworkऔर अधिक के लिए उपयोग करेंUtilities : लिंक


@ DocAsh59 :) आपका स्वागत है! हैप्पी कोडिंग!
जमील हसनैन तमीम

मुझे इसके उपयोग की समझ नहीं है। संकलक एक त्रुटि दिखाता है "तर्क जो कॉल करने के लिए पारित हुआ वह कोई तर्क नहीं लेता है"।
रोलैंड लारोटे

1
@RolandLariotte आप अपने प्रोजेक्ट में सिर्फ क्लास लगाते हैं जिसका नाम है - "InternetConnectionManager", और फिर जहाँ से आप चाहें कॉल करें!
जमील हसनैन तमीम

अच्छी तरह से काम। क्या आपको लगता है कि Combine का उपयोग करके और AnyPublisher <Bool, Never> को वापस करके यह कोड अधिक प्रतिक्रियाशील हो सकता है? क्या आप इसे इस तरह से लिख सकते हैं?
रोलैंड लारोटे

@ रोलैंडलियोटे हाँ हो सकता है। बाद में एक और कोड लिखूंगा। धन्यवाद और समर्थन करने के लिए मत भूलना! :)
जमील हसनैन तमीम

7

बस यह पता लगा लिया अपने लिए।

Xcode: 7.3.1, iOS 9.3.3

अपने प्रोजेक्ट में Realebility.swift के रूप में ashleymills / Reachability.swift का उपयोग करते हुए , मैंने निम्नलिखित फ़ंक्शन बनाया:

func hasConnectivity() -> Bool {
    do {
        let reachability: Reachability = try Reachability.reachabilityForInternetConnection()
        let networkStatus: Int = reachability.currentReachabilityStatus.hashValue

        return (networkStatus != 0)
    }
    catch {
        // Handle error however you please
        return false
    }
}

बस कॉल करें hasConnectivity()जहां आपको कनेक्शन के लिए जांचने की आवश्यकता है। यह Wifi के साथ-साथ Cellular के लिए भी काम करता है।


Ashleymills के रीचैबिलिटी को जोड़ना। ऐसे लोगों को साइटों के बीच नहीं बढ़ना है:

Copyright (c) 2014, Ashley Mills
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
*/

// Reachability.swift version 2.2beta2

import SystemConfiguration
import Foundation

public enum ReachabilityError: ErrorType {
    case FailedToCreateWithAddress(sockaddr_in)
    case FailedToCreateWithHostname(String)
    case UnableToSetCallback
    case UnableToSetDispatchQueue
}

public let ReachabilityChangedNotification = "ReachabilityChangedNotification"

func callback(reachability:SCNetworkReachability, flags: SCNetworkReachabilityFlags, info: UnsafeMutablePointer<Void>) {
    let reachability = Unmanaged<Reachability>.fromOpaque(COpaquePointer(info)).takeUnretainedValue()

    dispatch_async(dispatch_get_main_queue()) {
        reachability.reachabilityChanged(flags)
    }
}


public class Reachability: NSObject {

    public typealias NetworkReachable = (Reachability) -> ()
    public typealias NetworkUnreachable = (Reachability) -> ()

    public enum NetworkStatus: CustomStringConvertible {

        case NotReachable, ReachableViaWiFi, ReachableViaWWAN

        public var description: String {
            switch self {
            case .ReachableViaWWAN:
                return "Cellular"
            case .ReachableViaWiFi:
                return "WiFi"
            case .NotReachable:
                return "No Connection"
            }
        }
    }

    // MARK: - *** Public properties ***
    public var whenReachable: NetworkReachable?
    public var whenUnreachable: NetworkUnreachable?
    public var reachableOnWWAN: Bool
    public var notificationCenter = NSNotificationCenter.defaultCenter()

    public var currentReachabilityStatus: NetworkStatus {
        if isReachable() {
            if isReachableViaWiFi() {
                return .ReachableViaWiFi
            }
            if isRunningOnDevice {
                return .ReachableViaWWAN
            }
        }
        return .NotReachable
    }

    public var currentReachabilityString: String {
        return "\(currentReachabilityStatus)"
    }

    private var previousFlags: SCNetworkReachabilityFlags?

    // MARK: - *** Initialisation methods ***

    required public init(reachabilityRef: SCNetworkReachability) {
        reachableOnWWAN = true
        self.reachabilityRef = reachabilityRef
    }

    public convenience init(hostname: String) throws {

        let nodename = (hostname as NSString).UTF8String
        guard let ref = SCNetworkReachabilityCreateWithName(nil, nodename) else { throw ReachabilityError.FailedToCreateWithHostname(hostname) }

        self.init(reachabilityRef: ref)
    }

    public class func reachabilityForInternetConnection() throws -> Reachability {

        var zeroAddress = sockaddr_in()
        zeroAddress.sin_len = UInt8(sizeofValue(zeroAddress))
        zeroAddress.sin_family = sa_family_t(AF_INET)

        guard let ref = withUnsafePointer(&zeroAddress, {
            SCNetworkReachabilityCreateWithAddress(nil, UnsafePointer($0))
        }) else { throw ReachabilityError.FailedToCreateWithAddress(zeroAddress) }

        return Reachability(reachabilityRef: ref)
    }

    public class func reachabilityForLocalWiFi() throws -> Reachability {

        var localWifiAddress: sockaddr_in = sockaddr_in(sin_len: __uint8_t(0), sin_family: sa_family_t(0), sin_port: in_port_t(0), sin_addr: in_addr(s_addr: 0), sin_zero: (0, 0, 0, 0, 0, 0, 0, 0))
        localWifiAddress.sin_len = UInt8(sizeofValue(localWifiAddress))
        localWifiAddress.sin_family = sa_family_t(AF_INET)

        // IN_LINKLOCALNETNUM is defined in <netinet/in.h> as 169.254.0.0
        let address: UInt32 = 0xA9FE0000
        localWifiAddress.sin_addr.s_addr = in_addr_t(address.bigEndian)

        guard let ref = withUnsafePointer(&localWifiAddress, {
            SCNetworkReachabilityCreateWithAddress(nil, UnsafePointer($0))
        }) else { throw ReachabilityError.FailedToCreateWithAddress(localWifiAddress) }

        return Reachability(reachabilityRef: ref)
    }

    // MARK: - *** Notifier methods ***
    public func startNotifier() throws {

        guard !notifierRunning else { return }

        var context = SCNetworkReachabilityContext(version: 0, info: nil, retain: nil, release: nil, copyDescription: nil)
        context.info = UnsafeMutablePointer(Unmanaged.passUnretained(self).toOpaque())

        if !SCNetworkReachabilitySetCallback(reachabilityRef!, callback, &context) {
            stopNotifier()
            throw ReachabilityError.UnableToSetCallback
        }

        if !SCNetworkReachabilitySetDispatchQueue(reachabilityRef!, reachabilitySerialQueue) {
            stopNotifier()
            throw ReachabilityError.UnableToSetDispatchQueue
        }

        // Perform an intial check
        dispatch_async(reachabilitySerialQueue) { () -> Void in
            let flags = self.reachabilityFlags
            self.reachabilityChanged(flags)
        }

        notifierRunning = true
    }

    public func stopNotifier() {
        defer { notifierRunning = false }
        guard let reachabilityRef = reachabilityRef else { return }

        SCNetworkReachabilitySetCallback(reachabilityRef, nil, nil)
        SCNetworkReachabilitySetDispatchQueue(reachabilityRef, nil)
    }

    // MARK: - *** Connection test methods ***
    public func isReachable() -> Bool {
        let flags = reachabilityFlags
        return isReachableWithFlags(flags)
    }

    public func isReachableViaWWAN() -> Bool {

        let flags = reachabilityFlags

        // Check we're not on the simulator, we're REACHABLE and check we're on WWAN
        return isRunningOnDevice && isReachable(flags) && isOnWWAN(flags)
    }

    public func isReachableViaWiFi() -> Bool {

        let flags = reachabilityFlags

        // Check we're reachable
        if !isReachable(flags) {
            return false
        }

        // Must be on WiFi if reachable but not on an iOS device (i.e. simulator)
        if !isRunningOnDevice {
            return true
        }

        // Check we're NOT on WWAN
        return !isOnWWAN(flags)
    }

    // MARK: - *** Private methods ***
    private var isRunningOnDevice: Bool = {
        #if (arch(i386) || arch(x86_64)) && os(iOS)
            return false
        #else
            return true
        #endif
    }()

    private var notifierRunning = false
    private var reachabilityRef: SCNetworkReachability?
    private let reachabilitySerialQueue = dispatch_queue_create("uk.co.ashleymills.reachability", DISPATCH_QUEUE_SERIAL)

    private func reachabilityChanged(flags: SCNetworkReachabilityFlags) {

        guard previousFlags != flags else { return }

        if isReachableWithFlags(flags) {
            if let block = whenReachable {
                block(self)
            }
        } else {
            if let block = whenUnreachable {
                block(self)
            }
        }

        notificationCenter.postNotificationName(ReachabilityChangedNotification, object:self)

        previousFlags = flags
    }

    private func isReachableWithFlags(flags: SCNetworkReachabilityFlags) -> Bool {

        if !isReachable(flags) {
            return false
        }

        if isConnectionRequiredOrTransient(flags) {
            return false
        }

        if isRunningOnDevice {
            if isOnWWAN(flags) && !reachableOnWWAN {
                // We don't want to connect when on 3G.
                return false
            }
        }

        return true
    }

    // WWAN may be available, but not active until a connection has been established.
    // WiFi may require a connection for VPN on Demand.
    private func isConnectionRequired() -> Bool {
        return connectionRequired()
    }

    private func connectionRequired() -> Bool {
        let flags = reachabilityFlags
        return isConnectionRequired(flags)
    }

    // Dynamic, on demand connection?
    private func isConnectionOnDemand() -> Bool {
        let flags = reachabilityFlags
        return isConnectionRequired(flags) && isConnectionOnTrafficOrDemand(flags)
    }

    // Is user intervention required?
    private func isInterventionRequired() -> Bool {
        let flags = reachabilityFlags
        return isConnectionRequired(flags) && isInterventionRequired(flags)
    }

    private func isOnWWAN(flags: SCNetworkReachabilityFlags) -> Bool {
        #if os(iOS)
            return flags.contains(.IsWWAN)
        #else
            return false
        #endif
    }
    private func isReachable(flags: SCNetworkReachabilityFlags) -> Bool {
        return flags.contains(.Reachable)
    }
    private func isConnectionRequired(flags: SCNetworkReachabilityFlags) -> Bool {
        return flags.contains(.ConnectionRequired)
    }
    private func isInterventionRequired(flags: SCNetworkReachabilityFlags) -> Bool {
        return flags.contains(.InterventionRequired)
    }
    private func isConnectionOnTraffic(flags: SCNetworkReachabilityFlags) -> Bool {
        return flags.contains(.ConnectionOnTraffic)
    }
    private func isConnectionOnDemand(flags: SCNetworkReachabilityFlags) -> Bool {
        return flags.contains(.ConnectionOnDemand)
    }
    func isConnectionOnTrafficOrDemand(flags: SCNetworkReachabilityFlags) -> Bool {
        return !flags.intersect([.ConnectionOnTraffic, .ConnectionOnDemand]).isEmpty
    }
    private func isTransientConnection(flags: SCNetworkReachabilityFlags) -> Bool {
        return flags.contains(.TransientConnection)
    }
    private func isLocalAddress(flags: SCNetworkReachabilityFlags) -> Bool {
        return flags.contains(.IsLocalAddress)
    }
    private func isDirect(flags: SCNetworkReachabilityFlags) -> Bool {
        return flags.contains(.IsDirect)
    }
    private func isConnectionRequiredOrTransient(flags: SCNetworkReachabilityFlags) -> Bool {
        let testcase:SCNetworkReachabilityFlags = [.ConnectionRequired, .TransientConnection]
        return flags.intersect(testcase) == testcase
    }

    private var reachabilityFlags: SCNetworkReachabilityFlags {

        guard let reachabilityRef = reachabilityRef else { return SCNetworkReachabilityFlags() }

        var flags = SCNetworkReachabilityFlags()
        let gotFlags = withUnsafeMutablePointer(&flags) {
            SCNetworkReachabilityGetFlags(reachabilityRef, UnsafeMutablePointer($0))
        }

        if gotFlags {
            return flags
        } else {
            return SCNetworkReachabilityFlags()
        }
    }

    override public var description: String {

        var W: String
        if isRunningOnDevice {
            W = isOnWWAN(reachabilityFlags) ? "W" : "-"
        } else {
            W = "X"
        }
        let R = isReachable(reachabilityFlags) ? "R" : "-"
        let c = isConnectionRequired(reachabilityFlags) ? "c" : "-"
        let t = isTransientConnection(reachabilityFlags) ? "t" : "-"
        let i = isInterventionRequired(reachabilityFlags) ? "i" : "-"
        let C = isConnectionOnTraffic(reachabilityFlags) ? "C" : "-"
        let D = isConnectionOnDemand(reachabilityFlags) ? "D" : "-"
        let l = isLocalAddress(reachabilityFlags) ? "l" : "-"
        let d = isDirect(reachabilityFlags) ? "d" : "-"

        return "\(W)\(R) \(c)\(t)\(i)\(C)\(D)\(l)\(d)"
    }

    deinit {
        stopNotifier()

        reachabilityRef = nil
        whenReachable = nil
        whenUnreachable = nil
    }
}

@ Xitcod13 यह 4 जी नेटवर्क के साथ काम करेगा। कहा जा रहा है कि यह अनुशंसित नहीं है कि प्रीफ्लाइट का परीक्षण करें। एक Reachability.swift परीक्षण मामले का उपयोग करने के बजाय कनेक्ट करने के अपने प्रयास में फेंके गए अपवाद को हैंडल करें।
15

स्विफ्ट 3 के लिए github.com/justin/Reachability.swift/tree/feature/swift3.0
AMAN77


स्विफ्ट 3 के साथ अच्छी तरह से काम करता है, बस बदल let reachability: Reachability = try Reachability.reachabilityForInternetConnection()जाता हैlet reachability: Reachability = try Reachability()!
davidethell

7

हालाँकि यह सीधे आपके प्रश्न का उत्तर नहीं देता है, मैं हाल ही में Apple से इस बात का उल्लेख करना चाहूंगा:

https://developer.apple.com/videos/play/wwdc2018/714/

लगभग 09:55 पर वह इस सामान के बारे में बात करता है जिसके बारे में आप पूछ रहे हैं:

  1. कनेक्शन की जाँच करें
  2. यदि कनेक्शन -> कुछ करो
  3. यदि कोई संबंध नहीं है -> कुछ और करें (प्रतीक्षा करें? पुन: प्रयास करें?)

हालाँकि, इसके कुछ नुकसान हैं:

  • क्या होगा अगर चरण 2 में यह कहता है कि इसका कनेक्शन है, लेकिन 0.5 सेकंड बाद वह नहीं आया है?
  • क्या होगा यदि उपयोगकर्ता प्रॉक्सी के पीछे है
  • अंतिम लेकिन कम से कम, क्या होगा अगर यहां कुछ उत्तर कनेक्टिविटी को सही नहीं निर्धारित कर सकते हैं? (मुझे यकीन है कि यदि आप तेजी से अपने कनेक्शन को स्विच करते हैं, तो वाई-फाई पर जाएं और इसे बंद करें (बस इसे जटिल बनाएं), यह लगभग कभी भी सही ढंग से निर्धारित नहीं कर सकता है कि मुझे एक कनेक्शन मिला या नहीं)।
  • वीडियो से उद्धरण: "ग्वारेंटी का कोई तरीका नहीं है कि भविष्य में ऑपरेशन सफल होगा या नहीं"

Apple के अनुसार निम्नलिखित बिंदु कुछ सर्वोत्तम अभ्यास हैं:

बात के अनुसार, आपके पास इंटरनेट कनेक्शन प्राप्त करने या न होने के कारण पूर्व-जांच करने का कोई कारण नहीं होना चाहिए, क्योंकि यह उस समय सटीक नहीं हो सकता है जब आप सर्वर पर अपना अनुरोध भेजते हैं


2

मैंने NSTimer और Alamofire का उपयोग करके अपना खुद का हल बनाया है:

import Alamofire

public class ConnectionHelper: NSObject {
    var request: Alamofire.Request?

    func isInternetConnected(completionHandler: Bool -> Void) {
        NSTimer.scheduledTimerWithTimeInterval(5.0, target: self, selector: "requestTimeout", userInfo: nil, repeats: false)

        request = Alamofire
            .request(
                Method.HEAD,
                "http://www.testurl.com"
            )
            .response { response in
                if response.3?.code == -999 {
                    completionHandler(
                        false
                    )
                } else {
                    completionHandler(
                        true
                    )
                }
        }
    }

    func requestTimeout() {
        request!.cancel()
    }
}

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

जब टाइमर समाप्त हो जाता है, तो अनुरोध रद्द कर दिया जाता है और परिणाम एक पूर्ण हैंडलर का उपयोग करके वापस किए जाते हैं।

उपयोग:

ConnectionHelper().isInternetConnected() { internetConnected in
    if internetConnected {
        // Connected
    } else {
        // Not connected
    }
}

1
क्या होगा अगर वेबसाइट सर्वर डाउन है?
TechBee

फिर requestTimeout()निर्दिष्ट समय समाप्त होने के बाद बुलाया जाएगा
मार्क टिकर

धन्यवाद मार्क! आपका दृष्टिकोण सामान्य होना चाहिए !!
TechBee

1
किस तरह से? जिस साइट का उपयोग किया जाता है? विचार यह होगा कि जिस साइट का उपयोग किया गया है वह वह है, जिस पर आपका ऐप निर्भर है
मार्क टिकर

संभवतः नेटवर्क कनेक्शन बनाने के लिए एक अच्छा विचार नहीं है और देखें कि यह प्रतिक्रिया के साथ वापस आता है या नहीं। अगर सवाल
GoodSp33d

2

यदि आप अल्मोफायर का उपयोग कर रहे हैं, तो आप कुछ इस तरह कर सकते हैं:

let configuration = NSURLSessionConfiguration.defaultSessionConfiguration()
configuration.timeoutIntervalForRequest = 15 //Set timeouts in sec
configuration.timeoutIntervalForResource = 15

let alamoFireManager = Alamofire.Manager(configuration:configuration)
alamoFireManager?.request(.GET, "https://yourURL.com", parameters: headers, encoding: .URL)
                     .validate()
                              .responseJSON { response in

                                if let error = response.result.error {
                                   switch error.code{
                                    case -1001:
                                        print("Slow connection")
                                        return
                                    case -1009:
                                        print("No Connection!")
                                        return
                                    default: break
                                    }
                                }

2

स्विफ्ट 5

import SystemConfiguration    

protocol Utilities {}
extension NSObject: Utilities {
    enum ReachabilityStatus {
        case notReachable
        case reachableViaWWAN
        case reachableViaWiFi
    }

    var currentReachabilityStatus: ReachabilityStatus {

        var zeroAddress = sockaddr_in()
        zeroAddress.sin_len = UInt8(MemoryLayout<sockaddr_in>.size)
        zeroAddress.sin_family = sa_family_t(AF_INET)
        guard let defaultRouteReachability = withUnsafePointer(to: &zeroAddress, {
            $0.withMemoryRebound(to: sockaddr.self, capacity: 1) {
                SCNetworkReachabilityCreateWithAddress(nil, $0)
            }
        }) else {
            return .notReachable
        }

        var flags: SCNetworkReachabilityFlags = []
        if !SCNetworkReachabilityGetFlags(defaultRouteReachability, &flags) {
            return .notReachable
        }

        if flags.contains(.reachable) == false {
            // The target host is not reachable.
            return .notReachable
        }
        else if flags.contains(.isWWAN) == true {
            // WWAN connections are OK if the calling application is using the CFNetwork APIs.
            return .reachableViaWWAN
        }
        else if flags.contains(.connectionRequired) == false {
            // If the target host is reachable and no connection is required then we'll assume that you're on Wi-Fi...
            return .reachableViaWiFi
        }
        else if (flags.contains(.connectionOnDemand) == true || flags.contains(.connectionOnTraffic) == true) && flags.contains(.interventionRequired) == false {
            // The connection is on-demand (or on-traffic) if the calling application is using the CFSocketStream or higher APIs and no [user] intervention is needed
            return .reachableViaWiFi
        }
        else {
            return .notReachable
        }
    }
}

किसी भी विधि में नीचे की स्थिति का उपयोग करें

if currentReachabilityStatus == .notReachable {
    // Network Unavailable
 } else {
    // Network Available
 }

1

यहाँ मेरी 2.3 समाधान के साथ तेजी से काम ( Reachability.swift )

अपने में जाओ Podfileऔर जोड़ें:

pod 'ReachabilitySwift', '~> 2.4' // swift 2.3

फिर अपने में terminal:

pod install

फिर एक नई फ़ाइल बनाएं ReachabilityManagerऔर नीचे कोड जोड़ें:

import Foundation
import ReachabilitySwift

enum ReachabilityManagerType {
    case Wifi
    case Cellular
    case None
}

class ReachabilityManager {
    static let sharedInstance = ReachabilityManager()

    private var reachability: Reachability!
    private var reachabilityManagerType: ReachabilityManagerType = .None


    private init() {
        do {
            self.reachability = try Reachability.reachabilityForInternetConnection()
        } catch {
            print("Unable to create Reachability")
            return
        }

        NSNotificationCenter.defaultCenter().addObserver(self, selector: #selector(ReachabilityManager.reachabilityChanged(_:)),name: ReachabilityChangedNotification,object: self.reachability)
        do{
            try self.reachability.startNotifier()
        }catch{
            print("could not start reachability notifier")
        }
    }

    @objc private func reachabilityChanged(note: NSNotification) {

        let reachability = note.object as! Reachability

        if reachability.isReachable() {
            if reachability.isReachableViaWiFi() {
                self.reachabilityManagerType = .Wifi
            } else {
                self.reachabilityManagerType = .Cellular
            }
        } else {
            self.reachabilityManagerType = .None
        }
    }
}

extension ReachabilityManager {

    func isConnectedToNetwork() -> Bool {
        return reachabilityManagerType != .None
    }

}

इसका उपयोग कैसे करें:

अपने में जाओ AppDelegate.swiftऔर नीचे कोड जोड़ें:

func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {
     ReachabilityManager.sharedInstance
}

तब जब आप यह जांचना चाहें कि उपकरण इंटरनेट से जुड़ा है या नहीं:

if ReachabilityManager.sharedInstance.isConnectedToNetwork() {
   // Connected
} else {
  // Not connected
}

1

हालांकि यह सीधे यह निर्धारित नहीं कर सकता है कि फोन नेटवर्क से जुड़ा है या नहीं, सबसे सरल (, सबसे साफ?) समाधान Google, या किसी अन्य सर्वर को 'पिंग' करना होगा, (जो तब तक संभव नहीं है जब तक फोन नेटवर्क से कनेक्ट न हो। ):

private var urlSession:URLSession = {
    var newConfiguration:URLSessionConfiguration = .default
    newConfiguration.waitsForConnectivity = false
    newConfiguration.allowsCellularAccess = true
    return URLSession(configuration: newConfiguration)
}()

public func canReachGoogle() -> Bool
{
    let url = URL(string: "https://8.8.8.8")
    let semaphore = DispatchSemaphore(value: 0)
    var success = false
    let task = urlSession.dataTask(with: url!)
    { data, response, error in
        if error != nil
        {
            success = false
        }
        else
        {
            success = true
        }
        semaphore.signal()
    }

    task.resume()
    semaphore.wait()

    return success
}

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


0

नीचे दिए गए कोड की मदद से आप दोनों सेलुलर नेटवर्क के साथ-साथ वाईफाई के लिए इंटरनेट कनेक्शन की जांच कर सकते हैं। भाषा - स्विफ्ट 3.0

import UIKit
import Foundation
import SystemConfiguration

class NetworkConnection: UIViewController {

  class func isConnectedToNetwork() -> Bool {
    var zeroAddress = sockaddr_in(sin_len: 0, sin_family: 0, sin_port: 0, sin_addr: in_addr(s_addr: 0), sin_zero: (0, 0, 0, 0, 0, 0, 0, 0))
    zeroAddress.sin_len = UInt8(MemoryLayout.size(ofValue: zeroAddress))
    zeroAddress.sin_family = sa_family_t(AF_INET)

    guard let defaultRouteReachability = withUnsafePointer(to: &zeroAddress, {
      $0.withMemoryRebound(to: sockaddr.self, capacity: 1) {
        SCNetworkReachabilityCreateWithAddress(nil, $0)
      }
    }) else {
      return false
    }

    var flags: SCNetworkReachabilityFlags = SCNetworkReachabilityFlags(rawValue: 0)
    if SCNetworkReachabilityGetFlags(defaultRouteReachability, &flags) == false {
      return false
    }
    let isReachable = (flags.rawValue & UInt32(kSCNetworkFlagsReachable)) != 0
    let needsConnection = (flags.rawValue & UInt32(kSCNetworkFlagsConnectionRequired)) != 0
    return (isReachable && !needsConnection)
  }

  class func checkConnection(sender:UIViewController){
    if NetworkConnection.isConnectedToNetwork() == true {
      print("Connected to the internet")
      //  Do something
    } else {
      print("No internet connection")
      let alertController = UIAlertController(title: "No Internet Available", message: "", preferredStyle: UIAlertControllerStyle.alert)
      let okAction = UIAlertAction(title: "Ok", style: UIAlertActionStyle.default){(result:UIAlertAction) -> Void in
        return
      }
      alertController.addAction(okAction)
      sender.present(alertController, animated: true, completion: nil)
      //  Do something
    }
  }

}

0

स्विफ्ट 3 के लिए, मैं RAJAMOHAN-S समाधानों से सिर्फ पुनःचैतन्यता का उपयोग नहीं कर सकता क्योंकि यह वाईफाई है लेकिन कोई इंटरनेट नहीं है तो यह "सही" है। इस प्रकार, मैंने URLSession वर्ग और पूर्ण हैंडलर के माध्यम से दूसरी मान्यता लागू की।

यहाँ पूरी क्लास है।

import Foundation
import SystemConfiguration

public class Reachability {

class func isConnectedToNetwork() -> Bool {

var zeroAddress = sockaddr_in(sin_len: 0, sin_family: 0, sin_port: 0, sin_addr: in_addr(s_addr: 0), sin_zero: (0, 0, 0, 0, 0, 0, 0, 0))
zeroAddress.sin_len = UInt8(MemoryLayout.size(ofValue: zeroAddress))
zeroAddress.sin_family = sa_family_t(AF_INET)

let defaultRouteReachability = withUnsafePointer(to: &zeroAddress) {
  $0.withMemoryRebound(to: sockaddr.self, capacity: 1) {zeroSockAddress in
    SCNetworkReachabilityCreateWithAddress(nil, zeroSockAddress)
  }
}

var flags: SCNetworkReachabilityFlags = SCNetworkReachabilityFlags(rawValue: 0)
if SCNetworkReachabilityGetFlags(defaultRouteReachability!, &flags) == false {
  return false
}

// Working for Cellular and WIFI
let isReachable = (flags.rawValue & UInt32(kSCNetworkFlagsReachable)) != 0
let needsConnection = (flags.rawValue & UInt32(kSCNetworkFlagsConnectionRequired)) != 0
let ret = (isReachable && !needsConnection)

return ret
}



class func isInternetAvailable(webSiteToPing: String?, completionHandler: @escaping (Bool) -> Void) {

// 1. Check the WiFi Connection
guard isConnectedToNetwork() else {
  completionHandler(false)
  return
}

// 2. Check the Internet Connection
var webAddress = "https://www.google.com" // Default Web Site
if let _ = webSiteToPing {
  webAddress = webSiteToPing!
}

guard let url = URL(string: webAddress) else {
  completionHandler(false)
  print("could not create url from: \(webAddress)")
  return
}

let urlRequest = URLRequest(url: url)
let session = URLSession.shared
let task = session.dataTask(with: urlRequest, completionHandler: { (data, response, error) in
  if error != nil || response == nil {
    completionHandler(false)
  } else {
    completionHandler(true)
  }
})

  task.resume()
}
}

और आप इसे इस तरह कहते हैं, उदाहरण के लिए:

Reachability.isInternetAvailable(webSiteToPing: nil) { (isInternetAvailable) in
  guard isInternetAvailable else {
    // Inform user for example
    return
  }

  // Do some action if there is Internet
}

0

यह मेरा संस्करण है। अनिवार्य रूप से यह कुछ भी नया नहीं लाता है। मैंने इसे यूडेविस के लिए बाध्य किया।

import UIKit
import SystemConfiguration

extension UIDevice {

    open class var isConnectedToNetwork: Bool {
        get {
            var zeroAddress = sockaddr_in()
            zeroAddress.sin_len = UInt8(MemoryLayout.size(ofValue: zeroAddress))
            zeroAddress.sin_family = sa_family_t(AF_INET)

            guard
                let defaultRouteReachability: SCNetworkReachability = withUnsafePointer(to: &zeroAddress, {
                    $0.withMemoryRebound(to: sockaddr.self, capacity: 1) {
                        SCNetworkReachabilityCreateWithAddress(nil, $0)
                    }
                }),
                var flags: SCNetworkReachabilityFlags = SCNetworkReachabilityFlags() as SCNetworkReachabilityFlags?,
                SCNetworkReachabilityGetFlags(defaultRouteReachability, &flags)
                else { return false }

            return flags.contains(.reachable) && !flags.contains(.connectionRequired)
        }
    }

}

print("Network status availability: " + ( UIDevice.isConnectedToNetwork ? "true" : "false" ))

0
struct Connectivity {
        static let sharedInstance = NetworkReachabilityManager()!
        static var isConnectedToInternet:Bool {
            return self.sharedInstance.isReachable
        }
    }

अब इसे बुलाओ

if Connectivity.isConnectedToInternet{
            call_your_methods_here()
        }else{
            show_alert_for_noInternet()
        }
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.