Problem about the usage of `withLatestFrom` - rx-swift

Question

I am a newbie to RxSwift. I ran into a problem
The requirement is like this,
If there are values return from stream A, B and C then I emit an event on stream X (boolean)
Whenever there is true value returns from streamX, I want to take a take a snapshot of stream A, B and C and do something
Due to class design reason, we need to separate the action 1 and 2 into two Rx blocks
below is the simplified version of my code
class parent {
let streamA: BehaviorRelay<String?> = BehaviorRelay(value: nil)
let streamB: BehaviorRelay<String?> = BehaviorRelay(value: nil)
let streamC: BehaviorRelay<String?> = BehaviorRelay(value: nil)
let moduleVisibility: BehaviorRelay<Bool?> = BehaviorRelay(value: nil)
BehaviorRelay.combineLatest(streamA.filterNil(), streamB.filterNil(), streamB.filterNil()).subscribe { [weak self ] _, _, _ in
guard let self = self else { return }
self.moduleVisibility.accept(true)
}.disposed(by: bag)
}
class childClass {
moduleVisibility.filterNil().filter({ $0 == true}).withLatestFrom(Observable.combineLatest(streamA.filterNil(), streamB.filterNil(), streamC.filterNil())).observeOn(MainScheduler.instance).subscribe(onNext: { valueA, valueB, valueC in
// This line does not get called
print("\(valueA) \(valueB) \(valueC)")
}).disposed(by: bag)
}
// then I called
streamA.accept("A")
streamB.accept("B")
streamC.accept("C")
// but the block # childClass does not get fired
I check there is event from the moduleVisibility stream. but it says that there is not value from withLatestFrom block.
Would like to know if my block setup is not correct.
Cause I think A B C are causing the event of X
while there is event from X, there must be values from A B C
or I need to observe on main.thread? any help will be appreciated :pray

Answer 1

formatted code
import RxSwift
import RxCocoa
func ignoreNil<A>(x: A?) -> Observable<A> {
return x.map { Observable.just($0) } ?? Observable.empty()
}
class Parent {
let bag = DisposeBag()
let streamA: BehaviorRelay<String?> = BehaviorRelay(value: nil)
let streamB: BehaviorRelay<String?> = BehaviorRelay(value: nil)
let streamC: BehaviorRelay<String?> = BehaviorRelay(value: nil)
let moduleVisibility: BehaviorRelay<Bool?> = BehaviorRelay(value: nil)
init() {
BehaviorRelay
.combineLatest(
streamA.flatMap(ignoreNil),
streamB.flatMap(ignoreNil),
streamC.flatMap(ignoreNil)
).subscribe { [weak self ] _, _, _ in
guard let self = self else { return }
print("moduleVisibility ")
self.moduleVisibility.accept(true)
}.disposed(by: bag)
}
}
class Child: Parent {
override init() {
super.init()
moduleVisibility
.flatMap(ignoreNil)
.filter({ $0 == true})
.withLatestFrom(
Observable.combineLatest(
streamA,
streamB,
streamC
)
)
.subscribe(onNext: { valueA, valueB, valueC in
// This line does not get called
print("\(valueA) \(valueB) \(valueC)")
}).disposed(by: bag)
}
}
let child = Child()
child.streamA.accept("A")
child.streamB.accept("B")
child.streamC.accept("C")
/*
moduleVisibility
Optional("A") Optional("B") nil
*/

Answer 2

Notice in the code below how the functions I created mirror the text descriptions almost exactly. That is what you should be striving for. No need for any classes here, just a couple of functions (these functions are your view models.) Notice how they are very reusable...
// If there are values return from stream A, B and C then I emit an event on stream X (boolean)
func allEmitedValue<A, B, C>(_ a: Observable<A?>, _ b: Observable<B?>, _ c: Observable<C?>) -> Observable<Bool> {
Observable.combineLatest(a, b, c) { allContainValue($0, $1, $2) }
}
// Whenever there is true value returns from streamX, I want to take a take a snapshot of stream A, B and C and do something
func snapshot<A, B, C>(_ a: Observable<A?>, _ b: Observable<B?>, _ c: Observable<C?>) -> Observable<(A, B, C)> {
Observable.combineLatest(a, b, c)
.compactMap{ allContainValue($0.0, $0.1, $0.2) ? ($0.0!, $0.1!, $0.2!) : nil }
}
func allContainValue<A, B, C>(_ a: A?, _ b: B?, _ c: C?) -> Bool {
a != nil && b != nil && c != nil
}
If the architecture requires that you put these in classes with relays then:
class parent {
let streamA: BehaviorRelay<String?> = BehaviorRelay(value: nil)
let streamB: BehaviorRelay<String?> = BehaviorRelay(value: nil)
let streamC: BehaviorRelay<String?> = BehaviorRelay(value: nil)
let moduleVisibility: Observable<Bool>
init() {
moduleVisibility = allEmitedValue(streamA.asObservable(), streamB.asObservable(), streamC.asObservable())
}
}
class childClass: parent {
let bag = DisposeBag()
override init() {
super.init()
snapshot(streamA.asObservable(), streamB.asObservable(), streamC.asObservable())
.observe(on: MainScheduler.instance)
.subscribe(onNext: { valueA, valueB, valueC in
// now it gets called.
print("\(valueA) \(valueB) \(valueC)")
})
.disposed(by: bag)
}
}
But note:
Avoid the use of the subject types [Including Relays]. Rx is effectively a functional programming paradigm. Using subjects [or Relays] means we are now managing state, which is potentially mutating. Dealing with both mutating state and asynchronous programming at the same time is very hard to get right. Furthermore, many of the operators (extension methods) have been carefully written to ensure that correct and consistent lifetime of subscriptions and sequences is maintained; when you introduce subjects, you can break this. -- Intro to Rx
Specifically in this case, that observe(on:) is woefully inadequate in ensuring that this code handles threads correctly.