Tips:

framework层调用函数hw_get_module依次在目录/system/lib/hw和/vendor/lib/hw中检查是否存在以下四个文件：

      gralloc.<ro.hardware>.so

      gralloc.<ro.product.board>.so

      gralloc.<ro.board.platform>.so

      gralloc.<ro.arch>.so
    只要其中的一个文件存在，  函数hw_get_module就会停止查找过程，并且调用另外一个函数load来将这个文件加载到内存中来。另一方面，如果在/system/lib/hw和/vendor/lib/hw中均不存这些文件，那么函数hw_get_module就会在目录/system/lib/hw中查找是否存在一个名称为gralloc.default.so的文件。

/**

* The id of this module

*/

#define GRALLOC_HARDWARE_MODULE_ID"gralloc"

/**

* Name of the graphics device to open

*/

#defineGRALLOC_HARDWARE_FB0 "fb0"

#defineGRALLOC_HARDWARE_GPU0 "gpu0"

/**

* Every hardware module must have a datastructure named HAL_MODULE_INFO_SYM

* and the fields of this data structure mustbegin with hw_module_t

* followed by module specific information.

*/

typedef struct gralloc_module_t {

   struct hw_module_t common;

int (*registerBuffer)(structgralloc_module_t const* module,

buffer_handle_t handle);

int(*unregisterBuffer)(struct gralloc_module_t const* module,

buffer_handle_t handle);

int(*lock)(struct gralloc_module_t const* module,

buffer_handle_t handle, int usage,

int l, int t, int w, int h,

void** vaddr);

int(*unlock)(struct gralloc_module_t const* module,

buffer_handle_t handle);

/* reserved for future use */

int (*perform)(struct gralloc_module_tconst* module,

int operation, ... );

/* reserved for future use */

void* reserved_proc[7];

}gralloc_module_t;

/**

* Every device data structure must begin withhw_device_t

* followed by module specific public methodsand attributes.

*/

typedef struct framebuffer_device_t {

   struct hw_device_t common;

/* flags describing some attributes of theframebuffer */

const uint32_t  flags;

/* dimensions of the framebuffer in pixels*/

const uint32_t  width;

const uint32_t  height;

/* frambuffer stride in pixels */

const int       stride;

/* framebuffer pixel format */

const int      format;

/* resolution of the framebuffer's displaypanel in pixel per inch*/

const float     xdpi;

const float     ydpi;

/* framebuffer's display panel refresh ratein frames per second */

const float     fps;

/* min swap interval supported by thisframebuffer */

const int       minSwapInterval;

/* max swap interval supported by thisframebuffer */

const int       maxSwapInterval;

int reserved[8];

int (*setSwapInterval)(structframebuffer_device_t* window,

int interval);

int (*setUpdateRect)(structframebuffer_device_t* window,

int left, int top, int width, intheight);

int (*post)(struct framebuffer_device_t*dev, buffer_handle_t buffer);

int (*compositionComplete)(structframebuffer_device_t* dev);

void* reserved_proc[8];

}framebuffer_device_t;

/**

* Every hardware module must have a datastructure named HAL_MODULE_INFO_SYM

* and the fields of this data structure mustbegin with hw_module_t

* followed by module specific information.

*/

typedef struct hw_module_t {

/** tag must be initialized toHARDWARE_MODULE_TAG */

uint32_t tag;

/** major version number for the module */

uint16_t version_major;

/** minor version number of the module */

uint16_t version_minor;

/** Identifier of module */

const char *id;

/** Name of this module */

const char *name;

/** Author/owner/implementor of the module*/

const char *author;

    /** Modules methods */

    struct hw_module_methods_t*methods;

/** module's dso */

void* dso;

/** padding to 128 bytes, reserved forfuture use */

uint32_t reserved[32-7];

}hw_module_t;

typedef struct hw_module_methods_t {

/** Open a specific device */

int (*open)(const struct hw_module_t* module,const char* id,

struct hw_device_t** device);

}hw_module_methods_t;

/**

* Every device data structure must begin withhw_device_t

* followed by module specific public methodsand attributes.

*/

typedef struct hw_device_t {

/** tag must be initialized toHARDWARE_DEVICE_TAG */

uint32_t tag;

/** version number for hw_device_t */

uint32_t version;

/** reference to the module this devicebelongs to */

struct hw_module_t* module;

/** padding reserved for future use */

uint32_t reserved[12];

/** Close this device */

int (*close)(struct hw_device_t* device);

}hw_device_t;

#ifndefANDROID_HELLO_INTERFACE_H

#defineANDROID_HELLO_INTERFACE_H

#include<hardware/hardware.h>

__BEGIN_DECLS

/*定义模块ID*/

#defineHELLO_HARDWARE_MODULE_ID "hello"

/*硬件模块结构体*/

structhello_module_t {

struct hw_module_t common;

};

/*硬件接口结构体*/

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

};

__END_DECLS

#endif

#defineLOG_TAG "HelloStub"

#include<hardware/hardware.h>

#include<hardware/hello.h>

#include<fcntl.h>

#include<errno.h>

#include<cutils/log.h>

#include<cutils/atomic.h>

/*驱动程序接口/dev/hello*/

#defineDEVICE_NAME "/dev/hello"

#defineMODULE_NAME "Hello"

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

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

staticint hello_device_close(struct hw_device_t* device);

/*设备访问接口*/

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

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

/*模块方法表*/

staticstruct hw_module_methods_t hello_module_methods = {

open: hello_device_open

};

/*模块实例变量*/

structhello_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: “mr shao”,

methods:&hello_module_methods,

}

};

static int hello_device_open(const structhw_module_t* module, const char* name, struct hw_device_t** device) {

structhello_device_t* dev;dev = (struct hello_device_t*)malloc(sizeof(structhello_device_t));

if(!dev){

LOGE("HelloStub: 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("HelloStub: failed to open /dev/hello -- %s.", strerror(errno));free(dev);

return-EFAULT;

}

*device= &(dev->common);

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

return0;

}

static int hello_device_close(structhw_device_t* device) {

structhello_device_t* hello_device = (struct hello_device_t*)device;

if(hello_device){

close(hello_device->fd);

free(hello_device);

}

return0;

}

static int hello_set_val(structhello_device_t* dev, int val) {

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

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

return0;

}

static int hello_get_val(structhello_device_t* dev, int* val) {

if(!val){

LOGE("HelloStub: error val pointer");

return-EFAULT;

}

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

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

return0;

}

LOCAL_PATH := $(call my-dir)

include$(CLEAR_VARS)

LOCAL_MODULE_TAGS := optional

LOCAL_PRELINK_MODULE := false

LOCAL_MODULE_PATH:= $(TARGET_OUT_SHARED_LIBRARIES)/hw

LOCAL_SHARED_LIBRARIES := liblog

LOCAL_SRC_FILES:= hello.c

LOCAL_MODULE :=hello.default

include$(BUILD_SHARED_LIBRARY)