Как узнать, включены или отключены «Данные мобильной сети» (даже при подключении через WiFi) в iOS?

Нет доступных API, с помощью которых приложение может запрашивать, включены ли мобильные данные. Вы можете использовать CTCellularData cellularDataRestrictionDidUpdateNotifier и limitedState, чтобы узнать, включил или отключил ли пользователь доступ к сотовым данным для вашего приложения. Это максимальное количество iOS, которое позволяет приложение. И даже это ненадежно, так как если вы удалите сим-карту из устройства, она все равно даст вам прежний статус ограниченного состояния.

Если вы ориентируетесь на iOS 12 или более позднюю версию, Apple представила (как часть платформы Network) класс NWPathMonitor. Вы можете (как и я) создать два разных монитора, один для сотовой связи, а другой для Wi-Fi:

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(_:) и предоставив последовательные очереди (я предоставил две отдельные очереди); есть причуда, так что, как только вы отмените экземпляр монитора, вы должны создать новый экземпляр, потому что он не может быть перезапущен.

Я думаю, вам нужно переосмыслить все, что вы планируете: вы никогда не сможете определить, будет ли надежное соединение (для данных) доступно в любой момент времени в будущем:

• Пользователь мог отключить передачу данных через своего оператора сотовой связи, поэтому, если WiFi выйдет из строя, сотовое соединение все равно не будет передавать данные.
• Либо пользователь мог сразу изменить это в настройках.
• Либо сотовая связь может прерваться в тот же момент, когда отключается WiFi (при входе в экранированное помещение или что-то в этом роде).
• И многое другое может произойти тем временем в секретной комнате™.

Вам просто придется иметь дело с отключением и обеспечить доброжелательное поведение в таком случае (вместо, например, сбоя).

Некоторое время назад я пытался выяснить, как решить эту проблему, и мне грустно констатировать, что нет 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
    }
}

Я использовал код этого ответа, вы тоже можете его проверить: Отслеживание использования мобильных данных с помощью swift

мое решение выглядит «немного» как излишество, может быть, кому-то оно покажется полезным. Но идея состоит в том, чтобы принять во внимание настройки приложения для мобильных данных пользователей. Он использует синглтон, чтобы избежать двойного запуска, и поддерживает 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;