如何在android的jni线程中实现回调

JNI回调是指在c/c++代码中调用java函数，当在c/c++的线程中执行回调函数时，会导致回调失败。

其中一种在Android系统的解决方案是：

把c/c++中所有线程的创建，由pthread_create函数替换为由Java层的创建线程的函数AndroidRuntime::createJavaThread。

假设有c++函数:

[cpp] view
plaincopy

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
plaincopy

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
plaincopy

//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
plaincopy

//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
plaincopy

//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 checkAndClearExceptionFromCallback(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;

}



//copy buffer to jchar array

for(i = 0; i < len; i++)

{

*(pArray + i) = *(buf + i);

}

//copy 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;



checkAndClearExceptionFromCallback(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
plaincopy

LOCAL_SHARED_LIBRARIES := liblog libcutils libandroid_runtime libnativehelper

最后再实现Java中的Test类：

[java] view
plaincopy

//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();



}