CODEWITHSUNDEEP
androidkotlinretrofit2rx-java2rx-android
LunaVulpo
LunaVulpo

Reputation: 3221

How to make request calls to remote service one by one usnig rx and kotlin?

I have remote service to which the app have to send data: Definition in retrofit2:

interface FooRemoteService {
    @POST("/foos")
    fun postFoos(@Body foos: List<FooPojo>): Observable<Response<List<String>>
 }

but the call has a limits no more than X Foos at once. Each call can returns 206 code "partially successful" with list of unsuccessful uploaded foos. Also 413 "Request Entity Too Large". And of course 400 and 500 as well.

And the app needs to send unknown count of foo items (defined by user in runtime).

To avoid DDoS of service app is required to send this calls one by one.

So I made such implementation in my FooRepositoryImpl:

This is an idea. I'm not happy with below solution and I'm sure that it can be done much better but I'm run out of ideas. So any proposes?

override fun postFoos(foos: List<Foo>) Completable {
  val fooChunks = divideListInToChuncksUnderRequestLimit(foos)

  val unuploadedFoos = mutableListOf<UnuploadedFoo>()
  fooChunks.fold(unuploadedFoos) 
  { accu: MutableList<UnuploadedFoo>, chunk ->
     fooRemoteService
        .postFoos(chunk)
        .subscribeOn(Schedulers.io())
        .flatMapCompletable {
             if (it.isSuccessful) {
                         Completable.complete()
                    } else {
                        Timber.e("$it")
                       accu.add(it.body())

                    }
                }.blockingAwait()
        responses

  }
return Completable.complete()
}

At the end the app should display list of all unsuccessful foos or if any available. So I need pass from that fuction list of unuploaded Foos.

Upvotes: 1

Views: 173

Answers (1)

marianosimone
marianosimone

Reputation: 3606

If you are OK with modifying the return type of postFoos a bit, something like this could work:

override fun postFoos(foos: List<Foo>): Observable<List<UnuploadedFoo>> {
    val chunks = foos.chunked(CHUNK_SIZE)
    val posters = chunks.map { chunk ->
        fooRemoteService.postFoos(chunk)
                .map { response ->
                    response.unUploaded.takeIf { !response.isSuccessful } ?: emptyList()
                }
                .filter { it.isNotEmpty() }
                .toObservable()
    }

    return Observable.concatDelayError(posters)
}

I'm imagining your service to have something like:

data class Response(val isSuccessful: Boolean, val unUploaded: List<UnoploadedFoo>)

fun postFoos(foos: List<Foo>): Single<Response>

The trick here is that Concat:

(...) waits to subscribe to each additional Observable that you pass to it until the previous Observable completes.

Upvotes: 1

Related Questions