1. What is Android NDK ● A toolset that lets you embed in you app native source code ● C, C++(recently supported December 2010) and assembly(?) ● It is supported on android cupcake(1.5)+ ● It is aimed to – Bring native libraries in android (code reusability) – Make some parts of the application really fast using code generated for arm-like cpus ● Most of the time android SDK is prerequisite for NDK ● Under heavy development

2. When should be used? ● Not just because we like c++ more than java! ● Only when its benefits outrages its drawbacks ● Why? – Always increases application complexity – Very difficult debugging ● But – OpenGL graphics to work on android in favor of NDK – Increases speed – Enable us to port most of the libraries

3. How... ? ● Android provides 2 ways: – Writing the application using the standard SDK framework and then using JNI to access the API provided by NDK. – Write a native activity using NativeActivity class and native code to implement activity lifecycle callbacks. – Available only on Android 2.3+ – Services, Content providers must be implemented using NDK.

4. So what exactly is JNI? ● Tip: Java Native Interface – Available years before android appeared ● Used when something java couldn't do – e.g. platform specific features – Many library java classes use JNI ● Can be used to inteface with C, C++ and assembly ● But also through that C and C++ can call native JAVA functions!

5. JNI example ● NativeConnection class public class NativeConnection{ public native String stringFromJNI(); // This method loads as soon as the instance of the class is created static { System.loadLibrary("helloFromJNI"); } ● HelloFromJNI.cpp JNIEXPORT jstring JNICALL Java_ceid_1ds2_cbox_helloandroid_NativeConnection_stringFromJNI( JNIEnv* env, //environment pointer jobject thiz ) //object pointer { return env->NewStringUTF("Hello from native C++ code using NJI :-D"); //return (*env)->NewStringUTF("Hello from native C code using NJI :-D"); }

6. Native Method Names ● A native method name is concatenated from the following components: – the prefix Java_ – a mangled fully-qualified class name – an underscore (“_”) separator – a mangled method name – for overloaded native methods, two underscores (“__”) followed by the mangled argument signature

7. Native Method Names ● Other characters: – _0XXXX: a Unicode character XXXX. – _1: the character “_” – _2: the character “;” in signatures – _3: the character “[“ in signatures ● Pretty difficult to remember! ● But there is a tool that can help us! ● javah !

8. javah ● Header and Stub File Generator ● javah [ options ] fully-qualified-classname ● e.g. javah -nji com.helloandroid.NativeConnection -o helloFromJNI.h ● Generates all the function prototypes in an automated way! ● Suports C-like C++

9. JNI strategy ● Create the native methods in java class ● Load the library in java class ● Create the function prototypes using javah in a.h file ● Create the final native source file! ● Use your native methods inside Android activity

10. JNI example! ● NativeConnection class public class NativeConnection{ public native String stringFromJNI(); // This method loads as soon as the instance of the class is created static { System.loadLibrary("helloFromJNI"); } ● HelloFromJNI.cpp JNIEXPORT jstring JNICALL Java_ceid_1ds2_cbox_helloandroid_NativeConnection_stringFromJNI( JNIEnv* env, //environment pointer jobject thiz ) //object pointer { return env->NewStringUTF("Hello from native C++ code using NJI :-D"); //return (*env)->NewStringUTF("Hello from native C code using NJI :-D"); }

11. JNI in android ● The Android NDK is nothing more than a complement to the Android SDK that helps you to: – Generate JNI-compatible shared libraries that can run on the Android platform running on ARM CPUs. – Copy the generated libraries to a proper location of your application to be included in.apks – - A set of cross-toolchains (compilers, linkers, etc..) that can generate native ARM binaries on Linux, OS X and Windows (with Cygwin) ● All the rest is just JNI!

12. Android NDK strategy ● Implement the usual application lifecycle callbacks ● Implement the native methods in a java class ● Load the library in a java class ● Create the function prototypes using javah in a.h file(optional) ● Create the final native source file ● Use your native methods somewhere inside Android activity ● Execute the commands from your working directory: – /tools/android update project -p. -s – /ndk-build ● Build the project using eclipse

13. JNI revisited ● A native cannot return anything to java ● It has to be one of the JNI defined types: jboolean, jint, jfloat, jdouble, jstring.... j ● To interfere with this types there also many many JNI functions ● To get the native string from javaString: ● const char *nativeString = env->GetStringUTFChars(javaString, 0); ● Some time are the same e.g. int data type is 8 bit signed same as jint.

14. JNI revisited ● For example Java arrays are not guaranteed to have a continuous memory layout like C arrays. ● void Get ArrayRegion(JNIEnv *env, ArrayType array, jsize start, jsize len, NativeType *buf); returns a native type array in a continues region ● JNIEXPORT jint JNICALL Java_IntArray_sumArray(JNIEnv *env, jobject obj, jintArray arr) { jint buf[10]; jint i, sum = 0; env->GetIntArrayRegion(arr, 0, 10, buf); for (i = 0; i < 10; i++) { sum += buf[i]; } return sum; }