坐着扦插bb有什么好处,JAPANESE69极品少妇,亚洲s色大片

_ 聲明: 對原文格式以及內(nèi)容做了細(xì)微的修改和美化, 主要為了方便閱讀和理解 _

一. 基礎(chǔ)

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

從如何載入.so檔案談起
由于Android 的應(yīng)用層的類都是以Java寫的，這些Java類編譯為Dex型式的Bytecode之后，必須靠Dalvik虛擬機(jī)(VM: Virtual Machine)來執(zhí)行。VM在Android平臺里，扮演很重要的角色。此外，在執(zhí)行Java類的過程中，如果Java類需要與C組件溝通時，VM就會去載入C組件，然后讓Java的函數(shù)順利地調(diào)用到C組件的函數(shù)。此時，VM扮演著橋梁的角色，讓Java與C組件能通過標(biāo)準(zhǔn)的JNI介面而相互溝通。應(yīng)用層的Java類是在虛擬機(jī)(VM: Vitual Machine)上執(zhí)行的，而C件不是在VM上執(zhí)行，那么Java程式又如何要求VM去載入(Load)所指定的C組件呢?
可使用下述指令：
System.loadLibrary("*.so的檔案名");
例如，Android框架里所提供的 MediaPlayer.java 類，含指令：
public class MediaPlayer{　　 static {　　 System.loadLibrary("media_jni");　　 }　　 }　
這要求VM去載入Android的/system/lib/libmedia_jni.so檔案。載入*.so之后，Java類與*.so檔案就匯合起來，一起執(zhí)行了。
如何撰寫*.so的入口函數(shù)

JNI_OnLoad()與JNI_OnUnload()函數(shù)的用途　　
當(dāng)Android的VM(Virtual Machine)執(zhí)行到System.loadLibrary()函數(shù)時，首先會去執(zhí)行C組件里的JNI_OnLoad()函數(shù)。
它的用途有二：　　
* (a) 指定JNI版本
告訴VM此C組件使用那一個JNI版本。如果你的.so檔沒有提供JNI_OnLoad()函數(shù)，VM會默認(rèn)該.so檔是使用最老的 JNI 1.1版本。由于新版的JNI做了許多擴(kuò)充，如果需要使用JNI的新版功能，例如JNI 1.4的java.nio.ByteBuffer,就必須藉由JNI_OnLoad()函數(shù)來告知VM。JNI_OnLoad()函數(shù)的返回值便是JNI的版本號, 這個版版號的值定義在jni.h文件中, 如下:

#define JNI_VERSION_1_1 0x00010001
#define JNI_VERSION_1_2 0x00010002
#define JNI_VERSION_1_4 0x00010004
#define JNI_VERSION_1_6 0x00010006

    * (b) 做C組件的初始化工作.

由于VM執(zhí)行到System.loadLibrary()函數(shù)時，就會立即調(diào)用JNI_OnLoad()方法，所以C組件的開發(fā)者可以借由JNI_OnLoad()函數(shù)來進(jìn)行C組件內(nèi)的某些初始化工作(Initialization) 。　　
例如，在Android的/system/lib/libmedia_jni.so檔案里，就提供了JNI_OnLoad()函數(shù)，其程式碼片段為：

//#define LOG_NDEBUG 0
        #define LOG_TAG "MediaPlayer-JNI"

        jint JNI_OnLoad(JavaVM *vm, void *reserved) {
            JNIEnv *env = NULL;
            jint result = -1;
            if (vm->GetEnv((void **) &env, JNI_VERSION_1_4) != JNI_OK) {
                LOGE("ERROR: GetEnv failed ");
                goto bail;
            }
            assert(env != NULL);

            if (register_android_media_MediaPlayer(env) < 0) {
                LOGE("ERROR: MediaPlayer native registration failed ");
                goto bail;
            }

            if (register_android_media_MediaRecorder(env) < 0) {
                LOGE("ERROR: MediaRecorder native registration failed ");
                goto bail;
            }

            if (register_android_media_MediaScanner(env) < 0) {
                LOGE("ERROR: MediaScanner native registration failed ");
                goto bail;
            }

            if (register_android_media_MediaMetadataRetriever(env) < 0) {
                LOGE("ERROR: MediaMetadataRetriever native registration failed ");
                goto bail;
            }

            result = JNI_VERSION_1_4;

            bail:
                return result;
        }

此函數(shù)回傳JNI_VERSION_1_4值給VM，于是VM知道了其所使用的JNI版本了。此外，它也做了一些初期的動作(可呼叫任何本地函數(shù))，例如指令：　　
if (register_android_media_MediaPlayer(env) < 0) {
LOGE("ERROR: MediaPlayer native registration failed ");
goto bail;
}
就將此組件提供的各個本地函數(shù)(Native Function)登記到VM里，以便能加快后續(xù)呼叫本地函數(shù)的效率。　　
JNI_OnUnload()函數(shù)與JNI_OnLoad()相對應(yīng)的。在載入C組件時會立即呼叫JNI_OnLoad()來進(jìn)行組件內(nèi)的初期動作;而當(dāng)VM釋放該C組件時，則會呼叫JNI_OnUnload()函數(shù)來進(jìn)行善后清除動作。當(dāng)VM呼叫JNI_OnLoad()或 JNI_Unload()函數(shù)時，都會將VM的指針(Pointer)傳遞給它們，其參數(shù)如下:
jint JNI_OnLoad(JavaVM* vm, void* reserved) { }
jint JNI_OnUnload(JavaVM* vm, void* reserved) { } 　　
在JNI_OnLoad()函數(shù)里，就通過過VM之指標(biāo)而取得JNIEnv之指標(biāo)值，并存入env指標(biāo)變數(shù)里，如下述指令：
jint JNI_OnLoad(JavaVM *vm, void *reserved) {
JNIEnv *env = NULL;
jint result = -1;
if (vm->GetEnv((void **) &env, JNI_VERSION_1_4) != JNI_OK) {
LOGE("ERROR: GetEnv failed ");
goto bail;
}
}
由于VM通常是多線程(Multi-threading)執(zhí)行環(huán)境。每一個線程在呼叫JNI_OnLoad()時，所傳遞進(jìn)來的JNIEnv指針值都是不同的。為了配合這種多線程環(huán)境，C組件開發(fā)者在撰寫本地函數(shù)時，可借由JNIEnv指針值的不同而避免多線程中的資料訪問沖突，這樣才能確保所寫的本地函數(shù)能安全地在不同Android進(jìn)程中安全的執(zhí)行。基于這個理由，當(dāng)在呼叫C組件的函數(shù)時，都會將JNIEnv指標(biāo)值傳遞給它，如下：　　
jint JNI_OnLoad(JavaVM *vm, void *reserved) {
JNIEnv *env = NULL;
if (register_android_media_MediaPlayer(env) < 0) {

            }
        }

在JNI_OnLoad()函數(shù)中調(diào)用register_android_media_MediaPlayer(env)函數(shù)時，就將env指針傳遞過去了。如此，在register_android_media_MediaPlayer()函數(shù)就能借由該指針做到同步操作資源，以便化解資料沖突的問題。
例如，在register_android_media_MediaPlayer()函數(shù)里，可撰寫下述代碼：　　
if ((*env)->MonitorEnter(env, obj) != JNI_OK) {　}
查看是否已經(jīng)有其他線程使用此物件，如果沒有，此程序就進(jìn)入if代碼塊并使用該物件執(zhí)行相關(guān)動作。還有，也可撰寫下述指令：　　
if ((*env)->MonitorExit(env, obj) != JNI_OK) {　}　　
查看是否是有線程在使用此物件，如果是，當(dāng)前線程不進(jìn)入if代碼塊。

registerNativeMethods() 函數(shù)的用途　　
應(yīng)用層級的Java類別透過VM而呼叫到本地函數(shù)。一般是仰賴VM去尋找*.so里的本地函數(shù)。如果需要連續(xù)呼叫很多次，每次都需要尋找一遍，會多花許多時間。此時，組件開發(fā)者可以自行將本地函數(shù)向VM進(jìn)行登記。例如，在Android的/system/lib/libmedia_jni.so 檔案里的代碼段如下：　　
#define LOG_NDEBUG 0
#define LOG_TAG "MediaPlayer-JNI"
static JNINativeMethod gMethods[] = {
{"setDataSource", "(Ljava/lang/String;)V",(void *) android_media_MediaPlayer_setDataSource},
{"setDataSource", "(Ljava/io/FileDescriptor;JJ)V", (void *) android_media_MediaPlayer_setDataSourceFD},
{"prepare", "()V", (void *) android_media_MediaPlayer_prepare},
{"prepareAsync", "()V", (void *) android_media_MediaPlayer_prepareAsync},
{"_start", "()V", (void *) android_media_MediaPlayer_start},
{"_stop", "()V", (void *) android_media_MediaPlayer_stop},
{"getVideoWidth", "()I",
(void *) android_media_MediaPlayer_getVideoWidth},
{ "getVideoHeight", "()I", (void *) android_media_MediaPlayer_getVideoHeight },
{ "seekTo", "(I)V", (void *) android_media_MediaPlayer_seekTo },
{ "_pause", "()V", (void *) android_media_MediaPlayer_pause },
{ "isPlaying", "()Z", (void *) android_media_MediaPlayer_isPlaying },
{ "getCurrentPosition", "()I", (void *) android_media_MediaPlayer_getCurrentPosition },
{ "getDuration", "()I", (void *) android_media_MediaPlayer_getDuration },
{ "_release", "()V", (void *) android_media_MediaPlayer_release },
{ "_reset", "()V", (void *) android_media_MediaPlayer_reset },
{ "setAudioStreamType", "(I)V", (void *) android_media_MediaPlayer_setAudioStreamType },
{ "setLooping", "(Z)V", (void *) android_media_MediaPlayer_setLooping },
{ "setVolume", "(FF)V", (void *) android_media_MediaPlayer_setVolume },
{ "getFrameAt", "(I)Landroid/graphics/Bitmap;",
(void *) android_media_MediaPlayer_getFrameAt },
{ "native_setup", "(Ljava/lang/Object;)V",
(void *) android_media_MediaPlayer_native_setup },
{ "native_finalize", "()V", (void *) android_media_MediaPlayer_native_finalize },
};
```
     static int register_android_media_MediaPlayer(JNIEnv *env) {
         return AndroidRuntime::registerNativeMethods(env, "android/media/MediaPlayer", gMethods, NELEM(gMethods));
     }

     jint JNI_OnLoad(JavaVM *vm, void *reserved) {
         if (register_android_media_MediaPlayer(env) < 0) {
             LOGE("ERROR: MediaPlayer native registration failed ");
             goto bail;
         }
     }　　
```

當(dāng)VM載入libmedia_jni.so檔案時，就呼叫JNI_OnLoad()函數(shù)。接著，JNI_OnLoad()呼叫 register_android_media_MediaPlayer()函數(shù)。此時，就呼叫到 AndroidRuntime::registerNativeMethods()函數(shù)，向VM(即AndroidRuntime)登記 gMethods[]表格所含的本地函數(shù)了。簡而言之， registerNativeMethods()函數(shù)的用途有二：

(1) 更有效率去找到函數(shù)。
(2) 可在執(zhí)行期間進(jìn)行抽換。
由于gMethods[]是一個<名稱，函數(shù)指針>對照表，在程序執(zhí)行時，可多次呼叫registerNativeMethods()函數(shù)來更換本地函數(shù)之指針，而達(dá)到彈性抽換本地函數(shù)之目的.
(這里別有深意, 可以用來hook Android的系統(tǒng)的某些native函數(shù))

Andoird 中使用了一種不同傳統(tǒng)Java JNI的方式來定義其native的函數(shù)。其中很重要的區(qū)別是Andorid使用了一種Java 和 C 函數(shù)的映射表數(shù)組，并在其中描述了函數(shù)的參數(shù)和返回值。這個數(shù)組的類型是JNINativeMethod，定義如下：　　
typedef struct {
const char* name; // Android Native方法名稱
const char* signature; // AndroidNative方法的簽名, 可以用javah查看方法簽名
void* fnPtr; // c/c++函數(shù)的函數(shù)指針
} JNINativeMethod;　
其中比較難以理解的是第二個參數(shù)，例如: "()V" , "(II)V" , " (Ljava/lang/String;Ljava/lang/String;)V"　　
實(shí)際上這些字符是與函數(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ù)組則以[開始，用兩個字符表示:

字符	Java類型	C類型
[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

字符	Java類型	C類型
Ljava/lang/String;	String	jstring
Ljava/net/Socket;	Socket	jobject

如果JAVA函數(shù)位于一個嵌入類，則用$作為類名間的分隔符。　　例如:
"(Ljava/lang/String;Landroid/os/FileUtils$FileStatus;)Z"
　　
二. Android JNI編程實(shí)踐

直接使用java本身jni接口(windows/ubuntu)

* (1) 在Eclipsh中新建一個android應(yīng)用程序。兩個類：一個繼承于`Activity`，UI顯示用。另一個包含`native`方法。編譯生成所有類。　　
        package com.hello.jnitest;

        import android.app.Activity;
        import android.os.Bundle;

        import com.stone.jni_demo1.R;

        public class jnitest extends Activity {
            @Override
            public void onCreate(Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);
                setContentView(R.layout.main); 
                Nadd cal = new Nadd();
                setTitle("The Native Add Result is " + String.valueOf(cal.nadd(10, 19)));
            }
        }

Nadd.java文件:

                package com.hello.jnitest;
                public class Nadd {
                    static {
                        System.loadLibrary("Nadd");
                    }
                    public native int nadd(int a, int b);
                }

以上在windows中完成。　　
* (2) 使用javah命令生成C/C++的頭文件。注意類要包含包名，路徑文件夾下要包含所有包中的類，否則會報(bào)找不到類的錯誤。classpath參數(shù)指定到包名前一級文件夾，文件夾層次結(jié)構(gòu)要符合java類的組織層次結(jié)構(gòu)。　　
生成頭文件的命令: javah -classpath ../jnitest/bin com.hello.jnitest.Nadd　
com_hello_jnitest_Nadd .h文件內(nèi)容如下：　　
/* DO NOT EDIT THIS FILE - it is machine generated /
#include <jni.h>
/ Header for class com_hello_jnitest_Nadd */

        #ifndef _Included_com_hello_jnitest_Nadd
        #define _Included_com_hello_jnitest_Nadd
        #ifdef __cplusplus
        extern "C" {
        #endif
        /*
         * Class:     com_hello_jnitest_Nadd
         * Method:    nadd
         * Signature: (II)I
         */
        JNIEXPORT jint JNICALL Java_com_hello_jnitest_Nadd_nadd
          (JNIEnv *, jobject, jint, jint);

        #ifdef __cplusplus
        }
        #endif
        #endif

(3) 編輯*.c文件實(shí)現(xiàn)native方法。　　
com_hello_jnitest_Nadd.c文件：　　
#include
#include "com_hello_jnitest_Nadd.h"

      JNIEXPORT jint JNICALL Java_com_hello_jnitest_Nadd_nadd(JNIEnv * env, jobject c, jint a, jint b) {
          return (a+b);
      }

(4) 編譯 *.c文件生存動態(tài)庫。
命令: arm-none-linux-gnueabi-gcc -I/home/a/work/android/jdk1.6.0_17/include -I/home/a/work/android/jdk1.6.0_17/include/linux -fpic -c com_hello_jnitest_Nadd.c　　arm-none-linux-gnueabi-ld -T/home/a/CodeSourcery/Sourcery_G++_Lite/arm-none-linux-gnueabi/lib/ldscripts/armelf_linux_eabi.xsc -share -o libNadd.so com_hello_jnitest_Nadd.o　　
執(zhí)行上面的命令得到libNadd.so文件。以上在ubuntu中完成。
(5) 將相應(yīng)的動態(tài)庫文件push到avd的system/lib中, 執(zhí)行命令: adb push libNadd.so /system/lib。若提示Read-only file system錯誤，先運(yùn)行adb remount命令，在運(yùn)行　
adb push libNadd.so /system/lib即可.
(6) 在eclipse中運(yùn)行原應(yīng)用程序即可。以上在windows中完成。　　
對于一中生成的so文件也可采用二中的方法編譯進(jìn)apk包中。只需在工程文件夾中建libsarmeabi文件夾(其他文件夾名無效，只建立libs文件夾也無效)，然后將so文件拷入，編譯工程即可。
1. 使用NDK生成本地方法(ubuntu and windows)
- (1) 安裝NDK：
  下載并解壓NDK包，然后進(jìn)入NDK根目錄，運(yùn)行build/host-setup.sh(需要Make 3.81和awk)。若有錯，修改host-setup.sh文件：將#!/bin/sh修改為#!/bin/bash，再次運(yùn)行即可。
- (2) 在apps文件夾下建立自己的工程文件夾，然后在該文件夾下建一文件Application.mk和project文件夾。　　
  Application.mk文件內(nèi)容：　
  APP_PROJECT_PATH := $(call my-dir)/project
  APP_MODULES := myjni
- (3) 在project文件夾下建一個jni文件夾，然后新建Android.mk和myjni.c文件。這里不需要用javah生成相應(yīng)的.h文件，但函數(shù)名要包含相應(yīng)的完整的包、類名。
- (4) 編輯相應(yīng)文件內(nèi)容。　　
  Android.mk文件：　　
  # Copyright (C) 2009 The Android Open Source Project
  # Licensed under the Apache License, Version 2.0 (the "License");
  # you may not use this file except in compliance with the License.
  # You may obtain a copy of the License at
  # http://www.apache.org/licenses/LICENSE-2.0
  # Unless required by applicable law or agreed to in writing, software
  # distributed under the License is distributed on an "AS IS" BASIS,
  # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  # See the License for the specific language governing permissions and
  # limitations under the License.
```
  LOCAL_PATH := $(call my-dir)
  include $(CLEAR_VARS)
  LOCAL_MODULE := myjni
  LOCAL_SRC_FILES := myjni.c
  include $(BUILD_SHARED_LIBRARY)　
```

myjni.c文件：　　
#include <jni.h>
#include "com_hello_NdkTest_NdkTest.h"

        jstring  Java_com_hello_NdkTest_NdkTest_stringFromJNI(JNIEnv* env, jobject thiz ) {
            return (*env)->NewStringUTF(env, "Hello from My-JNI !");
        }

myjni文件組織：　
~/work/android/ndk-1.6_r1/apps$ tree myjni　　
myjni　　
|-- Application.mk　　
|-- project　　
|-- jni　　
|-- Android.mk　　
|-- myjni.c　　
|-- libs　　
|-- armeabi
|-- libmyjni.so　　
4 directories, 4 files　　
* (5) 編譯：make APP=myjni.　　
以上內(nèi)容在ubuntu完成。
以下內(nèi)容在windows中完成。當(dāng)然也可以在ubuntu中完成。　　
* (6) 在eclipsh中創(chuàng)建android application。將myjni中自動生成的libs文件夾拷貝到當(dāng)前工程文件夾中，編譯運(yùn)行即可。　　
NdkTest.java文件：　　
package com.hello.NdkTest;
import android.app.Activity;
import android.os.Bundle;
import android.widget.TextView;

        public class NdkTest extends Activity {
            @Override
            public void onCreate(Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);
                TextView tv = new TextView(this);
                tv.setText( stringFromJNI() );
                setContentView(tv);
            }
            
            public native String stringFromJNI();
            
            static { 
                System.loadLibrary("myjni");
            }
        }

上面生成的so文件也可使用adb push命令將so文件push到avd中運(yùn)行.

**本篇將介紹在JNI編程中如何傳遞參數(shù)和返回值. **
首先要強(qiáng)調(diào)的是，native方法不但可以傳遞Java的基本類型做參數(shù)，還可以傳遞更復(fù)雜的類型，比如String，數(shù)組，甚至自定義的類。這一切都可以在jni.h中找到答案.

(1) Java基本類型的傳遞
用過Java的人都知道，Java中的基本類型包括boolean，byte，char，short，int，long，float，double這樣幾種，如果你用這幾種類型做native方法的參數(shù)，當(dāng)你通過javah -jni生成.h頭文件的時候，只要看一下生成的.h頭文件，就會一清二楚，這些類型分別對應(yīng)的類型是: jboolean，jbyte，jchar，jshort，jint，jlong，jfloat，jdouble 。這幾種類型幾乎都可以當(dāng)成對應(yīng)的C++類型來用，所以沒什么好說的。

(2) String參數(shù)的傳遞　　
Java的String和C++的string是不能對等起來的，所以處理起來比較麻煩。先看一個例子:
　　
class Prompt {

          static {
              System.loadLibrary("Prompt");
          }
          
          // native method that prints a prompt and reads a line
          private native String getLine(String prompt);
          
          public static void main(String args[]) {
              Prompt p = new Prompt();
              String input = p.getLine("Type a line: ");
              System.out.println("User typed: " + input);
          }
      }

在這個例子中，我們要實(shí)現(xiàn)這個native方法:
private native String getLine(String prompt);　　
getLine()方法讀入一個String參數(shù)，返回一個String值。
通過執(zhí)行javah -jni 得到的com_hello_jnitest_Nadd.h頭文件的內(nèi)容是這樣的:
/* DO NOT EDIT THIS FILE - it is machine generated /
#include <jni.h>
/ Header for class com_hello_jnitest_Nadd */

        #ifndef _Included_com_hello_jnitest_Nadd
        #define _Included_com_hello_jnitest_Nadd
        #ifdef __cplusplus
        extern "C" {
        #endif
        /*
         * Class:     com_hello_jnitest_Nadd
         * Method:    nadd
         * Signature: (II)I
         */
        JNIEXPORT jint JNICALL Java_com_hello_jnitest_Nadd_nadd
          (JNIEnv *, jobject, jint, jint);

        #ifdef __cplusplus
        }
        #endif
        #endif

jstring是JNI中對應(yīng)于String的類型，但是和基本類型不同的是，jstring不能直接當(dāng)作C++的string用。如果你用編寫這樣的代碼cout << prompt << endl; 編譯器肯定會扔給你一個錯誤信息的。　　
其實(shí)要處理jstring有很多種方式，這里只講一種我認(rèn)為最簡單的方式，看下面這個例子:
#include "jni.h"
#include "Prompt.h"

        JNIEXPORT jstring JNICALL Java_Prompt_getLine(JNIEnv *env, jobject obj, jstring prompt) {
            const char* str;
            str = env->GetStringUTFChars(prompt, false);
            if(str == NULL) { 
                return NULL;
            }
            std::cout << str << std::endl; 
            env->ReleaseStringUTFChars(prompt, str);
            char* tmpstr = "return string succeeded";
            jstring rtstr = env->NewStringUTF(tmpstr);
            return rtstr; 
        }

在上面的例子中，作為參數(shù)prompt不能直接被C++程序使用，先做了如下轉(zhuǎn)換
str = env->GetStringUTFChars(prompt, false);
將jstring類型變成一個char *類型。
返回的時候，要生成一個jstring類型的對象，也必須通過如下代碼，
jstring rtstr = env->NewStringUTF(tmpstr);
這里用到的GetStringUTFChars()和NewStringUTF()函數(shù)都是JNI提供的處理String類型的函數(shù)，還有其他的函數(shù)這里就不一一列舉了.

(3) 數(shù)組類型的傳遞
和String一樣，JNI為Java基本類型的數(shù)組提供了j*Array類型，比如int[]對應(yīng)的就是jintArray。來看一個傳遞int數(shù)組的例子，Java程序就不寫了,
JNIEXPORT jint JNICALL Java_IntArray_sumArray(JNIEnv *env, jobject obj, jintArray arr) {
jint *carr;
carr = env->GetIntArrayElements(arr, false);
if(carr == NULL) {
return 0;
}
jint sum = 0;
for(int i=0; i<10; i++) {
sum += carr[i];
}
env->ReleaseIntArrayElements(arr, carr, 0);
return sum;
}
這個例子中的GetIntArrayElements()和ReleaseIntArrayElements()函數(shù)就是JNI提供用于處理int數(shù)組的函數(shù)。如果試圖用arr[i]的方式去訪問jintArray類型，毫無疑問會出錯。JNI還提供了另一對函數(shù)GetIntArrayRegion()和 ReleaseIntArrayRegion()訪問int數(shù)組，就不介紹了，對于其他基本類型的數(shù)組，方法類似。
(4) 二維數(shù)組和String數(shù)組　　
在JNI中，二維數(shù)組和String數(shù)組都被視為object數(shù)組，因?yàn)?code>數(shù)組和String被視為object。仍然用一個例子來說明，這次是一個二維int數(shù)組，作為返回值。　　
JNIEXPORT jobjectArray JNICALL Java_ObjectArrayTest_initInt2DArray(JNIEnv *env, jclass cls, int size) {
jobjectArray result;
jclass intArrCls = env->FindClass("[I");
result = env->NewObjectArray(size, intArrCls, NULL);
```
          for (int i = 0; i < size; i++) {
              jint tmp[256];
              jintArray iarr = env->NewIntArray(size);
              
              for(int j = 0; j < size; j++) {
                  tmp[j] = i + j;
              }
              
              env->SetIntArrayRegion(iarr, 0, size, tmp);
              env->SetObjectArrayElement(result, i, iarr);
              env->DeleteLocalRef(iarr);
          }
          
          return result;
      }
```

上面代碼中的第二行 (jobjectArray result; ) 聲明了一個對象數(shù)組, 因?yàn)槲覀円祷氐氖且粋€int[][]類型 (int類型的二維數(shù)組) 的值，所以需要新建一個jobjectArray對象。
jclass intArrCls = env->FindClass("[I"); 是創(chuàng)建一個jclass的引用，因?yàn)?code>result的元素是一維int數(shù)組的引用，所以intArrCls必須是一維int數(shù)組的引用，這一點(diǎn)是如何保證的呢? 注意FindClass()的參數(shù)"[I"，JNI就是通過它來確定引用的類型的，I表示是int類型，[標(biāo)識是數(shù)組。對于其他的類型，都有相應(yīng)的表示方法，

標(biāo)識符	類型
Z	boolean
B	byte
C	char
S	short
I	int
J	long
F	float
D	double

String是通過“Ljava/lang/String;”表示的，那相應(yīng)的，String數(shù)組就應(yīng)該是“[Ljava/lang/String;”。
還是回到代碼，
result = env->NewObjectArray(size, intArrCls, NULL);　的作用是為result分配空間。　　
jintArray iarr = env->NewIntArray(size); 是為一維int數(shù)組iarr分配空間。
env->SetIntArrayRegion(iarr, 0, size, tmp); 是為iarr賦值。
env->SetObjectArrayElement(result, i, iarr);是為result的第i個元素賦值。

通過上面這些步驟，我們就創(chuàng)建了一個二維int數(shù)組，并賦值完畢，這樣就可以做為參數(shù)返回了。
如果了解了上面介紹的這些內(nèi)容，基本上大部分的任務(wù)都可以對付了。雖然在操作數(shù)組類型，尤其是二維數(shù)組和String數(shù)組的時候，比起在單獨(dú)的語言中編程要麻煩，但既然我們享受了跨語言編程的好處，必然要付出一定的代價(jià)。　　
有一點(diǎn)要補(bǔ)充的是，本文所用到的函數(shù)調(diào)用方式都是針對C++的，如果要在C中使用，所有的env->都要被替換成(env)->，而且后面的函數(shù)中需要增加一個參數(shù)env，具體請看一下jni.h的代碼。*另外還有些省略的內(nèi)容，可以參考JNI的文檔：Java Native Interface 6.0 Specification，Interface 6.0 Specification 翻譯文檔
在JDK的文檔里也可以找到。如果要進(jìn)行更深入的JNI編程，需要仔細(xì)閱讀這個文檔。接下來的高級篇，也會討論更深入的話題

4.在本篇中，將會涉及關(guān)于JNI編程更深入的話題，
包括：在native方法中訪問Java類的域和方法，將Java中自定義的類作為參數(shù)和返回值傳遞等等。了解這些內(nèi)容，將會對JNI編程有更深入的理解，寫出的程序也更清晰，易用性更好。

(1). 在一般的Java類中定義native方法　
在前兩篇的例子中，都是將native方法放在main方法的Java類中，實(shí)際上，完全可以在任何類中定義native方法。這樣，對于外部來說，這個類和其他的Java類沒有任何區(qū)別。
(2) 訪問Java類的域和方法　　
native方法雖然是native的，但畢竟是方法，那么就應(yīng)該同其他方法一樣，能夠訪問類的私有域和方法。實(shí)際上，JNI的確可以做到這一點(diǎn)，我們通過幾個例子來說明，　　　
public class ClassA {
String str_ = "abcde";
int number_;
```
        public native void nativeMethod();
        
        private void javaMethod() {
            System.out.println("call java method succeeded");
        }
        
        static {
            System.loadLibrary("ClassA");
        } 
    }
```

在這個例子中，我們在一個沒有main()方法的Java類中定義了native方法。我們將演示如何在nativeMethod()中訪問域str_，number_和方法javaMethod()，nativeMethod()的C++實(shí)現(xiàn)如下，
JNIEXPORT void JNICALL Java_testclass_ClassCallDLL_nativeMethod(JNIEnv *env, jobject obj) {
// access field str_
jclass cls = env->GetObjectClass(obj);
jfieldID fid = env->GetFieldID(cls, "str_", "Ljava/lang/String;");
jstring jstr = (jstring)env->GetObjectField(obj, fid);
const char *str = env->GetStringUTFChars(jstr, false);
if(std::string(str) == "abcde") {
std::cout << "access field succeeded" << std::endl;
}
// access field number_
jint i = 2468;
fid = env->GetFieldID(cls, "number_", "I");
env->SetIntField(obj, fid, i);

            // access method javaMethod()
            jmethodID mid = env->GetMethodID(cls, "javaMethod", "()V");
            env->CallVoidMethod(obj, mid);
        }

上面的代碼中，通過如下兩行代碼獲得 str_的值,

jfieldID fid = env->GetFieldID(cls, "str_", "Ljava/lang/String;");
jstring jstr = (jstring)env->GetObjectField(obj, fid);

第一行代碼獲得str_的id，在GetFieldID()函數(shù)的調(diào)用中需要指定str_的類型，第二行代碼通過str_的id獲得它的值，當(dāng)然我們讀到的是一個jstring類型，不能直接顯示，需要轉(zhuǎn)化為char *類型。　　
接下來我們看如何給Java類的域賦值，看下面兩行代碼，

fid = env->GetFieldID(cls, "number_", "I");　　
env->SetIntField(obj, fid, i);

第一行代碼同前面一樣，獲得number_的id，第二行我們通過SetIntField()函數(shù)將i的值賦給number_，其他類似的函數(shù)可以參考JDK的文檔。　
訪問javaMethod()的過程同訪問域類似，

jmethodID mid = env->GetMethodID(cls, "javaMethod", "()V");
env->CallVoidMethod(obj, mid);```
需要強(qiáng)調(diào)的是，在`GetMethodID()`中，我們需要指定`javaMethod()`方法的類型，域的類型很容易理解，方法的類型如何定義呢，在上面的例子中，我們用的是`()V`，`V`表示返回值為空，`()`表示參數(shù)為空。如果是更復(fù)雜的函數(shù)類型如何表示? 
看一個例子，`long f (int n, String s, int[] arr);` 這個函數(shù)的類型符號是`(ILjava/lang/String;[I)J`，`I`表示`int`類型，`Ljava/lang/String;`表示`String`類型，`[I`表示`in`t數(shù)組，`J`表示`long`。這些都可以在文檔中查到。　　
  * (3) 在native方法中使用用戶定義的類　　
JNI不僅能使用Java的基礎(chǔ)類型，還能使用用戶定義的類，這樣靈活性就大多了。大體上使用自定義的類和使用Java的基礎(chǔ)類(比如 String)沒有太大的區(qū)別，關(guān)鍵的一點(diǎn)是，如果要使用自定義類，首先要能訪問類的構(gòu)造函數(shù)，看下面這一段代碼，我們在native方法中使用了自定義的`Java`類`ClassB`，
            jclass cls = env->FindClass("Ltestclass/ClassB;");
            jmethodID id = env->GetMethodID(cls, "", "(D)V");
            jdouble dd = 0.033;
            jvalue args[1];
            args[0].d = dd;
            jobject obj = env->NewObjectA(cls, id, args);
首先要創(chuàng)建一個自定義類的引用，通過`FindClass()`函數(shù)來完成，參數(shù)同前面介紹的創(chuàng)建 `String`對象的引用類似，只不過類名稱變成自定義類的名稱。然后通過`GetMethodID()`函數(shù)獲得這個類的構(gòu)造函數(shù)，**注意這里方法的名稱是`""`，它表示這是一個構(gòu)造函數(shù)。**
`jobject obj = env->NewObjectA(cls, id, args);` 生成了一個`ClassB`的對象，`args`是`ClassB`的構(gòu)造函數(shù)的參數(shù)，它是一個`jvalue *`類型。　　
通過以上介紹的三部分內(nèi)容，`native`方法已經(jīng)看起來完全像Java自己的方法了，至少主要功能上齊備了，只是實(shí)現(xiàn)上稍麻煩。而了解了這些，JNI編程的水平也更上一層樓。下面要討論的話題也是一個重要內(nèi)容，至少如果沒有它，我們的程序只能停留在演示階段，不具有實(shí)用價(jià)值。　　
  * (4) 異常處理　　
在C++和Java的編程中，異常處理都是一個重要的內(nèi)容。但是在JNI中，麻煩就來了，  `native`方法是通過`C++`實(shí)現(xiàn)的，如果在`native`方法中發(fā)生了異常，如何傳導(dǎo)到Java呢?　JNI提供了實(shí)現(xiàn)這種功能的機(jī)制。我們可以通過下面這段代碼拋出一個Java可以接收的異常，　　
            jclass errCls;
            env->ExceptionDescribe();
            env->ExceptionClear();
            errCls = env->FindClass("java/lang/IllegalArgumentException");
            env->ThrowNew(errCls, "thrown from C++ code");　　
如果要拋出其他類型的異常，替換掉`FindClass()`函數(shù)的參數(shù)即可。這樣，在Java中就可以接收到`native`方法中拋出的異常。　　

References: 
在Android Studio中進(jìn)行NDK開發(fā): 
https://developer.android.google.cn/studio/projects/add-native-code.html
https://developer.android.google.cn/ndk/guides/build.html
http://docs.oracle.com/javase/8/docs/technotes/guides/jni/spec/jniTOC.html
http://www.tuicool.com/articles/NfAfuum
http://blog.csdn.net/xiaoyu_93/article/details/53082088
http://www.lxweimin.com/p/0261e6cceb3e

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

[轉(zhuǎn)] Android JNI 作用及其詳解

[轉(zhuǎn)] Android JNI 作用及其詳解

推薦閱讀更多精彩內(nèi)容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

[轉(zhuǎn)] Android JNI 作用及其詳解

推薦閱讀更多精彩內(nèi)容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频