[ad_1]
Nearly each cell app wants to hook up with the Web in some unspecified time in the future to retrieve knowledge from a number or service or add new knowledge to it. Nevertheless, the Web connection shouldn’t be all the time out there, and its availability can change at any time. To know the state of the system’s present community and if a number or service is reachable by way of that community, we will use the SCNetworkReachability API.
This API is a part of Core Basis, so it written in C. If you’re utilizing Swift this API shouldn’t be actually simple to make use of for many individuals. Apple gives some pattern code containing a category known as Reachability, which is an Goal-C wrapper across the SCNetworkReachability API. This class encapsulates easy methods to entry the community, together with some comfort strategies for asking if we’re related or to not the Web. It additionally permits to register your objects to NSNotificationCenter to be notified by way of a NSNotification object when the community standing modifications. Yow will discover this wrapper class in a pattern code challenge out there at:
https://developer.apple.com/library/ios/samplecode/Reachability/Introduction/Intro.html
If you’re already accustomed to the Reachability class, you must solely replace your code with the newest model (4.2 from November eleventh, 2015) that fixes a few bugs that would doubtlessly leak some reminiscence.
The pattern code supplied by Apple is written in Goal-C, and since we get numerous petitions from builders requesting the Swift model, we’re going to tackle that on this put up. We’ll write our personal Reachability class in Swift 3.0 and clarify the way it works, step-by-step.
The SCNetworkReachability API
The SCNetworkReachability API gives a synchronous methodology to find out the reachability. The synchronous methodology permits us to request the present standing of the reachability by calling the SCNetworkReachabilityGetFlags perform. The second parameter of this perform is a pointer to reminiscence that will likely be full of flags that describe the reachability standing and can present additional data corresponding to whether or not a connection is required and whether or not some consumer intervention may be required when establishing a connection.
Along with the synchronous methodology, the SCNetworkReachability API gives an asynchronous methodology. To implement this method we have to schedule the SCNetworkReachability object in a run loop. Offering a callback perform we will then put up a notification at any time when the reachability of the distant host modifications.
Let’s do it in Swift
Launch Xcode 8 and create a brand new Swift Single View Utility challenge. Identify it ReachabilityExample. Let’s instantly add a brand new swift file to our challenge. Identify it Reachability.swift. Let’s add to this file the next import assertion:
|
|
import SystemConfiguration
|
We wish to inform our App when the community standing modifications in three potential situations.
- when the app shouldn’t be related,
- when the app is related through Wifi,
- when the app is related through WWAN.
We’ll achieve this by sending a notification containing the standing of the connection. So, let’s outline the notification identify and the three potential states:
|
|
let ReachabilityDidChangeNotificationName = “ReachabilityDidChangeNotification”
enum ReachabilityStatus { case notReachable case reachableViaWiFi case reachableViaWWAN }
|
Let’s now implement the Reachability class.
|
|
class Reachability: NSObject {
}
|
Let’s add to this class a property to retailer the SCNetworkReachability object:
|
|
non-public var networkReachability: SCNetworkReachability?
|
For circumstances the place we wish to monitor the reachability of the goal host, we create an initializer that takes the node identify of the specified host as parameter, and creates a SCNetworkReachability object with the SCNetworkReachabilityCreateWithName perform. This perform can return nil, if it isn’t capable of create a legitimate SCNetworkReachability object. So, our initializer will likely be a failable initializer:
|
|
init?(hostName: String) { networkReachability = SCNetworkReachabilityCreateWithName(kCFAllocatorDefault, (hostName as NSString).UTF8String) tremendous.init() if networkReachability == nil { return nil } }
|
We have to create a further initializer for circumstances the place we wish to create a reachability reference to the community tackle. On this case we are going to use the SCNetworkReachabilityCreateWithAddress perform. As this perform expects a pointer to a community tackle, we are going to name it inside a withUnsafePointer perform. Additionally on this case, we have to make the init failable, as there may be additionally the potential of returning a nil worth as defined earlier than:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
|
init?(hostAddress: sockaddr_in) { var tackle = hostAddress
guard let defaultRouteReachability = withUnsafePointer(to: &tackle, { $0.withMemoryRebound(to: sockaddr.self, capability: 1) { SCNetworkReachabilityCreateWithAddress(kCFAllocatorDefault, $0) } }) else { return nil }
networkReachability = defaultRouteReachability
tremendous.init() if networkReachability == nil { return nil } }
|
For comfort, we create a few class strategies. The primary methodology creates a reachability occasion to regulate if we’re related to web. The second methodology permits to examine if we’re related to an area WiFi. Each strategies use the initializers that we now have simply created with a community tackle. In case of the native WiFi, the tackle will level to 169.254.0.0 as outlined in for IN_LINKLOCALNETNUM.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
|
static func networkReachabilityForInternetConnection() -> Reachability? { var zeroAddress = sockaddr_in() zeroAddress.sin_len = UInt8(MemoryLayout.measurement(ofValue: zeroAddress)) zeroAddress.sin_family = sa_family_t(AF_INET) return Reachability(hostAddress: zeroAddress) }
static func networkReachabilityForLocalWiFi() -> Reachability? { var localWifiAddress = sockaddr_in() localWifiAddress.sin_len = UInt8(MemoryLayout.measurement(ofValue: localWifiAddress)) localWifiAddress.sin_family = sa_family_t(AF_INET) // IN_LINKLOCALNETNUM is outlined in <netinet/in.h> as 169.254.0.0 (0xA9FE0000). localWifiAddress.sin_addr.s_addr = 0xA9FE0000
return Reachability(hostAddress: localWifiAddress) }
|
Now we want a few strategies to begin and cease notifying and a property to avoid wasting a state if we’re notifying modifications or not:
|
|
non-public var notifying: Bool = false
|
To start out notifying, we first examine that we aren’t already doing so. Then, we get a SCNetworkReachabilityContext and we assign self to its information parameter. After that we set the callback perform, passing additionally the context (when the callback perform is named, the information parameter that incorporates a reference to self will likely be handed as pointer to a knowledge block as third parameter). If setting the callback perform is profitable, we will then schedule the community reachability reference in a run loop.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
|
func startNotifier() -> Bool {
guard notifying == false else { return false }
var context = SCNetworkReachabilityContext() context.information = UnsafeMutableRawPointer(Unmanaged.passUnretained(self).toOpaque())
guard let reachability = networkReachability, SCNetworkReachabilitySetCallback(reachability, { (goal: SCNetworkReachability, flags: SCNetworkReachabilityFlags, information: UnsafeMutableRawPointer?) in if let currentInfo = information { let infoObject = Unmanaged<AnyObject>.fromOpaque(currentInfo).takeUnretainedValue() if infoObject is Reachability { let networkReachability = infoObject as! Reachability NotificationCenter.default.put up(identify: Notification.Identify(rawValue: ReachabilityDidChangeNotificationName), object: networkReachability) } } }, &context) == true else { return false }
guard SCNetworkReachabilityScheduleWithRunLoop(reachability, CFRunLoopGetCurrent(), CFRunLoopMode.defaultMode.rawValue) == true else { return false }
notifying = true return notifying }
|
To cease notifying, we simply unschedule the community reachability reference from the run loop:
|
|
func stopNotifier() { if let reachability = networkReachability, notifying == true { SCNetworkReachabilityUnscheduleFromRunLoop(reachability, CFRunLoopGetCurrent(), CFRunLoopMode.defaultMode as! CFString) notifying = false } }
|
We also needs to make it possible for we cease notifying earlier than the Reachability object is deallocated:
|
|
deinit { stopNotifier() }
|
To know the state of the community reachability, we will outline a computed property that can get the present flags of the SCNetworkReachability object:
|
|
non-public var flags: SCNetworkReachabilityFlags {
var flags = SCNetworkReachabilityFlags(rawValue: 0)
if let reachability = networkReachability, withUnsafeMutablePointer(to: &flags, { SCNetworkReachabilityGetFlags(reachability, UnsafeMutablePointer($0)) }) == true { return flags } else { return [] } }
|
I create now a way that is ready to return the reachability standing for the set of flags handed to it (the logic used to find out which flag means which sort of connection is defined within the feedback of the strategy):
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
|
var currentReachabilityStatus: ReachabilityStatus {
if flags.incorporates(.reachable) == false { // The goal host shouldn’t be reachable. return .notReachable } else if flags.incorporates(.isWWAN) == true { // WWAN connections are OK if the calling software is utilizing the CFNetwork APIs. return .reachableViaWWAN } else if flags.incorporates(.connectionRequired) == false { // If the goal host is reachable and no connection is required then we’ll assume that you just’re on Wi-Fi… return .reachableViaWiFi } else if (flags.incorporates(.connectionOnDemand) == true || flags.incorporates(.connectionOnTraffic) == true) && flags.incorporates(.interventionRequired) == false { // The connection is on-demand (or on-traffic) if the calling software is utilizing the CFSocketStream or greater APIs and no [user] intervention is required return .reachableViaWiFi } else { return .notReachable } }
|
If you wish to know extra in regards to the completely different flags which are out there and the that means of every one, you may learn the official documentation for the flags.
Lastly, we will create a way to find out the reachability standing of the present flags of our community reachability reference, and a computed property to confirm if we’re related or not:
|
|
var isReachable: Bool { change currentReachabilityStatus { case .notReachable: return false case .reachableViaWiFi, .reachableViaWWAN: return true } }
|
How you can use the Reachability?
Utilizing your new Reachability class is basically simple: you create a brand new occasion, and begin the notifier. Then, if wish to management the state of the UI relying on the reachability, you may register your view controller to the reachability notification and make it react to reachability modifications.
Let’s construct a quite simple instance to check our Reachability class. I’ll change the colour of the viewcontroller’s view to inexperienced when there may be connection to the Web. As an alternative, the colour of the view will change to pink if there isn’t a Web related.
Open the ViewController.swift file and add a brand new property to this class:
|
|
import UIKit
class ViewController: UIViewController {
var reachability: Reachability? = Reachability.reachabilityForInternetConnection()
|
Within the viewDidLoad() methodology we add the view controller as an observer of the reachability notification.
|
|
override func viewDidLoad() { tremendous.viewDidLoad()
NotificationCenter.default.addObserver(self, selector: #selector(reachabilityDidChange(_:)), identify: NSNotification.Identify(rawValue: ReachabilityDidChangeNotificationName), object: nil)
_ = reachability?.startNotifier() }
|
Within the deinit we cease the notifier:
|
|
deinit { NotificationCenter.default.removeObserver(self) reachability?.stopNotifier() }
|
Each time the view of this view controller seems on the display, we examine for the reachability:
|
|
override func viewWillAppear(_ animated: Bool) { tremendous.viewWillAppear(animated) checkReachability() }
func checkReachability() { guard let r = reachability else { return } if r.isReachable { view.backgroundColor = UIColor.inexperienced } else { view.backgroundColor = UIColor.pink } }
|
Once we obtain a notification, the view controller executes the next methodology:
|
|
func reachabilityDidChange(_ notification: Notification) { checkReachability() }
|
In fact you may also use it with a site tackle. Simply use the corresponding initializer, for instance:
|
|
var reachability = Reachability(hostName: “www.apple.com”)
|
Conclusion
I hope that now you may have a greater understanding of how the SystemConfiguration framework works.
Get pleasure from studying!!!
Geppy Parziale (@geppyp) is cofounder of InvasiveCode. He has developed many iOS functions and taught iOS growth to many engineers all over the world since 2008. He labored at Apple as iOS and OS X Engineer within the Core Recognition group. He has developed a number of iOS and OS X apps and frameworks for Apple, and lots of of his growth tasks are top-grossing iOS apps which are featured within the App Retailer. Geppy is an knowledgeable in pc imaginative and prescient and machine studying.
(Visited 3,961 occasions, 1 visits right this moment)
[ad_2]
Source_link