今天带大家解读RxSwift中封装UI事件响应相关的源码：
ControlEvent和ControlProperty
ControlEvent 专门用于描述 UI 控件所产生的事件，ControlProperty专门描述 UI 控件属性，它们具有以下特征：
- 不会产生 error 事件
- 一定在 MainScheduler 订阅（主线程订阅）
- 一定在 MainScheduler 监听（主线程监听）。
这两个都是可观察序列。
两者的区别在于ControlProperty可以作为观察者接受消息，比如他可以作为一个Binder；而ControlEvent不可以。看下面的例子：
btn.rx.tap.subscribe {
print($0)
}
.disposed(by: bag)
textFiled.rx.text.subscribe {
print($0)
}
.disposed(by: bag)
一个Button调用rx.tap转换成一个序列, 在源码中实际上就是包装成一个ControlEvent，这样将Button的点击事件转换成序列，并可通过subscribe订阅这个事件，所以每次点击按钮会打印next事件。
public var tap: ControlEvent<Void> {
controlEvent(.touchUpInside)
}
public func controlEvent(_ controlEvents: UIControl.Event) -> ControlEvent<()> {
let source: Observable<Void> = Observable.create { [weak control = self.base] observer in
MainScheduler.ensureRunningOnMainThread()
guard let control = control else {
observer.on(.completed)
return Disposables.create()
}
let controlTarget = ControlTarget(control: control, controlEvents: controlEvents) { _ in
observer.on(.next(()))
}
return Disposables.create(with: controlTarget.dispose)
}
.take(until: deallocated)
return ControlEvent(events: source)
}
上面的代码将点击事件封装成可观察序列，内部通过Observable.create创建了一个可观察序列，并且将此序列所谓source保存在ControlEvent的对象中。在subscribe handler中，包装一个ControlTarget对象，ControlTarget初始化方法中对UIControl添加点击事件
control.addTarget(self, action: selector, for: controlEvents)
然后处理点击事件。
@objc func eventHandler(_ sender: Control!) {
if let callback = self.callback, let control = self.control {
callback(control)
}
}
在callback的实现中，调用了onNext, 回到调用的地方：
let controlTarget = ControlTarget(control: control, controlEvents: controlEvents) { _ in
observer.on(.next(()))
}
这样就能产生ui点击事件，它将点击事件变换为onNext(())。
ControlEvent是一个结构体，遵循了ControlEventType协议，ControlEventType协议又继承了ObservableType，所以它是一个可观察序列。
除了上面的UIControl，任何对象都可以可序列化，只要遵循了ReactiveCompatible的协议，ReactiveCompatible实现了rx属性的get set方法，通过这种方式创建一个Reactive对象，同时Reactive对象有一个属性base，这个base就是被序列化的对象。
比如 上面的代码 btn.rx 等价于 Reactive(btn), 然后再通过扩展Reactive，创建一个可观察序列即可。
回到例子中的代码继续看textFiled.rx，同样是对UITextFiled转换成Reactive<UITextFiled>类型对象。调用text时调用了controlPropertyWithDefaultEvents
public var value: ControlProperty<String?> {
return base.rx.controlPropertyWithDefaultEvents(
getter: { textField in
textField.text
},
setter: { textField, value in
// This check is important because setting text value always clears control state
// including marked text selection which is imporant for proper input
// when IME input method is used.
if textField.text != value {
textField.text = value
}
}
)
}
传入getter和setter闭包
getter是取出textfiled的text，setter是更新textfiled的text。
public func controlProperty<T>(
editingEvents: UIControl.Event,
getter: @escaping (Base) -> T,
setter: @escaping (Base, T) -> Void
) -> ControlProperty<T> {
let source: Observable<T> = Observable.create { [weak weakControl = base] observer in
guard let control = weakControl else {
observer.on(.completed)
return Disposables.create()
}
observer.on(.next(getter(control)))
let controlTarget = ControlTarget(control: control, controlEvents: editingEvents) { _ in
if let control = weakControl {
observer.on(.next(getter(control)))
}
}
return Disposables.create(with: controlTarget.dispose)
}
.take(until: deallocated)
let bindingObserver = Binder(base, binding: setter)
return ControlProperty<T>(values: source, valueSink: bindingObserver)
}
这里封装了一个ControlProperty，绑定一个Binder。如果当前ControlProperty作为一个Observer，这个Binder才有用。
ControlTarget封装了UITextField的text改变的事件，通过callback通知调用者，然后通过observer.on(.next(getter(control)))将当前UITextFiled的text值发出去。
我们进入ControlProperty结构体看看
public struct ControlProperty<PropertyType> : ControlPropertyType {
public typealias Element = PropertyType
let values: Observable<PropertyType>
let valueSink: AnyObserver<PropertyType>
/...
ControlProperty遵循了ControlPropertyType协议，而ControlPropertyType继承了ObservableType和ObserverType。所以既可以作为可观察序列又可以作为观察者，比如可以作为一个Binder。
作为可订阅序列，如例子中当我们订阅它时，一旦text改变，就可以接受到事件，订阅时执行的是values的订阅方法。订阅逻辑和第一章讲到的订阅逻辑一样，这里不再重述。
ControlProperty包含一个 values和一个valueSink，values是原始的observable，而且保证了在主线程执行subscribe handler。
values.subscribe(on: ConcurrentMainScheduler.instance)
valueSink是一个Binder，ControlProperty实现了on方法：
/// Binds event to user interface.
///
/// - In case next element is received, it is being set to control value.
/// - In case error is received, DEBUG buids raise fatal error, RELEASE builds log event to standard output.
/// - In case sequence completes, nothing happens.
public func on(_ event: Event<Element>) {
switch event {
case .error(let error):
bindingError(error)
case .next:
self.valueSink.on(event)
case .completed:
self.valueSink.on(event)
}
}
如果将ControlProperty作为一个Observer来使用，这里的on方法会接受到事件，同时将next和completed事件转发给valueSink进行处理，valueSink是在初始化ControlProperty赋值的：
let bindingObserver = Binder(base, binding: setter)
return ControlProperty<T>(values: source, valueSink: bindingObserver)
将setter闭包赋值给binding，setter就是最开始创建序列时定义的，用来设置UITextFiled的text
setter: { textField, value in
// This check is important because setting text value always clears control state
// including marked text selection which is imporant for proper input
// when IME input method is used.
if textField.text != value {
textField.text = value
}
}
所以我们进入Binder类看一看：
/// Initializes `Binder`
///
/// - parameter target: Target object.
/// - parameter scheduler: Scheduler used to bind the events.
/// - parameter binding: Binding logic.
public init<Target: AnyObject>(_ target: Target, scheduler: ImmediateSchedulerType = MainScheduler(), binding: @escaping (Target, Value) -> Void) {
weak var weakTarget = target
self.binding = { event in
switch event {
case .next(let element):
_ = scheduler.schedule(element) { element in
if let target = weakTarget {
binding(target, element)
}
return Disposables.create()
}
case .error(let error):
rxFatalErrorInDebug("Binding error: \(error)")
case .completed:
break
}
}
}
/// Binds next element to owner view as described in `binding`.
public func on(_ event: Event<Value>) {
self.binding(event)
}
当调用valueSink的on方法时，会调用binding方法，也就是执行setter方法，完成UITextFiled 的text更新，而且为了保证更新操作再主线程执行，上面代码中默认的调度器是MainScheduler。
下面是一个例子，演示一个UITextField绑定另一个UITextField：
// 两个rx.text 返回的都是ControlProperty对象
let binder = textFiled2.rx.text
textFiled.rx.text.bind(to: binder)
.disposed(by: bag)
UITextFiled 也可以绑定attributedText；代码实现与绑定text类似。
Binder any thing
除了可以绑定UITextFiled，我们可以封装任意属性为一个Binder，比如lable.rx.text, 只需要在对象后面调用.rx.属性名, 这样就转换成一个Binder. 如：
textFiled.rx.text.bind(to: label.rx.text)
.disposed(by: bag)
这样text一旦发生改变，就会降其值赋值给label.text, 这就是绑定。我们看看label.rx.text方法实现
/// Automatically synthesized binder for a key path between the reactive
/// base and one of its properties
public subscript<Property>(dynamicMember keyPath: ReferenceWritableKeyPath<Base, Property>) -> Binder<Property> where Base: AnyObject {
Binder(self.base) { base, value in
base[keyPath: keyPath] = value
}
}
这里利用swift的keypath实现了任意属性的绑定，代码非常简洁巧妙。
然后再看看bind方法实现：
public func bind<Observer: ObserverType>(to observers: Observer...) -> Disposable where Observer.Element == Element {
self.subscribe { event in
observers.forEach { $0.on(event) }
}
}
实际上就是调用订阅方法，而且可以绑定多个Observer。
总结
- ControlProperty 和 ControlEvent都是Observable的变体，它们是对Observable的封装，封装了UI事件，将UI事件封装可观察序列。另外ControlProperty可以作为观察者被绑定。
- Binder是一个观察者，用来和可观察序列进行绑定，绑定实际上是对订阅操作的简化。
