Based on the post i have written earlier about clean and efficient architecture for developing application using Rx. This will continue with the same theme. If you think what i am talking about have a look at my last blog on reactive programming. link given below.
Let’s take an example before we start:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
mBinding.etSearch.addTextChangedListener(new TextWatcher() { @Override public void beforeTextChanged(CharSequence s, int start, int count, int after) { } @Override public void onTextChanged(CharSequence s, int start, int before, int count) { } @Override public void afterTextChanged(Editable s) { } }); |
For most devs, implementing this kind of reactive callback chaining yourself will prove a time-consuming and error-prone mess. The problem increases when there are certain operation need to be perform like ignore the text when user is typing or when the text has only few characters. Using conventional callbacks may lead to pain in maintaining boilerplate code when the activity is already a God Object (contain every stuff).
Here comes the RxBinding to rescue from such kind of problem.
RxBinding is a set of libraries that allow you to react to user interface events via the RxJava paradigm.
This mean we can have the benefits of Rx (event paradigm) for our views as well.
|
1 2 3 4 5 6 7 8 9 10 |
RxTextView.textChangeEvents(mBinding.etSearch).subscribe(new Consumer<TextViewTextChangeEvent>() { @Override public void accept(@NonNull TextViewTextChangeEvent textViewTextChangeEvent) throws Exception { } }); or // on using lambda just a one liner RxTextView.textChangeEvents(mBinding.etSearch).subscribe(textViewTextChangeEvent -> {}); |
The real benefit here is the syntactic sugar over the existing Android API’s that make your code more readable and consistent. Regardless if you’re observing a click event, a text change event, or even a dismissal of a Snackbar, RxBinding provides a consistent implementation that you can use to react accordingly.
Being an Observable, we can apply every transformation to the stream of data provided by just using the factory methods provided by the class RxView.
So coming to our problem of preventing unnecessary calls when user is typing to enhance performance by reducing load on server. We can apply variety of observable functions to do that.
|
1 |
RxTextView.textChangeEvents(mBinding.etSearch).debounce(DEBOUNCE_REQUEST_TIMEOUT, TimeUnit.MILLISECONDS).subscribe(textViewTextChangeEvent -> {}); |
Just a debounce function and the problem solved. Behind the scene debounce wait for the applied timeout to hold the stream of input data. If some other event occur during the debounce timeout then the new data replaced the earlier one. And thus no processing is done when user is interacting with the application during debounce time period.
Hope you get the real idea behind it’s usage.
Note: Earlier in Retrofit 1, there was a class called ViewObservable do the same thing like RxTextView(which is present in Retrofit 2)
Be the first to comment.