Monetize your NativeScript apps with AdMob (part 2 - Android)

Or how to create a simple module when both iOS and Android come into play

This is the second part of the Monetize your NativeScript apps with AdMob blog. In part one I discussed how you can easily access and use the native API of a native framework in JavaScript, taking the AdMob library for iOS as an example. To do that, you only needed the existing AdMob documentation in combination with a few simple rules to translate the Objective-C API calls to JavaScript.

The popular mobile platforms, however, are two - iOS and Android. So, it would be fair if I cover Android as well. Moreover, further in this article as things get more interesting and we are close to having a cross-platform AdMob usage, I will show you what’s the recommended way of separating and isolating the native API calls in a NativeScript project. So, let’s begin.

Just like in the iOS case, we will focus on these two types of ads:

• Banners - These ads appear at the bottom of your application without interruption
• Interstitials - These ads appear from time to time occupying the whole screen estate

Following the documentations links above and with some help from the NativeScript documentation here is how to plug the AdMob SDKs in a NativeScript app.

Prerequisites

We made an important update in the latest version of NativeScript that allows calling Java methods of private classes. This will allow the usage of the Android AdMob API. Therefore, please check your version with:

tns --version

It should read 1.5.2

If this is not the case, update your NativeScript version following this documentation article.

Regarding the AdMob SDK itself, it is distributed as a part of Google Play Services. So, I extended my nativescript-google-mobile-ads-sdk plugin to have a dependency on Google Play Services.

We will enable our Banner and Interstitial ads in the same apps we created in Part 1 of the blog. Therefore, make sure you first uninstall the old version of the plugin from these apps:

tns plugin remove nativescript-google-mobile-ads-sdk

and then add it anew:

tns plugin add nativescript-google-mobile-ads-sdk

It’s coding time!

Using Banner ads

Just like in the iOS case, our Android banner will be hosted in a Placeholder on its creatingView event. Considering the existing iOS implementation, our code would look like this:


Now it’s time to set up a few important properties of the bannerView in the loaded event of the page:


The complete source of the pageLoaded function called for the loaded event of the page will be:


The intriguing thing here is the usage of the AdListener which is an abstract class in Java. When an object of that type is attached to our banner, it allows us to handle various interesting events related to the banner - for example, when the banner is clicked and this puts the app in the background in favor of a browser with the landing page related to the ad.

Here is the result:



The complete iOS + Android source code of the Banner NativeScript app can be found at GitHub.

Using Interstitial ads

Again... interstitials… these ‘disrupting the UX’ ads… Let’s see how they are implemented.

First, we should create the interstitial on the loaded event of the page, or in other words, in the pageLoaded function:


As you can see, we are again taking benefit from an AdListener object attached to our interstitial. Actually, in the case of the interstitials, it’s not just our own scenario which may require the use of AdListener, but it’s the Google recommendation which makes it necessary. Because, we should prepare the next ad request the moment we close the previous interstitial, which happens on the onAdClosed function. And, here is the loadAndroidAd implementation:


Finally, we should display the interstitial. In our sample case we do that on a button click. In a real-world scenario, this would happen between two important events in your app, like two game levels. Make sure you do not annoy your end-users too much. :)


Tap the TAP button to see the result:



The complete iOS + Android source code of the Interstitial app can be found at GitHub.

But...wait a minute! All these platform checks… it’s madness! Can we do something about it? Yes, we can!

If you check the given GitHub repositories above you may not find the code there very pretty. We have just a few platform checks in our case, but in a real-world project with quite a rich native SDK, the platform checks may kind of uglify your code. If you are a fan of the clean code, just like me, then you can isolate the iOS and Android native API calls into a module.

If you check the tns-core-modules under the node_modules folder of the project, you will notice that a module mainly consists of modulename.ios.js, modulename.android.android.js, modulename-common.js and package.json . Well, as you may guess the modulename.ios.js contains the JavaScript calls to the native iOS API and the modulename.android.js contains the JavaScript calls to the native Android API. And on top of that we have modulename-common.js to expose unified API, so that you don’t bother with calls to the native APIs yourself. 

NativeScript is smart enough to load only modulename.ios.js when run on an iOS device and modulename.android.js when run on an Android device. 

Banner ads

Using the feature discussed above, let’s create  bannerview.ios.js and bannerview.android.js and put the appropriate API calls there, thus avoiding the platform checks in our main-page.js file.

iOS

For the bannerview.ios.js file we will expose two static method - the first one will create the banner instance and the second will set a few important banner properties:


This is it with the iOS, part. Now to the Android one.

Android

In Android we should create the same static methods, this time filled with Android native API calls:


main-page.js

The fact that the methods declarations in both files are the same allows us to simply call them in our main-page.js file and NativeScript will take the appropriate file (bannerview.ios.js or bannerview.android.js) depending on the platform the app is run at. Here is how simple main-page.js becomes:


Note how that we are loading the bannerview module at the top.

You can get the complete source code of the bannerview module at GitHub.

Interstitial ads

Let’s do the same exercise for the interstitial ads. First, create two js files - interstitial.ios.js and interstitial.android.js. 

iOS

In the interstitial.ios.js file we will expose two static method - one that creates the interstitial and one that shows it:


Android

As expected, we should also create and expose two static methods for Android doing the same:


main-page.js

Finally, thanks to the code separation and abstraction, here is how simple the main-page.js looks now:


Simple, huh? Get the complete source code of that modulized example from GitHub.

Now you know how to directly use the APIs of a native library by only referring to the documentation of that library and the NativeScript documentation. And, you also know how to extract the native API calls in a module thus keeping your code clean and tidy.

Stay tuned for the introduction of the verified AdMob plugin at the {N} Verified Plugins Marketplace.

For more information and updates on NativeScript, please follow @nativescript at Twitter or follow the NativeScript project.