gpt4 book ai didi

ios - Swift iOS -AshleyMills Reachability 每隔几秒就会打开和关闭 wifi

转载 作者:行者123 更新时间:2023-11-30 11:32:02 27 4
gpt4 key购买 nike

我从 AshleyMills Reachability 下载了 iOS 示例 Reachability 项目

它有一个 networkStatus 标签,上面写着:WifiNo Connection

其下方有一个 hostNameLabel,上面写着:无主机名google.cominvalidhost

当我在设备上运行该应用程序时,它会按照以下方式每 5 秒重复循环一次连接:

第一个 5 秒:

enter image description here

第二个 5 秒:

enter image description here

第三个​​ 5 秒:

enter image description here

从第一、第二和第三开始循环并不断重复。

我使用家庭 wifi,并且我的互联网连接很强(任何其他应用程序都没有问题)。 为什么会这样不断循环,而不是仅仅停留在 Wifi + google.com(第二个循环)

View Controller 文件:

class ViewController: UIViewController {

let networkStatus: UILabel = {
let label = UILabel()
label.translatesAutoresizingMaskIntoConstraints = false
label.font = UIFont.systemFont(ofSize: 21)
label.textColor = .black
label.numberOfLines = 0
label.sizeToFit()
label.text = "Status"
label.textAlignment = .center
return label
}()

let hostNameLabel: UILabel = {
let label = UILabel()
label.translatesAutoresizingMaskIntoConstraints = false
label.font = UIFont.systemFont(ofSize: 21)
label.textColor = .black
label.numberOfLines = 0
label.sizeToFit()
label.text = "Host"
label.textAlignment = .center
return label
}()

var reachability: Reachability?
let hostNames = [nil, "google.com", "invalidhost"]
var hostIndex = 0

override func viewDidLoad() {
super.viewDidLoad()

setConstraints()
startHost(at: 0)
}

func startHost(at index: Int) {
stopNotifier()
setupReachability(hostNames[index], useClosures: true)
startNotifier()
DispatchQueue.main.asyncAfter(deadline: .now() + 5) {
self.startHost(at: (index + 1) % 3)
}
}

func setupReachability(_ hostName: String?, useClosures: Bool) {
let reachability: Reachability?
if let hostName = hostName {
reachability = Reachability(hostname: hostName)
hostNameLabel.text = hostName
} else {
reachability = Reachability()
hostNameLabel.text = "No host name"
}
self.reachability = reachability
print("--- set up with host name: \(hostNameLabel.text!)")

if useClosures {
reachability?.whenReachable = { reachability in
self.updateLabelColourWhenReachable(reachability)
}
reachability?.whenUnreachable = { reachability in
self.updateLabelColourWhenNotReachable(reachability)
}
} else {
NotificationCenter.default.addObserver(
self,
selector: #selector(reachabilityChanged(_:)),
name: .reachabilityChanged,
object: reachability
)
}
}

func startNotifier() {
print("--- start notifier")
do {
try reachability?.startNotifier()
} catch {
networkStatus.textColor = .red
networkStatus.text = "Unable to start\nnotifier"
return
}
}

func stopNotifier() {
print("--- stop notifier")
reachability?.stopNotifier()
NotificationCenter.default.removeObserver(self, name: .reachabilityChanged, object: nil)
reachability = nil
}

func updateLabelColourWhenReachable(_ reachability: Reachability) {
print("\(reachability.description) - \(reachability.connection)")
if reachability.connection == .wifi {
self.networkStatus.textColor = .green
} else {
self.networkStatus.textColor = .blue
}

self.networkStatus.text = "\(reachability.connection)"
}

func updateLabelColourWhenNotReachable(_ reachability: Reachability) {
print("\(reachability.description) - \(reachability.connection)")

self.networkStatus.textColor = .red

self.networkStatus.text = "\(reachability.connection)"
}

@objc func reachabilityChanged(_ note: Notification) {
let reachability = note.object as! Reachability

if reachability.connection != .none {
updateLabelColourWhenReachable(reachability)
} else {
updateLabelColourWhenNotReachable(reachability)
}
}

func setConstraints(){
view.addSubview(networkStatus)
view.addSubview(hostNameLabel)

networkStatus.leftAnchor.constraint(equalTo: view.leftAnchor, constant: 8).isActive = true
networkStatus.rightAnchor.constraint(equalTo: view.rightAnchor, constant: -8).isActive = true
networkStatus.centerYAnchor.constraint(equalTo: view.centerYAnchor).isActive = true

hostNameLabel.leftAnchor.constraint(equalTo: view.leftAnchor, constant: 8).isActive = true
hostNameLabel.rightAnchor.constraint(equalTo: view.rightAnchor, constant: -8).isActive = true
hostNameLabel.topAnchor.constraint(equalTo: networkStatus.bottomAnchor, constant: 20).isActive = true
}

deinit {
stopNotifier()
}
}

可达性文件:

import SystemConfiguration
import Foundation

public enum ReachabilityError: Error {
case FailedToCreateWithAddress(sockaddr_in)
case FailedToCreateWithHostname(String)
case UnableToSetCallback
case UnableToSetDispatchQueue
}

@available(*, unavailable, renamed: "Notification.Name.reachabilityChanged")
public let ReachabilityChangedNotification = NSNotification.Name("ReachabilityChangedNotification")

extension Notification.Name {
public static let reachabilityChanged = Notification.Name("reachabilityChanged")
}

func callback(reachability: SCNetworkReachability, flags: SCNetworkReachabilityFlags, info: UnsafeMutableRawPointer?) {
guard let info = info else { return }

let reachability = Unmanaged<Reachability>.fromOpaque(info).takeUnretainedValue()
reachability.reachabilityChanged()
}

public class Reachability {

public typealias NetworkReachable = (Reachability) -> ()
public typealias NetworkUnreachable = (Reachability) -> ()

@available(*, unavailable, renamed: "Connection")
public enum NetworkStatus: CustomStringConvertible {
case notReachable, reachableViaWiFi, reachableViaWWAN
public var description: String {
switch self {
case .reachableViaWWAN: return "Cellular"
case .reachableViaWiFi: return "WiFi"
case .notReachable: return "No Connection"
}
}
}

public enum Connection: CustomStringConvertible {
case none, wifi, cellular
public var description: String {
switch self {
case .cellular: return "Cellular"
case .wifi: return "WiFi"
case .none: return "No Connection"
}
}
}

public var whenReachable: NetworkReachable?
public var whenUnreachable: NetworkUnreachable?

@available(*, deprecated: 4.0, renamed: "allowsCellularConnection")
public let reachableOnWWAN: Bool = true

/// Set to `false` to force Reachability.connection to .none when on cellular connection (default value `true`)
public var allowsCellularConnection: Bool

// The notification center on which "reachability changed" events are being posted
public var notificationCenter: NotificationCenter = NotificationCenter.default

@available(*, deprecated: 4.0, renamed: "connection.description")
public var currentReachabilityString: String {
return "\(connection)"
}

@available(*, unavailable, renamed: "connection")
public var currentReachabilityStatus: Connection {
return connection
}

public var connection: Connection {
guard isReachableFlagSet else { return .none }

// If we're reachable, but not on an iOS device (i.e. simulator), we must be on WiFi
guard isRunningOnDevice else { return .wifi }

var connection = Connection.none

if !isConnectionRequiredFlagSet {
connection = .wifi
}

if isConnectionOnTrafficOrDemandFlagSet {
if !isInterventionRequiredFlagSet {
connection = .wifi
}
}

if isOnWWANFlagSet {
if !allowsCellularConnection {
connection = .none
} else {
connection = .cellular
}
}

return connection
}

fileprivate var previousFlags: SCNetworkReachabilityFlags?

fileprivate var isRunningOnDevice: Bool = {
#if targetEnvironment(simulator)
return false
#else
return true
#endif
}()

fileprivate var notifierRunning = false
fileprivate let reachabilityRef: SCNetworkReachability

fileprivate let reachabilitySerialQueue = DispatchQueue(label: "uk.co.ashleymills.reachability")

fileprivate var usingHostname = false

required public init(reachabilityRef: SCNetworkReachability, usingHostname: Bool = false) {
allowsCellularConnection = true
self.reachabilityRef = reachabilityRef
self.usingHostname = usingHostname
}

public convenience init?(hostname: String) {
guard let ref = SCNetworkReachabilityCreateWithName(nil, hostname) else { return nil }
self.init(reachabilityRef: ref, usingHostname: true)
}

public convenience init?() {
var zeroAddress = sockaddr()
zeroAddress.sa_len = UInt8(MemoryLayout<sockaddr>.size)
zeroAddress.sa_family = sa_family_t(AF_INET)

guard let ref = SCNetworkReachabilityCreateWithAddress(nil, &zeroAddress) else { return nil }

self.init(reachabilityRef: ref)
}

deinit {
stopNotifier()
}
}

public extension Reachability {

// MARK: - *** Notifier methods ***
func startNotifier() throws {
guard !notifierRunning else { return }

var context = SCNetworkReachabilityContext(version: 0, info: nil, retain: nil, release: nil, copyDescription: nil)
context.info = UnsafeMutableRawPointer(Unmanaged<Reachability>.passUnretained(self).toOpaque())
if !SCNetworkReachabilitySetCallback(reachabilityRef, callback, &context) {
stopNotifier()
throw ReachabilityError.UnableToSetCallback
}

if !SCNetworkReachabilitySetDispatchQueue(reachabilityRef, reachabilitySerialQueue) {
stopNotifier()
throw ReachabilityError.UnableToSetDispatchQueue
}

// Perform an initial check
reachabilitySerialQueue.async {
self.reachabilityChanged()
}

notifierRunning = true
}

func stopNotifier() {
defer { notifierRunning = false }

SCNetworkReachabilitySetCallback(reachabilityRef, nil, nil)
SCNetworkReachabilitySetDispatchQueue(reachabilityRef, nil)
}

// MARK: - *** Connection test methods ***
@available(*, deprecated: 4.0, message: "Please use `connection != .none`")
var isReachable: Bool {
guard isReachableFlagSet else { return false }

if isConnectionRequiredAndTransientFlagSet {
return false
}

if isRunningOnDevice {
if isOnWWANFlagSet && !reachableOnWWAN {
// We don't want to connect when on cellular connection
return false
}
}

return true
}

@available(*, deprecated: 4.0, message: "Please use `connection == .cellular`")
var isReachableViaWWAN: Bool {
// Check we're not on the simulator, we're REACHABLE and check we're on WWAN
return isRunningOnDevice && isReachableFlagSet && isOnWWANFlagSet
}

@available(*, deprecated: 4.0, message: "Please use `connection == .wifi`")
var isReachableViaWiFi: Bool {
// Check we're reachable
guard isReachableFlagSet else { return false }

// If reachable we're reachable, but not on an iOS device (i.e. simulator), we must be on WiFi
guard isRunningOnDevice else { return true }

// Check we're NOT on WWAN
return !isOnWWANFlagSet
}

var description: String {
let W = isRunningOnDevice ? (isOnWWANFlagSet ? "W" : "-") : "X"
let R = isReachableFlagSet ? "R" : "-"
let c = isConnectionRequiredFlagSet ? "c" : "-"
let t = isTransientConnectionFlagSet ? "t" : "-"
let i = isInterventionRequiredFlagSet ? "i" : "-"
let C = isConnectionOnTrafficFlagSet ? "C" : "-"
let D = isConnectionOnDemandFlagSet ? "D" : "-"
let l = isLocalAddressFlagSet ? "l" : "-"
let d = isDirectFlagSet ? "d" : "-"

return "\(W)\(R) \(c)\(t)\(i)\(C)\(D)\(l)\(d)"
}
}

fileprivate extension Reachability {
func reachabilityChanged() {
guard previousFlags != flags else { return }

let block = connection != .none ? whenReachable : whenUnreachable

DispatchQueue.main.async {
if self.usingHostname {
print("USING HOSTNAME ABOUT TO CALL BLOCK")
}
block?(self)
self.notificationCenter.post(name: .reachabilityChanged, object:self)
}

previousFlags = flags
}

var isOnWWANFlagSet: Bool {
#if os(iOS)
return flags.contains(.isWWAN)
#else
return false
#endif
}
var isReachableFlagSet: Bool {
return flags.contains(.reachable)
}
var isConnectionRequiredFlagSet: Bool {
return flags.contains(.connectionRequired)
}
var isInterventionRequiredFlagSet: Bool {
return flags.contains(.interventionRequired)
}
var isConnectionOnTrafficFlagSet: Bool {
return flags.contains(.connectionOnTraffic)
}
var isConnectionOnDemandFlagSet: Bool {
return flags.contains(.connectionOnDemand)
}
var isConnectionOnTrafficOrDemandFlagSet: Bool {
return !flags.intersection([.connectionOnTraffic, .connectionOnDemand]).isEmpty
}
var isTransientConnectionFlagSet: Bool {
return flags.contains(.transientConnection)
}
var isLocalAddressFlagSet: Bool {
return flags.contains(.isLocalAddress)
}
var isDirectFlagSet: Bool {
return flags.contains(.isDirect)
}
var isConnectionRequiredAndTransientFlagSet: Bool {
return flags.intersection([.connectionRequired, .transientConnection]) == [.connectionRequired, .transientConnection]
}

var flags: SCNetworkReachabilityFlags {
var flags = SCNetworkReachabilityFlags()
if SCNetworkReachabilityGetFlags(reachabilityRef, &flags) {
print("Returning flags \(flags)")
return flags
} else {
return SCNetworkReachabilityFlags()
}
}
}

最佳答案

我查看了代码并找到了答案。在 ViewController 文件中,startHost() 函数中有一个计时器,每 5 秒循环一次。

func startHost(at index: Int) {
stopNotifier()
setupReachability(hostNames[index], useClosures: true)
startNotifier()

// Timer is HERE
DispatchQueue.main.asyncAfter(deadline: .now() + 5) {
self.startHost(at: (index + 1) % 3)
}
}

关于ios - Swift iOS -AshleyMills Reachability 每隔几秒就会打开和关闭 wifi,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/50161115/

27 4 0
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com