android-jni与java参数传递

来源：互联网发布：哈佛大学知乎编辑：程序博客网时间：2024/05/21 10:05

http://blog.csdn.net/andyhuabing/article/details/7551230

android-jni与java参数传递

===================================================================================================
问题的来源：
jni与java层之间互传参数，有几个问题需要解决：
1、需要传递的参数的函数非常多，达到100个左右
2、传递的参数有些比较复杂，涉及到结构的嵌套
3、参数有输入参数与输出参数两种
举函数例子如下：
/*-- 授权信息 --*/
typedef struct {
   int m_dwProductID; /* 普通授权的节目ID */
   int m_tBeginDate; /* 授权的起始时间 */
   int m_tExpireDate; /* 授权的过期时间 */
   char m_bCanTape; /* 用户是否购买录像：1－可以录像；0－不可以录像 */
   char m_byReserved[3]; /* 保留 */
}CAEntitle;

结构嵌套结构，比较复杂
/*-- 授权信息集合 --*/
typedef struct {
   int m_wProductCount;
   char m_m_byReserved[2]; /* 保留 */
   CAEntitle m_Entitles[300]; /* 授权列表 */
}SCDCAEntitles;

前面两个是输入参数，后面两个是输出参数
extern boolean STBCA_SCPBRun( const char* pbyCommand,
int wCommandLen,
char* pbyReply,
int* pwReplyLen );

问题解决方案1：
常用方案，
A、C++调用传递参数给java层
   调用成员函数利用CallxxxMethodYYY(其中xxx表示返回数据类型，YYY表代码V/A)
   其参数可以直接利用函数传，也可采用GetFieldID&SetObjectField配对使用
   即如下方案：
struct CATestOffsets
{
jfieldID name;
jfieldID vendor;
jfieldID version;
jfieldID handle;
jfieldID m_tBeginDate;
jfieldID m_tExpireDate;
....

jmethodID STBCA_SCPBRunCallXX;
jmethodID ....
} gSensorOffsets;
  利用jfieldID和jmethodID表示java类的成员变量及成员函数。。。。工作量相当大，调试也很麻烦

B、JAVA调用C++代码
通过做法就是定义一堆的native函数，然后将参数传递一一定义传递下来
对于结构在java层定义类，在jni层进行转换，首先可能传递的参数很多，而且每个函数都要小心写，
对于需要既需要输入参数又需要输出参数的，很麻烦哟。。非常痛苦。

这种方案做了两天，实在受不了，太多native函数，大多jmethodID与jfieldID，而且同时输入及输出。

确认让人很头痛噻！

问题解决方案2：
重点就是利用C++层分配共享内存空间，函数参数非常简单，只需要返回值，所有参数传递利用共享内存搞定

这利方式对于参数的传递非常方便，只是需要注意地址及偏移值(addr:offset)，代码比较清晰。
但对于native函数及jmethodID与jfieldID的处理还是很麻烦呀！不对对于参数处理简化了很多了。

基本代码如下，我这里搞了个最复杂的传递结构参数举例：

Java 代码编写如下

[java] view plain copy print?

/**
* 按长度进行缓冲区分配空间
* @param length： buffer length
* @return start address
*/
public int AllocStructMem(int length){
if (length % 4 != 0) {
length -= (length % 4);
length += 4;
}
if ((address = native_alloc(length)) == 0)
throw new RuntimeException();
return address;
}
/**
* 释放缓冲区空间
* @param ptr：start address
*/
public void FreeStructMem(int ptr){
if(ptr == 0x00){
throw new NullPointerException("NULL pointer");
}
native_free(ptr);
}
public int DSSetInt(int ptr,int offset,int value) {
if(ptr == 0x00){
throw new NullPointerException("NULL pointer");
}
return native_setInt(ptr,offset,4,value);
}
public int DSSetBytes(int addr,int off,int len,byte[] b){
return native_setBytes(addr,off, len, b);
}
public void DSSetUTFString(int addr,int off, int len, String s) {
DSSetBytes(addr,off, len, s.getBytes());
}
public int DSGetInt(int addr,int off, int len) {
if(off < 0 || len <= 0 || addr == 0x00 )
throw new IllegalArgumentException();
return native_getInt(addr, off, len);
}
public int DSGetBytes(int addr,int off, int len, byte[] b) {
if (off < 0 || len <= 0 || addr == 0x00 ||b == null || b.length < len)
throw new IllegalArgumentException();
return native_getBytes(addr, off, len, b);
}
public String DSGetUTFString(int addr,int off, int len) {
if (off < 0 || len <= 0 )
throw new IllegalArgumentException();
byte[] b = new byte[len];
native_getBytes(addr, off, len, b);
return new String(b);
}
private static native int native_alloc(int length);
private static native void native_free(int ptr);
private static native int native_setInt(int addr, int offset, int len,
int value);
private static native int native_setBytes(int addr, int offset, int len,
byte[] b);
private static native int native_getInt(int addr, int offset, int len);
private static native int native_getBytes(int addr, int offset, int len,
byte[] b);

下面是测试代码：

[java] view plain copy print?

// C++ 定义结构
// struct mmm_t {
// int a;
// int b[4];
// struct {
// int c1, c2;
// } c;
// struct {
// int d1;
// char*d2;
// } d[2];
// float e;
// };
static class cc{
int c1;
int c2;
}
static class dd{
int d1;
byte[] d2 = new byte[64];
};
static class mmm_t{
int a;
int[] b = new int[4];
cc c[] = new cc[1];
dd d[] = new dd[2];
int e;
dd darr[] = new dd[10];
public void mmm_malloc(){
c[0] = new cc();
for(int i=0;i<2;i++){
d[i] = new dd();
}
for(int i=0; i < 10; i++){
darr[i] = new dd();
}
}
}
public int complexStructTest(){
mmm_t m = new mmm_t();
m.mmm_malloc();
Log.i(TAG,"complexStructTest is test.....");
/* 赋值 */
m.a = 10;
Log.i(TAG,"complexStructTest 000");
m.b[0] = 0x22352352;
m.b[1] = 0x31212362;
m.b[2] = 0x31343521;
m.b[3] = 0x33299552;
Log.i(TAG,"complexStructTest 111");
m.c[0].c1 = 0x2352539;
Log.i(TAG,"complexStructTest 222");
m.c[0].c2 = 0x9235265;
Log.i(TAG,"complexStructTest 333");
m.d[0].d1 = 0x983652;
String s = "ksdf2035k8";
Log.i(TAG,"length111:" + s.length());
m.d[0].d2 = s.getBytes();
m.d[1].d1 = 0x983652;
String s1 = "ksdf2035k8";
Log.i(TAG,"length222:" + s1.length());
m.d[1].d2 = s1.getBytes();
Log.i(TAG,"complexStructTest 444");
m.e = 0x8923572;
Log.i(TAG,"complexStructTest 555");
/* 设定值到jni层 */
int size = 0;
size += 4 + 4*4;
size += 4*2;
size += 2 * (4+64);
size += 4 ;
Log.i("size","size=" + size);
int ptr = AllocStructMem(size);
Log.i(TAG,"alloc memory address=" + ptr);
if(ptr !=0){
DSSetInt(ptr,0,m.a);
DSSetInt(ptr,1,m.b[0]);
DSSetInt(ptr,2,m.b[1]);
DSSetInt(ptr,3,m.b[2]);
DSSetInt(ptr,4,m.b[3]);
DSSetInt(ptr,5,m.c[0].c1);
DSSetInt(ptr,6,m.c[0].c1);
DSSetInt(ptr,7,m.d[0].d1);
DSSetBytes(ptr,8,s.length(),s.getBytes());
Log.e(TAG,"complexStructTest aaaa");
DSSetInt(ptr,12,m.d[1].d1);
Log.e(TAG,"complexStructTest bbbb");
DSSetBytes(ptr,13,s1.length(),s1.getBytes());
Log.e(TAG,"complexStructTest cccc");
DSSetInt(ptr,17,m.e);
}
if(ptr != 0){
FreeStructMem(ptr);
ptr = 0;
}
return 0;
}

下面贴下jni实现代码：

[cpp] view plain copy print?

static jint native_setInt(JNIEnv *e, jclass cls, jint addr,jint off,jint len,jint value) {
int *ptr = (int*)addr;
if(ptr == NULL){
LOGE("setInt illegal memory address");
return -1;
}
assert( len == 4);
LOGI("ptr=0x%x,offset=%d native_setInt value = %d",ptr,off,value);
(*(int*)(ptr + off)) = value;
return 0;
}
static jint native_setBytes(JNIEnv *e, jclass cls, jint addr, jint off, jint len, jbyteArray byteValues) {
jbyte *ptr = (jbyte*)addr;
e->GetByteArrayRegion(byteValues,0,len,ptr+off*4);
if(buf == NULL){
LOGE("setBytes illegal memory address");
return -1;
}
return 0;
}
static jint native_getInt(JNIEnv *e, jclass cls, jint addr, jint off, jint len) {
int value = 0x00;
int *ptr = (int*)addr;
if(ptr == NULL){
LOGE("getInt illegal memory address");
return -1;
}
assert(len == 4);
value = *((int*)(ptr + off));
LOGI("ptr=0x%x,offset=%d native_getInt value = %d",ptr,off,value);
return value;
}
static jint native_getBytes(JNIEnv *e, jclass cls, jint addr, jint off, jint len, jbyteArray byteValues) {
jbyte *ptr = (jbyte*)addr;
if(ptr == NULL){
LOGE("getBytes illegal memory address");
return -1;
}
e->SetByteArrayRegion(byteValues,0,len,ptr+off*4);
return 0;
}
static jint native_alloc(JNIEnv *e, jobject thiz, jint len) {
void *ptr = (void*)calloc(1,len);
if(ptr == NULL){
LOGE("alloc buffer out of memory(size=0x%x)",len);
return -1;
}
return (jint)ptr;
}
static void native_free(JNIEnv *e, jobject thiz, jint ptr) {
if(ptr != NULL){
free((void*)ptr);
ptr = NULL;
}
return ;
}

嘿嘿，还是够复杂噻，不过比第一个方案前进了一大步。还有没有更好的办法呢？
请听下会分解。。。哈哈哈!!!

0 0