如何使用 Moya 和 RxSwift 检查互联网？

Question

据我了解，Alamofire 是内置的 Reachability，所以我自己的处理程序看起来像：

import Alamofire

let reachabilityManager = NetworkReachabilityManager()
reachabilityManager.listener = { status in

switch status {

case .notReachable:
 print("The network is not reachable")
 self.onInternetDisconnection()

case .unknown :
 print("It is unknown whether the network is reachable")
 self.onInternetDisconnection() // not sure what to do for this case

case .reachable(.ethernetOrWiFi):
 print("The network is reachable over the WiFi connection")
 self.onInternetConnection()

case .reachable(.wwan):
 print("The network is reachable over the WWAN connection")
 self.onInternetConnection()

 }
}

我正在提出请求：

let provider = MoyaProvider<MyMoyaRequest>()
let token = provider.request(.start(
    username:self.email.value, 
    password: self.password.value) { result in

    switch result { 
    case let .success(moyaResponse):
        //handle success
    case let .failure(error):
        //handle failure
    }
}

如果我想在每个 Moya 请求发出之前检查连接性，那么最好的方法是什么？

1. 为 Moyas 内部的一个扩展编写一个扩展，以首先检查
2. 使用Moya插件（准备）检查
3. 一些花哨的裤子到目前为止还没有想到......

出于可读性原因，我确实不想为每个 API 调用添加可达性检查。但我有兴趣了解以前使用的方法。

感谢您提供的任何帮助。

Answer 1

我特别不想为每个 API 调用添加可达性检查

将所有 API 调用封装到某个服务中可能是一个合理的决定。例如我在上一个应用中是如何做到的：

public protocol NetworkServiceType: class {
    /// Cancellable request
    func observableRequest<T,C>(api: AnyApi<T>, cancel: Observable<C>, headers: [AUApi.Header: String], indicator: ActivityRelay?, logs: NetworkServiceLogs, timeout: TimeInterval, queue: DispatchQueue) -> Observable<Output<T>>
}

如您所见，网络服务有一个函数可以接受所有必要的参数。当您将所有请求包装到一个函数中时 - 您可以在此函数中添加您想要的所有内容。甚至可达性检查！

我想在发出每个 Moya 请求之前检查连接

有一些方法可以做到：

1. 我将创建一个共享的反应式可达性服务并将该服务注入网络服务中。因此，在每次 Moya 请求之前，您都可以致电 withLatestFrom 并从您的可达性服务中获取最新状态。
2. 您可以为每个请求创建可达性服务，并在请求完成后将其删除。

我很乐意向您展示如何创建第二个变体。我们首先需要的是一些ReachabilityInformer:

final class ReachabilityInformer: Disposable {

    private lazy var networkReachabilityManager: NetworkReachabilityManager? = NetworkReachabilityManager(host: "www.google.com")
    private lazy var relayNetworkReachable = PublishRelay<Bool>()

    init() {
        switch networkReachabilityManager {
        case .none:
            relayNetworkReachable.accept(false)
        case .some(let manager):
            manager.listener = { [weak informer = self] status in
                switch status {
                case .notReachable:
                    informer?.relayNetworkReachable.accept(false)
                case .unknown:
                    break
                case .reachable:
                    informer?.relayNetworkReachable.accept(true)
                }
            }
        }
        networkReachabilityManager?.startListening()
    }

    func observableReachable() -> Observable<Bool> {
        return relayNetworkReachable
            .asObservable()
            .distinctUntilChanged()
    }

    func dispose() {
        networkReachabilityManager?.stopListening()
        networkReachabilityManager?.listener = nil
        networkReachabilityManager = nil
    }
}

它应该符合Disposable，因为它将被using操作员使用。

那么，如何使用它：

Observable<Bool>
    .using({ ReachabilityInformer() }, observableFactory: { (informer: ReachabilityInformer) -> Observable<Bool> in
        return informer.observableReachable()
    })

应使用此Observable 启动请求。如果连接存在true，您应该flatMap 到您的 Moya 请求。如果是false，那么你应该返回一个失败或者抛出一个错误。当请求完成时，using 操作员将确保 ReachabilityInformer 被释放。

附：未经测试，只是一些需要考虑的信息