Android JNI

It is not like I hate java so much. I mean who wants to write all those verbose and repetitive stuff  all throw your code that’s all. That been said I always thought JNI as a mystery box and never tried it.

Now that I have tried JNI it seems so handy. Feels like I will transfer all the logic to JNI and just bother about small stuff and GUI for java code. Anyhow in this post I just want to iterate through how easy it is to use JNI. There are so many help page to do so. I just want to write so that I will remember it.
Step 1:

You just need to create a folder name jni in your eclipse(android) project. In this jni folder keep all your c or c++ files. ndk-tool is used to build these files inside jni folder. Just download ndk tool and add the “ndk-build” batch file path in your PATH environment variable so that you can use this command to compile jni folder content anywhere.

Step 2:
In Java program where you want to call the native c code function declare the function definition like this :
public static native return_type func(args);

public static native int add_two_nums(int first_num, int second_num);

To tell java where these functions are defined import the C/C++ library using below statement:
This is how you load the c library:

/** Load jni .so on initialization */
static {
System.loadLibrary("jni_module_library_name"); /* Note the name written here is without .so extension */
Step 3:

Now create the c file with the functions you want to call and other c helper functions: imported functions has special name signature which always starts with JNIEXPORT

JNIEXPORT j_appended_return_type JNICALL Java_package_name_class_name_func(JNIEnv *, jclass, args);
JNIEXPORT j_appended_return_type JNICALL Java_com_example_hello_jni_MainActivity_add_two_nums(JNIEnv *, jclass, jint first, jint second);

com.example.hello_jni is the name of the package dot(.) is replaced by underscore(_). Next name is the class name where you want to call the function from rest is actual function name.
jstring, jint etc are data types.
Above part is little bit complex but this is just needed for one or two function calls where you want the interaction from java to C/C++ rest is complete C/C++ as you like it. You can create server/client with C/C++ netdb socket includes use OpenMX AL to play audio video. include  #include for threads assert.h for assert debugging.
Always remember to include #include <jni.h> for macro definition and jni magic
#include <android/log.h>
#define TAG “MyAppTag”
#define LOGVERBOSE(…) __android_log_print(ANDROID_LOG_VERBOSE, TAG, __VA_ARGS__)
Now you can just add LOGVERBOSE(“Any string message if you need to print integer use %u”, integer);
Step 4:
You will also need to write one make file so that ndk-build can actually go through all the c files and build your project. Java program will be build separately.
create file inside jni folder like this:

LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)

LOCAL_MODULE    := jni_module_library_name

LOCAL_SRC_FILES := file_name.c


Other useful flags in make file which you can use:

LOCAL_CFLAGS    := -Werror

LOCAL_LDLIBS    := -llog
Step 5:
Finally you will need to compile jni folder code by command ndk-build from root folder of the project. Don’t compile from inside the jni folder but one directory up. This is because ndk-build read information from AndroidManifest.xml and This will create obj folder with architecture type .o and .so it will also create one libs folder.


What ndk tool does for you? It compiles the architecture dependent C/C++ code for you for the architecture you need it for

You can run any c/c++ program from android shell. You just need to cross compile it with ndk-build and then push the executable in android device using adb push command. By default sdcard is mounted in non-executable format so it is good to push in /data/local and change the permission of the executable to x (execute) then just run.

chmod 755 /data/local/executable_name.out


You can remount sdcard in execute mode using

mount -o remount,rw /mnt/sdcard

To create executable using ndk tool you will need to change the file:


You can also change the LOCAL_MODULE line to the name you want for your executable(executable_name)

Scratch pad:

# for native multimedia
# for logging
# for native windows
LOCAL_LDLIBS += -landroid


Only required directories and files are: jni folder, AndroidManifest.xml, which is created automatically and has android target ndk information
libs and obj will be created
Good JNI tutorial:

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s