Porting a CPP application to Android

Issue

I need to port a CPP project to Android but I somehow got stuck because of the following things that I am not sure of:

1. Do I need to use some kind of java wrapper for my CPP project at all, i.e is it necessarily that I use Android SDK to integrate my application with Android? If there is another way, which one would that be?

2. I have seen some people claiming they have been able to manipulate their cmake file and some custom android-cmake toolchain to build their “.so” or eventually an “.apk” from their project. Would it be possible without a java wrapper to manipulate the cmake files of the cpp project to build your project? (source: Build Android NDK project with Cmake)

Solution

From my experience, I would go with using the android java entry point, otherwise you will most likely bump into problems (you can make full native android apps , but I strongly advise against it).

One of the reasons is that you will want SDK function calls from inside your CPP, and using reflection on the java environment from CPP isn't trivial.

The steps would be the following :

1. Create a very simple C code that will server as bridge to your CPP code . Here are some sample C functions that I've commonly used :
   • OnApplicationStart
   • OnApplicationPaused
   • OnApplicationResumed
   • OnApplicationUpdate
   • OnTouchReceived
2. Export these functions and load them in your Java code (lookup JNI on how to do this)
3. Handle all Android-specific actions in Java, and all application specific actions in cpp

So the answer to your 1st question is that a java wrapper isn't mandatory, but it's HIGHLY recommended.

To answer your 2nd question :

Yes, you can use cmkae, ant, cygwin , allot of command tools that will end up creating your apk (It's up to you on how you feel comfortable).You will still use the android compiler since you are targeting arm.

The difference is that you need to change in your manifest.xml the entry point of the application from a normal activity to a native activity ( http://developer.android.com/reference/android/app/NativeActivity.html ) .

As you can see, the difference isn't the build system, it's the way you define your entry point.

As a friendly advice, try using the minimal java wrapper approach. You might get to better results sooner, and it won't take you more then 1 week of research on the web on how to link java code to cpp.

EDIT :

As of demand, I will shortly explain how I would approach the process of porting a CPP application to Android :

1. Rethink your application to work as a shared library , using a C entry point :

a.Create a simple C application that will load yourCPPApp.dll (or .so if you are on linux)

b. In your .dll create the minimum necessary extern "C" functions to be exported in order for you to give the necessary information to your dll

For simplicity, we'll assume we have 3 methods :

 void StartApplication();
 bool OnApplicationUpdate();
 void OnScreenTouched(int x, int y);

c. Implement the simple C project that will make the calls to these methods externaly (so the .exe will call the methods from the .dll ! )

Sample code :

 #include "myCPPapp.h"
 int main(int arg, char** argv)
 {
      StartApplication();
      srand(time(NULL));
      while (OnApplicationUpdate())
      {
          // we assume we have a 480x640 resolution
          OnScreenTouched(rand()%480,rand()%640);
      }
      return 0;
 }

1. Now that we have things working in full native with a .exe and a .dll , time to make it work with a .apk and a .so

a. Rename the exposed methods from myCppApp into java compatible prototypes

extern "C" {
    JNIEXPORT void JNICALL Java_com_sample_nativebridge_OnApplicationStart(JNIEnv env, jobject thiz);
    JNIEXPORT jboolean JNICALL Java_com_sample_nativebridge_OnApplcationUpdate(JNIEnv env, jobject thiz);
    JNIEXPORT void JNICALL Java_com_sample_nativebridge_OnScreenTouched(JNIEnv env, jobject thiz, jint x, jint y);
}

b. create the java class nativebridge (case sensitive) in the package com.sample (you need t respect the names in order for correct linkage to native)

class nativebridge {
    public static native void OnApplicationStart();
    public static native boolean OnApplicationUpdate();
    public static native void OnScreenTouched(int x, int y);
}

c. add the load library statement in the native bridge in order to have your library loaded at runtime

class nativebridge {
  ....
  static {
    System.loadLibrary("myCppApp"); 
    // notice that the lib prefix and .so sufix aren't part of the name
  }
}

d. compile your CPP code with the armeabi compiler and create libmyCPPApp.so (ndk build system , or whatever you'd like... i would go with the ndk, it's quite easy , just go into the folder with Android.mk and call $ANDROID_NDK_BUILD_PATH/build )

At this point you will need to createa a .mk file that will compile your myCppApp code, but this is out of scope, you will need to do this research on your own (it's quite trivial once you get the hang of it).

c. use the native methods from the bridge inside your java app wherever you see fit.

A very good tip would be to go through a hello world sample of ndk :

http://www.ntu.edu.sg/home/ehchua/programming/android/android_ndk.html

Enjoy.

Answered By - MichaelCMS