Develop Reference

I want a function to be called only after live data is received

i am using live data in android. But my problem is that the data is received at last after every function is called. In my case one of my function has dependency on live data but it is called before live data is received.i have added comments to make u understand better. Please help.
// polist is a MutableList
transactionDao.selectAll().observe(this, Observer {
if (it != null && it.isNotEmpty()) {
polist.addAll(it)
}
})
vregularDao.getAll().observe(this, Observer {
if (it != null && it.isNotEmpty()) {
polist.addAll(it)
}
})
// but this is called first then above codes.I want this to be called only after live data is received
alllist.forEach{
//perform some action
}

You may want to look into threads. The code below runs in a thread and once there's a return value it is added to polist
transactionDao.selectAll().observe(this, Observer {
if (it != null && it.isNotEmpty()) {
polist.addAll(it)
}
})
Same for
vregularDao.getAll().observe(this, Observer {
if (it != null && it.isNotEmpty()) {
polist.addAll(it)
}
})
Therefor the last chunk of code is called directly. as the other two thread hasn't returned any data at the moment.
You would need to create some sort of blocker.
So it would be call another function after the list enumeration, this isn't elegant(PSUDEOCODE)...
bool selectAllDone;
bool getAllDone;
// polist is a MutableList
transactionDao.selectAll().observe(this, Observer {
if (it != null && it.isNotEmpty()) {
polist.addAll(it)
performSomeAction();
selectAllDone = true;
}
})
vregularDao.getAll().observe(this, Observer {
if (it != null && it.isNotEmpty()) {
polist.addAll(it)
performSomeAction();
getAllDone = true;
}
})
// but this is called first then above codes.I want this to be called only after live data is received
public fun performSomeAction(){
if(getAllDone & selectAllDone){
alllist.forEach{
//perform some action
}
}
}

RxJava: Skip all the errors in fromIterable() and notify subscriber when all the items are emitted - Flowable.parallel execution

I have an API call which verifies some status against an "Id". The API returns Single or error. I have a list of such Id's, Only one Id is valid to return success or none (all id's return error). What I need is, Iterate through each Id and skip the errors from API call, until either a success or end of the list. I am able to achieve this sequentially. However, I am trying to do the same, using ParallelFlowable.
It works fine when an Id returns success, But when there is no id which returns success (all ids fail), then it just skip all the errors from API, but does not notify the subscriber after all the ids are validated. I am not sure how to handle this.
// API call
fun getStatus(Id: String): Single<String> {
//... returns Single<String> or error
}
//Sequential flow, Working
fun getStatus(ids: List<String>): Single<String> {
Observable.fromIterable(ids)
.flatMapSingle { id ->
getStatus(id)
.onErrorResumeWith { singleSource ->
if (ids.last() == id)) { //If this is last item in list, return error
singleSource.onError(NoStatusFoundException())
} else {
// Skip errors until valid id is found or till the list reached end.
Flowable.empty<String>()
}
}
}.firstOrError()
}
// Parallel Flow, How to identify the list is completed and return NoStatusFoundException in case of all id's fail?
fun getStatus(ids: List<String>): Single<String> {
Flowable.fromIterable(ids)
.parallel()
.runOn(io())
.flatMap{ id -> getStatus(id).toFlowable()
.onErrorResumeWith { Flowable.empty<String>() }
}
.sequentialDelayError()
.firstOrError()
.onErrorResumeNext { Single.error(it) }
}
// Subscription
getStatus(listOf("1","2","3","4","5",))
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscriber({ id->
// success
this is notified when an id is success
},
{ // error handler - Need help here
Never notified when all the id's fail?
})

I am able to resolve this issue by removing onErrorResumeWith { Flowable.empty<String>() } within flatMap and implementing RxJavaPlugins.setErrorHandler{...}.
sequentialDelayError() delays all the errors until all the rails have finished their task.
fun getStatus(ids: List<String>): Single<String> {
Flowable.fromIterable(ids)
.parallel()
.runOn(io())
.flatMap{ id -> getStatus(id).toFlowable()
}
.sequentialDelayError()
.firstOrError()
.onErrorResumeNext { Single.error(it) }
}
///
RxJavaPlugins.setErrorHandler{ it: Throwable ->
is UndeliverableException -> {...}
.....
}

You are returning Flowable.empty() that immediately completes the subscription. Taken from the docs:
Returns a Flowable that emits no items to the {#link Subscriber} and immediately invokes its {#link Subscriber#onComplete onComplete} method.
Maybe you can return Flowable.just("") or provide some expected argument incase of an error.
.onErrorResumeWith { Flowable.just("") }

The problem is in this line:
.onErrorResumeWith { Flowable.empty<String>() }
The parameter of onErrorResumeWith is a Publisher<out T>, not () -> Publisher<out T>. The Publisher interface happens to have a single method, void subscribe​(Subscriber<? super T> s). As such, it is eligible for SAM conversion.
The lambda { Flowable.empty<String>() } is a perfectly valid (Subscriber<String>) -> Unit that ignores its single parameter, calls a method, and ignores the result. This compiles, but the result is for all practical purposes the same as Flowable.never().
Instead of a lambda, you need to pass Flowable.empty() directly into onErrorResumeNext():
.flatMap{ id -> getStatus(id).toFlowable()
.onErrorResumeWith(Flowable.empty<String>())
}

How to send a custom throwable down through flatmap in RxJava on Android?

So I am using flatMap with RxJava to chain some API calls that return Singles and was wondering how to pass a custom throwable to the subscribe method in the flatmap method depending on my own condition.
This is in an Android Kotlin app that uses MVVM and RxJava2/RxAndroid for data operations. I am trying to chain together a bunch of API calls that return Singles using the flatmap method. Everytime, I want to call a new API method after the previous one, I want to check to see if the previous call's response was successful. If the previous call's response was successful, I just call the next API method in the flatmap and everything is good, but if the previous call's response was not successful, I want to pass a custom throwable that tells me where and why the operation wasn't successful. Right now in the situation of an unsuccessful response, I pass a Single with a null value, but that just gives me a null pointer when subscribing and that isn't very helpful.
dataManager.apiCall1(dataManager.sessionId!!)
.subscribeOn(schedulerProvider.io())
.observeOn(schedulerProvider.ui())
.flatMap{apiCall1Response ->
if (apiCall1Response.isSuccessful && apiCall1Response.body() != null) {
// First api call was successful, execute api call 2.
return#flatMap dataManager.apiCall2(apiCall1Response.importantVal)
} else {
// First api call failed
Single.just(null)
}
}.flatMap{apiCall2Response ->
if (apiCall2Response != null && apiCall2Response.isSuccessful && apiCall2Response.body() != null) {
// Second api call was successful, execute api call 3.
return#flatMap dataManager.apiCall3(apiCall2Response.importantVal)
} else {
// Second api call failed
Single.just(null)
}
}.subscribe({apiCall3Response ->
if (apiCall3Response != null && apiCall3Response.body() != null) {
// Success!
navigator!!.successful(response)
} else {
// Third api call failed, handle error
navigator!!.handleError(Throwable("Api call 3 failed."))
}
}, {throwable ->
// Failure, this is where I want to receive a custom throwable
// in case one of the responses were unsuccessful.
navigator!!.handleError(throwable)
})
I expect the throwable message to be something like "apiCall1" failed, but the throwable message when apiCall1 fails is just NullPointer because of the Single.just(null) that I pass.

Instead of Single.just(null) use Single.error().
For example: Single.error<TypeHere>(RuntimeException("First api call failed"))

For the most readable code, define an extension function like this
private fun <T> Single<Response<T>>.decorateWithErrorHandling(): Single<T> {
return this
.onErrorResumeNext { throwable ->
// Map network layer exceptions, e.g. IOException to your specific "domain level" exceptions
Single.error(mapNetworkErrorToSpecificThrowable(throwable))
}
.flatMap { response ->
if (response.isSuccessful) {
Single.just(response.body())
} else {
Single.error(convertToSpecificThrowable(response))
}
}
}
Use it like this:
apiCall1()
.composeWithErrorHandling().flatMap { result1 -> apiCall2(result1) }
.composeWithErrorHandling().flatMap { result2 -> apiCall3(result2) }
etc.

Use this code
throw NullPointerException from flatMap
and catch the error by
.onErrorReturn(throwable -> {//your work here})
#Carson J.

RxJava + GRPC recover from errors and retry requests

I'm trying to recover from errors using RxJava and GRPC. This is my observable:
Observable<Object> observable = Observable.fromCallable(() -> {
try {
Grpc.MyRequest request = Grpc.MyRequest.newBuilder()
.setToken(mToken)
.build();
Grpc.MyResponse reply = mStub.mytest(request);
return reply;
} catch (Exception e) {
///
}
}).cache();
And this is the subscription:
observable.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.doOnError(throwable -> {
})
.subscribe((result) -> {
MyResponse res = ((MyResponse) result);
if (res.getCode()!=0) {
//Check error code and try to refresh token and repeat this request after.
}
},throwable -> {
throwable.printStackTrace();
});
So, when I get the error from my GRPC service, depending on the error code, I want to try and recover from it by doing another request, and then repeating the original request. I'm not sure how to use RxJava retrywhen.
What is the most elegant way of doing something like this?

Error recovery in an observer chain does require a bit of tap dancing, and is by no means elegant. However, it can be contained in the observer chain.
boolean isRecoverable( Throwable t ) {
// this test can be as sophisticated as you want
if ( t instanceof StatusRuntimeException ) {
return true;
}
return false;
}
...
.retryWhen( throwableObservable ->
throwableObservable.flatMap( t -> isRecoverable( t )
? Observable.just("")
: Observable.error( t ) )
...
This approach allows you to decide what you want to do with the error. You could add a delay the just() so that you don't retry immediately. Instead of the just(), you could return an Observable that fetches a new API token.

How to refresh parameters of a observable inside retrywhen

I`m trying to implement a autoLogin function with retry when and need to change the parameters of the previous observable after the auto login is done.
So i created a function
class TestClass(): Function<Flowable<out Throwable>, Flowable<*>> {
override fun apply(flowable: Flowable<out Throwable>): Flowable<*> {
return flowable
.flatMap {
if (it is HttpException && it.code() == 401 ) {
Timber.d("apply: Doing AutoLogin.")
dataSource
.login(document, password)
.map {
//Auto login done, update user
}
.doOnError({
// login failed
})
.toFlowable()
} else {
Flowable.error(it)
}
}
}
}
And apply it this way:
dataSource.apiCall(user)
.retryWhen(TestClass())
.subscribe()
Tried this way too:
Single.defer {
dataSource.apiCall(user)
.retryWhen(TestClass())
}
.subscribe()
}
The problem is, after the login when the request is retried, the user isn`t updated.
What i`m doing wrong?