iOS开发-Reachability实时检测Wifi,2G/3G/4G/网络状态

简介:

最近遇到一个功能就是根据用户当前的网络状,用户未联网需要提示一下,如果是Wifi可以推荐一些图片新闻,如果是3G模式设置为无图的模式,获取网络状态比较简单,毕竟中国现在的流量还是一个比较贵的状态,哪天用户发现App消耗流量过多说不定就干掉了App不过苹果的Reachability都解决了以上问题,使用起来也比较方便,具体的稍微简单分析一下。

Reachability.h头文件代码:

 

 

Reachability.m文件:

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
#import <arpa/inet.h>
#import <ifaddrs.h>
#import <netdb.h>
#import <sys/socket.h>
#import <CoreFoundation/CoreFoundation.h>
#import "Reachability.h"
 
 
NSString  *kReachabilityChangedNotification = @ "kNetworkReachabilityChangedNotification" ;
 
 
#pragma mark - Supporting functions
 
#define kShouldPrintReachabilityFlags 1
 
static  void  PrintReachabilityFlags(SCNetworkReachabilityFlags flags,  const  char * comment)
{
#if kShouldPrintReachabilityFlags
 
     NSLog (@ "Reachability Flag Status: %c%c %c%c%c%c%c%c%c %s\n" ,
           //当前网络2G/3G/4G蜂窝网络
           (flags & kSCNetworkReachabilityFlagsIsWWAN)               ?  'W'  '-' ,
           //网络是否可达
           (flags & kSCNetworkReachabilityFlagsReachable)            ?  'R'  '-' ,
 
           (flags & kSCNetworkReachabilityFlagsTransientConnection)  ?  't'  '-' ,
           (flags & kSCNetworkReachabilityFlagsConnectionRequired)   ?  'c'  '-' ,
           (flags & kSCNetworkReachabilityFlagsConnectionOnTraffic)  ?  'C'  '-' ,
           (flags & kSCNetworkReachabilityFlagsInterventionRequired) ?  'i'  '-' ,
           (flags & kSCNetworkReachabilityFlagsConnectionOnDemand)   ?  'D'  '-' ,
           (flags & kSCNetworkReachabilityFlagsIsLocalAddress)       ?  'l'  '-' ,
           (flags & kSCNetworkReachabilityFlagsIsDirect)             ?  'd'  '-' ,
           comment
           );
#endif
}
 
 
static  void  ReachabilityCallback(SCNetworkReachabilityRef target, SCNetworkReachabilityFlags flags,  void * info)
{
#pragma unused (target, flags)
     NSCAssert (info !=  NULL , @ "info was NULL in ReachabilityCallback" );
     NSCAssert ([(__bridge  NSObject *) info isKindOfClass: [Reachability  class ]], @ "info was wrong class in ReachabilityCallback" );
     //http://www.cnblogs.com/xiaofeixiang
     Reachability* noteObject = (__bridge Reachability *)info;
     // Post a notification to notify the client that the network reachability changed.
     [[ NSNotificationCenter  defaultCenter] postNotificationName: kReachabilityChangedNotification object: noteObject];
}
 
 
#pragma mark - Reachability implementation
 
@implementation  Reachability
{
     BOOL  _alwaysReturnLocalWiFiStatus;  //default is NO
     SCNetworkReachabilityRef _reachabilityRef;
}
//通过域名进行实例化  博客园-Fly_Elephant
+ (instancetype)reachabilityWithHostName:( NSString  *)hostName
{
     Reachability* returnValue =  NULL ;
     SCNetworkReachabilityRef reachability = SCNetworkReachabilityCreateWithName( NULL , [hostName UTF8String]);
     if  (reachability !=  NULL )
     {
         returnValue= [[ self  alloc] init];
         if  (returnValue !=  NULL )
         {
             returnValue->_reachabilityRef = reachability;
             returnValue->_alwaysReturnLocalWiFiStatus =  NO ;
         }
     }
     return  returnValue;
}
 
//通过ip地址实例化Reachability
+ (instancetype)reachabilityWithAddress:( const  struct  sockaddr_in *)hostAddress
{
     SCNetworkReachabilityRef reachability = SCNetworkReachabilityCreateWithAddress(kCFAllocatorDefault, ( const  struct  sockaddr *)hostAddress);
 
     Reachability* returnValue =  NULL ;
 
     if  (reachability !=  NULL )
     {
         returnValue = [[ self  alloc] init];
         if  (returnValue !=  NULL )
         {
             returnValue->_reachabilityRef = reachability;
             returnValue->_alwaysReturnLocalWiFiStatus =  NO ;
         }
     }
     return  returnValue;
}
 
 
//检测是否能够直接连上互联网
+ (instancetype)reachabilityForInternetConnection
{
     struct  sockaddr_in zeroAddress;
     bzero(&zeroAddress,  sizeof (zeroAddress));
     zeroAddress.sin_len =  sizeof (zeroAddress);
     zeroAddress.sin_family = AF_INET;
     
     return  [ self  reachabilityWithAddress:&zeroAddress];
}
 
//检测当前网络是否能够联上wifi
+ (instancetype)reachabilityForLocalWiFi
{
     struct  sockaddr_in localWifiAddress;
     bzero(&localWifiAddress,  sizeof (localWifiAddress));
     localWifiAddress.sin_len =  sizeof (localWifiAddress);
     localWifiAddress.sin_family = AF_INET;
 
     // IN_LINKLOCALNETNUM is defined in <netinet/in.h> as 169.254.0.0.
     localWifiAddress.sin_addr.s_addr = htonl(IN_LINKLOCALNETNUM);
 
     Reachability* returnValue = [ self  reachabilityWithAddress: &localWifiAddress];
     if  (returnValue !=  NULL )
     {
         returnValue->_alwaysReturnLocalWiFiStatus =  YES ;
     }
     
     return  returnValue;
}
 
 
#pragma mark - Start and stop notifier
 
- ( BOOL )startNotifier
{
     BOOL  returnValue =  NO ;
 
     SCNetworkReachabilityContext context = {0, (__bridge  void  *)( self ),  NULL NULL NULL };
     //SCNetworkReachabilitySetCallback函数为指定一个target
     //当设备对于这个target链接状态发生改变时(比如断开链接,或者重新连上),则回调reachabilityCallback函数,
     if  (SCNetworkReachabilitySetCallback(_reachabilityRef, ReachabilityCallback, &context))
     {
         if  (SCNetworkReachabilityScheduleWithRunLoop(_reachabilityRef, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode))
         {
             returnValue =  YES ;
         }
     }
     
     return  returnValue;
}
 
 
- ( void )stopNotifier
{
     if  (_reachabilityRef !=  NULL )
     {
         SCNetworkReachabilityUnscheduleFromRunLoop(_reachabilityRef, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);
     }
}
 
 
- ( void )dealloc
{
     [ self  stopNotifier];
     if  (_reachabilityRef !=  NULL )
     {
         CFRelease(_reachabilityRef);
     }
}
 
 
#pragma mark - Network Flag Handling
 
- (NetworkStatus)localWiFiStatusForFlags:(SCNetworkReachabilityFlags)flags
{
     PrintReachabilityFlags(flags,  "localWiFiStatusForFlags" );
     NetworkStatus returnValue = NotReachable;
 
     if  ((flags & kSCNetworkReachabilityFlagsReachable) && (flags & kSCNetworkReachabilityFlagsIsDirect))
     {
         returnValue = ReachableViaWiFi;
     }
     
     return  returnValue;
}
 
 
- (NetworkStatus)networkStatusForFlags:(SCNetworkReachabilityFlags)flags
{
     PrintReachabilityFlags(flags,  "networkStatusForFlags" );
     if  ((flags & kSCNetworkReachabilityFlagsReachable) == 0)
     {
         // The target host is not reachable.
         return  NotReachable;
     }
 
     NetworkStatus returnValue = NotReachable;
 
     if  ((flags & kSCNetworkReachabilityFlagsConnectionRequired) == 0)
     {
         /*
          If the target host is reachable and no connection is required then we'll assume (for now) that you're on Wi-Fi...
          */
         returnValue = ReachableViaWiFi;
     }
 
     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...
              */
             returnValue = ReachableViaWiFi;
         }
     }
 
     if  ((flags & kSCNetworkReachabilityFlagsIsWWAN) == kSCNetworkReachabilityFlagsIsWWAN)
     {
         /*
          ... but WWAN connections are OK if the calling application is using the CFNetwork APIs.
          */
         returnValue = ReachableViaWWAN;
     }
     
     return  returnValue;
}
 
 
- ( BOOL )connectionRequired
{
     NSAssert (_reachabilityRef !=  NULL , @ "connectionRequired called with NULL reachabilityRef" );
     SCNetworkReachabilityFlags flags;
 
     if  (SCNetworkReachabilityGetFlags(_reachabilityRef, &flags))
     {
         return  (flags & kSCNetworkReachabilityFlagsConnectionRequired);
     }
 
     return  NO ;
}
 
//获取当前网络状态
- (NetworkStatus)currentReachabilityStatus
{
     NSAssert (_reachabilityRef !=  NULL , @ "currentNetworkStatus called with NULL SCNetworkReachabilityRef" );
     NetworkStatus returnValue = NotReachable;
     SCNetworkReachabilityFlags flags;
     
     if  (SCNetworkReachabilityGetFlags(_reachabilityRef, &flags))
     {
         if  (_alwaysReturnLocalWiFiStatus)
         {
             returnValue = [ self  localWiFiStatusForFlags:flags];
         }
         else
         {
             returnValue = [ self  networkStatusForFlags:flags];
         }
     }
     
     return  returnValue;
}
 
 
@end

AppDelegate中的实现:

1
2
3
4
5
6
7
8
9
10
- ( BOOL )application:(UIApplication *)application didFinishLaunchingWithOptions:( NSDictionary  *)launchOptions {
     //添加一个系统通知
     [[ NSNotificationCenter  defaultCenter] addObserver: self  selector: @selector (reachabilityChanged:) name:kReachabilityChangedNotification object: nil ];
     //初始化
     self .internetReachability=[Reachability reachabilityForInternetConnection];
     //通知添加到Run Loop
     [ self .internetReachability startNotifier];
     [ self  updateInterfaceWithReachability:_internetReachability];
     return  YES ;
}

回调函数:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
- ( void ) reachabilityChanged:( NSNotification  *)note
{
     Reachability* curReach = [note object];
     NSParameterAssert ([curReach isKindOfClass:[Reachability  class ]]);
     [ self  updateInterfaceWithReachability:curReach];
}
 
- ( void )updateInterfaceWithReachability:(Reachability *)reachability
{
     NetworkStatus netStatus = [reachability currentReachabilityStatus];
     switch  (netStatus) {
         case  NotReachable:
             NSLog (@ "====当前网络状态不可达=======http://www.cnblogs.com/xiaofeixiang" );
             break ;
         case  ReachableViaWiFi:
             NSLog (@ "====当前网络状态为Wifi=======博客园-Fly_Elephant" );
             break ;
         case  ReachableViaWWAN:
             NSLog (@ "====当前网络状态为3G=======keso" );
             break ;
     }
}

 模式测试 Wifi模式-wuWifi-连接Wifi,显示结果如下:

如果直接通过host实例化也可以:

1
2
NSString  *remoteHostName = @ "www.cnblogs.com/xiaofeixiang" ;
self .hostReachability = [Reachability reachabilityWithHostName:remoteHostName];  
本文转自Fly_Elephant博客园博客,原文链接:http://www.cnblogs.com/xiaofeixiang/p/4472343.html,如需转载请自行联系原作者
相关文章
|
3天前
|
监控 5G
GPRS与4G网络:技术差异与应用选择
GPRS与4G在移动通信中各有重要地位,但4G(如LTE)以其高达1Gbps的速度、低延迟及优化的高带宽应用(如视频监控)超越了GPRS的几十Kbps速度。5G的兴起将进一步革新通信,带来更快、更智能的服务。选择技术需依据实际需求。
|
30天前
|
移动开发 网络协议 安全
iOS审核在ipv6网络下无法访问服务器的问题及解决方案
iOS审核在ipv6网络下无法访问服务器的问题及解决方案
38 0
|
1月前
|
边缘计算 物联网 5G
4G 网络跟 5G 的区别
4G 网络跟 5G 的区别
43 0
|
1月前
|
XML JSON API
IOS网络编程:介绍一下 Alamofire 库。
IOS网络编程:介绍一下 Alamofire 库。
54 3
|
1月前
|
缓存 JSON API
IOS网络编程:什么是 RESTful API?如何使用 RESTful 风格设计 API?
IOS网络编程:什么是 RESTful API?如何使用 RESTful 风格设计 API?
65 3
|
1月前
|
缓存 iOS开发
IOS网络编程:使用 URLSession 实现网络请求的步骤是什么?
IOS网络编程:使用 URLSession 实现网络请求的步骤是什么?
44 1
|
iOS开发
ios 快速判断当前网络状态(三种方法)
1️⃣-利用AFN框架 //1.创建网络状态监测管理者 AFNetworkReachabilityManager *manager = [AFNetworkReachabilityManager  sharedManager]; //2.
1594 0
|
18小时前
|
iOS开发 开发者 容器
探索iOS开发中的SwiftUI框架
【6月更文挑战第21天】本文深入探讨了苹果在iOS开发中推出的SwiftUI框架,旨在为开发者提供一种声明式、更简洁的界面设计方法。文章首先概述了SwiftUI的核心概念和优势,接着通过一个天气预报应用实例,详细讲解了如何使用SwiftUI进行布局和用户界面的设计。此外,还讨论了SwiftUI与UIKit的差异,以及如何将SwiftUI集成到现有的项目中。最后,文章展望了SwiftUI的未来发展方向,包括潜在的改进和新特性。
|
1天前
|
安全 Android开发 iOS开发
探索安卓与iOS开发的差异:平台特性与用户体验的对比分析
移动应用开发的两大阵营——安卓与iOS,各自拥有独特的开发环境、用户群体和市场定位。本文将深入探讨这两个操作系统在应用开发过程中的主要差异,包括编程语言、开发工具、用户界面设计、性能优化、安全性考量以及发布流程等方面。通过比较分析,旨在为开发者提供跨平台开发的见解和策略,以优化应用性能和提升用户体验。
7 0

热门文章

最新文章