RxSwift-场景序列

简化创建流程
简化订阅流程

ControlEvent

• ControlEvent: 专门用于描述 UI 控件所产生的事件，它具有以下特征
• 不会产生 error 事件
• 一定在 MainScheduler 订阅（主线程订阅）
• 一定在 MainScheduler 监听（主线程监听）
• 会共享附加作用

        let controlEventOB = self.button.rx.controlEvent(.touchUpInside)
        
        controlEventOB.subscribe { (result) in
            print("订阅:\(result)  \(Thread.current)")
        }.disposed(by: self.disposeBag)
        
        controlEventOB.subscribe { (result) in
            print("订阅:\(result)  \(Thread.current)")
            }.disposed(by: self.disposeBag)

订阅:next(())  <NSThread: 0x600001920bc0>{number = 1, name = main}
订阅:next(())  <NSThread: 0x600001920bc0>{number = 1, name = main}

Binder

• 简化订阅流程
• 不会处理错误事件
• 确保绑定都是在给定 Scheduler 上执行（默认 MainScheduler）
• 一旦产生错误事件，在调试环境下将执行 fatalError，在发布环境下将打印错误信息。

//        let observer: AnyObserver<Bool> = AnyObserver{ (event) in
//            print("observer 当前线程：\(Thread.current)")
//            switch event {
//            case .next(let value):
//                self.label.isHidden = value
//                break
//            case .error(let error):
//                print("observer error:\(error)")
//                break
//            case .completed:
//                print("完成了")
//                break
//            }
//        }
        
        let binder = Binder<Bool>(self.label) { (lab, value) in
             print("Binder 当前线程:\(Thread.current)")
            lab.isHidden = value
        }
        
        let observable = Observable<Bool>.create { (ob) -> Disposable in
            ob.onNext(true)
//            ob.onError(NSError.init(domain: "com.imefuture.cn", code: 10090, userInfo: nil))
//            ob.onCompleted()
            return Disposables.create()
        }.observeOn(ConcurrentDispatchQueueScheduler(queue: DispatchQueue.global()))
        
//        observable.bind(to: observer).disposed(by: self.disposeBag)
        observable.bind(to: binder).disposed(by: self.disposeBag)

Driver

• Driver 是一个精心准备的特征序列。它主要是为了简化 UI 层的代码。不过如果你遇到的序列具有以下特征，你也可以使用它：
• 不会产生 error 事件
• 一定在 MainScheduler 监听（主线程监听）
• 会共享附加作用

        let result = self.textFiled.rx.text.orEmpty
            .asDriver() //普通序列转化为
            .throttle(.milliseconds(500))
            .flatMap {
                self.dealWithData(inputText: $0)
                    .asDriver(onErrorJustReturn: "检测到了错误")
        }
        
        result.map { "长度：\(($0 as! String).count)"}
            .drive(self.label.rx.text)
            .disposed(by: disposeBag)
        
        result.map { ($0 as! String) }
            .drive(self.button.rx.title())
            .disposed(by: disposeBag)

    func dealWithData(inputText: String) -> Observable<Any> {
        print("请求网络了 \(Thread.current)")
        return Observable<Any>.create({ (ob) -> Disposable in
            if inputText == "1234" {
                ob.onError(NSError.init(domain: "com.dyz.cn", code: 2019, userInfo: nil))
            }
            DispatchQueue.global().async {
                print("发送之前看看：\(Thread.current)")
                ob.onNext("已经输入：\(inputText)")
                ob.onCompleted()
            }
            return Disposables.create()
        })
    }

Signal

• Signal 和 Driver 相似，唯一的区别是，Driver 会对新观察者回放（重新发送）上一个元素，而 Signal 不会对新观察者回放上一个元素。
• 这个demo运行 label 是有值的,但是对于我们的新的观察者btn是没有值
• 不会产生 error 事件
• 一定在 MainScheduler 监听（主线程监听）
• 会共享附加作用

        let result = self.textFiled.rx.text.orEmpty
            .asSignal(onErrorJustReturn: "没有值")
            .throttle(.milliseconds(500))
            .flatMap {
                self.dealWithData(inputText: $0 )
                    .asSignal(onErrorJustReturn: "检测到了错误")
        }
        
        result.map { "长度：\(($0 as! String).count)" }
            .emit(to: self.label.rx.text)
            .disposed(by: disposeBag)
        
        result.map { ($0 as! String) }
            .emit(to: self.button.rx.title())
            .disposed(by: disposeBag)

Single

• Single 是 Observable 的另外一个版本。不像 Observable 可以发出多个元素，它要么只能发出一个元素，要么产生一个 error 事件。
• 发出一个元素，或一个 error 事件
• 不会共享附加作用

        let singleOB = Single<Any>.create { (single) -> Disposable in
            print("singleOB 是否共享")
            single(.success("Dyz"))
            single(.success("Hello"))
            single(.error(NSError.init(domain: "com.ime.cn", code: 098, userInfo: nil)))
            return Disposables.create()
        }
        
        singleOB.subscribe { (result) in
            print("订阅：\(result)")
        }.disposed(by: self.disposeBag)
        singleOB.subscribe { (result) in
            print("订阅：\(result)")
        }.disposed(by: self.disposeBag)

singleOB 是否共享
订阅：success("Dyz")
singleOB 是否共享
订阅：success("Dyz")

Completable

• Completable 是 Observable 的另外一个版本。不像 Observable 可以发出多个元素，它要么只能产生一个 completed 事件，要么产生一个 error 事件
• 发出零个元素
• 发出一个 completed 元素，或一个 error 事件
• 不会共享附加作用
• Completable 适用于那种你只关心任务是否完成，而不需要在意任务返回值的情况。它和 Observable<Void> 有点相似。

        let completableOB = Completable.create { (completable) -> Disposable in
            print("completableOB 是否共享")
            completable(.completed)
            completable(.error(NSError.init(domain: "com.ime.cn", code: 909, userInfo: nil)))
            return Disposables.create()
        }
        
        completableOB.subscribe { (result) in
            print("订阅:\(result)")
        }.disposed(by: disposeBag)
        
        completableOB.subscribe { (result) in
            print("订阅:\(result)")
        }.disposed(by: disposeBag)

completableOB 是否共享
订阅:completed
completableOB 是否共享
订阅:completed

Maybe

• Maybe 是 Observable 的另外一个版本。它介于 Single 和 Completable 之间，它要么只能发出一个元素，要么产生一个 completed 事件，要么产生一个 error 事件。
• 发出一个元素或者一个 completed 事件或者一个 error 事件
• 不会共享附加作用
• 如果你遇到那种可能需要发出一个元素，又可能不需要发出时，就可以使用 Maybe。

        let maybeOB = Maybe<Any>.create { (maybe) -> Disposable in
            print("maybeOB 是否共享")
            maybe(.success("dyz"))
            maybe(.completed)
            maybe(.error(NSError.init(domain: "com.ime.cn", code: 89, userInfo: nil)))
            return Disposables.create()
        }
        
        maybeOB.subscribe { (result) in
            print("订阅:\(result)")
        }.disposed(by: disposeBag)
        
        maybeOB.subscribe { (result) in
            print("订阅:\(result)")
        }.disposed(by: disposeBag)

maybeOB 是否共享
订阅:success("dyz")
maybeOB 是否共享
订阅:success("dyz")