我有一个应用程序，想在一定的时间间隔后获取连接状态报告。 即使我已经连接或关联到Wifi网络，我也想知道是否启用了蜂窝网络上的数据访问。这意味着，如果经过检查，我可以优雅地从Wifi网络中断开连接，知道有可用的蜂窝连接，可以将设备连接到该连接。
当前的Reachability 方法只会在连接到蜂窝时提供有关蜂窝可用性的信息，并且在实际连接到接口之前没有太多关于获取此数据的信息。
寻找类似于Android中可用的解决方案，如此链接所述：link。
澄清
我不是要查看我的设备是否具有蜂窝功能。我正在尝试确定用户是否已启用/禁用移动网络上的数据访问，并希望即使连接到Wifi，也能获得此信息。用户可以通过转到设置来打开或关闭此选项。
let wifiMonitor = NWPathMonitor(requiredInterfaceType: .wifi)
let cellularMonitor = NWPathMonitor(requiredInterfaceType: .cellular)
假设你有一个类，用两个简单的布尔值跟踪两个连接状态，使用pathUpdateHandler属性，你可以这样做：
wifiMonitor.pathUpdateHandler = { path in
self.isWifiConnected = path.status == .satisfied
}
cellularMonitor.pathUpdateHandler = { path in
self.isCellularConnected = path.status == .satisfied
}
然后按照您的喜好处理自己。
记得调用start(_:)并提供串行队列来启动监视器（我提供了两个单独的队列）;
有一个小问题，一旦取消监视器实例，您必须实例化一个新实例，因为它无法重新启动。
目前没有可用的API来查询移动数据是否已启用。您可以使用CTCellularData的cellularDataRestrictionDidUpdateNotifier和restrictedState来了解用户是否已为您的应用启用或禁用了移动数据访问。这是iOS允许的应用程序的最大限度。但即使如此，这也并不可靠，因为如果您从设备中取出SIM卡，它仍将向您提供先前受限状态。
我认为你需要重新考虑你正在计划的事情：你永远无法确定在未来的任何时间点是否可靠的（数据）连接将可用：
你只需处理断开连接并在这种情况下提供一种仁慈的行为（而不是崩溃）。
之前我曾经尝试着想解决这个问题，但很遗憾地告诉你，目前没有API可以快速而简单地解决这个问题，所以我决定采取一个变通的方法。我的思路是通过跟踪整个设备的移动数据使用情况，如果我在应用程序中存储了移动数据使用情况，那么我就可以知道用户设备上是否有活跃的移动数据。具体做法如下：首先编写扩展程序：
extension SystemDataUsage {
public static var wwanCompelete: UInt64 {
return SystemDataUsage.getDataUsage().wirelessWanDataSent + SystemDataUsage.getDataUsage().wirelessWanDataReceived
}
}
然后是类：
class SystemDataUsage {
private static let wwanInterfacePrefix = "pdp_ip"
class func getDataUsage() -> DataUsageInfo {
var ifaddr: UnsafeMutablePointer<ifaddrs>?
var dataUsageInfo = DataUsageInfo()
guard getifaddrs(&ifaddr) == 0 else { return dataUsageInfo }
while let addr = ifaddr {
guard let info = getDataUsageInfo(from: addr) else {
ifaddr = addr.pointee.ifa_next
continue
}
dataUsageInfo.updateInfoByAdding(info)
ifaddr = addr.pointee.ifa_next
}
freeifaddrs(ifaddr)
return dataUsageInfo
}
private class func getDataUsageInfo(from infoPointer: UnsafeMutablePointer<ifaddrs>) -> DataUsageInfo? {
let pointer = infoPointer
let name: String! = String(cString: pointer.pointee.ifa_name)
let addr = pointer.pointee.ifa_addr.pointee
guard addr.sa_family == UInt8(AF_LINK) else { return nil }
return dataUsageInfo(from: pointer, name: name)
}
private class func dataUsageInfo(from pointer: UnsafeMutablePointer<ifaddrs>, name: String) -> DataUsageInfo {
var networkData: UnsafeMutablePointer<if_data>?
var dataUsageInfo = DataUsageInfo()
if name.hasPrefix(wwanInterfacePrefix) {
networkData = unsafeBitCast(pointer.pointee.ifa_data, to: UnsafeMutablePointer<if_data>.self)
if let data = networkData {
dataUsageInfo.wirelessWanDataSent += UInt64(data.pointee.ifi_obytes)
dataUsageInfo.wirelessWanDataReceived += UInt64(data.pointee.ifi_ibytes)
}
}
return dataUsageInfo
}
}
最后一个结构体：
struct DataUsageInfo {
var wirelessWanDataReceived: UInt64 = 0
var wirelessWanDataSent: UInt64 = 0
mutating func updateInfoByAdding(_ info: DataUsageInfo) {
wirelessWanDataSent += info.wirelessWanDataSent
wirelessWanDataReceived += info.wirelessWanDataReceived
}
}
我的解决方案可能有些过度，但可能会对某些人有用。但是，这个想法是考虑用户的蜂窝数据应用设置。它利用单例来避免重复初始化并保留BOOL以供依赖，并发布通知，可以在应用程序的任何地方观察到。
// MobileDataPolicy.h
#ifndef MobileDataPolicy_h
#define MobileDataPolicy_h
#import <Foundation/Foundation.h>
@import CoreTelephony;
NS_ASSUME_NONNULL_BEGIN
extern NSNotificationName const kMobileDataPolicyNotification;
extern NSString * const kMobileDataPolicyAllowedKey;
@interface MobileDataPolicy : NSObject
+(BOOL)isAllowed;
@end
NS_ASSUME_NONNULL_END
#endif
并且
// MobileDataPolicy.m
#import "MobileDataPolicy.h"
NSNotificationName const kMobileDataPolicyNotification = @"kMobileDataPolicyNotification";
NSString * const kMobileDataPolicyAllowedKey = @"kMobileDataPolicyAllowedKey";
@interface MobileDataPolicy ()
@property (nonatomic, readwrite) BOOL cellularDataAllowed;
@end
@implementation MobileDataPolicy
+(instancetype)singleton {
static MobileDataPolicy * singletonInstance = nil;
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
if ( !singletonInstance ) {
singletonInstance = [[MobileDataPolicy alloc] initReal];
if (singletonInstance) {
[singletonInstance setupCellularDataPolicyHandler];
}
}
});
return singletonInstance;
}
_Pragma("clang diagnostic push")
_Pragma("clang diagnostic ignored \"-Wobjc-designated-initializers\"")
-(instancetype)init {
NSAssert(NO, @"init is not the designated initializer for instances of MobileDataPolicy. use [MobileDataPolicy isAllowed]");
return nil;
}
_Pragma("clang diagnostic pop")
-(instancetype)initReal {
if (!(self=[super init])) return nil;
_cellularDataAllowed = NO;
return self;
}
// ask for policy with [MobileDataPolicy allowed]
+(BOOL)isAllowed {
//we need only one handler per App.
return [MobileDataPolicy singleton].cellularDataAllowed;
}
#pragma mark setup - Cellular Data Policy Handler
- (void)setupCellularDataPolicyHandler {
if (@available(iOS 9.0, *)) {
CTCellularData *cellularData = [[CTCellularData alloc] init];
//following handler block will run on default priority global dispatch queue
[cellularData setCellularDataRestrictionDidUpdateNotifier:^(CTCellularDataRestrictedState state) {
switch (state) {
case kCTCellularDataRestrictedStateUnknown: self->_cellularDataAllowed = NO;
break;
case kCTCellularDataRestricted: self->_cellularDataAllowed = NO;
break;
case kCTCellularDataNotRestricted: self->_cellularDataAllowed = YES;
break;
default:
break;
}
[[NSNotificationCenter defaultCenter] postNotificationName:kMobileDataPolicyNotification object:nil userInfo:@{kMobileDataPolicyAllowedKey:@(state)}];
}];
}
}
@end
例如使用..
//class method that inits singleton and returns state
BOOL reachCellularData = MobileDataPolicy.isAllowed;
NSLog(@"initial cellular data allowed for app = %@",reachCellularData ? @"YES" : @"NO");
//start observing
id<NSObject> noteKeeper = [[NSNotificationCenter defaultCenter] addObserverForName:kMobileDataPolicyNotification object:nil queue:[NSOperationQueue currentQueue] usingBlock:^(NSNotification * _Nonnull note) {
// do something on cellular Data Policy State change..
int cellularDataState = [note.userInfo[kMobileDataPolicyAllowedKey] intValue];
}];
//stop observing, possibly in -(void)dealloc
[[NSNotificationCenter defaultCenter] removeObserver:noteKeeper];
https://github.com/ashleymills/Reachability.swift Reachability有一种方法可以确定网络是否可通过WWAN连接
var isReachableViaWWAN: Bool {
// Check we're not on the simulator, we're REACHABLE and check we're on WWAN
return isRunningOnDevice && isReachableFlagSet && isOnWWANFlagSet
}
你可以了解所有的情况：
[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(handleNetworkChange:) name:kReachabilityChangedNotification object:nil];
Reachability *reachablity=[Reachability reachabilityWithHostName:@"google.com"];
[reachablity startNotifier];
// reachablity = [Reachability reachabilityForInternetConnection];
NetworkStatus remoteHostStatus = [reachablity currentReachabilityStatus];
if(remoteHostStatus == NotReachable) {
NSLog(@"network not available ");
}
else if (remoteHostStatus == ReachableViaWiFi) {
NSLog(@"connect with wifi");
}
else if (remoteHostStatus == ReachableViaWWAN) {
NSLog(@"Cellulor network ");
}
return netwrokCheck;