社区首页 >专栏 >【iOS】RxSwift官方Example3--地理位置监听

【iOS】RxSwift官方Example3--地理位置监听

MapleYe

发布于 2020-03-31 03:02:02

1.2K00

代码可运行

文章被收录于专栏：MapleYeMapleYe

运行总次数：0

代码可运行

前言

其实，这一篇的题目，我觉得应该是RxSwift对代理的封装，最后还是沿用官方Example的命名吧。

效果说明

图一是当App可以使用定位信息时，显示当前的经纬度。

图二是当App被禁止使用定位信息时，显示的提示信息

代码解释

比起上两个Example，这个Example复杂的多了。主要复杂在对Delegate的封装。

如何使用RxSwift对Delegate的封装稍后再说，先看看封装后的使用。

let service = GeolocationService.instance
        // 将是否允许使用定位的“Bool”绑定noGeolocationView.rx.isHidden
        service.authorized
        .drive(noGeolocationView.rx.isHidden)
        .addDisposableTo(disposeBag)
        // 将定位信息绑定在showLocationLabel.rx.coordinates
        service.location
        .drive(showLocationLabel.rx.coordinates)
        .addDisposableTo(disposeBag)

1、对UILabel的扩展

可以看到上面的例子，将CLLocationCoordinate2D的经纬度信息绑定在label上了。当想绑定的在视图信息越多，我们就需要对UILabel进行扩展。

扩展方法如下：

/*
意思就是当Reactive的Base对象是UILabel时，增加一个类型为UIBindingObserver<Base, CLLocationCoordinate2D>的coordinates属性。
*/ 
private extension Reactive where Base: UILabel {
    var coordinates: UIBindingObserver<Base, CLLocationCoordinate2D> {
        return UIBindingObserver(UIElement: base, binding: { (label, location) in
            label.text = "Lat: \(location.latitude)\nLon: \(location.longitude)"
        })
    }
}

在后面的block参数列表中，label的类型是泛型中的Base类型（例子是UILabel），location是泛型中的CLLocationCoordinate2D对象。因此，我们只要在block中对label和location对象做操作即可。

2、封装CLLocationManagerDelegate

2.1、创建CLLocationManagerDelegate的代理Proxy

为了创建Proxy对象，我们需要继承DelegateProxy，并且遵守DelegateProxyType协议，该协议必须实现以下两个方法。

/// 返回object的代理对象
    class func currentDelegateFor(_ object: AnyObject) -> AnyObject? {
        let locationManager: CLLocationManager = object as! CLLocationManager
        return locationManager.delegate
    }

    /// 设置objct代理对象
    class func setCurrentDelegate(_ delegate: AnyObject?, toObject object: AnyObject) {
        let locationManager: CLLocationManager = object as! CLLocationManager
        if let delegate = delegate {
            locationManager.delegate = (delegate as! CLLocationManagerDelegate)
        } else {
            locationManager.delegate = nil
        }
    }

2.2、创建PublishSubject对象

先来简单回顾一下概念：

subject的概念

Subject可以看做是一种代理和桥梁。它既是订阅者又是订阅源，这意味着它既可以订阅其他Observable对象，同时又可以对它的订阅者们发送事件。

PublishSubject的概念

当你订阅PublishSubject的时候，你只能接收到订阅他之后发生的事件

因此为了能够成为代理的代理，我们需要监听代理的事件，并且能够让外部进行监听，所以我们创建了以下两个publishSubject对象

internal lazy var didUpdateLocationsSubject = PublishSubject<[CLLocation]>()
    internal lazy var didFailWithErrorSubject = PublishSubject<Error>()

将代理事件通过subject传递出去，记得调用_forwardToDelagate?.method方法，因为我们这里只是做了一层监听中转

public func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
        _forwardToDelegate?.locationManager(manager, didUpdateLocations: locations)
        didUpdateLocationsSubject.onNext(locations)
    }

    public func locationManager(_ manager: CLLocationManager, didFailWithError error: Error) {
        _forwardToDelegate?.locationManager(manager, didFailWithError: error)
        didFailWithErrorSubject.onNext(error)
    }

代理和proxy之间的层级关系图：

      +-------------------------------------------+
      |                                           |                           
      | UIView subclass (UIScrollView)            |                           
      |                                           |
      +-----------+-------------------------------+                           
                  |                                                           
                  | Delegate                                                  
                  |                                                           
                  |                                                           
      +-----------v-------------------------------+                           
      |                                           |                           
      | Delegate proxy : DelegateProxyType        +-----+---->  Observable<T1>
      |                , UIScrollViewDelegate     |          |
      +-----------+-------------------------------+     +---->  Observable<T2>
                  |                                     |                     
                  |                                     +---->  Observable<T3>
                  |                                     |                     
                  | forwards events                     |
                  | to custom delegate                  |
                  |                                     v                     
      +-----------v-------------------------------+                           
      |                                           |                           
      | Custom delegate (UIScrollViewDelegate)    |                           
      |                                           |
      +-------------------------------------------+

2.3、对CLLocationManager做扩展

将想被监听的属性，通过刚才创建Proxy传递出来，于是我们只需要创建对应的Observable。

代码如下：

extension Reactive where Base: CLLocationManager {
    /**
     Reactive wrapper for `delegate`.
     
     For more information take a look at `DelegateProxyType` protocol documentation.
     */
    public var delegate: DelegateProxy {
        return RxCLLocationManagerDelegateProxy.proxyForObject(base)
    }
    
    // MARK: Responding to Authorization Changes
    
    /**
     Reactive wrapper for `delegate` message.
     */
    public var didChangeAuthorizationStatus: Observable<CLAuthorizationStatus> {
        return delegate.methodInvoked(#selector(CLLocationManagerDelegate.locationManager(_:didChangeAuthorization:)))
            .map { a in
                let number = try castOrThrow(NSNumber.self, a[1])
                return CLAuthorizationStatus( rawValue: Int32(number.intValue)) ?? .notDetermined
        }
    }
    
    // MARK: Responding to Location Events
    
    /**
     Reactive wrapper for `delegate` message.
     */
    public var didUpdateLocations: Observable<[CLLocation]> {
        return (delegate as! RxCLLocationManagerDelegateProxy).didUpdateLocationsSubject.asObservable()
    }
    
    /**
     Reactive wrapper for `delegate` message.
     */
    public var didFailWithError: Observable<Error> {
        return (delegate as! RxCLLocationManagerDelegateProxy).didFailWithErrorSubject.asObservable()
    }
}

这里值得一提的是调后delegate.methodInvoked，会返回Observable<[Any]>，其中数组装的就是传递给selector的参数，所以后面的map的block中，a[1]代表的就是CLAuthorizationStatus枚举类型。

此外，还定义了一个转类型的函数，转失败后，会发出Error

fileprivate func castOrThrow<T>(_ resultType: T.Type, _ object: Any) throws -> T {
    guard let returnValue = object as? T else {
        throw RxCocoaError.castingError(object: object, targetType: resultType)
    }
    
    return returnValue
}

2.4、定义service层

class GeolocationService {
static let instance = GeolocationService()
private (set) var authorized: Driver<Bool>
private (set) var location: Driver<CLLocationCoordinate2D>

private let locationManager = CLLocationManager()

private init() {
    
    locationManager.distanceFilter = kCLDistanceFilterNone
    locationManager.desiredAccuracy = kCLLocationAccuracyBestForNavigation
    
    // deferred会为每一位订阅者observer创建一个新的可观察序列
    authorized = Observable.deferred { [weak locationManager] in
        let status = CLLocationManager.authorizationStatus()
        guard let locationManager = locationManager else {
            return Observable.just(status)
        }
        return locationManager
            .rx.didChangeAuthorizationStatus
            .startWith(status)
        }
        .asDriver(onErrorJustReturn: CLAuthorizationStatus.notDetermined)
        .map {
            switch $0 {
            case .authorizedAlways:
                return true
            default:
                return false
            }
    }
    
    location = locationManager.rx.didUpdateLocations
        .asDriver(onErrorJustReturn: [])
        .flatMap {
            return $0.last.map(Driver.just) ?? Driver.empty()
        }
        .map { $0.coordinate }
    locationManager.requestAlwaysAuthorization()
    locationManager.startUpdatingLocation()
}
}