Now we're going to change this broadcast receiver to only work when our

activity is running.

Let's start by commenting out our manifest receiver.

We can select it all, and hit command plus forward slash.

Or control plus forward slash on Windows.

Now we can work in main activity.

So let's open that back up.

And we'll start by adding a field for our receiver.

So up at the top let's add a new private

NetworkConnectionReceiver and let's call it mReceiver and

now let's set it here equals a new NetworkConnectionReceiver.

Okay, so think back to the activity life cycle for a moment.

Which events do we use to make sure that something is only running when an activity

is alive and visible?

That's right, onResume and onPause.

Let's scroll down to the bottom.

And here we already have onStart and onStop.

So I'm gonna group them together and add onResume and below that, onPause.

All right, first things first let's add some log messages for

what's going on with our activity.

Log.i(TAG, and then App is in the foreground.

I'm going to copy this paste for pause and

say App is in the background and

now we want to register in on resume and unregister in on pause.

First thing we need to do to register is to declare our intent filter in code.

We're just building the same thing we had in the manifest.

So here in on resume, let's say,

IntentFilter, let's name it filter equals a new intent filter.

And we'll use the same value we had in the manifest,

android.net.com.CONNECTIVITY_CHANGE.

And now we can hook up our receiver and filter with registerReceiver.

We'll pass in mReceiver that we just set up top and this new filter.

We need to register in unpause with

unregister receiver and it's that same mReceiver.

All right and now we can test this out.

Okay let's get into the notification drawer and if we go back to log it, we can

scroll up a little bit and we see that our app is currently in the foreground.

So let's turn on airplane mode again and then let's go back to lock it.

And here is our connectivity change again, cool.

Now let's test it in the background.

So go back to our app and

we'll back out of it and here in logcat we see that the app is now in the background.

And now if we turn off airplane mode in this case we don't get a message for

the connectivity change.

Our receiver is no longer operating.

So which method should you normally use to register a receiver,

in the manifest or in code.

Well it depends on what you are monitoring for and when you need to act on it.

Usually you only want to listen when your activity or your service is running.

In which case, you'll register in code like this.

But occasionally, you may want to monitor for

things whenever they occur, even if your app isn't running.

In those cases, you'll need to register in the manifest.