Android添加系统服务访问驱动程序系列:添加HAL层

static const char *variant_keys[] = {
    "ro.hardware",  /* This goes first so that it can pick up a different
                       file on the emulator. */
    "ro.product.board",
    "ro.board.platform",
    "ro.arch"
};

typedef struct hw_module_t {
    /** tag must be initialized to HARDWARE_MODULE_TAG */
    uint32_t tag;
    uint16_t module_api_version;
    uint16_t hal_api_version;
    /** 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;
} 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;

typedef struct hw_device_t {
    /** tag must be initialized to HARDWARE_DEVICE_TAG */
    uint32_t tag;
    uint32_t version;
    /** reference to the module this device belongs to */
    struct hw_module_t* module;
    /** Close this device */
    int (*close)(struct hw_device_t* device);
} hw_device_t;

/hardware/libhardware
---include
    ---hardware
       ---operate_char.h
---modules
    ---operatechar
       ---operate_char.c
       ---Android.mk

#ifndef ANDROID_OPERATE_CHAR_H
#define ANDROID_OPERATE_CHAR_H

#include <stdint.h>
#include <sys/cdefs.h>
#include <sys/types.h>

#include <hardware/hardware.h>
    
__BEGIN_DECLS

#define OPERATE_CHAR_HARDWARE_MODULE_ID "operatechar"
#define OPERATE_CHAR_HARDWARE_DEVICE_ID "operatechar"

/*自定义模块结构体*/
struct opetatechar_module_t {
    struct hw_module_t common;
};

/*自定义设备结构体*/
struct operatechar_device_t {
    struct hw_device_t common;
    int fd;
    int (*close)(void);
    int (*read)(struct operatechar_device_t* dev, char* buffer, int length);
    int (*write)(struct operatechar_device_t* dev, char* buffer);
};

__END_DECLS

#endif // ANDROID_OPERATE_CHAR_H

#define  LOG_TAG  "operate_char_hal"
#include <cutils/log.h>
#include <cutils/sockets.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <malloc.h>
#include <errno.h>
#include <hardware/operate_char.h>

#define   OPERATECHAR_DEBUG   1

#if OPERATECHAR_DEBUG
#  define D(...)   ALOGD(__VA_ARGS__)
#else
#  define D(...)   ((void)0)
#endif

#define DEVICE_NAME "/dev/mychar"

/*设备打开与关闭操作*/
static int operatechar_open(const struct hw_module_t* module, const char* id,struct hw_device_t** device);
static int operatechar_close(struct hw_device_t* dev);

/*设备读写操作*/
static int operatechar_write(struct operatechar_device_t* dev, char* buffer);
static int operatechar_read(struct operatechar_device_t* dev, char* buffer, int length);

static int operatechar_open(const struct hw_module_t* module, const char* id, struct hw_device_t** device)
{
    if(!strcmp(id, OPERATE_CHAR_HARDWARE_DEVICE_ID)) {
        struct operatechar_device_t *dev = malloc(sizeof(struct operatechar_device_t));
        if (!dev) {
            D("OPERATECHAR HW failed to malloc memory !!!");
            return -1;
        }
        memset(dev, 0, sizeof(*dev));
        dev->common.tag = HARDWARE_DEVICE_TAG;
        dev->common.version = 0;
        dev->common.module = (struct hw_module_t*)module;
        dev->read = operatechar_read;
        dev->write = operatechar_write;
        dev->close = operatechar_close;

        dev->fd = open(DEVICE_NAME, O_RDWR);
        if (dev->fd < 0) {
            D("failed to open /dev/mychar!");
            free(dev);
            return -EFAULT;
        }
        *device = &(dev->common);
        D("OPERATECHAR HW has been initialized");

        return 0;
    }
    return -EFAULT;
}

static int operatechar_close(struct hw_device_t* dev)
{
    struct operatechar_device_t* operatechar_device = (struct operatechar_device_t*)dev;
    if (operatechar_device) {
        close(operatechar_device->fd);
        free(operatechar_device);
    }
    return 0;
}

/*往/dev/mychar存数据*/
static int operatechar_write(struct operatechar_device_t* dev, char* buffer)
{
    if(!dev) {
        D("Null device pointer.");
        return -EFAULT;
    }
    write(dev->fd, buffer, strlen(buffer));
    D("write data to driver: %s", buffer);
    return 0;
}

/*读取/dev/mychar的数据*/
static int operatechar_read(struct operatechar_device_t* dev, char* buffer, int length)
{
    if(!dev) {
        D("Null device pointer.");
        return -EFAULT;
    }
    if(!buffer) {
        D("Null buffer pointer.");
        return -EFAULT;
    }
    int retval;
    retval = read(dev->fd, buffer, length);
    D("read data from driver: %s", buffer);
    return retval;
}

static struct hw_module_methods_t operatechar_module_methods = {
    .open = operatechar_open,
};

struct opetatechar_module_t HAL_MODULE_INFO_SYM = {
    common: {
        .tag = HARDWARE_MODULE_TAG,
        .version_major = 1,
        .version_minor = 0,
        .id = OPERATE_CHAR_HARDWARE_MODULE_ID,
        .name = "Operatechar HW Module",
        .author = "Vane",
        .methods = &operatechar_module_methods,
    }
};