We've already seen how to bundle up a song and

send it by an intent from one activity to another.

We'll do the same thing here to send it from one app to another but

we need to create a custom intent and a custom intent filter in a second app.

Let's do this from detail activity, where we already have a specific song chosen.

I already created a menu option for us.

So, all we need to do is define our new intent and

share it when that menu option is tapped.

First we need a song though.

Right now it's only available here in the onCreate method

because that's the only place we are using it.

I've also already seated these starter files with a member variable mSong.

So let's just switch that.

So we'll change song to mSong, and we'll do the same thing down here,

mSong, and over here, msong.

Okay, now let's scroll down to the methods for the menu.

First is the create method, and then we have the onOptionsItemSelected,

which is called when a menu item is Selected.

Now it's good practice to check the item id and then perform actions on it,

we only have one item id but let's follow the best practice and check it, so

if we expand menu and look at the detail XML, we see that the id is action_ share.

Let's go back here at a test, if ItemID = r.id.action_share.

Then we want to share the data.

Let's play it safe in here and add a check to make sure that our song isn't null so

if Msong does not equal null then we will continue.

Let's create a custom intent CustomIntent equals a new Intent.

What we really need is a custom action.

It's just a string value, but we want it to be unique so that it doesn't collide

with any other custom actions that any other developers might have made up.

Common practice when we need to use unique values

is to prefix them with the package name.

So let's create a constant to use down here.

Up at the top let's add public static final string.

And let's call this share_song.

Let's set this equal to the Packers name, come.teamtreehouse.

And then I'll follow the intent.ActionPattern used by Android.

We'll finish with .SHARE_SONG.

Let's go back down and use this in our constructor.

So now we pass in SHARE_SONG.

And now we can add the song as an extra since it's parsable.

customIntent.putExtra(mSong).

Whoops I forgot to pass in a key.

Let's add that.

We'll use the same one as before, MainActivity.EXTRA_SONG, mSong.

There we go.

Finally lets start the activity.

But rather than just calling regular old startActivity

let's follow another best practice and use an activity chooser.

Let's revisit our handy intense and filters page.

And now we wanna look at Forcing an app chooser.

The app chooser is a nice feature because it allows the user to pick a specific app

and even make that app the default for that action for

given app We just need to create a second intent to create a chooser for

the actual intent, which we see down here.

So before we call this, let's create a second intent called intent

chooser equals intent.createchooser.

Then we pass in our custom intent and a title for the chooser dialog.

Let's say Share song, and now we can pass in chooser to start activity.

Now we can't try this yet because we don't have anything that can receive it, but

still let's take a look.

So let's pick one of the songs in our list and.

We got an error.

Let's take a look and see.

So, here in the stack trace we see that it is a NullPointerException and

it links to the offending line and I see what it is.

This is a common mistake I made it before.

We want to call the .equals method and

the Intent.ACTION said I want to switch it around the order.

Now right now get action might be N o and it's giving us a No pointer.

So instead we say intent.

ACTION_SEND.equals And then we pass in intent.getAction.

There that's better let's try this again.

So, now if we click on a song we're taken to the detail view.

And if we try the menu we can click on share song.

But now it's hard to see it says no apps can perform this action.

One of the good things about using a chooser like this is that we avoid

a runtime exception.

If we weren't using a chooser we would need to add another check like we did

before by calling result activity and checking the package manager for handlers.