CODEWITHSUNDEEP
swiftreactive-cocoareactive-cocoa-4
beseder
beseder

Reputation: 1372

Pipe for repeating network requests in Reactive Cocoa 4

I want to refresh data every 15 seconds from an API using Reactive Cocoa 4. Since more than one subscriber can ask for this data at the same time, I want to have multiple subscribers to share one source of data.

My current approach is to have one Signal and share it to every instance that asks for the data. This Signal should start refreshing as soon as the first Signal is subscribed and end after the last has disposed.

SignalProducer<String, NoError> { observer, disposable in
    self.disposable = self.repeatTimer.observeNext { _ in
        NSLog("start network request")
            observer.sendNext("result")
        }
        }.on(disposed: {
            NSLog("disposed")
        }).startWithSignal { signal, disposable1 in
            self.updateSignal = signal
        }
    }

    return (updateSignal, disposable!)

So for the first request I create and store the updateSignal and each following request will get that signal.

My first question: How can I know when the last subscriber disposed its signal? So when can I stop the requests?

My second question: I store the disposable from my repeatin network request in self.disposable which I also return to the subscriber. If the subscriber only disposes its Signal (which he got from Signal.observeNext()) the inner loop, where I log "start network request" is running endless. Do I really need to stop that Signal myself even when the outer Signal gets disposed?

Is there any nicer way or pattern for shared repeating requests?

Upvotes: 0

Views: 809

Answers (1)

JBAction
JBAction

Reputation: 26

Use the global timer function to perform work at specified intervals.

You could do something like this: 

self.disposable = 
    timer(SomeTimeInterval onScheduler:QueueScheduler.mainQueueScheduler)
    .startWithNext { _ in
         //start network request here
    }

But it's better if you chain your network request producer and observe the results, like this: 

self.disposable =
    timer(SomeTimeInterval onScheduler:QueueScheduler.mainQueueScheduler)
    .flatMap(.Latest, transform { _ in 
         return self.networkRequestSignalProducer()
    })
    .start({ event in 
         //monitor the result of the network request
    })

Note that you may not want to use the main queue like I did in this example, depending on how you've implemented your network requests.

If you want to avoid dealing with disposables, you can add a .takeUntil before .flatMap and terminate the timer with a signal

Upvotes: 1

Related Questions