today I had some time taking problems with the RSA implementation on Android. I was trying to do the following:

Encrypt a log file on my Android device with a RSA public key, copy the device to the server and on the server decrypt the log file with my RSA private key using a small Java-App.

So for testing I first encrypted and decrypted on my Android device using the generated key pair, then I encrypted and decrypted a String in my Java App using the same key pair. Worked nicely.
Then I tried to copy the encrypted file from the Android device and decrypt in on the server. Didn’t work. But why? I used the same key pair all the time, but always got an Exception:

javax.crypto.BadPaddingException: Blocktype mismatch: 0

Solution:

Afters some hours of trying, confirming that the key pairs are the same, using different options of saving the public key in the Android filesystem, etc. I finally found a post stating that Android is using the Bouncycastle Security provider. Bouncycastle’s default RSA implementation is: “RSA/None/NoPadding”, whereas Sun’s default security provider implementation is “RSA/None/PKCS1Padding”. So, no decryption possible when just using

Cipher.getInstance("RSA")

because of the different paddings used.

So for a solution I downloaded the bouncycastle Jar, added bounycastle as a Security provider to my Java App, and now use

Cipher.getInstance("RSA", "BC");

It works fine now.

Mobile Atlas Creator is a cool open-source project, that allows you to use different map providers (OpenStreetMap, Google Maps, Bing Maps, Yahoo Maps, …), donwload these maps and export to different atlas formats. Have a look at their website (http://mobac.dnsalias.org/) and download the latest stable version.

Just unzip, start the .jar-file and you will be presented a world map.
On the left side you can choose which map provider to use, i.e. OpenStreet Mapnik, Yahoo, …
Choose OpenStret Mapnik for now.

Now navigate and zoom in to your preferred area, I took Hamburg, Germany using the arrow keys on your keyboard and the zoom selector in the upper left corner of the map.

Now make a selection of the parts you want to have as an offline map.

In the left panel you may now select which zoom levels to include in your offline map. Just select the numbers you want where 18 is highest detail level and 0 is lowest. The higher detail you want, the more tiles you have to download, the higher the final size of the offline map will be.

When you’re happy with your selection on the map, click “Add Selection” in the “Atlas Content” area, and for “Atlas settings” select Osmdroid ZIP.

Now start atlas creation by clicking on the “Create Atlas” button. Now the selected parts of the map will be downloaded and bundled into a Osmdroid ZIP map. After some time, depending on your internet connection and the number of tiles you want to download, creation of the offline map is ready. You can now close Mobile Atlas Creator and have a look at the Mobile Atlas Creator folder. You’ll now find a subfolder “atlases” and inside the subfolder a .zip-file containing all the map tiles (you can confirm that by unzipping the file).

Now let’s use this map in our app. Open the app we created in the last part.
We want to make sure we’re not using any data connection to download the map tiles, so just set

mapView.setUseDataConnection(false)

somewhere after the mapView instantiation and before setContentView(mapView).

Let’s also delete the map cache in case you followed the last tutorial. You can find a folder “osmdroid” on your android’s sdcard, just delete everything in that folder and instead put the zip-file we created inside.

Now adjust the zoom level and the latitude/longitude in your app to point to a place in the map you created and start your app.

You should now see a map, but that map wasn’t downloaded on-the-fly, now it’s using the map tiles in the zipped-atlas you created! You can confirm that by moving outside of the area you zipped and you will just see grey map tiles.

Problem is: you still can zoom out of the zoom levels you downloaded or zoom closer than you wanted the user to (you provided no maps for that zoom level). That’s ugly because the user only sees grey maps and may get lost.

Let’s discuss how to solve that problem in the next part of the tutorial.

1. Get the needed osmdroid’s library, I used the osmdroid-android-3.0.2.jar
here

2. Lets create a new simple Android project (you know how that is done)

3. Add the osmdroid-library to your Android project.
Depends on the IDE you use, in IntelliJ right-click on your project and select Open Module Settings. Goto “Libraries”, create a new library and attach the osmdroid-jar to it.

4. Now the fun begins:

In our AndroidManifest.xml define the permissions needed:

<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.INTERNET" />
 
<uses-feature android:name="android.hardware.location.network" />
<uses-feature android:name="android.hardware.location.gps" />	<uses-feature android:name="android.hardware.wifi" />

Let’s create the easiest MapView.
In the Activity’s onCreate-method create a new Object of Type MapView (exactly: org.osmdroid.views.MapView) like this:

MapView mapView = new MapView(this, 256);

That uses the context as the first parameter, and the tile size of 256px (needed later).
We want to be able to zoom in and out, so let’s define that:

mapView.setClickable(true);
mapView.setBuiltInZoomControls(true);

And let’s set the ContentView:

setContentView(mapView);

So that was our onCreate-method. You may now start in the emulator or on your device and you should see the OpenStreetMap of the whole world. By clicking the MapView the standard zoom-in/zoom-out buttons appear and that should work, too, given you have an internet connection.

5. Play around with the options
Let’s set the zoom level (the standard one is funny, but not really helpful). Thats done via an instance of the MapController, you can easily grab the MapView’s MapController by calling

mapView.getController().setZoom(10);

Play around with the numbers, to see how close to earth you can get

But maybe you also want to set a specific point as the map’s center. That’s also done via the MapController:

mapView.getController().setCenter(new GeoPoint(53.550657, 9.995499));

Use a GeoPoint to specify the coordinates (first param is latitude, second longitude) and use this as paramter for setCenter(). Start the app again and look where I directed you: the most beautiful city in the world

6. Have fun playing with coordinates and zoom levels.

7. BUT! What if you want offline maps?
Let’s say you’re on holiday in the US, Germany, England, India, China, (insert your favorite country) and need a map on your mobile device, but you don’t want to pay thousands of €/$/¥/(insert your favorite currency) just for displaying a map?
Also, how do we set set minimum and maximum zoom levels?

Next time…

This is the complete onCreate method:

/** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
 
        mapView = new MapView(this, 256);
        mapView.setClickable(true);
        mapView.setBuiltInZoomControls(true);
 
        mapView.getController().setZoom(10);
        mapView.getController().setCenter(new GeoPoint(39.461078, 2.856445));
 
        setContentView(mapView);
 
    }

To fix this, put the following lines in build-impl.xml in the debugging section. Just remove the old part and paste in the new:

<target depends="init,-debug-start-debuggee" if="netbeans.home" name="-debug-start-debugger">
      <androidproject1:nbjpdaconnect/>
  </target>
  <target depends="init,compile,-start-emulator,-wait-for-emulator,-install-app" name="-debug-start-debuggee">
      <exec executable="${adb}">
          <arg line="${android.target.device}"/>
          <arg value="shell"/>
          <arg value="am start -D -n ${main.component}/${main.class}"/>
      </exec>
      <getdebuggerport addressProperty="local.debug.port" app="${main.component}"/>
  </target>
  <target depends="init,compile,-debug-start-debuggee,-debug-start-debugger" description="Debug project in IDE." if="netbeans.home" name="debug"/>
  <target depends="init" if="netbeans.home" name="-debug-start-debugger-stepinto">
      <androidproject1:nbjpdastart stopclassname="${main.class}"/>
  </target>
  <target depends="init,compile,-debug-start-debugger-stepinto,-debug-start-debuggee" if="netbeans.home" name="debug-stepinto"/>

So, in the last part we created some parts of the UI the user sees when he starts the game.

Today we want to create a small part of the real “Game View”!
First, lets change the standard layout of the Android App. The layout file can be found in res/layout/main.xml.
The standard is a simple LinearLayout with a TextView, that currently just displays “Hello…” when you start the game.
Let’s remove this part and change it to:

<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    >
 
    <GameView
    	android:id="@+id/game"
    	android:layout_width="fill_parent"
    	android:layout_height="fill_parent" />
 
    <RelativeLayout
	android:layout_width="fill_parent"
	android:layout_height="fill_parent">
	<TextView
		android:id="@+id/text"
		android:text="@string/space_janitor_info_text"
		android:visibility="visible"
		android:layout_height="wrap_content"
		android:layout_width="wrap_content"
		android:layout_centerInParent="true"
		android:gravity="center_horizontal"
		android:textColor="#88ffffff"
		android:textSize="24sp" />
    </RelativeLayout>
</FrameLayout>

First, we define a Game View that we can use later on to hold the game graphics. Second we defined a RelativeLayout that holds a TextView, we need this to display some infos later on.

Now let’s extend the code to use this views.

Create a new class called GameView in your App. The GameView extends SurfaceView and has to implement the SufaceHolder.Callback interface. Add the yet unimplemented methods and a constructor to fulfill the interface’s requirements.

public class GameView extends SurfaceView implements SurfaceHolder.Callback {
 
	public GameView(Context context, AttributeSet attrs) {
		super(context, attrs);
		// TODO Auto-generated constructor stub
	}
 
	public void surfaceChanged(SurfaceHolder holder, int format, int width,
			int height) {
		// TODO Auto-generated method stub
 
	}
 
	public void surfaceCreated(SurfaceHolder holder) {
		// TODO Auto-generated method stub
 
	}
 
	public void surfaceDestroyed(SurfaceHolder holder) {
		// TODO Auto-generated method stub
 
	}
}

The SurfaceView is designated to hold the game graphics. Via the SurfaceHolder.Callback we are informed about dimension changes, i.e. when the user switches to landscape mode.

In the Main View we now have to code a connection to the Game View, we’ll do this via an instance variable of GameView. Add a variable of the type “GameView” to your Activity.

public class SpaceJanitor extends Activity {
	private static final int MENU_START = 1;
	private GameView myGameView;
        ...
}

In our “onCreate”-method we have to initialize this variable and we would like to give the GameView the ability to display some info in the TextView we recently defined in our layout file, like “Game Over”, etc. So:

public void onCreate(Bundle savedInstanceState) {
   super.onCreate(savedInstanceState);
 
   requestWindowFeature(Window.FEATURE_NO_TITLE);
   setContentView(R.layout.main);
   myGameView = (GameView) findViewById(R.id.game);
   myGameView.setTextView = (TextView) findViewById(R.id.text);
}

This implies that we have to add a method “setTextView” in the GameView class to save a reference on this TextView locally.

public void setTextView(TextView findViewById) {
		// TODO Auto-generated method stub	
	}

In the next part we will add a thread to handle graphic updates, user actions, etc. etc.

First I have to say that I am using Eclipse and the Android plugin to program, because it really minifies the work needed. If your using another IDE you have to change some of the steps according to your IDE’s workflow, but the code stays the same.

I decided that my game should have a welcome screen and an options menu to start the game (or later when playing to pause or stop the game). That is easily done with Android.
First lets create a new project in Android, name it what you like, I chose “Space Janitor” (I assume that you already now how to create new Android project, otherwise refer to one of the many tutorials).

You will then see something like this:

 
package de.rakery.android.spacejanitor.part1;
 
import android.app.Activity;
import android.os.Bundle;
 
public class SpaceJanitor extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }
}

We want to use the full screen for our game and don’t need the window title, so add the following to the onCreate Method:

requestWindowFeature(Window.FEATURE_NO_TITLE);

Press Cmd-Shift-O in Eclipse (sorry, only have a Mac, don’t know which keys on Win/Linux) to automatically import the needed dependencies (here android.view.Window).

Next, lets create the Options Menu to start the game.
We don’t want to keep the Text-Strings in our code, so lets move them to the XML file in res/values/strings.xml.
When using Eclipse you will be presented with the following screen after double-clicking the file:

So, now you can easily add a new string key-value pair. Add a key “MENU_FIRST” and as value “Start new game” to the strings.xml.
We will later add more menu items, but this one is enough for now.

So how do we add this String as a Menu item to the options menu?
On Android when an activity starts a method onCreateOptionsMenu is called automatically at some points. So we can override the normal method of the class Activity and add our own onCreateOptionsMenu-method.
Lets do this by adding the following right under the onCreate Method

@Override
public boolean onCreateOptionsMenu(Menu menu){
	super.onCreateOptionsMenu(menu);
        menu.add(0, MENU_START, 0, R.string.MENU_FIRST);
	return true;
}

The add-Method takes 4 arguments: the groupId, the itemId, the order, and a title.
As you can see, we set the title by reading R.string.MENU_FIRST (the key we used for the text-string).
I also defined a

private static final int MENU_START = 1;

for my activity, that is now set as the menu itemId, which can later be used to identify user clicks on a menu item.
I’ve set the group ID to 0 because currently there is only one group with the ID zero, and I want to order the items in the order I add them to the menu, so I can set order to 0. If you would like to order in a different way you would have to set the order explicitly.

Now we also want to react on user clicks on a menu item. Once again we override a method defined in Activity called onOptionsItemsSelect:

public boolean onOptionsItemsSelect(MenuItem item){
        switch (item.getItemId()){
	   	// do something with the clicks
	   	case MENU_START:
		// TODO: Define what to do on click
	 }
	 return true;
}

Here we can make use of the constant MENU_START we defined to compare it to the itemID.

Start the emulator and you will see a black screen with a text “Hello World, Space Janitor”. When clicking on the options button, the menu will show up and display the Menuitem “Start new game”.

So, this was part one of the game development on Android tutorial, not much game development here, but we have to start somewhere

So I decided to write a simple game for the Android platform, not that there aren’t already enough games in the Android Market, more because in the last weeks I mostly concentrated on developing games for the Vodafone mobile widget runtime. I made a game called “Space Janitor”, which I now want to port to the Android platform. I would like to extend the game at some points, i.e. making use of the device accelerometer sensors to move the spaceship to the left or to the right, or vibrating the mobile when being hit by an asteroid. That would be real fun.

Another good way to learn is to try to explain the things one learned to others. That was a great way to learn during my university time, because the professors always wanted to have something explained So if one already explained the learned things to others, it was no problem to explain it again to the professor. I now decided to keep track of my development by writing some blog posts about how to develop the game, thus explaing it to others. But I would also very much appreciate your comments on how to improve the quality and the speed of my code as I would call myself just a novice in Android programming. Maybe you’ve also got some more tipps for game improvement, game handling, gameplay, etc.

I will somewhat unregularly post new entries in my blog, so keep in touch.