rxcocoa学习-ControlEvent等

2017-06-13

ControlEvent

一个结构体，具有observable的特点，代表一个UI上的event。

它具有以下特点：

绝对不会failed（error）
subscription时不会发送任何初始值(publish而不是behavior或者replay)
在control dealloc时收到comple
发送event到MainScheduler。

在他的实现中只保证了最后一点，即调用了subscribeOn(ConcurrentMainScheduler.instance)，其他特点由使用者保证。

public struct ControlEvent<PropertyType> : ControlEventType {
    public typealias E = PropertyType
    let _events: Observable<PropertyType>
    ///初始化，就是传入一个Observable
    public init<Ev: ObservableType>(events: Ev) where Ev.E == E {
    	//保证了在主线程上emit element
        _events = events.subscribeOn(ConcurrentMainScheduler.instance)
    }
    //让这个结构体表现的像一个observable，内部调用真正的observable
    public func subscribe<O : ObserverType>(_ observer: O) -> Disposable where O.E == E {
        return _events.subscribe(observer)
    }
    /// - returns: `Observable` interface.
    public func asObservable() -> Observable<E> {
        return _events
    }
    /// - returns: `ControlEvent` interface.
    public func asControlEvent() -> ControlEvent<E> {
        return self
    }
}

总结就是：只是一个简单的封装。

ControlProperty

一个结构体，具有observable和observer的特点，代表一个UI元素的一个property。

他的特点如下：

不会failed ,error out
具有shareReplay(1)的行为，只要subscribe了他，立马收到最后一个element
Emit event到主线程上

public struct ControlProperty<PropertyType> : ControlPropertyType {
    public typealias E = PropertyType
    //由于同时又observable和observer的特点，那么就都持有一个
    let _values: Observable<PropertyType>
    let _valueSink: AnyObserver<PropertyType>
    //通过一个observable和observer初始化
    public init<V: ObservableType, S: ObserverType>(values: V, valueSink: S) where E == V.E, E == S.E {
        ///保证在主线程上emit
        _values = values.subscribeOn(ConcurrentMainScheduler.instance)
        _valueSink = valueSink.asObserver()
    }
    //observable的特点
    public func subscribe<O : ObserverType>(_ observer: O) -> Disposable where O.E == E {
        return _values.subscribe(observer)
    }
  
    public var changed: ControlEvent<PropertyType> {
        get {
            return ControlEvent(events: _values.skip(1))
        }
    }
    /// - returns: `Observable` interface.
    public func asObservable() -> Observable<E> {
        return _values
    }
    /// - returns: `ControlProperty` interface.
    public func asControlProperty() -> ControlProperty<E> {
        return self
    }
    public func on(_ event: Event<E>) {
        switch event {
        case .error(let error):
            bindingErrorToInterface(error)
        case .next:
            _valueSink.on(event)
        case .completed:
            _valueSink.on(event)
        }
    }
}

ControlTarget

对target-action的封装，由于target-action，需要传入selector，所以需要一个class来提供一个selector。

// This should be only used from `MainScheduler`
RxTarget ---> NSObject , Disposable
final class ControlTarget: RxTarget {
    typealias Callback = (Control) -> Void
    let selector: Selector = #selector(ControlTarget.eventHandler(_:))
    weak var control: Control?
    let controlEvents: UIControlEvents
    var callback: Callback?
    init(control: Control, controlEvents: UIControlEvents, callback: @escaping Callback) {
        MainScheduler.ensureExecutingOnScheduler()
        self.control = control
        self.controlEvents = controlEvents
        self.callback = callback
        super.init()
	    ///初始化时就执行了addTarget操作
        control.addTarget(self, action: selector, for: controlEvents)
        let method = self.method(for: selector)
        if method == nil {
            rxFatalError("Can't find method")
        }
    }
	///通用的selector，具体执行什么由callback决定
    func eventHandler(_ sender: Control!) {
        if let callback = self.callback, let control = self.control {
            callback(control)
        }
    }
    
    // 在dispose时销毁
    override func dispose() {
        super.dispose()
        self.control?.removeTarget(self, action: self.selector, for: self.controlEvents)
        self.callback = nil
    }
}