Linux内核提供了统一的framebuffer显示驱动。Framebuffer是内核系统提供的图形硬件的抽象描述，称为buffer是因为它也占用了系统存储空间的一部分，是一块包含屏幕显示信息的缓冲区。Framebuffer借助于Linux文件系统向上层应用提供了统一而高效的操作接口，让用户空间运行的程序比较容易地适配多种显示设备。
Android系统中，每个显示屏被抽象为一个帧缓冲区，注册到FrameBuffer模块中，并在/dev/graphics目录下创建对应的fbX设备，framebuffer提供的设备节点为/dev/graphics/fb或者/dev/fb，Android系统在硬件抽象层中提供了一个Gralloc模块，封装了对帧缓冲区的所有访问操作。用户空间的应用程序在使用帧缓冲区之间，首先要加载Gralloc模块，并且获得一个gralloc设备和一个fb设备。有了gralloc设备之后，用户空间中的应用程序就可以申请分配一块图形缓冲区，并且将这块图形缓冲区映射到应用程序的地址空间来，以便可以向里面写入要绘制的画面的内容。
Android 硬件抽象库的加载简介
Android系统，为了隐藏各厂家自身特定硬件驱动实现细节，在用户空间定义了一套硬件抽象层，各厂商在Android的硬件抽象层实现特定硬件的操作细节，编译成动态库，以库的形式提供给用户使用。
hardware/libhardware/include/hardware/hardware.h 头文件中定义一个代表模块的结构体 (hw_module_t)，其中包含模块的版本、名称和作者等元数据。Android系统 会根据这些元数据来找到并正确加载 HAL 模块。
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;
const char *id;
const char *name;
const char *author;
struct hw_module_methods_t* methods;
void* dso;
#ifdef __LP64__
uint64_t reserved[32-7];
#else
/** padding to 128 bytes, reserved for future use */
uint32_t reserved[32-7];
#endif
} hw_module_t;
hw_module_t 结构体还包含指向另一个结构体 hw_module_methods_t 的指针，后面这个结构体包含指向相应模块的 open 函数的指针。此 open 函数用于与相关硬件（此 HAL 是其抽象形式）建立通信。每个硬件专用 HAL 通常都会使用该特定硬件的附加信息来扩展通用的 hw_module_t 结构体。例如，在相机 HAL 中，camera_module_t 结构体包含一个 hw_module_t 结构体以及相机专用的其他函数指针：
typedef struct camera_module {
hw_module_t common;
int (*get_number_of_cameras)(void);
int (*get_camera_info)(int camera_id, struct camera_info *info);
} camera_module_t;
实现 HAL 并创建模块结构体时，您必须将其命名为 HAL_MODULE_INFO_SYM，以下是 Nexus 9 音频 HAL 的示例：
struct audio_module HAL_MODULE_INFO_SYM = {
.common = {
.tag = HARDWARE_MODULE_TAG,
.module_api_version = AUDIO_MODULE_API_VERSION_0_1,
.hal_api_version = HARDWARE_HAL_API_VERSION,
.id = AUDIO_HARDWARE_MODULE_ID,
.name = "NVIDIA Tegra Audio HAL",
.author = "The Android Open Source Project",
.methods = &hal_module_methods,
},
};
HAL 设备
设备是产品硬件的抽象表示。例如，一个音频模块可能包含主音频设备、USB 音频设备或蓝牙 A2DP 音频设备。
设备由 hw_device_t 结构体表示。与模块类似，每类设备都定义了一个通用 hw_device_t 的详细版本，其中包含指向特定硬件功能的函数指针。例如，audio_hw_device_t 结构体类型会包含指向音频设备操作的函数指针：
struct audio_hw_device {
struct hw_device_t common;
/**
* used by audio flinger to enumerate what devices are supported by
* each audio_hw_device implementation.
*
* Return value is a bitmask of 1 or more values of audio_devices_t
*/
uint32_t (*get_supported_devices)(const struct audio_hw_device *dev);
...
};
typedef struct audio_hw_device audio_hw_device_t;
如何加载硬件抽象层的动态库？
int hw_get_module(const char *id, const struct hw_module_t **module)
{
return hw_get_module_by_class(id, NULL, module);
}
参数为模块的ID，最终会返回一个hw_module_t的结构体保存在参数module中。
每个硬件抽象层模块都必须定义HAL_MODULE_INFO_SYM符号，并且有自己唯一的ID。
hw_get_module会遍历规定的几个目录来查找名称对应的动态库，找到库的路径后，会调用load函数使用dlopen打开找到的库，并依据HAL_MODULE_INFO_SYM_AS_STR（其值为HMI）获取到hw_module_t（即HAL_MODULE_INFO_SYM）结构体指针。以及把dlopen返回的handle保存在hw_module_t中，而hw_module_t HMI 结构是一个全局结构。
每个硬件抽象层必须有自己的ID以及HAL_MODULE_INFO_SYM符号，Gralloc也不例外
/**
* The id of this module
*/
#define GRALLOC_HARDWARE_MODULE_ID "gralloc"
struct private_module_t HAL_MODULE_INFO_SYM = {
.base = {
.common = {
.tag = HARDWARE_MODULE_TAG,
.version_major = 1,
.version_minor = 0,
.id = GRALLOC_HARDWARE_MODULE_ID,
.name = "Graphics Memory Allocator Module",
.author = "The Android Open Source Project",
.methods = &gralloc_module_methods
},
.registerBuffer = gralloc_register_buffer,
.unregisterBuffer = gralloc_unregister_buffer,
.lock = gralloc_lock,
.unlock = gralloc_unlock,
},
.framebuffer = 0,
.flags = 0,
.numBuffers = 0,
.bufferMask = 0,
.lock = PTHREAD_MUTEX_INITIALIZER,
.currentBuffer = 0,
};
hw_get_module硬件加载方法根据gralloc的ID, 查找到gralloc模块定义的HAL_MODULE_INFO_SYM并返回给hw_module_t结构，但是HAL_MODULE_INFO_SYM是private_module_t结构类型，如何赋值呢？
Gralloc模块数据结构分析
struct private_module_t {
gralloc_module_t base;
private_handle_t* framebuffer; //指向系统帧缓冲区的句柄
uint32_t flags; //用来标志系统帧缓冲区是否支持双缓冲
uint32_t numBuffers; //表示系统帧缓冲区包含有多少个图形缓冲区
uint32_t bufferMask; //记录系统帧缓冲区中的图形缓冲区的使用情况
pthread_mutex_t lock; //一个互斥锁，用来保护结构体private_module_t的并行访问
buffer_handle_t currentBuffer; //用来描述当前正在被渲染的图形缓冲区
int pmem_master;
void* pmem_master_base;
struct fb_var_screeninfo info; //保存设备显示屏的动态属性信息
struct fb_fix_screeninfo finfo; //保存设备显示屏的固定属性信息
float xdpi; //描述设备显示屏在宽度
float ydpi; //描述设备显示屏在高度
float fps; //用来描述显示屏的刷新频率
};
private_module_t负责管理显示驱动framebuffer相关的信息，包括framebuffer的fd, 有多少个缓存，系统帧缓冲区使用情况，动态可变的信息，固定属性的信息，显示屏的宽高，刷新率等信息。
private_module_t 第一个变量是gralloc_module_t结构。
typedef struct gralloc_module_t {
struct hw_module_t common;
//映射一块图形缓冲区到一个进程的地址空间去
int (*registerBuffer)(struct gralloc_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);
int (*perform)(struct gralloc_module_t const* module,
int operation, ... );
int (*lock_ycbcr)(struct gralloc_module_t const* module,
buffer_handle_t handle, int usage,
int l, int t, int w, int h,
struct android_ycbcr *ycbcr);
int (*lockAsync)(struct gralloc_module_t const* module,
buffer_handle_t handle, int usage,
int l, int t, int w, int h,
void** vaddr, int fenceFd);
int (*unlockAsync)(struct gralloc_module_t const* module,
buffer_handle_t handle, int* fenceFd);
int (*lockAsync_ycbcr)(struct gralloc_module_t const* module,
buffer_handle_t handle, int usage,
int l, int t, int w, int h,
struct android_ycbcr *ycbcr, int fenceFd);
/* reserved for future use */
void* reserved_proc[3];
} gralloc_module_t;
gralloc_module_t 负责管理gralloc模块相关的操作，其第一个是属性是硬件抽象层规定的hw_module_t结构，其他都是关于gralloc模块图像buffer处理的相关操作方法。
hw_module_t结构如下：
/**
* 任何一个硬件模块都必须有一个名称为 HAL_MODULE_INFO_SYM的数据结构
* 并且这个数据结构必须以hw_module_t为第一个元素，其后再跟随这个模块特有的信息
*/
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; //模块从设备号
const char *id; //模块ID
const char *name; //名称
const char *author; //作者
struct hw_module_methods_t* methods; //操作模块的方法
void* dso; //模块首地址
uint64_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;
硬件抽象层hw_module_t结构描述了硬件抽象层库相关的信息。如版本号，id, 名称，相关的操作方法等。
其中还定义了模块的打开模块的操作方法open.
根据以上的三个结构我们可以画出结构图如下：
回到上面问题，为什么private_module_t可以赋值给hw_module_t呢？这样看就很简单了，private_module_t的第一个变量就是gralloc_module_t, 而gralloc_module_t的数据第一个元素就是hw_module_t。private_module_t的首地址和hw_module_t的首地址是一样的，所以可以直接赋值过去。
除了hw_module_t的数据结构外，gralloc模块还定义了两种设备相关的数据结构：
1: framebuffer_device_t 用来描述系统帧缓冲区的信息
typedef struct framebuffer_device_t {
struct hw_device_t common;
const uint32_t flags;//用来记录系统帧缓冲区的标志
const uint32_t width;//用来描述设备显示屏的宽度
const uint32_t height;//用来描述设备显示屏的高度
const int stride;//用来描述设备显示屏的一行有多少个像素点
const int format;//用来描述系统帧缓冲区的像素格式
const float xdpi;//用来描述设备显示屏在宽度上的密度
const float ydpi;//用来描述设备显示屏在高度上的密度
const float fps;//用来描述设备显示屏的刷新频率
const int minSwapInterval;//用来描述帧缓冲区交换前后两个图形缓冲区的最小时间间隔
const int maxSwapInterval;//用来描述帧缓冲区交换前后两个图形缓冲区的最大时间间隔
int reserved[8];//保留
//用来设置帧缓冲区交换前后两个图形缓冲区的最小和最大时间间隔
int (*setSwapInterval)(struct framebuffer_device_t* window,int interval);
//用来设置帧缓冲区的更新区域
int (*setUpdateRect)(struct framebuffer_device_t* window,int left, int top, int width, int height);
//用来将图形缓冲区buffer的内容渲染到帧缓冲区中去
int (*post)(struct framebuffer_device_t* dev, buffer_handle_t buffer);
//用来通知fb设备，图形缓冲区的组合工作已经完成
int (*compositionComplete)(struct framebuffer_device_t* dev);
void (*dump)(struct framebuffer_device_t* dev, char *buff, int buff_len);
int (*enableScreen)(struct framebuffer_device_t* dev, int enable);
//保留
void* reserved_proc[6];
2:alloc_device_t 用于描述图像分配相关的信息
typedef struct alloc_device_t {
struct hw_device_t common;
//用于分配一块图形缓冲区
int (*alloc)(struct alloc_device_t* dev,int w, int h, int format, int usage,buffer_handle_t* handle, int* stride);
//用于释放指定的图形缓冲区
int (*free)(struct alloc_device_t* dev,buffer_handle_t handle);
void (*dump)(struct alloc_device_t *dev, char *buff, int buff_len);
void* reserved_proc[7];
} alloc_device_t;
Gralloc设备打开过程分析
从上一节数据结构分析的过程中可知，设备打开的方法是在hw_module_t结构中定义的，定义打开的方法为
struct private_module_t HAL_MODULE_INFO_SYM = {
.base = {
.common = {
...
.methods = &gralloc_module_methods
},
....
},
...
};
static struct hw_module_methods_t gralloc_module_methods = {
.open = gralloc_device_open
};
int gralloc_device_open(const hw_module_t* module, const char* name,
hw_device_t** device)
{
int status = -EINVAL;
if (!strcmp(name, GRALLOC_HARDWARE_GPU0)) {
gralloc_context_t *dev;
dev = (gralloc_context_t*)malloc(sizeof(*dev));
/* initialize our state here */
memset(dev, 0, sizeof(*dev));
/* initialize the procs */
dev->device.common.tag = HARDWARE_DEVICE_TAG;
dev->device.common.version = 0;
dev->device.common.module = const_cast(module);
dev->device.common.close = gralloc_close;
dev->device.alloc = gralloc_alloc;
dev->device.free = gralloc_free;
*device = &dev->device.common;
status = 0;
} else {
status = fb_device_open(module, name, device);
}
return status;
}
gralloc_device_open方法用来打开设备
参数hw_module_t为硬件抽象层加载得到的结构体
name 为打开目标设备的类型，分为两种
- 1：GRALLOC_HARDWARE_FB0 "fb0"
打开framebuffer_device_t， 负责将图像缓冲区的内容渲染到帧缓冲区，显示到屏幕上 - 2：GRALLOC_HARDWARE_GPU0 "gpu0"
打开alloc_device_t，负责图像缓冲区的分配和释放
参数hw_device_t为打开的设备保存的结构，返回给调用者
分别分析下打开两种设备的过程
1：打开GRALLOC_HARDWARE_FB0的过程
gralloc_device_open根据参数的不同来打开不同的设备，打开设备GRALLOC_HARDWARE_FB0，调用了fb_device_open方法
struct fb_context_t {
framebuffer_device_t device;
};
int fb_device_open(hw_module_t const* module, const char* name,
hw_device_t** device)
{
int status = -EINVAL;
//判断设备名称是否是GRALLOC_HARDWARE_FB0，如果不是的直接返回打开失败
if (!strcmp(name, GRALLOC_HARDWARE_FB0)) {
//初始化设备framebuffer的上下文结构
fb_context_t *dev = (fb_context_t*)malloc(sizeof(*dev));
memset(dev, 0, sizeof(*dev));
//初始化设备相关的变量
dev->device.common.tag = HARDWARE_DEVICE_TAG;
dev->device.common.version = 0;
dev->device.common.module = const_cast(module);
//初始化fb相关的操作函数
dev->device.common.close = fb_close;
dev->device.setSwapInterval = fb_setSwapInterval;
dev->device.post = fb_post;
dev->device.setUpdateRect = 0;
private_module_t* m = (private_module_t*)module;
//将fb映射到当前进程的地址空间
status = mapFrameBuffer(m);
if (status >= 0) {
int stride = m->finfo.line_length / (m->info.bits_per_pixel >> 3);
int format = (m->info.bits_per_pixel == 32)
? (m->info.red.offset ? HAL_PIXEL_FORMAT_BGRA_8888 : HAL_PIXEL_FORMAT_RGBX_8888)
: HAL_PIXEL_FORMAT_RGB_565;
const_cast(dev->device.flags) = 0;
const_cast(dev->device.width) = m->info.xres;
const_cast(dev->device.height) = m->info.yres;
const_cast(dev->device.stride) = stride;
const_cast(dev->device.format) = format;
const_cast(dev->device.xdpi) = m->xdpi;
const_cast(dev->device.ydpi) = m->ydpi;
const_cast(dev->device.fps) = m->fps;
const_cast(dev->device.minSwapInterval) = 1;
const_cast(dev->device.maxSwapInterval) = 1;
*device = &dev->device.common;
}
}
return status;
}
这个函数创建了一个fb_context_t的数据结构， 并对其进行初始化，fb_context_t的device变量就是framebuffer_device_t，用来描述fb设备的。
同时还注册了操作fb设备的几个函数, 其中fb_post函数比较关键，负责将图形缓冲区的内容渲染到Framebuffer的显存中。
然后使用mapFrameBuffer函数来获取帧缓冲区的信息，然后将信息保存到framebuffer_device_t结构中，并将fb设备映射到当前进程。
再看下mapFrameBuffer做了什么操作？
int mapFrameBufferLocked(struct private_module_t* module)
{
// framebuffer设备已经初始化则直接返回
if (module->framebuffer) {
return 0;
}
//从"/dev/graphics/和/dev/目录查找fb设备，并打开
char const * const device_template[] = {
"/dev/graphics/fb%u",
"/dev/fb%u",
0 };
int fd = -1;
int i=0;
char name[64];
while ((fd==-1) && device_template[i]) {
snprintf(name, 64, device_template[i], 0);
fd = open(name, O_RDWR, 0);
i++;
}
if (fd < 0)
return -errno;
//获取framebuffer设备的不可变的信息
struct fb_fix_screeninfo finfo;
if (ioctl(fd, FBIOGET_FSCREENINFO, &finfo) == -1)
return -errno;
//获取framebuffer设备的可变信息
struct fb_var_screeninfo info;
if (ioctl(fd, FBIOGET_VSCREENINFO, &info) == -1)
return -errno;
info.reserved[0] = 0;
info.reserved[1] = 0;
info.reserved[2] = 0;
info.xoffset = 0;
info.yoffset = 0;
info.activate = FB_ACTIVATE_NOW;
//fb_var_screeninfo的成员变量xres和yres用来描述显示屏的可视分辨率，而成员变量xres_virtual和
yres_virtual用来描述显示屏的虚拟分辨率。
//将虚拟分辨率的高度值设置为可视分辨率的高度值的NUM_BUFFERS倍
//当前声明为双缓存
info.yres_virtual = info.yres * NUM_BUFFERS;
//默认为双缓冲，如果不支持，则移除双缓冲的标志flag
uint32_t flags = PAGE_FLIP;
#if USE_PAN_DISPLAY
if (ioctl(fd, FBIOPAN_DISPLAY, &info) == -1) {
ALOGW("FBIOPAN_DISPLAY failed, page flipping not supported");
#else
if (ioctl(fd, FBIOPUT_VSCREENINFO, &info) == -1) {
ALOGW("FBIOPUT_VSCREENINFO failed, page flipping not supported");
#endif
info.yres_virtual = info.yres;
flags &= ~PAGE_FLIP;
}
if (info.yres_virtual < info.yres * 2) {
// we need at least 2 for page-flipping
info.yres_virtual = info.yres;
flags &= ~PAGE_FLIP;
ALOGW("page flipping not supported (yres_virtual=%d, requested=%d)",
info.yres_virtual, info.yres*2);
}
if (ioctl(fd, FBIOGET_VSCREENINFO, &info) == -1)
return -errno;
//计算屏幕刷新频率
uint64_t refreshQuotient =
(
uint64_t( info.upper_margin + info.lower_margin + info.yres )
* ( info.left_margin + info.right_margin + info.xres )
* info.pixclock
);
/* Beware, info.pixclock might be 0 under emulation, so avoid a
* division-by-0 here (SIGFPE on ARM) */
int refreshRate = refreshQuotient > 0 ? (int)(1000000000000000LLU / refreshQuotient) : 0;
if (refreshRate == 0) {
// bleagh, bad info from the driver
refreshRate = 60*1000; // 60 Hz
}
//计算显示器像素密度
if (int(info.width) <= 0 || int(info.height) <= 0) {
// the driver doesn't return that information
// default to 160 dpi
info.width = ((info.xres * 25.4f)/160.0f + 0.5f);
info.height = ((info.yres * 25.4f)/160.0f + 0.5f);
}
float xdpi = (info.xres * 25.4f) / info.width;
float ydpi = (info.yres * 25.4f) / info.height;
float fps = refreshRate / 1000.0f;
//再次通过IO控制命令FBIOGET_FSCREENINFO来获得系统帧缓冲区的固定信息
if (ioctl(fd, FBIOGET_FSCREENINFO, &finfo) == -1)
return -errno;
if (finfo.smem_len <= 0)
return -errno;
//得到的系统帧缓冲区的其它信息来初始化参数module所描述的一个private_module_t结构体
module->flags = flags;
module->info = info;
module->finfo = finfo;
module->xdpi = xdpi;
module->ydpi = ydpi;
module->fps = fps;
//整个系统帧缓冲区的大小=虚拟分辨率的高度值info.yres_virtual * 每一行所占用的字节数finfo.line_length,并将整个系统帧缓冲区的大小对齐到页面边界
int err;
size_t fbSize = roundUpToPageSize(finfo.line_length * info.yres_virtual);
//创建一个private_handle_t，用来描述整个系统帧缓冲区的信息
module->framebuffer = new private_handle_t(dup(fd), fbSize, 0);
//计算整个系统帧缓冲区可以划分为多少个图形缓冲区来使用
module->numBuffers = info.yres_virtual / info.yres;
//初始化所有缓冲区为空闲状态
module->bufferMask = 0;
//将帧缓冲区映射到当前进程地址空间中
void* vaddr = mmap(0, fbSize, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
if (vaddr == MAP_FAILED) {
ALOGE("Error mapping the framebuffer (%s)", strerror(errno));
return -errno;
}
//系统帧缓冲区在当前进程的地址空间中的起始地址保存到private_handle_t的域base中
module->framebuffer->base = intptr_t(vaddr);
//清空缓冲区的内存空间
memset(vaddr, 0, fbSize);
return 0;
}
mapFrameBuffer函数做了几件事情
1：打开fb设备，获取fb驱动的相关信息
2：设置fb的 yres_virtual为双缓冲大小
3：计算像素密度
4：计算双缓冲大小，并将其映射到当前进程，将缓冲区起始地址宝尊在framebuffer_device_t的base属性中。
至此FB设备打开过程就分析完了，FB设备打开过程做了什么事情？
打开fb设备，根据fb设备初始化相关的显示信息，并把fb设备显存映射到当前进程方便访问，同时还注册了几个操作fb设备的方法。
打开GRALLOC_HARDWARE_GPU0的过程
gralloc设备使用结构体alloc_device_t来描述。结构体alloc_device_t有两个成员函数alloc和free，分别用来分配和释放图形缓冲区。
if (!strcmp(name, GRALLOC_HARDWARE_GPU0)) {
gralloc_context_t *dev;
dev = (gralloc_context_t*)malloc(sizeof(*dev));
/* initialize our state here */
memset(dev, 0, sizeof(*dev));
/* initialize the procs */
dev->device.common.tag = HARDWARE_DEVICE_TAG;
dev->device.common.version = 0;
dev->device.common.module = const_cast(module);
dev->device.common.close = gralloc_close;
dev->device.alloc = gralloc_alloc;
dev->device.free = gralloc_free;
*device = &dev->device.common;
status = 0;
}
首先创建了一个gralloc_context_t的上下文，gralloc_context_t的device就是alloc_device_t, 对其进行初始化 ，同时注册了几个操作alloc_device_t设备的函数， gralloc_alloc和gralloc_free用于分配和释放图形缓冲区。
什么地方打开了这两种设备？
分析了两种设备打开的过程， 但是什么时候会打开这两种设备呢？
1：FB设备打开时机
// Load and prepare the FB HAL, which uses the gralloc module. Sets mFbDev.
int HWComposer::loadFbHalModule()
{
hw_module_t const* module;
int err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module);
if (err != 0) {
ALOGE("%s module not found", GRALLOC_HARDWARE_MODULE_ID);
return err;
}
return framebuffer_open(module, &mFbDev);
}
FB设备打开时机实在HWCompser构造函数中打开的，说明HWCompser会操作fb设备，渲染图像缓冲区到显示缓冲区， 具体在分析HWCompser的时候在进行分析。
2：gralloc设备打开时机
GraphicBufferAllocator::GraphicBufferAllocator()
: mAllocDev(0)
{
hw_module_t const* module;
int err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module);
ALOGE_IF(err, "FATAL: can't find the %s module", GRALLOC_HARDWARE_MODULE_ID);
if (err == 0) {
gralloc_open(module, &mAllocDev);
}
}
gralloc设备用于管理GraphicBuffer图形缓冲区，是在GraphicBufferAllocator中打开的，GraphicBufferAllocator负责图形缓冲区的分配和释放。后续在做详细分析
文章参考：Android图形显示之硬件抽象层Gralloc