Rx’s flatMap is not what you think!
The learning curve of RxJava
I have been programming for Android professionally for almost two years, and RxJava/RxAndroid took me the longest time to understand enough to be able to manage it by myself.
I’m not going to introduce you to Rx, I assume you know the basics like Observables emitting data and you subscribe to them but still don’t understand Rx generally.
The operator flatMap
I will take you directly to the turning point — where it all began to make sense to me. I often saw this in the code project: Observable.flatMap(). I didn’t understand it because, of course, I assumed it was Collections.flatMap(), which mapped lists into a single list.
But, then something happened, I decided to ask a senior fellow at my work to clarify the flatMap operator of Rx. He replied — “You do know it’s not the same as Collections.flatMap, don’t you?” this was when the penny dropped. I wish I knew this much earlier.
But, what does that Observable.flatMap() do then?
Very good question. I will simply go by this simple description provided by the documentation:
Transform the items emitted by an Observable into Observables, then flatten the emissions from those into a single Observable
Say you want to subscribe to fetchUserObservable, but you would need an accessToken from the loginObservable first. So, you can do this — subscribe to loginObservable and then use its response, which is the accessToken, to the fetchUserObservable. Like the example below:
authRepo.loginObservable
.flatMap { accessToken ->
// accessToken is from loginObservable
userRepo.fetchUserObservable(accessToken)
}
.subscribe { user ->
// user is from fetchUserObservable
print(user)
}
That was a trivial example, but hopefully clear. You can connect how many Observables into each other you want using flatMap. Let me repeat: