ReactiveCocoa 5, ReactiveSwift network sub-request handling & best practice

Question

I'm trying to find best practice to handle multiple sub-requests per each value got from parent request. I'm trying to use the same logic as here - Reactive Cocoa 5 and ReactiveSwift network requests handling, but have some problems.

What we have and need:
1. TableView with infinite scrolling handler (SVPullToRefresh)
2. Fetch list of objects each time handler is called
3. Send "sub-request" for each object from response

Notes:
1. All requests (parent + sub-requests) should become cancelled once viewController is closed (deinit called)
2. I need to have an ability to cancel parent request at any time. This should also cancel all sub-requests.

What I currently have

I know what I do in "infinite handler" is kinda "duct tape", but I'm new with ReactiveSwift...

self.tableView.addInfiniteScrollingWithActionHandler { [unowned self] in
    self.tempMutableProperty.value = true
}

self.tempMutableProperty.producer.skipNil().flatMap(.latest) { [unowned self] tempValueThatIDontNeed in
    return self.producerForParentRequest(offset: self.offset)
        .take(during: self.reactive.lifetime)
        .on(
            // handlers for errors, completed, etc
            value: { [unowned self] items in
                self.items.append(items)
                self.tableView.reloadData()
                self.offset += items.count
                // SEND REQUEST #2 FOR EACH ITEM
            }
    ).flatMapError { error in
        return SignalProducer.empty
    }
}.observe(on: UIScheduler().start()

So, as you see, I have pagination with tableView. I'm fetching list of objects for each page. Then for each item from response I need to fetch an additional information with request #2.

---

Flow and problems:
1. Of course I want to get rid of tempMutableProperty and somehow start new parent request without some kinda of proxy
2. Each sub-request should be independent, which means I want to have value/error handler called for each sub-request separately, and NOT like it waits for all 10 sub-requests and then call success handler with all 10 responses collected. Also, fail on some specific sub-request should not affect on other sub-requests running
3. User can change his search request without waiting for whole request process beeing completed. This mean that once user changes some parameters, I will clear all items, and I need to cancel parent request within all sub-requests and start this all again.
4. In addition to #2, sometimes user can scroll down to fetch new portion of items. This will mean that new parent request should start, but sub-requests from previous response of parent request should continue working
5. All requests should become cancelled on self.deinit, so this all should work only during self.lifetime, but I'm not sure what is the correct place to put this parameter

I'm not sure if this all is possible without storing disposable/signals as properties of self, so that's not a problem if sub-request will be somehow stored as properties.

---

Thank you all for your help

Answer 1

So, I will post here solutions for my problems.

For point #1 I've made this:

let disposable = SerialDisposable()

self.tableView.addInfiniteScrolling(actionHandler: { [unowned self] in
    self.disposable.inner = nil // this is needed to force dispose current request before starting new one
    self.disposable.inner = self.producer().take(during: self.reactive.lifetime)
        .on(value: { [unowned self] value in
            // handle as you want
        }).start()
})

This helped me to get rid of tempMutableProperty. Instead of flatMap the SerialDisposable is used. So, this works fine for me, and it disposed request automatically when self is getting destroyed

For other points I've made this:

The idea was that I'm loading some items for table, then I need to send additional request per item to fetch detailed information for it. So, I created class, having 3 properties - item, itemDetail, requestSent.

Then in willDisplay cell I have

func tableView(_ tableView: UITableView, willDisplay cell: UITableViewCell, forRowAt indexPath: IndexPath) {
    if !self.items[indexPath.row].requestSent {
        self.items[indexPath.row].details <~ self.detailedProducerForItemID(self.items[indexPath.row].item.id)
        self.items[indexPath.row].requestSent = true
    }
}

Note: self.items[indexPath.row].details is a MutableProperty<Details?>

In the cell itself for representing details I have something like:

let (detailsSignal, detailsObserver) = Signal<MutableProperty<Details?>, NoError>.pipe(), where Details is the name of class for item's details.

In cell's awakeFromNib:

let details = self.detailsSignal.flatMap(.latest) { $0.producer }

self.detailsLabel.reactive.text <~ details.map { value -> String? in
    // handling `Details`
}

And in cellForRow I call cell.detailsObserver.send(value: self.items[indexPath.row].details)

And, when VC's deinit is called, or I perform a new main request, all requests are automatically getting cancelled, since when I use self.items.removeAll() it dispose all requests.

This is rough flow. If someone is interested in more details, don't hesitate to ask.

Answer 2

For part 1, I would add an extension that turns the infinite scrolling action handling into a Signal:

extension Reactive where Base: UITableView {
    public func infiniteScrollingSignal() -> Signal<Void, NoError>
    {
        return Signal { [unowned base = self.base] observer in
            base.addInfiniteScrollingWithActionHandler  {
                observer.send(value: ())
            }

            return ActionDisposable {
                // Unsubscribe the infinite scrolling action handler here if necessary
            }
        }
        .take(during: self.lifetime)
    }
}

Then you can hook up all of your logic to self.tableView.reactive.infiniteScrollingSignal()