[MUSIC PLAYING]
Hey, hey, everybody.
I'm Andrew Brogdon, and welcome back to the Mobile Ads Garage.
Today, with the help of my partner, Gary, the graphics
guy, we're going to talk about rewarded video, a full screen
video format from AdMob that can help you monetize
while increasing engagement with your users.
We'll have screencasts and talk implementation, but first--
well, yeah, yeah, with Katie-- super nice engineer,
by the way--
that covered reward video, but only through mediation.
But now, AdMob has launched its own rewarded video demand.
That means you can get rewarded video ads right
from Google's advertisers with no mediation
or third-party SDKs required.
Well, yeah.
Dude, I had a baby.
I was in the room.
Do you know what it's like to chase a two-foot tall version
of me around a house?
All right, I'm going to get back to talking to YouTube now.
If you haven't used it before, rewarded video
is a full screen ad format that gives users the option
to watch a video in exchange for something, usually
an in-game reward.
Because users have the power of choice,
they don't have to see ads they're not interested in.
And the ads they do see are presented in full.
That dynamic allows publishers to build monetization
into the mechanics of their games,
offering different paths within an adventure or items
that affect game play.
And that's key.
We've seen publishers who, after integrating rewarded video,
saw an increase of overall user engagement and long-term value.
All right, so that's the what and the why.
Let's get to our screencast and implement rewarded video
in Android Studio.
OK, so I've got a real basic Android app here.
It's just got a button to display an ad along
with a text view that's going to keep a log of events as we go.
And I'm just to wired up to load an ad and show it.
So how do I do that?
With these steps.
So first, I'll make sure that the SDK's initialized.
Then I'll set up the listener that will keep
me wired into the ad lifecycle.
And after that, it's just loading the ad,
showing it, and making sure I catch
the rewards that come out.
So step one, initialize the SDK.
Normally for these videos, I start
with the SDK already imported.
But I wanted to be sure to mention that Google recently
started distributing the SDK via Maven and not
in the SDK manager.
So I'm here in my apps project level gradle file.
And you can see this Google line here.
That's new for Android Studio 3.0, which will, hopefully,
be released before this video makes it to YouTube.
If you're using version two, though, you
could just add the Maven repo manually like this.
Here we go.
And the URL's just maven.google.com.
And this way, studio will know which
repo to use to go get the SDK.
So once that's done, you can go into the app level gradle file
and add the mobile ads SDK the same way you normally
would before.
It's just com.google.android.gms and then Play Services ads.
And always make sure you're using the latest version.
Right now, it's 11.4.2.
All right, so with that in place,
let's head into my activity file and make
the call to initialize the SDK.
You only need to do this once in your app per execution.
Although, if you do it more than once, it's not a big deal.
And I'm just going to call the static method, initialize.
And I'm giving it a context and an app ID.
Since this is just a test app I'm messing around with
and not a real published app, I'm
actually using the App ID from our quickstart guide, which
you can use as well if you're just playing around
with the SDK.
So don't publish with it, of course, but it's
fun for testing if you're just playing around with the SDK
and it's API.
All right, so step one, done.
Let's move on to the listener.
First, I'm going to come up here and add to my class
the rewarded video ad listener interface so my activity can
serve as the listener for the ads
and get callbacks for events in the ad life cycle.
Then I'm going to use Android Studio's implement methods
right there to do some code generation.
So it's going to stub out these methods.
And let's talk about them.
So I've got the big seven here.
Number one is the ad loaded callback.
This gets fired when an ad loads successfully.
Then I've got ad opened.
That will get called when an ad opens and covers the screen.
Video started, of course, for when the playback starts.
Ad closed for when the ad is closed,
and you've returned to your app's UI.
Then on rewarded, this is the reward item callback--
we'll get back to this toward the end in step five.
Ad left application, this is called
when focus leaves your app to go to the Play Store
or destination URL.
And then ad failed to load, which
has an error code to let you know
that a load add call failed.
OK, so I'm just going to drop some log statements in here,
and I'm going to leave the reward callback blank for now.
Like I said, we'll come back to that one in just a second.
And I'm just going to put some text in here,
so I can see it in that text view.
OK, now I'm going to scroll back up
and make a member variable that's
going to hold a reference to the rewarded video ad singleton.
And here, I'm going to retrieve that reference using
a static method in the mobile ads class.
Unlike all the other formats, rewarded video
uses the singleton pattern.
So rather than instantiating individual objects yourself
for each ad, you just need to grab a reference in the SDK
and hang onto it.
All your calls are going to go through as one object.
And now that I have that reference,
I can set this activity as the listener for rewarded video
ads.
And I'm wired up.
Cool.
So that's two steps down.
Time to load an ad.
Video ads are big, so it's a good idea
to load them well in advance and make sure they're ready.
I'm going to load mine as soon as this activity's created
by calling load ad.
And I'm going to give it an ad unit and a new request object.
And that's the same ad request class used
for all the other formats, so the usual methods for options
and targeting and stuff, those are right there in place.
And the ad unit I'm using here is a test unit.
It will always return test ads, which makes it
safe to use while developing.
You can find that same ad unit right here
in our rewarded video guide.
And you're welcome to use it in your apps.
If you're just starting out, you haven't registered
an ad unit of your own, or any time you're debugging
and just want to make sure you get test ads,
you're welcome to use this one.
All right.
So if I launch my app now, I should see it in ad loads.
And there it is.
Cool.
All right, on to step four, showing the ad.
First, let me just slip a little line in here
to enable the button when it loads.
I'm going to put that into the on ad loaded callback,
so my button will be lit.
Perfect.
Now I'm going to go up to the click listener for the button.
And I'm going to disable it when it's clicked,
because we'll be showing an ad.
And then I'm going to check the page is loaded method
to make sure I've got an ad ready, and then show.
Now, technically, I don't really need
to do the is loaded call because I know, for a fact,
I've got an ad.
But it's a good practice to get in the habit of doing,
and so I do recommend it.
All right, let's run it again.
And I've got an ad loaded.
Let's show it.
And there's my test ad.
All right.
So one step left, and that's to reward the user when
they watch a video completely.
For that, I'm going to pop down to the on rewarded callback.
So this is fired when a user watches a video to completion.
And it's how your app knows to distribute a reward.
And it comes with this little reward item
parameter that includes the amount and type of reward.
And those will have the data that you put into the AdMob UI
when you make your ad units.
So depending on the ad unit, you might
want to have one that's 10 coins, for example,
and another one that rewards 37 sheep.
Whatever you put in, you're going to get out here.
They come in the form of a number and a string
description.
So I'm just going to log the reward
to show that it happened, but you
can do pretty much whatever you want
with this data in your own app.
OK, so let's run one last time.
There's my ad.
So I'll go ahead and click show.
And we just need to wait for this to finish.
Let me quickly say, by the way, that when
they asked me to record the video for the test ad,
I didn't think about the fact that people are going
to have to look at it, like, 50 times while testing
the rewarded code.
So if you get to that 50th go round and you're thinking,
dear lord, if I have to look at this guy one more time--
don't feel bad.
I completely understand.
The good news is we got the reward.
We got our 10 coins, though, so this implementation's done.
That's all five steps-- initialize,
set up the listener, load, show, and reward.
All right, so that's rewarded video in Android Studio.
Actually, that's kind of true.
Rewarded ads are a lot like interstitials
in that you load them in advance and then show them
at a pause in the flow of your app.
In fact, a rewarded ad is really just a video interstitial
with an extra callback to reward the user.
So with Android down, let's see how rewarded ads work in iOS.
For that, we're going to head in to Xcode.
All right, here's my iOS app running on the simulator.
I've got a button up top to show an ad,
and a log that will show events as they come in.
Now, how am I going to get this wired up
to show a rewarded video ad?
Well, here are the steps, and they're
almost identical to the ones for Android.
First, I'll initialize the SDK and set up
a delegate that will get callbacks
for the events in the ad lifecycle.
And once that's done, it's just load, show, and reward.
So first up, initialising the SDK.
Here's my AppDelegate.
And I've already got the SDK building
into this app via CocoaPods, so I can import it right here.
And then I'll hop down and call the class method for configure
on GADMobileAds.
And I need to pass that my application ID.
There we go.
Since this is just a sample app that's not really registered,
I'm using the sample app ID from our Get Started Guide
on the AdMob developer site.
If you're just messing around with the SDK,
testing things out, you can use this as well in your own test
apps.
Cool.
So that's step one.
Now, let's get the delegate going.
Here I am in my view controller.
And the first thing I'm going to do is import the SDK.
Then I'll make a property that'll
store a reference to the rewarded video singleton.
So unlike the other formats, rewarded video
uses the singleton pattern in iOS.
So instead of creating your own object for each ad,
you just grab a reference to the shared instance, which
you'll see right here, and then you
use that to make all your calls.
And that's all I'm doing in this step.
So next, I'm going to assign this view controller
as the delegate for that rewarded video singleton.
And Xcode's going to yell at me, correctly,
because my view controller doesn't implement the delegate
protocol.
So I'll pop up here, and I'll add that protocol.
There we go.
And I'm going to get a new error, because I don't
implement the required methods.
Now, XCode 9 has this new thing where
it will stub out the protocol for you,
but it only does the required methods.
And I want all of them, so I'm going
to do it through the magic of cutting and pasting.
This is like in a cooking show where
they make a roast turkey that has to go
in the oven for three hours.
And they put it in, and then, like, I just
happen to have this other turkey I put in three hours ago.
And they pull out the finished one.
So you can get these method signatures
from our reference docs.
They also auto-complete if you start typing them in.
Let me go down a list, though, and I'll cover each one.
So, first we have video ad did open.
This is called when an ad opens and covers the UI.
Then we have ad did close.
It's the opposite-- when an ad closes
and you go back to your app.
This is ad did receive.
This is the ad loaded callback, basically,
so this is where you get an ad.
Ad did start playing, that's for when video playback begins.
Ad will leave application, that's
when somebody clicks through on the ad
and goes to the app store or destination URL,
YOU get that one.
This is did fail to load, which is called
when an ad fails to load.
You get an error code explaining the problem.
And finally, did reward user with reward--
and that's the reward callback.
We'll cover that in step five.
Cool.
So the view controller is now set up
as the delegate for rewarded video ads.
That's all the methods.
Let's load an ad.
I'm just going to call the load method.
First, I'll pass it a GAD request object.
And this is the same request class used for other formats,
so the same options and targeting methods are there.
And I'm also going to give it an ad unit.
And since I'm just messing around here
and need to use test ads, I'm actually using the ad unit
from our rewarded video guide-- which you can use too.
It's specially configured to always return test ads.
So you can mess around with it, load ads, tap on them,
click on them, whatever you're going to do,
and you don't have to worry about it.
Cool.
So if I build this, I should see an ad get loaded.
And there it is.
Cool.
All right, so I've got an ad.
Let's show it.
First up, my button for showing an ad
starts off disabled, so I'm going
to need to enable it in the did receive ad delegate method.
This gets called when an ad loads.
And so I'll just enable that button, so I can press it.
Now, I'm going to scroll back up to the action
method for that button.
And first, I'll disable it.
Since we're going to show, we want to disable the button.
And then I'm going to check the is ready property
and call present.
The is ready check here isn't really necessary, since I know
for a fact that I just loaded an ad,
but it's a good idea to call it anyway.
It doesn't take much time.
It's a good thing to check on each show.
All right.
So if I build and run this, let's see what happens.
All right, there's my ad.
And we click the button, and there's our test ad.
Cool.
So, just one step left, and that's
to reward the user when they watch a video to completion.
And that's done in a did reward user with reward delegate
method.
This method is invoked whenever a video is
watched to completion and the user
needs to be given their award.
So I'm just going to log this info,
but your app or game can do pretty much whatever
you want with the reward data.
It arrives in a GAD ad reward object,
which has two properties, amount and type, for the reward.
It's going to be set to whatever you entered when you created
your ad unit in the AdMob UI.
In this case, I think it's 10 coins,
but it's literally just a number and a string.
It can be almost anything you want.
All right.
So now when I run this--
get the simulator back up.
And I'll click show ad.
And we just need to watch this to completion,
and that reward callback will be fired.
So we're watching a video of me in a video of me.
I'm basically incepting.
There we go.
Cool.
So if I close this, there's my reward callback
just before the I close callback.
All right, so that's all five steps.
Rewarded video ads are finished for iOS.
Job done.
And that's rewarded video.
For links to our guides for Android, iOS, and Unity,
plus samples on GitHub, check the description below.
We've also got a link down there for our support forum
if you run into any problems.
And as always, if you've got a question about this episode
or an idea for something you'd like us to cover,
leave a comment below, and Gary and I will see you next time.
[MUSIC PLAYING]