android分层学习笔记（一）
对于Android系统移植，主要是信息中framework的移植，而且都会涉及到硬件。关于硬件相关，资料目前不算小，最先比较详细介绍的是Jollen，其他资料也大部分基于他的分析而写出了一些自己的理解，他的博客地址是http://www.jollen.org/blog/2009/。
以下是自己的学习笔记及理解，以为备忘。
本文的主要内容如下：
写在前面：关于分层
一、 Stub编写
二、 JNI编写
三、 framework的java编写
四、 应用程序编写
五、 linux硬件驱动编写
尽量把每一部分内家写得短些，太长看了会比较累。
------------------------------------------------------------------------------
写在前面：关于分层
一个系统的分层，可以有比较清晰的层次感，基本上我们的世界都是在一个分层的理念中，生物圈，管理、行政体系、人类需求……都可以看到分层的影子，还有一些逻辑上的概念，如tcp/ip分层。
有些时候，我们称之为等级。
分层不能太多层，否则鞭长莫及。也不能不太小，否则层面太宽，失去分层之要义。所谓适当的、有效的、健壮的有分层，就是我们所常说的“中庸”，当然此中庸，非彼中庸了。
anroid系统的分层，有一张图很清楚地显示了，网上比较多这张图，此处略去。apps->framework(apps service, manager)->jni->stub->linux kernel/driver。
对于整个系统来说，这个分层的确有点太多层了，不花点时间，会顾此失彼，而且涉及到的知识面比较广。
对于效率来说，分层太多，效率肯定会打折扣，何况还应用程序还是用java写的，java比较高级的语言了。目前来看，android系统对硬件要求也比较高了，似乎这些折扣，可以通过硬件的方式来补偿了。硬件，硬件，发展也是会有瓶颈的吧？？
一、Stub编写
1、Stub的编写
Stub是与linux驱动打交道，也就是直接调用了open，close，ioctl，read，write等函数。实际上等价于我们直接在linux上写一些应用程序时所调用硬件驱动功能。只是在android里叫做stub而已。
首先熟悉一下，两个结构体：hw_module_t 和hw_device_t。
此两结构体定义在 hardware/libhardware/include/hardware/hardware.h
typedef struct hw_module_t { /** tag must be initialized to HARDWARE_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 for future 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 with hw_device_t * followed by module specific public methods and attributes. */ typedef struct hw_device_t { /** tag must be initialized to HARDWARE_DEVICE_TAG */ uint32_t tag; /** version number for hw_device_t */ uint32_t version; /** reference to the module this device belongs 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;
写Stub代码，就是填充这两个结体体。
在访问硬件设备时，是通过文件标识来操作，因此实际上在hw_device_t还应该添一个文件标识变fd，有两种方式可以实现：1）把hw_device_t中reseverd变量来放文件标识，这是被系统保留，应该说不太安全。2）自定义一个结构体，把hw_device_t 当作此结构体的成员变量。如下操作：
struct gpio_device_t {
struct hw_device_t hwdev;
/* attributes */
int fd; //the file description of the device in /dev/xxx
}
这样在open设备的时候，就可以把返回的文件标识值，传给fd了。
下面就是简单写Stub的流程：
1、 在vendor目录下建一个hal目录，再分别创建framework和modules目录。对应于framework代码和c/c++模块代码，在moueles创建gpio目录。gpio比较通用，led也是属于gpio范畴。
2、创建gpio.h 如下
#include <hardware/hardware.h> #include <fcntl.h> #include <errno.h> #include <cutils/log.h> #include <cutils/atomic.h> struct gpio_module_t { struct hw_module_t hwmod; }; struct gpio_device_t { struct hw_device_t hwdev; /* attributes */ int fd; //the file description of the device in /dev/xxx /* supporting control APIs go here */ int (*SetGPIO)(struct gpio_device_t *dev, int32_t gpio); int (*ClrGPIO)(struct gpio_device_t *dev, int32_t gpio); }; #define GPIO_HARDWARE_MODULE_ID "gpio"
头文件：
#include <hardware/hardware.h> //上两个基本结构体定义处
#include <fcntl.h>
#include <errno.h>
#include <cutils/log.h>
#include <cutils/atomic.h>
自己定义的两个结构体
struct gpio_module_t {
struct hw_module_t hwmod;
};
struct gpio_device_t {
struct hw_device_t hwdev;
int fd; //the file description of the device in /dev/xxx
int (*SetGPIO)(struct gpio_device_t *dev, int32_t gpio);
int (*ClrGPIO)(struct gpio_device_t *dev, int32_t gpio);
};
定义一个模块id，#define GPIO_HARDWARE_MODULE_ID "gpio"
保存到gpio目录下。
3 编写gpio.c
#include "gpio.h" #define LOG_TAG "GPIO" int gpio_device_close(struct hw_device_t* device) { struct gpio_device_t* gdev = (struct gpio_device_t*)device; if (gdev) { free(gdev); } return 0; } int gpio_set(struct gpio_device_t *dev, int32_t gpio) { LOGI("gpio : %d set .", gpio); if (dev->fd >= 0) { } return 0; } int gpio_clr(struct gpio_device_t *dev, int32_t gpio) { LOGI("gpio : %d clr.", gpio); if (dev->fd >= 0) { } return 0; } static int gpio_device_open(const struct hw_module_t* module, const char* name, struct hw_device_t** device) { struct gpio_device_t *dev; dev = (struct gpio_device_t *)malloc(sizeof(struct gpio_device_t)); memset(dev, 0, sizeof(struct gpio_device_t)); dev->hwdev.tag = HARDWARE_DEVICE_TAG; dev->hwdev.version = 0; dev->hwdev.module = module; dev->hwdev.close = gpio_device_close; dev->SetGPIO = gpio_set; dev->ClrGPIO = gpio_clr; dev->fd = open("/dev/gpio0", O_RDWR); *device = &dev->hwdev; if (dev->fd < 0) { free(dev); dev = NULL; return -1; } return 0; } static struct hw_module_methods_t gpio_module_methods = { open: gpio_device_open }; const struct gpio_module_t HAL_MODULE_INFO_SYM = { hwmod: { tag: HARDWARE_MODULE_TAG, version_major: 1, version_minor: 0, id: GPIO_HARDWARE_MODULE_ID, name: "gpio Stub", author: "guim", methods: &gpio_module_methods, } };
int gpio_device_close(struct hw_device_t* device) //关闭gpio设备
int gpio_set(struct gpio_device_t *dev, int32_t gpio)//gpio置1
int gpio_clr(struct gpio_device_t *dev, int32_t gpio)//gpio置0
static int gpio_device_open(const struct hw_module_t* module, const char* name,
struct hw_device_t** device) //打开gpio设备，这个函数是一定要实现，因为之后要传给hw_module_methods_t中的open函数指针：
static struct hw_module_methods_t gpio_module_methods =
{
open: gpio_device_open
};
在此函数中，要填充gpio_device_t一些接口，供上层调用：
dev->hwdev.tag = HARDWARE_DEVICE_TAG; //默认都为此值
dev->hwdev.version = 0; //应该可以随便写，根据自己定义
dev->hwdev.module = module;
dev->hwdev.close = gpio_device_close;
dev->SetGPIO = gpio_set;
dev->ClrGPIO = gpio_clr;
dev->fd = open("/dev/gpio0", O_RDWR); //打开gpio设备
//注册接口，HAL_MODULE_INFO_SYM
const struct gpio_module_t HAL_MODULE_INFO_SYM = //固定为HAL_MODULE_INFO_SYM，不可修改，不知为什么，照做。
{
hwmod:
{
tag: HARDWARE_MODULE_TAG,
version_major: 1,
version_minor: 0,
id: GPIO_HARDWARE_MODULE_ID,
name: "gpio Stub",
author: "guim",
methods: &gpio_module_methods,
}
};
4 编写Android.mk文件
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_PRELINK_MODULE := false
LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw
LOCAL_SHARED_LIBRARIES := liblog
LOCAL_SRC_FILES := gpio.c
#模块名为gpio.default
LOCAL_MODULE := gpio.default
include $(BUILD_SHARED_LIBRARY)
其中LOCAL_PRELINK_MODULE要置为false，否则编译时会出错。
5 关于模块名的命名
在jni调用stub方法时，是用到hw_get_module函数来查找这个库。hw_get_module函数实现如下（位置hardware/libhardware/Hardware.c ）：
在查找模块的时候，默认是查找system/lib/hwh目录下的，也就是上面编译好的gpio.default.so是放在此目录下
#define HAL_LIBRARY_PATH "/system/lib/hw"
//模块的键值，在查找库的时候，要根据模块的id，即GPIO_HARDWARE_MODULE_ID来查找模块文件
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"
};
static const int HAL_VARIANT_KEYS_COUNT =
(sizeof(variant_keys)/sizeof(variant_keys[0]));
int hw_get_module(const char *id, const struct hw_module_t **module)
{
int status;
int i;
const struct hw_module_t *hmi = NULL;
char prop[PATH_MAX];
char path[PATH_MAX];
/*
* Here we rely on the fact that calling dlopen multiple times on
* the same .so will simply increment a refcount (and not load
* a new copy of the library).
* We also assume that dlopen() is thread-safe.
*/
/* Loop through the configuration variants looking for a module */
for (i=0 ; i<HAL_VARIANT_KEYS_COUNT+1 ; i++) {
if (i < HAL_VARIANT_KEYS_COUNT) {
if (property_get(variant_keys, prop, NULL) == 0) {
continue;
}
snprintf(path, sizeof(path), "%s/%s.%s.so",
HAL_LIBRARY_PATH, id, prop);
} else {
snprintf(path, sizeof(path), "%s/%s.default.so",
HAL_LIBRARY_PATH, id);
}
if (access(path, R_OK)) {
continue;
}
/* we found a library matching this id/variant */
break;
}
status = -ENOENT;
if (i < HAL_VARIANT_KEYS_COUNT+1) {
/* load the module, if this fails, we're doomed, and we should not try
* to load a different variant. */
status = load(id, path, module);
}
return status;
}
property_get(variant_keys, prop, NULL) 会从variant_keys数组中去获取相应变量所对应的值，然后返回给 prop ：
数组中的变量对应的值，如下：
"ro.product.board=$TARGET_BOOTLOADER_BOARD_NAME"
"ro.board.platform=$TARGET_BOARD_PLATFORM"
TARGET_BOOTLOADER_BOARD_NAME会根据具体的设定而确定，当然要还要看在编译android系统的时所选的target了，此处默认选择genic，TARGET_BOOTLOADER_BOARD_NAME和TARGET_BOARD_PLATFORM都为空，因此，此处就找不到对应的模块文件，如果找到会传给prop值，然后根据snprintf(path, sizeof(path), "%s/%s.%s.so", HAL_LIBRARY_PATH, id, prop);得到模块的绝对文件名。否则则用snprintf(path, sizeof(path), "%s/%s.default.so", HAL_LIBRARY_PATH, id);设定模块的全路径名，即/system/lib/hw/xxx.default.so。因此，上面生成模块名是定义为gpio.default.so, 此处xxx即为gpio。如果都没有找到模块文件，那么上层调用时就会提示出错，可以通过LOG信息来跟踪。
此部分详情，将由JNI的编写具体讨论。