Let us start by talking a bit about the tricatch block we have in our code.

The idea here is that if something bad happens in our app, the Java runtime

system will kind of raise a little flag that says something is wrong.

If we are on the lookout for these flags, we can handle them appropriately and

save our users from a crash or bad experience.

The act of raising that little flag is called throwing an exception

when we must catch them in code in our app.

A lot of methods we use throw exceptions like these.

The response.issuccesful method is one example.

It throws a specific type of exception called an IO exception.

Which stands for input output exception.

Specific exceptions like this are typically

subclasses of a base class called exception.

What can we do about them?

We need to wrap our code in something called a tri catch block,

like we have here.

Our code then is essentially saying, try to check if the response is successful.

If so, do something.

In this case, output to the log the forecast data.

If it fails with an IOException, run this other code to handle the exception.

Otherwise, we just proceed as normal.

In this specific case, we are just logging the exception.

But we could take other appropriate action as well.

Next, let's talk about how to handle the case where the response is not successful.

We want to add an else block here.

Down under the if, I like to drop this down.

That's just a matter of personal taste.

So inside here let's Log.v(TAG).

It would probably be helpful to know what the response looks like.

Response.body().string.

Now to make our code follow the dry principle of, don't repeat yourself.

Let's move the log statement up here to the top of the try statement.

We can get rid of that one.

Now it would be great to alert the user about the error somehow.

After all, they won't see the log messages in the app.

Let's create a new method inside our else statement to do just that.

Call it alertUserAboutError.

You can come over here now.

Hit Alt + Enter.

For the quick fix pop-up, we want to create a new method or

alertuUserAboutError.

And we wanna create it here in MainActivity,

not in this anonymous inner class.

We want the main activity.

Scroll up a little bit.

Inside our new method,

we want to do something to visually alert the user that an error has occurred.

We could certainly use a toast as we've seen before.

But the issue with toast method is that they only stay on the screen for

a short period of time.

If we want to make sure the user sees a message,

we should use something that requires them to confirm or dismiss it.

Android provides a nice way to do this with dialogues.

Let's go to the Android docs and check out the documentation for dialogues.

Dialogs pop up over the activity and ask the user to do something.

You're probably familiar with them in other apps, and

this is a great use for them.

They can be simple or quite complex.

We'll just build a simple one for our StoreMe app that has an error message and

an OK button.

We scroll down on this page a little bit

We read that we should use a dialog fragment as a container for our dialogs.

Now, it is kind of a lot of code for

what appears in the app as a pretty simple thing.

The good news though is that once you have this example working,

you'll have code you can easily reuse and adapt in the future.

Let's head back to Android Studio into our code and add a dialog to our app.

So first, we'll need a new class for

that dialog fragment, as mentioned in the documentation.

We can do that here in the Project pane.

Select Java, To New Java Class.

We'll call it AlertDialogFragment.

And for the super class, we will want to

put in android.app.DialogFragment.

Everything else is okay Fragments

are similar to activities and are very useful in certain situations.

We'll cover fragments in more depth in future projects.

For now, we need to override one key method from dialog fragment.

Type onCreateDialog and hit Enter for auto-complete.

The method will be called when we create the dialog.

We will do this from our activity in a moment.

We need to add code here to configure the dialog.

To do that, we will use a special dialog class called AlertDialog.

So we can delete this line here, And replace it with the following.

AlertDialog.Builder.

Builder, option enter for inputs.

And we want that first one there.

Not the support.

We want a new AlertDialog.Builder.

Now we need to pass in the context.

Normally we would use this or

activity.this to refer to the current context which has been the activity.

However, now we're in a different class so what do we use for our context?

Fortunately, the DialogFragment class that we're extending

has a useful method to get the activity where this DialogFragment was created.

We call it with getActivity which will?

Yeah, you guessed it, give us the activity and the context we need.

So we can put in, getActivity.

Let's actually make it into a variable as well, that will be useful shortly.

So context context, do our imports, Get activity.

And then we can pass in contacts down here.

Notice that our data type is alertDialog.builder.

Builder is a nested class inside the alert dialogue class.

As a quick side note here, the reasons for

this have to do with a software design pattern called the factory method pattern.

I've put links in the teacher's notes for further reading on this.

Now is a great time for a quick break.

When we get back, we'll setup this alert dialogue.