We just finished creating our loader, but we still haven't seen how to use it.

But before we get to that,

it looks like I forgot to delete this percentProgress line.

So let's do that.

Okay, now it's time to get back to deleting our AsyncTaskClass.

Over in MainActivity, let's start by deleting our AsyncTaskClass.

And let's also delete this new MyAsyncTask line.

Next, we need to implement a few callbacks to help us interact with our loader.

Specifically, we need to implement LoaderCallbacks, and

make sure we're picking the option from the support library.

And let's use a bitmap array for our type parameter again.

Then let's use Alt+Enter to implement the three required methods.

The first method is onCreateLoader.

In this method, we need to create a new instance of our loader and return it.

So since our loader requires a URL as a parameter,

let's first cut and paste the URL code into the top of this method.

Then, right below the URL, let's return a new instance of our loader.

return new MyAsyncTaskLoader, and

passing in this for the context and url for the URL.

I'd love to get rid of this return null as well, but

even though our URL isn't malformed, we've still gotta catch the exception,

which means we need to have a return down here.

Well. Moving on to onLoadFinished,

this method is called when your work is done and is where we should update the UI.

So let's first update the data, our adapter is based on.

myAdapter.bitmaps = data.

And then let's notify our adapter that the data has been updated.

myAdapter.notifyDataSetChanged.

Nice.

The last method is onLoaderReset.

If your loader's been reset, then it no longer contains any data.

So if you've got any references to data in your loader,

you'd want to clean those up in this method.

Since we don't have any way to reset our loader, we're fine leaving this empty.

Now that we've implemented our loader callbacks,

all that's left is to start our loader.

At the bottom of onCreate.

Let's call getSupportLoaderManager().initLoader().

Then let's pass in an arbitrary number for the ID, I'll choose 1.

And an arguments bundle, which we don't have, so let's just pass in null.

And finally a LoaderCallbacks object,

which we've implemented right here in this activity.

So let's just pass in this.

And before we forget, let's make sure to show our progress bar while we're loading

and hide it once we're done.

So at the top of OnCreateLoader,

let's add progressBar.setVisibility to View.VISIBLE.

And then at the top of onLoadFinished, Let's set it to gone.

progressBar.setVisibility(View.GONE); All right, time for the moment of truth.

Let's run the app and see what happens.

There's our progress bar, and now we've got our images.

And if we rotate the app, Awesome, it's the same images!

So instead of re-downloading all of those images, we just used our cached images and

made for a much better user experience.

When you've gotta do something in the background and

you're worried about the activity lifecycle, just use a loader.

Since a loader will stay alive through a rotation, it's a great

place to do your loading and keep any data safe from being destroyed in an activity.

If you'd like to learn more about loaders, check out the teacher's notes below.

And as always, if you've got any questions or would like to try your hand at

answering someone else's question, be sure to check out the community.

Until next time.