android_JNI学习

最新推荐文章于 2023-08-17 15:24:16 发布

frank_zyp

最新推荐文章于 2023-08-17 15:24:16 发布

阅读量411

点赞数

分类专栏： 05-android学习

本文链接：https://blog.csdn.net/frank_zyp/article/details/53486728

版权

05-android学习专栏收录该内容

3 篇文章 0 订阅

订阅专栏

一、硬件抽象层（hal）函数：

static int hello_device_open(const struct hw_module_t* module , const char* name , struct hw_device_t **device)  
{  
    struct hello_device_t* dev;  
    dev = (struct hello_device_t *)malloc(sizeof(struct hello_device_t));//分配一块内存  
    if(!dev){  
        ALOGE("Hello Stub: failed to alloc space");  
        return -EFAULT;  
    }  
  
    memset(dev,0,sizeof(struct hello_device_t));  
  
    dev->common.tag = HARDWARE_DEVICE_TAG;  
    dev->common.version = 0;  
    dev->common.module = (hw_module_t*)module;  
    dev->common.close = hello_device_close;  
    dev->set_val = hello_set_val;  
    dev->get_val = hello_get_val;  
  
    if(dev->fd = open(DEVICE_NAME,O_RDWR) == -1){  
        ALOGE("Hello Stub: failed to open /dev/chrdev -- %s",strerror(errno));  
        free(dev);  
        return -EFAULT;  
    }  
  
    *device = &(dev->common);  
    ALOGI("Hello Stub : open /dev/chrdev/ successfully.");  
    return 0;  
}  
  
static int hello_device_close(struct hw_device_t* device)  
{     
    struct hello_device_t* hello_device = (struct hello_device_t *)device;  
    if(hello_device){  
        close(hello_device->fd);  
        free(hello_device);  
    }  
    return 0;  
}  
  
static int hello_set_val(struct hello_device_t* dev,int val)  
{     
    ALOGI("Hello Stub: set value %d to device.\n",val);  
    write(dev->fd , &val , sizeof(val));  
    return 0;  
}

二、cpp文件构件JNI桥梁

namespace android  
{  
    /*在硬件抽象层中定义的硬件访问结构体,参考hardware/hello.h文件*/  
    struct hello_device_t* hello_device = NULL;  
    /*通过硬件抽象层定义的硬件访问接口设置硬件寄存器val的值*/  
    static void hello_setVal(JNIEnv* env , jobject clazz , jint value){  
        int val = value;  
        ALOGI("Hello JNI: set value %d to device.",val);  
        if(!hello_device){  
            ALOGI("Hello JNI: device is not open.");  
            return ;  
        }  
        hello_device->set_val(hello_device , &val);//以此实现cpp到c的调用  
  
    }  
  
    /*通过硬件抽象层定义的硬件访问接口读取硬件寄存器val的值*/  
    static jint hello_getVal(JNIEnv* env , jobject clazz){  
        int val = 0;      
        if(!hello_device){  
            ALOGI("Hello JNI:device is not open.");  
            return val;  
        }  
        hello_device->get_val(hello_device,val);//!!!  
        ALOGI("Hello JNI: get value %d from device.",val);  
        return val;  
    }  
  
    /*通过硬件抽象层定义的硬件模块打开接口，打开硬件设备*/  
    static inline int hello_device_open(const hw_module_t* module,struct hello_device_t** device){  
        return module->methods->open(module,HELLO_HARDWARE_MODULE_ID,(struct hw_device_t**) device);  
    }  
  
    /*通过硬件模块ID来加载指定的硬件抽象层模块并打开硬件*/  
    static jboolean hello_init(JNIEnv* env,jclass clazz){  
        hello_module_t* module;  
  
        ALOGI("Hello Jni: initializing......");  
        if(hw_get_module(HELLO_HARDWARE_MODULE_ID,(const struct hw_module_t**)&module) == 0){  
            ALOGI("Hello JNI: hello Stub found.");  
            if(hello_device_open(&(module->common),&hello_device) == 0){  
                ALOGI("Hello JNI:hello device is open");  
                return 0;  
            }  
            ALOGE("Hello JNI:failed to open hello device.");  
            return -1;  
        }  
        ALOGE("Hello JNI: failed to get hello stub module.");  
        return -1;  
    }  
      
    /*JNI方法表*/  
    static const JNINativeMethod method_table[] = {//此处实现java对cpp的调用转化 注1  
        {"init_native" , "()Z" , (void *)hello_init},  
        {"setVal_native" , "(I)V" , (void *)hello_setVal},  
        {"getVal_native" , "()I" , (void *)hello_getVal},  
    };  
  
    /*注册JNI方法*/  
    int register_android_server_HelloService(JNIEnv *env){//此处注册jni  
        return jniRegisterNativeMethods(env,"com/android/server/HelloService" , method_table , NELEM(method_table));  
    }  
}

注1:

typedef struct {
    const char* name;              //Java中函数的名字
    const char* signature;       //用字符串是描述了函数的参数和返回值
    void*       fnPtr;             //函数指针，指向C函数
} JNINativeMethod;
其中比较难以理解的是第二个参数，例如
    "()V"
    "(II)V"
    "(Ljava/lang/String;Ljava/lang/String;)V"
    实际上这些字符是与函数的参数类型一一对应的。
    "()" 中的字符表示参数，后面的则代表返回值。例如"()V" 就表示void Func();
    "(II)V" 表示 void Func(int, int);
    具体的每一个字符的对应关系如下
    字符     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
    数组则以"["开始，用两个字符表示
    [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函数的参数是class，则以"L"开头，以";"结尾中间是用"/" 隔开的包及类名。而其对应的C函数名的参数则为jobject. 一个例外是String类，其对应的类为jstring
    Ljava/lang/String; String jstring
    Ljava/net/Socket; Socket jobject
    如果JAVA函数位于一个嵌入类，则用$作为类名间的分隔符。
    例如 "(Ljava/lang/String;Landroid/os/FileUtils$FileStatus;)Z"

三、java的封装

package android.os;  
interface IHelloService{  
         void setVal(int val);  
         int getVal();  
}  

package com.android.server;    
import android.content.Context;    
import android.os.IHelloService;    
import android.util.Slog;    
public class HelloService extends IHelloService.Stub {    
    private static final String TAG = "HelloService";    
    HelloService() {    
        init_native();    
    }    
    public void setVal(int val) {    
        setVal_native(val);    
    }       
    public int getVal() {    
        return getVal_native();    
    }    
        
//被native修饰的表示调用了非java语言的本地方法  
    private static native boolean init_native();    
        private static native void setVal_native(int val);    
    private static native int getVal_native();    
};

四、java的调用

helloService = IHelloService.Stub.asInterface(ServiceManager.getService("hello"));

int val = helloService.getVal();

五、native接口定义

JNIEnv定义了一个虚拟机的接口，通过这个接口可以访问虚拟机的所有功能：
       1)分配对象（AllocObject/NewObject），并且控制对象的引用计数（NewGlobalRef/DeleteGlobalRef/DeleteLocalRef/IsSameObject/NewLocalRef）。
       2)获取类的定义（FindClass），并通过类的定义来获取获取类得方法和成员的ID（GetMethodID/GetFieldID）
       3)通过方法ID调用类的普通方法（CallObjectMethod）和静态方法（CallStaticObjectMethod）
       4)通过成员ID获取和设置类的普通成员（GetObjectField/SetObjectField）和静态成员（GetStaticObjectField/SetStaticObjectField）

常用方法：

下面是比较常用的方法：
1）查找该类：
   jclass xxx = (*env)->FindClass(env, "Lclass_name;");
2）取得方法的id：
   jmethodID xxx = (*env)->GetMethodID(env, jclass, methodName, "(M)N");
3）查找需要调用的该类的方法：
   jmethodID xxx = (*env)->GetMethodID(env, jclass, "(M)N" );
4）取得静态方法的id
   jmethodID xxx = (*env)->GetStaticMethodID(env,jclass, methodName,"(M)N")
5）初始化该类的实例：
   jobject xxx = (*env)->NewObject(env, jclass, jmethodID );
6）调用实例的某方法：
   (*env)->CallObjectMethod(env, jobject, jmethodID, [parameter1, parameter2,...] );
7）释放实例：
   (*env)->DeleteLocalRef(env, xxx);
8）取得成员变量的id
   jfieldID xxx = (*env)->GetFieldID(env,jclass ,jfieldID,jfieldType)
9）取得静态成员变量的id
   jfieldID xxx = GetStaticFieldID(env,jclass ,jfieldID,jfieldType)

注：JNIENV - java的运行环境；jobject - 代表java的instance；jclass - 代表java的类

六、函数与属性签名
在GetMethodID和GetFieldID这两个函数中，最后一个参数都是签名字符串，用来标示java函数和成员的唯一性。因为java中存在重载函数，所以一个函数名不足以唯一指定一个函数，这时候就需要签名字符串来指定函数的参数列表和返回值类型了。函数签名是一个字符串："(M)N"，括号中的内容是函数的参数类型，括号后面表示函数的返回值。

参考博客：http://blog.chinaunix.net/uid-25885064-id-3364407.html

作者：frank_zyp

您的支持是对博主最大的鼓励，感谢您的认真阅读。

本文无所谓版权，欢迎转载。

frank_zyp

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
android_JNI学习

一、硬件抽象层（hal）函数：static int hello_device_open(const struct hw_module_t* module , const char* name , struct hw_device_t **device) { struct hello_device_t* dev; dev = (struct hello_devic
复制链接

扫一扫