As data is emitted from an observable, we can optionally add steps to manipulate

the data before it reaches the observer's onNext method.

Manipulating data is done using operators.

Operators act on data from an observable before it reaches the observer.

RxJava contains many built in operators such as filter [SOUND], map [SOUND], or

skip [SOUND].

Operators can also do more advanced things,

like combine two pieces of data into a single item to be emitted.

A helpful way to understand these operators is to visit RxMarbles.

This site provides interactive diagrams for common RxJava operators.

I've added the link in the teacher's notes.

Let's take a look at a couple to understand these diagrams.

Okay, open your browser and go to rxmarbles.com.

You can see here, there's a diagram in the middle and

there's a bunch of operators listed on the left hand side here.

Let's just go through a couple to see how it works.

We choose, first.

Here we can see the diagram, I can change the data being emitted by the observable.

Just like our diagram before, the observable is on the top,

the observer is on the bottom.

So here we can see that as the number 1 gets emitted,

it gets observed by the observer.

But also notice that as 2, 3, and 4 get emitted,

only the first item is still passed to the observer.

Let's go ahead and change one of these items being emitted.

Let's pass in 2 as the first item.

So if 2 is the first item emitted by the observable,

we can see that 2 is then the only item received by the observer.

So that's what first does, only emits the first item.

Okay, let's take a look at another one here.

How about map?

Here we can see this map is a function that takes in a value x and

multiplies it by 10.

So that means whatever value is emitted by the observable,

will be multiplied by 10 and that's the value the observer will see.

Here we can see that 1 is emitted and 10 is received, 2 is emitted, 20 is received.

We can change the order of these, it doesn't matter.

Map doesn't change the order, it simply adds a function

as an operator to the value and passes that result to the observer.

Let's go in and take another one.

How about merge.

So what does merge do?

Well, we can see that merge has two observables here, so

there's one observable on the top.

It's emitting 20, 40, 60, 80, 100.

And then we have another observable emitting 1 and 1.

Then we have an operator merge.

And then we have what the observer sees.

So if you take a look at this,

the observer sees the items from observable one up here on the top.

It also sees the items from the second observable.

And that's what merge does.

It takes the items from multiple observables, and

then emits them all to the observer.

So we can see this observer received the items from the first observable and

the second one as well.

We can change the order here and you can see that the order remains the same.

Whichever order they are emitted from either observable,

the observer sees them in that order as well.

Okay, and let's look at another one here.

How about combineLatest?

What does that do?

combineLatest here is a function, it takes in two values and

it concatenates them together.

So we can see we have again multiple observables,

the top observable emits numbers 1, 2, 3, 4, 5.

A second observable emits letters A, B, C, D.

So if a 1 and then an A comes along, and

then combineLatest takes the 1 and the A and it concatenates them and

it makes 1A, and that's what the observer sees.

So notice the observer doesn't get an item until there isn't two items emitted,

one from each observable.

Because the operator has to combine items, one from each observable.

So it needs to have an at least one item from each.

Notice that the next item emitted is 2A.

Why is that?

That's because 1's been emitted, then we have an A, then we have a 2.

And so it takes the latest two items.

That's gonna be the 2 and the A before it, cuz the B hasn't come yet.

Once the B comes then it will be 2B.

And if we change the order of these, you can see it makes sense,

it also changes the order and it changes what the observer sees.

Once the 1 and the B is emitted, we get 1B.

Then the 2 and the B are together combined to receive 2B in the observer.

Then once the A comes, the 2 and the A are combined together to receive 2A, and so

on and so forth, all of these.

And you can move these around and see how it changes what the observer sees by

combining the latest two values from two different observables.

Up until this point we haven't discussed threading.

As you know, threading is an important topic on Android to maintain a fluid and

fast application.

And there's a course listed in the teacher's notes if you wanna learn more.

However, handling multithreading has also been a major pain point for developers.

RxJava helps with this by providing a clean API to handle multithreading

called a scheduler.

A scheduler isn't a thread, but it describes a threading model underneath it.

This means RxJava is flexible to whatever type of threading model you are using.

By default, observables will emit items and

they will be passed to the subscriber on the thread the subscription is created on.

However, if you wanna change which thread items are received on,

you can use the method, observe on.

This ensures the calls to the observers on next., on completed and

on error are called on whatever scheduler you provide.

On Android, we need to do UI work on the main UI thread.

That's why the Rx Android companion library contains

the AndroidScheduler.mainThread class.

Using this scheduler ensures your observer receives OnNext on the main UI thread.

RxJava includes other scheduler's by default,

such as, schedulers.IO which is useful for performing long live calls.

So how would you move your long work off the UI thread?

The subscriber on operator specifies a scheduler on which the observable

should operate.

It's important to note that subscribe on can be called in

any order of your chain of operators.

The last call to subscribe on will determine which scheduler is used for

that observable.

Now that we've gone through the basics of the RxJava API, let's dive into an app,

and convert it to use what we just learned.