RxSwift: How to create cache for last network response without creating class/struct property?

Question

I'm working on iOS App that uses the IP Stack API for geolocation. I'd like to optimise the IP Stack Api usage by asking for external (public) IP address first and then re-use lat response for that IP if it hasn't changed.

So what I'm after is that I ask every time the https://www.ipify.org about external IP, then ask https://ipstack.com with given IP address. If I ask the second time but IP doesn't changed then re-use last response (or actually cached dictionary with IP's as keys and responses as values).

I have a solution but I'm not happy with this cache property in my code. It is some state and some other part of code can mutate this. I was thinking about using some scan() operator in RxSwfit but I just can't figure out any new ideas.

class ViewController: UIViewController {
    @IBOutlet var geoButton: UIButton!

    let disposeBag = DisposeBag()
    let API_KEY = "my_private_API_KEY"

    let provider = PublicIPProvider()
    var cachedResponse: [String: Any] = [:] // <-- THIS

    override func viewDidLoad() {
        super.viewDidLoad()
    }

    @IBAction func geoButtonTapped(_ sender: UIButton) {

        // my IP provider for ipify.org
        // .flatMap to ignore all nil values,
        // $0 - my structure to contains IP address as string
        let fetchedIP = provider.currentPublicIP()
            .timeout(3.0, scheduler: MainScheduler.instance)
            .flatMapLatest { Observable.from(optional: $0.ip) }
            .distinctUntilChanged()

        // excuse me my barbaric URL creation, it's just for demonstration
        let geoLocalization = fetchedIP
            .flatMapLatest { ip -> Observable<Any> in
                // check if cache contains response for given IP address
                guard let lastResponse = self.cachedResponse[ip] else {
                    return URLSession.shared.rx.json(request: URLRequest(url: URL(string: "http://api.ipstack.com/\(ip)?access_key=\(API_KEY)")! ))
                        .do(onNext: { result in
                            // store cache as a "side effect"
                            print("My result 1: \(result)")
                            self.cachedResponse[ip] = result
                        })
                }

                return Observable.just(lastResponse)
        }

        geoLocalization
            .subscribe(onNext: { result in
                print("My result 2: \(result)")
            })
            .disposed(by: disposeBag)
    }
}

Is it possible to achieve the same functionality but without var cachedResponse: [String: Any] = [:] property in my class?

Answer 1

OMG! I spent a bunch of time with the answer for this question (see below) and then realized that there is a much simpler solution. Just pass the correct caching parameter in your URLRequest and you can do away with the internal cache completely! I left the original answer because I also do a general review of your code.

class ViewController: UIViewController {
    let disposeBag = DisposeBag()
    let API_KEY = "my_private_API_KEY"

    let provider = PublicIPProvider()

    @IBAction func geoButtonTapped(_ sender: UIButton) {
        // my IP provider for ipify.org
        let fetchedIP: Maybe<String> = provider.currentPublicIP() // `currentPublicIP()` returns a Single
            .timeout(3.0, scheduler: MainScheduler.instance)
            .map { $0.ip ?? "" }
            .filter { !$0.isEmpty }

        // excuse me my barbaric URL creation, it's just for demonstration
        let geoLocalization = fetchedIP
            .flatMap { (ip) -> Maybe<Any> in
                let url = URL(string: "http://api.ipstack.com/\(ip)?access_key=cce3a2a23ce22922afc229b154d08393")!
                return URLSession.shared.rx.json(request: URLRequest(url: url, cachePolicy: .returnCacheDataElseLoad))
                    .asMaybe()
        }

        geoLocalization
            .observeOn(MainScheduler.instance)
            .subscribe(onSuccess: { result in
                print("My result 2: \(result)")
            })
            .disposed(by: disposeBag)
    }
}

Original Answer

The short answer here is no. The best you can do is wrap the state in a class to limit its access. Something like this generic approach:

final class Cache<Key: Hashable, State> {
    init(qos: DispatchQoS, source: @escaping (Key) -> Single<State>) {
        scheduler = SerialDispatchQueueScheduler(qos: qos)
        getState = source
    }

    func data(for key: Key) -> Single<State> {
        lock.lock(); defer { lock.unlock() }
        guard let state = cache[key] else {
            let state = ReplaySubject<State>.create(bufferSize: 1)
            getState(key)
                .observeOn(scheduler)
                .subscribe(onSuccess: { state.onNext($0) })
                .disposed(by: bag)
            cache[key] = state
            return state.asSingle()
        }

        return state.asSingle()
    }

    private var cache: [Key: ReplaySubject<State>] = [:]
    private let scheduler: SerialDispatchQueueScheduler
    private let lock = NSRecursiveLock()
    private let getState: (Key) -> Single<State>
    private let bag = DisposeBag()
}

Using the above isolates your state and creates a nice reusable component for other situations where a cache is necessary.

I know it looks more complex than your current code, but gracefully handles the situation where there are multiple requests for the same key before any response is returned. It does this by pushing the same response object to all observers. (The scheduler and lock exist to protect data(for:) which could be called on any thread.)

I have some other suggested improvements for your code as well.

• Instead of using flatMapLatest to unwrap an optional, just filter optionals out. But in this case, what's the difference between an empty String and a nil String? Better would be to use the nil coalescing operator and filter out empties.

• Since you have the code in an IBAction, I assume that currentPublicIP() only emits one value and completes or errors. Make that clear by having it return a Single. If it does emit multiple values, then you are creating a new chain with every function call and all of them will be emitting values. It's unlikely that this is what you want.

• URLSession's json(request:) function emits on a background thread. If you are going to be doing anything with UIKit, you will need to observe on the main thread.

Here is the resulting code with the adjustments mentioned above:

class ViewController: UIViewController {
    private let disposeBag = DisposeBag()
    private let provider = PublicIPProvider()
    private let responses: Cache<String, Any> = Cache(qos: .userInitiated) { ip in
        return URLSession.shared.rx.json(request: URLRequest(url: URL(string: "http://api.ipstack.com/\(ip)?access_key=cce3a2a23ce22922afc229b154d08393")!))
            .asSingle()
    }

    @IBAction func geoButtonTapped(_ sender: UIButton) {
        // my IP provider for ipify.org
        let fetchedIP: Maybe<String> = provider.currentPublicIP() // `currentPublicIP()` returns a Single
            .timeout(3.0, scheduler: MainScheduler.instance)
            .map { $0.ip ?? "" }
            .filter { !$0.isEmpty }

        let geoLocalization: Maybe<Any> = fetchedIP
            .flatMap { [weak responses] ip in
                return responses?.data(for: ip).asMaybe() ?? Maybe.empty()
            }

        geoLocalization
            .observeOn(MainScheduler.instance) // this is necessary if your subscribe messes with UIKit
            .subscribe(onSuccess: { result in
                print("My result 2: \(result)")
            }, onError: { error in
                // don't forget to handle errors.
            })
            .disposed(by: disposeBag)
    }
}