To learn RX Java we're revisiting an app you've probably built before.

A to do list.

I've included an implementation of a simple to do app

built without the use of RX Java.

Let's take a look at the code and see what's going on.

Here we can see that we have one activity,

the main activity We have a data model object.

A to do is just as a description and

a boolean to indicate if this to do item is completed.

We have a to do list.

So a to do list, is a list of to do's and this to do listener.

Let's go to the to do listener,

that's a simple interface it has a method called on to do is change.

So, if the to do list changes, something is gonna listen for

changes to that and update that you are.

So our to do list keeps our items and whenever we add or

remove an item from our to do list, the listener will be called.

And also some other helpful methods to set the listener up, to get the number of

items in our list, and to get a specific to do from our list as well.

You'll notice that the to do list also reads data in from Json and writes it

to Json in the to string, which is just helpful for serializing this data.

If we need to we can also see that there is something called a to do list filter so

this is a class.

And it implements the to do listener so that means this receives a call back.

When the to do list changes in some way.

And here we can see at some sort of filter.

It describes What to dos are being shown.

So, all.

That's all items, whether they are completed or not complete.

Incomplete is a one, and completed is a two.

And there's basically a mode, a filter mode.

So, by default, we want to show all the items.

And this filter class is responsible for.

Filtering the items out.

So if we're only looking at the incomplete items.

Then we're going to take the to do list.

And we're going to compile just the ones that are only incomplete.

And the same with complete.

We'll take the items.

And just compile a list of just the items that are completed, and return those.

You'll notice that if it's all, we're just going to return the list, itself.

So there's a to do list filter.

We can see that there is an adapter to display these in our cycler view.

And this also listens for changes.

This it to do completed change a listener here.

And they to do completed change listener.

Let's go ahead and look at what that is.

That is if an item is checked.

So if it changes from being not completed to completed that item will then

be called on, whatever implements this interface.

So we can see here that we have a check box for each item.

And the first thing we're going to do is actually set the on

check listener to normal.

That's because of this interesting thing with Android where if you

call a set checked on a check box and there's a listener set,

it's gonna get that call back with the new value even if you're just setting it for

the first time with an initial.

Item value so in this case we don't want to get the call back until the value

changes so we said to know we set the value then we set up our listener here.

And we'll get changes to do the listener, to do change listener.

Whenever an item is checked or unchecked.

We also have it on to do list change so

again this thing is also implementing ToDoListener.

So it's listening for changes to the list and

it's updating its data set whenever items in our to do list change as well.

And then let's go back to the main activity and

kinda see how this is all put together.

So here in our main activity, we have all the views,

which is mainly the RecyclerView, which has an adapter.

We also have the ability to add a new item to the list

via an input which is an EditText and then we have our list of data and our filter.

And we can see that we save our data and we serialize it to the bundle.

That's for rotation and handling other instances where our activities destroyed

and then recreated and we can also see that.

We set up a to do list filter with the list and

we set the filter to interact as a part of the listener.

With the to do adapter so there's all these listener's.

Calling to each other in each item and it's a little bit complicated.

But we're going to see that our next java helps us to simplify this

model quite a bit.

We can also see that we just look up our recycler view we set our adapter.

And we also have our Ability to add another todo item.

So in this case we have our ClickListener for a button to add the todo.

When we click that button we want to get the text.

Make sure it's not empty.

Add the item to the list.

Notify everything that the changes have occurred.

Set the input box back to nothing.

Request focus away from our input box and then dismiss the keyboard.

So this is basically going to dismiss the keyboard and refresh our list.

And that's gonna happen by triggering all of these listeners that are set up

between our adapter and our filter and our to do list.

We can also see that we have this spinner at the top in our toolbar, and

the spinner has three values.

It has the All, Completed, and Incomplete values.

And when we select one of those we also need to trigger all all those listeners to

change the value of what UI is being displayed.

What items get put in our adapter essentially, and we do that by

getting our filter and calling set filter mode to the position which is an indicator

of which filter we're using and we also have to notify our adapter.

Which needs to get the newest filtered data from our filter as well.

So again these are all kind of working together each of these is

tied to one another in all these listeners and how they are set up.

Now there's probably a better way to do this.

I know there is one at least which is using our X Java.

There are other ways to do this but this is a common thing you see in Android code

which is listeners, interfaces and then working together to inform

when data has changed or when the UI needs to be updated in some way.

So this is something you probably commonly see in Android code, it may be something

you've written before and will see in RX Java is that there's a much simpler

straight forward way to do it and something that's also less error prone.

Okay so the first step that we want to take when we're going to for

this project to use Rx-java is we need to add some dependencies on Rx-java and

some other libraries that will help us along the way.

So go ahead and go to your project and open up your build.gradle for

the app module, and in here what we'll see is at the very bottom, under dependencies,

we need to add some dependencies for our RX Java, that's the first one.

We have here RX Java one dot one dot zero.

You can get the latest version from the RX Java website.

But if you wanna use the code I'm using here make sure you use that same version.

If you use a different version, code might change.

And I'm also using rxandroid 1.1.0.

You'll notice that both of these have the exact same version number.

And that's gonna be the case going forward in the future, these should pretty much

have the same numbers because RX Android will be updated along with RX Java.

What you also see is RX Binding and what RX Binding does,

is it allows us to have observables and subscriptions with common

UI elements, views in Android and it's very helpful.

Comes in handy a lot of times.

So, arcs binding the default one is for

all the standard views that come with Androids STK.

And we also have bindings for

the support library apt compact design or cycle or view as well.

And then finally just because it's easier let's go ahead and

use butter knife as well.

That'll make it easier to look up our references to views and

you've probably used this before in multiple workshops and courses.

So you should be familiar with that.

Once you've added these you're gonna need to good ahead an sync so

we're good ahead sync now and

then our project should be ready to go to start adding in RX Java functionality.