主要的JNI代碼放在以下的路徑中：frameworks/base/core/jni/，這個路徑中的內(nèi)容被編譯成庫 libandroid_runtime.so，這是個普通的動態(tài)庫，被放置在目標系統(tǒng)的/system/lib目錄下。此外，android還有其他的 JNI庫。JNI中的各個文件，實際上就是普通的C++源文件；在android中實現(xiàn)的JNI庫，需要連接動態(tài)庫 libnativehelper.so。

1，JNI的實現(xiàn)方式

     實現(xiàn)JNI需要在Java源代碼中聲明，在C++代碼中實現(xiàn)JNI的各種方法，并把這些方法注冊到系統(tǒng)中。實現(xiàn)JNI的核心是 JNINativeMethod結(jié)構(gòu)體。

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

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

      在Java代碼中，定義的函數(shù)由JNI實現(xiàn)時，需要指定函數(shù)為native。

2，在應(yīng)用程序中使用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))   //調(diào)用下層makefile

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

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

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

3，JNI的代碼實現(xiàn)和調(diào)用

A，native.cpp內(nèi)容

     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[] = {                   //本地實現(xiàn)方法列表
             {"add", "(II)I", (void*)add },
     };

    static int registerNativeMethods(JNIEnv* env, const char* className,
    JNINativeMethod* gMethods, int numMethods){}   //為調(diào)用的某個JAVA類注冊本地JNI函數(shù)

    static int registerNatives(JNIEnv* env){}                //為當前平臺注冊所有類及JNI函數(shù)

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

以上三個從下到上依次調(diào)用

B，SimpleJNI.java 內(nèi)容

    package com.example.android.simplejni;  //JAVA包，跟文件路徑對應(yīng)

    import android.app.Activity;
    import android.os.Bundle;
    import android.widget.TextView;            //需要包含的類，以便調(diào)用函數(shù)

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);                     //調(diào)用Native類的函數(shù)add，該add就是JNI函數(shù)，由CPP實現(xiàn)
        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生成的動態(tài)庫，全名是lib+simplejni+.o
    }

    static native int add(int a, int b);                  //聲明動態(tài)庫中實現(xiàn)的JNI函數(shù)add，供JAVA調(diào)用
}

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

JNI 是Java Native Interface。
Java Native Interface (JNI)標準成為java平臺的一部分，
它允許Java代碼和其他語言寫的代碼進行交互。
JNI 是本地編程接口。它使得在 Java 虛擬機 (VM) 內(nèi)部運行的 Java 代碼
能夠與用其它編程語言(如 C、C++ 和匯編語言)編寫的應(yīng)用程序和庫進行互操作。

下面就是我在 Android 環(huán)境中一個Test JNI 的代碼。
1.
// TestNativeApi.java
// Native程序，編譯成jar包形式，被上層java應(yīng)用調(diào)用。
// static 函數(shù)中調(diào)用 android System.loadLibrary() 來調(diào)用 .so 庫，
// loadLibrary()會判斷 .so庫的類型，如果是jni庫，則會調(diào)用 .so庫中的 JNI_OnLoad()函數(shù)來注冊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
// 通過函數(shù) 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()函數(shù)在.so被load的時候調(diào)用
// JNI interface function中可以調(diào)用底層的 C++/C函數(shù)控制硬件等

#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
// 通過函數(shù) 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 使用的數(shù)據(jù)結(jié)構(gòu)JNINativeMethod詳解

Andoird 中使用了一種不同傳統(tǒng)Java JNI的方式來定義其native的函數(shù)。其中很重要的區(qū)別是Andorid使用了一種Java 和 C 函數(shù)的映射表數(shù)組，并在其中描述了函數(shù)的參數(shù)和返回值。這個數(shù)組的類型是JNINativeMethod，定義如下：

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

第一個變量name是Java中函數(shù)的名字。

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

第三個變量fnPtr是函數(shù)指針，指向C函數(shù)。

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

"()V"

"(II)V"

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

實際上這些字符是與函數(shù)的參數(shù)類型一一對應(yīng)的。

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

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

具體的每一個字符的對應(yīng)關(guān)系如下

字符 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

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

[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函數(shù)的參數(shù)是class，則以"L"開頭，以";"結(jié)尾中間是用"/" 隔開的包及類名。而其對應(yīng)的C函數(shù)名的參數(shù)則為jobject. 一個例外是String類，其對應(yīng)的類為jstring

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

如果JAVA函數(shù)位于一個嵌入類，則用$作為類名間的分隔符。

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