老罗带你探索Android世界

5星 · 超过95%的资源需积分: 10 138 浏览量更新于2024-07-22 1 收藏 22.94MB PDF 举报

"老罗的android之旅是一份针对Android学习者的宝贵资料，涵盖了Android的基础和进阶知识，强调了Android在移动平台中的重要地位，并对比了它与iOS的开放与封闭策略。作者指出Android的开放性为其赢得了众多手机厂商的支持，而深入理解Android，就需要掌握Linux Kernel的相关知识。推荐了几本关于Linux Kernel和Android开发的经典书籍，帮助读者系统学习和实践。" 在深入探讨Android之前，我们首先需要理解Android系统的核心特性。Android是一个基于Linux内核的操作系统，但它的开放性并不等同于开源。Android系统允许手机制造商进行定制和优化，以满足不同市场和用户需求，这与苹果iOS的封闭式生态系统形成了鲜明对比。这种开放性使得Android设备多样化，但也带来了一定的碎片化问题。学习Android开发，首先要熟悉Java编程语言，因为Android应用程序主要用Java编写，并在Dalvik虚拟机上运行。此外，由于Android系统是基于Linux内核，因此了解Linux内核的工作原理对于深入理解Android的底层机制至关重要。推荐的《LinuxKernelDevelopment》、《Understanding the LinuxKernel》和《LinuxDeviceDrivers》等书籍可以帮助读者构建坚实的Linux基础知识。当掌握了Linux内核的基本概念后，转向Android平台的具体知识就显得尤为重要。《ProfessionalAndroidApplicationDevelopment》和《GoogleAndroidSDK开发范例大全》这两本书提供了Android应用开发的实战指导，包括Android SDK的使用、UI设计、网络通信、数据存储等关键主题。通过阅读并实践书中的例子，学习者能快速提升Android应用开发技能。在Android的学习旅程中，不仅要有理论知识，还要动手实践。尝试创建简单的应用，逐步升级到复杂的项目，将理论与实践相结合，是成为一名熟练Android开发者的关键步骤。同时，持续关注Android的最新动态，参与社区讨论，不断学习新的API和技术，可以确保你在这个快速发展的领域保持竞争力。 "老罗的android之旅"提供了一个全面的Android学习路径，从选择合适的参考书籍到实践项目，再到跟踪行业动态，都是成为成功Android开发者的必要环节。通过系统学习，你将能够掌握这个开放平台的精髓，开发出创新且有影响力的移动应用。

将这个字节数对齐到4个字节边界，最后得到一行像素所需要的字节数就保存在变量bpr中。

参数h表示要分配的图形缓冲区所保存的图像的高度，将它乘以bpr，就可以得到保存整个图像所需要使用的字节数。

将变量bpr的值除以变量bpp的值，就得到要分配的图形缓冲区一行包含有多少个像素点，这个结果需要保存在输出参

数pStride中，以便可以返回给调用者。

参数usage用来描述要分配的图形缓冲区的用途。如果是用来在系统帧缓冲区中渲染的，即参数usage

的GRALLOC_USAGE_HW_FB位等于1，那么就必须要系统帧缓冲区中分配，否则的话，就在内存中分配。注意，在内存中分配

的图形缓冲区，最终是需要拷贝到系统帧缓冲区去的，以便可以将它所描述的图形渲染出来。

函数gralloc_alloc_framebuffer用来在系统帧缓冲区中分配图形缓冲区，而函数gralloc_alloc_buffer用来在内存在分配图形缓冲区

，接下来我们就分别分析这两个函数的实现。

函数gralloc_alloc_framebuffer实现在文件hardware/libhardware/modules/gralloc/gralloc.cpp中，如下所示：

static int gralloc_alloc_framebuffer(alloc_device_t* dev,

size_t size, int usage, buffer_handle_t* pHandle)

{

private_module_t* m = reinterpret_cast<private_module_t*>(

dev->common.module);

pthread_mutex_lock(&m->lock);

int err = gralloc_alloc_framebuffer_locked(dev, size, usage, pHandle);

pthread_mutex_unlock(&m->lock);

return err;

}

这个函数调用了另外一个函数gralloc_alloc_framebuffer_locked来分配图形缓冲区。

函数gralloc_alloc_framebuffer_locked也是实现在文件hardware/libhardware/modules/gralloc/gralloc.cpp中，如下所示：

static int gralloc_alloc_framebuffer_locked(alloc_device_t* dev,

size_t size, int usage, buffer_handle_t* pHandle)

{

private_module_t* m = reinterpret_cast<private_module_t*>(

dev->common.module);

// allocate the framebuffer

if (m->framebuffer == NULL) {

// initialize the framebuffer, the framebuffer is mapped once

// and forever.

int err = mapFrameBufferLocked(m);

if (err < 0) {

return err;

}

const uint32_t bufferMask = m->bufferMask;

const uint32_t numBuffers = m->numBuffers;

const size_t bufferSize = m->finfo.line_length * m->info.yres;

if (numBuffers == 1) {

// If we have only one buffer, we never use page-flipping. Instead,

// we return a regular buffer which will be memcpy'ed to the main

// screen when post is called.

int newUsage = (usage & ~GRALLOC_USAGE_HW_FB) | GRALLOC_USAGE_HW_2D;

return gralloc_alloc_buffer(dev, bufferSize, newUsage, pHandle);

}

if (bufferMask >= ((1LU<<numBuffers)-1)) {

// We ran out of buffers.

return -ENOMEM;

}

// create a "fake" handles for it

intptr_t vaddr = intptr_t(m->framebuffer->base);

private_handle_t* hnd = new private_handle_t(dup(m->framebuffer->fd), size,

private_handle_t::PRIV_FLAGS_FRAMEBUFFER);

// find a free slot

for (uint32_t i=0 ; i<numBuffers ; i++) {

if ((bufferMask & (1LU<<i)) == 0) {

m->bufferMask |= (1LU<<i);

break;

}

vaddr += bufferSize;

}

hnd->base = vaddr;

hnd->offset = vaddr - intptr_t(m->framebuffer->base);

*pHandle = hnd;

return 0;

}

在系统帧缓冲区分配图形缓冲区之前，首先要对系统帧缓冲区进行过初始化，即这里的变量m所指向的一个private_module_t结

构体的成员变量framebuffer的值不能等于NULL。如果等于NULL的话，那么就必须要调用另外一个函数mapFrameBufferLocked来

初始化系统帧缓冲区。初始化系统帧缓冲区的过程可以参考前面第3部分的内容。

变量bufferMask用来描述系统帧缓冲区的使用情况，而变量numBuffers用来描述系统帧缓冲区可以划分为多少个图形缓冲区来

使用，另外一个变量bufferSize用来描述设备显示屏一屏内容所占用的内存的大小。

如果系统帧缓冲区只有一个图形缓冲区大小，即变量numBuffers的值等于1，那么这个图形缓冲区就始终用作系统主图形缓冲

区来使用。在这种情况下，我们就不能够在系统帧缓冲区中分配图形缓冲区来给用户空间的应用程序使用，因此，这时候就会转向

内存中来分配图形缓冲区，即调用函数gralloc_alloc_buffer来分配图形缓冲区。注意，这时候分配的图形缓冲区的大小为一屏内容

的大小，即bufferSize。

如果bufferMask的值大于等于((1LU<<numBuffers)-1)的值，那么就说明系统帧缓冲区中的图形缓冲区全部都分配出去了，这时

候分配图形缓冲区就失败了。例如，假设图形缓冲区的个数为2，那么((1LU<<numBuffers)-1)的值就等于3，即二制制0x11。如果这

时候bufferMask的值也等于0x11，那么就表示第一个和第二个图形缓冲区都已经分配出去了。因此，这时候就不能再在系统帧缓冲

区中分配图形缓冲区。

假设此时系统帧缓冲区中尚有空闲的图形缓冲区的，接下来函数就会创建一个private_handle_t结构体hnd来描述这个即将要分

配出去的图形缓冲区。注意，这个图形缓冲区的标志值等于PRIV_FLAGS_FRAMEBUFFER，即表示这是一块在系统帧缓冲区中分

配的图形缓冲区。

接下来的for循环从低位到高位检查变量bufferMask的值，并且找到第一个值等于0的位，这样就可以知道在系统帧缓冲区中，第

几个图形缓冲区的是空闲的。注意，变量vadrr的值开始的时候指向系统帧缓冲区的基地址，在下面的for循环中，每循环一次它的值

都会增加bufferSize。从这里就可以看出，每次从系统帧缓冲区中分配出去的图形缓冲区的大小都是刚好等于显示屏一屏内容大小的

。

最后分配出去的图形缓冲区的开始地址就保存在前面所创建的private_handle_t结构体hnd的成员变量base中，这样，用户空间

的应用程序就可以直接将要渲染的图形内容拷贝到这个地址上去，这就相当于是直接将图形渲染到系统帧缓冲区中去。

在将private_handle_t结构体hnd返回给调用者之前，还需要设置它的成员变量offset，以便可以知道它所描述的图形缓冲区的起

始地址相对于系统帧缓冲区的基地址的偏移量。

至此，在系统帧缓冲区中分配图形缓冲区的过程就分析完成了，接下来我们再分析在内存在分析图形缓冲区的过程，即分析函

数gralloc_alloc_buffer的实现。

函数gralloc_alloc_buffer也是实现在文件hardware/libhardware/modules/gralloc/gralloc.cpp中，如下所示：

static int gralloc_alloc_buffer(alloc_device_t* dev,

size_t size, int usage, buffer_handle_t* pHandle)

{

int err = 0;

int fd = -1;

size = roundUpToPageSize(size);

fd = ashmem_create_region("gralloc-buffer", size);

if (fd < 0) {

LOGE("couldn't create ashmem (%s)", strerror(-errno));

err = -errno;

}

if (err == 0) {

private_handle_t* hnd = new private_handle_t(fd, size, 0);

gralloc_module_t* module = reinterpret_cast<gralloc_module_t*>(

dev->common.module);

err = mapBuffer(module, hnd);

if (err == 0) {

*pHandle = hnd;

}

LOGE_IF(err, "gralloc failed err=%s", strerror(-err));

return err;

}

这个函数的实现很简单，它首先调用函数ashmem_create_region来创建一块匿名共享内存，接着再在这块匿名共享内存上分配

一个图形缓冲区。注意，这个图形缓冲区也是使用一个private_handle_t结构体来描述的，不过这个图形缓冲区的标志值等于0，以

区别于在系统帧缓冲区中分配的图形缓冲区。匿名共享内存的相关知识，可以参考前面Android系统匿名共享内

存Ashmem（Anonymous Shared Memory）简要介绍和学习计划一文，以及Android系统匿名共享内存（Anonymous Shared

Memory）C++调用接口分析这篇文章。

从匿名共享内存中分配的图形缓冲区还需要映射到进程的地址空间来，然后才可以使用，这是通过调用函数mapBuffer来实

现的。

函数mapBuffer实现在文件hardware/libhardware/modules/gralloc/mapper.cpp中，如下所示：

int mapBuffer(gralloc_module_t const* module,

private_handle_t* hnd)

{

void* vaddr;

return gralloc_map(module, hnd, &vaddr);

}

它通过调用另外一个函数gralloc_map来将参数hnd所描述的一个图形缓冲区映射到当前进程的地址空间来。后面在分析图形缓

冲区的注册过程时，我们再分析函数gralloc_map的实现。

注意，在Android系统中，在系统帧缓冲区中分配的图形缓冲区是在SurfaceFlinger服务中使用的，而在内存中分配的图形缓冲

区既可以在SurfaceFlinger服务中使用，也可以在其它的应用程序中使用。当其它的应用程序需要使用图形缓冲区的时候，它们就会

请求SurfaceFlinger服务为它们分配，因此，对于其它的应用程序来说，它们只需要将SurfaceFlinger服务返回来的图形缓冲区映射

到自己的进程地址空间来使用就可以了，这就是后面我们所要分析的图形缓冲区的注册过程。

至此，图形缓冲区的分配过程就分析完成了，接下来我们继续分析图形缓冲区的释放过程。

5. 图形缓冲区的释放过程

前面提到，用户空间的应用程序用到的图形缓冲区是由Gralloc模块中的函数gralloc_free来释放的，这个函数实现在文

件hardware/libhardware/modules/gralloc/gralloc.cpp中，如下所示：

static int gralloc_free(alloc_device_t* dev,

buffer_handle_t handle)

{

if (private_handle_t::validate(handle) < 0)

return -EINVAL;

private_handle_t const* hnd = reinterpret_cast<private_handle_t const*>(handle);

if (hnd->flags & private_handle_t::PRIV_FLAGS_FRAMEBUFFER) {

// free this buffer

private_module_t* m = reinterpret_cast<private_module_t*>(

dev->common.module);

const size_t bufferSize = m->finfo.line_length * m->info.yres;

int index = (hnd->base - m->framebuffer->base) / bufferSize;

m->bufferMask &= ~(1<<index);

} else {

gralloc_module_t* module = reinterpret_cast<gralloc_module_t*>(

dev->common.module);

terminateBuffer(module, const_cast<private_handle_t*>(hnd));

}

close(hnd->fd);

delete hnd;

return 0;

}

要释放的图形缓冲区使用参数handle来描述。前面提到，从Gralloc模块中分配的图形缓冲区是使用private_handle_t结构体来描

述的，因此，这里的参数handle应该指向一个private_handle_t结构体，这是通过调用private_handle_t类的静态成员函数validate来

验证的。private_handle_t类的静态成员函数validate的实现可以参考前面第1部分的内容。

要释放的图形缓冲区有可能是在系统帧缓冲区分配的，也有可能是在内存中分配的，这可以通过检查它的标志值flags

的PRIV_FLAGS_FRAMEBUFFER位是否等于1来确认。

如果要释放的图形缓冲区是在系统帧缓冲区中分配的，那么首先要知道这个图形缓冲区是系统帧缓冲区的第index个位置，接着

再将变量m所描述的一个private_module_t结构体的成员变量bufferMask的第index位重置为0即可。我们只需要将要释放的图形缓冲

区的开始地址减去系统帧缓冲区的基地址，再除以一个图形缓冲区的大小，就可以知道要释放的图形缓冲区是系统帧缓冲区的第几

个位置。这个过程刚好是在系统帧缓冲区中分配图形缓冲区的逆操作。

如果要释放的图形缓冲区是内存中分配的，那么只需要调用另外一个函数terminateBuffer来解除要释放的图形缓冲区在当前进

程的地址空间中的映射。

最后，这个函数还会将用来描述要释放的图形缓冲区的private_handle_t结构体所占用的内存释放掉，并且将要要释放的图形缓

冲区所在的系统帧缓冲区或者匿名共享内存的文件描述符关闭掉。

函数terminateBuffer实现在文件hardware/libhardware/modules/gralloc/mapper.cpp中，如下所示：

int terminateBuffer(gralloc_module_t const* module,

private_handle_t* hnd)

{

if (hnd->base) {

// this buffer was mapped, unmap it now

gralloc_unmap(module, hnd);

}

return 0;

}

它通过调用另外一个函数gralloc_unmap来解除参数hnd所描述的一个图形缓冲区在当前进程的地址空间中的映射。后面在分析

图形缓冲区的注销过程时，我们再详细分析函数gralloc_unmap的实现。

至此，图形缓冲区的释放过程就分析完成了，接下来我们继续分析图形缓冲区的注册过程。

6. 图形缓冲区的注册过程

前面提到，在Android系统中，所有的图形缓冲区都是由SurfaceFlinger服务分配的，而当一个图形缓冲区被分配的时候，它会

同时被映射到请求分配的进程的地址空间去，即分配的过程同时也包含了注册的过程。但是对用户空间的其它的应用程序来说，它

们所需要的图形缓冲区是在由SurfaceFlinger服务分配的，因此，当它们得到SurfaceFlinger服务分配的图形缓冲区之后，还需要将

这块图形缓冲区映射到自己的地址空间来，以便可以使用这块图形缓冲区。这个映射的过程即为我们接下来要分析的图形缓冲区注

册过程。

前面还提到，注册图形缓冲区的操作是由Gralloc模块中的函数gralloc_register_buffer来实现的，这个函数实现在文

件hardware/libhardware/modules/gralloc/mapper.cpp中，如下所示：

int gralloc_register_buffer(gralloc_module_t const* module,

buffer_handle_t handle)

{

if (private_handle_t::validate(handle) < 0)

return -EINVAL;

// if this handle was created in this process, then we keep it as is.

int err = 0;

private_handle_t* hnd = (private_handle_t*)handle;

if (hnd->pid != getpid()) {

void *vaddr;

err = gralloc_map(module, handle, &vaddr);

}

return err;

}

这个函数首先验证参数handle指向的一块图形缓冲区的确是由Gralloc模块分配的，方法是调用private_handle_t类的静态成员函

数validate来验证，即如果参数handle指向的是一个private_handle_t结构体，那么它所指向的一块图形缓冲区就是由Gralloc模块分

配的。

通过了上面的检查之后，函数gralloc_register_buffer还需要检查当前进程是否就是请求Gralloc模块分配图形缓冲区hnd的进程。

如果是的话，那么当前进程在请求Gralloc模块分配图形缓冲区hnd的时候，就已经将图形缓冲区hnd映射进自己的地址空间来了，

因此，这时候就不需要重复在当前进程中注册这个图形缓冲区。

真正执行注册图形缓冲区的操作是由函数gralloc_map来实现的，这个函数也是实现文

件hardware/libhardware/modules/gralloc/mapper.cpp中，如下所示：

static int gralloc_map(gralloc_module_t const* module,

buffer_handle_t handle,

void** vaddr)

{

private_handle_t* hnd = (private_handle_t*)handle;

if (!(hnd->flags & private_handle_t::PRIV_FLAGS_FRAMEBUFFER)) {

size_t size = hnd->size;

void* mappedAddress = mmap(0, size,

PROT_READ|PROT_WRITE, MAP_SHARED, hnd->fd, 0);

if (mappedAddress == MAP_FAILED) {

LOGE("Could not mmap %s", strerror(errno));

return -errno;

}

hnd->base = intptr_t(mappedAddress) + hnd->offset;

//LOGD("gralloc_map() succeeded fd=%d, off=%d, size=%d, vaddr=%p",

// hnd->fd, hnd->offset, hnd->size, mappedAddress);

}

*vaddr = (void*)hnd->base;

return 0;

}

由于在系统帧缓冲区中分配的图形缓冲区只在SurfaceFlinger服务中使用，而SurfaceFlinger服务在初始化系统帧缓冲区的时候

，已经将系统帧缓冲区映射到自己所在的进程中来了，因此，函数gralloc_map如果发现要注册的图形缓冲区是在系统帧缓冲区分配

的时候，那么就不需要再执行映射图形缓冲区的操作了。

如果要注册的图形缓冲区是在内存中分配的，即它的标志值flags的PRIV_FLAGS_FRAMEBUFFER位等于1，那么接下来就需

要将它映射到当前进程的地址空间来了。由于要注册的图形缓冲区是在文件描述符hnd->fd所描述的一块匿名共享内存中分配的，

因此，我们只需要将文件描述符hnd->fd所描述的一块匿名共享内存映射到当前进程的地址空间来，就可以将参数hnd所描述的一个

图形缓冲区映射到当前进程的地址空间来。

由于映射文件描述符hnd->fd得到的是一整块匿名共享内存在当前进程地址空间的基地址，而要注册的图形缓冲区可能只占据这

块匿名共享内存的某一小部分，因此，我们还需要将要注册的图形缓冲区的在被映射的匿名共享内存中的偏移量hnd->offset加上被

映射的匿名共享内存的基地址hnd->base，才可以得到要注册的图形缓冲区在当前进程中的访问地址，这个地址最终又被写入

到hnd->base中去。

注册图形缓冲区的过程就是这么简单，接下来我们再分析图形缓冲区的注销过程。

7. 图形缓冲区的注销过程

图形缓冲区使用完成之后，就需要从当前进程中注销。前面提到，注销图形缓冲区是由Gralloc模块中的函

数gralloc_unregister_buffer来实现的，这个函数实现在文件hardware/libhardware/modules/gralloc/mapper.cpp中，如下所示：

int gralloc_unregister_buffer(gralloc_module_t const* module,

buffer_handle_t handle)

{

if (private_handle_t::validate(handle) < 0)

return -EINVAL;

// never unmap buffers that were created in this process

private_handle_t* hnd = (private_handle_t*)handle;

if (hnd->pid != getpid()) {

if (hnd->base) {

gralloc_unmap(module, handle);

}

return 0;

}

这个函数同样是首先调用private_handle_t类的静态成员函数validate来验证参数handle指向的一块图形缓冲区的确是由Gralloc

模块分配的，接着再将将参数handle指向的一块图形缓冲区转换为一个private_handle_t结构体hnd来访问。

一块图形缓冲区只有被注册过，即被Gralloc模块中的函数gralloc_register_buffer注册过，才需要注销，而由函

数gralloc_register_buffer注册的图形缓冲区都不是由当前进程分配的，因此，当前进程在注销一个图形缓冲区的时候，会检查要注

销的图形缓冲区是否是由自己分配的。如果是由自己分配的话，那么它什么也不做就返回了。

假设要注销的图形缓冲区hnd不是由当前进程分配的，那么接下来就会调用另外一个函数galloc_unmap来注销图形缓冲区hnd。

函数galloc_unmap也是实现在文件hardware/libhardware/modules/gralloc/mapper.cpp中，如下所示：

static int gralloc_unmap(gralloc_module_t const* module,

buffer_handle_t handle)

{

private_handle_t* hnd = (private_handle_t*)handle;

if (!(hnd->flags & private_handle_t::PRIV_FLAGS_FRAMEBUFFER)) {

void* base = (void*)hnd->base;

size_t size = hnd->size;

//LOGD("unmapping from %p, size=%d", base, size);

if (munmap(base, size) < 0) {

LOGE("Could not unmap %s", strerror(errno));

}

hnd->base = 0;

return 0;

}

这个函数的实现与前面所分析的函数gralloc_map的实现是类似的，只不过它执行的是相反的操作，即将解除一个指定的图形缓

冲区在当前进程的地址空间中的映射，从而完成对这个图形缓冲区的注销工作。

这样，图形缓冲区的注销过程就分析完成了，接下来我们再继续分析一个图形缓冲区是如何被渲染到系统帧缓冲区去的，即它

的内容是如何绘制在设备显示屏中的。

8. 图形缓冲区的渲染过程

用户空间的应用程序将画面内容写入到图形缓冲区中去之后，还需要将图形缓冲区渲染到系统帧缓冲区中去，这样才可以把画

面绘制到设备显示屏中去。前面提到，渲染图形缓冲区是由Gralloc模块中的函数fb_post来实现的，这个函数实现在文

件hardware/libhardware/modules/gralloc/framebuffer.cpp中，如下所示：

static int fb_post(struct framebuffer_device_t* dev, buffer_handle_t buffer)

{

if (private_handle_t::validate(buffer) < 0)

return -EINVAL;

fb_context_t* ctx = (fb_context_t*)dev;

private_handle_t const* hnd = reinterpret_cast<private_handle_t const*>(buffer);

private_module_t* m = reinterpret_cast<private_module_t*>(

dev->common.module);

if (hnd->flags & private_handle_t::PRIV_FLAGS_FRAMEBUFFER) {

const size_t offset = hnd->base - m->framebuffer->base;

m->info.activate = FB_ACTIVATE_VBL;

m->info.yoffset = offset / m->finfo.line_length;

if (ioctl(m->framebuffer->fd, FBIOPUT_VSCREENINFO, &m->info) == -1) {

LOGE("FBIOPUT_VSCREENINFO failed");

m->base.unlock(&m->base, buffer);

return -errno;

}

m->currentBuffer = buffer;

剩余949页未读，继续阅读

eshuihanbing

粉丝: 0
资源: 2

老罗带你探索Android世界

人气专家】老罗的Android之旅.

老罗的Android之旅

老罗Android之旅课件.zip

Android studio sha1

输入格式: 输入三个正整数代表大杯，中杯和小杯的价格。 输出格式: 输出老罗的选择，是大杯输出big，小杯输出small，同时输出与中杯的差价的绝对值，空格隔开。（假设大杯和小杯与中杯的差价的绝对值不相同）

给我推荐几个电子领域的博主

金典的老罗的android之旅

老罗的Android之旅系列导读PPT课件（全集）

老罗的Android之旅（罗升阳）导读PPT合集.zip

老罗的android之旅时序图

最新资源

输入格式: 输入三个正整数代表大杯，中杯和小杯的价格。输出格式: 输出老罗的选择，是大杯输出big，小杯输出small，同时输出与中杯的差价的绝对值，空格隔开。（假设大杯和小杯与中杯的差价的绝对值不相同）