androidjni回调
Ⅰ 如何在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(); }
Ⅱ Opencv4Android NDK，JNI调用C++函数，对象类型参数转换问题
Mat传地址过去
java中：
Mat src = new Mat();
Utils.bitmapToMat(bmp, src);
long addrMat = src.getNativeObjAddr();
在C++中：
Mat& finger_src = *(Mat *)addrMat;
至于Point2f 数组可拆为X坐标和Y坐标数组
Point2f mask[15], float width[15]直接传 jfloatArray width, jfloatArray maskX, jfloatArray maskY
获取
jfloat *arr, *mx, *my;
arr = env->GetFloatArrayElements(width,JNI_FALSE);
mx = env->GetFloatArrayElements(maskX,JNI_FALSE);
my = env->GetFloatArrayElements(maskY,JNI_FALSE);
/******** 转为C++类型 进行处理 **********/
Point2f mask[16]; //坐标
float fingerWidth[15]; //宽度
for(int i=0;i<15;i++){
mask[i].x = mx[i];
mask[i].y = my[i];
fingerWidth[i] = arr[i];
}
/************************** 结果返回java ************************************/
for(int i=0;i<15;i++){
mx[i] = mask[i].x;
my[i] = mask[i].y;
arr[i] = fingerWidth[i];
}
Ⅲ android中，请简述jni的调用过程
1)安装和下载Cygwin，下载 Android NDK
2)在ndk项目中JNI接口的设计
3)使用C/C++实现本地方法
4)JNI生成动态链接库.so文件
5)将动态链接库复制到java工程，在java工程中调用，运行java工程即可
Ⅳ 如何在android的jni线程中实现回调
您好，很高兴能帮助您如果是C/C++回调,你只要参考linux的线程指南，在线程函数中传入回调函数地址就行了。如果是要回调到Java层，稍微复杂点。首先，你需要在onload的时候，找到回调函数所在的类，用全局变量保存：JNIEXPORTjintJNICALLJNI_OnLoad(JavaVM*vm,void*reserved){LOGE("JNI_OnLoadstart");jintversion;g_vm=vm;//全局变量保存JNIEnv*env;jobjectcls;version=vm->GetEnv((void**)&env,JNI_VERSION_1_2);if(env){g_clazz=env->FindClass(CLASS_CustomSurfaceView);//全局变量保存}LOGE("JNI_OnLoadfinishg_clazz=0x%x",g_clazz);returnJNI_VERSION_1_2;}在JNI启动线程的时候，需要把线程挂到JVM上，不然不能访问Java。你有了g_vm,g_clazz,以及env，就可以做回调操作了。//线程函数void*threadFunc(void*data){JNIEnv*env=MNull;intret=g_vm->AttachCurrentThread((JNIEnv**)&env,MNull);//挂到JVMif(retDetachCurrentThread();//从JVM卸载return;}你的采纳是我前进的动力，记得好评和采纳，答题不易，互相帮助，
Ⅳ android studio怎么调用jni
（1）老版本，方法如下： task NativeLibs(type: Copy) { from(new File(project(':MyProject').buildDir, 'native-libs')) { include '**/*.so' } into new File(buildDir, 'native-libs') } tasks.withType(Compile) { compileTask -> compileTask.dependsOn NativeLibs } clean.dependsOn 'cleanCopyNativeLibs' tasks.withType(com.android.build.gradle.PackageApplicationTask) { pkgTask -> pkgTask.jniDir new File(buildDir, 'native-libs') } （2）新版本三种方法： （2.1）打包前先生成.Jar文件后自动解包到apk文件 task nativeLibsToJar(type: Zip, description: 'create a jar archive of the native libs') { destinationDir file("$buildDir/native-libs") baseName 'native-libs' extension 'jar' from fileTree(dir: 'libs', include: '**/*.so') into 'lib/' } tasks.withType(Compile) { compileTask -> compileTask.dependsOn(nativeLibsToJar) } 下面一句话就是打包生成目录(build\native-libs)中的.jar文件 compile fileTree(dir: "$buildDir/native-libs", include: 'native-libs.jar') （2.2）手动生成.Jar文件后自动解包到apk文件 这个方式需要自己手动进行.SO文件压缩，具体步骤为：将所有需要使用的.so文件压缩为.zip文件（zip中的文件目录结构为： lib/armeabi/*.so）然后把zip文件后缀改为.Jar然后放到libs生成apk就ok 默认就是自动打包所有.Jar文件： dependencies { compile fileTree(dir: 'libs', include: '*.jar') } （2.3）这也就是现在正在使用的方式（推荐） ，其实无非就是把.SO文件打包到APK的lib文件夹中，假如仔细阅读了Gradle的使用方法，自然就知道其实Gradle官方在新版已经自动实现了打包.SO文件的.很简单级就是在配置的android节点下加入下面的内容就ok： sourceSets { main { jniLibs.srcDirs = ['libs'] } } 其他地方无需修改，整个项目的配置文件如下： apply plugin: 'android' android { compileSdkVersion 19 buildToolsVersion "19.0.0" defaultConfig { minSdkVersion 16 targetSdkVersion 19 versionCode 1 versionName "1.0" } buildTypes { release { runProguard false proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.txt' } } sourceSets { main { jniLibs.srcDirs = ['libs'] } } } dependencies { compile fileTree(dir: 'libs', include: ['*.jar']) }
Ⅵ android 怎么调用jni里面的方法
调用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文件：
Ⅶ 如何在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();
}
Ⅷ android jni程序（c++）如何编译适用于arm-v8指令集的32位程序
可以看到Android上层的Application和ApplicationFramework都是使用Java编写，
底层包括系统和使用众多的LIiraries都是C/C++编写的。
所以上层Java要调用底层的C/C++函数库必须通过Java的JNI来实现。
下面将学习Android是如何通过Jni来实现Java对C/C++函数的调用。以HelloWorld程序为例：
第一步：
使用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环境。
http://www.cnblogs.com/bastard/archive/2012/05/19/2508913.html
Ⅸ 如何在Android下使用JNI
1.引言
我们知道，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官网http://developer.android.com/sdk/ndk/index.html下载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文件如下：编辑res/layout/main.xml文件
我们在主界面上添加了一个EditText控件和一个Button控件。
（3）编辑JNITest.java文件
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文件。
3.2.用javah工具生成符合JNI规范的c语言头文件
在终端中，进入android工程所在的bin目录
[plain] view plainprint?
01.$cd ~/project/Android/JNITest/bin
$cd ~/project/Android/JNITest/bin
我们用ls命令查看，可以看到bin目录下有个classes目录，其目录结构为classes/org/tonny/jni，即classes的子目录结构是android工程的包名org.tonny.jni。请注意，下面我们准备执行javah命令的时候，必须进入到org/tonny/jni的上级目录，即classes目录，否则javah会提示找不到相关的java类。
下面继续：
[plain] view plainprint?
01.$cd classes
02.$javah org.tonny.jni.JNITest
03.$ls
04.org org_tonny_jni_JNITest.h
$cd classes
$javah org.tonny.jni.JNITest
$ls
org org_tonny_jni_JNITest.h
执行javahorg.tonny.jni.JNITest命令，在classes目录下会生成org_tonny_jni_JNITest.h头文件。如果不进入到classes目录下的话，也可以这样：
[plain] view plainprint?
01.$javah -classpath ~/project/Android/JNITest/bin/classesorg.tonny.jni.JNITest
$javah -classpath ~/project/Android/JNITest/bin/classesorg.tonny.jni.JNITest
-classpath 参数表示装载类的目录。
3.3.编写c/c++代码
生成org_tonny_jni_JNITest.h头文件后，我们就可以编写相应的函数代码了。下面在android工程目录下新建jni目录，即~/project/Android/JNITest/jni，把org_tonny_jni_JNITest.h头文件拷贝到jni目录下，并在jni目录下新建org_tonny_jni_JNITest.c文件，编辑代码如下：
[cpp] view plainprint?
01.#include<jni.h>
02.#include<string.h>
03.#include"org_tonny_jni_JNITest.h"
04.
05.
06.JNIEXPORTjstring JNICALLJava_org_tonny_jni_JNITest_GetReply
07.(JNIEnv *env, jobject obj){
08.return(*env)->NewStringUTF(env,(char*)"Hello,JNITest");
09.}
#include<jni.h>
#include<string.h>
#include"org_tonny_jni_JNITest.h"
JNIEXPORTjstring JNICALLJava_org_tonny_jni_JNITest_GetReply
(JNIEnv *env, jobject obj){
return(*env)->NewStringUTF(env,(char*)"Hello,JNITest");
}
我们可以看到，该函数的实现相当简单，返回一个字符串为："Hello,JNITest"
3.4.编写Android.mk文件
在~/project/Android/JNITest/jni目录下新建Android.mk文件，android可以根据这个文件的编译参数编译模块。编辑Android.mk文件如下：
[plain] view plainprint?
01.LOCAL_PATH:= $(call my-dir)
02.include$(CLEAR_VARS)
03.LOCAL_MODULE := libJNITest
04.LOCAL_SRC_FILES:= org_tonny_jni_JNITest.c
05.include$(BUILD_SHARED_LIBRARY)
LOCAL_PATH:= $(call my-dir)
include$(CLEAR_VARS)
LOCAL_MODULE := libJNITest
LOCAL_SRC_FILES:= org_tonny_jni_JNITest.c
include$(BUILD_SHARED_LIBRARY)
LOCAL_MODULE表示编译的动态库名称
LOCAL_SRC_FILES 表示源代码文件
3.5.用ndk工具编译并生成.so文件
进入到JNITest的工程目录，执行ndk-build命令即可生成libJNITest.so文件。
[plain] view plainprint?
01.$cd ~/project/Android/JNITest/
02.$ndk-build
03.Invalidattribute name:
04.package
05.Install : libJNITest.so => libs/armeabi/libJNITest.so
$cd ~/project/Android/JNITest/
$ndk-build
Invalidattribute name:
package
Install : libJNITest.so => libs/armeabi/libJNITest.so
可以看到，在工程目录的libs/armeabi目录下生成了libJNITest.so文件。
3.6.在模拟器上运行
（1）首先，我们把android模拟器启动起来。进入到emulator所在目录，执行emulator命令：
[plain] view plainprint?
01.$cd ~/software/android/android-sdk-linux/tools
02.$./emulator @AVD-2.3.3-V10 -partition-size 512
$cd ~/software/android/android-sdk-linux/tools
$./emulator @AVD-2.3.3-V10 -partition-size 512
AVD-2.3.3-V10表示你的模拟器名称，与在Eclipse->AVDManager下的AVDName对应，-partition-size表示模拟器的存储设备容量。
（2）接下来，我们需要把libJNITest.so文件拷贝到模拟器的/system/lib目录下，执行以下命令：
[plain] view plainprint?
01.$cd ~/project/Android/JNITest/libs/armeabi/
02.$adb remount
03.$adb push libJNITest.so /system/lib
04.80 KB/s (10084 bytes in 0.121s)
$cd ~/project/Android/JNITest/libs/armeabi/
$adb remount
$adb push libJNITest.so /system/lib
80 KB/s (10084 bytes in 0.121s)
当在终端上看到有80 KB/s (10084 bytes in 0.121s)传输速度等信息的时候，说明拷贝成功。
（3）在终端上执行JNITest程序，这个我们可以在Eclipse下，右键点击JNITest工程，RunAs->Android Application，即可在模拟器上启动程序