Introduction

This article shows you how to set up AdMob with a libGDX app. This is current roughly with AdMob 4.0.4 and libGDX 0.9.1. The same instructions will work with Mobclix as well (and probably others), the only changes being the differences between the AdMob and Mobclix APIs. In the code snippets, I’m going to leave out the package and import lines for brevity. If you’re working in Eclipse, Ctrl-1 on any line showing an error will auto-fill-in the required imports.

I should note that this isn’t the only way to make this work. But it’s one approach that worked for me, so I decided to share it in the hopes that others might find it useful as well.

Please note that Google have deprecated 6.4.1 and earlier SDKs. For notes on how to use the new Google Mobile Ads approach, please see Google Mobile Ads. Thankfully the changes are very minimal from a developer/implementation point of view.

Background

Let’s look at the libGDX HelloWorld example and understand what it’s doing. There’s a HelloWorld class (in HelloWorld.java) that does all the libGDX stuff. There’s a HelloWorldDesktop class that creates and runs a HelloWorld on the desktop. And finally, there’s a HelloWorldAndroid class that creates and runs a HelloWorld on Android. Here’s what they look like:

HelloWorldDesktop:

  1. public class HelloWorldDesktop {
  2.     public static void main (String[] argv) {
  3.         new LwjglApplication(new HelloWorld(), "Hello World", 480, 320, false);
  4.     }
  5. }

HelloWorldAndroid:

  1. public class HelloWorldAndroid extends AndroidApplication {
  2.     @Override public void onCreate (Bundle savedInstanceState) {
  3.         super.onCreate(savedInstanceState);
  4.         initialize(new HelloWorld(), false);        
  5.     }
  6. }

HelloWorldIOS:

  1. public class HelloWorldIOS extends Delegate {
  2.     @Override
  3.     protected IOSApplication createApplication() {
  4.         final IOSApplicationConfiguration config = new IOSApplicationConfiguration();
  5.         config.orientationLandscape = false;
  6.         config.orientationPortrait = true;
  8.         return new IOSApplication(new HelloWorld(), config);
  9.     }
  10. }

They’re pretty similar. They all create a new HelloWorld(), and pass that into something that sets up the application. On the desktop that’s a LwjglApplication, on Android that’s the initialize() method and on IOS it’s IOSApplication(). Then the HelloWorld class does all the work of the application.

Let’s take a closer look at the initialize() method. There are two forms, and one of them calls the other. If you follow that code through, here’s the stuff that sets up an Android application:

  1.     public void initialize(ApplicationListener listener, AndroidApplicationConfiguration config) {
  2.         graphics = new AndroidGraphics(this, ...
  4. ...
  6.        requestWindowFeature(Window.FEATURE_NO_TITLE);
  7.        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
  8.        getWindow().clearFlags(WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN);
  9.        setContentView(graphics.getView(), createLayoutParams());
  11. ...

Let’s see what it’s doing:

  • Create an AndroidGraphics object with some parameters
  • Specify that the window has no title
  • Specify that the window is fullscreen
  • Call setContentView() with a View from the AndroidGraphics object, and some layout parameters

The last step hooks everything together, and sets up the Activity to use the libGDX view as its main (and only) View. I’m not going to explain what an Android Activity and View is, you can find that information easily enough with a Google search.

With that background, let’s look at what needs to be changed to add AdMob to the application.

Setup

To start out, follow the AdMob setup instructions as normal. Sign up, get your application key, configure your ad colors and refresh rate on the website, add the stuff needed to the AndroidManifest.xml file for permissions, activities, etc.

Initialization

The main thing to understand is that AdMob uses its own View. And we know that libGDX creates a View. If we call setContentView() with the libGDX View, then that’s what gets hooked up to the application, and there’s no place to add the AdMob view. So here’s what we need to do:

  • Create a Layout that can contain multiple views
  • Create the libGDX View, add that to the Layout
  • Create the AdMob view, add that to the Layout as well
  • Call setContentView() with the Layout

Let’s dive into some code. This example uses the RelativeLayout class, because I found it easy to get multiple overlapping Views on the screen using that. This assumes that you want your libGDX View to be full-screen, and the AdMob view to be overlaid on top. If you want some other layout, like the AdMob view sitting next to a partial-screen libGDX View, then you’ll probably have to use a different Layout and set it up accordingly.

First, create a RelativeLayout:

  1.         RelativeLayout layout = new RelativeLayout(this);

Easy enough. Then, we need to create the libGDX View. There’s a different initialization function, initializeForView(), that does this. It is similar to initialize(), but instead of calling setContentView() with the libGDX View, it returns the View to you so you can use it. The way you call it is identical to calling initialize():

  1.         View gameView = initializeForView(new HelloWorld(), false);

Let’s take a closer look inside initializeForView(). Again, there are two versions, and the bulk of the work is here:

  1.     public View initializeForView(ApplicationListener listener, AndroidApplicationConfiguration config) {
  2.         graphics = new AndroidGraphics(this, ...
  4. ...
  6.        return graphics.getView();
  7.     }

You’ll note that this time, the function didn’t do anything about setting the Activity to be full-screen, removing the title, and so on. Most likely, you will want all those things. So make sure you call them in your AndroidActivity:

  1.         requestWindowFeature(Window.FEATURE_NO_TITLE);
  2.         getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, 
  3.                 WindowManager.LayoutParams.FLAG_FULLSCREEN);
  4.         getWindow().clearFlags(WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN);
  6.         View gameView = initializeForView(new HelloWorld(), false);

That completes the setup for the libGDX View. Next, we create the AdMob view and kick it off by calling loadAd(). This assumes that you want it to start fetching ads immediately. If you want more customized behavior, then you’ll have to configure the AdView accordingly. I’m not going to cover that here.

  1.         AdView adView = new AdView(this);
  2.         adView.setAdSize(AdSize.BANNER);
  3.         adView.setAdUnitId("xxxxxxxx"); // Put in your secret key here
  5.         AdRequest adRequest = new AdRequest.Builder().build();
  6.         adView.loadAd(adRequest);

Now we have a Layout, and two Views. All that’s left is to add both the Views to the Layout, and then tell Android to use the Layout as the thing to display for the Activity.

Views get stacked in the sequence in which you add them, so make sure you add the libGDX View first, since you want that under the AdMob View. If you do the reverse, the full-screen libGDX View will hide the AdMob View, and you’ll be left wondering why your ads aren’t showing up.

Add the libGDX View. You can use the simpler form of addView(), because the libGDX View is full-screen, so there’s no positioning information needed.

  1.         layout.addView(gameView);

Now we need to add the AdMob View. Here, you probably want some more control, because you want to position the ads in some specific area of the screen. There’s another addView() that takes some layout parameters, so let’s use that. In this example, I’m telling Android that I want the AdMob View to be as large as necessary to show the full ad, and I want to align it with the top right of the screen (technically, it’s aligning to the top right of the parent, but the parent is the Layout which fills the screen, so it’s effectively aligning with the screen):

  1.         RelativeLayout.LayoutParams adParams = 
  2.             new RelativeLayout.LayoutParams(RelativeLayout.LayoutParams.WRAP_CONTENT, 
  3.                     RelativeLayout.LayoutParams.WRAP_CONTENT);
  4.         adParams.addRule(RelativeLayout.ALIGN_PARENT_TOP);
  5.         adParams.addRule(RelativeLayout.ALIGN_PARENT_RIGHT);

Then we add the AdMob View using these layout parameters:

  1.         layout.addView(adView, adParams);

And finally, all that’s needed is to tell Android to use this Layout:

  1.         setContentView(layout);

Putting all of that together, here’s what it looks like:

  1. public class HelloWorldAndroid extends AndroidApplication {
  2.     @Override public void onCreate (Bundle savedInstanceState) {
  3.         super.onCreate(savedInstanceState);
  5.         // Create the layout
  6.         RelativeLayout layout = new RelativeLayout(this);
  8.         // Do the stuff that initialize() would do for you
  9.         requestWindowFeature(Window.FEATURE_NO_TITLE);
  10.         getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, 
  11.                 WindowManager.LayoutParams.FLAG_FULLSCREEN);
  12.         getWindow().clearFlags(WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN);
  14.         // Create the libGDX View
  15.         View gameView = initializeForView(new HelloWorld(), false);
  17.         // Create and setup the AdMob view
  18.         AdView adView = new AdView(this);
  19.         adView.setAdSize(AdSize.BANNER);
  20.         adView.setAdUnitId("xxxxxxxx"); // Put in your secret key here
  22.         AdRequest adRequest = new AdRequest.Builder().build();
  23.         adView.loadAd(adRequest);
  25.         // Add the libGDX view
  26.         layout.addView(gameView);
  28.         // Add the AdMob view
  29.         RelativeLayout.LayoutParams adParams = 
  30.             new RelativeLayout.LayoutParams(RelativeLayout.LayoutParams.WRAP_CONTENT, 
  31.                     RelativeLayout.LayoutParams.WRAP_CONTENT);
  32.         adParams.addRule(RelativeLayout.ALIGN_PARENT_TOP);
  33.         adParams.addRule(RelativeLayout.ALIGN_PARENT_RIGHT);
  35.         layout.addView(adView, adParams);
  37.         // Hook it all up
  38.         setContentView(layout);
  39.     }

And that’s it. Now you should have ads showing on top of your libGDX app. If you want the ads to be visible all the time, this should be all you need to do. If you want to control when the ads are visible from within your libGDX app, then there’s a little more work left.

Control

This example will show you how to turn the AdMob View’s visibility on and off from within your libGDX app. Note that this is probably not the best way to control AdMob. If your ad View is invisible, but still fetching ads in the background, then you’re wasting ad impressions, and that will negatively impact your ad revenue. I’m not going to talk about the best way to control the AdMob view - that varies from application to application. Also, there are things you can do on the website, and things you can do in your app. So look through the AdMob documentation for more information on that.

The first thing you need to do is to make the AdView a member of your AndroidApplication, because you’ll need to refer to it later.

  1. public class HelloWorldAndroid extends AndroidApplication {
  2.     protected AdView adView;
  4.     @Override public void onCreate (Bundle savedInstanceState) {
  6. ...
  8.       adView = new AdView(this, AdSize.BANNER, "xxxxxxxx"); // Put in your secret key here

The next thing you need to understand is a Handler. This is an Android mechanism that lets you send messages between threads. The HelloWorld app runs in its own thread (let’s call it the ‘game thread’), which is different from the thread where you created the AdView (the ‘UI thread’). AdMob (and many other libraries, for that matter) gets cranky if you try to manipulate the AdView from any thread other than the UI thread. So what can you do? From the other thread, you send a message back to your UI thread. The next time the UI thread is scheduled to run, it picks up the message, and takes the action. All of this is handled by something called a Handler. Let’s see how you set that up:

  1. public class HelloWorldAndroid extends AndroidApplication {
  3.     private final int SHOW_ADS = 1;
  4.     private final int HIDE_ADS = 0;
  6.     protected Handler handler = new Handler()
  7.     {
  8.         @Override
  9.         public void handleMessage(Message msg) {
  10.             switch(msg.what) {
  11.                 case SHOW_ADS:
  12.                 {
  13.                     adView.setVisibility(View.VISIBLE);
  14.                     break;
  15.                 }
  16.                 case HIDE_ADS:
  17.                 {
  18.                     adView.setVisibility(View.GONE);
  19.                     break;
  20.                 }
  21.             }
  22.         }
  23.     };

That’s the part that will process the message. You’ve defined two constants - SHOW_ADS and HIDE_ADS. If the message contains either one of those constants, this code makes the AdView visible or invisible, as instructed.

That leaves two things:

  • Some code to send a message containing the SHOW_ADS or HIDE_ADS command
  • Some way to call that code from within the libGDX app’s game thread

There are multiple ways to solve that problem. One solution is to use an interface that defines functionality that the AndroidApplication can provide, like the ability to show and hide ads. Here’s the definition of such an interface. Note that this should go in its own Java file:

IActivityRequestHandler.java:

  1. public interface IActivityRequestHandler {
  2.    public void showAds(boolean show);
  3. }

This interface defines just one function, showAds(). If you later want to add other functionality that you need to call from the game thread and have it run in the UI thread, you can add more methods in here.

Now that we have an interface, our AndroidApplication must implement that interface:

  1. public class HelloWorldAndroid extends AndroidApplication implements IActivityRequestHandler  {
  3. ...
  5.     // This is the callback that posts a message for the handler
  6.     @Override
  7.     public void showAds(boolean show) {
  8.        handler.sendEmptyMessage(show ? SHOW_ADS : HIDE_ADS);
  9.     }

And there’s our implementation of the showAds() function. It’s pretty simple - it sends a message to our Handler. sendEmptyMessage is handy when the message only needs to contain a single code, as in this case. If you need to convey more information in the message, you’ll have to send a more complex message, and the Handler code for processing that message must change accordingly.

Now we have a mechanism to send a message to the UI thread, so that the UI thread can process it. Next, we need a way to get the game thread to call this functionality. To do this, the HelloWorld object needs to know about the HelloWorldAndroid object, so it can call the showAds() function. One way to do this is to define a constructor for HelloWorld that takes a parameter:

  1. public class HelloWorld implements ApplicationListener {
  2.     private IActivityRequestHandler myRequestHandler;
  4.     public HelloWorld(IActivityRequestHandler handler) {
  5.         myRequestHandler = handler;
  6.     }

That lets you save the reference to the IActivityRequestHandler that was passed in by the caller. Now, you can access myRequestHandler from anywhere in this object, so when you want to turn ads on, all you do is:

  1.     myRequestHandler.showAds(true);

Back in the HelloWorldAndroid class, we need to create the HelloWorld with this new constructor:

  1.         View gameView = initializeForView(new HelloWorld(this), false);

Note the this parameter in the HelloWorld constructor - that’s how you pass in a reference to the HelloWorldAndroid object to the HelloWorld object.

There’s just one thing left. Remember the desktop version - that needs to be updated to call the new constructor as well. To do this, HelloWorldDesktop must implement the IActivityRequestHandler interface as well, so HelloWorld has something on which it can call showAds(). But the implementation can be empty here, since we don’t have any ads to show on the desktop. We need to cheat a little here, because main() is a static function, so there’s no this when you’re in that function. The following solution works, but there are probably better ways of handling this:

  1. public class HelloWorldDesktop implements IActivityRequestHandler {
  2.     private static HelloWorldDesktop application;
  3.     public static void main (String[] argv) {
  4.         if (application == null) {
  5.             application = new HelloWorldDesktop();
  6.         }
  8.         new LwjglApplication(new HelloWorld(application), "Hello World", 480, 320, false);
  9.     }
  11.     @Override
  12.     public void showAds(boolean show) {
  13.         // TODO Auto-generated method stub
  15.     }
  16. }

That’s it. Now you can show and hide AdMob ads from within your libGDX app.

Code

Here’s the full code for the various classes, for completeness:

HelloWorldAndroid.java:

  1. /*******************************************************************************
  2.  * Copyright 2011 See AUTHORS file.
  3.  * 
  4.  * Licensed under the Apache License, Version 2.0 (the "License");
  5.  * you may not use this file except in compliance with the License.
  6.  * You may obtain a copy of the License at
  7.  * 
  8.  *   http://www.apache.org/licenses/LICENSE-2.0
  9.  * 
  10.  * Unless required by applicable law or agreed to in writing, software
  11.  * distributed under the License is distributed on an "AS IS" BASIS,
  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13.  * See the License for the specific language governing permissions and
  14.  * limitations under the License.
  15.  ******************************************************************************/
  16. /*
  17.  * Copyright 2010 Mario Zechner (contact@badlogicgames.com), Nathan Sweet (admin@esotericsoftware.com)
  18.  * 
  19.  * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the
  20.  * License. You may obtain a copy of the License at
  21.  * 
  22.  * http://www.apache.org/licenses/LICENSE-2.0
  23.  * 
  24.  * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS"
  25.  * BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language
  26.  * governing permissions and limitations under the License.
  27.  */
  29. package com.badlogic.gdx;
  31. import android.os.Bundle;
  32. import android.os.Handler;
  33. import android.os.Message;
  34. import android.view.View;
  35. import android.view.Window;
  36. import android.view.WindowManager;
  37. import android.widget.RelativeLayout;
  39. import com.badlogic.gdx.backends.android.AndroidApplication;
  40. import com.badlogic.gdx.helloworld.HelloWorld;
  41. import com.badlogic.gdx.helloworld.IActivityRequestHandler;
  42. import com.mobclix.android.sdk.MobclixMMABannerXLAdView;
  44. public class HelloWorldAndroid extends AndroidApplication implements IActivityRequestHandler  {
  46.     protected AdView adView;
  48.     private final int SHOW_ADS = 1;
  49.     private final int HIDE_ADS = 0;
  51.     protected Handler handler = new Handler()
  52.     {
  53.         @Override
  54.         public void handleMessage(Message msg) {
  55.             switch(msg.what) {
  56.                 case SHOW_ADS:
  57.                 {
  58.                     adView.setVisibility(View.VISIBLE);
  59.                     break;
  60.                 }
  61.                 case HIDE_ADS:
  62.                 {
  63.                     adView.setVisibility(View.GONE);
  64.                     break;
  65.                 }
  66.             }
  67.         }
  68.     };
  70.     @Override public void onCreate (Bundle savedInstanceState) {
  71.         super.onCreate(savedInstanceState);
  73.         // Create the layout
  74.         RelativeLayout layout = new RelativeLayout(this);
  76.         // Do the stuff that initialize() would do for you
  77.         requestWindowFeature(Window.FEATURE_NO_TITLE);
  78.         getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, 
  79.                 WindowManager.LayoutParams.FLAG_FULLSCREEN);
  80.         getWindow().clearFlags(WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN);
  82.         // Create the libGDX View
  83.         View gameView = initializeForView(new HelloWorld(this), false);
  85.         // Create and setup the AdMob view
  86.         AdView adView = new AdView(this);
  87.         adView.setAdSize(AdSize.BANNER);
  88.         adView.setAdUnitId("xxxxxxxx"); // Put in your secret key here
  90.         AdRequest adRequest = new AdRequest.Builder().build();
  91.         adView.loadAd(adRequest);
  93.         // Add the libGDX view
  94.         layout.addView(gameView);
  96.         // Add the AdMob view
  97.         RelativeLayout.LayoutParams adParams = 
  98.             new RelativeLayout.LayoutParams(RelativeLayout.LayoutParams.WRAP_CONTENT, 
  99.                     RelativeLayout.LayoutParams.WRAP_CONTENT);
  100.         adParams.addRule(RelativeLayout.ALIGN_PARENT_TOP);
  101.         adParams.addRule(RelativeLayout.ALIGN_PARENT_RIGHT);
  103.         layout.addView(adView, adParams);
  105.         // Hook it all up
  106.         setContentView(layout);
  107.     }
  109.     // This is the callback that posts a message for the handler
  110.     @Override
  111.     public void showAds(boolean show) {
  112.        handler.sendEmptyMessage(show ? SHOW_ADS : HIDE_ADS);
  113.     }
  114. }

HelloWorldDesktop.java:

  1. /*******************************************************************************
  2.  * Copyright 2011 See AUTHORS file.
  3.  * 
  4.  * Licensed under the Apache License, Version 2.0 (the "License");
  5.  * you may not use this file except in compliance with the License.
  6.  * You may obtain a copy of the License at
  7.  * 
  8.  *   http://www.apache.org/licenses/LICENSE-2.0
  9.  * 
  10.  * Unless required by applicable law or agreed to in writing, software
  11.  * distributed under the License is distributed on an "AS IS" BASIS,
  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13.  * See the License for the specific language governing permissions and
  14.  * limitations under the License.
  15.  ******************************************************************************/
  16. package com.badlogic.gdx.helloworld;
  18. import com.badlogic.gdx.backends.lwjgl.LwjglApplication;
  20. public class HelloWorldDesktop implements IActivityRequestHandler {
  21.     private static HelloWorldDesktop application;
  22.     public static void main (String[] argv) {
  23.         if (application == null) {
  24.             application = new HelloWorldDesktop();
  25.         }
  27.         new LwjglApplication(new HelloWorld(application), "Hello World", 480, 320, false);
  28.     }
  30.     @Override
  31.     public void showAds(boolean show) {
  32.         // TODO Auto-generated method stub
  34.     }
  35. }

HelloWorld.java:

  1. /*******************************************************************************
  2.  * Copyright 2011 See AUTHORS file.
  3.  * 
  4.  * Licensed under the Apache License, Version 2.0 (the "License");
  5.  * you may not use this file except in compliance with the License.
  6.  * You may obtain a copy of the License at
  7.  * 
  8.  *   http://www.apache.org/licenses/LICENSE-2.0
  9.  * 
  10.  * Unless required by applicable law or agreed to in writing, software
  11.  * distributed under the License is distributed on an "AS IS" BASIS,
  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13.  * See the License for the specific language governing permissions and
  14.  * limitations under the License.
  15.  ******************************************************************************/
  16. package com.badlogic.gdx.helloworld;
  18. import com.badlogic.gdx.ApplicationListener;
  19. import com.badlogic.gdx.Files.FileType;
  20. import com.badlogic.gdx.Gdx;
  21. import com.badlogic.gdx.graphics.Color;
  22. import com.badlogic.gdx.graphics.GL10;
  23. import com.badlogic.gdx.graphics.Texture;
  24. import com.badlogic.gdx.graphics.Texture.TextureFilter;
  25. import com.badlogic.gdx.graphics.Texture.TextureWrap;
  26. import com.badlogic.gdx.graphics.g2d.BitmapFont;
  27. import com.badlogic.gdx.graphics.g2d.SpriteBatch;
  28. import com.badlogic.gdx.math.Vector2;
  30. public class HelloWorld implements ApplicationListener {
  31.     SpriteBatch spriteBatch;
  32.     Texture texture;
  33.     BitmapFont font;
  34.     Vector2 textPosition = new Vector2(100, 100);
  35.     Vector2 textDirection = new Vector2(1, 1);
  37.     private IActivityRequestHandler myRequestHandler;
  39.     public HelloWorld(IActivityRequestHandler handler) {
  40.         myRequestHandler = handler;
  41.     }
  43.     @Override public void create () {
  44.         font = new BitmapFont();
  45.         font.setColor(Color.RED);
  46.         texture = new Texture(Gdx.files.internal("data/badlogic.jpg"));
  47.         spriteBatch = new SpriteBatch();
  48.     }
  50.     @Override public void render () {
  51.         int centerX = Gdx.graphics.getWidth() / 2;
  52.         int centerY = Gdx.graphics.getHeight() / 2;
  54.         Gdx.graphics.getGL10().glClear(GL10.GL_COLOR_BUFFER_BIT);
  56.         // more fun but confusing :)
  57.         //textPosition.add(textDirection.tmp().mul(Gdx.graphics.getDeltaTime()).mul(60));
  58.         textPosition.x += textDirection.x * Gdx.graphics.getDeltaTime() * 60;
  59.         textPosition.y += textDirection.y * Gdx.graphics.getDeltaTime() * 60;
  61.         if (textPosition.x < 0 ) {
  62.             textDirection.x = -textDirection.x;
  63.             textPosition.x = 0;
  64.         }
  65.         if(textPosition.x > Gdx.graphics.getWidth()) {
  66.             textDirection.x = -textDirection.x;
  67.             textPosition.x = Gdx.graphics.getWidth();
  68.         }
  69.         if (textPosition.y < 0) {
  70.             textDirection.y = -textDirection.y;
  71.             textPosition.y = 0;            
  72.         }
  73.         if (textPosition.y > Gdx.graphics.getHeight()) {
  74.             textDirection.y = -textDirection.y;
  75.             textPosition.y = Gdx.graphics.getHeight();            
  76.         }
  78.         spriteBatch.begin();
  79.         spriteBatch.setColor(Color.WHITE);
  80.         spriteBatch.draw(texture, 
  81.                               centerX - texture.getWidth() / 2, 
  82.                               centerY - texture.getHeight() / 2, 
  83.                               0, 0, texture.getWidth(), texture.getHeight());        
  84.         font.draw(spriteBatch, "Hello World!", (int)textPosition.x, (int)textPosition.y);
  85.         spriteBatch.end();
  86.     }
  88.     @Override public void resize (int width, int height) {
  89.         spriteBatch.getProjectionMatrix().setToOrtho2D(0, 0, width, height);
  90.         textPosition.set(0, 0);
  91.     }
  93.     @Override public void pause () {
  95.     }
  97.     @Override public void resume () {
  99.     }
  101.     @Override public void dispose () {
  103.     }
  105. }

iOS Setup (RoboVM)

For admob to work on IOS it’s best to make sure you are doing the following things:

  • Make sure you project is using the latest libGDX version

  • Make sure you are on the latest RoboVM

  • Make sure you are using the latest admob bindings found here robovm-ios-bindings - admob

  • Admob needs a separate ad unit for iOS, so make sure you create a new app the key will be different than the one used for Android.

  1. Follow the AdMob RoboPod installation instructions https://github.com/MobiVM/robovm-robopods/tree/master/google-mobile-ads/ios.

  2. Now with the configuration complete you can make calls to the AdMob API from Java and configure ads as desired. The following is an example on how to integrate a Banners ad at the top of the screen:

WARNING the following code may be a bit outdated for latest RoboPod version, use it as a reference

  1. package com.badlogic.gdx;
  3. import org.robovm.apple.coregraphics.CGRect;
  4. import org.robovm.apple.coregraphics.CGSize;
  5. import org.robovm.apple.foundation.NSArray;
  6. import org.robovm.apple.foundation.NSAutoreleasePool;
  7. import org.robovm.apple.foundation.NSObject;
  8. import org.robovm.apple.foundation.NSString;
  9. import org.robovm.apple.uikit.UIApplication;
  10. import org.robovm.apple.uikit.UIScreen;
  11. import org.robovm.bindings.admob.GADAdSizeManager;
  12. import org.robovm.bindings.admob.GADBannerView;
  13. import org.robovm.bindings.admob.GADBannerViewDelegateAdapter;
  14. import org.robovm.bindings.admob.GADRequest;
  15. import org.robovm.bindings.admob.GADRequestError;
  17. import com.badlogic.gdx.Application;
  18. import com.badlogic.gdx.backends.iosrobovm.IOSApplication;
  19. import com.badlogic.gdx.backends.iosrobovm.IOSApplication.Delegate;
  20. import com.badlogic.gdx.backends.iosrobovm.IOSApplicationConfiguration;
  21. import com.badlogic.gdx.utils.Logger;
  23. public class HelloWorldIOS extends Delegate implements IActivityRequestHandler {
  24.     private static final Logger log = new Logger(HelloWorldIOS.class.getName(), Application.LOG_DEBUG);
  25.     private static final boolean USE_TEST_DEVICES = true;
  26.     private GADBannerView adview;
  27.     private boolean adsInitialized = false;
  28.     private IOSApplication iosApplication;
  30.     @Override
  31.     protected IOSApplication createApplication() {
  32.         final IOSApplicationConfiguration config = new IOSApplicationConfiguration();
  33.         config.orientationLandscape = false;
  34.         config.orientationPortrait = true;
  36.         iosApplication = new IOSApplication(new HelloWorld(this), config);
  37.         return iosApplication;
  38.     }
  40.     public static void main(String[] argv) {
  41.         NSAutoreleasePool pool = new NSAutoreleasePool();
  42.         UIApplication.main(argv, null, HelloWorldIOS.class);
  43.         pool.close();
  44.     }
  46.     @Override
  47.     public void hide() {
  48.         initializeAds();
  50.         final CGSize screenSize = UIScreen.getMainScreen().getBounds().size();
  51.         double screenWidth = screenSize.width();
  53.         final CGSize adSize = adview.getBounds().size();
  54.         double adWidth = adSize.width();
  55.         double adHeight = adSize.height();
  57.         log.debug(String.format("Hidding ad. size[%s, %s]", adWidth, adHeight));
  59.         float bannerWidth = (float) screenWidth;
  60.         float bannerHeight = (float) (bannerWidth / adWidth * adHeight);
  62.         adview.setFrame(new CGRect(0, -bannerHeight, bannerWidth, bannerHeight));
  63.     }
  65.     @Override
  66.     public void show() {
  67.         initializeAds();
  69.         final CGSize screenSize = UIScreen.getMainScreen().getBounds().size();
  70.         double screenWidth = screenSize.width();
  72.         final CGSize adSize = adview.getBounds().size();
  73.         double adWidth = adSize.width();
  74.         double adHeight = adSize.height();
  76.         log.debug(String.format("Showing ad. size[%s, %s]", adWidth, adHeight));
  78.         float bannerWidth = (float) screenWidth;
  79.         float bannerHeight = (float) (bannerWidth / adWidth * adHeight);
  81.         adview.setFrame(new CGRect((screenWidth / 2) - adWidth / 2, 0, bannerWidth, bannerHeight));
  82.     }
  84.     public void initializeAds() {
  85.         if (!adsInitialized) {
  86.             log.debug("Initalizing ads...");
  88.             adsInitialized = true;
  90.             adview = new GADBannerView(GADAdSizeManager.smartBannerPortrait());
  91.             adview.setAdUnitID("xxxxxxxx"); //put your secret key here
  92.             adview.setRootViewController(iosApplication.getUIViewController());
  93.             iosApplication.getUIViewController().getView().addSubview(adview);
  95.             final GADRequest request = GADRequest.request();
  96.             if (USE_TEST_DEVICES) {
  97.                 final NSArray<?> testDevices = new NSArray<NSObject>(
  98.                         new NSString(GADRequest.GAD_SIMULATOR_ID));
  99.                 request.setTestDevices(testDevices);
  100.                 log.debug("Test devices: " + request.getTestDevices());
  101.             }
  103.             adview.setDelegate(new GADBannerViewDelegateAdapter() {
  104.                 @Override
  105.                 public void didReceiveAd(GADBannerView view) {
  106.                     super.didReceiveAd(view);
  107.                     log.debug("didReceiveAd");
  108.                 }
  110.                 @Override
  111.                 public void didFailToReceiveAd(GADBannerView view,
  112.                         GADRequestError error) {
  113.                     super.didFailToReceiveAd(view, error);
  114.                     log.debug("didFailToReceiveAd:" + error);
  115.                 }
  116.             });
  118.             adview.loadRequest(request);
  120.             log.debug("Initalizing ads complete.");
  121.         }
  122.     }
  124.     @Override
  125.     public void showAds(boolean show) {
  126.         initializeAds();
  128.            final CGSize screenSize = UIScreen.getMainScreen().getBounds().size();
  129.         double screenWidth = screenSize.width();
  131.         final CGSize adSize = adview.getBounds().size();
  132.         double adWidth = adSize.width();
  133.         double adHeight = adSize.height();
  135.         log.debug(String.format("Hidding ad. size[%s, %s]", adWidth, adHeight));
  137.         float bannerWidth = (float) screenWidth;
  138.         float bannerHeight = (float) (bannerWidth / adWidth * adHeight);
  140.         if(show) {
  141.             adview.setFrame(new CGRect((screenWidth / 2) - adWidth / 2, 0, bannerWidth, bannerHeight));
  142.         } else {
  143.             adview.setFrame(new CGRect(0, -bannerHeight, bannerWidth, bannerHeight));
  144.         }
  145.     }
  146. }