Android JNI

     JNI是Java Native Interface的縮寫，譯爲Java本地接口。它容許Java代碼和其餘語言編寫的代碼進行交互。在android中提供JNI的方式，讓Java程序能夠調用C語言程序。android中不少Java類都具備native接口，這些接口由本地實現，而後註冊到系統中。

      主要的JNI代碼放在如下的路徑中：frameworks/base/core/jni/，這個路徑中的內容被編譯成庫 libandroid_runtime.so，這是個普通的動態庫，被放置在目標系統的/system/lib目錄下。此外，android還有其餘的 JNI庫。JNI中的各個文件，實際上就是普通的C++源文件；在android中實現的JNI庫，須要鏈接動態庫 libnativehelper.so。

1，JNI的實現方式

     實現JNI須要在Java源代碼中聲明，在C++代碼中實現JNI的各類方法，並把這些方法註冊到系統中。實現JNI的核心是 JNINativeMethod結構體。

typedef struct {
       const char* name;
       const char* signature;
       void* fnPtr;
} JNINativeMethod;

     第一個變量name是Java中JNI函數的名字，第二個變量signature用字符串描述函數參數和返回值，第三個變量fnPtr是JNI函數C指針。  

      在Java代碼中，定義的函數由JNI實現時，須要指定函數爲native。

2，在應用程序中使用JNI，能夠經過代碼中/development/samples/SimpleJNI來分析：

    A，分析頂層 Android.mk文件

    LOCAL_PACKAGE_NAME := SimpleJNI    //生成PACKAGE的名字，在out/target/product/smdk6410/obj/APPS

    LOCAL_JNI_SHARED_LIBRARIES := libsimplejni //生成JNI共享庫的名字，在....smdk6410/obj/SHARED_LIBRARIES

    include $(BUILD_PACKAGE)                   //以生成APK的方式編譯

    include $(call all-makefiles-under,$(LOCAL_PATH))   //調用下層makefile

   B，分析 JNI目錄下Android.mk文件

    LOCAL_SRC_FILES:= /                           //JNI的C++源文件
          native.cpp

    include $(BUILD_SHARED_LIBRARY)       //以共享庫方式編譯

3，JNI的代碼實現和調用

A，native.cpp內容

     static jint add(JNIEnv *env, jobject thiz, jint a, jint b){} //定義JAVA方法add

     static const char *classPathName = "com/example/android/simplejni/Native";   //目標JAVA類路徑

     static JNINativeMethod methods[] = {                   //本地實現方法列表
             {"add", "(II)I", (void*)add },
     };

    static int registerNativeMethods(JNIEnv* env, const char* className,
    JNINativeMethod* gMethods, int numMethods){}   //爲調用的某個JAVA類註冊本地JNI函數

    static int registerNatives(JNIEnv* env){}                //爲當前平臺註冊全部類及JNI函數

    jint JNI_OnLoad(JavaVM* vm, void* reserved)        //爲當前虛擬機平臺註冊本地JNI

以上三個從下到上依次調用

B，SimpleJNI.java 內容

    package com.example.android.simplejni;  //JAVA包，跟文件路徑對應

    import android.app.Activity;
    import android.os.Bundle;
    import android.widget.TextView;            //須要包含的類，以便調用函數

public class SimpleJNI extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        TextView tv = new TextView(this);
        int sum = Native.add(2, 3);                     //調用Native類的函數add，該add就是JNI函數，由CPP實現
        tv.setText("2 + 3 = " + Integer.toString(sum));
        setContentView(tv);                                //在屏幕上顯示
    }
}

 class Native {
    static {
     // The runtime will add "lib" on the front and ".o" on the end of
     // the name supplied to loadLibrary.
        System.loadLibrary("simplejni");              //載入由native.cpp生成的動態庫，全名是lib+simplejni+.o
    }

    static native int add(int a, int b);                  //聲明動態庫中實現的JNI函數add，供JAVA調用
}

    編譯生成PACKAGE後，安裝到MID上，運行便是2+3=5。

 

JNI 是Java Native Interface。
Java Native Interface (JNI)標準成爲java平臺的一部分，
它容許Java代碼和其餘語言寫的代碼進行交互。
JNI 是本地編程接口。它使得在 Java 虛擬機 (VM) 內部運行的 Java 代碼
可以與用其它編程語言(如 C、C++ 和彙編語言)編寫的應用程序和庫進行互操做。

下面就是我在 Android 環境中一個Test JNI 的代碼。
1. 
// TestNativeApi.java
// Native程序，編譯成jar包形式，被上層java應用調用。
// static 函數中調用 android System.loadLibrary() 來調用 .so 庫，
// loadLibrary()會判斷 .so庫的類型，若是是jni庫，則會調用 .so庫中的 JNI_OnLoad()函數來註冊jni interface.

package com.me.test;

import android.util.Log;

public final class TestNativeApi {

   static {
        try {
            System.loadLibrary("itest_jni");
        } catch (UnsatisfiedLinkError e) {
            Log.d("itest_jni", "itest jni library not found!");
        }
    }

    /**
     * This class is uninstantiable.
     */
    private TestNativeApi() {
        // This space intentionally left blank.
    }

    public native static int apiFunction();

}

// Android.mk for TestNativeApi.java
// 經過函數 BUILD_JAVA_LIBRARY 編譯成jar.

# Build com.me.test.jar
# ============================================================

test_dirs := /
 ./test/java/com/me/test

test_src_files := $(call all-java-files-under,$(cm_dirs))

# ====  the library  =========================================
include $(CLEAR_VARS)

LOCAL_SRC_FILES := $(test_src_files)

LOCAL_NO_STANDARD_LIBRARIES := true
LOCAL_JAVA_LIBRARIES := core framework

LOCAL_MODULE := com.me.test

include $(BUILD_JAVA_LIBRARY) 

2.
// TestInternalApi.cpp
// JNI interface class, JNI_OnLoad()函數在.so被load的時候調用
// JNI interface function中能夠調用底層的 C++/C函數控制硬件等

#define LOG_TAG "itest_jni"
#include <utils/misc.h>
#include <utils/Log.h>
#include "jni.h"
#include "JNIHelp.h"
#include "android_runtime/AndroidRuntime.h"
#include "scm_dbus_utils.h"

#define INTERNALAPI_PKG_NAME                "com/me/test/TestNativeApi"

using namespace android;

static jint test_TestInterAPI_Func(JNIEnv* env, jobject clazz)
{
    jint ret = (jint)0;

    LOGD("call /"%s/"", __FUNCTION__);
    return ret;
}

/*
 * JNI registration.
 */

static JNINativeMethod gTestInterApiMethods[] = {
    { "apiFunction", "()I", (void *)test_TestInterAPI_Func }
};

int register_com_me_test_TestInternalApiNative(JNIEnv *env)
{
    return AndroidRuntime::registerNativeMethods(env, INTERNALAPI_PKG_NAME, gTestInterApiMethods, NELEM(gTestInterApiMethods));
}

jint JNI_OnLoad(JavaVM* vm, void* reserved)
{
    JNIEnv* env = NULL;
    jint result = -1;

    LOGD("TestInteralApi JNI loaded");

    if (vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) {
        LOGE("GetEnv failed");
        goto bail;
    }
    assert(env != NULL);

    if (register_com_me_test_TestInternalApiNative(env) < 0) {
        LOGE("TestInternalApi native registration failed");
        goto bail;
    }

    result = JNI_VERSION_1_4;

bail:
    return result;
}

// Android.mk for TestInternalApi.cpp
// 經過函數 BUILD_SHARED_LIBRARY 編譯成 .so .

include $(CLEAR_VARS)

ifeq ($(TARGET_ARCH), arm)
 LOCAL_CFLAGS += -DPACKED="__attribute__ ((packed))"
else
 LOCAL_CFLAGS += -DPACKED=""
endif

LOCAL_SRC_FILES:= /
 TestInternalApi.cpp

LOCAL_C_INCLUDES += /
 $(JNI_H_INCLUDE)

LOCAL_SHARED_LIBRARIES := /
 libandroid_runtime /
 libnativehelper /
 libcutils /
 libutils /
 libdvm

LOCAL_MODULE:= libitest_jni

include $(BUILD_SHARED_LIBRARY)

endif

 

 

Android JNI 使用的數據結構JNINativeMethod詳解

Andoird 中使用了一種不一樣傳統Java JNI的方式來定義其native的函數。其中很重要的區別是Andorid使用了一種Java 和 C 函數的映射表數組，並在其中描述了函數的參數和返回值。這個數組的類型是JNINativeMethod，定義以下：

typedef struct {
const char* name;
const char* signature;
void* fnPtr;
} JNINativeMethod;

第一個變量name是Java中函數的名字。

第二個變量signature，用字符串是描述了函數的參數和返回值

第三個變量fnPtr是函數指針，指向C函數。

其中比較難以理解的是第二個參數，例如

"()V"

"(II)V"

"(Ljava/lang/String;Ljava/lang/String;)V"

實際上這些字符是與函數的參數類型一一對應的。

"()" 中的字符表示參數，後面的則表明返回值。例如"()V" 就表示void Func();

"(II)V" 表示 void Func(int, int);

具體的每個字符的對應關係以下

字符 Java類型 C類型

V      void            void
Z       jboolean     boolean
I        jint              int
J       jlong            long
D      jdouble       double
F      jfloat            float
B      jbyte            byte
C      jchar           char
S      jshort          short

數組則以"["開始，用兩個字符表示

[I       jintArray      int[]
[F     jfloatArray    float[]
[B     jbyteArray    byte[]
[C    jcharArray    char[]
[S    jshortArray   short[]
[D    jdoubleArray double[]
[J     jlongArray     long[]
[Z    jbooleanArray boolean[]

上面的都是基本類型。若是Java函數的參數是class，則以"L"開頭，以";"結尾中間是用"/" 隔開的包及類名。而其對應的C函數名的參數則爲jobject. 一個例外是String類，其對應的類爲jstring

Ljava/lang/String; String jstring
Ljava/net/Socket; Socket jobject

若是JAVA函數位於一個嵌入類，則用$做爲類名間的分隔符。

例如 "(Ljava/lang/String;Landroid/os/FileUtils$FileStatus;)Z"