Existe-t-il un moyen de vérifier si la connexion Internet est disponible avec Swift?
Je sais qu'il existe de nombreuses bibliothèques tierces pour ce faire, mais elles sont toutes écrites en Objective-C. Je recherche une alternative Swift.
Existe-t-il un moyen de vérifier si la connexion Internet est disponible avec Swift?
Je sais qu'il existe de nombreuses bibliothèques tierces pour ce faire, mais elles sont toutes écrites en Objective-C. Je recherche une alternative Swift.
Réponses:
Comme mentionné dans les commentaires, bien qu'il soit possible d'utiliser les bibliothèques Objective-C dans Swift, je voulais une solution Swift plus pure. La classe d'accessibilité Apple existante et d'autres bibliothèques tierces me semblaient trop compliquées à traduire en Swift. J'ai cherché un peu plus sur Google et je suis tombé sur cet article qui montre une méthode simple pour vérifier la disponibilité du réseau. J'ai décidé de traduire ceci en Swift. J'ai rencontré de nombreux problèmes, mais grâce à Martin R de StackOverflow, j'ai réussi à les résoudre et enfin à obtenir une solution viable dans Swift. Voici le code.
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(nil, UnsafePointer($0)).takeRetainedValue()
}
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
}
}
Pour Swift> 3.0
public class Reachability {
public func isConnectedToNetwork() -> Bool {
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 false
}
var flags: SCNetworkReachabilityFlags = []
if !SCNetworkReachabilityGetFlags(defaultRouteReachability, &flags) {
return false
}
if flags.isEmpty {
return false
}
let isReachable = flags.contains(.reachable)
let needsConnection = flags.contains(.connectionRequired)
return (isReachable && !needsConnection)
}
}
Cela fonctionne pour les connexions 3G et WiFi. Je l'ai également téléchargé sur mon GitHub avec un exemple fonctionnel.
isConnectedToNetwork
retourne true, mais je ne peux pas appeler mon service Web
Je te donne un meilleur moyen ...
Vous devez créer une classe avec ce code
import Foundation
public class Reachability {
class func isConnectedToNetwork()->Bool{
var Status:Bool = false
let url = NSURL(string: "http://google.com/")
let request = NSMutableURLRequest(URL: url!)
request.HTTPMethod = "HEAD"
request.cachePolicy = NSURLRequestCachePolicy.ReloadIgnoringLocalAndRemoteCacheData
request.timeoutInterval = 10.0
var response: NSURLResponse?
var data = NSURLConnection.sendSynchronousRequest(request, returningResponse: &response, error: nil) as NSData?
if let httpResponse = response as? NSHTTPURLResponse {
if httpResponse.statusCode == 200 {
Status = true
}
}
return Status
}
}
Et puis, vous pouvez vérifier la connexion Internet n'importe où dans votre projet en utilisant ce code:
if Reachability.isConnectedToNetwork() == true {
println("Internet connection OK")
} else {
println("Internet connection FAILED")
}
Très facile!
* Cette méthode est basée sur la réponse de Vikram Pote!
Pour Swift 3.1 (iOS 10.1)
Si vous souhaitez faire la distinction entre le type de réseau (c'est-à-dire WiFi ou WWAN):
Vous pouvez utiliser:
func checkWiFi() -> Bool {
let networkStatus = Reachability().connectionStatus()
switch networkStatus {
case .Unknown, .Offline:
return false
case .Online(.WWAN):
print("Connected via WWAN")
return true
case .Online(.WiFi):
print("Connected via WiFi")
return true
}
}
Voici toute la classe d'accessibilité qui distingue les types de réseau:
import Foundation
import SystemConfiguration
import UIKit
import SystemConfiguration.CaptiveNetwork
public let ReachabilityStatusChangedNotification = "ReachabilityStatusChangedNotification"
public enum ReachabilityType: CustomStringConvertible {
case WWAN
case WiFi
public var description: String {
switch self {
case .WWAN: return "WWAN"
case .WiFi: return "WiFi"
}
}
}
public enum ReachabilityStatus: CustomStringConvertible {
case Offline
case Online(ReachabilityType)
case Unknown
public var description: String {
switch self {
case .Offline: return "Offline"
case .Online(let type): return "Online (\(type))"
case .Unknown: return "Unknown"
}
}
}
public class Reachability {
func connectionStatus() -> ReachabilityStatus {
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) { zeroSockAddress in
SCNetworkReachabilityCreateWithAddress(nil, zeroSockAddress)
}
}) else {
return .Unknown
}
var flags : SCNetworkReachabilityFlags = []
if !SCNetworkReachabilityGetFlags(defaultRouteReachability, &flags) {
return .Unknown
}
return ReachabilityStatus(reachabilityFlags: flags)
}
func monitorReachabilityChanges() {
let host = "google.com"
var context = SCNetworkReachabilityContext(version: 0, info: nil, retain: nil, release: nil, copyDescription: nil)
let reachability = SCNetworkReachabilityCreateWithName(nil, host)!
SCNetworkReachabilitySetCallback(reachability, { (_, flags, _) in
let status = ReachabilityStatus(reachabilityFlags: flags)
NotificationCenter.default.post(name: NSNotification.Name(rawValue: ReachabilityStatusChangedNotification), object: nil, userInfo: ["Status": status.description])}, &context)
SCNetworkReachabilityScheduleWithRunLoop(reachability, CFRunLoopGetMain(), CFRunLoopMode.commonModes.rawValue)
}
}
extension ReachabilityStatus {
public init(reachabilityFlags flags: SCNetworkReachabilityFlags) {
let connectionRequired = flags.contains(.connectionRequired)
let isReachable = flags.contains(.reachable)
let isWWAN = flags.contains(.isWWAN)
if !connectionRequired && isReachable {
if isWWAN {
self = .Online(.WWAN)
} else {
self = .Online(.WiFi)
}
} else {
self = .Offline
}
}
}
Puisque sendSynchronousRequest est obsolète, j'ai essayé ceci mais 'return Status' a été appelé avant la fin de la réponse.
Cette réponse fonctionne bien cependant, vérifiez la connexion Internet avec Swift
Voici ce que j'ai essayé de toute façon:
import Foundation
public class Reachability {
class func isConnectedToNetwork()->Bool{
var Status:Bool = false
let url = NSURL(string: "http://google.com/")
let request = NSMutableURLRequest(URL: url!)
request.HTTPMethod = "HEAD"
request.cachePolicy = NSURLRequestCachePolicy.ReloadIgnoringLocalAndRemoteCacheData
request.timeoutInterval = 10.0
let session = NSURLSession.sharedSession()
session.dataTaskWithRequest(request, completionHandler: {(data, response, error) in
print("data \(data)")
print("response \(response)")
print("error \(error)")
if let httpResponse = response as? NSHTTPURLResponse {
print("httpResponse.statusCode \(httpResponse.statusCode)")
if httpResponse.statusCode == 200 {
Status = true
}
}
}).resume()
return Status
}
}
SWIFT 3: Vérifie wifi et internet connexion:
import Foundation
import SystemConfiguration
public class Reachability {
public func isConnectedToNetwork() -> Bool {
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 false
}
var flags: SCNetworkReachabilityFlags = []
if !SCNetworkReachabilityGetFlags(defaultRouteReachability, &flags) {
return false
}
let isReachable = flags.contains(.reachable)
let needsConnection = flags.contains(.connectionRequired)
return (isReachable && !needsConnection)
}
}
USAGE:
if Reachability.isConnectedToNetwork() == true {
print("Connected to the internet")
// Do something
} else {
print("No internet connection")
// Do something
}
public func isConnectedToNetwork() {...}
doit être remplacé par class func isConnectedToNetwork{...}
pour votre cas d'utilisation.
Vous pouvez également utiliser la réponse ci-dessous.
func checkInternet(flag:Bool, completionHandler:(internet:Bool) -> Void)
{
UIApplication.sharedApplication().networkActivityIndicatorVisible = true
let url = NSURL(string: "http://www.google.com/")
let request = NSMutableURLRequest(URL: url!)
request.HTTPMethod = "HEAD"
request.cachePolicy = NSURLRequestCachePolicy.ReloadIgnoringLocalAndRemoteCacheData
request.timeoutInterval = 10.0
NSURLConnection.sendAsynchronousRequest(request, queue:NSOperationQueue.mainQueue(), completionHandler:
{(response: NSURLResponse!, data: NSData!, error: NSError!) -> Void in
UIApplication.sharedApplication().networkActivityIndicatorVisible = false
let rsp = response as NSHTTPURLResponse?
completionHandler(internet:rsp?.statusCode == 200)
})
}
func yourMethod()
{
self.checkInternet(false, completionHandler:
{(internet:Bool) -> Void in
if (internet)
{
// "Internet" mean Google
}
else
{
// No "Internet" no Google
}
})
}
SWIFT 3: vérifier la connexion 3G et Wi-Fi
DispatchQueue.main.async {
let url = URL(string: "https://www.google.com")!
let request = URLRequest(url: url)
let task = URLSession.shared.dataTask(with: request) {data, response, error in
if error != nil {
// do something here...
print("Internet Connection not Available!")
}
else if let httpResponse = response as? HTTPURLResponse {
if httpResponse.statusCode == 200 {
// do something here...
print("Internet Connection OK")
}
print("statusCode: \(httpResponse.statusCode)")
}
}
task.resume()
}
Pour Swift 5:
import Network
let monitor = NWPathMonitor()
func checkInterwebs() -> Bool {
var status = false
monitor.pathUpdateHandler = { path in
if path.status == .satisfied {
status = true // online
}
}
return status
}
Swift 4
if isInternetAvailable() {
print("if called Internet Connectivity success \(isInternetAvailable())");
} else {
print("else called Internet Connectivity success \(isInternetAvailable())");
}
func isInternetAvailable() -> Bool {
var zeroAddress = sockaddr_in()
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()
if !SCNetworkReachabilityGetFlags(defaultRouteReachability!, &flags) {
return false
}
let isReachable = flags.contains(.reachable)
let needsConnection = flags.contains(.connectionRequired)
// print(isReachable && !needsConnection)
return (isReachable && !needsConnection)
}