RTsoft Wiki

Originally the Android platform was crippled by requiring all “app” code to be written in Java.

In OS 1.5, the NDK (Native Development Kit) was introduced. Used with Proton SDK you get the following advantages:

• Native ARM machine code is faster than using Java
• The ability to use millions of lines of existing legacy C++ code
• Can use boost and stl
• Can write an Android game without writing a single line of Java
• Can debug your app in MSVC or Xcode
• Can also code parts in Java if you really need to
• Can write standard GL code in C/C++

The way Proton SDK handles each target, be it iOS, WebOS, or Android is by using glue code that isolates the game code from the platform specific API.

The C++ “glue” code for Android is located in /shared/android and the .Java parts are in /shared/android/src. These are shared between all applications so be careful if you touch them.

Side Note : There is actually an even newer way to do NDK now - something called a NativeActivity where you can use 100% C++. Except you can't, because things like IAP and Tapjoy integration would still be in Java so I assume more ugly bridging would be required.. also it requires Android 2.3 (boo, hiss), but I plan to do an android target supporting this eventually, especially since it seems to be the only way to support the xperia play gamepad controls. -Seth

Before attempting moving on, you really should already have done this:

• Read the Compiling RTBareBones for Windows tutorial
• Read the Compiling RTSimpleApp for Windows tutorial

NOTE (MK): RTSimpleApp, you need to do the “Building resources” step. Otherwise, the app will crash/exit right away, and you'll get the “Can't load font 1” error mentioned.

Get ready to do a lot of downloading and installing. Android is the most complicated setup to get going so far.

This is going to take a while.

• Install the Android SDK - use the Windows exe version so it will also prompt you to install the Java SE JDK which will be needed as well.
• Add C:\Program Files (x86)\Android\android-sdk\platform-tools to your windows path
• Add C:\Program Files (x86)\Android\android-sdk\tools to your path
• Install Cygwin - you run the setup.exe to create/update an install, it's very simple. During the part where it lets you choose what additional parts to install, I strongly suggest selecting the entire dev subtree to be safe.

If you type “android” from the DOS prompt it will bring up the Android SDK and AVD Manager. This is where you create AVDs (basically, emulator profiles, if you want to use the emulator) and can install optional libraries.

Here is how I setup my AVD (note my naming format.. helps later to remember which AVD is which version)

Make sure you install “USB Driver package, revision X”, your phone probably needs this. Also, “Market licensing package, revision X” is needed.

Note: I had problems on Win7 until I found “android.bat” and ran it with “Run as administrator”.

Another note: The emulator refused to start until I edited the path to be a dos 8.3 format. (Ie, C:\PROGRA~2\Android\android-sdk\tools instead of C:\Program Files (x86)\Android\android-sdk\tools - you can use dir /x to get the exact name to use)

You want to test on your real phone, right?

Setup your Android phone like this:

• In Settings→Applications enable “Unknown sources”. Otherwise you can't test your apps.
• In Settings→Applications→Development enable “USB debugging”
• After plugging in your phone, in the Win device manager it will probably say “no drivers installed” - click update driver and locate the USB drivers you downloaded above using the Android SDK and AVD Manager. (Probably in Program Files (x86)/Android/android-sdk/extras/google/usb_driver) If it's not a Nexus One or Nexus S, you may need one of these drivers instead.
• Typing “abd devices” should show your plugged in phone as a device now. If so, congrats, you got this far!

Ok. In theory, you're now setup for building a standard Android app and running it in the emulator or on your phone.

You don't absolutely have to, but I'd recommend installing Eclipse (get Eclipse IDE for Java Developers) and building a “hello world” app to test everything thus far. Nice tutorial on doing that is here.

Android is complex and I don't really think p+ can shield you from its intricacies. You still need to know how to create an AVD emulator, understand what a .manifest is and know what obscure error messages like “Committing suicide to kill the zombie!” mean.

You should probably spend a few days of hacking around with hello world apps to get a feel for it before attempting to use Proton SDK with it.

Ok, your hairs have magically turned white and mostly fallen out, but you've finally got your hello world app on your device.

You are now ready to move to the next step.

First, mentally throw away Eclipse if you were using it for testing - you'll never need it again.

• Install Ant, grab the latest .zip (v1.8.2 at this time) and unzip it to somewhere.
• Add the ant directory to your windows path. Verify it's working by typing “ant” in a dos prompt, it should do something other than “bad command or file error”.
• Download the Android NDK and unzip it somewhere.

Ant is command line utility that will do the Android packaging for us after the .so binary is built. Cygwin lets us run linux-style stuff on Windows.

IMPORTANT NOTE : When editing files like build.sh that cygwin is going to process, keep in mind they will probably puke if you don't keep unix-style line feeds. Use a smart editor like UltraEdit ($$) or Programmer's Notepad (free) and they will be able to keep the existing format.. don't use Windows Notepad! If you see an error like “$'/r': command not found” that's the problem. (If you must, you could use something like dos2unix.exe to fix it again)

Annoying stuff you have to do:

• Add a Windows environmental var CYGWIN_DIR to your base cygwin directory.
• Add your android ndk dir to the windows path
• Edit RTBareBones/android/app_info_setup.bat and set the variables up if different, note that you can set the emulator AVD name you wish to use.
• Edit RTBareBones/android/local.properties and set the path to your android-sdk dir. (used by ant)
• Edit RTBareBones/android/build.sh and set the path. Instead of “/cygdrive/o/projects/proton/rtbarebones/android” it should be “/cygdrive/c/proton/rtbarebones/android” or wherever you put proton. Also see where you have to change it a bit below.

Phew! I could probably find ways to reduce the hand edits needed above but meh. Good enough for now. Tricky hacks like reading from windows environmental vars from inside cygwin would make it harder to build from linux or mac later, don't want that either.

Get ready to open the champagne because we're about to compile!

From file explorer, double click /RTBareBones/android/build.bat

You should see a bunch of weird warnings like “this precompiled header message should show up once” showing up forty times. This is all perfectly normal. Trust me.

After a lengthy C++ compile process, it then compiles the Java pieces in one second, then slowly puts it on the Emulator and your real phone if it can. The .apk it makes is located in /RTBareBones/android/bin in case you want to give it to someone else to test with.

Run ViewLog.bat to see the debug output from the emulator, or ViewLogPhone.bat to see the debug output from your phone.

If you need to add remove source files to the project, manually edit RTBareBones/jni/Android.mk.

Also, if you're having trouble, it's a good idea to enable debug mode compiling. To do that, change:

#release flags
LOCAL_CFLAGS := -DANDROID_NDK -DBUILD_ANDROID -DGC_BUILD_ANDROID -DNDEBUG
LOCAL_CPPFLAGS := -DGC_BUILD_C -DANDROID_NDK -DBUILD_ANDROID -DNDEBUG

#debug flags
#LOCAL_CFLAGS := -DANDROID_NDK -DBUILD_ANDROID -DGC_BUILD_ANDROID -D_DEBUG
#LOCAL_CPPFLAGS := -DGC_BUILD_C -DANDROID_NDK -DBUILD_ANDROID -D_DEBUG

TO:

#release flags
#LOCAL_CFLAGS := -DANDROID_NDK -DBUILD_ANDROID -DGC_BUILD_ANDROID -DNDEBUG
#LOCAL_CPPFLAGS := -DGC_BUILD_C -DANDROID_NDK -DBUILD_ANDROID -DNDEBUG

#debug flags
LOCAL_CFLAGS := -DANDROID_NDK -DBUILD_ANDROID -DGC_BUILD_ANDROID -D_DEBUG
LOCAL_CPPFLAGS := -DGC_BUILD_C -DANDROID_NDK -DBUILD_ANDROID -D_DEBUG

Don't forget to change it back later.

If you want to sell your App in the Android market, you should use LVL.

It's actually already implemented in Proton SDK, take a look at the only .Java file in RTBareBones, located in RTBareBones/android/src/com/rtsoft/rtbarebones

//This is the only app-specific java file for the android project.  The real work is done in
//shared/android/src/rtsoft/shared/SharedActivity.java.  When editing that, be careful, as it is used
//by all Proton projects.
 
//Thanks to Phil Hassey for his help and code
 
package com.rtsoft.rtbarebones;
import com.rtsoft.shared.SharedActivity;
import android.os.Bundle;
 
public class Main extends SharedActivity
{
	@Override
    protected void onCreate(Bundle savedInstanceState) 
	{
		//EDIT THESE TO MATCH YOUR PROJECT NAME
		BASE64_PUBLIC_KEY = "uh, it would go here if you had one and wanted to use the google licensing stuff";
		PackageName= "com.rtsoft.rtbarebones";
		dllname= "rtbarebones";
		securityEnabled = false; 
       super.onCreate(savedInstanceState);
    }
}

You would just need to enter your public key (The Google developer console gives this to you after you sign up) and change “securityEnabled” to true.

That's about it for getting the samples running.

Use the same process to compile RTSimpleApp.

Want to clone one of the example apps to be the starting place of a new app? Then read the tutorial on how to create a new project by copying from a Proton sample app.