We just finished putting together all the pieces that make up a widget but

it doesn't do very much.

Let's see if we can't spice things up a bit by making it so

that when we tap on the widget, it randomly changes color.

Normally, we would be able to do this by adding an OnClickListener to our frame

layout.

But since our views are hiding inside a remote views object,

we're not going to be able to do that.

Instead, what we can do,

is set a pending intent which we will fire off when we click on our frame layout.

And we're going to make that pending intent trigger a call to onUpdate,

where we'll update the color of our widget.

Let's start in our widget provider and add some space between where

we declare our remote views and where we update our widget.

Then we need to create a pending intent but in order to create a pending intent,

we must first create a regular intent.

So let's create a new intent, named intent.

And let's pass in our context for the first parameter, and for the class,

let's pass in our widget provider.

Then on the next line, let's call intent.setAction and

pass in AppWidgetManager.ACTION_APPWIDGET_UPDATE.

Then let's add another line and

let's add our app widget IDs as an extra to this intent.

Intent.putExtra and for the name, let's pass in

appWidgetManager.EXTRA_APPWIDGET_IDS and

let's finish up by passing in appWidgetIds for the value.

Now that we've got our intent,

we just need to use this intent to create a pending intent.

Let's add two lines and then create a new variable to hold our pending intent and

let's set it = PendingIntent.getBroadcast, which takes in four parameters.

I'm going to do these each on a separate line to keep things visible.

The first parameter is the context, which we've already got access to.

Next, we've got the request code, the request code is just a way for

us to differentiate between two similar pending intents.

Pending intents get stored in the Android system, and

they're not stored individually.

If there's an existing pending intent that looks just like yours does,

Android's not going to create another one.

But if we'd like Android to create another pending intent,

we can pass an unique request code to make Android think that this one is different.

Also, if you want to know if Android thinks two pending intent's are the same,

just use the intent.filter= method.

That said, we're fine just passing in zero.

Next, we need to pass in our intent, and finally,

we need to add any flags to specify how to handle our pending intent.

Let's pass in PendingIntent.FLAG_UPDATE_CURRENT.

This way, if our pending intent already exists, then we'll keep it and

we'll update its extra data with the new data in this version.

There's a few other options for flags and if you'd like to read more about them,

there's a link below in the teacher's notes.

All right, last but not least,

we need to attach this pending intent to the frame layout in our widget.

To do this we can just use the set on click pending intent method

on a remote use object.

So on the next line let's type removeViews.setOnClickPendingIntent and

then for the view ID let's pass in our frame layout R.id.frameLayout and

then let's pass in our pendingIntent for the pending intent.

And now, whenever we tap on one of our widgets,

it will trigger a call to this onUpdate method, awesome.

But we still haven't done anything to make it change color and

we'll get to that in the next video.