Android 4.4 Graphic系统详解(1) SurfaceFlinger的启动过程

init启动SurfaceFlinger

SurfaceFlinger目前的启动方式是做为init进程中的一个Service来启动。
在init中添加如下配置代码:

 
 
  1. # Set this property so surfaceflinger is not started by system_init  
  2. setprop system_init.startsurfaceflinger 0  
  3.   
  4. service surfaceflinger /system/bin/surfaceflinger  
  5. class main  
  6. user system  
  7. group graphics drmrpc  
  8. onrestart restart zygote  

系统将启动/system/bin/目录下的surfaceflinger bin文件来运行SurfaceFlinger。

关于init.rc的语法问题,我们将有专门的文章展开讨论(TODO)。

SurfaceFlinger启动过程

我们继续来看下对应的bin文件中的代码,位置在Android\frameworks\native\services\surfaceflinger下。

 
 
  1. int main(int argc, char** argv) {  
  2.     // 1.创建surfaceflinger对象  
  3.     sp<SurfaceFlinger> flinger = new SurfaceFlinger();  
  4.     // initialize before clients can connect  
  5.     // 2.初始化  
  6.     flinger->init();  
  7.     // 3.注册SF服务  
  8.     sp<IServiceManager> sm(defaultServiceManager());  
  9.     sm->addService(String16(SurfaceFlinger::getServiceName()), flinger, false);  
  10.     // 4.运行程序  
  11.     flinger->run();  
  12.     return 0;  
  13. }  

从上面代码中我们看到SF的创建过程主要有四个步骤,我们来逐一分析一下。

1. 创建SF对象

 
 
  1. SurfaceFlinger::SurfaceFlinger()  
  2.     :   BnSurfaceComposer(),  
  3.         mTransactionFlags(0),  
  4.         mTransactionPending(false),  
  5.         mAnimTransactionPending(false),  
  6.         mLayersRemoved(false),  
  7.         mRepaintEverything(0),  
  8.         mRenderEngine(NULL),  
  9.         mBootTime(systemTime()),  
  10.         mVisibleRegionsDirty(false),  
  11.         mHwWorkListDirty(false),  
  12.         mAnimCompositionPending(false),  
  13.         mDebugRegion(0),  
  14.         mDebugFps(0),  
  15.         mDebugDDMS(0),  
  16.         mDebugDisableHWC(0),  
  17.         mDebugDisableTransformHint(0),  
  18.         mDebugInSwapBuffers(0),  
  19.         mLastSwapBufferTime(0),  
  20.         mDebugInTransaction(0),  
  21.         mLastTransactionTime(0),  
  22.         mBootFinished(false),  
  23.         mPrimaryHWVsyncEnabled(false),  
  24.         mHWVsyncAvailable(false),  
  25.         mDaltonize(false),  
  26.         /* Activity-Activity: */  
  27.         mProjectionType(ORTHOGRAPHIC_PROJECTION)  
  28.         /* Activity-Activity: Change End*/  
  29. // End  
  30. {  
  31.     ALOGI("SurfaceFlinger is starting");  
  32.   
  33.     // debugging stuff...  
  34.     char value[PROPERTY_VALUE_MAX];  
  35.   
  36.     property_get("ro.bq.gpu_to_cpu_unsupported", value, "0");  
  37.     mGpuToCpuSupported = !atoi(value);  
  38.   
  39.     property_get("debug.sf.showupdates", value, "0");  
  40.     mDebugRegion = atoi(value);  
  41.     property_get("debug.sf.showfps", value, "0");  
  42.     mDebugFps = atoi(value);  
  43.   
  44.     property_get("debug.sf.ddms", value, "0");  
  45.     mDebugDDMS = atoi(value);  
  46.     if (mDebugDDMS) {  
  47.         if (!startDdmConnection()) {  
  48.             // start failed, and DDMS debugging not enabled  
  49.             mDebugDDMS = 0;  
  50.         }  
  51.     }  
  52.     ALOGI_IF(mDebugRegion, "showupdates enabled");  
  53. //    ALOGI_IF(mDebugFps,          "showfps enabled");  
  54.     ALOGI_IF(mDebugDDMS, "DDMS debugging enabled");  
  55. }  

其实这个创建过程很简单,无非就是初始化了一些值。从配置中读取了一些值。
需要注意的一点是,SurfaceFlinger实现了三个接口:

 
 
  1. class SurfaceFlinger : public BnSurfaceComposer,  
  2.                        private IBinder::DeathRecipient,  
  3.                        private HWComposer::EventHandler  

BnSurfaceComposer意思是指这个Surface混合的native端,这显然也符合我们对SF功能的认识—-用于Layer的混合处理。
另外,我们会在后面消息的处理一节中单独讲解HWComposer::EventHandler接口的作用。

2.初始化

其实相比SurfaceFlinger的创建,初始化做了更多的工作。
这一过程比较复杂,我们分为几部分来分析:

2.1 EGL初始化
 
 
  1. void SurfaceFlinger::init() {  
  2.     ALOGI(  "SurfaceFlinger's main thread ready to run. "  
  3.             "Initializing graphics H/W...");  
  4.     status_t err;  
  5.     Mutex::Autolock _l(mStateLock);  
  6.     // initialize EGL for the default display  
  7.     mEGLDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);  
  8.     eglInitialize(mEGLDisplay, NULL, NULL);  
  9.    ...  
  10.    }  

首先SF初始化时,会进行一些EGL的初始化工作。
我们知道EGL是用来管理绘图表面(Drawing surfaces),并且提供了如下的机制
1) 与本地窗口系统进行通信(本地窗口在X-Window下是XDisplay ID,在MS Windows下是Window DC,而在Android平台上EGL是NativeDisplayType)
2) 查找绘图表面可用的类型和配置信息
3) 创建绘图表面
4) 同步OpenGL ES 2.0和其他的渲染API(Open VG、本地窗口系统的绘图命令等)
5) 管理渲染资源,比如材质

eglGetDisplay调用egl_display_t::get_display(dpy)获取(连接)显示设备的句柄。
egl_display_t结构用来存储get_display函数获取的物理显示设备。
这里的EGL_DEFAULT_DISPLAY类型是NativeDisplayType,是一个关联系统物理屏幕的通用数据类型。

每个 EGLDisplay 在使用前都需要通过eglInitialize函数来初始化。初始化 EGLDisplay 的同时,你可以得到系统中 EGL 的实现版本号。

这个整个过程是由平台实现的,我们看不到具体实现代码(libagl里面有一套谷歌的实现,但是非常简单)。

2.2 创建HWComposer
 
 
  1. {  
  2. ...  
  3. // Initialize the H/W composer object.  There may or may not be an  
  4.     // actual hardware composer underneath.  
  5.     mHwc = new HWComposer(this,  
  6.             *static_cast<HWComposer::EventHandler *>(this));  
  7. ...  
  8. }  

接下来是创建了一个HWComposer,也就是一个负责硬件合成的模块。但是我们也看到上面的注释明确写着,下面可能并没有一个真正的硬件支持。我们来研究下这个HWComposer的创建过程:

 
 
  1. HWComposer::HWComposer(  
  2.         const sp<SurfaceFlinger>& flinger,  
  3.         EventHandler& handler)  
  4.     : mFlinger(flinger),  
  5.       mFbDev(0), mHwc(0), mNumDisplays(1),  
  6.       mCBContext(new cb_context),  
  7.       mEventHandler(handler),  
  8.       mDebugForceFakeVSync(false)  
  9. {  
  10.     for (size_t i =0 ; i<MAX_HWC_DISPLAYS ; i++) {  
  11.         mLists[i] = 0;  
  12.     }  
  13.     //首先是一些和VSYNC有关的信息的初始化  
  14.     //因为在硬件支持的情况下,VSYNC的功能就是由HWC提供的  
  15.     for (size_t i=0 ; i<HWC_NUM_PHYSICAL_DISPLAY_TYPES ; i++) {  
  16.         mLastHwVSync[i] = 0;  
  17.         mVSyncCounts[i] = 0;  
  18.     }  
  19.     //根据配置来看是否需要模拟VSYNC消息  
  20.     char value[PROPERTY_VALUE_MAX];  
  21.     property_get("debug.sf.no_hw_vsync", value, "0");  
  22.     mDebugForceFakeVSync = atoi(value);  
  23.   
  24.     bool needVSyncThread = true;  
  25.     //加载Gralloc中的GRALLOC_HARDWARE_FB0设备,和HWC设备  
  26.     // Note: some devices may insist that the FB HAL be opened before HWC.  
  27.     int fberr = loadFbHalModule();  
  28.     loadHwcModule();  
  29.   
  30.     if (mFbDev && mHwc && hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)) {  
  31.         // close FB HAL if we don't needed it.  
  32.         // FIXME: this is temporary until we're not forced to open FB HAL  
  33.         // before HWC.  
  34.         framebuffer_close(mFbDev);  
  35.         mFbDev = NULL;  
  36.     }  
  37.   
  38.     // If we have no HWC, or a pre-1.1 HWC, an FB dev is mandatory.  
  39.     if ((!mHwc || !hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1))  
  40.             && !mFbDev) {  
  41.         ALOGE("ERROR: failed to open framebuffer (%s), aborting",  
  42.                 strerror(-fberr));  
  43.         abort();  
  44.     }  
  45.   
  46.     // these display IDs are always reserved  
  47.     for (size_t i=0 ; i<NUM_BUILTIN_DISPLAYS ; i++) {  
  48.         mAllocatedDisplayIDs.markBit(i);  
  49.     }  
  50.     //如果我们有HWC这个硬件设备,那么我们就注册一些HWC的函数  
  51.     //另外,就不需要使用vsync的进程,因为我们有了硬件支持的VSYNC中断  
  52.     if (mHwc) {  
  53.         ALOGI("Using %s version %u.%u", HWC_HARDWARE_COMPOSER,  
  54.               (hwcApiVersion(mHwc) >> 24) & 0xff,  
  55.               (hwcApiVersion(mHwc) >> 16) & 0xff);  
  56.         if (mHwc->registerProcs) {  
  57.             mCBContext->hwc = this;  
  58.             mCBContext->procs.invalidate = &hook_invalidate;  
  59.             mCBContext->procs.vsync = &hook_vsync;  
  60.             if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1))  
  61.                 mCBContext->procs.hotplug = &hook_hotplug;  
  62.             else  
  63.                 mCBContext->procs.hotplug = NULL;  
  64.             memset(mCBContext->procs.zero, 0, sizeof(mCBContext->procs.zero));  
  65.             mHwc->registerProcs(mHwc, &mCBContext->procs);  
  66.         }  
  67.   
  68.         // don't need a vsync thread if we have a hardware composer  
  69.         needVSyncThread = false;  
  70.         // always turn vsync off when we start  
  71.         eventControl(HWC_DISPLAY_PRIMARY, HWC_EVENT_VSYNC, 0);  
  72.   
  73.         // the number of displays we actually have depends on the  
  74.         // hw composer version  
  75.         //根据HWC硬件的支持情况,来设置显示屏幕的数量  
  76.         if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_3)) {  
  77.             // 1.3 adds support for virtual displays  
  78.             mNumDisplays = MAX_HWC_DISPLAYS;  
  79.         } else if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)) {  
  80.             // 1.1 adds support for multiple displays  
  81.             mNumDisplays = NUM_BUILTIN_DISPLAYS;  
  82.         } else {  
  83.             mNumDisplays = 1;  
  84.         }  
  85.     }  
  86.     //如果我们能获取到FB设置,那么我们就从FB设备里面读取一些屏幕相关的I型难洗  
  87.     if (mFbDev) {  
  88.         ALOG_ASSERT(!(mHwc && hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)),  
  89.                 "should only have fbdev if no hwc or hwc is 1.0");  
  90.   
  91.         DisplayData& disp(mDisplayData[HWC_DISPLAY_PRIMARY]);  
  92.         disp.connected = true;  
  93.         disp.width = mFbDev->width;  
  94.         disp.height = mFbDev->height;  
  95.         disp.format = mFbDev->format;  
  96.         disp.xdpi = mFbDev->xdpi;  
  97.         disp.ydpi = mFbDev->ydpi;  
  98.         if (disp.refresh == 0) {  
  99.             disp.refresh = nsecs_t(1e9 / mFbDev->fps);  
  100.             ALOGW("getting VSYNC period from fb HAL: %lld", disp.refresh);  
  101.         }  
  102.         if (disp.refresh == 0) {  
  103.             disp.refresh = nsecs_t(1e9 / 60.0);  
  104.             ALOGW("getting VSYNC period from thin air: %lld",  
  105.                     mDisplayData[HWC_DISPLAY_PRIMARY].refresh);  
  106.         }  
  107.     } else if (mHwc) {//否则我们将会从HWC中读取相关配置,打log确认下走哪个分支  
  108.         // here we're guaranteed to have at least HWC 1.1  
  109.         for (size_t i =0 ; i<NUM_BUILTIN_DISPLAYS ; i++) {  
  110.             queryDisplayProperties(i);  
  111.         }  
  112.     }  
  113.   
  114. // End  
  115.     //显然,如果需要模拟VSync信号的话,我们需要线程来做这个工作  
  116.     if (needVSyncThread) {  
  117.         // we don't have VSYNC support, we need to fake it  
  118.         //VSyncThread类的实现很简单,无非就是一个计时器而已,定时发送消息而已  
  119.         //TODO VSYNC专题  
  120.         mVSyncThread = new VSyncThread(*this);  
  121.     }  
  122. }  
2.3 EGL配置

HWC模块创建完成之后,我们继续回到SurfaceFlinger的初始化过程,后面将继续是一些EGL相关的配置:

 
 
  1. {  
  2. ...  
  3.     //首先获取OpenGL ES2.0的配置,在另外一篇文档中,我们提到过从KK之后,SF开始使用ES 2.0  
  4.     // First try to get an ES2 config  
  5.     err = selectEGLConfig(mEGLDisplay, mHwc->getVisualID(), EGL_OPENGL_ES2_BIT,  
  6.             &mEGLConfig);  
  7.     //当然如果获取失败,还是会继续使用1.0,TODO 我们会新开一个专题讲OpengGL  
  8.     if (err != NO_ERROR) {  
  9.         // If ES2 fails, try ES1  
  10.         err = selectEGLConfig(mEGLDisplay, mHwc->getVisualID(),  
  11.                 EGL_OPENGL_ES_BIT, &mEGLConfig);  
  12.     }  
  13.   
  14.     if (err != NO_ERROR) {  
  15.         // still didn't work, probably because we're on the emulator...  
  16.         // try a simplified query  
  17.         ALOGW("no suitable EGLConfig found, trying a simpler query");  
  18.         err = selectEGLConfig(mEGLDisplay, mHwc->getVisualID(), 0, &mEGLConfig);  
  19.     }  
  20.   
  21.     if (err != NO_ERROR) {  
  22.         // this EGL is too lame for android  
  23.         LOG_ALWAYS_FATAL("no suitable EGLConfig found, giving up");  
  24.     }  
  25.   
  26.     // 打印一些配置信息  
  27.     EGLint r,g,b,a;  
  28.     eglGetConfigAttrib(mEGLDisplay, mEGLConfig, EGL_RED_SIZE,   &r);  
  29.     eglGetConfigAttrib(mEGLDisplay, mEGLConfig, EGL_GREEN_SIZE, &g);  
  30.     eglGetConfigAttrib(mEGLDisplay, mEGLConfig, EGL_BLUE_SIZE,  &b);  
  31.     eglGetConfigAttrib(mEGLDisplay, mEGLConfig, EGL_ALPHA_SIZE, &a);  
  32.     ALOGI("EGL informations:");  
  33.     ALOGI("vendor    : %s", eglQueryString(mEGLDisplay, EGL_VENDOR));  
  34.     ALOGI("version   : %s", eglQueryString(mEGLDisplay, EGL_VERSION));  
  35.     ALOGI("extensions: %s", eglQueryString(mEGLDisplay, EGL_EXTENSIONS));  
  36.     ALOGI("Client API: %s", eglQueryString(mEGLDisplay, EGL_CLIENT_APIS)?:"Not Supported");  
  37.     ALOGI("EGLSurface: %d-%d-%d-%d, config=%p", r, g, b, a, mEGLConfig);  
  38.   
  39.     // get a RenderEngine for the given display / config (can't fail)  
  40.     // KK升级一章中我们讲过SF通过RenderEngine来实现了使用不同版本的OpenGL  
  41.     mRenderEngine = RenderEngine::create(mEGLDisplay, mEGLConfig);  
  42.   
  43.     // retrieve the EGL context that was selected/created  
  44.     //获取ES的上下文,这个是用于SF的上下文  
  45.     mEGLContext = mRenderEngine->getEGLContext();  
  46.   
  47.     // figure out which format we got  
  48.     eglGetConfigAttrib(mEGLDisplay, mEGLConfig,  
  49.             EGL_NATIVE_VISUAL_ID, &mEGLNativeVisualId);  
  50.   
  51.     LOG_ALWAYS_FATAL_IF(mEGLContext == EGL_NO_CONTEXT,  
  52.             "couldn't create EGLContext");  
  53. ...  
  54. }  
2.4 display设置

EGL和OpenGL ES的配置设置完毕之后,我们将对display进行设置。

 
 
  1. {  
  2. ...  
  3.   // initialize our non-virtual displays  
  4.     for (size_t i=0 ; i<DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES ; i++) {  
  5.         DisplayDevice::DisplayType type((DisplayDevice::DisplayType)i);  
  6.         // set-up the displays that are already connected  
  7.         if (mHwc->isConnected(i) || type==DisplayDevice::DISPLAY_PRIMARY) {  
  8.             // All non-virtual displays are currently considered secure.  
  9.             bool isSecure = true;  
  10.             createBuiltinDisplayLocked(type);  
  11.             wp<IBinder> token = mBuiltinDisplays[i];  
  12.   
  13.             //对于每个display,SF都会创建一个新的BufferQueue  
  14.             sp<BufferQueue> bq = new BufferQueue(new GraphicBufferAlloc());  
  15.             sp<FramebufferSurface> fbs = new FramebufferSurface(*mHwc, i, bq);  
  16.             //最后,用我们创建的这些内容,来创建一个DisplayDevice  
  17.             //它有两个重要的变量,一个是mFrameBufferSurface和mNativeWindow。  
  18.             //mFrameBufferSurace是FrameBufferSurface类型,  
  19.             //当显示设备不属于VIRTUAL类型的话,则该变量不为空  
  20.             sp<DisplayDevice> hw = new DisplayDevice(this,  
  21.                     type, allocateHwcDisplayId(type), isSecure, token,  
  22.                     fbs, bq,  
  23.                     mEGLConfig);  
  24.             if (i > DisplayDevice::DISPLAY_PRIMARY) {  
  25.                 // FIXME: currently we don't get blank/unblank requests  
  26.                 // for displays other than the main display, so we always  
  27.                 // assume a connected display is unblanked.  
  28.                 ALOGD("marking display %d as acquired/unblanked", i);  
  29.                 //这里应该是指非主屏幕的屏幕一旦注册,就长期处于开启状态  
  30.                 hw->acquireScreen();  
  31.             }  
  32.             mDisplays.add(token, hw);  
  33.         }  
  34.     }  
  35.     ...  
  36.     }  

上面这段代码其实涉及到了三个重要的概念,BufferQueue、FrameBufferSurface以及DisplayDevice。
BufferQueue做为Graphic的核心组件,我们在讲解Graphic总体结构时已经有说明,后面会另开专题说明。我们先来看下FrameBufferSurface的实现:

 
 
  1. FramebufferSurface::FramebufferSurface(HWComposer& hwc, int disp,  
  2.         const sp<IGraphicBufferConsumer>& consumer) :  
  3.     ConsumerBase(consumer),  
  4.     mDisplayType(disp),  
  5.     mCurrentBufferSlot(-1),  
  6.     mCurrentBuffer(0),  
  7.     mHwc(hwc)  
  8. {  
  9.     mName = "FramebufferSurface";  
  10.     mConsumer->setConsumerName(mName);  
  11.     mConsumer->setConsumerUsageBits(GRALLOC_USAGE_HW_FB |  
  12.                                        GRALLOC_USAGE_HW_RENDER |  
  13.                                        GRALLOC_USAGE_HW_COMPOSER);  
  14.     mConsumer->setDefaultBufferFormat(mHwc.getFormat(disp));  
  15.     mConsumer->setDefaultBufferSize(mHwc.getWidth(disp),  mHwc.getHeight(disp));  
  16.     mConsumer->setDefaultMaxBufferCount(NUM_FRAMEBUFFER_SURFACE_BUFFERS);  
  17.     mConsumer->setMaxAcquiredBufferCount(NUM_FRAMEBUFFER_SURFACE_BUFFERS - 1);  
  18. }  

我们使用了BufferQueue来创建了一个FramebufferSurface,显然这个FramebufferSurface是一个消费者。在创建过程我们使用了屏幕的编号和HWC,我们可以猜测这个FBS是和一个屏幕绑定的,而且最终应该也是要通过HWC进行渲染。我们可以理解为这是SF在这个屏幕上使用的帧缓冲区,那么也就是一旦使用SF合成,最后数据应该是合成在了这里面(待验证),然后这里面的数据通过HWC显示在了屏幕上。猜测一下,这个是不是就是抓dump时抓到的那个HWC_FRAMEBUFFER_TARGET?

FBS的创建并没有特别之处,需要留意的是这里设置了MaxBufferCount和MaxAcquiredBufferCount,我们在Graphic总体架构一文中已经提到了设置这两个属性的作用。

DisplayDevice其实是抽象了显示设备,封装了用于渲染的Surface和HWComposer模块等,从而尽可能使得SurfaceFlinger只要和它打交道。来看下他的创建过程:

 
 
  1. DisplayDevice::DisplayDevice(  
  2.         const sp<SurfaceFlinger>& flinger,  
  3.         DisplayType type,  
  4.         int32_t hwcId,  
  5.         bool isSecure,  
  6.         const wp<IBinder>& displayToken,  
  7.         const sp<DisplaySurface>& displaySurface,  
  8.         const sp<IGraphicBufferProducer>& producer,  
  9.         EGLConfig config)  
  10.     : mFlinger(flinger),  
  11.       mType(type), mHwcDisplayId(hwcId),  
  12.       mDisplayToken(displayToken),  
  13.       mDisplaySurface(displaySurface),  
  14.       mDisplay(EGL_NO_DISPLAY),  
  15.       mSurface(EGL_NO_SURFACE),  
  16.       mDisplayWidth(), mDisplayHeight(), mFormat(),  
  17.       mFlags(),  
  18.       mPageFlipCount(),  
  19.       mIsSecure(isSecure),  
  20.       mSecureLayerVisible(false),  
  21.       mScreenAcquired(false),  
  22.       mLayerStack(NO_LAYER_STACK),  
  23.       mOrientation()  
  24. {  
  25.     mNativeWindow = new Surface(producer, false);  
  26.     ANativeWindow* const window = mNativeWindow.get();  
  27.   
  28.     int format;  
  29.     window->query(window, NATIVE_WINDOW_FORMAT, &format);  
  30.   
  31.     /* 
  32.      * Create our display's surface 
  33.      */  
  34.     EGLSurface surface;  
  35.     EGLint w, h;  
  36.     EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);  
  37.     surface = eglCreateWindowSurface(display, config, window, NULL);  
  38.     eglQuerySurface(display, surface, EGL_WIDTH,  &mDisplayWidth);  
  39.     eglQuerySurface(display, surface, EGL_HEIGHT, &mDisplayHeight);  
  40.   
  41.     mDisplay = display;  
  42.     mSurface = surface;  
  43.     mFormat  = format;  
  44.     mPageFlipCount = 0;  
  45.     mViewport.makeInvalid();  
  46.     mFrame.makeInvalid();  
  47.     float mFOV = 30.0f;  
  48.     float tangent = tan(PI / 180.0f * mFOV / 2.0f);  
  49.     mDefaultX = -((float) mDisplayWidth / 2.0f);  
  50.     mDefaultY = -((float) mDisplayHeight / 2.0f);  
  51.     mDefaultZ = -(((float) mDisplayHeight / 2.0f) / tangent);  
  52.     /* Activity-Activity: Change End*/  
  53.   
  54.     // virtual displays are always considered enabled  
  55.     mScreenAcquired = (mType >= DisplayDevice::DISPLAY_VIRTUAL);  
  56.   
  57.     // Name the display.  The name will be replaced shortly if the display  
  58.     // was created with createDisplay().  
  59.     switch (mType) {  
  60.         case DISPLAY_PRIMARY:  
  61.             mDisplayName = "Built-in Screen";  
  62.             break;  
  63.         case DISPLAY_EXTERNAL:  
  64.             mDisplayName = "HDMI Screen";  
  65.             break;  
  66.         default:  
  67.             mDisplayName = "Virtual Screen";    // e.g. Overlay #n  
  68.             break;  
  69.     }  
  70.     char property[PROPERTY_VALUE_MAX];  
  71.     int panelOrientation = DisplayState::eOrientationDefault;  
  72.     // Set the panel orientation from the property.  
  73.     property_get("persist.panel.orientation", property, "0");  
  74.     panelOrientation = atoi(property) / 90;  
  75.   
  76.     // initialize the display orientation transform.  
  77.     setProjection(panelOrientation, mViewport, mFrame);  
  78. }  

这段创建同样相当之长,我们目前只关注这里面创建了一个EGLSurface。我们在前面的文章中曾经提到过这个类,这个实际上就是一个供GLES使用的窗口缓冲区,为GLES提供了一个绘制的地方。
在这个EGLSurface里面是一个Surface,本质上下面还是一个BufferQueue。
渲染这个EGLSurface将导致一个buffer出队渲染入队的过程,lock和unlock过程是通过eglSwapBuffers函数来提供的。

2.5 makeCurrent

看完了上面几个重要概念的讲解,我们继续回到SF的init过程中来。
下面是对主屏幕对应的display进行makeCurrent操作:

 
 
  1. {  
  2. ...  
  3.     //  initialize OpenGL ES  
  4.     /* Activity-Activity: */  
  5.     setProjectionType(ORTHOGRAPHIC_PROJECTION);  
  6.     /* Activity-Activity: Change End*/  
  7.   
  8.     // make the GLContext current so that we can create textures when creating Layers  
  9.     // (which may happens before we render something)  
  10.     getDefaultDisplayDevice()->makeCurrent(mEGLDisplay, mEGLContext);  
  11. ...  
  12. }  

注意到这里调用的实际上是DisplayDevice类提供的函数,这也某种程度上说明了我们前面提到的DisplayDevice的作用是:封装了用于渲染的Surface和HWComposer模块等,从而尽可能使得SurfaceFlinger只要和它打交道。看下这个makeCurrent函数:

 
 
  1. EGLBoolean DisplayDevice::makeCurrent(EGLDisplay dpy, EGLContext ctx) const {  
  2.     EGLBoolean result = EGL_TRUE;  
  3.     EGLSurface sur = eglGetCurrentSurface(EGL_DRAW);  
  4.     if (sur != mSurface) {  
  5.         result = eglMakeCurrent(dpy, mSurface, mSurface, ctx);  
  6.         if (result == EGL_TRUE) {  
  7.             if (mType >= DisplayDevice::DISPLAY_VIRTUAL)  
  8.                 eglSwapInterval(dpy, 0);  
  9.         }  
  10.     }  
  11.     setViewportAndProjection();  
  12.     return result;  
  13. }  

这里获取了当前使用的EGLSurface,一旦发现这个Surface发生了改变,就要重新调用eglMakeCurrent函数来设置,这是因为一个线程同时只能有一个EGLSurface作为current。而关于eglMakeCurrent函数的更详尽的说明,我们将在EGL和GLES的章节中给予说明。

2.6 EventThread的创建

再次回到SF的init过程中来:

 
 
  1. {  
  2. ...  
  3.     // start the EventThread  
  4.     sp<VSyncSource> vsyncSrc = new DispSyncSource(&mPrimaryDispSync,  
  5.             vsyncPhaseOffsetNs, true);  
  6.     mEventThread = new EventThread(vsyncSrc);  
  7.     sp<VSyncSource> sfVsyncSrc = new DispSyncSource(&mPrimaryDispSync,  
  8.             sfVsyncPhaseOffsetNs, true);  
  9.     mSFEventThread = new EventThread(sfVsyncSrc);  
  10.     mEventQueue.setEventThread(mSFEventThread);  
  11.   
  12.     mEventControlThread = new EventControlThread(this);  
  13.     mEventControlThread->run("EventControl", PRIORITY_URGENT_DISPLAY);  
  14.   
  15.     // set a fake vsync period if there is no HWComposer  
  16.     if (mHwc->initCheck() != NO_ERROR) {  
  17.         mPrimaryDispSync.setPeriod(16666667);  
  18.     }  
  19. ...  
  20. }  

这段讲了EventThread的创建和使用。EventThread主要用于VSYNC消息的处理,我们同样会单开一个章节来讲解VSYNC的逻辑。
EventControlThread是用来向真实的VSync硬件发命令的,我们这里暂时不展开。
而一旦硬件不能正常发送VSYNC命令时,我们则通过软件方式模拟,我们可以看到这里把模拟的间隔时间设置为16.6ms左右。

2.7 初始化显示设备

终于到了init函数的最后几句话,首先是初始化显示设备。

 
 
  1. {  
  2. ...  
  3.     // initialize our drawing state  
  4.     mDrawingState = mCurrentState;  
  5.   
  6.     // set initial conditions (e.g. unblank default device)  
  7.     initializeDisplays();  
  8.   
  9. ...  
  10. }  

我们来看初始化显示设备的逻辑:

 
 
  1. void SurfaceFlinger::onInitializeDisplays() {  
  2.     // reset screen orientation and use primary layer stack  
  3.     Vector<ComposerState> state;  
  4.     Vector<DisplayState> displays;  
  5.     DisplayState d;  
  6.     d.what = DisplayState::eDisplayProjectionChanged |  
  7.              DisplayState::eLayerStackChanged;  
  8.     d.token = mBuiltinDisplays[DisplayDevice::DISPLAY_PRIMARY];  
  9.     d.layerStack = 0;  
  10.     d.orientation = DisplayState::eOrientationDefault;  
  11.     d.frame.makeInvalid();  
  12.     d.viewport.makeInvalid();  
  13.     displays.add(d);  
  14.     setTransactionState(state, displays, 0);  
  15.     onScreenAcquired(getDefaultDisplayDevice());  
  16.   
  17.     const nsecs_t period =  
  18.             getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY);  
  19.     mAnimFrameTracker.setDisplayRefreshPeriod(period);  
  20.     property_set("debug.sf.layerdump""0");  
  21. }  

其中setTransactionState函数在很多地方都会有调用,作用主要是处理上层的各个命令,并根据flag设置event通知Threadloop进行处理,TODO
而onScreenAcquired同样是一个重要的函数,不仅在这里,在屏幕会唤醒时同样会调用。

 
 
  1. void SurfaceFlinger::onScreenAcquired(const sp<const DisplayDevice>& hw) {  
  2.     ALOGD("Screen acquired, type=%d flinger=%p", hw->getDisplayType(), this);  
  3.     if (hw->isScreenAcquired()) {  
  4.         // this is expected, e.g. when power manager wakes up during boot  
  5.         ALOGD(" screen was previously acquired");  
  6.         return;  
  7.     }  
  8.   
  9.     hw->acquireScreen();  
  10.     int32_t type = hw->getDisplayType();  
  11.     if (type < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) {  
  12.         // built-in display, tell the HWC  
  13.         getHwComposer().acquire(type);  
  14.   
  15.         if (type == DisplayDevice::DISPLAY_PRIMARY) {  
  16.             // FIXME: eventthread only knows about the main display right now  
  17.             mEventThread->onScreenAcquired();  
  18.   
  19.             resyncToHardwareVsync(true);  
  20.         }  
  21.     }  
  22.     mVisibleRegionsDirty = true;  
  23.     repaintEverything();  
  24. }  

这里有几个点比较重要,首先是通知HWC,调用了HWC的acquire函数:

 
 
  1. status_t HWComposer::acquire(int disp) {  
  2.     LOG_FATAL_IF(disp >= VIRTUAL_DISPLAY_ID_BASE);  
  3.     if (mHwc) {  
  4.         return (status_t)mHwc->blank(mHwc, disp, 0);  
  5.     }  
  6.     return NO_ERROR;  
  7. }  

接下来,调用了EventThread的onScreenAcquired函数。

 
 
  1. void EventThread::onScreenAcquired() {  
  2.     if (mUseSoftwareVSync) {  
  3.         // resume use of h/w vsync  
  4.         mUseSoftwareVSync = false;  
  5.         mCondition.broadcast();  
  6.     }  
  7. }  

这个函数首先判断如果在之前mUseSoftwareVSync被设置为了true,这里需要改回来。而mUseSoftwareVSync这个值其实是在onScreenReleased被设置为true的(也就是说,在屏幕被灭掉之后,就变为软件的VSync,TODO,在屏幕黑掉之后,还有没有绘制或者显示方面的工作?)。

后面这个广播发送的主要作用是唤醒EventThread线程,并打开VSync事件发送器(可以看下waitForEvent函数)。

接下来的resyncToHardwareVsync函数逻辑比较简单,应该就是开启硬件的VSYNC。

 
 
  1. void SurfaceFlinger::resyncToHardwareVsync(bool makeAvailable) {  
  2.     Mutex::Autolock _l(mHWVsyncLock);  
  3.   
  4.     if (makeAvailable) {  
  5.         mHWVsyncAvailable = true;  
  6.     } else if (!mHWVsyncAvailable) {  
  7.         ALOGE("resyncToHardwareVsync called when HW vsync unavailable");  
  8.         return;  
  9.     }  
  10.   
  11.     const nsecs_t period =  
  12.             getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY);  
  13.   
  14.     mPrimaryDispSync.reset();  
  15.     mPrimaryDispSync.setPeriod(period);  
  16.   
  17.     if (!mPrimaryHWVsyncEnabled) {  
  18.         mPrimaryDispSync.beginResync();  
  19.         //eventControl(HWC_DISPLAY_PRIMARY, SurfaceFlinger::EVENT_VSYNC, true);  
  20.         mEventControlThread->setVsyncEnabled(true);  
  21.         mPrimaryHWVsyncEnabled = true;  
  22.     }  
  23. }  

最后是调用了repaintEverything函数,这个函数就是发送invalidate消息,请求屏幕刷新。

2.8 开机动画

回到init的过程上来。

 
 
  1. {  
  2. ...  
  3.     // start boot animation  
  4.     startBootAnim();  
  5.   
  6. }  

播放开机动画我们会专门讲解,这里不再展开。

3.注册SF服务

向Android的ServiceManager进程注册服务是系统的通用逻辑,不再展开,这里就是注册了一个名叫的SurfaceFlinger的服务而已。

4.运行程序

在一系列的准备工作之后,终于到了启动SurfaceFlinger的时候。

 
 
  1. void SurfaceFlinger::run() {  
  2.     do {  
  3.         waitForEvent();  
  4.     } while (true);  
  5. }  
  6. void SurfaceFlinger::waitForEvent() {  
  7.     mEventQueue.waitMessage();  
  8. }  

而这个过程其实异常简单,SF进入死循环中,一直在等待消息的传来。

总结

这样,我们就完整的分析了SF的启动过程,我们将在下一节继续分析SF对消息的处理过程。









评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值