Upload
lucas-fields
View
224
Download
0
Tags:
Embed Size (px)
Citation preview
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
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
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.
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!
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");
}
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
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 !
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++
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
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");
}
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!
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:– <pathToSDK>/tools/android update project -p . -s
– <pathToNDK>/ndk-build
● Build the project using eclipse
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<javaType>
●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.
JNI revisited
● For example Java arrays are not guaranteed to have a continuous memory layout like C arrays.
● void Get<PrimitiveType>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;
}