Le moyen le plus simple de détecter une connexion Internet sur iOS?

147

Je sais que cette question semblera être une dupe de beaucoup d'autres, cependant, je ne pense pas que le cas simple soit bien expliqué ici. Venant d'un arrière-plan Android et BlackBerry, les demandes HTTPUrlConnectionéchouent instantanément s'il n'y a pas de connexion disponible. Cela semble être un comportement complètement sensé, et j'ai été surpris de constater que NSURLConnectioniOS ne l'avait pas émulé.

Je comprends qu'Apple (et d'autres qui l'ont étendu) fournissent une Reachabilityclasse pour aider à déterminer l'état du réseau. J'étais heureux de voir cela pour la première fois et je m'attendais vraiment à voir quelque chose comme bool isNetworkAvailable(), mais à ma grande surprise, j'ai trouvé un système complexe nécessitant des enregistrements de notification et des rappels, et un tas de détails apparemment inutiles. Il doit y avoir un meilleur moyen.

Mon application gère déjà correctement les échecs de connexion, y compris l'absence de connectivité. L'utilisateur est informé de l'échec et l'application continue.

Ainsi, mes exigences sont simples: une fonction synchrone unique que je peux appeler avant toutes les requêtes HTTP pour déterminer si je devrais prendre la peine d'envoyer la requête ou non. Idéalement, il ne nécessite aucune configuration et renvoie simplement un booléen.

N'est-ce pas vraiment possible sur iOS?

RealCasually
la source
Vous ne devez jamais appeler une méthode d'accessibilité de réseau synchrone avant chaque requête HTTP; c'est juste un peu fou de faire ce travail à moins que l'accessibilité ne vous dise de manière asynchrone qu'il y a eu un changement dans les conditions du réseau et que vous pouvez alors choisir de ne pas envoyer la requête HTTP. C'est également la raison pour laquelle les délais d'expiration existent (et vous devez ensuite gérer ce scénario avec élégance). Voir le lien ci-dessus pour la manière asynchrone
iwasrobbed

Réponses:

251

J'ai fait un peu plus de recherche et je mets à jour ma réponse avec une solution plus actuelle. Je ne sais pas si vous l'avez déjà regardé, mais il existe un bel exemple de code fourni par Apple.

Téléchargez l'exemple de code ici

Incluez les fichiers Reachability.h et Reachability.m dans votre projet. Jetez un œil à ReachabilityAppDelegate.m pour voir un exemple sur la façon de déterminer l'accessibilité de l'hôte, l'accessibilité par WiFi, par WWAN, etc. Pour une vérification très simple de l'accessibilité du réseau, vous pouvez faire quelque chose comme ceci

Reachability *networkReachability = [Reachability reachabilityForInternetConnection];   
NetworkStatus networkStatus = [networkReachability currentReachabilityStatus];    
if (networkStatus == NotReachable) {        
    NSLog(@"There IS NO internet connection");        
} else {        
     NSLog(@"There IS internet connection");        
}

@ BenjaminPiette's: N'oubliez pas d'ajouter SystemConfiguration.framework à votre projet.

Semere Taézaz Sium
la source
46
N'oubliez pas d'ajouter SystemConfiguration.framework à votre projet.
Benjamin Piette
1
@chandru Cela fonctionne. C'est le moyen le plus simple et le plus efficace que je vois pour détecter la connexion réseau. Simple et facile!
S1U
3
Attention à cela. Je trouve que cela ne fonctionne pas de manière fiable lorsque le réseau est restauré, du moins dans le simulateur. Je lance avec le wifi désactivé, et il signale correctement qu'aucun réseau n'est disponible; mais ensuite je rallume le wifi, et SCNetworkReachabilityGetFlags continue de renvoyer 0, même si les requêtes réseau réelles fonctionnent très bien.
Joe Strout
2
Je crois que ma réponse ci-dessous ( stackoverflow.com/a/26593728/557362 ) nécessite moins de travail (pas de téléchargement d'autres fichiers), mais ce n'est que mon avis.
GilesDMiddleton
3
Notez que cela vous indique uniquement si la connexion à l'hôte spécifique est routable . Cela ne signifie pas que vous êtes réellement en mesure de vous connecter. Exemple: vous connectez le wifi de votre iPhone au wifi de votre caméra. Le Wifi est connecté à une passerelle par défaut: tous les hôtes se rapporteront joignables. Mais ils ne le sont en fait pas - la caméra est une connexion sans issue.
xaphod
45

Étant donné que ce fil est le meilleur résultat sur Google pour ce type de question, j'ai pensé que je fournirais la solution qui fonctionnait pour moi. J'utilisais déjà AFNetworking , mais la recherche n'a révélé comment accomplir cette tâche avec AFNetworking qu'au milieu de mon projet.

Ce que vous voulez, c'est l' AFNetworkingReachabilityManager .

// -- Start monitoring network reachability (globally available) -- //
[[AFNetworkReachabilityManager sharedManager] startMonitoring];

[[AFNetworkReachabilityManager sharedManager] setReachabilityStatusChangeBlock:^(AFNetworkReachabilityStatus status) {

    NSLog(@"Reachability changed: %@", AFStringFromNetworkReachabilityStatus(status));


    switch (status) {
        case AFNetworkReachabilityStatusReachableViaWWAN:
        case AFNetworkReachabilityStatusReachableViaWiFi:
            // -- Reachable -- //
            NSLog(@"Reachable");
            break;
        case AFNetworkReachabilityStatusNotReachable:
        default:
            // -- Not reachable -- //
            NSLog(@"Not Reachable");
            break;
    }

}];

Vous pouvez également utiliser les éléments suivants pour tester l'accessibilité de manière synchrone (une fois la surveillance démarrée):

-(BOOL) isInternetReachable
{
    return [AFNetworkReachabilityManager sharedManager].reachable;
}
Sherbertman
la source
3
J'ai voté pour la mise AFNetworkReachabilityManageren lumière!
Selvin
Pour ceux pour qui cela n'a pas été immédiatement évident: AFNetworking est une bibliothèque tierce.
arlomedia
1
L'accessibilité du réseau est un outil de diagnostic qui peut être utilisé pour comprendre pourquoi une demande a échoué. Il ne doit pas être utilisé pour déterminer s'il faut ou non faire une demande. - C'est ce que dit la documentation.
Nosov Pavel
AFNetworkReachabilityManager.reachableN'effectue AUCUNE sorte de contrôle synchrone. Il renvoie un ou logique de reachableViaWWANet reachableViaWifi.
jdolan
40

Désolé d'avoir répondu trop tard, mais j'espère que cette réponse pourra aider quelqu'un à l'avenir.

Voici un petit extrait de code C natif qui peut vérifier la connectivité Internet sans aucune classe supplémentaire.

Ajoutez les en-têtes suivants:

#include<unistd.h>
#include<netdb.h>

Code:

-(BOOL)isNetworkAvailable
{
    char *hostname;
    struct hostent *hostinfo;
    hostname = "google.com";
    hostinfo = gethostbyname (hostname);
    if (hostinfo == NULL){
        NSLog(@"-> no connection!\n");
        return NO;
    }
    else{
        NSLog(@"-> connection established!\n");
        return YES;
    }
}

Swift 3

func isConnectedToInternet() -> Bool {
    let hostname = "google.com"
    //let hostinfo = gethostbyname(hostname)
    let hostinfo = gethostbyname2(hostname, AF_INET6)//AF_INET6
    if hostinfo != nil {
        return true // internet available
      }
     return false // no internet
    }
expéditionMain
la source
3
fonctionne bien mieux que l'accessibilité Apple. Mais selon la documentation, gethostbyname est obsolète et vous devez utiliser getaddrinfo: struct addrinfo * res = NULL; int s = getaddrinfo ("apple.com", NULL, NULL, & res); booléen network_ok = (s == 0 && res! = NULL); freeaddrinfo (res);
Tertium
1
Bien qu'il soit courant d'utiliser google.com pour vérifier la disponibilité d'Internet, il convient de noter qu'il est bloqué dans certains pays. Un meilleur choix serait des domaines de sociétés plus «favorables au gouvernement» telles que yahoo.com ou microsoft.com.
laurent
8
@Laurent: La meilleure option est d'utiliser l'adresse du serveur à partir de laquelle vous allez demander des données. google.com ici n'est qu'un exemple.
expéditionMain
7
S'agit-il simplement d'une recherche DNS? Si tel est le cas, un résultat DNS mis en cache pourrait-il amener la fonction à croire à tort que le réseau est disponible?
Stephen Moore
2
@amar L'exécuter en boucle consommera des données sans fil, vous ne voulez pas faire cela.
sens-questions
31

J'utilise actuellement cette méthode synchrone simple qui ne nécessite aucun fichier supplémentaire dans vos projets ou délégués.

Importer:

#import <SystemConfiguration/SCNetworkReachability.h>

Créez cette méthode:

+(bool)isNetworkAvailable
{
    SCNetworkReachabilityFlags flags;
    SCNetworkReachabilityRef address;
    address = SCNetworkReachabilityCreateWithName(NULL, "www.apple.com" );
    Boolean success = SCNetworkReachabilityGetFlags(address, &flags);
    CFRelease(address);

    bool canReach = success
                    && !(flags & kSCNetworkReachabilityFlagsConnectionRequired)
                    && (flags & kSCNetworkReachabilityFlagsReachable);

    return canReach;
}

Ensuite, si vous avez mis ceci dans un MyNetworkClass:

if( [MyNetworkClass isNetworkAvailable] )
{
   // do something networky.
}

Si vous testez dans le simulateur, activez et désactivez le wifi de votre Mac, car il semble que le simulateur ignorera les paramètres du téléphone.

Mettre à jour:

  1. À la fin, j'ai utilisé un thread / callback asynchrone pour éviter de bloquer le thread principal; et re-tester régulièrement pour que je puisse utiliser un résultat mis en cache - bien que vous devriez éviter de garder les connexions de données ouvertes inutilement.

  2. Comme @thunk l'a décrit, il existe de meilleures URL à utiliser, qu'Apple utilise lui-même. http://cadinc.com/blog/why-your-apple-ios-7-device-wont-connect-to-the-wifi-network

GilesDMiddleton
la source
1
Merci, et comme la plupart des autres dans ce fil: n'oubliez pas d'ajouter SystemConfiguration.framework à votre projet.
eselk
1
Bizarre, dans mon projet Xcode, je n'ai pas eu à ajouter le SystemConfiguration.framework. J'ai SpriteKit, UIKit, StoreKit, Foundation et CoreGraphics, mais pas SystemConfiguration ... Y a-t-il une inclusion implicite en cours?
GilesDMiddleton
3
Cela a fonctionné pour moi, mais lorsque je l'ai exécuté lorsqu'il était connecté à un réseau Wi-Fi sans connexion Internet, il a verrouillé mon interface utilisateur pendant environ 30 secondes. Une approche asynchrone est nécessaire dans cette situation.
arlomedia
2
www.apple.comest un grand site Web ... la meilleure option serawww.google.com
Fahim Parkar
2
excellente réponse! Une suggestion: l'URL de test,, www.appleiphonecell.comest censée être disponible strictement à cette fin et apparemment non bloquée en Chine.
Thunk du
11

C'est possible et c'est vraiment simple si vous le regardez lorsque vous avez terminé l'implémentation, ce qui est encore une fois - très simple, car les seuls éléments dont vous avez besoin sont deux variables booléennes: l'accessibilité à Internet et l'accessibilité de l'hôte (vous avez souvent besoin de plus d'une de ces ). Une fois que vous avez assemblé votre classe d'assistance qui peut déterminer l'état des connexions, vous ne vous souciez vraiment plus de l'implémentation nécessaire pour connaître ces procédures.

Exemple:

#import <Foundation/Foundation.h>

@class Reachability;

@interface ConnectionManager : NSObject {
    Reachability *internetReachable;
    Reachability *hostReachable;
}

@property BOOL internetActive;
@property BOOL hostActive;

- (void) checkNetworkStatus:(NSNotification *)notice;

@end

Et le fichier .m:

#import "ConnectionManager.h"
#import "Reachability.h"

@implementation ConnectionManager
@synthesize internetActive, hostActive;

-(id)init {
    self = [super init];
    if(self) {

    }
    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(checkNetworkStatus:) name:kReachabilityChangedNotification object:nil];

    internetReachable = [[Reachability reachabilityForInternetConnection] retain];
    [internetReachable startNotifier];

    hostReachable = [[Reachability reachabilityWithHostName:@"www.apple.com"] retain];
    [hostReachable startNotifier];

    return self;
}

- (void) checkNetworkStatus:(NSNotification *)notice {
    NetworkStatus internetStatus = [internetReachable currentReachabilityStatus];
    switch (internetStatus)

    {
        case NotReachable:
        {
            NSLog(@"The internet is down.");
            self.internetActive = NO;

            break;

        }
        case ReachableViaWiFi:
        {
            NSLog(@"The internet is working via WIFI.");
            self.internetActive = YES;

            break;

        }
        case ReachableViaWWAN:
        {
            NSLog(@"The internet is working via WWAN.");
            self.internetActive = YES;

            break;

        }
    }

    NetworkStatus hostStatus = [hostReachable currentReachabilityStatus];
    switch (hostStatus)

    {
        case NotReachable:
        {
            NSLog(@"A gateway to the host server is down.");
            self.hostActive = NO;

            break;

        }
        case ReachableViaWiFi:
        {
            NSLog(@"A gateway to the host server is working via WIFI.");
            self.hostActive = YES;

            break;

        }
        case ReachableViaWWAN:
        {
            NSLog(@"A gateway to the host server is working via WWAN.");
            self.hostActive = YES;

            break;

        }
    }

}

// If lower than SDK 5 : Otherwise, remove the observer as pleased.

- (void)dealloc {
    [[NSNotificationCenter defaultCenter] removeObserver:self];
    [super dealloc];
}

@end
Danut Pralea
la source
4

J'ai extrait le code et mis en une seule méthode, j'espère que cela aiderait les autres.

#import <SystemConfiguration/SystemConfiguration.h>

#import <netinet/in.h>
#import <netinet6/in6.h>

...

- (BOOL)isInternetReachable
{    
    struct sockaddr_in zeroAddress;
    bzero(&zeroAddress, sizeof(zeroAddress));
    zeroAddress.sin_len = sizeof(zeroAddress);
    zeroAddress.sin_family = AF_INET;

    SCNetworkReachabilityRef reachability = SCNetworkReachabilityCreateWithAddress(kCFAllocatorDefault, (const struct sockaddr*)&zeroAddress);
    SCNetworkReachabilityFlags flags;

    if(reachability == NULL)
        return false;

    if (!(SCNetworkReachabilityGetFlags(reachability, &flags)))
        return false;

    if ((flags & kSCNetworkReachabilityFlagsReachable) == 0)
        // if target host is not reachable
        return false;


    BOOL isReachable = false;


    if ((flags & kSCNetworkReachabilityFlagsConnectionRequired) == 0)
    {
        // if target host is reachable and no connection is required
        //  then we'll assume (for now) that your on Wi-Fi
        isReachable = true;
    }


    if ((((flags & kSCNetworkReachabilityFlagsConnectionOnDemand ) != 0) ||
         (flags & kSCNetworkReachabilityFlagsConnectionOnTraffic) != 0))
    {
        // ... and the connection is on-demand (or on-traffic) if the
        //     calling application is using the CFSocketStream or higher APIs

        if ((flags & kSCNetworkReachabilityFlagsInterventionRequired) == 0)
        {
            // ... and no [user] intervention is needed
            isReachable = true;
        }
    }

    if ((flags & kSCNetworkReachabilityFlagsIsWWAN) == kSCNetworkReachabilityFlagsIsWWAN)
    {
        // ... but WWAN connections are OK if the calling application
        //     is using the CFNetwork (CFSocketStream?) APIs.
        isReachable = true;
    }


    return isReachable;


}
Walty Yeung
la source
[A] D'où avez-vous extrait ce code? Pouvez-vous publier un lien vers la source? [B] Merci beaucoup pour votre travail d'extraction! Juste ce dont j'avais besoin. J'étais sur le point d'accomplir cette corvée moi-même.
Basil Bourque
Donc, il semble que ce soit la seule réponse qui ne vérifie aucun serveur distant?
Jasper
Pour les autres testant cela sur MacOS, notez que kSCNetworkReachabilityFlagsIsWWAN est pour OS_IPHONE et non macOS.
GeoffCoope
4

J'écris la version rapide de la réponse acceptée ici , au cas où si quelqu'un la trouve utile, le code est écrit swift 2,

Vous pouvez télécharger les fichiers requis à partir de SampleCode

Ajouter Reachability.het Reachability.mdéposer à votre projet,

Maintenant, il faudra créer un Bridging-Header.hfichier s'il n'en existe pas pour votre projet,

À l'intérieur de votre Bridging-Header.hfichier, ajoutez cette ligne:

#import "Reachability.h"

Maintenant, pour vérifier la connexion Internet

static func isInternetAvailable() -> Bool {
    let networkReachability : Reachability = Reachability.reachabilityForInternetConnection()
    let networkStatus : NetworkStatus = networkReachability.currentReachabilityStatus()

    if networkStatus == NotReachable {
        print("No Internet")
        return false
    } else {
        print("Internet Available")
        return true
    }

}
Satyen Udeshi
la source
3

Je pense que cela pourrait aider.

[[AFNetworkReachabilityManager sharedManager] startMonitoring];

if([AFNetworkReachabilityManager sharedManager].isReachable)
{
    NSLog(@"Network reachable");
}
else
{   
   NSLog(@"Network not reachable");
}
pooja
la source
Cela ne fonctionne pas si l'interface réseau n'est pas modifiée et si la connectivité Internet est perdue.
Pratik Somaiya
2

Vous pouvez également essayer celui-ci si vous avez déjà configuré AFNetworking dans votre projet.

-(void)viewDidLoad{  // -- add connectivity notification --//
[[NSNotificationCenter defaultCenter ] addObserver:self selector:@selector(ReachabilityDidChangeNotification:) name:AFNetworkingReachabilityDidChangeNotification object:nil];}
-(void)ReachabilityDidChangeNotification:(NSNotification *)notify
{
// -- NSLog(@"Reachability changed: %@", AFStringFromNetworkReachabilityStatus(status));  -- //
NSDictionary *userInfo =[notif userInfo];
AFNetworkReachabilityStatus status= [[userInfo valueForKey:AFNetworkingReachabilityNotificationStatusItem] intValue];
switch (status)
{
    case AFNetworkReachabilityStatusReachableViaWWAN:
    case AFNetworkReachabilityStatusReachableViaWiFi:
        // -- Reachable -- //
// -- Do your stuff when internet connection is available -- //
        [self getLatestStuff];
        NSLog(@"Reachable");
        break;
    case AFNetworkReachabilityStatusNotReachable:
    default:
        // -- Not reachable -- //
        // -- Do your stuff for internet connection not available -- //
NSLog(@"Not Reachable");
        break;
}
}
Ravi Raja Jangid
la source
1

Voici une bonne solution pour vérifier la connectivité à l'aide de Swift, sans utiliser l'accessibilité. Je l'ai trouvé sur ce blog .

Créez un nouveau fichier Swift dans votre projet appelé Network.swift(par exemple). Collez ce code dans ce fichier:

import Foundation

public class Network {

    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
    }
}

Vous pouvez ensuite vérifier la connectivité n'importe où dans votre projet en utilisant:

if Network.isConnectedToNetwork() == true {
    println("Internet connection OK")
} else {
    println("Internet connection FAILED")
}
hivers
la source
0

EDIT: Cela ne fonctionnera pas pour les URL réseau (voir les commentaires)

À partir d'iOS 5, il existe une nouvelle méthode d'instance NSURL:

- (BOOL)checkResourceIsReachableAndReturnError:(NSError **)error

Dirigez-le vers le site Web qui vous intéresse ou dirigez-le vers apple.com; Je pense que c'est le nouvel appel d'une ligne pour voir si Internet fonctionne sur votre appareil.

SG1
la source
En fait, dans mes propres tests, cela renvoie toujours faux. La documentation indique que c'est le cas pour 4.x, mais dans 5+, cela devrait fonctionner. YMMV
SG1
Cela ne semble pas fonctionner pour la situation que vous recherchez. Voir stackoverflow.com/questions/9266154/…
Micah Hainline
7
Cela est utilisé pour les URL de fichiers, pas pour les URL Internet.
Victor Bogdan
0

Je n'étais pas non plus satisfait des options de vérification Internet disponibles (pourquoi n'est-ce pas une API native?!?!)

Mon propre problème était la perte de 100% des paquets - lorsqu'un appareil est connecté au routeur, mais que le routeur n'est pas connecté à Internet. L'accessibilité et d'autres seront suspendues pendant des siècles. J'ai créé une classe de singleton utilitaire pour gérer cela en ajoutant un délai d'attente asynchrone. Cela fonctionne bien dans mon application. J'espère que ça aide. Voici le lien sur github:

https://github.com/fareast555/TFInternetChecker

Mike Critchley
la source
0

Vérification de la disponibilité de la connexion Internet dans (iOS) Xcode 8.2, Swift 3.0

Il s'agit d'une méthode simple pour vérifier la disponibilité du réseau. J'ai réussi à le traduire en Swift 2.0 et ici le code final. La classe d'accessibilité Apple existante et d'autres bibliothèques tierces semblaient trop compliquées à traduire en Swift.

Cela fonctionne pour les connexions 3G et WiFi.

N'oubliez pas d'ajouter «SystemConfiguration.framework» à votre constructeur de projet.

//Create new swift class file Reachability in your project.

import SystemConfiguration

public class Reachability {
class func isConnectedToNetwork() -> 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.rawValue & UInt32(kSCNetworkFlagsReachable)) != 0
    let needsConnection = (flags.rawValue & UInt32(kSCNetworkFlagsConnectionRequired)) != 0
    return (isReachable && !needsConnection)
   }
}

// Check network connectivity from anywhere in project by using this code.

if Reachability.isConnectedToNetwork() == true {
     print("Internet connection OK")
} else {
 print("Internet connection FAILED")
}
ViJay Avhad
la source
Avec Xcode version 7.2 (7C68), ce code a des erreurs de compilation
Daniel
@Daniel, merci pour le problème de pointage, ceci à cause de pointeurs dangereux, car Swift 2 / Xcode met à jour ses syntaxes, nous devrions les suivre. J'ai mis à jour le code pour le même. ty;)
ViJay Avhad
Si vous êtes connecté à un réseau Wi-Fi mais que vous ne parvenez pas à vous connecter à Internet (ouvrez une page Google), il renvoie toujours vrai pour accessible. C'est faux.
Arildo Junior
0

Remplacement de l'accessibilité d'Apple réécrit en Swift avec fermetures , inspiré par tonymillion: https://github.com/ashleymills/Reachability.swift

  1. Déposez le fichier Reachability.swiftdans votre projet. Vous pouvez également utiliser CocoaPods ou Carthage - Voir la section Installation du fichier README du projet.

  2. Recevez des notifications sur la connectivité réseau:

    //declare this property where it won't go out of scope relative to your listener
    let reachability = Reachability()!
    
    reachability.whenReachable = { reachability in
        if reachability.isReachableViaWiFi {
            print("Reachable via WiFi")
        } else {
            print("Reachable via Cellular")
        }
    }
    
    reachability.whenUnreachable = { _ in
        print("Not reachable")
    }
    
    do {
        try reachability.startNotifier()
    } catch {
        print("Unable to start notifier")
    }

    et pour arrêter les notifications

    reachability.stopNotifier()
Pierre F
la source
0

Alamofire

Si vous utilisez déjà Alamofire pour toutes les API RESTful, voici ce que vous pouvez en tirer.

Vous pouvez ajouter la classe suivante à votre application et appeler MNNetworkUtils.main.isConnected()pour obtenir un booléen indiquant si elle est connectée ou non.

#import Alamofire

class MNNetworkUtils {
  static let main = MNNetworkUtils()
  init() {
    manager = NetworkReachabilityManager(host: "google.com")
    listenForReachability()
  }

  private let manager: NetworkReachabilityManager?
  private var reachable: Bool = false
  private func listenForReachability() {
    self.manager?.listener = { [unowned self] status in
      switch status {
      case .notReachable:
        self.reachable = false
      case .reachable(_), .unknown:
        self.reachable = true
      }
    }
    self.manager?.startListening()
  }

  func isConnected() -> Bool {
    return reachable
  }
}

Ceci est une classe singleton. Chaque fois que l'utilisateur se connecte ou se déconnecte du réseau, il remplace self.reachablecorrectement true / false, car nous commençons à écouter l' NetworkReachabilityManagerinitialisation sur singleton.

Aussi, afin de surveiller l'accessibilité, vous devez fournir un hôte, actuellement j'utilise, google.comn'hésitez pas à changer pour tout autre hôte ou l'un des vôtres si nécessaire.

nuynait
la source