To start converting our app to use RxJava,

let's look at the core functionality this app has.

We're gonna convert our to do list class into an observable that pushes data

to subscribers.

So I got to look at our TodoList class, and if you recall from before,

this holds a list of to do's and

has the ability to add and remove and toggle to do's here.

And it also has a listener and

if you look at this TodoListener you can see that any time our list changes.

Anyone who is registered, any object or

other part of our app that's registered can listen for changes to this list.

And so what we're gonna do is we're going to convert

our TodoList into an observable.

So when changes happen it pushes and emits those changes out to any subscribers.

So to do this what we need to do is we need this TodoList

to both be an observable and also emit items.

So be able to push items out through that observable and

there's a specific type RxJava that we can use to do this,

it's called a subject and theres several different types of subjects.

For this, we're gonna use one called a replay subject.

So let's add it in here in the we'll talk about what it does.

So our replay subject it's typed and we're going to make it the TodoList type and

that just means that every time we emit an item it's gonnas be a TodoList object.

So that means whenever anything changes we're gonna update this TodoList object

and then push the object out emit it as an item and we'll gonna call it a notifier.

And using RxJava, normally you think, I'm gonna create something using new.

In RxJava usually there's a static helper method to create objects.

So in this case we're gonna say ReplaySubject.create.

So what does this do?

This ReplaySubject is a special kind of subject and

what it does is If item are emitted let's say two items are emitted and then a new

subscriber subscribes to this subject remember, the subject is an observable.

It's pushing, it's emitting items so

as subscribers subscribe it's gonna emit all items that have been emitted so far.

So it's gonna replay those items to every new subscriber.

That means no subscribers will miss out on any items if they subscribe later

then when items were first emitted and that's what we wanna do here.

And now we want to use this notifier instead of our TodoListener.

So I'm gonna remove the TodoListener, we're not gonna use that anymore.

And we're gonna go down here and

every place that we reference our TodoListener we're going to get rid of it.

So the set listener we just don't need that at all.

And down here, when we add to you we're gonna update the list.

And now instead of notifying the listener, what we're gonna do is push out or

emit an item on our notifier and we do that by just calling the onNext.

And it expects the updated TodoList which is just this object so

we're gonna pass in this and we're gonna do the same exact thing for remove.

So for remove we're gonna go ahead and say notifier.onNext(this).

So if items are added or

removed any subscribers will receive the new updated TodoList object.

And finally, down here,

if something is toggled as well, we can go ahead and notify as well.

So we'll say notifier.onNext(this).

So that's pretty straightforward, we got rid of our interface and

our listener call back and we made our TodoList into

an observable using the subject and specifically this ReplaySubject.

So now whenever this list changes we need something else to subscribe to this and

the main thing we want to subscribe is our adapter.

The adapter is listening for changes in the list of items and

then it updates its own data set, and calls notify data set change.

So we can see here, right now, it implements TodoListener.

And whenever TodoListener on TodoList changed gets called,

it sets the new data and calls notifyDataSetChanged.

In this is more or less exactly what we wanna do except we're not gonna use this

interface anymore instead we wanna use our TodoList as an observable.

So to do that we actually need to expose the to do list as an observable so

we're gonna add a method to do that.

So it's gonna return back observable and we're gonna call it asObservable.

And we're gonna return back our notifier.

So now when I have my TodoList I can use it as an observable and

we'll be able to subscribe to it.

And the thing that's gonna subscribe is our to do adapter.

So we want to call back in here when that happens and

we need to set up that subscription.

So to do that instead of implementing TodoListener, let's go ahead and

implement the action that we talked about before.

So remember Action Is when we don't care about on a completed or

on error, we just care about onNext.

So any time this TodoList changes, it calls onNext, that's what we care about.

So we're just gonna change this TodoList as an Action,

make sure we import it and implement the required method which is just call.

And then we're simply gonna move this code into our call method.

So the call method is going to be called, every time onNext.

Would be called for the subscription and what we're gonna do is just gonna say all

right data be the new todoList and then notify data set changed.

So everything else remains the same we still have some listeners and

things will get to that, but we've now changed our TodoList to an observable and

on our to do adaptor to be an observer with an action.

And now we can go to our main activity and

just make sure that that gets set up correctly.

So before we are passing in our onTodoCompletedChanged

listener as part of our adapter we would be calling our onTodoListChanged.

So we no longer need that because

the TodoList is gonna push out changes automatically to any subscribers

all we need to do is make sure that our adapter is subscribed to our list.

So let's just get our list as an observable and

let's subscribe and the thing that's going to subscribe is going to be our adapter.

So we created our list up here we created our adapter.

Now we subscribe our adaptor to our list.

So any time our list changes, we no longer need to manually call to update and

send out those listeners.

We can just get rid of these all together.

So list will call toggle.

It will push out and

emit a new item of the list to any subscriber, same with down here.

Now you'll notice that there was a part here for filtering data, and

we'll get to that.

But for now we're just gonna delete these, cuz we no longer need that TodoListener.

And if we look for any references to TodoListener,

we can see the TodoListFilter also implements the TodoListener.

So we can see that this TodoListFilter,

we can also update and change it so it doesn't use our TodoListener anymore.

So remember the list here, setListener(this).

What we wanna do is just make this instead into an action.

The same one we had before.

And we had here on TodoListChanged, go ahead and

change that move the code over here.

We no longer need to set the listener.

And, finally we just want to subscribe

our TodoListFilter as well to our list.

So now any time items are emitted from our TodoList the filter and

the adapter are both going to get those items emitted to them as observers.

So as you can see Android depends a lot on listeners and

we often make interfaces with different types of listeners.

But the RxJava model of push instead of pull can simplify a lot of this code and

it can simplify the interactions between different objects in your app.

So this is just the start we're gonna keep going and

we'll see that it gets even simpler as we add in new functionality RxJava gives us.