Heads up! To view this whole video, sign in with your Courses Plus account or enroll in your free 7-day trial. Sign In Enroll
Preview
Start a free Courses trial
to watch this video
Convert TodoList class into Observable that pushes data to subscribers. That means our data-model which holds the Todo items will emit the updated items anytime the Todo list is updated.
To start converting our app to use RxJava,
0:00
let's look at the core
functionality this app has.
0:03
We're gonna convert our to do list class
into an observable that pushes data
0:06
to subscribers.
0:11
So I got to look at our TodoList class,
and if you recall from before,
0:13
this holds a list of to do's and
0:19
has the ability to add and
remove and toggle to do's here.
0:22
And it also has a listener and
0:27
if you look at this TodoListener you
can see that any time our list changes.
0:30
Anyone who is registered, any object or
0:36
other part of our app that's registered
can listen for changes to this list.
0:39
And so what we're gonna do
is we're going to convert
0:44
our TodoList into an observable.
0:47
So when changes happen it pushes and emits
those changes out to any subscribers.
0:50
So to do this what we need to
do is we need this TodoList
0:57
to both be an observable and
also emit items.
1:00
So be able to push items out
through that observable and
1:04
there's a specific type RxJava
that we can use to do this,
1:06
it's called a subject and theres
several different types of subjects.
1:10
For this, we're gonna use
one called a replay subject.
1:14
So let's add it in here in
the we'll talk about what it does.
1:18
So our replay subject it's typed and we're
going to make it the TodoList type and
1:22
that just means that every time we emit
an item it's gonnas be a TodoList object.
1:27
So that means whenever anything changes
we're gonna update this TodoList object
1:32
and then push the object out emit it as an
item and we'll gonna call it a notifier.
1:36
And using RxJava, normally you think,
I'm gonna create something using new.
1:42
In RxJava usually there's a static
helper method to create objects.
1:47
So in this case we're gonna
say ReplaySubject.create.
1:53
So what does this do?
1:57
This ReplaySubject is
a special kind of subject and
1:58
what it does is If item are emitted let's
say two items are emitted and then a new
2:01
subscriber subscribes to this subject
remember, the subject is an observable.
2:07
It's pushing, it's emitting items so
2:12
as subscribers subscribe it's gonna emit
all items that have been emitted so far.
2:15
So it's gonna replay those
items to every new subscriber.
2:21
That means no subscribers will miss out
on any items if they subscribe later
2:24
then when items were first emitted and
that's what we wanna do here.
2:29
And now we want to use this notifier
instead of our TodoListener.
2:34
So I'm gonna remove the TodoListener,
we're not gonna use that anymore.
2:38
And we're gonna go down here and
2:42
every place that we reference our
TodoListener we're going to get rid of it.
2:44
So the set listener we just
don't need that at all.
2:48
And down here, when we add to
you we're gonna update the list.
2:52
And now instead of notifying the listener,
what we're gonna do is push out or
2:56
emit an item on our notifier and
we do that by just calling the onNext.
3:00
And it expects the updated TodoList
which is just this object so
3:05
we're gonna pass in this and we're gonna
do the same exact thing for remove.
3:09
So for remove we're gonna go ahead and
say notifier.onNext(this).
3:12
So if items are added or
3:18
removed any subscribers will receive
the new updated TodoList object.
3:20
And finally, down here,
3:27
if something is toggled as well,
we can go ahead and notify as well.
3:29
So we'll say notifier.onNext(this).
3:33
So that's pretty straightforward,
we got rid of our interface and
3:39
our listener call back and
we made our TodoList into
3:43
an observable using the subject and
specifically this ReplaySubject.
3:47
So now whenever this list changes we need
something else to subscribe to this and
3:52
the main thing we want to
subscribe is our adapter.
3:59
The adapter is listening for
changes in the list of items and
4:02
then it updates its own data set,
and calls notify data set change.
4:06
So we can see here, right now,
it implements TodoListener.
4:12
And whenever TodoListener on
TodoList changed gets called,
4:15
it sets the new data and
calls notifyDataSetChanged.
4:19
In this is more or less exactly what we
wanna do except we're not gonna use this
4:23
interface anymore instead we wanna
use our TodoList as an observable.
4:26
So to do that we actually need to expose
the to do list as an observable so
4:31
we're gonna add a method to do that.
4:36
So it's gonna return back observable and
we're gonna call it asObservable.
4:45
And we're gonna return back our notifier.
4:50
So now when I have my TodoList I
can use it as an observable and
4:56
we'll be able to subscribe to it.
5:00
And the thing that's gonna
subscribe is our to do adapter.
5:03
So we want to call back in
here when that happens and
5:06
we need to set up that subscription.
5:09
So to do that instead of implementing
TodoListener, let's go ahead and
5:10
implement the action that
we talked about before.
5:14
So remember Action Is when we
don't care about on a completed or
5:16
on error, we just care about onNext.
5:21
So any time this TodoList changes, it
calls onNext, that's what we care about.
5:24
So we're just gonna change
this TodoList as an Action,
5:28
make sure we import it and implement
the required method which is just call.
5:33
And then we're simply gonna move
this code into our call method.
5:41
So the call method is going to be called,
every time onNext.
5:47
Would be called for the subscription and
what we're gonna do is just gonna say all
5:51
right data be the new todoList and
then notify data set changed.
5:55
So everything else remains the same
we still have some listeners and
6:02
things will get to that, but we've now
changed our TodoList to an observable and
6:04
on our to do adaptor to be
an observer with an action.
6:10
And now we can go to our main activity and
6:14
just make sure that that
gets set up correctly.
6:16
So before we are passing in
our onTodoCompletedChanged
6:18
listener as part of our adapter we
would be calling our onTodoListChanged.
6:23
So we no longer need that because
6:29
the TodoList is gonna push out changes
automatically to any subscribers
6:31
all we need to do is make sure that
our adapter is subscribed to our list.
6:36
So let's just get our
list as an observable and
6:41
let's subscribe and the thing that's going
to subscribe is going to be our adapter.
6:46
So we created our list up
here we created our adapter.
6:55
Now we subscribe our adaptor to our list.
6:58
So any time our list changes, we no longer
need to manually call to update and
7:01
send out those listeners.
7:06
We can just get rid of these all together.
7:08
So list will call toggle.
7:12
It will push out and
7:14
emit a new item of the list to any
subscriber, same with down here.
7:15
Now you'll notice that there was
a part here for filtering data, and
7:22
we'll get to that.
7:26
But for now we're just gonna delete these,
cuz we no longer need that TodoListener.
7:27
And if we look for
any references to TodoListener,
7:41
we can see the TodoListFilter
also implements the TodoListener.
7:44
So we can see that this TodoListFilter,
7:51
we can also update and change it so
it doesn't use our TodoListener anymore.
7:55
So remember the list here,
setListener(this).
8:00
What we wanna do is just make
this instead into an action.
8:04
The same one we had before.
8:10
And we had here on TodoListChanged,
go ahead and
8:22
change that move the code over here.
8:26
We no longer need to set the listener.
8:41
And, finally we just want to subscribe
8:44
our TodoListFilter as well to our list.
8:50
So now any time items are emitted
from our TodoList the filter and
9:00
the adapter are both going to get those
items emitted to them as observers.
9:05
So as you can see Android
depends a lot on listeners and
9:12
we often make interfaces with
different types of listeners.
9:15
But the RxJava model of push instead of
pull can simplify a lot of this code and
9:18
it can simplify the interactions
between different objects in your app.
9:24
So this is just the start
we're gonna keep going and
9:27
we'll see that it gets even simpler as we
add in new functionality RxJava gives us.
9:30
You need to sign up for Treehouse in order to download course files.
Sign up