Hardware-javaaplication.

eg:hello

一:Hardware

//作用，向系统申请设备号，设备节点实体化file_operations，cdv

struct cdev{

dev_t dev;

};



static struct file_operations hello_ops={

.owner = THIS_MODULE,

.ioctl = hello_ioctl,

.read = hello_read,

.write = hello_write,

.open = hello_open,

......

};



static __init xxx_init() 模块加载函数

{

}

static __exit xxx_exit() 模块卸载函数

{

}

module_init(hello_init);

module_exit(hello_exit);

二:HAL

/*

Android硬件抽象层规范的要求，

分别定义模块ID、模块结构体以及硬件接口结构体。

在硬件接口结构体中，fd表示设备文件描述符，对应我们将要处理的设备文件"/dev/hello"，

set_val和get_val为该HAL对上提供的函数接口。

__BEGIN_DECLS

*/

/*定义模块ID*/

#define HELLO_HARDWARE_MODULE_ID "hello"

/*硬件模块结构体*/

struct hello_module_t {

struct hw_module_t common;

};

/*硬件接口结构体*/

struct hello_device_t {

struct hw_device_t common;

int fd;

int (*set_val)(struct hello_device_t* dev, int val);

int (*get_val)(struct hello_device_t* dev, int* val);

};

/*设备打开和关闭接口*/

static int hello_device_open(const struct hw_module_t* module, const char* name, struct hw_device_t** device);

static int hello_device_close(struct hw_device_t* device);



/*设备访问接口*/

static int hello_set_val(struct hello_device_t* dev, int val);

static int hello_get_val(struct hello_device_t* dev, int* val);



/*模块方法表*/

static struct hw_module_methods_t hello_module_methods = {

open: hello_device_open

};



/*模块实例变量*/

struct hello_module_t HAL_MODULE_INFO_SYM = {

common: {

tag: HARDWARE_MODULE_TAG,

version_major: 1,

version_minor: 0,

id: HELLO_HARDWARE_MODULE_ID,

name: MODULE_NAME,

author: MODULE_AUTHOR,

methods: &hello_module_methods,

}

};

//这里，实例变量名必须为HAL_MODULE_INFO_SYM，tag也必须为HARDWARE_MODULE_TAG，这是Android硬件抽象层规范规定的



//定义hello_device_open函数：

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) {

LOGE("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) {

LOGE("Hello Stub: failed to open /dev/hello -- %s.", strerror(errno));free(dev);

return -EFAULT;

}



*device = &(dev->common);

LOGI("Hello Stub: open /dev/hello successfully.");



return 0;

}

//DEVICE_NAME定义为"/dev/hello"。由于设备文件是在内核驱动里面通过device_create创建的，

//而device_create创建的设备文件默认只有root用户可读写，而hello_device_open一般是由上层APP来调用的，

//这些APP一般不具有root权限，这时候就导致打开设备文件失败

//解决办法是类似于Linux的udev规则，打开Android源代码工程目录下，进入到system/core/rootdir目录，

//里面有一个名为ueventd.rc文件，往里面添加一行：

/dev/hello 0666 root root

//定义hello_device_close、hello_set_val和hello_get_val这三个函数：

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) {

LOGI("Hello Stub: set value %d to device.", val);



write(dev->fd, &val, sizeof(val));



return 0;

}



static int hello_get_val(struct hello_device_t* dev, int* val) {

if(!val) {

LOGE("Hello Stub: error val pointer");

return -EFAULT;

}



read(dev->fd, val, sizeof(*val));



LOGI("Hello Stub: get value %d from device", *val);



return 0;

}

三:JNI

/*

Android的Application Frameworks层提供硬件服务

Java应用程序通过JNI来调用硬件抽象层接口

准备好硬件抽象层模块，确保Android系统镜像文件system.img已经包含hello.default模块。

二. 进入到frameworks/base/services/jni目录，新建com_android_server_HelloService.cpp文件：

在com_android_server_HelloService.cpp文件中，实现JNI方法。注意文件的命令方法，com_android_server前缀表示的是包名，表示硬件服务HelloService是放在frameworks/base/services/java目录下的com/android/server目录的，即存在一个命令为com.android.server.HelloService的类。这里，我们暂时略去HelloService类的描述，在下一篇文章中，我们将回到HelloService类来。简单地说，HelloService是一个提供Java接口的硬件访问服务类。

接着定义hello_init、hello_getVal和hello_setVal三个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;

LOGI("Hello JNI: set value %d to device.", val);

if(!hello_device) {

LOGI("Hello JNI: device is not open.");

return;

}



hello_device->set_val(hello_device, val);

}

/*通过硬件抽象层定义的硬件访问接口读取硬件寄存器val的值*/

static jint hello_getVal(JNIEnv* env, jobject clazz) {

int val = 0;

if(!hello_device) {

LOGI("Hello JNI: device is not open.");

return val;

}

hello_device->get_val(hello_device, &val);



LOGI("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;



LOGI("Hello JNI: initializing......");

if(hw_get_module(HELLO_HARDWARE_MODULE_ID, (const struct hw_module_t**)&module) == 0) {

LOGI("Hello JNI: hello Stub found.");

if(hello_device_open(&(module->common), &hello_device) == 0) {

LOGI("Hello JNI: hello device is open.");

return 0;

}

LOGE("Hello JNI: failed to open hello device.");

return -1;

}

LOGE("Hello JNI: failed to get hello stub module.");

return -1;

}

/*JNI方法表*/

static const JNINativeMethod method_table[] = {

{"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) {

return jniRegisterNativeMethods(env, "com/android/server/HelloService", method_table, NELEM(method_table));

}

};

注意，在hello_init函数中，通过Android硬件抽象层提供的hw_get_module方法来加载模块ID为HELLO_HARDWARE_MODULE_ID的硬件抽象层模块，其中，HELLO_HARDWARE_MODULE_ID是在<hardware/hello.h>中定义的。Android硬件抽象层会根据HELLO_HARDWARE_MODULE_ID的值在Android系统的/system/lib/hw目录中找到相应的模块，然后加载起来，并且返回hw_module_t接口给调用者使用。在jniRegisterNativeMethods函数中，第二个参数的值必须对应HelloService所在的包的路径，即com.android.server.HelloService。



三. 修改同目录下的onload.cpp文件，首先在namespace android增加register_android_server_HelloService函数声明：



namespace android {



..............................................................................................



int register_android_server_HelloService(JNIEnv *env);



};



在JNI_onLoad增加register_android_server_HelloService函数调用：

extern "C" jint JNI_onLoad(JavaVM* vm, void* reserved)

{

.................................................................................................

register_android_server_HelloService(env);

.................................................................................................

}

这样，在Android系统初始化时，就会自动加载该JNI方法调用表。

四. 修改同目录下的Android.mk文件，在LOCAL_SRC_FILES变量中增加一行：

LOCAL_SRC_FILES:= \

com_android_server_AlarmManagerService.cpp \

com_android_server_BatteryService.cpp \

com_android_server_InputManager.cpp \

com_android_server_LightsService.cpp \

com_android_server_PowerManagerService.cpp \

com_android_server_SystemServer.cpp \

com_android_server_UsbService.cpp \

com_android_server_VibratorService.cpp \

com_android_server_location_GpsLocationProvider.cpp \

com_android_server_HelloService.cpp /

onload.cpp

五. 编译和重新找亿system.img：

USER-NAME@MACHINE-NAME:~/Android$ mmm frameworks/base/services/jni

USER-NAME@MACHINE-NAME:~/Android$ make snod

这样，重新打包的system.img镜像文件就包含我们刚才编写的JNI方法了，也就是我们可以通过Android系统的Application Frameworks层提供的硬件服务HelloService来调用这些JNI方法，进而调用低层的硬件抽象层接口去访问硬件了。前面提到，在这篇文章中，我们暂时忽略了HelloService类的实现，在下一篇文章中，我们将描述如何实现硬件服务HelloService，敬请关注。

四:java Frameworks

/*

一：

我们要先定义好通信接口。进入到frameworks/base/core/java/android/os目录

新增IHelloService.aidl接口定义文件：

IHelloService接口主要提供了设备和获取硬件寄存器val的值的功能，分别通过setVal和getVal两个函数来实现。

eg

*/

package android.os;

interface IHelloService {

void setVal(int val);

int getVal();

}



/*

二

返回到frameworks/base目录，打开Android.mk文件，修改LOCAL_SRC_FILES变量的值，增加IHelloService.aidl源文件：

eg

*/

core/java/android/os/IHelloService.aidl /

/*

三

编译IHelloService.aidl接口：

USER-NAME@MACHINE-NAME:~/Android$ mmm frameworks/base

这样，就会根据IHelloService.aidl生成相应的IHelloService.Stub接口。

*/

/*

四

.进入到frameworks/base/services/java/com/android/server目录，新增HelloService.java文件：

HelloService主要是通过调用JNI方法init_native、setVal_native和getVal_native

(见在Ubuntu为Android硬件抽象层（HAL）模块编写JNI方法提供Java访问硬件服务接口一文)来提供硬件服务。

*/

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

}



private static native boolean init_native();

private static native void setVal_native(int val);

private static native int getVal_native();

};

/*

五. 修改同目录的SystemServer.java文件，在ServerThread::run函数中增加加载HelloService的代码：

*/

try {



Slog.i(TAG, "Hello Service");



ServiceManager.addService("hello", new HelloService());



} catch (Throwable e) {



Slog.e(TAG, "Failure starting Hello Service", e);



}

/*

七. 编译HelloService和重新打包system.img：



USER-NAME@MACHINE-NAME:~/Android$ mmm frameworks/base/services/java



USER-NAME@MACHINE-NAME:~/Android$ make snod



这样，重新打包后的system.img系统镜像文件就在Application Frameworks层中包含了我们自定义的硬件服务HelloService了，并且会在系统启动的时候，自动加载HelloService。这时，应用程序就可以通过Java接口来访问Hello硬件服务了。我们将在下一篇文章中描述如何编写一个Java应用程序来调用这个HelloService接口来访问硬件，敬请期待。





*/

五:Application

/*

我们将在Android系统的应用层增加一个内置的应用程序，

这个内置的应用程序通过ServiceManager接口获取指定的服务，然后通过这个服务来获得硬件服务。

*/

package shy.luo.hello;



import shy.luo.hello.R;

import android.app.Activity;

import android.os.ServiceManager;

import android.os.Bundle;

import android.os.IHelloService;

import android.os.RemoteException;

import android.util.Log;

import android.view.View;

import android.view.View.OnClickListener;

import android.widget.Button;

import android.widget.EditText;



public class Hello extends Activity implements OnClickListener {

private final static String LOG_TAG = "shy.luo.renju.Hello";



private IHelloService helloService = null;



private EditText valueText = null;

private Button readButton = null;

private Button writeButton = null;

private Button clearButton = null;



/** Called when the activity is first created. */

@Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.main);



helloService = IHelloService.Stub.asInterface(

ServiceManager.getService("hello"));



valueText = (EditText)findViewById(R.id.edit_value);

readButton = (Button)findViewById(R.id.button_read);

writeButton = (Button)findViewById(R.id.button_write);

clearButton = (Button)findViewById(R.id.button_clear);



readButton.setOnClickListener(this);

writeButton.setOnClickListener(this);

clearButton.setOnClickListener(this);



Log.i(LOG_TAG, "Hello Activity Created");

}



@Override

public void onClick(View v) {

if(v.equals(readButton)) {

try {

int val = helloService.getVal();

String text = String.valueOf(val);

valueText.setText(text);

} catch (RemoteException e) {

Log.e(LOG_TAG, "Remote Exception while reading value from device.");

}

}

else if(v.equals(writeButton)) {

try {

String text = valueText.getText().toString();

int val = Integer.parseInt(text);

helloService.setVal(val);

} catch (RemoteException e) {

Log.e(LOG_TAG, "Remote Exception while writing value to device.");

}

}

else if(v.equals(clearButton)) {

String text = "";

valueText.setText(text);

}

}

}

/*

程序通过ServiceManager.getService("hello")来获得HelloService，

接着通过IHelloService.Stub.asInterface函数转换为IHelloService接口。

其中，服务名字“hello”是系统启动时加载HelloService时指定的，

而IHelloService接口定义在android.os.IHelloService中，

具体可以参考在Ubuntu上为Android系统的Application Frameworks层增加硬件访问服务一文。

这个程序提供了简单的读定自定义硬件有寄存器val的值的功能，

通过IHelloService.getVal和IHelloService.setVal两个接口实现。

*/

ServiceManager.addService("hello", new HelloService());

ServiceManager.getService("hello")

public class HelloService extends IHelloService.Stub {}



helloService = IHelloService.Stub.asInterface(

ServiceManager.getService("hello"));