Hi, my name's Jamie Huson, and I'm an Android developer at Etsy.

In this workshop, we're going to get you started using RX Java.

We'll cover the concepts and

API's by integrating RX Java into a familiar project, a toDoList app.

Let's dive right in.

RX Java is a library of code to handle data using a push and pull mechanism.

Just like a notification on your phone,

some data will be pushed to receiver of that data.

It's a different way of thinking about existing coding patterns you know.

For instance, let's take a look at this array of to-do's.

In your app, you might have a list or array of to-do items.

Usually, you'll [SOUND] iterate over those items using an index starting at zero and

moving to the last item.

Each time you iterate, you'll perform some action with that item.

In our next Java, we think of these items as being pushed to us one at a time.

Over time, each item is emitted and we can handle that item as we did before.

This is very similar to a callback like on a click in Android,

where we receive a notification when an item is tapped on the screen.

In this model our data is being provided as it becomes available.

In our next job the object that emits items is [SOUND] called an Observable.

The callback that receives items [SOUND] is called the Observer.

And Observer subscribes to the observables and starts receiving data and

un-subscribes and the data is no longer received.

Here we can see the Observable emit items [SOUND] and

as they're emitted they're passed along to the Observer.

Here's what that would look like in RX Java code.

Observable.just creates an Observable that will emit each item from our data set.

In this case a todoList [SOUND].

Now, we've subscribed to the Observable.

An observer's past of the subscribe method.

It's type to the kind of data being emitted.

In this case a Todo object.

Observer contains the callbacks required for subscription.

On next is called for each item emitted.

Uncompleted is called when the Observable has no more items to admit.

Finally, on errors call if an error occurs.

It's important to note that on completed and on error are only ever called once.

And after they are called, on next will not be called again.

[SOUND] Calling subscriber turns back a subscription object.

[SOUND] With our subscription we can later call unsubscribe.

For instance, in on passive our activity in Android.

These are the basics of the RX Java model.

Data is submitted from Observables which are subscribed to by Observers.

Data is pushed to the observables as it becomes available.

If you've worked with loaders on Android before,

it's similar except this API is much cleaner.

RXJava does include a couple of helpful classes

that it makes working with observables much easier in certain situations.

For instance, sometimes you may not care about all three callbacks.

You may not care about on completed or on error.

And just want to know when items are emitted.

If that's the case, you can simply pass an action to the subscribe method.

The actions call method will be called for each on next called by the Observable.

By default, Observables emit up to an infinite number of items.

However, sometimes you may only want to emit a single item.

For that there's a special observable called single.

Single is an observable that emits only a single item.

Because of this, unlike the regular onCompleted, onError, and

onNext calls, there is a simpler onSuccess or onError callback.

Next, Rx Java adds additional power by letting

us manipulate the data through a pipeline before it reaches our observer.

Here's what I mean by that.