In an app that creates something, pictures, video, sounds or

whatever, we need to decide where to store the output.

Do we want it to live on if our app is deleted or

should content created by our app be deleted as well?

In this case, we're going to save our pictures and

videos to the photos up and let it stay even if our app is deleted.

Users can delete pictures from the photos app manually if they want.

All right, so we are set in the takePhoto method.

Let's go back down to our getOutput method,

and here before we return anything, let's add a few steps in comments so

we know what we're doing, then we'll fill in each piece.

So first we want to get the external storage directory.

Then we want to create a unique file name.

Thirdly, we will create the file.

And then finally, we will return the file's URI.

For step one the method we want returns a file object.

So let's create a file variable named mediaStorageDir for directory.

The file object can be either a file or directory.

We will set this with a special method called getExternalFilesDir.

This method requires another environment constant as a parameter.

So let's type Environment.

And then look at the list here.

There are a few different options here and I'd recommend checking out the environment

class documentation to understand when they're useful.

We want to use directory underscore pictures.

Because it will allow our photos and

videos to be stored in a place that will exist even if our app is deleted.

Now before we go on I just want to point out one thing.

Getting the external files like this works on newer releases of a Android.

But depending on your device and the version of Android it's running

you may need to do it a little bit differently.

I'll put some additional information in the teacher's notes, but

just know that if you're having trouble with this you might need to investigate

how you're getting the external files directory.

So next we need a unique file name for the file that will hold the image or

video in return its URI.

If we use the same name then the file would get overwritten with each

photo or video.

So a common practice is to append a timestamp in the name itself.

In the interest of time I'm going to paste this code in but it's available for

you to copy and paste in the teacher's notes.

All right, so let's check out what I just pasted in I'm going to move this over

a little bit and center the code.

And the first thing I have is an error because I can't resolve

the day classify it.

If I hit all plus enter, I wanna import the class and

I want the java.util version not the java.sql version.

So what we're doing here is we're creating a file name and adding a file type.

The unique timestamp is formatted with this simple date formatter.

And then based on the type of request are doing if it's an image we're going to

prefix it with img append the timeStamp and then use the .JPEG file extension.

Otherwise, if it's a video then we will prefix with vid,

do the timeStamp and then add the file type of mp4.

So next for step three,

we can create a temp version of the file where the photo will be stored.

We need this file to exist for the camera to work correctly.

So let's say, File mediaFile = File.createTempFile and

then get pass in the parts that we defined up above.

FileName, fileType and the directory mediaStorageDir.

Let's add a log statement here to take a look at the file path being created.

Log.i TAG File: then + Uri.fromFile and

we can pass in mediaFile.

Okay now we're getting an error here because this is throwing an exception so

we need to handle it.

So let's say try these lines and

then we'll catch an IOException named E.

And here all we will do is add a log statement Log.e TAG,

we’ll say error creating a file colon and

then we'll add to this mediaStorageDir.getAbsolutePath

plus the file name, plus the file type.

Once again I'm gonna drop this down just so it will all fit on the same screen.

Now we're finally ready to return the URI that we need.

We can us a URI class method to get the URI for a file object.

So we say instead of return null let's return

Uri.framefile mediaFile.

Oops and I got my scope wrong because I declared

media file inside of the try blocks so now I need to move it out here.

Let's say file mediaFile was declared up here at the same level of scope and

I can get rid of the file keyword.

That's right, we only want to return this inside of the try block, so

let me cut that from here.

Pasted up here and again if anything goes wrong we will catch the exception and

then down here at the bottom we will return null.

Okay, let's run this and see what happens.

Okay so our app has started.

Let's try capturing a photo and get that green box right there.

I'll hit the check mark.

And we come back to main activity and now if we look over here we can see in the log

that the actual file path for the photo, cool.

Look at this and all the way over to the right,

we see that image with the unique timeStamp that we created.

Now the cool thing is this is an actual file path on the device and

we can go look at it.

So let's check it out in the Android device monitor.

So it's going to ask about disabling ADB Integration that's okay because

it's going to stop its connection with our emulator.

Okay, so the device monitor has our emulator listed over here on the left and

I want to change to the file explorer tab.

And then I'm going to walk this same path storage emulated zero etc., etc.

Let's go here.

We’ll click on storage and emulated and

it looks like I'm gonna have to pull this over to see more, Zero > Android >

Data > com.teamtreehouse

> files > Pictures and finally, the actual image itself.

Now we can't see it from here, but we can save it to our local computer.

So I'm going to save this to my home drive.

And check it out, here in finder I can see the image file itself and

it's a great shot of that green box almost on the left side of the screen, cool.

All right, so let's close this.

I'm going to close the device monitor.

And in the next video,

we'll see how to view this saved photo inside of an image view.