Android4.0 Surface机制分析

1. java层面的Surface

对于Surface我们的认识主要是android的类Surface, android的文档描述Surface是“Handle onto a raw buffer that is being managed by the screen compositor”，这个描述透漏出两个信息：首先，Surface是一个raw buffer的句柄，通过它去管理一个raw buffer，其次，Surface本身是由screen compositor来管理的。但是raw buffer具体是什么，screen compositor又是什么，Surface是如何管理一个raw buffer，而它又是怎样被compositor来管理，后续我们会具体来分析。

Surface的具体使用上，我们通常并不直接去手动创建一个Surface，尽管可以这么做，通常，我们是通过SurfaceView，GLSurfaceView间接地去创建Surface，当然，更多的时候我们在使用Surface而不自知，在Andorid的窗口实现里，每一个Window其实都会对应一个Surface，而每个Activity都会持有一个Window，所以，我们通常在Activity里设置的view（通过setContentView），从java抽象上看其最终的绘制目标就是在Surface上。(Window以及view本身的结构也比较复杂，我会在后面的文章里再讨论这个部分。)

下面我们来看看Surface的接口都有什么，除了重要的构造函数外，比较重要的两个接口，lockCanvas, unlockCanvasAndPost. lockCanvas会返回一个Canvas给我们，我们可以使用这个Canvas来改变Surface的内容，但是这个改变不会立刻生效，只有在我们调用了unlockCanvasAndPost之后，改变才会生效。

上面说了，通常我们并不手动去创建Surface，帮我们创建Surface的是WindowManagerService，它在帮我们创建Surface时，会生成一个SurfaceSession，然后将这个SurfaceSession作为参数来构造Surface。SurfaceSession，其代表的是与前面说的compositor的一个会话连接。

2. 一些重要的类及关系介绍

在开始介绍cpp层面的Surface工作流程之前，我们先简要的介绍几个比较重要的类，因为Surface的机制抽象层级比较多，对基本类的功能有一个初步了解有助于我们更容易理解。

首先，需要说明的是，java层的Surface与cpp层的Surface并不相同，他们之间存在着关系，但并不是同一个抽象. 而cpp层里Surface与ISurface又是不同的抽象，切忌混为一谈。

我们知道，在android里大量的使用了CS模式，把一些功能做成服务Service，供各个客户端Client访问，而Client，Service都具有相同的接口，这样抽象掉了Client，Service之间的通信，让Client，Service各自独立，消除耦合。对于Surface部分来说，Android的framework里主要涉及到以下的几个接口：

SurfaceFinger：这个是Surface服务端的总管家，它具体是ISurfaceComposer接口的服务端实现。

ComposerService：这个是为客户端取得ISurfaceComposer代理而提供的方便类。

ISurfaceComposer：通过这个接口可以访问到SurfaceFlinger，可以通过它建立一个会话，即ISurfaceComposerClient，也可以通过它去更新Surface的相关信息，这个是通过setTransactionState接口完成的。

SurfaceFlinger::Client： ISurfaceComposerClient的服务端实现。

SurfaceComposerClient: 持有ISurfaceComposerClient的客户端代理，在SurfaceComposerClient初次实例化时，通过ISurfaceComposer的createConnection()接口得到一个ISurfaceComposerClient的代理。同时，它也会管理Surface的状态，通过ISurfaceComposer更新Surface状态，状态的具体保存涉及到一个相关类Composer。可以说，它是Surface跟服务端打交道一个非常重要的接口。

ISurfaceComposerClient：代表一个到SurfaceFinger的会话连接。

SurfaceControl：从字面上看，其作用是控制Surface。其实际作用是持有ISurface的代理及SurfaceComposerClient

ISurfaceTexture：其对应具体的buffer管理

SurfaceTextureClient: 持有ISurfaceTexture的本地代理，通过它可以访问到ISurfaceTexture的实现。同时，特别注意的是，它继承了ANativeWindow，而Surface类会继承SurfaceTextureClient. ANativeWindow代表的是本地窗口，在创建EGL的eglSurface时需要用到它。

3. cpp层面的Surface

从前面的图中可见，在Surface及SurfaceSession的构造过程中，都会调用到各自的init方法，而init的具体实现是在cpp层，具体对framework/base/core/jni/android_view_Surface.java.

我们来看看这两个init的代码：

static void SurfaceSession_init(JNIEnv* env, jobject clazz)

    sp<SurfaceComposerClient> client = new SurfaceComposerClient;

    client->incStrong(clazz);

    env->SetIntField(clazz, sso.client, (int)client.get());

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }

SurfaceSession的init方法SurfaceSession_init主要是获取到一个SurfaceComposerClient，这个类是非常重要的与服务端通讯的类，它的作用：

通过在构造函数里使用ISurfaceComposer的createConnection接口，它获得ISurfaceComposerClient的本地代理
通过得到的ISurfaceComposerClient创建或销毁ISurface
通过它持有的Composer来记录Surface的状态，并在Composer里通过ISurfaceComposer接口更新状态。

static void Surface_init(

        JNIEnv* env, jobject clazz,

        jobject session,

        jint, jstring jname, jint dpy, jint w, jint h, jint format, jint flags)

    if (session == NULL) {

        doThrowNPE(env);

        return;

    SurfaceComposerClient* client =

            (SurfaceComposerClient*)env->GetIntField(session, sso.client);

    sp<SurfaceControl> surface;

    if (jname == NULL) {

        surface = client->createSurface(dpy, w, h, format, flags);

    } else {

        const jchar* str = env->GetStringCritical(jname, 0);

        const String8 name(str, env->GetStringLength(jname));

        env->ReleaseStringCritical(jname, str);

        surface = client->createSurface(name, dpy, w, h, format, flags);

    if (surface == 0) {

        jniThrowException(env, OutOfResourcesException, NULL);

        return;

    setSurfaceControl(env, clazz, surface);

sp<SurfaceControl> SurfaceComposerClient::createSurface(

        const String8& name,

        DisplayID display,

        uint32_t w,

        uint32_t h,

        PixelFormat format,

        uint32_t flags)

    sp<SurfaceControl> result;

    if (mStatus == NO_ERROR) {

        ISurfaceComposerClient::surface_data_t data;

        sp<ISurface> surface = mClient->createSurface(&data, name,

                display, w, h, format, flags);

        if (surface != 0) {

            result = new SurfaceControl(this, surface, data);

    return result;

sp<Surface> SurfaceControl::getSurface() const

    Mutex::Autolock _l(mLock);

    if (mSurfaceData == 0) {

        sp<SurfaceControl> surface_control(const_cast<SurfaceControl*>(this));

        mSurfaceData = new Surface(surface_control);

    return mSurfaceData;

而Surface_init主要是通过SurfaceComposerClient获取了一个sp<SurfaceControl>，SurfaceControl是对ISurface及Surface的一层封装，其需要注意的地方是：

通过构造SurfaceControl时传入ISurface，其持有ISurface接口
它的getSurface方法可以构造一个Surface对象，并通过mSurfaceData持有Surface对象
它可以通过SurfaceComposerClient去更改Surface的状态

通过上面的分析我们得到了两个Surface，sp<ISurface>, sp<Surface>，前者，我们知道是ISurface的本地代理，但是Surface是做什么的呢，我们下面将具体分析Surface。

4. Surface对象

前面我们提到SurfaceControl的getSurface方法会构造一个Surface对象，事实上，Surface是我们Android GUI系统的核心部分，我们来看看代码：

Surface::Surface(const sp<SurfaceControl>& surface)

    : SurfaceTextureClient(),

      mSurface(surface->mSurface),

      mIdentity(surface->mIdentity)

    sp<ISurfaceTexture> st;

    if (mSurface != NULL) {

        st = mSurface->getSurfaceTexture();

    init(st);

void Surface::init(const sp<ISurfaceTexture>& surfaceTexture)

    if (mSurface != NULL || surfaceTexture != NULL) {

        LOGE_IF(surfaceTexture==0, "got a NULL ISurfaceTexture from ISurface");

        if (surfaceTexture != NULL) {

            setISurfaceTexture(surfaceTexture);

            setUsage(GraphicBuffer::USAGE_HW_RENDER);

        DisplayInfo dinfo;

        SurfaceComposerClient::getDisplayInfo(0, &dinfo);

        const_cast<float&>(ANativeWindow::xdpi) = dinfo.xdpi;

        const_cast<float&>(ANativeWindow::ydpi) = dinfo.ydpi;

        const_cast<uint32_t&>(ANativeWindow::flags) = 0;

可以看到，在构造函数里，通过ISurface接口的getSurfaceTexture，我们得到一个ISurfaceTexture的本地代理，在init里我们保存了该代理，即SurfaceTextureClient将持有ISurfaceTextureClient。

我们第一节里说java层面的Surface有两个接口，lockCanvas，unlockCanvasAndPost，我们来看看其底层实现是怎样的

   const sp<Surface>& surface(getSurface(env, clazz));

      ........................................

   status_t err = surface->lock(&info, &dirtyRegion);

static void Surface_unlockCanvasAndPost(

        JNIEnv* env, jobject clazz, jobject argCanvas)

    jobject canvas = env->GetObjectField(clazz, so.canvas);

    if (env->IsSameObject(canvas, argCanvas) == JNI_FALSE) {

        doThrowIAE(env);

        return;

    const sp<Surface>& surface(getSurface(env, clazz));

    if (!Surface::isValid(surface))

        return;

    // detach the canvas from the surface

    SkCanvas* nativeCanvas = (SkCanvas*)env->GetIntField(canvas, no.native_canvas);

    int saveCount = env->GetIntField(clazz, so.saveCount);

    nativeCanvas->restoreToCount(saveCount);

    nativeCanvas->setBitmapDevice(SkBitmap());

    env->SetIntField(clazz, so.saveCount, 0);

    // unlock surface

    status_t err = surface->unlockAndPost();

    if (err < 0) {

        doThrowIAE(env);

可以看到，lockCanvas最终会调用到Surface的lock方法，而unlockCanvasAndPost最终调用到Surface的Surface的unlockAndPost，前面说到lockCanvas会返回一个Canvas供我们绘制使用，这个Canvas其实是利用lock得到的缓冲区来构建的。我们下面来分析。

首先，我们说Surface是一个ANativeWindow，它的继承关系如下：

ANativeWindow我们前面说过，它其实是一个EGL可以操作的窗口，其具体定义在system/core/include/system/window.h里，它的主要接口有dequeueBuffer，queueBuffer，lockBuffer等。

好了，搞清楚Surface是个什么东西，下面来看其lock及unlockAndPost方法：

status_t Surface::lock(SurfaceInfo* other, Region* inOutDirtyRegion) {

    ANativeWindow_Buffer outBuffer;

    ARect temp;

    ARect* inOutDirtyBounds = NULL;

    if (inOutDirtyRegion) {

        temp = inOutDirtyRegion->getBounds();

        inOutDirtyBounds = &temp;

    status_t err = SurfaceTextureClient::lock(&outBuffer, inOutDirtyBounds);

    if (err == NO_ERROR) {

        other->w = uint32_t(outBuffer.width);

        other->h = uint32_t(outBuffer.height);

        other->s = uint32_t(outBuffer.stride);

        other->usage = GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN;

        other->format = uint32_t(outBuffer.format);

        other->bits = outBuffer.bits;

    if (inOutDirtyRegion) {

        inOutDirtyRegion->set( static_cast<Rect const&>(temp) );

    return err;

status_t Surface::unlockAndPost() {

    return SurfaceTextureClient::unlockAndPost();

这两个方法都会调用到SurfaceTextureClient里的相应方法，代码这里就不贴了，lock的实现主要是dequeueBuffer出一个GraphicBuffer，而unlockAndPost主要是将这个GraphicBuffer入队queueBuffer。我们来看看SurfaceTextureClient的dequeueBuffer及queueBuffer实现：

int SurfaceTextureClient::dequeueBuffer(android_native_buffer_t** buffer) {

    LOGV("SurfaceTextureClient::dequeueBuffer");

    Mutex::Autolock lock(mMutex);

    int buf = -1;

    status_t result = mSurfaceTexture->dequeueBuffer(&buf, mReqWidth, mReqHeight,

            mReqFormat, mReqUsage);

    if (result < 0) {

        LOGV("dequeueBuffer: ISurfaceTexture::dequeueBuffer(%d, %d, %d, %d)"

             "failed: %d", mReqWidth, mReqHeight, mReqFormat, mReqUsage,

             result);

        return result;

    sp<GraphicBuffer>& gbuf(mSlots[buf]);

    if (result & ISurfaceTexture::RELEASE_ALL_BUFFERS) {

        freeAllBuffers();

    if ((result & ISurfaceTexture::BUFFER_NEEDS_REALLOCATION) || gbuf == 0) {

        result = mSurfaceTexture->requestBuffer(buf, &gbuf);

        if (result != NO_ERROR) {

            LOGE("dequeueBuffer: ISurfaceTexture::requestBuffer failed: %d",

                    result);

            return result;

    *buffer = gbuf.get();

    return OK;

int SurfaceTextureClient::queueBuffer(android_native_buffer_t* buffer) {

    LOGV("SurfaceTextureClient::queueBuffer");

    Mutex::Autolock lock(mMutex);

    int64_t timestamp;

    if (mTimestamp == NATIVE_WINDOW_TIMESTAMP_AUTO) {

        timestamp = systemTime(SYSTEM_TIME_MONOTONIC);

        LOGV("SurfaceTextureClient::queueBuffer making up timestamp: %.2f ms",

             timestamp / 1000000.f);

    } else {

        timestamp = mTimestamp;

    int i = getSlotFromBufferLocked(buffer);

    if (i < 0) {

        return i;

    status_t err = mSurfaceTexture->queueBuffer(i, timestamp,

            &mDefaultWidth, &mDefaultHeight, &mTransformHint);

    if (err != OK)  {

        LOGE("queueBuffer: error queuing buffer to SurfaceTexture, %d", err);

    return err;

我们可以看到，SurfaceTexture会利用持有的ISurfaceTextureClient接口去得到或入队GraphicBuffer。

我们前面也说过，Surface是一个ANativeWindow，而ANatvieWidnow是一个EGL可以操作的窗口，所以除了在java层显式调用lockCanvas方法可以操作Surface外，openGL ES通过EGL也能操作Surface。

5. GraphicBuffer

在具体分析之前，我们先来看一个ANativeWindow的dequeueBuffer以及queueBuffer原型：

    int     (*dequeueBuffer)(struct ANativeWindow* window,

                struct ANativeWindowBuffer** buffer);

    int     (*queueBuffer)(struct ANativeWindow* window,

                struct ANativeWindowBuffer* buffer);

ANativeWindow我们前面说过了，ANativeWindowBuffer我们还没有提及。我们本节讲的GraphicBuffer正是一个ANativeWindowBuffer，从前面我们看到，GraphicBuffer是需要通过ISurfaceTexture接口在客户端及服务端来传递的，所以其需要实现Flattenable接口。

GraphicBuffer实际的存储空间其实是在ashmem上的，具体是gralloc模块来完成分配的，然后映射到应用程序的进程地址空间。因为这部分涉及到底层设备部分，这里就不在分析。

参考文章：

http://www.linuxidc.com/Linux/2012-03/55898p7.htm

Android4.0 Surface机制分析的更多相关文章

Android4.0窗口机制和创建过程分析
一前言在谈到这个话题的时候,脑海里面千头万绪,因为它涉及到了方方面面的知识… 比如Activity管理,窗口添加,Token权限验证等等… 既然这么复杂,那么我们就复杂的问题简单化,可以分成下面 ...
Android系统Surface机制的SurfaceFlinger服务的线程模型分析
文章转载至CSDN社区罗升阳的安卓之旅,原文地址:http://blog.csdn.net/luoshengyang/article/details/8062945 在前面两篇文章中,我们分析了Sur ...
Android系统Surface机制的SurfaceFlinger服务对帧缓冲区（Frame Buffer）的管理分析
文章转载至CSDN社区罗升阳的安卓之旅,原文地址:http://blog.csdn.net/luoshengyang/article/details/8046659 在前文中,我们分析了Surface ...
Solr4.8.0源码分析(19)之缓存机制(二)
Solr4.8.0源码分析(19)之缓存机制(二) 前文<Solr4.8.0源码分析(18)之缓存机制(一)>介绍了Solr缓存的生命周期,重点介绍了Solr缓存的warn过程.本节将更深 ...
Solr4.8.0源码分析(18)之缓存机制(一)
Solr4.8.0源码分析(18)之缓存机制(一) 前文在介绍commit的时候具体介绍了getSearcher()的实现,并提到了Solr的预热warn.那么本文开始将详细来学习下Solr的缓存机制 ...
Android4.0中蓝牙适配器state machine（状态机）的分析
今天晓东和大家来一起看一下Android4.0中蓝牙适配器(Bluetooth Adapter)的状态机变化的过程.首先,我们需要了解一下,蓝牙适配器究竟有哪些状态,从代码可以清晰地看到(framew ...
Android4.0图库Gallery2代码分析(二) 数据管理和数据加载
Android4.0图库Gallery2代码分析(二) 数据管理和数据加载 2012-09-07 11:19 8152人阅读评论(12) 收藏举报代码分析android相册优化工作 Androi ...
Android4.0图库Gallery2代码分析(一) 程序整体结构
Android4.0图库Gallery2代码分析(一) 程序整体结构 Gallery2的用例图分析:Gallery2主要功能是实现本地存储器.MTP存储器和网络存储器中媒体(图像和视频)的浏览.显示和 ...
Android4.0 Launcher拖拽原理分析
在Android4.0源码自带的Launcher中,拖拽是由DragController进行控制的. 1) 先来看看类之间的继承关系 2)再来看看Launcher拖拽流程的时序图 1.基本流程: ...

随机推荐

zookeeper配置详解
原文地址: http://itindex.net/detail/40187-zookeeper-%E7%AE%A1%E7%90%86%E5%91%98-%E7%AE%A1%E7%90%86 参数名说 ...
js函数柯里化
function curry(fn){ // 代码 } function add(a,b,c){ return a + b + c; } const execAdd = curry(add); exe ...
《C++ Primer Plus》学习笔记 2.1.1 main()函数
main()函数的基本结构如下: int main() { statements ; } 这几行代码构成了函数定义(function definition),该定义由两部分组成: 第一行int mai ...
[Web] 如何实现Web服务器和应用服务器的负载均衡？
本文对Web服务器和应用服务器的负载均衡进行说明. 在负载均衡的思路下,多台服务器为对称方式,每台服务器都具有同等的地位,可以单独对外提供服务而无须其他服务器的辅助.通过负载分担技术,将外部发送来的请 ...
PHP 基础知识代码总结
一.PHP基础语法变量到数组 <?php //phpinfo(); /* 变量 $a=1;//不分配空间 echo "\$a=".$a; echo "<br ...
vue axios配置发起请求加载loading请求结束关闭loading
axios带有请求拦截器,避免在每个请求里面加loading重复操作,可以封装进去,在请求开始时加载loading层,请求结束关闭,loading层用vux的loading加载 axios.js im ...
green rgb(255, 102, 0) #FF6600
w通过元素背景色定位元素,改变其属性. style="background-color: #FF6600" <script> var w = document.quer ...
shell (check return of each line)(PIPESTATUS[@])and sudoer
shell result from cmdline echo $? if 0 then success ;else failure (shell 执行每部返回值,rm -rf 错误,打包不能覆盖) 我 ...
Guess Your Way Out! II---cf 558D （区间覆盖，c++STL map 的使用）
题目链接:http://codeforces.com/contest/558/problem/D 题意就是有一个二叉树高度为 h ,人站在根节点上,现在要走出去,出口在叶子节点上,有 q 条信息,每条 ...
LocalActivityManager与ActivityGroup
Helper class for managing multiple running embedded activities in the same process. This class is no ...

Android4.0 Surface机制分析

Android4.0 Surface机制分析的更多相关文章

随机推荐

热门专题