With all this working, I wanna show you how you can set up multiple

APIs within a single app using Retrofit.

So you may have in your app, connecting to Twitter, Facebook, Imgur, multiple APIs.

And to do that, it's really easy.

So in this app as an example what we're gonna do is

we're gonna think of the Imgur API as kinda two different APIs and

that's the anonymous and the authenticated.

So we've been using the authenticated API thus far where the user has to sign in and

we upload images on their behalf.

The next part we want to do is add the ability to anonymously upload images and

it turns out it's a really straightforward and

easy because retrofit makes it really easy.

So first we need to do is add a new API and just like we did it for

our interface for authenticating off, we're gonna do the exact same thing.

We're gonna add a new interface for Anon.

And we only have one method that we want which is the uploadImage and

it turns out it's the exact same as our uploadImage from before.

It looks the exact same so I'll just go ahead and copy that over.

So if you're using completely different APIs like Twitter or Facebook,

you would just have a different interface with the names of each one of those.

So here we have the upload image to the exact same API end point, but

we're gonna do it anonymously.

The next part we add to the service.

So here we can just add a new method, and it actually looks

basically identical to this one that we've already done so let's go and copy that.

Put it in here and instead of off the API it's gonna be AnonApi and

it's 'gonna return back to the Anon interface instance.

Same base URL, same clien, Gson factory is all good.

The only difference here is, we're not gonna have the access token anymore.

The access token was only given to us when we signed the user in and,

we're not gonnas have the user sign in for this.

So instead, the documentation, which I've linked to in the teacher's notes,

says that we can still upload anonymously.

We just have to change the header for the authorization,

and that's we're gonnas do here.

So, instead of the Bearer, what we do is we just say our Client-ID.

And we kept track of that earlier, so let's go ahead and get it.

And that's the only difference between these two APIs.

One uses the Client-ID the other uses the access token.

So now we can go ahead and head back to our main activity and

add the ability to anonymously upload.

We already have a button for that uploadAnon, it's gonna go down there.

And here will just add a method like we did before,

this one is called uploadAnon and it's actually,

nearly identical to this other one because the API is pretty much the exact same.

So let's just copy this, paste it and change the name.

And it can indicate that it's Anon.

And then we just need to get the other APIs.

So get the AnonApi..

It turns out it's the exact same parameters.

So that's all the same, already in the same file.

The only difference here is what it comes back,

when i'm gonna fetch the account images here because we're not signed in.

So instead of that what we wanna do is let's go ahead and

just go to this newly uploaded image and that has a URL.

So when this comes back we get the image object and we're going to

grab the URL which they call little link and then just direct the user to that.

So we can do that using an Intent.

So we'll say startActivity, new Intent,

Intent.Action_VIEW and we just need to parse the URI.

And we're gonna get that from our response.body,

data which is the image, link.

So if we successfully upload this image we should then mean directed to

the browser where that image resides with a URL.

So let's run this and we can see how the user would upload it anonymously an image.

So in this case we haven't signed in yet.

But we have the upload anonymous image option.

So let's go ahead and choose it.

And we can see that when I came back, we were able to fetch that URL and

go to the browser to show that image that we just uploaded.

Now that we've used Retrofit,

you can see how easy it is to add new API calls to your apps.

It handles the hard parts with it's easy syntax and friendly callback mechanism.

You can also see the power retrofit in ok HTTP

have to customize requests however you need.

I can't wait to see what kinds of apps you all come up with next.