More C++ and JNI on Linux Mint

In last JNI tutorial we learned how to compile Java code, generate header and implement and compile native code. JNI declares two main groups of commonly used types. Primitive types, which are int, boolean, float and so on, and they are user friendly, no need to do cast to native types. Other group are reference types, like String, arrays or proper Java classes, and they all inherit from jobject and require special handling to map them to native types. So here is the simple example to illustrate different parameter type handling:

public class MultiCall{
    public native int add(int a, int b);
    public native boolean isOdd(long a);
    public native int sum(int[] arr);
    public native String add(String a, String b);
    static
    {
        System.loadLibrary("MultiCall");
    }
    public static void main(String[] args)
    {
        MultiCall m = new MultiCall();
        System.out.println(m.add(1, 2));
        System.out.println(m.add("Hello", "World"));
        System.out.println(m.sum(new int[]{1,2,3,4}));
        System.out.println(m.isOdd(6L));
    }
}

After we compile it and run javah tool on resulting class, we have the following method definitions:

/* DO NOT EDIT THIS FILE - it is machine generated */ #include <jni.h> /* Header for class MultiCall */ #ifndef _Included_MultiCall #define _Included_MultiCall #ifdef __cplusplus extern "C" { #endif /* * Class: MultiCall * Method: add * Signature: (II)I */ JNIEXPORT jint JNICALL Java_MultiCall_add__II (JNIEnv *, jobject, jint, jint); /* * Class: MultiCall * Method: isOdd * Signature: (J)Z */ JNIEXPORT jboolean JNICALL Java_MultiCall_isOdd (JNIEnv *, jobject, jlong); /* * Class: MultiCall * Method: sum * Signature: ([I)I */ JNIEXPORT jint JNICALL Java_MultiCall_sum (JNIEnv *, jobject, jintArray); /* * Class: MultiCall * Method: add * Signature: (Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String; */ JNIEXPORT jstring JNICALL Java_MultiCall_add__Ljava_lang_String_2Ljava_lang_String_2 (JNIEnv *, jobject, jstring, jstring); #ifdef __cplusplus } #endif #endif

Implementation looks like this:

#include "MultiCall.h" #include <string> using namespace std; JNIEXPORT jint JNICALL Java_MultiCall_add__II(JNIEnv *env, jobject obj, jint a, jint b){ return a+b; } JNIEXPORT jboolean JNICALL Java_MultiCall_isOdd(JNIEnv *env, jobject obj, jlong l){ jboolean res = JNI_TRUE; if(l%2 == 0) res = JNI_FALSE; return res; } JNIEXPORT jint JNICALL Java_MultiCall_sum(JNIEnv *env, jobject obj, jintArray arr){ int res = 0; jsize length = env->GetArrayLength(arr); jint *array = env->GetIntArrayElements(arr, 0); for (int i=0; i<length; i++) res+=array[i]; env->ReleaseIntArrayElements(arr, array, 0); return res; } JNIEXPORT jstring JNICALL Java_MultiCall_add__Ljava_lang_String_2Ljava_lang_String_2(JNIEnv *env, jobject obj, jstring a, jstring b){ const char* ca = env->GetStringUTFChars(a, 0); string na(ca); env->ReleaseStringUTFChars(a, ca); na+=" "; const char* cb = env->GetStringUTFChars(b, 0); string nb(cb); env->ReleaseStringUTFChars(b, cb); string res = na+nb; return env->NewStringUTF(res.c_str()); }

Reference types require significant work to use them from native code. Also if we want to return reference type it needs to be constructed. I am using std::string because it will do deep copy of character array, at least if you are using gcc/g++, and allows me to easily manipulate strings. Code is easy to understand and doesn’t deserve further comments.
The second example is illustration how to throw exception from native code and catch it in Java code.

public class NativeException{
    public native int divide(int a, int b) throws IllegalArgumentException;
    static
    {
        System.loadLibrary("NativeException");
    }
    public static void main(String[] args)
    {
        NativeException n = new NativeException();
        try{
            System.out.println(n.divide(12, 3));
            n.divide(12, 0);
        }catch(Exception e){
            System.out.println(e.getMessage());
        }
    }
}

Even if we marked native method with throws, javac will not complain if we try to call it out of try-catch block. One of reasons why pure Java is preferred to JNI. Also in header file, that throws is just ignored.

/* DO NOT EDIT THIS FILE - it is machine generated */ #include <jni.h> /* Header for class NativeException */ #ifndef _Included_NativeException #define _Included_NativeException #ifdef __cplusplus extern "C" { #endif /* * Class: NativeException * Method: divide * Signature: (II)I */ JNIEXPORT jint JNICALL Java_NativeException_divide (JNIEnv *, jobject, jint, jint); #ifdef __cplusplus } #endif #endif

In implementation we do sanity check and if second parameter is zero we try to throw IllegalArgumentException.

#include "NativeException.h" #include <string> using namespace std; JNIEXPORT jint JNICALL Java_NativeException_divide(JNIEnv *env, jobject obj, jint a, jint b){ int res = 0; if(b==0){ jclass exception = env->FindClass("java/lang/IllegalArgumentException"); if (exception == NULL) { return res; } env->ThrowNew(exception, "division with zero attempted"); return res; } res = a/b; return res; }

If env fails to find IllegalArgumentException, we just return zero.