Limiting simultaneous downloads using RxAlamofire

Question

Given my App will download files from a server and I only want 1 download to be progressed at the same time, then how could this be done with RxAlamofire? I might simply be missing an Rx operator. Here's the rough code:

Observable
    .from(paths)
    .flatMapWithIndex({ (ip, idx) -> Observable<(Int, Video)> in
        let v = self.files![ip.row] as! Video
        return Observable.from([(idx, v)])
    })
    .flatMap { (item) -> Observable<Video> in
        let req = URLRequest(url: item.1.downloadURL())

        return Api.alamofireManager()
            .rx
            .download(req, to: { (url, response) -> (destinationURL: URL, options: DownloadRequest.DownloadOptions) in
              ...
            })
            .flatMap({ $0.rx.progress() })
            .flatMap { (progress) -> Observable<Float> in
              // Update a progress bar
              ...
            }
            // Only propagate finished items
            .filter { $0 >= 1.0 } 
            // Return the item itself
            .flatMap { _ in Observable.from([item.1]) }
    }
    .subscribe(
      onNext: { (res) in
        ...
      },
      onError: { (error) in
        ...
      },
      onCompleted: {
        ...
      }
    )

My problem is a) RxAlamofire will download multiple items at the same time and b) the (progress) block is called multiple times for those various items (with different progress infos on each, causing the UI to behave a bit weird).

How to ensure the downloads are done one by one instead of simultaneously?

Answer 1

Does alamofireManager().rx.download() download concurrently or serially?

I'm not sure how it does, so test that first. Isolate this code and see if it does execute multiple downloads at once. If it does, then read up on the documentation for serial downloads instead of concurrent downloads.

If it downloads one at a time, then it means it has something to do with your Rx code that triggers the progress bar update issue. If it doesn't download one at a time, then it means we just need to read up on Alamofire's documentation on how to download one at a time.

Complex transformations and side effects

Something to consider is that your data streams are becoming more complex and difficult to debug because so many things are happening in one stream. Because of the multiple flat maps, there can be a lot more emissions coming out affecting the progress bar update. It is also possible that the numerous flat maps operations that acquired an Observable are the cause for the multiple triggering of the updates on the progress bar.

Complex data streams

In one data stream you (a) performed the network call (b) updated the progress bar (c) filtered finished videos (d) and went back to the video you wanted by using flatMapWithIndex at the start to pair together id and the video model so that you can return back to the model at the end. Kind of complicated... My guess is that the weird progress bar updates might be caused by creating a hot observable on call of $0.rx.progress().

I made a github gist of my Rx Playground that tries to model what you're trying to do.

In functional reactive programming, it would be much more readable and easier to debug if you first define your data streams/observables. In my gist, I began with the observables and how I planned to model the download progress.

This code will avoid the concurrency issues if the RxAlamofire query downloads 1 at a time, and it properly presents the progress value for a UIProgressBar.

Side note

Do you need to track the individual progress downloads per download item? Or do you want your progress bar to just increment per finished download item?

Also, be wary with the possible dangers of misusing a chain of multiple flatMaps as explained here.