ekenlinbing
ekenlinbing

Android系统Surface机制的SurfaceFlinger服务对帧缓冲区（Frame Buffer）的管理分析

Android系统Surface机制的SurfaceFlinger服务对帧缓冲区（Frame Buffer）的管理分析

分类： Android 2012-10-15 00:56 12763人阅读 评论(34) 收藏 举报

        在前文中，我们分析了SurfaceFlinger服务的启动过程。SurfaceFlinger服务在启动的过程中，会对系统的硬件帧缓冲区进行初始化。由于系统的硬件帧缓冲区一般只有一个，并且不是谁都可以随便访问的，因此，它就需要由一个服务来统一管理。在Android系统中，这个服务便是SurfaceFlinger。在本文中，我们就详细分析SurfaceFlinger服务是如何管理系统的硬件帧缓冲区的。

        从前面Android系统Surface机制的SurfaceFlinger服务简要介绍和学习计划一文可以知道，SurfaceFlinger服务通过一个GraphicPlane对象来描述系统的显示屏，即系统的硬件帧缓冲区。GraphicPlane类内部聚合了一个DisplayHardware对象，通过这个DisplayHardware对象就可以访问系统的硬件帧缓冲区。DisplayHardware类内部又包含了一个FramebufferNativeWindow对象，这个FramebufferNativeWindow对象才是真正用来描述系统的硬件帧缓冲区的。FramebufferNativeWindow类的作用类似于在前面Android应用程序请求SurfaceFlinger服务创建Surface的过程分析一文中所介绍的Surface类，它是连接OpenGL库和Android的UI系统的一个桥梁，OpenGL库就是通过这个桥梁来将Android系统的UI渲染到硬件帧缓冲区中去的。GraphicPlane、DisplayHardware和FramebufferNativeWindow这三个类的关系如图1所示。

Android系统Surface机制的SurfaceFlinger服务对帧缓冲区（Frame Buffer）的管理分析_第1张图片

图1 GraphicPlane、DisplayHardware和FramebufferNativeWindow的类关系图

       接下来，我们就分别介绍GraphicPlane、DisplayHardware和FramebufferNativeWindow这三个类的实现，以便可以理解SurfaceFlinger服务是如何通过它们来管理系统的硬件帧缓冲区的。

       从前面Android系统Surface制的SurfaceFlinger服务的启动过程分析一文可以知道，SurfaceFlinger服务在启动的过程中，会对系统的硬件帧缓冲区进行初始化，如下所示：

[cpp] view plain copy print ?
  1. status_t SurfaceFlinger::readyToRun()    
  2. {  
  3.     ......  
  4.   
  5.     // we only support one display currently     
  6.     int dpy = 0;    
  7.     
  8.     {    
  9.         // initialize the main display     
  10.         GraphicPlane& plane(graphicPlane(dpy));    
  11.         DisplayHardware* const hw = new DisplayHardware(this, dpy);    
  12.         plane.setDisplayHardware(hw);    
  13.     }    
  14.   
  15.     ......  
  16.   
  17.     // initialize primary screen     
  18.     // (other display should be initialized in the same manner, but     
  19.     // asynchronously, as they could come and go. None of this is supported     
  20.     // yet).     
  21.     const GraphicPlane& plane(graphicPlane(dpy));    
  22.     const DisplayHardware& hw = plane.displayHardware();    
  23.     ......  
  24.     hw.makeCurrent();  
  25.   
  26.     ......    
  27. }  
status_t SurfaceFlinger::readyToRun()  
{
    ......

    // we only support one display currently  
    int dpy = 0;  
  
    {  
        // initialize the main display  
        GraphicPlane& plane(graphicPlane(dpy));  
        DisplayHardware* const hw = new DisplayHardware(this, dpy);  
        plane.setDisplayHardware(hw);  
    }  

    ......

    // initialize primary screen  
    // (other display should be initialized in the same manner, but  
    // asynchronously, as they could come and go. None of this is supported  
    // yet).  
    const GraphicPlane& plane(graphicPlane(dpy));  
    const DisplayHardware& hw = plane.displayHardware();  
    ......
    hw.makeCurrent();

    ......  
}
       这个函数定义在文件frameworks/base/services/surfaceflinger/SurfaceFlinger.cpp文件中。

       这个代码段首先创建了一个DisplayHardware对象，用来初始化编号为0的GraphicPlane对象，接着再将这个DisplayHardware对象设置为系统当前活动的DisplayHardware对象，这就相当于是将编号为0的GraphicPlane对象所描述的显示屏设置为系统当前活动的显示屏。

       接下来，我们就首先分析编号为0的GraphicPlane对象的初始化过程，接着再分析DisplayHardware对象的创建过程。

       编号为0的GraphicPlane对象的初始化过程主要是调用GraphicPlane类的成员函数setDisplayHardware来实现的，如下所示：

[cpp] view plain copy print ?
  1. void GraphicPlane::setDisplayHardware(DisplayHardware *hw)  
  2. {  
  3.     mHw = hw;  
  4.   
  5.     // initialize the display orientation transform.   
  6.     // it's a constant that should come from the display driver.   
  7.     int displayOrientation = ISurfaceComposer::eOrientationDefault;  
  8.     char property[PROPERTY_VALUE_MAX];  
  9.     if (property_get("ro.sf.hwrotation", property, NULL) > 0) {  
  10.         //displayOrientation   
  11.         switch (atoi(property)) {  
  12.         case 90:  
  13.             displayOrientation = ISurfaceComposer::eOrientation90;  
  14.             break;  
  15.         case 270:  
  16.             displayOrientation = ISurfaceComposer::eOrientation270;  
  17.             break;  
  18.         }  
  19.     }  
  20.   
  21.     const float w = hw->getWidth();  
  22.     const float h = hw->getHeight();  
  23.     GraphicPlane::orientationToTransfrom(displayOrientation, w, h,  
  24.             &mDisplayTransform);  
  25.     if (displayOrientation & ISurfaceComposer::eOrientationSwapMask) {  
  26.         mDisplayWidth = h;  
  27.         mDisplayHeight = w;  
  28.     } else {  
  29.         mDisplayWidth = w;  
  30.         mDisplayHeight = h;  
  31.     }  
  32.   
  33.     setOrientation(ISurfaceComposer::eOrientationDefault);  
  34. }  
void GraphicPlane::setDisplayHardware(DisplayHardware *hw)
{
    mHw = hw;

    // initialize the display orientation transform.
    // it's a constant that should come from the display driver.
    int displayOrientation = ISurfaceComposer::eOrientationDefault;
    char property[PROPERTY_VALUE_MAX];
    if (property_get("ro.sf.hwrotation", property, NULL) > 0) {
        //displayOrientation
        switch (atoi(property)) {
        case 90:
            displayOrientation = ISurfaceComposer::eOrientation90;
            break;
        case 270:
            displayOrientation = ISurfaceComposer::eOrientation270;
            break;
        }
    }

    const float w = hw->getWidth();
    const float h = hw->getHeight();
    GraphicPlane::orientationToTransfrom(displayOrientation, w, h,
            &mDisplayTransform);
    if (displayOrientation & ISurfaceComposer::eOrientationSwapMask) {
        mDisplayWidth = h;
        mDisplayHeight = w;
    } else {
        mDisplayWidth = w;
        mDisplayHeight = h;
    }

    setOrientation(ISurfaceComposer::eOrientationDefault);
}
       这个函数定义在文件frameworks/base/services/surfaceflinger/SurfaceFlinger.cpp文件中。

       函数首先设置显示屏的初始大小和旋转方向。GraphicPlane类有三个成员变量mDisplayWidth、mDisplayHeight和mDisplayTransform，前两者的类型为float，分别用描述显示屏的初始宽度和高度，而后者的类型为Transform，用来描述显示屏的初始旋转矩阵。Transform类的作用是来描述变换矩阵，以便后面在渲染UI时可以用来动态地计算显示屏的大小和旋转方向等。

       显示屏的初始化宽度和高度是由参数hw所描述的一个DisplayHardware对象来描述的，而显示屏的初始旋转方向则是由名称为“ro.sf.hwrotation”的系统属性来决定的。如果没有设置名称为“ro.sf.hwrotation”的系统属性，那么显示屏的旋转方向就为默认方向，即ISurfaceComposer::eOrientationDefault。

       获得了显示屏的初始化宽度w、高度h和旋转方向displayOrientation之后，函数接着就调用GraphicPlane类的静态成员函数orientationToTransfrom来将它们构造成一个变换矩阵，并且保存在GraphicPlane类的成员变量mDisplayTransform中。

       函数接下来继续判断显示屏的初始化旋转方向是否将初始化宽度和高度值翻转了。如果翻转了，那么就需要相互调换GraphicPlane类的成员变量mDisplayWidth和mDisplayHeight的值，以便可以正确地反映显示屏的初始化宽度和高度。

       注意，显示屏的初始宽度、高度和旋转方向一经初始化之后，就会保持不变，以后显示屏的实际旋转方向计算都是要在此基础上进行计算的，即要在变换矩阵mDisplayTransform的基础上进行计算。从这里还可以看出，通过设置名称为“ro.sf.hwrotation”的系统属性的值，就可以设置系统显示屏的初始化旋转方向，以便匹配实际的硬件帧缓冲区的旋转方向。

       函数最后调用GraphicPlane类的成员函数setOrientation来设备显示屏的实际度度、高度以及旋转方向，如下所示：

[cpp] view plain copy print ?
  1. status_t GraphicPlane::setOrientation(int orientation)  
  2. {  
  3.     // If the rotation can be handled in hardware, this is where   
  4.     // the magic should happen.   
  5.   
  6.     const DisplayHardware& hw(displayHardware());  
  7.     const float w = mDisplayWidth;  
  8.     const float h = mDisplayHeight;  
  9.     mWidth = int(w);  
  10.     mHeight = int(h);  
  11.   
  12.     Transform orientationTransform;  
  13.     GraphicPlane::orientationToTransfrom(orientation, w, h,  
  14.             &orientationTransform);  
  15.     if (orientation & ISurfaceComposer::eOrientationSwapMask) {  
  16.         mWidth = int(h);  
  17.         mHeight = int(w);  
  18.     }  
  19.   
  20.     mOrientation = orientation;  
  21.     mGlobalTransform = mDisplayTransform * orientationTransform;  
  22.     return NO_ERROR;  
  23. }  
status_t GraphicPlane::setOrientation(int orientation)
{
    // If the rotation can be handled in hardware, this is where
    // the magic should happen.

    const DisplayHardware& hw(displayHardware());
    const float w = mDisplayWidth;
    const float h = mDisplayHeight;
    mWidth = int(w);
    mHeight = int(h);

    Transform orientationTransform;
    GraphicPlane::orientationToTransfrom(orientation, w, h,
            &orientationTransform);
    if (orientation & ISurfaceComposer::eOrientationSwapMask) {
        mWidth = int(h);
        mHeight = int(w);
    }

    mOrientation = orientation;
    mGlobalTransform = mDisplayTransform * orientationTransform;
    return NO_ERROR;
}
        这个函数定义在文件frameworks/base/services/surfaceflinger/SurfaceFlinger.cpp文件中。

        参数orientation的值等于ISurfaceComposer::eOrientationDefault，即SurfaceFlinger服务在初始化系统显示屏时，会将它的旋转方向设置为默认值，以后再根据实际情况来做调整。

       GraphicPlane类有三个成员变量mWidth、mHeight和mOrientation，它们的类型均为int，分别用来描述显示屏的实际宽度、高度和旋转方向。与成员变量mDisplayWidth、mDisplayHeight和mDisplayTransform所描述的显示屏初始化宽度、高度和旋转矩阵一经初始化后就保持不变不同，mWidth、mHeight和mOrientation这三个成员变量是会动态变化的。例如，当显示屏由LANDSCAPE变为PORTRAIT模式时，mWidth、mHeight和mOrientation这三个成员变量就会相应地发生改变。

       函数首先将显示屏的实际宽度mWidth、高度mHeight和旋转方向mOrientation设置为显示屏的初始宽度mDisplayWidth、高度mDisplayHeight以及参数orientation所描述的旋转方向，接着再调用GraphicPlane类的静态成员函数orientationToTransfrom来将它们构造成一个变换矩阵orientationTransform。

       函数接着判断显示屏的实际旋转方向orientation是否将原来的实际宽度和高度值翻转了。如果翻转了，那么就需要相互调换GraphicPlane类的成员变量mWidth和mHeight的值，以便可以正确地反映显示屏的实际宽度和高度。

       函数最后将用来描述显示屏的初始化旋转方向的变换矩阵mDisplayTransform和用来描述显示屏的实际旋转方向的变换矩阵orientationTransform相乘，就可以得到一个全局变换矩阵，并且保存在GraphicPlane类的成员变量mGlobalTransform中。这样以后渲染UI时，对于一个任意的点向量，只要将它乘以全局变换矩阵mGlobalTransform，那么就可以得到它所描述的实际位置。

       至此，编号为0的GraphicPlane对象的初始化过程就完成了，以后SurfaceFlinger服务就可以调用它的成员函数displayHardware来获得它内部的一个DisplayHardware对象，如下所示：

[cpp] view plain copy print ?
  1. const DisplayHardware& GraphicPlane::displayHardware() const {  
  2.     return *mHw;  
  3. }  
const DisplayHardware& GraphicPlane::displayHardware() const {
    return *mHw;
}
      这个函数定义在文件frameworks/base/services/surfaceflinger/SurfaceFlinger.cpp文件中。

      接下来，回到前面SurfaceFlinger类的成员函数readyToRun中，我们通过DisplayHardware对象的创建过程来分析DisplayHardware类的实现。

      在创建DisplayHardware对象的过程中，会调用DisplayHardware类的构造函数，如下所示：

[cpp] view plain copy print ?
  1. DisplayHardware::DisplayHardware(  
  2.         const sp& flinger,  
  3.         uint32_t dpy)  
  4.     : DisplayHardwareBase(flinger, dpy),  
  5.       mFlags(0)  
  6. {  
  7.     init(dpy);  
  8. }  
DisplayHardware::DisplayHardware(
        const sp& flinger,
        uint32_t dpy)
    : DisplayHardwareBase(flinger, dpy),
      mFlags(0)
{
    init(dpy);
}
       这个函数定义在文件frameworks/base/services/surfaceflinger/DisplayHardware/DisplayHardware.cpp中。

       从这里可以看出，DisplayHardware类是从DisplayHardwareBase类继承下来的。接下来，我们首先继续分析一个DisplayHardware对象的初始化过程，接着再分析这个DisplayHardware对象的父对象DisplayHardwareBase的初始化过程，以便可以了解DisplayHardwareBase类的实现。

       一个DisplayHardware对象的初始化过程是通过调用DisplayHardware类的成员函数init来实现的。DisplayHardware类的成员函数init的实现比较长，我们分段来阅读：

[cpp] view plain copy print ?
  1. void DisplayHardware::init(uint32_t dpy)  
  2. {  
  3.     mNativeWindow = new FramebufferNativeWindow();  
  4.     framebuffer_device_t const * fbDev = mNativeWindow->getDevice();  
  5.     mDpiX = mNativeWindow->xdpi;  
  6.     mDpiY = mNativeWindow->ydpi;  
  7.     mRefreshRate = fbDev->fps;  
  8.   
  9.     mOverlayEngine = NULL;  
  10.     hw_module_t const* module;  
  11.     if (hw_get_module(OVERLAY_HARDWARE_MODULE_ID, &module) == 0) {  
  12.         overlay_control_open(module, &mOverlayEngine);  
  13.     }  
void DisplayHardware::init(uint32_t dpy)
{
    mNativeWindow = new FramebufferNativeWindow();
    framebuffer_device_t const * fbDev = mNativeWindow->getDevice();
    mDpiX = mNativeWindow->xdpi;
    mDpiY = mNativeWindow->ydpi;
    mRefreshRate = fbDev->fps;

    mOverlayEngine = NULL;
    hw_module_t const* module;
    if (hw_get_module(OVERLAY_HARDWARE_MODULE_ID, &module) == 0) {
        overlay_control_open(module, &mOverlayEngine);
    }
        这段代码首先是创建了一个FramebufferNativeWindow对象，并且保存在DisplayHardware类的成员变量mNativeWindow中，用来管理硬件帧缓冲区。有了这个FramebufferNativeWindow对象之后，就可以通过它里面的一个fb设备来获得硬件帧缓冲区的点密度以及刷新频率等信息。后面我们再详细分析FramebufferNativeWindow类的实现。

        这段代码接着再加载HAL层中的overlay模块，目的是要打开系统的overlay设备。在Android系统中，我们可以将overlay看作是一种特殊的Surface，一般用来显示视频。在这一系列文章中，我们暂时不关心overlay设备的实现。

        我们接着往下阅读代码：

[cpp] view plain copy print ?
  1. EGLint w, h, dummy;  
  2. EGLint numConfigs=0;  
  3. EGLSurface surface;  
  4. EGLContext context;  
  5.   
  6. // initialize EGL   
  7. EGLint attribs[] = {  
  8.         EGL_SURFACE_TYPE,   EGL_WINDOW_BIT,  
  9.         EGL_NONE,           0,  
  10.         EGL_NONE  
  11. };  
  12.   
  13. // debug: disable h/w rendering   
  14. char property[PROPERTY_VALUE_MAX];  
  15. if (property_get("debug.sf.hw", property, NULL) > 0) {  
  16.     if (atoi(property) == 0) {  
  17.         LOGW("H/W composition disabled");  
  18.         attribs[2] = EGL_CONFIG_CAVEAT;  
  19.         attribs[3] = EGL_SLOW_CONFIG;  
  20.     }  
  21. }  
    EGLint w, h, dummy;
    EGLint numConfigs=0;
    EGLSurface surface;
    EGLContext context;

    // initialize EGL
    EGLint attribs[] = {
            EGL_SURFACE_TYPE,   EGL_WINDOW_BIT,
            EGL_NONE,           0,
            EGL_NONE
    };

    // debug: disable h/w rendering
    char property[PROPERTY_VALUE_MAX];
    if (property_get("debug.sf.hw", property, NULL) > 0) {
        if (atoi(property) == 0) {
            LOGW("H/W composition disabled");
            attribs[2] = EGL_CONFIG_CAVEAT;
            attribs[3] = EGL_SLOW_CONFIG;
        }
    }
        这段代码主要用来设置一个EGL属性数组attribs，以便接下来可以根据这个属性数组的值来正确的初始化EGL库。

        我们接着往下阅读代码：

[cpp] view plain copy print ?
  1. // TODO: all the extensions below should be queried through   
  2. // eglGetProcAddress().   
  3.   
  4. EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);  
  5. eglInitialize(display, NULL, NULL);  
  6. eglGetConfigs(display, NULL, 0, &numConfigs);  
  7.   
  8. EGLConfig config;  
  9. status_t err = EGLUtils::selectConfigForNativeWindow(  
  10.         display, attribs, mNativeWindow.get(), &config);  
  11. LOGE_IF(err, "couldn't find an EGLConfig matching the screen format");  
    // TODO: all the extensions below should be queried through
    // eglGetProcAddress().

    EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
    eglInitialize(display, NULL, NULL);
    eglGetConfigs(display, NULL, 0, &numConfigs);

    EGLConfig config;
    status_t err = EGLUtils::selectConfigForNativeWindow(
            display, attribs, mNativeWindow.get(), &config);
    LOGE_IF(err, "couldn't find an EGLConfig matching the screen format");

        这段代码首先调用eglGetDisplay和eglInitialize函数来获得和初始化OpengGL库的默认显示屏，接着再调用EGLUtils::selectConfigForNativeWindow函数来获得前面所创建的一个FramebufferNativeWindow对象所描述的系统主绘图表面的配置信息，并且保存在EGLConfig对象config。有了这些配置信息之后，接下来就可以在硬件帧缓冲区上面创建系统的主绘图表面。

        我们接着往下阅读代码：

[cpp] view plain copy print ?
  1. EGLint r,g,b,a;  
  2. eglGetConfigAttrib(display, config, EGL_RED_SIZE,   &r);  
  3. eglGetConfigAttrib(display, config, EGL_GREEN_SIZE, &g);  
  4. eglGetConfigAttrib(display, config, EGL_BLUE_SIZE,  &b);  
  5. eglGetConfigAttrib(display, config, EGL_ALPHA_SIZE, &a);  
  6.   
  7. if (mNativeWindow->isUpdateOnDemand()) {  
  8.     mFlags |= PARTIAL_UPDATES;  
  9. }  
  10.   
  11. if (eglGetConfigAttrib(display, config, EGL_CONFIG_CAVEAT, &dummy) == EGL_TRUE) {  
  12.     if (dummy == EGL_SLOW_CONFIG)  
  13.         mFlags |= SLOW_CONFIG;  
  14. }  
    EGLint r,g,b,a;
    eglGetConfigAttrib(display, config, EGL_RED_SIZE,   &r);
    eglGetConfigAttrib(display, config, EGL_GREEN_SIZE, &g);
    eglGetConfigAttrib(display, config, EGL_BLUE_SIZE,  &b);
    eglGetConfigAttrib(display, config, EGL_ALPHA_SIZE, &a);

    if (mNativeWindow->isUpdateOnDemand()) {
        mFlags |= PARTIAL_UPDATES;
    }

    if (eglGetConfigAttrib(display, config, EGL_CONFIG_CAVEAT, &dummy) == EGL_TRUE) {
        if (dummy == EGL_SLOW_CONFIG)
            mFlags |= SLOW_CONFIG;
    }
        这段代码主要是用来获得系统主绘图表面的一些属性，例如，四个颜色分量R、G、B和A的大小，以及是否支持部分更新、是否使用慢渲染方式等。

        我们接着往下阅读代码：

[cpp] view plain copy print ?
  1. /* 
  2.  * Create our main surface 
  3.  */  
  4.   
  5. surface = eglCreateWindowSurface(display, config, mNativeWindow.get(), NULL);  
  6. eglQuerySurface(display, surface, EGL_WIDTH,  &mWidth);  
  7. eglQuerySurface(display, surface, EGL_HEIGHT, &mHeight);  
  8.   
  9. if (mFlags & PARTIAL_UPDATES) {  
  10.     // if we have partial updates, we definitely don't need to   
  11.     // preserve the backbuffer, which may be costly.   
  12.     eglSurfaceAttrib(display, surface,  
  13.             EGL_SWAP_BEHAVIOR, EGL_BUFFER_DESTROYED);  
  14. }  
  15.   
  16. if (eglQuerySurface(display, surface, EGL_SWAP_BEHAVIOR, &dummy) == EGL_TRUE) {  
  17.     if (dummy == EGL_BUFFER_PRESERVED) {  
  18.         mFlags |= BUFFER_PRESERVED;  
  19.     }  
  20. }  
    /*
     * Create our main surface
     */

    surface = eglCreateWindowSurface(display, config, mNativeWindow.get(), NULL);
    eglQuerySurface(display, surface, EGL_WIDTH,  &mWidth);
    eglQuerySurface(display, surface, EGL_HEIGHT, &mHeight);

    if (mFlags & PARTIAL_UPDATES) {
        // if we have partial updates, we definitely don't need to
        // preserve the backbuffer, which may be costly.
        eglSurfaceAttrib(display, surface,
                EGL_SWAP_BEHAVIOR, EGL_BUFFER_DESTROYED);
    }

    if (eglQuerySurface(display, surface, EGL_SWAP_BEHAVIOR, &dummy) == EGL_TRUE) {
        if (dummy == EGL_BUFFER_PRESERVED) {
            mFlags |= BUFFER_PRESERVED;
        }
    }
        这段代码首先调用函数eglCreateWindowSurface来创建系统的主绘图表面。系统的主绘图表面是直接在硬件帧缓冲区上创建的，用来渲染系统的UI，即负责合成和渲染所有应用程序的UI。

        这段代码接着还获得系统的主绘图表面的宽度和高度，分别保存在并且保存在DisplayHardware类的成员变量mWidth和mHeight中。

        这段代码最后还判断硬件帧缓冲区是否支持部分更新。如果支持的话，就会在调用函数eglSwapBuffers来渲染系统的UI时，不保留后端图形缓冲区的内容，因为保留是有代价的。如果不支持的话，那么就会就会调用函数eglQuerySurface来检查在调用函数eglSwapBuffers来渲染系统的UI时是否需要保留后端图形缓冲区的内容。如果需要的话，那么就会将DisplayHardware类的成员变量mFlags的BUFFER_PRESERVED位设置为1。在保留后端图形缓冲区的内容的情况下，系统就可以支持仅仅渲染那些需要更新的脏区域，这些区域可以是不规则的。然而，实现不规则区域部分更新功能是有代价的，因为每次在渲染UI时，都要将后端图形缓冲区的内容拷贝回那些不在那些需要更新的区域中去，这会导致性能低下。因此，系统一般都不支持不规则区域部分更新功能。

        我们接着往下阅读代码：

[cpp] view plain copy print ?
  1. /* Read density from build-specific ro.sf.lcd_density property 
  2.  * except if it is overridden by qemu.sf.lcd_density. 
  3.  */  
  4. if (property_get("qemu.sf.lcd_density", property, NULL) <= 0) {  
  5.     if (property_get("ro.sf.lcd_density", property, NULL) <= 0) {  
  6.         LOGW("ro.sf.lcd_density not defined, using 160 dpi by default.");  
  7.         strcpy(property, "160");  
  8.     }  
  9. } else {  
  10.     /* for the emulator case, reset the dpi values too */  
  11.     mDpiX = mDpiY = atoi(property);  
  12. }  
  13. mDensity = atoi(property) * (1.0f/160.0f);  
    /* Read density from build-specific ro.sf.lcd_density property
     * except if it is overridden by qemu.sf.lcd_density.
     */
    if (property_get("qemu.sf.lcd_density", property, NULL) <= 0) {
        if (property_get("ro.sf.lcd_density", property, NULL) <= 0) {
            LOGW("ro.sf.lcd_density not defined, using 160 dpi by default.");
            strcpy(property, "160");
        }
    } else {
        /* for the emulator case, reset the dpi values too */
        mDpiX = mDpiY = atoi(property);
    }
    mDensity = atoi(property) * (1.0f/160.0f);

        这段代码用来设备系统的主绘图表面的点密度信息。系统的主绘图表面的点密度信息可以通过名称为“qemu.sf.lcd_density”或者“ro.sf.lcd_density”的系统属性来配置。如果没有配置，那么默认值就为160dpi。

        我们接着往下阅读代码：

[cpp] view plain copy print ?
  1.     /* 
  2.      * Create our OpenGL ES context 
  3.      */  
  4.   
  5.   
  6.     EGLint contextAttributes[] = {  
  7. #ifdef EGL_IMG_context_priority   
  8. #ifdef HAS_CONTEXT_PRIORITY   
  9. #warning "using EGL_IMG_context_priority"   
  10.         EGL_CONTEXT_PRIORITY_LEVEL_IMG, EGL_CONTEXT_PRIORITY_HIGH_IMG,  
  11. #endif   
  12. #endif   
  13.         EGL_NONE, EGL_NONE  
  14.     };  
  15.     context = eglCreateContext(display, config, NULL, contextAttributes);  
  16.   
  17.     mDisplay = display;  
  18.     mConfig  = config;  
  19.     mSurface = surface;  
  20.     mContext = context;  
  21.     mFormat  = fbDev->format;  
  22.     mPageFlipCount = 0;  
    /*
     * Create our OpenGL ES context
     */


    EGLint contextAttributes[] = {
#ifdef EGL_IMG_context_priority
#ifdef HAS_CONTEXT_PRIORITY
#warning "using EGL_IMG_context_priority"
        EGL_CONTEXT_PRIORITY_LEVEL_IMG, EGL_CONTEXT_PRIORITY_HIGH_IMG,
#endif
#endif
        EGL_NONE, EGL_NONE
    };
    context = eglCreateContext(display, config, NULL, contextAttributes);

    mDisplay = display;
    mConfig  = config;
    mSurface = surface;
    mContext = context;
    mFormat  = fbDev->format;
    mPageFlipCount = 0;
        这段代码主要是调用函数eglCreateContext来创建系统的主绘图表面的上下文。有了这个上下文之后，OpenGL库就能够在前面所创建的系统主绘图表面上渲染系统的UI了。

        我们接着往下阅读代码：

[cpp] view plain copy print ?
  1.     /* 
  2.      * Gather OpenGL ES extensions 
  3.      */  
  4.   
  5.     eglMakeCurrent(display, surface, surface, context);  
  6.   
  7.     GLExtensions& extensions(GLExtensions::getInstance());  
  8.     extensions.initWithGLStrings(  
  9.             glGetString(GL_VENDOR),  
  10.             glGetString(GL_RENDERER),  
  11.             glGetString(GL_VERSION),  
  12.             glGetString(GL_EXTENSIONS),  
  13.             eglQueryString(display, EGL_VENDOR),  
  14.             eglQueryString(display, EGL_VERSION),  
  15.             eglQueryString(display, EGL_EXTENSIONS));  
  16.   
  17.     glGetIntegerv(GL_MAX_TEXTURE_SIZE, &mMaxTextureSize);  
  18.     glGetIntegerv(GL_MAX_VIEWPORT_DIMS, &mMaxViewportDims);  
  19.   
  20.   
  21. #ifdef EGL_ANDROID_swap_rectangle   
  22.     if (extensions.hasExtension("EGL_ANDROID_swap_rectangle")) {  
  23.         if (eglSetSwapRectangleANDROID(display, surface,  
  24.                 0, 0, mWidth, mHeight) == EGL_TRUE) {  
  25.             // This could fail if this extension is not supported by this   
  26.             // specific surface (of config)   
  27.             mFlags |= SWAP_RECTANGLE;  
  28.         }  
  29.     }  
  30.     // when we have the choice between PARTIAL_UPDATES and SWAP_RECTANGLE   
  31.     // choose PARTIAL_UPDATES, which should be more efficient   
  32.     if (mFlags & PARTIAL_UPDATES)  
  33.         mFlags &= ~SWAP_RECTANGLE;  
  34. #endif  
    /*
     * Gather OpenGL ES extensions
     */

    eglMakeCurrent(display, surface, surface, context);

    GLExtensions& extensions(GLExtensions::getInstance());
    extensions.initWithGLStrings(
            glGetString(GL_VENDOR),
            glGetString(GL_RENDERER),
            glGetString(GL_VERSION),
            glGetString(GL_EXTENSIONS),
            eglQueryString(display, EGL_VENDOR),
            eglQueryString(display, EGL_VERSION),
            eglQueryString(display, EGL_EXTENSIONS));

    glGetIntegerv(GL_MAX_TEXTURE_SIZE, &mMaxTextureSize);
    glGetIntegerv(GL_MAX_VIEWPORT_DIMS, &mMaxViewportDims);


#ifdef EGL_ANDROID_swap_rectangle
    if (extensions.hasExtension("EGL_ANDROID_swap_rectangle")) {
        if (eglSetSwapRectangleANDROID(display, surface,
                0, 0, mWidth, mHeight) == EGL_TRUE) {
            // This could fail if this extension is not supported by this
            // specific surface (of config)
            mFlags |= SWAP_RECTANGLE;
        }
    }
    // when we have the choice between PARTIAL_UPDATES and SWAP_RECTANGLE
    // choose PARTIAL_UPDATES, which should be more efficient
    if (mFlags & PARTIAL_UPDATES)
        mFlags &= ~SWAP_RECTANGLE;
#endif

        这段代码主要用来检查系统的主绘图表面是否支持EGL_ANDROID_swap_rectangle扩展属性。如果支持的话，那么每次在调用函数eglSwapBuffers来渲染UI时，都会使用软件的方式来支持部分更新区域功能，即：先得到不在新脏区域里面的那部分旧脏区域的内容，然后再将得到的这部分旧脏区域的内容拷贝回到要渲染的新图形缓冲区中去，这要求每次在渲染UI时，都要将被渲染的图形缓冲区以及对应的脏区域保存下来。注意，如果系统的主绘图表面同时支持EGL_ANDROID_swap_rectangle扩展属性以及部分更新属性，那么将会优先使用部分更新属性，因为后者是直接在硬件上支持部分更新，因而性能会更好。

        我们接着往下阅读最后一段代码：

[cpp] view plain copy print ?
  1. LOGI("EGL informations:");  
  2. LOGI("# of configs : %d", numConfigs);  
  3. LOGI("vendor    : %s", extensions.getEglVendor());  
  4. LOGI("version   : %s", extensions.getEglVersion());  
  5. LOGI("extensions: %s", extensions.getEglExtension());  
  6. LOGI("Client API: %s", eglQueryString(display, EGL_CLIENT_APIS)?:"Not Supported");  
  7. LOGI("EGLSurface: %d-%d-%d-%d, config=%p", r, g, b, a, config);  
  8.   
  9. LOGI("OpenGL informations:");  
  10. LOGI("vendor    : %s", extensions.getVendor());  
  11. LOGI("renderer  : %s", extensions.getRenderer());  
  12. LOGI("version   : %s", extensions.getVersion());  
  13. LOGI("extensions: %s", extensions.getExtension());  
  14. LOGI("GL_MAX_TEXTURE_SIZE = %d", mMaxTextureSize);  
  15. LOGI("GL_MAX_VIEWPORT_DIMS = %d", mMaxViewportDims);  
  16. LOGI("flags = %08x", mFlags);  
  17.   
  18. // Unbind the context from this thread   
  19. eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);  
    LOGI("EGL informations:");
    LOGI("# of configs : %d", numConfigs);
    LOGI("vendor    : %s", extensions.getEglVendor());
    LOGI("version   : %s", extensions.getEglVersion());
    LOGI("extensions: %s", extensions.getEglExtension());
    LOGI("Client API: %s", eglQueryString(display, EGL_CLIENT_APIS)?:"Not Supported");
    LOGI("EGLSurface: %d-%d-%d-%d, config=%p", r, g, b, a, config);

    LOGI("OpenGL informations:");
    LOGI("vendor    : %s", extensions.getVendor());
    LOGI("renderer  : %s", extensions.getRenderer());
    LOGI("version   : %s", extensions.getVersion());
    LOGI("extensions: %s", extensions.getExtension());
    LOGI("GL_MAX_TEXTURE_SIZE = %d", mMaxTextureSize);
    LOGI("GL_MAX_VIEWPORT_DIMS = %d", mMaxViewportDims);
    LOGI("flags = %08x", mFlags);

    // Unbind the context from this thread
    eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
}
       这段代码首先调用日志接口LOGI来显示系统的主绘图表面的属性信息，接着最调用函数eglMakeCurrent来取消 设置OpenGL库在当前线程的绘图表面以及绘图上下文。

       从这里就可以看出，一个DisplayHardware对象在初始化完成之后，它还不能直接用来渲染系统的UI，因为它所初始化的的绘图表面以及绘图上下文并没有作为当前线程的绘图表面以及绘图上下文。这是由于SurfaceFlinger服务可以同时支持多个DisplayHardware对象，即同时支持多个显示屏造成的。

       从前面SurfaceFlinger类的成员函数readyToRun可以知道，当前正在初始化的DisplayHardware对象的编号为0，并且它是在SurfaceFlinger服务的UI渲染线程中创建的，为了可以将它设置系统的主显示屏，即主绘图表面，SurfaceFlinger类的成员函数readyToRun接下来还会调用它的成员函数makeCurrent来将它所里面的绘图表面以及绘图上下文设置为SurfaceFlinger服务的UI渲染线程的绘图表面以及绘图上下文。

       DisplayHardware类的成员函数makeCurrent的实现如下所示：

[cpp] view plain copy print ?
  1. void DisplayHardware::makeCurrent() const  
  2. {  
  3.     eglMakeCurrent(mDisplay, mSurface, mSurface, mContext);  
  4. }  
void DisplayHardware::makeCurrent() const
{
    eglMakeCurrent(mDisplay, mSurface, mSurface, mContext);
}
       这个函数定义在文件frameworks/base/services/surfaceflinger/DisplayHardware/DisplayHardware.cpp中。

       DisplayHardware类的成员函数makeCurrent的实现很简单，它只是通过调用函数eglMakeCurrent来将前面已经创建好的绘图表面以及绘图上下文设置为当前线程的绘图表面以及绘图上下文，即设置为SurfaceFlinger服务的UI渲染线程的绘图表面以及绘图上下文。

       系统的硬件帧缓冲区在初始化完成之后，SurfaceFlinger服务以后就可以调用用来描述它的一个DisplayHardware对象的成员函数flip来在它上面渲染系统的UI了，这个成员函数的实现如下所示：

[cpp] view plain copy print ?
  1. void DisplayHardware::flip(const Region& dirty) const  
  2. {  
  3.     checkGLErrors();  
  4.   
  5.     EGLDisplay dpy = mDisplay;  
  6.     EGLSurface surface = mSurface;  
  7.   
  8. #ifdef EGL_ANDROID_swap_rectangle       
  9.     if (mFlags & SWAP_RECTANGLE) {  
  10.         const Region newDirty(dirty.intersect(bounds()));  
  11.         const Rect b(newDirty.getBounds());  
  12.         eglSetSwapRectangleANDROID(dpy, surface,  
  13.                 b.left, b.top, b.width(), b.height());  
  14.     }  
  15. #endif   
  16.   
  17.     if (mFlags & PARTIAL_UPDATES) {  
  18.         mNativeWindow->setUpdateRectangle(dirty.getBounds());  
  19.     }  
  20.   
  21.     mPageFlipCount++;  
  22.     eglSwapBuffers(dpy, surface);  
  23.     checkEGLErrors("eglSwapBuffers");  
  24.   
  25.     // for debugging   
  26.     //glClearColor(1,0,0,0);   
  27.     //glClear(GL_COLOR_BUFFER_BIT);   
  28. }  
void DisplayHardware::flip(const Region& dirty) const
{
    checkGLErrors();

    EGLDisplay dpy = mDisplay;
    EGLSurface surface = mSurface;

#ifdef EGL_ANDROID_swap_rectangle    
    if (mFlags & SWAP_RECTANGLE) {
        const Region newDirty(dirty.intersect(bounds()));
        const Rect b(newDirty.getBounds());
        eglSetSwapRectangleANDROID(dpy, surface,
                b.left, b.top, b.width(), b.height());
    }
#endif

    if (mFlags & PARTIAL_UPDATES) {
        mNativeWindow->setUpdateRectangle(dirty.getBounds());
    }

    mPageFlipCount++;
    eglSwapBuffers(dpy, surface);
    checkEGLErrors("eglSwapBuffers");

    // for debugging
    //glClearColor(1,0,0,0);
    //glClear(GL_COLOR_BUFFER_BIT);
}
       这个函数定义在文件frameworks/base/services/surfaceflinger/DisplayHardware/DisplayHardware.cpp中。

       这个函数主要就是调用OpenGL库中的函数eglSwapBuffers来将系统的UI渲染到系统的主绘图表面上去的，即渲染到系统的硬件帧缓冲区上去的。在渲染之前，函数会首先判断系统的主绘图表面是否支持EGL_ANDROID_swap_rectangle扩展属性和部分更新属性。如果支持EGL_ANDROID_swap_rectangle扩展属性，即DisplayHardware类的成员变量mFlags的SWAP_RECTANGLE位等于1，那么就需要调用函数eglSetSwapRectangleANDROID来设置要渲染的区域，以便在渲染UI时，可以通过软件的方式来支持部分更新。如果硬件帧缓冲区直接支持部分更新属性，即DisplayHardware类的成员变量mFlags的PARTIAL_UPDATES位等于1，那么就需要调用DisplayHardware类的成员变量mNativeWindow所描述的一个本地窗口的成员函数setUpdateRectangle来设置要更新的那一部分区域。

        DisplayHardware类的成员函数flip在调用函数eglSwapBuffers来渲染UI之前，实际上需要通过其成员变量mNativeWindow所描述的一个本地窗口（FramebufferNativeWindow）来获得一个空闲的图形缓冲区，然后才可以将UI数据写入到这个空闲的图形缓冲区中去，最后再渲染到硬件帧缓冲区中去。前面提到，FramebufferNativeWindow类的作用类似于在前面Android应用程序请求SurfaceFlinger服务创建Surface的过程分析一文中所介绍的Surface类，不过它里面所维护的图形缓冲区是直接在硬件帧缓冲区上创建的，后面我们在分析FramebufferNativeWindow类的实现时，再详细分析。

        至此，我们就分析完成DisplayHardware类的实现了，接下来我们还需要继续介绍它的父类DisplayHardwareBase的实现，以便可以了解DisplayHardware类的另外一个作用，即它还会创建一个线程来监控硬件帧缓冲区的睡眠和唤醒事件。分析完成DisplayHardwareBase类的实现之后，我们最后再分析FramebufferNativeWindow类的实现。

        前面在分析DisplayHardware类的实现时提到，DisplayHardware对象在创建的过程中，会对其父类对象DisplayHardwareBase进行初始化，因此，接下来我们就从DisplayHardwareBase对象的初始化过程入手，来分析DisplayHardwareBase类的实现。不过，在分析DisplayHardwareBase类的实现之前，我们首先看看它的类关系图，如图2所示。

Android系统Surface机制的SurfaceFlinger服务对帧缓冲区（Frame Buffer）的管理分析_第2张图片

图2 DisplayHardwareBase类关系图

        DisplayHardwareBase类一方面用来控制SurfaceFlinger服务当前是否能够访问显示屏。当显示屏处于唤醒状态时，DisplayHardwareBase类的成员变量mScreenAcquired的值就会等于1，表示SurfaceFlinger服务就可以访问显示屏；而当显示屏处于睡眠状态时，DisplayHardwareBase类的成员变量mScreenAcquired的值就会等于0，表示SurfaceFlinger服务不可以访问显示屏。

        显示屏的唤醒/睡眠状态切换是由内核来通知DisplayHardwareBase类的，因此，DisplayHardwareBase类会通过一个线程来监控显示屏的唤醒/睡眠状态切换。这个线程是通过DisplayHardwareBase类的成员变量mDisplayEventThread来描述的。DisplayHardwareBase类的成员变量mDisplayEventThread所描述的线程的类型要么是DisplayEventThread，要么是ConsoleManagerThread，这两者均是从DisplayEventThreadBase类继续下来的，而后者又是从Thread类继承下来的。当硬件帧缓冲区的控制台被打开时，DisplayHardwareBase类的成员变量mDisplayEventThread所描述的线程的类型就是DisplayEventThread；当硬件帧缓冲区的控制台没有被打开时，DisplayHardwareBase类的成员变量mDisplayEventThread所描述的线程的类型就是ConsoleManagerThread。这里我们只考虑硬件帧缓冲区的控制台被打开的情况。

        用来监控显示屏唤醒/睡眠状态切换的线程是在DisplayHardwareBase对象的初始化过程中创建的，它运行起来之后，就会在一个无限循环中不断地监控显示屏唤醒/睡眠状态切换事件。为了方便描述，我们将这个线程称为控制台事件监控线程。DisplayEventThreadBase类的成员变量mFlinger指向了SurfaceFlinger服务，一旦控制台事件监控线程监控到显示屏发生唤醒/睡眠状态切换，那么就会通过它来通知SurfaceFlinger服务。

       控制台事件监控线程的运行过程大概上这样的。在每一次循环中，控制台事件监控线程首先监控显示屏是否要进入睡眠状态了。如果是的话，那么该线程就会通过DisplayEventThreadBase类的成员变量mFlinger来通知SurfaceFlinger服务，并且等待SurfaceFlinger服务处理完成这个通知。SurfaceFlinger服务一旦处理完成显示屏进入睡眠状态的事件，它就会调用DisplayHardwareBase类的成员函数releaseScreen来将其成员变量mScreenAcquired的值设置为0，表示它目前不可以访问显示屏。控制台事件监控线程接下来就会等待显示屏被唤醒过来。一旦显示屏被唤醒过来，那么该线程就会通过DisplayEventThreadBase类的成员变量mFlinger来通知SurfaceFlinger服务。SurfaceFlinger服务得到这个通知之后，就会调用DisplayHardwareBase类的成员函数acquireScreen来将其成员变量mScreenAcquired的值设置为1，表示它目前可以访问显示屏。在下一篇文章分析SurfaceFlinger服务的线程模型时，我们再详细分析这个过程。

        DisplayHardwareBase类另一方面用来控制SurfaceFlinger服务当前是否能够在显示屏上渲染UI。当系统的其它组件请求SurfaceFlinger服务关闭显示屏时，SurfaceFlinger服务就会调用DisplayHardwareBase类的成员函数setCanDraw来将其成员变量mCanDraw的值设置为0；而当系统的其它组件请求SurfaceFlinger服务打开显示屏时，SurfaceFlinger服务就会调用DisplayHardwareBase类的成员函数setCanDraw来将其成员变量mCanDraw的值设置为1。只有当DisplayHardwareBase类的成员变量mScreenAcquired和mCanDraw的值均等于1时，SurfaceFlinger服务才可以在显示屏上渲染系统的UI。为了方便SurfaceFlinger服务判断它当前是否可以在显示屏上渲染系统的UI，DisplayHardwareBase类提供了另外一个成员函数canDraw。当DisplayHardwareBase类的成员函数canDraw的返回值等于true时，就表示SurfaceFlinger服务可以在显示屏上渲染系统的UI，否则就不可以。

       了解了DisplayHardwareBase类的作用之后，接下来我们就从它的构造函数开始分析它的初始化过程。

        DisplayHardwareBase类的构造函数的实现如下所示：

[cpp] view plain copy print ?
  1. DisplayHardwareBase::DisplayHardwareBase(const sp& flinger,  
  2.         uint32_t displayIndex)  
  3.     : mCanDraw(true), mScreenAcquired(true)  
  4. {  
  5.     mDisplayEventThread = new DisplayEventThread(flinger);  
  6.     if (mDisplayEventThread->initCheck() != NO_ERROR) {  
  7.         // fall-back on the console   
  8.         mDisplayEventThread = new ConsoleManagerThread(flinger);  
  9.     }  
  10. }  
DisplayHardwareBase::DisplayHardwareBase(const sp& flinger,
        uint32_t displayIndex)
    : mCanDraw(true), mScreenAcquired(true)
{
    mDisplayEventThread = new DisplayEventThread(flinger);
    if (mDisplayEventThread->initCheck() != NO_ERROR) {
        // fall-back on the console
        mDisplayEventThread = new ConsoleManagerThread(flinger);
    }
}
        这个函数定义在文件frameworks/base/services/surfaceflinger/DisplayHardware/DisplayHardwareBase.cpp中。

        函数首先创建一个类型为DisplayEventThread的线程。如果这个线程能够通过初始化检查，即DisplayEventThread类的成员函数initCheck的返回值等于NO_ERROR，那么SurfaceFlinger服务就会使用这个类型为DisplayEventThread的线程来监控显示屏的睡眠/唤醒状态切换事件，否则的话，函数接下来就会创建另外一个类型为ConsoleManagerThread的线程来监控显示屏的睡眠/唤醒状态切换事件。

        DisplayEventThread类的成员函数initCheck的实现如下所示：

[cpp] view plain copy print ?
  1. status_t DisplayHardwareBase::DisplayEventThread::initCheck() const  
  2. {  
  3.     return (((access(kSleepFileName, R_OK) == 0 &&  
  4.             access(kWakeFileName, R_OK) == 0) ||  
  5.             (access(kOldSleepFileName, R_OK) == 0 &&  
  6.             access(kOldWakeFileName, R_OK) == 0)) &&  
  7.             access(kFbconSysDir, F_OK) != 0) ? NO_ERROR : NO_INIT;  
  8. }  
status_t DisplayHardwareBase::DisplayEventThread::initCheck() const
{
    return (((access(kSleepFileName, R_OK) == 0 &&
            access(kWakeFileName, R_OK) == 0) ||
            (access(kOldSleepFileName, R_OK) == 0 &&
            access(kOldWakeFileName, R_OK) == 0)) &&
            access(kFbconSysDir, F_OK) != 0) ? NO_ERROR : NO_INIT;
}
       这个函数定义在文件frameworks/base/services/surfaceflinger/DisplayHardware/DisplayHardwareBase.cpp中。

       kSleepFileName、kWakeFileName、kOldSleepFileName、kOldWakeFileName和kFbconSysDir是五个字符串常量，它们的定义如下所示：

[cpp] view plain copy print ?
  1. static char const * kSleepFileName = "/sys/power/wait_for_fb_sleep";  
  2. static char const * kWakeFileName = "/sys/power/wait_for_fb_wake";  
  3. static char const * const kOldSleepFileName = "/sys/android_power/wait_for_fb_sleep";  
  4. static char const * const kOldWakeFileName = "/sys/android_power/wait_for_fb_wake";  
  5.   
  6. // This dir exists if the framebuffer console is present, either built into   
  7. // the kernel or loaded as a module.   
  8. static char const * const kFbconSysDir = "/sys/class/graphics/fbcon";  
static char const * kSleepFileName = "/sys/power/wait_for_fb_sleep";
static char const * kWakeFileName = "/sys/power/wait_for_fb_wake";
static char const * const kOldSleepFileName = "/sys/android_power/wait_for_fb_sleep";
static char const * const kOldWakeFileName = "/sys/android_power/wait_for_fb_wake";

// This dir exists if the framebuffer console is present, either built into
// the kernel or loaded as a module.
static char const * const kFbconSysDir = "/sys/class/graphics/fbcon";
       当硬件帧缓冲区的控制台被打开时，帧缓冲区驱动程序就创建一个/sys/class/graphics/fbcon目录，以及创建/sys/power/wait_for_fb_sleep和/sys/power/wait_for_fb_wake或者/sys/android_power/wait_for_fb_sleep和/sys/android_power/wait_for_fb_wake文件，用来通知用户空间显示屏即将要进入睡眠/唤醒状态了。

       回到DisplayHardwareBase类的构造函数中，最终创建出来的线程对象保存在其成员变量mDisplayEventThread中。DisplayHardwareBase类的mDisplayEventThread是一个类型为DisplayEventThreadBase的强指针，从前面Android系统的智能指针（轻量级指针、强指针和弱指针）的实现原理分析一文可以知道，当一个强指针第一次引用一个对象的时候，这个对象的成员函数onFirstRef就会被调用，因此，接下来我们就继续分析DisplayEventThreadBase类的成员函数onFirstRef的实现，看看它在里面做了一件什么事情。

       DisplayEventThreadBase类的成员函数onFirstRef的实现如下所示：

[cpp] view plain copy print ?
  1. class DisplayHardwareBase  
  2. {  
  3.     ......  
  4.   
  5. private:  
  6.     class DisplayEventThreadBase : public Thread {  
  7.         ......  
  8.   
  9.     public:  
  10.         ......  
  11.   
  12.         virtual void onFirstRef() {  
  13.             run("DisplayEventThread", PRIORITY_URGENT_DISPLAY);  
  14.         }  
  15.           
  16.         ......  
  17.     };  
  18.   
  19.     ......  
  20. };  
class DisplayHardwareBase
{
    ......

private:
    class DisplayEventThreadBase : public Thread {
        ......

    public:
        ......

        virtual void onFirstRef() {
            run("DisplayEventThread", PRIORITY_URGENT_DISPLAY);
        }
        
        ......
    };

    ......
};
       这个函数定义在文件frameworks/base/services/surfaceflinger/DisplayHardware/DisplayHardwareBase.h中。

       DisplayEventThreadBase类的成员函数onFirstRef主要就调用父类Thread的成员函数run来创建一个名称为“DisplayEventThread”的线程，用来监控显示屏的睡眠/唤醒状态切换事件。这个线程在创建完成之后，首先会调用DisplayEventThread类的成员函数readyToRun来执行一些初始化操作，接下来不断地循环调用DisplayEventThread类的成员函数threadLoop来监控显示屏的睡眠/唤醒状态切换事件。接下来，我们就主要分析这个线程的初始化操作，即DisplayEventThread类的成员函数readyToRun的实现，在接下来的一篇文章中分析SurfaceFlinger服务的线程模型时，再详细分析这个线程监控显示屏的睡眠/唤醒状态切换事件的过程，即DisplayEventThread类的成员函数threadLoop的实现。

      DisplayEventThread类的成员函数readyToRun的实现如下所示：

[cpp] view plain copy print ?
  1. status_t DisplayHardwareBase::DisplayEventThread::readyToRun()  
  2. {  
  3.     if (access(kSleepFileName, R_OK) || access(kWakeFileName, R_OK)) {  
  4.         if (access(kOldSleepFileName, R_OK) || access(kOldWakeFileName, R_OK)) {  
  5.             LOGE("Couldn't open %s or %s", kSleepFileName, kWakeFileName);  
  6.             return NO_INIT;  
  7.         }  
  8.         kSleepFileName = kOldSleepFileName;  
  9.         kWakeFileName = kOldWakeFileName;  
  10.     }  
  11.     return NO_ERROR;  
  12. }  
status_t DisplayHardwareBase::DisplayEventThread::readyToRun()
{
    if (access(kSleepFileName, R_OK) || access(kWakeFileName, R_OK)) {
        if (access(kOldSleepFileName, R_OK) || access(kOldWakeFileName, R_OK)) {
            LOGE("Couldn't open %s or %s", kSleepFileName, kWakeFileName);
            return NO_INIT;
        }
        kSleepFileName = kOldSleepFileName;
        kWakeFileName = kOldWakeFileName;
    }
    return NO_ERROR;
}
       这个函数定义在文件frameworks/base/services/surfaceflinger/DisplayHardware/DisplayHardwareBase.cpp中。

       DisplayEventThread类的成员函数readyToRun的实现很简单，它首先判断/sys/power/wait_for_fb_sleep和/sys/power/wait_for_fb_wake文件是否存在。如果存在的话，那么就通过它们来监控显示屏的睡眠/唤醒状态切换事件，否则的话，就通过/sys/android_power/wait_for_fb_sleep和/sys/android_power/wait_for_fb_wake文件来监控显示屏的睡眠/唤醒状态切换事件。如果这四个文件都不存在，那么就说明硬件帧缓冲区的控制台没有被打开了，这时候就不能使用类型为DisplayEventThread的线程来监控显示屏的睡眠/唤醒状态切换事件。

       至此，我们就分析完成DisplayHardwareBase类的实现了，接下来我们继续分析FramebufferNativeWindow类的实现，以便可以了解它是如何管理硬件帧缓冲区的。

       在分析FramebufferNativeWindow类的实现之前，我们首先看看它的类关系图，如图3所示。

Android系统Surface机制的SurfaceFlinger服务对帧缓冲区（Frame Buffer）的管理分析_第3张图片

图3 FramebufferNativeWindow类关系

        前面提到，FramebufferNativeWindow类与在前面Android应用程序请求SurfaceFlinger服务创建Surface的过程分析一文中提到的Surface类的作用是类似的。FramebufferNativeWindow类一方面用来在OpenGL库和Android本地窗口系统之间建立连接，这样，我们就可以使用它的成员函数dequeueBuffer来为OpenGL库分配空闲图形缓冲区，以及使用它的成员函数queueBuffer来将OpenGL已经填充好UI数据的图形缓冲区渲染到硬件帧缓冲区中去。FramebufferNativeWindow类另一方面还继承了LightRefBase类，因此，从前面Android系统的智能指针（轻量级指针、强指针和弱指针）的实现原理分析一文可以知道，FramebufferNativeWindow类对象可以结合Android系统的轻量级指针sp来使用，以便可以自动维护生命周期。

        FramebufferNativeWindow类与Surface类又有不同的地方。从前面Android应用程序请求SurfaceFlinger服务创建Surface的过程分析一文可以知道，Surface类使用的图形缓冲区一般是在匿名共享内存中分配的，并且是由SurfaceFlinger服务来负责分配，然后再传递给应用程序进程使用的，而FramebufferNativeWindow类使用的图形缓冲区是直接在硬件帧缓冲区分配的，并且它可以直接将这些图形缓冲区渲染到硬件帧缓冲区中去。从前面Android帧缓冲区（Frame Buffer）硬件抽象层（HAL）模块Gralloc的实现原理分析一文可以知道，要从硬件帧缓冲区中分配和渲染图形缓冲区，就必须要将HAL层中的Gralloc模块加载到当前的进程空间来，并且打开里面的gralloc设备和fb设备，其中，gralloc设备用来分配图形缓冲区，而fb设备用来渲染图形缓冲区。因此，FramebufferNativeWindow类包含了一个类型的alloc_device_t*的成员变量grDev和一个类型为framebuffer_device_t*的成员变量fbDev，它们分别指向HAL层中的Gralloc模块的gralloc设备和fb设备。

       FramebufferNativeWindow类在内部还包含了一个类型为sp的数组buffers，用来描述OpenGL库可以使用的图形缓冲区，数组的大小等于NUM_FRAME_BUFFERS，即等于硬件帧缓冲区能够提供的图形缓冲区的个数。例如，在Android 2.3系统中，硬件帧缓冲区能够提供的图形缓冲区的个数等于2，这意味着Android系统可以使用双缓冲区技术来渲染系统的UI。由于OpenGL库所使用的图形缓冲区必须要实现android_native_buffer_t接口，因此，NativeBuffer类继承了android_native_buffer_t类。此外，NativeBuffer类还继承了LightRefBase类，因此，它的对象就和FramebufferNativeWindow类对象一样，可以结合Android系统的轻量级指针sp来使用，以便可以自动维护生命周期。

       了解了FramebufferNativeWindow类的作用之后，接下来我们就从它的构造函数开始分析它的实现，即分析它的类对象的创建过程。从前面DisplayHardware类的成员函数init的实现可以知道，FramebufferNativeWindow对象是在DisplayHardware对象初始化的过程中创建的，并且包含在DisplayHardware对象内部中，用来管理硬件帧缓冲区。

        FramebufferNativeWindow类的构造函数定义在文件frameworks/base/libs/ui/FramebufferNativeWindow.cpp中，它的实现比较长，我们分段来阅读：

[cpp] view plain copy print ?
  1. FramebufferNativeWindow::FramebufferNativeWindow()  
  2.     : BASE(), fbDev(0), grDev(0), mUpdateOnDemand(false)  
  3. {  
  4.     hw_module_t const* module;  
  5.     if (hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module) == 0) {  
  6.         int stride;  
  7.         int err;  
  8.         int i;  
  9.         err = framebuffer_open(module, &fbDev);  
  10.         LOGE_IF(err, "couldn't open framebuffer HAL (%s)", strerror(-err));  
  11.   
  12.         err = gralloc_open(module, &grDev);  
  13.         LOGE_IF(err, "couldn't open gralloc HAL (%s)", strerror(-err));  
  14.   
  15.         // bail out if we can't initialize the modules   
  16.         if (!fbDev || !grDev)  
  17.             return;  
  18.   
  19.         mUpdateOnDemand = (fbDev->setUpdateRect != 0);  
  20.   
  21.         // initialize the buffer FIFO   
  22.         mNumBuffers = NUM_FRAME_BUFFERS;  
  23.         mNumFreeBuffers = NUM_FRAME_BUFFERS;  
  24.         mBufferHead = mNumBuffers-1;  
FramebufferNativeWindow::FramebufferNativeWindow()
    : BASE(), fbDev(0), grDev(0), mUpdateOnDemand(false)
{
    hw_module_t const* module;
    if (hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module) == 0) {
        int stride;
        int err;
        int i;
        err = framebuffer_open(module, &fbDev);
        LOGE_IF(err, "couldn't open framebuffer HAL (%s)", strerror(-err));

        err = gralloc_open(module, &grDev);
        LOGE_IF(err, "couldn't open gralloc HAL (%s)", strerror(-err));

        // bail out if we can't initialize the modules
        if (!fbDev || !grDev)
            return;

        mUpdateOnDemand = (fbDev->setUpdateRect != 0);

        // initialize the buffer FIFO
        mNumBuffers = NUM_FRAME_BUFFERS;
        mNumFreeBuffers = NUM_FRAME_BUFFERS;
        mBufferHead = mNumBuffers-1;
        这段代码首先调用函数hw_get_module来将HAL层中的Gralloc模块加载到当前进程来，并且调用函数framebuffer_open和gralloc_open分别打开Gralloc模块中的fb设备和gralloc设备。这三个过程的实现可以参考前面 Android帧缓冲区（Frame Buffer）硬件抽象层（HAL）模块Gralloc的实现原理分析一文。Gralloc模块中的fb设备和gralloc设备打开之后，就分别保存在FramebufferNativeWindow类的成员变量fbDev和grDev中。

        这段代码接着判断硬件帧缓冲区是否支持部区更新UI。如果支持的话，那么从Gralloc模块中打开的fb设备的成员函数setUpdateRect就不等于0。这时候这段代码就会FramebufferNativeWindow类的成员变量mUpdateOnDemand的值设置为true。

        这段代码最后还会将FramebufferNativeWindow类的成员变量mNumBuffers和mNumFreeBuffers的值均设置为NUM_FRAME_BUFFERS，它们分别用来描述硬件帧缓冲区可以提供的图形缓冲区的个数，以及当前可用的空闲图形缓冲区的个数。此外，FramebufferNativeWindow类的成员变量mBufferHead的值还会被设置为（NUM_FRAME_BUFFERS - 1），表示下一个可用的空闲图形缓冲区在FramebufferNativeWindow类的成员变量buffers所描述的一个图形缓冲区数组的位置。

         我们接着往下阅读代码：

[cpp] view plain copy print ?
  1. for (i = 0; i < mNumBuffers; i++)  
  2. {  
  3.         buffers[i] = new NativeBuffer(  
  4.                 fbDev->width, fbDev->height, fbDev->format, GRALLOC_USAGE_HW_FB);  
  5. }  
  6.   
  7. for (i = 0; i < mNumBuffers; i++)  
  8. {  
  9.         err = grDev->alloc(grDev,  
  10.                 fbDev->width, fbDev->height, fbDev->format,  
  11.                 GRALLOC_USAGE_HW_FB, &buffers[i]->handle, &buffers[i]->stride);  
  12.   
  13.         LOGE_IF(err, "fb buffer %d allocation failed w=%d, h=%d, err=%s",  
  14.                 i, fbDev->width, fbDev->height, strerror(-err));  
  15.   
  16.         if (err)  
  17.         {  
  18.                 mNumBuffers = i;  
  19.                 mNumFreeBuffers = i;  
  20.                 mBufferHead = mNumBuffers-1;  
  21.                 break;  
  22.         }  
  23. }  
        for (i = 0; i < mNumBuffers; i++)
        {
                buffers[i] = new NativeBuffer(
                        fbDev->width, fbDev->height, fbDev->format, GRALLOC_USAGE_HW_FB);
        }

        for (i = 0; i < mNumBuffers; i++)
        {
                err = grDev->alloc(grDev,
                        fbDev->width, fbDev->height, fbDev->format,
                        GRALLOC_USAGE_HW_FB, &buffers[i]->handle, &buffers[i]->stride);

                LOGE_IF(err, "fb buffer %d allocation failed w=%d, h=%d, err=%s",
                        i, fbDev->width, fbDev->height, strerror(-err));

                if (err)
                {
                        mNumBuffers = i;
                        mNumFreeBuffers = i;
                        mBufferHead = mNumBuffers-1;
                        break;
                }
        }
        这段代码用来创建FramebufferNativeWindow类的成员变量buffers所描述的一个图形缓冲区数组。每一个图形缓冲区都使用一个NativeBuffer对象来描述，并且这些图形缓冲区都是通过调用HAL层中的Gralloc模块的gralloc设备的成员函数alloc来分配的。注意，在分配图形缓冲区时，指定的标志，即第5个参数的值为GRALLOC_USAGE_HW_FB。这意味着FramebufferNativeWindow类所管理的图形缓冲区都是直接在硬件帧缓冲区上分配的，而不是在匿名共享内存中分配的。

        我们接着往下阅读代码：

[cpp] view plain copy print ?
  1. const_cast(ANativeWindow::flags) = fbDev->flags;  
  2. const_cast<float&>(ANativeWindow::xdpi) = fbDev->xdpi;  
  3. const_cast<float&>(ANativeWindow::ydpi) = fbDev->ydpi;  
  4. const_cast<int&>(ANativeWindow::minSwapInterval) =  
  5.     fbDev->minSwapInterval;  
  6. const_cast<int&>(ANativeWindow::maxSwapInterval) =  
  7.     fbDev->maxSwapInterval;  
  8. se {  
  9. LOGE("Couldn't get gralloc module");  
        const_cast(ANativeWindow::flags) = fbDev->flags;
        const_cast(ANativeWindow::xdpi) = fbDev->xdpi;
        const_cast(ANativeWindow::ydpi) = fbDev->ydpi;
        const_cast(ANativeWindow::minSwapInterval) =
            fbDev->minSwapInterval;
        const_cast(ANativeWindow::maxSwapInterval) =
            fbDev->maxSwapInterval;
    } else {
        LOGE("Couldn't get gralloc module");
    }
        这段代码主要就是用来设置FramebufferNativeWindow的父类ANativeWindow的成员变量flags、xdpi、ydpi、minSwapInternal和maxSwapInterval的值，以便OpenGL库可以知道系统当前所使用的硬件帧缓冲区的一些属性，例如，点密度、缓冲区数据交换时间间隔等信息。这些成员变量的具体含义可以参考前面 Android应用程序请求SurfaceFlinger服务创建Surface的过程分析一文所提到的Surface类的初始化过程。

        我们接着往下阅读代码：

[cpp] view plain copy print ?
  1.     ANativeWindow::setSwapInterval = setSwapInterval;  
  2.     ANativeWindow::dequeueBuffer = dequeueBuffer;  
  3.     ANativeWindow::lockBuffer = lockBuffer;  
  4.     ANativeWindow::queueBuffer = queueBuffer;  
  5.     ANativeWindow::query = query;  
  6.     ANativeWindow::perform = perform;  
  7. }  
    ANativeWindow::setSwapInterval = setSwapInterval;
    ANativeWindow::dequeueBuffer = dequeueBuffer;
    ANativeWindow::lockBuffer = lockBuffer;
    ANativeWindow::queueBuffer = queueBuffer;
    ANativeWindow::query = query;
    ANativeWindow::perform = perform;
}
        这段代码用来设置FramebufferNativeWindow的父类ANativeWindow的成员函数setSwapInterval、dequeueBuffer、lockBuffer、queueBuffer、query和perform，它们都是OpenGL的回调接口，分别指向FramebufferNativeWindow类的静态成员函数setSwapInterval、dequeueBuffer、lockBuffer、queueBuffer、query和perform。与前面 Android应用程序请求SurfaceFlinger服务创建Surface的过程分析一文所提到的Surface类一样，我们只关注FramebufferNativeWindow类的静态成员函数dequeueBuffer和queueBuffer的实现，因为它们负责用来为OpenGL库分配和渲染图形缓冲区。

        FramebufferNativeWindow类的成员函数dequeueBuffer的实现如下所示：

[cpp] view plain copy print ?
  1. int FramebufferNativeWindow::dequeueBuffer(ANativeWindow* window,  
  2.         android_native_buffer_t** buffer)  
  3. {  
  4.     FramebufferNativeWindow* self = getSelf(window);  
  5.     Mutex::Autolock _l(self->mutex);  
  6.     framebuffer_device_t* fb = self->fbDev;  
  7.   
  8.     int index = self->mBufferHead++;  
  9.     if (self->mBufferHead >= self->mNumBuffers)  
  10.         self->mBufferHead = 0;  
  11.   
  12.     GraphicLog& logger(GraphicLog::getInstance());  
  13.     logger.log(GraphicLog::SF_FB_DEQUEUE_BEFORE, index);  
  14.   
  15.     // wait for a free buffer   
  16.     while (!self->mNumFreeBuffers) {  
  17.         self->mCondition.wait(self->mutex);  
  18.     }  
  19.     // get this buffer   
  20.     self->mNumFreeBuffers--;  
  21.     self->mCurrentBufferIndex = index;  
  22.   
  23.     *buffer = self->buffers[index].get();  
  24.   
  25.     logger.log(GraphicLog::SF_FB_DEQUEUE_AFTER, index);  
  26.     return 0;  
  27. }  
int FramebufferNativeWindow::dequeueBuffer(ANativeWindow* window,
        android_native_buffer_t** buffer)
{
    FramebufferNativeWindow* self = getSelf(window);
    Mutex::Autolock _l(self->mutex);
    framebuffer_device_t* fb = self->fbDev;

    int index = self->mBufferHead++;
    if (self->mBufferHead >= self->mNumBuffers)
        self->mBufferHead = 0;

    GraphicLog& logger(GraphicLog::getInstance());
    logger.log(GraphicLog::SF_FB_DEQUEUE_BEFORE, index);

    // wait for a free buffer
    while (!self->mNumFreeBuffers) {
        self->mCondition.wait(self->mutex);
    }
    // get this buffer
    self->mNumFreeBuffers--;
    self->mCurrentBufferIndex = index;

    *buffer = self->buffers[index].get();

    logger.log(GraphicLog::SF_FB_DEQUEUE_AFTER, index);
    return 0;
}
       这个函数定义在文件frameworks/base/libs/ui/FramebufferNativeWindow.cpp中。

       参数window虽然是一个类型为ANativeWindow的指针，但是它指向的实际上是一个FramebufferNativeWindow对象，这个FramebufferNativeWindow对象是在DisplayHardware类的成员函数init中创建的，因此，函数在开始的地方就可以将它转换一个FramebufferNativeWindow对象self。

       有了FramebufferNativeWindow对象self之后，我们就可以在它内部的图形缓冲区数组buffers中获取下一个空闲图形缓冲区。前面提到，下一个空闲图形缓冲区的在数组buffer中的位置就保存在FramebufferNativeWindow对象self的成员变量mBufferHead中。因此，函数就可以将FramebufferNativeWindow对象self的成员变量mBufferHead的值取出来保存在变量index中，以便接下来可以从FramebufferNativeWindow对象self内部的图形缓冲区数组buffers中取出一个图形缓冲区。此外，函数还需要将FramebufferNativeWindow对象self的成员变量mBufferHead增加1，以便它可以指向下一个空闲的图形缓冲区。注意，FramebufferNativeWindow对象self内部的图形缓冲区数组buffers是循环使用的，因此，在将它的成员变量mBufferHead增加1之后，要判断它的值是否已经大于等于数组的大小，如果大于等于的话，就需要将它的值设置为0，即绕回到前面去。

       从前面的分析可以知道，FramebufferNativeWindow对象self内部可用的空闲图形缓冲区的个数保存在其成员变量mNumFreeBuffers中，因此，当这个成员变量的值等于0的时候，就表示FramebufferNativeWindow对象self没有空闲的空闲图形缓冲区可用，这时候当前线程就会通过FramebufferNativeWindow对象self的成员变量mCondition所描述的一个条件变量进入到睡眠等待状态，直到有可用的空闲图形缓冲区为止。什么时候FramebufferNativeWindow对象self内部才会有可用的空闲图形缓冲区呢？当OpenGL库请求FramebufferNativeWindow对象self将一个图形缓冲区的内容渲染到硬件帧缓冲区之后，FramebufferNativeWindow对象self就会获得一个可用的空闲图形缓冲区了，后面我们分析FramebufferNativeWindow类的成员函数queueBuffer的实现时就会看到这个逻辑。

       一旦FramebufferNativeWindow对象self内部有可用的空闲图形缓冲区，那么函数就会将这个空闲图形缓冲区就会返回给OpenGL库，即保存在输出参数buffer，并且将FramebufferNativeWindow对象self内部可用的空闲图形缓冲区的个数减1，以及将OpenGL库当前正前正在使用的图形缓冲区在数组buffers中的位置保存在FramebufferNativeWindow对象self的成员变量mCurrentBufferIndex中。

       至此，我们就分析完成FramebufferNativeWindow类的成员函数dequeueBuffer的实现了，接下来我们继续分析FramebufferNativeWindow类的成员函数queueBuffer的实现，如下所示：

[cpp] view plain copy print ?
  1. int FramebufferNativeWindow::queueBuffer(ANativeWindow* window,  
  2.         android_native_buffer_t* buffer)  
  3. {  
  4.     FramebufferNativeWindow* self = getSelf(window);  
  5.     Mutex::Autolock _l(self->mutex);  
  6.     framebuffer_device_t* fb = self->fbDev;  
  7.     buffer_handle_t handle = static_cast(buffer)->handle;  
  8.   
  9.     const int index = self->mCurrentBufferIndex;  
  10.     GraphicLog& logger(GraphicLog::getInstance());  
  11.     logger.log(GraphicLog::SF_FB_POST_BEFORE, index);  
  12.   
  13.     int res = fb->post(fb, handle);  
  14.   
  15.     logger.log(GraphicLog::SF_FB_POST_AFTER, index);  
  16.   
  17.     self->front = static_cast(buffer);  
  18.     self->mNumFreeBuffers++;  
  19.     self->mCondition.broadcast();  
  20.     return res;  
  21. }  
int FramebufferNativeWindow::queueBuffer(ANativeWindow* window,
        android_native_buffer_t* buffer)
{
    FramebufferNativeWindow* self = getSelf(window);
    Mutex::Autolock _l(self->mutex);
    framebuffer_device_t* fb = self->fbDev;
    buffer_handle_t handle = static_cast(buffer)->handle;

    const int index = self->mCurrentBufferIndex;
    GraphicLog& logger(GraphicLog::getInstance());
    logger.log(GraphicLog::SF_FB_POST_BEFORE, index);

    int res = fb->post(fb, handle);

    logger.log(GraphicLog::SF_FB_POST_AFTER, index);

    self->front = static_cast(buffer);
    self->mNumFreeBuffers++;
    self->mCondition.broadcast();
    return res;
}
        这个函数定义在文件frameworks/base/libs/ui/FramebufferNativeWindow.cpp中。

        参数window指向的实际上也是一个FramebufferNativeWindow对象，这个FramebufferNativeWindow对象是在DisplayHardware类的成员函数init中创建的，因此，函数在开始的地方同样是先将它转换一个FramebufferNativeWindow对象self。

        参数buffer指向的是一个实际类型为NativeBuffer的图形缓冲区，这个图形缓冲区是在FramebufferNativeWindow类的成员函数dequeueBuffer中分配的，如前所述。

        FramebufferNativeWindow类的成员函数queueBuffer目标就是要将参数buffer所描述的图形缓冲区渲染到硬件帧缓冲区中去，因此，我们就需要获得FramebufferNativeWindow对象self的成员变量fbDev所描述的一个fb设备。有了这个fb设备之后， 我们就可以调用它的成员函数post来将参数buffer所描述的图形缓冲区渲染到硬件帧缓冲区中去，这个过程可以参考Android帧缓冲区（Frame Buffer）硬件抽象层（HAL）模块Gralloc的实现原理分析一文。

       参数buffer所描述的图形缓冲区被渲染到硬件帧缓冲区中去之后，它就变成一个空闲的图形缓冲区了，因此，我们就需要将它返回给FramebufferNativeWindow对象self内部的图形缓冲区数组buffers中去，并且将可用的空闲图形缓冲区的个数增加1，最后通过FramebufferNativeWindow对象self的成员变量mCondition所描述的一个条件变量将前面正在等待从FramebufferNativeWindow对象self内部分配空闲图形缓的线程唤醒。

       至此，FramebufferNativeWindow类的成员函数queueBuffer的实现就分析完成了，FramebufferNativeWindow类的实现也分析完成了。通过GraphicPlane、DisplayHardware和FramebufferNativeWindow这三个类的实现，我们就可以知道SurfaceFlinger服务是如何管理系统的显示屏，即系统的硬件帧缓冲区的了。

       从SurfaceFlinger服务创建一个DisplayHardwareBase对象来管理系统的显示屏的过程可以知道，这个DisplayHardwareBase对象会创建一个控制台事件监控线程来监控硬件帧缓冲区的睡眠/唤醒状态切换事件，而从前面Android系统Surface制的SurfaceFlinger服务的启动过程分析一文又可以知道，System进程在启动SurfaceFlinger服务过程中，又会创建一个Binder线程池，以及为SurfaceFlinger服务创建一个UI渲染线程，这样在SurfaceFlinger服务中，就存在三种不同类型的线程，在接下来的一篇文章中，我们就将分析详细SurfaceFlinger服务的线程模型，以便最后我们就可以更好地分析SurfaceFlinger服务的实现，敬请关注！

你可能感兴趣的:(fb)

  • 高仿包包批发在哪里买最便宜?推荐6个购买渠道 鸿运工作室
    高仿包包作为一种时尚单品，受到很多人的喜爱。然而，对于批发高仿包包的人来说，如何找到最便宜的购买渠道是一个关键问题。本文将为您推荐6个购买高仿包包最便宜的渠道，帮助您更好地满足批发需求。咨询加微信：FB2260(下单赠送精美礼品)1.义乌国际商贸城义乌国际商贸城是中国最大的小商品批发市场之一，也是高仿包包批发的热门地点。这里有众多的批发商聚集，提供了各种各样的高仿包包，价格相对较低。您可以在这里找
  • python语法——三目运算符 HappyRocking pythonpython三目运算符
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
  • python-pcl函数_Python简介，第4章-函数 cumei1658 javawebglpythonluaios
    python-pcl函数Runningthroughthedoor,Baldricfoundhimselfinanenormouscavern,itsceilinglostinshadow.Greatcolumnsofblackstonesoaredfromtheground,andpoolsoflavabubbledthroughout,lightingthecaverninadarkred.T
  • ComfyUI中的sam模型国内下载方法 jayli517 ComfyUIpythonstablediffusion
    was-node-suite-comfyui这个节点安装的时候，有它内部的config配置文件，里面其实给了一些下载地址，配置文件里是这么写的："sam_model_vith_url":"https://dl.fbaipublicfiles.com/segment_anything/sam_vit_h_4b8939.pth","sam_model_vitl_url":"https://dl.fba
  • 以假乱真的高仿手表在哪里买，2024分享最新渠道 鸿运工作室
    大家好，今天我要给大家分享一些关于如何购买高仿手表的最新渠道。这些信息都是我通过研究和调查得来的，希望能对大家有所帮助。【更多详情加薇信了解：FB2260】首先，我想提醒大家的是，购买高仿手表并不是一种违法行为。高仿手表与正品手表在外观和性能上并没有太大的差别，只是价格更为低廉。对于那些想要拥有一块高品质手表但又不想花费太多的人来说，购买高仿手表是一个不错的选择。那么，在哪里可以买到高仿手表呢？其
  • 【Python爬虫】百度百科词条内容 PokiFighting 数据处理python爬虫开发语言
    词条内容我这里随便选取了一个链接，用的是FBI的词条importurllib.requestimporturllib.parsefromlxmlimportetreedefquery(url):headers={'user-agent':'Mozilla/5.0(WindowsNT6.1;Win64;x64)AppleWebKit/537.36(KHTML,likeGecko)Chrome/80.
  • SFBT其他重要晤谈技巧与原则 金JJ
    中原焦点团队坚持原创分享第1438天1.以“澄清式自我揭露”与“温和挑战”取代面质。Sfbt不建议咨询师告诉当事人有关自己的过去经验，而是用澄清的方式询问当事人，并仍然扣着目标导向与优势的观点，这样的自我阐述能催化当事人面对自己的挣扎，在澄清中看到自己的优势力量，进而愿意继续往解决导向的路线前进。SFBT咨询师不强烈面质当事人的不一致，而采用较为温和的自我揭露方式，来澄清咨询师所发现当事人矛盾之处
  • 2021-12-01 MA马
    中原焦点团队网初26期马红2021--12--1日坚持分享第302天例外及正向经验的重视，促进来访者正向的自我意识。也就是说，SFBT重视例外经验的开发，将能增加来访者的自我效能、自我肯定、胜任感等赋能感，并且改变来访者内在的主管知觉，对自己产生合理的、全面的、正向的评估，甚至带出自己是能够独立、能够保护自己、能够改变环境的意愿，信心与动力。
  • 精仿手表在哪里买【2024科普一下】 桃朵桃朵
    在2024年，随着科技的进步和互联网的普及，购买精仿手表的渠道和方式也变得越来越多样化。为了帮助大家更好地了解如何购买精仿手表，本文将科普一下相关的知识和技巧。【更多详情加薇信了解：FB2260】首先，要选择可靠的购买渠道。购买精仿手表时，一定要选择正规的商家和平台，避免购买到质量差、假冒伪劣的产品。在选择商家时，可以参考商家的信誉评分、历史评价等信息，确保选择的商家具有良好的信誉。此外，一些知名
  • 利用apache-pdfbox库修改pdf文件模板，进行信息替换 区块链攻城狮 pdf合同模板pdf生成合同生成
    publicStringcreateSignFile(Longid)throwsIOException{//1.验证企业信息CompanyDOcompany=validateCompanyExists(id);//2.验证签约状态if(company.getSignStatus()!=0){throwexception(COMPANY_SIGN_STATUS_NOT_ZERO);}//3.获取合同
  • [bzoj1139]Wie weixin_30437481
    1139:[POI2009]WieTimeLimit:10SecMemoryLimit:259MBDescriptionByteasarhasbecomeahexer-aconquerorofmonsters.CurrentlyheistoreturntohishometownByteburg.Thewayhome,alas,leadsthroughalandfullofbeasts.Fortun
  • 高仿皮带在哪里有卖，推荐十个购买渠道 桃朵桃朵
    高仿皮带是一种常见的配饰，许多人都想要购买一条高仿皮带以搭配自己的服装。然而，在购买高仿皮带时，许多人会遇到一些问题，比如不知道在哪里购买以及如何选择适合自己的高仿皮带。本文将为你推荐十个购买高仿皮带的渠道，让你能够轻松地找到适合自己的高仿皮带。【更多详情加薇信了解：FB2260】1.官方网站官方网站是一个非常可靠的购买渠道。许多高仿皮带品牌都有自己的官方网站，可以直接在网站上购买。官方网站上的高
  • 中原焦点团队网络初级23班 陈松 分享第45天 读书29天 悟_b6c1
    SFBT将赞美和重新建构和称为正向眼光。重新建构是SFBT的一个很重要的技巧与精神。重新建构指的是：我们基于事情不会只有一个面向，从不同看待事情的眼光，看到当事人的特质，优点，动机，努力引导他看见事情的其他方向，进而拓展当事人的思考，引发不同的行动。重新建构的另一个意义是：我们了解了孩子描述的事情并重新诠释后，赋予相同的事件不同不同区正向的意义，看到事件本身所带来的正面价值，进而形成新的解决方案或
  • 徐忠顺刘友龙秦皇岛焦点解决坚持分享第66天2020.04.07 雨顺心理
    助人者SFBT技术，不单纯是一个心理学技术，更是每个人生活哲学的重要组成部分。以往，看到“助人者”时，总是想到的是“咨询师”。而从生活哲学层面看“助人者”是一种广义的称呼，凡是在生活中可能提供他人协助的人都可以称为“助人者”，包括父母、教师、主管、督导、咨询师、社工人员、神职人员、义务助人工作者等；家人、同事、朋友之间，也可能互相帮助。
  • mariadb主从配置步骤 秋月霜风 其他知识标记mariadbandroidadb
    mariadb主从配置步骤配置开始前注意关闭主从服务器的防火墙或者确保主从服务器之间数据库通信正常；主服务器（主IP）配置a.编辑主服务器的MariaDB配置文件：sudovim/etc/my.cnf.d/mariadb-server.cnfb.在[mysqld]部分添加或修改以下内容：[mysqld]server-id=1log-bin=/var/log/mariadb/mysql-binbin
  • 伯爵高仿手表在哪里买:这10个购买渠道一定要看 鸿运工作室
    伯爵高仿手表在哪里买：这10个购买渠道一定要看如果你正在寻找一款高品质的高仿手表，那么伯爵品牌绝对是一个值得考虑的选择。然而，对于许多消费者来说，购买高仿手表时最常遇到的问题是不知道在哪里购买。不用担心，本文将为你介绍10个购买伯爵高仿手表的渠道，让你轻松找到心仪的手表。【更多详情加薇信了解：FB2260】1.官方网站首先，你可以访问伯爵的官方网站。在这里，你可以找到所有伯爵高仿手表的款式和型号，
  • 焦点初13中13坚持分享第218天2019.6.26 ruby吕
    6，生命的亮光。焦点解决短期治疗的例外架构。例外，即优势，资源，力量，成功的统称。持优势观点并看重如何引发当事人自我赋能的sfbt强调:例外的思维是找寻优势，方法与资源的放大镜，例外的内容是形塑自我赋能与解决之道的重要素材。
  • 如何建立员工都能理解的使命和愿景 Kobe24KB
    image亚马逊的创始人兼首席执行官杰夫·贝佐斯（JeffBezos）是这门艺术的大师之一。从他给股东的传奇性年度信件中纪念了仍然是第一天的想法到设定定义整个年度的内部优先事项（例如“让我们的房子井井有条”和“让大婴儿快活”），这些夸夸其谈的言论似乎是不必要的。但实际上，它们对于亚马逊成立初期的发展至关重要。来自在该产品上工作过的EugeneWei：突出的是，即使在十年后的今天，我仍然可以从记忆中
  • 由于生成一个完整的游戏商城代码涉及很多细节和复杂性，我无法在这里直接给出完整的代码示例。但是，我可以为你提供一个简化版的游戏商城核心功能的概念性代码，用几种不同的编程语言来展示。 NewmanEdwarda2 游戏
    Python(伪代码)pythonclassGame:definit(self,name,price):tcjmbj.cnself.name=nameself.price=priceclassGameStore:definit(self):self.games=[]defadd_game(self,game):self.games.append(game)defbuy_game(self,game
  • Hbase - 迁移数据[导出,导入] kikiki5
    >有没有这样一样情况，把一个集群中的某个表导到另一个群集中，或者hbase的表结构发生了更改，但是数据还要，比如预分区没做，导致某台RegionServer很吃紧，Hbase的导出导出都可以很快的完成这些操作。![](https://upload-images.jianshu.io/upload_images/9028759-4fb9aa8ca3777969.png?imageMogr2/auto
  • 基础-3 hellomyshadow
    异常处理error接口：Go中的一个关于错误处理的标准模式，属于Go内建的接口类型；typeerrorinterface{Error()string}使用方式：import"errors"functest(aint,bint)(valueint,errerror){ifb==0{err=errors.New("0不能作为除数！")return}else{value=a/breturn}}funcm
  • 2024高仿手表值不值得买？以下的内容可参考 桃朵桃朵
    在当今社会，高仿手表已经成为一个备受关注的话题。2024年，随着技术的不断进步和市场的不断扩大，高仿手表的质量和外观越来越接近真品，这使得越来越多的消费者开始考虑购买高仿手表。那么，2024年高仿手表到底值不值得买呢？【更多详情加薇信了解：FB2260】首先，我们需要明确什么是高仿手表。高仿手表是指模仿正品手表的外观、功能和材质等方面，但是价格比正品手表低很多的手表。这种手表通常是由一些小作坊或者
  • C生万物 函数的讲解与剖析【内附众多案例详解】 2401_84170337 c语言java开发语言
    printf("交换前：a=%d,b=%d\n",a,b);swap(a,b);printf("交换后：a=%d,b=%d\n",a,b);return0;}*来看一下运行结果。可以看到两个数并没有发生交换![在这里插入图片描述](https://img-blog.csdnimg.cn/04248dabca704086bbe930d12efb1d0a.jpeg#pic_center)*那有小伙伴就
  • 由于没有公钥，无法验证下列签名： NO_PUBKEY 记得往前走 linux运维服务器
    笔者在进行：sudoaptupdate报错：由于没有公钥，无法验证下列签名：NO_PUBKEYF42ED6FBAB17C654正在读取软件包列表...完成解决方案：获取缺失公钥的ID：在您看到"NO_PUBKEY"后面的值，比如"F42ED6FBAB17C654"，这是缺失的公钥的ID。添加缺失的公钥：运行以下命令，将缺失的公钥添加到系统：sudoapt-keyadv--keyserverkeys
  • 小猿圈python学习-内置函数 小猿圈IT教育
    Python的len为什么你可以直接用？肯定是解释器启动时就定义好了内置参数详解https://docs.python.org/3/library/functions.html?highlight=built#ascii每个函数的作用我都帮你标好了abs#求绝对值all#ReturnTrueifbool(x)isTrueforallvaluesxintheiterable.Iftheiterabl
  • 第22天：如何使用OpenAI Gym和Universe构建AI游戏机器人 cumi7754 游戏人工智能pythonjava编程语言
    byHariniJanakiraman通过哈里尼·贾纳基拉曼第22天：如何使用OpenAIGym和Universe构建AI游戏机器人(Day22:HowtobuildanAIGameBotusingOpenAIGymandUniverse)Let’sfaceit,AIiseverywhere.Aface-offbattleisunfoldingbetweenElonMuskandMarkZucke
  • 2021-04-20 快乐有我_c00f
    大荔县心理咨询协会郭亚婵坚持分享第138天：《家庭中的正面管教》第15天——耐心引导孩子找到“成功的例外”沙中淘金的例外问句例外问句是SFBT的三大架构之一，是一种很重要的谈话方向。SFBT的基本假设之一就是凡事都有例外。例外的思考原则会让我们区分“问题发生时”“问题较少发生时”以及“问题没有发生时”，而不会一直只专注在问题上面。SFBT相信孩子在与我们谈话之前，他就已经在为解决问题做准备，只是他
  • 臧利娜焦点网初第34期坚持分享第121天 2022.08.04 ccd84ccf3e2a
    SFBT认为情绪是当事人知觉中一个重要的部分，但情绪不会比当事人的想法、态度、信念和过去行为来得更重要。亦即，SFBT把情绪视为人们生命中的核心，但不视情绪为一种需要被修补的、有问题的错误反应。所以，对于当事人的情绪会予以接纳认可，并看重其代表的意义与价值。换句话说，SFBT并非不注重当事人的情绪，而是将情绪视为当事人整体知觉的一部分，因此不会特别将当事人的情绪从整体知觉中独立出来予以单独探讨，反
  • Java pdf转jpg tanzongbiao Javajavaeureka开发语言
    org.apache.pdfboxfontbox2.0.26org.apache.pdfboxpdfbox2.0.26PdfToJpgUtil.jpgpackagecom.qyj.utils;importorg.apache.pdfbox.pdmodel.PDDocument;importorg.apache.pdfbox.pdmodel.PDPageTree;importorg.apache.p
  • java pdf转jpg gonepoo 工具类javapdfpdf转jpgjpg代码
    packagecom.xxx;importorg.apache.pdfbox.pdmodel.PDDocument;importorg.apache.pdfbox.pdmodel.PDPageTree;importorg.apache.pdfbox.rendering.PDFRenderer;importjavax.imageio.ImageIO;importjava.awt.image.Buff
  • java短路运算符和逻辑运算符的区别 3213213333332132 java基础
    /* * 逻辑运算符——不论是什么条件都要执行左右两边代码 * 短路运算符——我认为在底层就是利用物理电路的“并联”和“串联”实现的 * 原理很简单，并联电路代表短路或（||），串联电路代表短路与（&&）。 * * 并联电路两个开关只要有一个开关闭合，电路就会通。 * 类似于短路或（||），只要有其中一个为true（开关闭合）是
  • Java异常那些不得不说的事 白糖_ javaexception
    一、在finally块中做数据回收操作 比如数据库连接都是很宝贵的，所以最好在finally中关闭连接。 JDBCAgent jdbc = new JDBCAgent(); try{ jdbc.excute("select * from ctp_log"); }catch(SQLException e){ ... }finally{ jdbc.close();
  • utf-8与utf-8(无BOM)的区别 dcj3sjt126com PHP
    BOM——Byte Order Mark，就是字节序标记   在UCS 编码中有一个叫做"ZERO WIDTH NO-BREAK SPACE"的字符，它的编码是FEFF。而FFFE在UCS中是不存在的字符，所以不应该出现在实际传输中。UCS规范建议我们在传输字节流前，先传输 字符"ZERO WIDTH NO-BREAK SPACE"。这样如
  • JAVA Annotation之定义篇 周凡杨 java注解annotation入门注释
        Annotation: 译为注释或注解 An annotation, in the Java computer programming language, is a form of syntactic metadata that can be added to Java source code. Classes, methods, variables, pa
  • tomcat的多域名、虚拟主机配置 g21121 tomcat
    众所周知apache可以配置多域名和虚拟主机，而且配置起来比较简单，但是项目用到的是tomcat，配来配去总是不成功。查了些资料才总算可以，下面就跟大家分享下经验。 很多朋友搜索的内容基本是告诉我们这么配置： 在Engine标签下增面积Host标签，如下： <Host name="www.site1.com" appBase="webapps"
  • Linux SSH 错误解析（Capistrano 的cap 访问错误 Permission ） 510888780 linuxcapistrano
    1.ssh -v [email protected] 出现 Permission denied (publickey,gssapi-keyex,gssapi-with-mic,password). 错误 运行状况如下： OpenSSH_5.3p1, OpenSSL 1.0.1e-fips 11 Feb 2013 debug1: Reading configuratio
  • log4j的用法 Harry642 javalog4j
    一、前言：     log4j 是一个开放源码项目，是广泛使用的以Java编写的日志记录包。由于log4j出色的表现，     当时在log4j完成时，log4j开发组织曾建议sun在jdk1.4中用log4j取代jdk1.4 的日志工具类，但当时jdk1.4已接近完成，所以sun拒绝使用log4j，当在java开发中
  • mysql、sqlserver、oracle分页，java分页统一接口实现 aijuans oraclejave
    定义：pageStart 起始页，pageEnd 终止页,pageSize页面容量 oracle分页： 　　　　select * from ( select mytable.*,rownum num from (实际传的SQL) where rownum<=pageEnd) where num>=pageStart sqlServer分页：  
  • Hessian 简单例子 antlove javaWebservicehessian
    hello.hessian.MyCar.java package hessian.pojo; import java.io.Serializable; public class MyCar implements Serializable { private static final long serialVersionUID = 473690540190845543
  • 数据库对象的同义词和序列 百合不是茶 sql序列同义词ORACLE权限
    回顾简单的数据库权限等命令; 解锁用户和锁定用户 alter user scott account lock/unlock; //system下查看系统中的用户 select * dba_users; //创建用户名和密码 create user wj identified by wj; identified by //授予连接权和建表权 grant connect to
  • 使用Powermock和mockito测试静态方法 bijian1013 持续集成单元测试mockitoPowermock
            实例： package com.bijian.study; import static org.junit.Assert.assertEquals; import java.io.IOException; import org.junit.Before; import org.junit.Test; import or
  • 精通Oracle10编程SQL(6)访问ORACLE bijian1013 oracle数据库plsql
    /* *访问ORACLE */ --检索单行数据 --使用标量变量接收数据 DECLARE v_ename emp.ename%TYPE; v_sal emp.sal%TYPE; BEGIN select ename,sal into v_ename,v_sal from emp where empno=&no; dbms_output.pu
  • 【Nginx四】Nginx作为HTTP负载均衡服务器 bit1129 nginx
     Nginx的另一个常用的功能是作为负载均衡服务器。一个典型的web应用系统，通过负载均衡服务器，可以使得应用有多台后端服务器来响应客户端的请求。一个应用配置多台后端服务器，可以带来很多好处：   负载均衡的好处 增加可用资源 增加吞吐量 加快响应速度，降低延时 出错的重试验机制 Nginx主要支持三种均衡算法： round-robin l
  • jquery-validation备忘 白糖_ jquerycssF#Firebug
    留点学习jquery validation总结的代码：   function checkForm(){ validator = $("#commentForm").validate({// #formId为需要进行验证的表单ID errorElement :"span",// 使用"div"标签标记错误， 默认:&
  • solr限制admin界面访问（端口限制和http授权限制） ronin47 限定Ip访问
    solr的管理界面可以帮助我们做很多事情，但是把solr程序放到公网之后就要限制对admin的访问了。 可以通过tomcat的http基本授权来做限制，也可以通过iptables防火墙来限制。 我们先看如何通过tomcat配置http授权限制。 第一步： 在tomcat的conf/tomcat-users.xml文件中添加管理用户，比如： <userusername="ad
  • 多线程-用JAVA写一个多线程程序，写四个线程，其中二个对一个变量加1，另外二个对一个变量减1 bylijinnan java多线程
    public class IncDecThread { private int j=10; /* * 题目:用JAVA写一个多线程程序，写四个线程，其中二个对一个变量加1，另外二个对一个变量减1 * 两个问题： * 1、线程同步--synchronized * 2、线程之间如何共享同一个j变量--内部类 */ public static
  • 买房历程 cfyme
        2015-06-21: 万科未来城，看房子   2015-06-26: 办理贷款手续，贷款73万，贷款利率5.65=5.3675   2015-06-27: 房子首付,签完合同   2015-06-28，央行宣布降息 0.25，就2天的时间差啊，没赶上。   首付，老婆找他的小姐妹接了5万，另外几个朋友借了1-
  • [军事与科技]制造大型太空战舰的前奏 comsci 制造
           天气热了........空调和电扇要准备好..........        最近,世界形势日趋复杂化,战争的阴影开始覆盖全世界..........        所以,我们不得不关
  • dateformat dai_lm DateFormat
    "Symbol Meaning Presentation Ex." "------ ------- ------------ ----" "G era designator (Text) AD" "y year
  • Hadoop如何实现关联计算 datamachine mapreducehadoop关联计算
        选择Hadoop，低成本和高扩展性是主要原因，但但它的开发效率实在无法让人满意。     以关联计算为例。     假设：HDFS上有2个文件，分别是客户信息和订单信息，customerID是它们之间的关联字段。如何进行关联计算，以便将客户名称添加到订单列表中？   &nbs
  • 用户模型中修改用户信息时，密码是如何处理的 dcj3sjt126com yii
    当我添加或修改用户记录的时候对于处理确认密码我遇到了一些麻烦，所有我想分享一下我是怎么处理的。 场景是使用的基本的那些(系统自带)，你需要有一个数据表(user)并且表中有一个密码字段(password),它使用 sha1、md5或其他加密方式加密用户密码。 面是它的工作流程: 当创建用户的时候密码需要加密并且保存，但当修改用户记录时如果使用同样的场景我们最终就会把用户加密过的密码再次加密，这
  • 中文 iOS/Mac 开发博客列表 dcj3sjt126com Blog
      本博客列表会不断更新维护，如果有推荐的博客，请到此处提交博客信息。 本博客列表涉及的文章内容支持 定制化Google搜索，特别感谢 JeOam 提供并帮助更新。 本博客列表也提供同步更新的OPML文件（下载OPML文件），可供导入到例如feedly等第三方定阅工具中，特别感谢 lcepy 提供自动转换脚本。这里有导入教程。
  • js去除空格，去除左右两端的空格 蕃薯耀 去除左右两端的空格js去掉所有空格js去除空格
    js去除空格，去除左右两端的空格 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>&g
  • SpringMVC4零配置--web.xml hanqunfeng springmvc4
    servlet3.0+规范后，允许servlet，filter，listener不必声明在web.xml中，而是以硬编码的方式存在，实现容器的零配置。 ServletContainerInitializer：启动容器时负责加载相关配置 package javax.servlet; import java.util.Set; public interface ServletContainer
  • 《开源框架那些事儿21》：巧借力与借巧力 j2eetop 框架UI
    同样做前端UI，为什么有人花了一点力气，就可以做好？而有的人费尽全力，仍然错误百出？我们可以先看看几个故事。 故事1：巧借力，乌鸦也可以吃核桃 有一个盛产核桃的村子，每年秋末冬初，成群的乌鸦总会来到这里，到果园里捡拾那些被果农们遗落的核桃。 核桃仁虽然美味，但是外壳那么坚硬，乌鸦怎么才能吃到呢？原来乌鸦先把核桃叼起，然后飞到高高的树枝上，再将核桃摔下去，核桃落到坚硬的地面上，被撞破了，于是，
  • JQuery EasyUI 验证扩展 可怜的猫 jqueryeasyui验证
      最近项目中用到了前端框架-- EasyUI，在做校验的时候会涉及到很多需要自定义的内容，现把常用的验证方式总结出来，留待后用。   以下内容只需要在公用js中添加即可。   使用类似于如下： <input class="easyui-textbox" name="mobile" id="mobile&
  • 架构师之httpurlconnection----------读取和发送(流读取效率通用类) nannan408
    1.前言.    如题. 2.代码. /* * Copyright (c) 2015, S.F. Express Inc. All rights reserved. */ package com.test.test.test.send; import java.io.IOException; import java.io.InputStream
  • Jquery性能优化 r361251 JavaScriptjquery
    一、注意定义jQuery变量的时候添加var关键字 这个不仅仅是jQuery，所有javascript开发过程中，都需要注意，请一定不要定义成如下： $loading = $('#loading'); //这个是全局定义，不知道哪里位置倒霉引用了相同的变量名，就会郁闷至死的 二、请使用一个var来定义变量 如果你使用多个变量的话，请如下方式定义： . 代码如下: var page
  • 在eclipse项目中使用maven管理依赖 tjj006 eclipsemaven
    概览: 如何导入maven项目至eclipse中 建立自有Maven  Java类库服务器 建立符合maven代码库标准的自定义类库 Maven在管理Java类库方面有巨大的优势，像白衣所说就是非常“环保”。 我们平时用IDE开发都是把所需要的类库一股脑的全丢到项目目录下，然后全部添加到ide的构建路径中，如果用了SVN/CVS，这样会很容易就 把
  • 中国天气网省市级联页面 x125858805 级联
    1、页面及级联js <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%> <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> &l
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他