OkHttp VS RxJava

We will use Square’s Mock Webserver to spin up a mock server which we can use to simulate real api's request to the get coffee endpoint.

OkHttp Documentation

mockwebserver -> https://github.com/square/okhttp/tree/master/mockwebserver

I searched in the OkHttp GitHub project for an advice on which values may be suitable for Android apps nowadays but found no answers (only this old issue which does not help). Since we share a single OkHttp client Singleton for all our retrofit APIs and even Coil, I wonder if the default 5 maxRequestsPerHost is really enough.

You can technically add a Content-Length header for each part. It's not forbidden by the RFC, but nor is it common. It caused [problems](https://github.com/square/okhttp/issues/2138) for OkHttp, and they eventually removed it. Might be fine for internal-only use, though.

Boundaries are a lot like UUIDs, and rely on the same logic. When generating random data, once you have enough bits, the odds are against that sequence of bits ever having been generated before in the universe.

Lets be specific. This is the gradle build file for Squares okhttp client library. How exactly would your bld tool "predict" or "help" with all the parameters needed? There is no need to be defensive. Replace those large build files with your own, show where your approach is better and then understanding will lead to better solutions.

And adding to that: The asynchttpclient library is just a thin wrapper around OkHttp3, so it might be easier to just go with that instead: https://square.github.io/okhttp/

Retrofit in combination with OkHttp for fetching data from server (which hopefully already exists)

OkHttp

3. RxJava This repository contains the source code for ReactiveX, a library used to create asynchronous and event-based programs with observable sequences. https://github.com/ReactiveX/RxJava

Is this similar RxJava, the reactive extensions library for https://github.com/ReactiveX/RxJava ? I have made that work in Clojure in production.

Since you mentioned java, there is RxJava and RxAndroid. Google general recommendation now is to use kotlin coroutines if you're considering writing your app with that.

It's very quick though. In terms of the correctness of the syntax, I've never seen an issue while translating a single file or a single function. When I took the entire RxJava code base 5 years ago, right clicked on the source folder and converted to Kotlin, I found lots of problems. File by file I've never seen any issues though, but I also haven't done it much.

You all beat me to MapStruct and Testcontainers. Honorable mention to RxJava, which I use in Desktop apps.

RxJava with RxRelay (and rx-combinetuple-kt)

RxJava2

More information about rxJava, check it out here: (HERE)[https://github.com/ReactiveX/RxJava]

Concurrency: Kotlin coroutines for general use, Rx or Flow for reactive programming (you can technically use Rx for regular concurrency as well, but not really what it's meant for)

If you're just looking at making a service call on a regular interval and notifying the user when there's an actual change in data, you can also look into RxJava https://github.com/ReactiveX/RxJava. From here you can "subscribe" to your service call, and then every time you make your service call you can have it look for changes compared to the previous emission .distinctUntilChanged() and then only notify it's subscribers when it notices an actual change. From there you can trigger a local notification and push to a LiveData (assuming MVVM) or otherwise update the UI to match as well.