androidjnijavac
1. 如何在Android下使用JNI
方法步驟：
第一步：
使用java編寫HelloWorld 的Android應用程序：
代碼如下
package com.lucyfyr;
import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
public class HelloWorld extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
Log.v("fresne", printJNI("I am HelloWorld Activity"));
}
static
{
//載入庫文件
System.loadLibrary("HelloWorldJni");
}
//聲明原生函數 參數為String類型 返回類型為String
private native String printJNI(String inputStr);
}
這一步可以使用eclipse來生成一個App；
因為eclipse會自動編譯此Java文件，後面要是用到。
第二步：
生成共享庫的頭文件：
進入到eclipse生成的Android Project中 ：/HelloWorld/bin/classes/com/lucyfyr/ 下：
可以看到裡面後很多後綴為.class的文件，就是eclipse為自動編譯好了的java文件，其中就有：
HelloWorld.class文件。
退回到classes一級目錄：/HelloWorld/bin/classes/
執行如下命令：
javah com.lucyfyr.HelloWorld
生成文件:com_lucyfyr_HelloWorld.h
/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class com_lucyfyr_HelloWorld */
#ifndef _Included_com_lucyfyr_HelloWorld
#define _Included_com_lucyfyr_HelloWorld
#ifdef __cplusplus
extern "C" {
#endif
/*
* Class: com_lucyfyr_HelloWorld
* Method: printJNI
* Signature: (Ljava/lang/String;)Ljava/lang/String;
*/
JNIEXPORT jstring JNICALL Java_com_lucyfyr_HelloWorld_printJNI
(JNIEnv *, jobject, jstring);
#ifdef __cplusplus
}
#endif
#endif
可以看到自動生成對應的函數：Java_com_lucyfyr_HelloWorld_printJNI
Java_ + 包名（com.lucyfyr） + 類名(HelloWorld) + 介面名(printJNI)：必須要按此JNI規范來操作；
java虛擬機就可以在com.simon.HelloWorld類調用printJNI介面的時候自動找到這個C實現的Native函數調用。
當然函數名太長，可以在.c文件中通過函數名映射表來實現簡化。
第三步：
實現JNI原生函數源文件：
新建com_lucyfyr_HelloWorld.c文件：
#include <jni.h>
#define LOG_TAG "HelloWorld"
#include <utils/Log.h>
/* Native interface, it will be call in java code */
JNIEXPORT jstring JNICALL Java_com_lucyfyr_HelloWorld_printJNI(JNIEnv *env, jobject obj,jstring inputStr)
{
LOGI("fresne Hello World From libhelloworld.so!");
// 從 instring 字元串取得指向字元串 UTF 編碼的指針
const char *str =
(const char *)(*env)->GetStringUTFChars( env,inputStr, JNI_FALSE );
LOGI("fresne--->%s",(const char *)str);
// 通知虛擬機本地代碼不再需要通過 str 訪問 Java 字元串。
(*env)->ReleaseStringUTFChars(env, inputStr, (const char *)str );
return (*env)->NewStringUTF(env, "Hello World! I am Native interface");
}
/* This function will be call when the library first be load.
* You can do some init in the libray. return which version jni it support.
*/
jint JNI_OnLoad(JavaVM* vm, void* reserved)
{
void *venv;
LOGI("fresne----->JNI_OnLoad!");
if ((*vm)->GetEnv(vm, (void**)&venv, JNI_VERSION_1_4) != JNI_OK) {
LOGE("fresne--->ERROR: GetEnv failed");
return -1;
}
return JNI_VERSION_1_4;
}
OnLoadJava_com_lucyfyr_HelloWorld_printJNI
函數裡面做一些log輸出 注意JNI中的log輸出的不同。
JNI_OnLoad函數JNI規范定義的，當共享庫第一次被載入的時候會被回調，
這個函數裡面可以進行一些初始化工作，比如注冊函數映射表，緩存一些變數等，
最後返回當前環境所支持的JNI環境。本例只是簡單的返回當前JNI環境。
第四步：
編譯生成so庫
編譯com_lucyfyr_HelloWorld.c成so庫可以和app一起編譯，也可以都單獨編譯。
在當前目錄下建立jni文件夾：HelloWorld/jni/
下建立Android.mk ，並將com_lucyfyr_HelloWorld.c和 com_lucyfyr_HelloWorld.h 拷貝到進去
編寫編譯生成so庫的Android.mk文件：
LOCAL_PATH:= $(call my-dir)
# 一個完整模塊編譯
include $(CLEAR_VARS)
LOCAL_SRC_FILES:=com_lucyfyr_HelloWorld.c
LOCAL_C_INCLUDES := $(JNI_H_INCLUDE)
LOCAL_MODULE := libHelloWorldJni
LOCAL_SHARED_LIBRARIES := libutils
LOCAL_PRELINK_MODULE := false
LOCAL_MODULE_TAGS :=optional
include $(BUILD_SHARED_LIBRARY)
系統變數解析：
LOCAL_PATH - 編譯時的目錄
$(call 目錄，目錄….) 目錄引入操作符
如該目錄下有個文件夾名稱 src，則可以這樣寫 $(call src)，那麼就會得到 src 目錄的完整路徑
include $(CLEAR_VARS) -清除之前的一些系統變數
LOCAL_MODULE － 編譯生成的目標對象
LOCAL_SRC_FILES － 編譯的源文件
LOCAL_C_INCLUDES － 需要包含的頭文件目錄
LOCAL_SHARED_LIBRARIES － 鏈接時需要的外部庫
LOCAL_PRELINK_MODULE － 是否需要prelink處理
include$（BUILD_SHARED_LIBRARY） － 指明要編譯成動態庫
2. android下JNI C 調用JAVA，可能是路徑問題
JNI_CreateJavaVM 這個方法是不能直接在C中調用了。你看 jni.h 的頭文件：
#if 0 /* In practice, these are not exported by the NDK so don't declare them */
jint JNI_GetDefaultJavaVMInitArgs(void*);
jint JNI_CreateJavaVM(JavaVM**, JNIEnv**, void*);
jint JNI_GetCreatedJavaVMs(JavaVM**, jsize, jsize*);
#endif
這三個方法都是禁止調用的 ( if 0 )
3. Android NDK Jni 開發C和C++的區別
Android NDK Jni 開發C和C++的區別
JNI是Java Native Interface的縮寫，中文為JAVA本地調用。從Java1.1開始，Java Native Interface(JNI)標准成為java平台的一部分，它允許Java代碼和其他語言寫的代碼進行交互。JNI一開始是為了本地已編譯語言，尤其是C和C++而設計的，但是它並不妨礙你使用其他語言，只要調用約定受支持就可以了。使用java與本地已編譯的代碼交互，通常會喪失平台可移植性。但是，有些情況下這樣做是可以接受的，甚至是必須的，比如，使用一些舊的庫，與硬體、操作系統進行交互，或者為了提高程序的性能。JNI標准至少保證本地代碼能工作在任何Java 虛擬機實現下。 標準的java類庫可能不支持你的程序所需的特性。 JNI·或許你已經有了一個用其他語言寫成的庫或程序，而你希望在java程序中使用它。你可能需要用底層語言實現一個小型的時間敏感代碼，比如匯編，然後在你的java程序中調用這些功能。 NDK是Google公司推出的幫助Android開發者通過C/C++本地語言編寫應用的開發包，包含了C/C++的頭文件、庫文件、說明文檔和示例代碼，我們可以理解為Windows Platform SDK一樣，是純C/C++編寫的，但是Android並不支持純C/C++編寫的應用，同時NDK提供的庫和函數功能很有限，僅僅處理些演算法效率敏感的問題，所以推薦初學者學好Java後再學習JNI。 NDK集成了交叉編譯器，並提供了相應的mk文件隔離CPU、平台、ABI等差異，開發人員只需要簡單修改mk文件(指出「哪些文件需要編譯」、「編譯特性要求」等)，就可以創建出so。 NDK可以自動地將so和Java應用一起打包，極大地減輕了開發人員的打包工作。
4. android 為什麼要使用jni
android的jni可以使用c/c++來開發，相比java而言，運行的效率提高了很多，特別是在做一些圖像演算法，或者游戲邏輯的時候，使用jni將大大的提高效率。比如某個游戲要採用opengl，同樣載入一個由1000個多邊形組成的3d模型，jni要比java運算快好幾倍，這樣就保證了游戲運行的fps不會太低。
另外一個好處就是內存管理上面，java的內存管理全部由虛擬機來管理，C++由程序員來管理，利用率上面就好多了。
等等其他優點。
既然這么多的優點，為什麼一個android程序不採用純c來開發呢？因為是android的 UI framework採用java，所以，在UI上面還是採用java來開發。
5. 如何在Android下使用JNI
關於如何在Android使用JNI調用C/C++代碼庫，網上已經有很多優秀的文章了，這里說一個大概過程吧：
首先需要懂C，其次要明白JNI的開發流程，然後還要知道NDK如何使用
1、在java代碼中聲明了一個native本地方法
Public native String helloFromc();
2、在項目目錄中創建JNI文件夾
3、在JNI文件夾裡面創建C文件，按照規范寫代碼
Jstring
Java_com_cheng_jnitest_MainActivity_helloFromc(JNIEnv* env,jobject obj)
4、用ndk-build指令編譯
編譯前需要配置Android.mk文件
//指定編譯的文件夾，指定當前的目錄
LOCAL_PATH := $(call my-dir)
//編譯器在編譯的時候會產生很多臨時變數，中間變數最好在編譯前清空所有的臨時變數
include $(CLEAR_VARS)
//編譯完成後的模塊名
LOCAL_MOUDLE := hello
//編譯的源文件
LOCAL_SRC_FILES:=hello.c
//編譯一個動態庫
//動態庫.so 只包含運行的函數，不包含依賴，所以體積小，運行的時候回去系統尋找依賴
//靜態庫.a 包含所有的函數和運行的依賴，所以體積大，包含所有的api
include $(BUILD_SHARED_LIBRARY)
5、生成了一個so動態庫，放到了libs裡面
6、項目中引入依賴庫
Static{
System.loadLibrary("hello");
}
-
6. Android NDK Jni 開發C和C++的區別
JNI是Java Native Interface的縮寫，中文為JAVA本地調用。從Java1.1開始，Java Native Interface(JNI)標准成為java平台的一部分，它允許Java代碼和其他語言寫的代碼進行交互。JNI一開始是為了本地已編譯語言，尤其是C和C++而設計的，但是它並不妨礙你使用其他語言，只要調用約定受支持就可以了。使用java與本地已編譯的代碼交互，通常會喪失平台可移植性。但是，有些情況下這樣做是可以接受的，甚至是必須的，比如，使用一些舊的庫，與硬體、操作系統進行交互，或者為了提高程序的性能。JNI標准至少保證本地代碼能工作在任何Java 虛擬機實現下。 標準的java類庫可能不支持你的程序所需的特性。 JNI·或許你已經有了一個用其他語言寫成的庫或程序，而你希望在java程序中使用它。你可能需要用底層語言實現一個小型的時間敏感代碼，比如匯編，然後在你的java程序中調用這些功能。 NDK是Google公司推出的幫助Android開發者通過C/C++本地語言編寫應用的開發包，包含了C/C++的頭文件、庫文件、說明文檔和示例代碼，我們可以理解為Windows Platform SDK一樣，是純C/C++編寫的，但是Android並不支持純C/C++編寫的應用，同時NDK提供的庫和函數功能很有限，僅僅處理些演算法效率敏感的問題，所以推薦初學者學好Java後再學習JNI。 NDK集成了交叉編譯器，並提供了相應的mk文件隔離CPU、平台、ABI等差異，開發人員只需要簡單修改mk文件(指出「哪些文件需要編譯」、「編譯特性要求」等)，就可以創建出so。 NDK可以自動地將so和Java應用一起打包，極大地減輕了開發人員的打包工作。
7. 如何在android的jni線程中實現回調
jni回調是指在c/c++代碼中調用java函數，當在c/c++的線程中執行回調函數時，會導致回調失敗。
其中一種在Android系統的解決方案是：
把c/c++中所有線程的創建，由pthread_create函數替換為由Java層的創建線程的函數AndroidRuntime::createJavaThread。
假設有c++函數:
[cpp] view plain
void *thread_entry(void *args)
{
while(1)
{
printf("thread running...\n");
sleep(1);
}
}
void init()
{
pthread_t thread;
pthread_create(&thread,NULL,thread_entry,(void *)NULL);
}
init()函數創建一個線程，需要在該線程中調用java類Test的回調函數Receive:
[cpp] view plain
public void Receive(char buffer[],int length){
String msg = new String(buffer);
msg = "received from jni callback:" + msg;
Log.d("Test", msg);
}
首先在c++中定義回調函數指針：
[cpp] view plain
//test.h
#include <pthread.h>
//function type for receiving data from native
typedef void (*ReceiveCallback)(unsigned char *buf, int len);
/** Callback for creating a thread that can call into the Java framework code.
* This must be used to create any threads that report events up to the framework.
*/
typedef pthread_t (* CreateThreadCallback)(const char* name, void (*start)(void *), void* arg);
typedef struct{
ReceiveCallback recv_cb;
CreateThreadCallback create_thread_cb;
}Callback;
再修改c++中的init和thread_entry函數：
[cpp] view plain
//test.c
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <sys/wait.h>
#include <unistd.h>
#include "test.h"
void *thread_entry(void *args)
{
char *str = "i'm happy now";
Callback cb = NULL;
int len;
if(args != NULL){
cb = (Callback *)args;
}
len = strlen(str);
while(1)
{
printf("thread running...\n");
//invoke callback method to java
if(cb != NULL && cb->recv_cb != NULL){
cb->recv_cb((unsigned char*)str, len);
}
sleep(1);
}
}
void init(Callback *cb)
{
pthread_t thread;
//pthread_create(&thread,NULL,thread_entry,(void *)NULL);
if(cb != NULL && cb->create_thread_cb != NULL)
{
cb->create_thread_cb("thread",thread_entry,(void *)cb);
}
}
然後在jni中實現回調函數，以及其他實現：
[cpp] view plain
//jni_test.c
#include <stdlib.h>
#include <malloc.h>
#include <jni.h>
#include <JNIHelp.h>
#include "android_runtime/AndroidRuntime.h"
#include "test.h"
#define RADIO_PROVIDER_CLASS_NAME "com/tonny/Test"
using namespace android;
static jobject mCallbacksObj = NULL;
static jmethodID method_receive;
static void (JNIEnv* env, const char* methodName) {
if (env->ExceptionCheck()) {
LOGE("An exception was thrown by callback '%s'.", methodName);
LOGE_EX(env);
env->ExceptionClear();
}
}
static void receive_callback(unsigned char *buf, int len)
{
int i;
JNIEnv* env = AndroidRuntime::getJNIEnv();
jcharArray array = env->NewCharArray(len);
jchar *pArray ;
if(array == NULL){
LOGE("receive_callback: NewCharArray error.");
return;
}
pArray = (jchar*)calloc(len, sizeof(jchar));
if(pArray == NULL){
LOGE("receive_callback: calloc error.");
return;
}
// buffer to jchar array
for(i = 0; i < len; i++)
{
*(pArray + i) = *(buf + i);
}
// buffer to jcharArray
env->SetCharArrayRegion(array,0,len,pArray);
//invoke java callback method
env->CallVoidMethod(mCallbacksObj, method_receive,array,len);
//release resource
env->DeleteLocalRef(array);
free(pArray);
pArray = NULL;
(env, __FUNCTION__);
}
static pthread_t create_thread_callback(const char* name, void (*start)(void *), void* arg)
{
return (pthread_t)AndroidRuntime::createJavaThread(name, start, arg);
}
static Callback mCallbacks = {
receive_callback,
create_thread_callback
};
static void jni_class_init_native
(JNIEnv* env, jclass clazz)
{
method_receive = env->GetMethodID(clazz, "Receive", "([CI)V");
}
static int jni_init
(JNIEnv *env, jobject obj)
{
if (!mCallbacksObj)
mCallbacksObj = env->NewGlobalRef(obj);
return init(&mCallbacks);
}
static const JNINativeMethod gMethods[] = {
{ "class_init_native", "()V", (void *)jni_class_init_native },
{ "native_init", "()I", (void *)jni_init },
};
static int registerMethods(JNIEnv* env) {
const char* const kClassName = RADIO_PROVIDER_CLASS_NAME;
jclass clazz;
/* look up the class */
clazz = env->FindClass(kClassName);
if (clazz == NULL) {
LOGE("Can't find class %s/n", kClassName);
return -1;
}
/* register all the methods */
if (env->RegisterNatives(clazz,gMethods,sizeof(gMethods)/sizeof(gMethods[0])) != JNI_OK)
{
LOGE("Failed registering methods for %s/n", kClassName);
return -1;
}
/* fill out the rest of the ID cache */
return 0;
}
jint JNI_OnLoad(JavaVM* vm, void* reserved) {
JNIEnv* env = NULL;
jint result = -1;
LOGI("Radio JNI_OnLoad");
if (vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) {
LOGE("ERROR: GetEnv failed/n");
goto fail;
}
if(env == NULL){
goto fail;
}
if (registerMethods(env) != 0) {
LOGE("ERROR: PlatformLibrary native registration failed/n");
goto fail;
}
/* success -- return valid version number */
result = JNI_VERSION_1_4;
fail:
return result;
}
jni的Android.mk文件中共享庫設置為：
[cpp] view plain
LOCAL_SHARED_LIBRARIES := liblog libcutils libandroid_runtime libnativehelper
最後再實現Java中的Test類：
[java] view plain
//com.tonny.Test.java
public class Test {
static{
try {
System.loadLibrary("test");
class_init_native();
} catch(UnsatisfiedLinkError ule){
System.err.println("WARNING: Could not load library libtest.so!");
}
}
public int initialize() {
return native_radio_init();
}
public void Receive(char buffer[],int length){
String msg = new String(buffer);
msg = "received from jni callback" + msg;
Log.d("Test", msg);
}
protected static native void class_init_native();
protected native int native_init();
}
8. android java 和 jni 調用代碼的區別
關於Android studio中使用NDK/JNI環境和入門：
1. C代碼回調Java方法的流程
(1) 找到java對應的Class
創建一個char*數組, 然後使用jni.h中提供的FindClass方法獲取jclass返回值;
[cpp] view plain print?
char* classname = "wjy/geridge/com/testndk/jni/JniUtils";
jclass dpclazz = (*env)->FindClass(env, classname);
(2) 找到要調用的方法的methodID
使用jni.h中提供的GetMethodID方法, 獲取jmethodID, 傳入參數 ①JNIEnv指針 ②Class對象 ③ 方法名 ④方法簽名, 在這里方法名和方法簽名確定一個方法, 方法簽名就是方法的返回值 與 參數的唯一標示;
9. 如何在Android下使用JNI
我們知道，Android系統的底層庫由c/c++編寫，上層Android應用程序通過Java虛擬機調用底層介面，銜接底層c/c++庫與Java應用程序間的介面正是JNI（JavaNative Interface)。本文描述了如何在ubuntu下配置AndroidJNI的開發環境，以及如何編寫一個簡單的c函數庫和JNI介面，並通過編寫Java程序調用這些介面，最終運行在模擬器上的過程。
2.環境配置
2.1.安裝jdk1.6
（1）從jdk官方網站下載jdk-6u29-linux-i586.bin文件。
（2）執行jdk安裝文件
[html] view plainprint?
01.$chmod a+x jdk-6u29-linux-i586.bin
02.$jdk-6u29-linux-i586.bin
$chmod a+x jdk-6u29-linux-i586.bin
$jdk-6u29-linux-i586.bin
(3)配置jdk環境變數
[html] view plainprint?
01.$sudo vim /etc/profile
02.#JAVAEVIRENMENT
03.exportJAVA_HOME=/usr/lib/java/jdk1.6.0_29
04.exportJRE_HOME=$JAVA_HOME/jre
05.exportCLASSPATH=$JAVA_HOME/lib:$JRE_HOME/lib:$CLASSPATH
06.exportPATH=$JAVA_HOME/bin:$JRE_HOME/bin:$PATH
$sudo vim /etc/profile
#JAVAEVIRENMENT
exportJAVA_HOME=/usr/lib/java/jdk1.6.0_29
exportJRE_HOME=$JAVA_HOME/jre
exportCLASSPATH=$JAVA_HOME/lib:$JRE_HOME/lib:$CLASSPATH
exportPATH=$JAVA_HOME/bin:$JRE_HOME/bin:$PATH
保存後退出編輯，並重啟系統。
（4）驗證安裝
[html] view plainprint?
01.$java -version
02.javaversion "1.6.0_29"
03.Java(TM)SE Runtime Environment (build 1.6.0_29-b11)
04.JavaHotSpot(TM) Server VM (build 20.4-b02, mixed mode)
05.$javah
06.用法：javah[選項]<類>
07.其中[選項]包括：
08.-help輸出此幫助消息並退出
09.-classpath<路徑>用於裝入類的路徑
10.-bootclasspath<路徑>用於裝入引導類的路徑
11.-d<目錄>輸出目錄
12.-o<文件>輸出文件（只能使用-d或-o中的一個）
13.-jni生成JNI樣式的頭文件（默認）
14.-version輸出版本信息
15.-verbose啟用詳細輸出
16.-force始終寫入輸出文件
17.使用全限定名稱指定<類>（例
18.如，java.lang.Object）。
$java -version
javaversion "1.6.0_29"
Java(TM)SE Runtime Environment (build 1.6.0_29-b11)
JavaHotSpot(TM) Server VM (build 20.4-b02, mixed mode)
$javah
用法：javah[選項]<類>
其中[選項]包括：
-help輸出此幫助消息並退出
-classpath<路徑>用於裝入類的路徑
-bootclasspath<路徑>用於裝入引導類的路徑
-d<目錄>輸出目錄
-o<文件>輸出文件（只能使用-d或-o中的一個）
-jni生成JNI樣式的頭文件（默認）
-version輸出版本信息
-verbose啟用詳細輸出
-force始終寫入輸出文件
使用全限定名稱指定<類>（例
如，java.lang.Object）。2.2.安裝android應用程序開發環境
ubuntu下安裝android應用程序開發環境與windows類似，依次安裝好以下軟體即可：
（1）Eclipse
（2）ADT
（3）AndroidSDK
與windows下安裝唯一不同的一點是，下載這些軟體的時候要下載Linux版本的安裝包。
安裝好以上android應用程序的開發環境後，還可以選擇是否需要配置emulator和adb工具的環境變數，以方便在進行JNI開發的時候使用。配置步驟如下：
把emulator所在目錄android-sdk-linux/tools以及adb所在目錄android-sdk-linux/platform-tools添加到環境變數中，android-sdk-linux指androidsdk安裝包android-sdk_rxx-linux的解壓目錄。
[plain] view plainprint?
01.$sudo vim /etc/profile
02.exportPATH=~/software/android/android-sdk-linux/tools:$PATH
03. exportPATH=~/software/android/android-sdk-linux/platform-tools:$PATH
$sudo vim /etc/profile
exportPATH=~/software/android/android-sdk-linux/tools:$PATH
exportPATH=~/software/android/android-sdk-linux/platform-tools:$PATH
編輯完畢後退出，並重啟生效。
2.3.安裝NDK
NDK是由android提供的編譯android本地代碼的一個工具。
（1）從androidndk官網下載ndk，目前最新版本為android-ndk-r6b-linux-x86.tar.bz2.
（2）解壓ndk到工作目錄：
[plain] view plainprint?
01.$tar -xvf android-ndk-r6b-linux-x86.tar.bz2
02.$sudo mv android-ndk-r6b /usr/local/ndk
$tar -xvf android-ndk-r6b-linux-x86.tar.bz2
$sudo mv android-ndk-r6b /usr/local/ndk
（3）設置ndk環境變數
[plain] view plainprint?
01.$sudo vim /etc/profile
02.exportPATH=/usr/local/ndk:$PATH
$sudo vim /etc/profile
exportPATH=/usr/local/ndk:$PATH
編輯完畢後保存退出，並重啟生效
（4）驗證安裝
[plain] view plainprint?
01.$ cd/usr/local/ndk/samples/hello-jni/
02.$ ndk-build
03.Gdbserver : [arm-linux-androideabi-4.4.3] libs/armeabi/gdbserver
04.Gdbsetup : libs/armeabi/gdb.setup
05.Install : libhello-jni.so => libs/armeabi/libhello-jni.so
$ cd/usr/local/ndk/samples/hello-jni/
$ ndk-build
Gdbserver : [arm-linux-androideabi-4.4.3] libs/armeabi/gdbserver
Gdbsetup : libs/armeabi/gdb.setup
Install : libhello-jni.so => libs/armeabi/libhello-jni.so
3.JNI實現
我們需要定義一個符合JNI介面規范的c/c++介面，這個介面不用太復雜，例如輸出一個字元串。接下來，則需要把c/c++介面的代碼文件編譯成共享庫（動態庫）.so文件，並放到模擬器的相關目錄下。最後，啟動Java應用程序，就可以看到最終效果了。
3.1.編寫Java應用程序代碼
（1）啟動Eclipse，新建android工程
Project：JNITest
Package：org.tonny.jni
Activity：JNITest
（2）編輯資源文件
編輯res/values/strings.xml文件如下：
[html] view plainprint?
01.<?xmlversionxmlversion="1.0"encoding="utf-8"?>
02.<resources>
03.<stringnamestringname="hello">HelloWorld, JNITestActivity!</string>
04.<stringnamestringname="app_name">JNITest</string>
05.<stringnamestringname="btn_show">Show</string>
06.</resources>
<?xmlversion="1.0"encoding="utf-8"?>
<resources>
<stringname="hello">HelloWorld, JNITestActivity!</string>
<stringname="app_name">JNITest</string>
<stringname="btn_show">Show</string>
</resources>
編輯res/layout/main.xml文件如下：
[html] view plainprint?
01.<?xmlversionxmlversion="1.0"encoding="utf-8"?>
02.<LinearLayoutxmlns:androidLinearLayoutxmlns:android="http://schemas.android.com/apk/res/android"
03.android:layout_width="fill_parent"
04.android:layout_height="fill_parent"
05.android:orientation="vertical">
06.<TextView
07.android:layout_width="fill_parent"
08.android:layout_height="wrap_content"
09.android:text="@string/hello"/>
10.<EditText
11.android:id="@+id/ed_name"
12.android:layout_width="match_parent"
13.android:layout_height="wrap_content"
14.android:layout_gravity="center_horizontal"
15.android:layout_marginLeft="5dp"
16.android:layout_marginRight="5dp"/>
17.<Button
18.android:id="@+id/btn_show"
19.android:layout_width="109dp"
20.android:layout_height="wrap_content"
21.android:layout_gravity="center_horizontal"
22.android:text="@string/btn_show"/>
23.</LinearLayout>
<?xmlversion="1.0"encoding="utf-8"?>
<LinearLayoutxmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="vertical">
<TextView
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="@string/hello"/>
<EditText
android:id="@+id/ed_name"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_gravity="center_horizontal"
android:layout_marginLeft="5dp"
android:layout_marginRight="5dp"/>
<Button
android:id="@+id/btn_show"
android:layout_width="109dp"
android:layout_height="wrap_content"
android:layout_gravity="center_horizontal"
android:text="@string/btn_show"/>
</LinearLayout>
我們在主界面上添加了一個EditText控制項和一個Button控制項。
（3）編輯JNITest.java文件
[java] view plainprint?
01.packageorg.tonny.jni;
02.
03.importandroid.app.Activity;
04.importandroid.os.Bundle;
05.importandroid.view.View;
06.importandroid.widget.EditText;
07.importandroid.widget.Button;
08.
09.
10. {
11.static{
12.System.loadLibrary("JNITest");
13.}
14.privatenativeString GetReply();
15.privateEditTextedtName;
16.privateButtonbtnShow;
17.Stringreply;
18./**Called when the activity is first created. */
19.@Override
20.publicvoidonCreate(Bundle savedInstanceState) {
21.super.onCreate(savedInstanceState);
22.setContentView(R.layout.main);
23.reply= GetReply();
24.edtName= (EditText)this.findViewById(R.id.ed_name);
25.btnShow= (Button)this.findViewById(R.id.btn_show);
26.btnShow.setOnClickListener(newButton.OnClickListener() {
27.publicvoidonClick(View arg0) {
28.edtName.setText(reply);
29.}
30.});
31.}
32.}
packageorg.tonny.jni;
importandroid.app.Activity;
importandroid.os.Bundle;
importandroid.view.View;
importandroid.widget.EditText;
importandroid.widget.Button;
{
static{
System.loadLibrary("JNITest");
}
privatenativeString GetReply();
privateEditTextedtName;
privateButtonbtnShow;
Stringreply;
/**Called when the activity is first created. */
@Override
publicvoidonCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
reply= GetReply();
edtName= (EditText)this.findViewById(R.id.ed_name);
btnShow= (Button)this.findViewById(R.id.btn_show);
btnShow.setOnClickListener(newButton.OnClickListener() {
publicvoidonClick(View arg0) {
edtName.setText(reply);
}
});
}
}
我們看這一段代碼：
[java] view plainprint?
01.static{
02.System.loadLibrary("JNITest");
03.}
static{
System.loadLibrary("JNITest");
}
static表示在系統第一次載入類的時候，先執行這一段代碼，在這里表示載入動態庫libJNITest.so文件。
再看這一段：
[java] view plainprint?
01.privatenativeString GetReply();
privatenativeString GetReply();
native表示這個方法由本地代碼定義，需要通過jni介面調用本地c/c++代碼。
[java] view plainprint?
01.publicvoidonClick(View arg0) {
02.edtName.setText(reply);
03.}
publicvoidonClick(View arg0) {
edtName.setText(reply);
}
這段代碼表示點擊按鈕後，把native方法的返回的字元串顯示到EditText控制項。
（4）編譯工程，生成.class文件。
10. 如何用jni開發android應用
JNI是Java NativeInterface的縮寫，中文為JAVA本地調用。從Java1.1開始，Java Native Interface(JNI)標准成為java平台的一部分，它允許Java代碼和其他語言寫的代碼進行交互。
JNI的作用是讓你在利用強大android平台的同時，使你仍然可以用其他語言例如C和C++等寫程序。 作為JavaVM的一部分，JNI是一套雙向的介面，允許Java與本地代碼間的互相操作。
JNI在交互中的角色
1.JNI編程的一般步驟
l 創建一個類(HelloWorld.java)
HelloWorld.java
class HelloWorld{
private native void print();
public static void main(String[] args) {
newHelloWorld().print();
}
static {
System.loadLibrary("HelloWorld");
}
}
HelloWrold類首先聲明了一個private nativeprint方法. static那幾行是本地庫。在Java代碼中聲明本地方法必須有"native"標識符，native修飾的方法，在Java代碼中只作為聲明存在。在 調用本地方法前，必須首先裝載含有該方法的本地庫. 如HelloWorld.java中所示，置於static塊中，在Java VM初始化一個類時，首先執行這部分代碼，這可保證調用本地方法前，裝載了本地庫。
l 編譯該類生成class文件
用eclipse自動編譯成class文件或用命令行javac HelloWorld.java來編譯
l 利用javah -jni產生頭文件
javah -jniHelloWorld
"-jni"為默認參數，可有可無。上述命令會生成HelloWorld.h文件。
l 用本地代碼實現頭文件中定義的方法
必須根據javah生成的本地函數聲明實現函數，如下：
#include
#include
#include"HelloWorld.h"
JNIEXPORTvoid JNICALL
Java_HelloWorld_print(JNIEnv*env, jobject obj)
{
printf("Hello World!\n");
return;
}
"jni.h"文件必須被包含，該文件定義了JNI所有的函數聲明和數據類型。HelloWorld.h是上一步我們用javah生成的頭文件
l 運行
最後用NDK編譯你的本地代碼並生成動態鏈接庫.so文件。請注意，生成的本地庫的名字，必須與System.loadLibrary("HelloWorld")；待裝載庫的名字相同。
然後在eclipse當中重新編譯一遍android程 序。這里注意，你每一個改動本地代碼並重新生成庫都要手動的編譯一遍android程序或修改eclipse的java代碼使其自動重新生成程序，因為你 只修改本地代碼eclipse會認為你的程序沒有任何修改是不會自動編譯的。