In Android, image processing can be performed using Java or RenderScript or Native(C/C++). The performance of native code(C/C++) for image processing is much better than Java and RenderScript. So we used native code for image processing in the photo editor of the Phimpme image application. In this blog, I explain how image processing is performed in Phimpme Android.
Setting up build script for native code.
NDK helps us to develop Android applications using native languages like C and C++ so that heavy tasks can be performed in relatively less time. We can also use libraries built using C/C++ in Android application using this NDK. NDK can be downloaded using the SDK manager of Android Studio and can be set up following instructions in Android developers’ site.
After setting up the NDK, we will create a simple application involving native code and understand the flow of functions from Java to native.
The java files are present in app/src/main/java directory. Similarly, all the native files are present in app/src/main/jni directory.
So now let’s create necessary files in jni directory.
- main.c – Native functions are added here
- Android.mk and Application.mk – make files for building native code using ndkbuild.
Android.mk
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_SRC_FILES := main.c // include the files that should be
// built(.c, .cpp, .h)
LOCAL_LDLIBS += -llog
LOCAL_MODULE := modulename //name of the module (custom)
include $(BUILD_SHARED_LIBRARY)
Application.mk
APP_OPTIM := release
APP_ABI := all //architectures for which native lib
//has to be built(can be one or many.
//should be separated by comma)
APP_PLATFORM := android-25
Add these lines to app’s build.gradle for building native code along with the Gradle build.
externalNativeBuild {
ndkBuild {
path 'src/main/jni/Android.mk'
}
}
The above lines in build.gradle will run Android.mk during the Gradle build.
When the Android.mk runs, it compiles all native code and generates modulename.so files in .externalNativeBuild/ndkBuild directory for all the mentioned architectures. This .so file for a particular architecture is a library containing all the native code compatible with that architecture.
So when this library(.so file) is statically imported into Java code, native code gets linked to Java and enables calling native functions directly from Java.
Importing native Library into Java
Static import of this library can be done by writing the below lines in your Java class.
static {
System.loadLibrary("modulename");
}
Creating a native function and calling it from Java?
Unlike normal java code, where you call a function by its name, here in native Android development, the name of the native function is different from what you call it in java. To understand this clearly, let’s see an example of simple hello world application. Define the native function in Java and call it normally like any other function.
package org.fossasia.phimpme;
import …
public class MainActivity extends Activity {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
textView = (TextView)findViewById(R.id.textview);
textView.setText(helloworld());
}
static {
System.loadLibrary(“modulename”);
}
Public native String helloworld();
}
Here the definition of the native function is present in org.fossasia.phimpme package and MainActivity class. So the name of the function in the native file should be “Java_org_fossasia_phimpme_MainActivity_helloworld”.
It follows a general structure of concatenating these strings Java, package name, Class name, function name defined in Java and replacing all full stops(.) with underscores(_).
The first two arguments in native function are JNIEnv* and jobject. These are present always. For a zero argument definition of a function in Java, there will be these two arguments in the native function. If there are two arguments defined in Java, there will be two arguments additional to these two arguments in the native function. These help in passing data in and out of the native part.
Here’s an example of a native function to output a string to Java
main.c :
#include <jni.h>
jstring Java_org_fossasia_phimpme_MainActivity_helloworld (JNIEnv * env, jobject obj){
return (*env)->NewStringUTF(env, "Hello World from Native");
}
Now when you run this application, you see “Hello World from Native” displayed on the screen. I hope this post clears about the flow of the native functions and how to link them with Java.