Prevent redundant operations in RxSwift

Question

I'm starting my adventure with RxSwift, having small experience with React in js already. I think that my problem is common, but I'm not sure how to describe it in concise abstract way, so instead I will describe it on the example.

I'm building iOS app showing some charts. The part of interest consist of ChartAreaController, ChartInfoController, both embedded in ChartController. First controller is the area showing some graph(based on rx chartData property), and the second one among others will have a slider for user to restrict show x-value (rx selectedXRange property) which is restricted to be between some min and max. The min/max value is defined by the current chart data.

Behavior when slider change updates chart is defined in ChartController:

override func viewDidLoad() {
   super.viewDidLoad()
   (...)
   chartInfoController.selectedXRange.asObservable()
                .subscribe(onNext: { [unowned self] selectedXRange in
                    (...)
                    let chartData = self.filterChartData(from: self.rawChartData, in: selectedXRange)
                    self.chartAreaController.chartData.accept(chartData)
                }).disposed(by: disposeBag)

The filterChartData() method just filters out data that is not in the range, but for the sake of the argument we can assume it is very costly and I don't want it to run twice when it is not necessary.

When user changes the chart he or she wants to show, the new data arrives from server (again ChartController):

private func handleNewData(_ rawChartData: ChartData) {
        self.rawChartData = rawChartData

        guard let allowedXRange = rawChartData.xRange() else { return }
        let selectedXRange = chartInfoController.selectedXRange.value
        let newSelectedXRange = calculateSelectedXRange(currentSelectedDays: selectedDaysRange, availableDaysRange: daysRange)
        let chartData = filterChartData(from: rawChartData, in: selectedXRange)

        self.chartInfoController.allowedXRange = allowedXRange //this line is not crucial
        self.chartInfoController.selectedXRange.accept(newSelectedXRange)

        self.chartAreaController.chartData.accept(rawChartData)
    }

So upon new chart data arrival it may be the case that the currently selected xRange must be trimmed because of the new min/max values of the data. So the side effect of the method will be changing the selectedXRange and in turn running the subscription I pasted earlier. So when new data arrives the chartData is updated twice and I don't want it to happen.

Of course I can comment out last line of the handleNewData() method, but I don't like it very much, since main reason for existence of the handleNewData() is to set chartData, and with the line commented out it's goal would be achieved because of the side effect of the method (which is updating the slider). Not acceptable.

To chartData I added throttle anyways, because fast moving slider will result in many updates and this solves my problem partially(chartData updated only once). But as you may remember the filterChartData() method is costly, and this part will still be running twice.

So the one question is, if my general layout of tackling the problem is OK, or should it be handled way different? At this point I came to conclusion that I'm looking for some way of temporary disabling particular subscription on selectedXRange (without damaging other subscriptions to that variable). Temporary meaning:

(...)
//disable subscription
self.chartInfoController.selectedXRange.accept(newSelectedXRange)
self.chartAreaController.chartData.accept(rawChartData)
//enable subscription
(...)

This seem legit to me, since ChartController as an owner of the subscription and changer of the values may want to disable the subscription whenever it suits him(it?).

Does RxSwift support something like this? If not, then I think I can achieve it myself e.g. via bool property in ChartController, or via adding the subscription to separate disposeBag, which I would dispose and then recreate the subscription. But if it's good thing to do? For example bool solution may be prone to be ill handled when there is some error, and dispose/recreate may be somehow costly, and it may be the case that disposal was not intended to be used like that.

Is there a better practice to handle such situations? As I said I think the problem is common so I hope there is a canonical solution to it :) Thanks for any answer, sorry for the lengthy post.

Answer 1

When We have multiple subscriptions to the same Observable, it will re-execute for each subscription. To stop re-execute for each subscription. RxSwift has several operators for this: share(), replay(), replayAll(), shareReplay(), publish(), and even shareReplayLatestWhileConnected().

read more at (RxSwift: share vs replay vs shareReplay)

Answer 2

So the one question is, if my general layout of tackling the problem is OK, or should it be handled way different?

A properly written UI input element observable will only fire when the user makes a change to the UI, not when the program makes a change. For example: textField.rx.text.orEmpty.subscribe(onNext: { print($0) }) will only print a value when the user types in the textField, not when you call textField.text = "foo" or from a binding .bind(to: textfield.rx.text).

If you wrote the ChartInfoController, I suggest you modify it to work the way the other UI elements do. If you didn't write it, submit an issue to the developer/maintainer.

Does RxSwift support something like [temporarily disabling particular subscription]?

It depends on what you mean by "temporarily disabling". It doesn't support silently unsubscribing and resubscribing but there are plenty of operators that will filter out some events they receive while passing others along. For example filter, throttle, debounce, ignoreElements... There's a lot of them that do that.

Is there a better practice to handle such situations?

Then best solution is mentioned above.