Android 源码分析 - 显示 - 数据流

最新推荐文章于 2025-11-05 17:17:29 发布

原创最新推荐文章于 2025-11-05 17:17:29 发布 · 2k 阅读

13 ·

CC 4.0 BY-SA版权

文章标签：

#android #java

Android 框架实现分析专栏收录该内容

110 篇文章

订阅专栏

本文详细介绍了Android系统中SurfaceFlinger如何处理硬件显示设备，包括虚拟显示设备的创建、VSync信号的处理、事务处理、失效更新及屏幕刷新等过程。SurfaceFlinger通过与HWComposer交互，管理屏幕合成，处理OpenGL和硬件Overlays的分工，确保显示的高效和准确。此外，还涉及了虚拟显示设备如Wi-FiDisplay（Miracast）的连接流程。

部署运行你感兴趣的模型镜像

硬件显示设备

在HWC 1.1之前，没有支持HWC_FRAMEBUFFER_TARGET，HWC从当前线程上下文中获取GLES的Display和Surface。

在所有层都由HWC合成时，不需要GLES，HWC_FRAMEBUFFER_TARGET层数据没有意义。

虚拟显示设备

Android Wi-Fi Display（Miracast）介绍

当虚拟显示设备得不到HWC支持时（HWC 1.3以前，或者虚拟设备数超限），SurfaceFlinger安排GLES直接合成到输出Surface（图中绿色线指示的流）。

VirtualDisplaySurface虚拟了一个BufferQueue（实现IGraphicBufferProducer接口），根据情况可能从中间BufferQueue或者目标BufferQueue获取缓存提供给GLES做合成，具体策略是：如果HWC返回全部由GLES合成时，从目标BufferQueue获取缓存。

流程

下面这个文章里面有SurfaceFlinger调用OpenGL的堆栈，同时问题就出在OpenGL、Overlay合成分工上。

Android 进入退出应用动画卡顿分析

线程

SurfaceFlinger：

名称	入口	说明
main	MessageQueue:: waitMessage()	init、run，SurfaceFlinger内部线程，invalidate、refresh消息，vsync信号
Binder_%X	IPCThreadState:: joinThreadPool	4个线程
EventControl	EventControlThread:: threadLoop()	控制硬件vsync开关
EventThread	EventThread:: threadLoop()	分发vsync信号，BitTube，2个线程，一个内部，一个App
DispSync	DispSyncThread:: threadLoop()	产生软件vsync信号

SystemServer：

名称

入口

说明

WindowManager

Looper.loop()

SystemServer 创建的wmHandlerThread，

DisplayManagerHandler、DisplayAdapter

android.ui

Looper.loop()

mUiHandler

初始化

SurfaceFlinger在init方法中进行初始化。

初始化EGL

eglGetDisplay
eglInitialize
new HWComposer
RenderEngine::create

初始化内建显示设备

for i = 0 ~ NUM_BUILTIN_DISPLAY_TYPES
1. new BufferQueue
2. new FramebufferSurface
3. new DisplayDevice
4. mDisplays.add

初始化辅助线程，消息队列

new DispSyncSource
new EventThread
new DispSyncSource
new EventThread
mEventQueue.setEventThread
new EventControlThread

其他

initializeDisplays
1. postMessageAsync(MessageScreenInitialized)
startBootAnim

VSync信号

HWComposer收到VSync回调（HWComposer::vsync）

HWComposer::vsync
1. mEventHandler.onVSyncReceived（EventHandler接口，由SurfaceFlinger实现）

SurfaceFlinger处理VSync回调（SurfaceFlinger::onVSyncReceived）

SurfaceFlinger::onVSyncReceived
1. if (type == 0 && mPrimaryHWVsyncEnabled)（type实际是Display id，只处理主屏幕的vsync）
  1. needsHwVsync = mPrimaryDispSync.addResyncSample（送到DispSync）
2. if (needsHwVsync)
  1. enableHardwareVsync
3. else
  1. disableHardwareVsync

DispSync计算VSync统计变量（DispSync::addResyncSample）

DispSync需要同步硬件Vsync，通过beginResync、addResyncSample、endResync做一次重新同步。addResyncSample需要多次调用知道返回false表示同步完成。

DispSync::addResyncSample
1. 添加当前Vsync时间戳到循环数组，只记录最近若干采样
2. updateModelLocked
3. 计算周期（mPeriod）和偏移（mPhase），偏移相对于时间0开始的周期信号
4. mThread->updateModel（更新到内部线程DispSyncThread）

DispSyncThread产生软件VSync信号（DispSyncThread::threadLoop）

DispSyncThread为多个客户端（Listener）产生不同偏移（相对于硬件Vsync）的周期信号。

DispSyncThread::threadLoop
1. computeNextEventTimeLocked
  1. foreach mEventListeners（计算每个Listener的下一个信号时间）
    1. computeListenerNextEventTimeLocked
      1. 下一个时间0开始的周期信号加上硬件偏移和客户端指定偏移
    2. 取最小值
2. mCond.waitRelative（等待到下一个信号时间）
3. gatherCallbackInvocationsLocked（收集到期的信号回调）
4. fireCallbackInvocations（调用回调，DispSync::Callback接口，由DispSyncSource实现）

DispSyncSource将软件VSync发送给注册的回调（DispSyncSource::onDispSyncEvent）

DispSyncSource纯粹是为了接口转换，可能是兼容的原因。

DispSyncSource::onDispSyncEvent
1. callback->onVSyncEvent（VSyncSource::Callback接口，由EventThread实现）

EventThread记录VSync信号，转换为内部事件

EventThread::onVSyncEvent
1. mVSyncEvent[0].vsync.count++（DisplayEventReceiver::Event类型）
2. mCondition.broadcast（唤醒内部线程

EventThread内部线程将软件VSync发送给注册客户端（EventThread::threadLoop）

EventThread::threadLoop
1. waitForEvent（等待事件，并返回感兴趣的连接EventThread::Connection）
  1. foreach mVSyncEvent（数组只有第一个可能会有Vsync事件）
    1. if (event.header.timestamp)
  2. foreach mDisplayEventConnections（所有连接）
    1. 根据connection->count（0，接收一次，变为-1，>0，如果整除，接收）
2. foreach signalConnections
  1. conn->postEvent(event)
    1. DisplayEventReceiver::sendEvents
      1. BitTube::sendObjects（通过BitTube管道发送事件）

MessageQueue接收事件（MessageQueue::cb_eventReceiver）

MessageQueue在内部线程（Looper）注册BitTube句柄，当句柄上有数据时，调用注册的回调cb_eventReceiver。

MessageQueue::cb_eventReceiver
1. queue->eventReceiver
  1. while (DisplayEventReceiver::getEvents)（从BitTube管道读取事件）
    1. if (buffer[i].header.type == DISPLAY_EVENT_VSYNC)
      1. #if INVALIDATE_ON_VSYNC
        mHandler->dispatchInvalidate();
        mQueue.mLooper->sendMessage（发送消息）
      2. #else
        mHandler->dispatchRefresh();
        mQueue.mLooper->sendMessage（发送消息）
      3. #endif

MessageQueue处理消息（MessageQueue::Handler::handleMessage）

MessageQueue::Handler::handleMessage
1. mQueue.mFlinger->onMessageReceived（SurfaceFlinger处理消息，详见下文）

增加虚拟屏幕

应用层调用方式（TODO：示例源代码）

new SurfaceComposerClient（创建到SurfaceFlinger的客户端连接）
createDisplay（创建虚拟屏幕）
1. Composer::getInstance().createDisplay
  1. ComposerService::getComposerService()->createDisplay
openGlobalTransaction（打开一个事务）
1. Composer::openGlobalTransaction
setDisplaySurface（设置虚拟屏幕表面Surface）
1. Composer::getInstance().setDisplaySurface
setDisplayLayerStack（设备虚拟屏幕图层镜像）
1. Composer::getInstance().setDisplayLayerStack
setDisplayProjection（设备虚拟屏幕投影区域）
1. Composer::getInstance().setDisplayProjection
closeGlobalTransaction（提交事务）
1. Composer::closeGlobalTransaction
  1. Composer::getInstance().closeGlobalTransactionImpl
    1. sm->setTransactionState

SurfaceFlinger创建虚拟屏幕（SurfaceFlinger::createDisplay）

SurfaceFlinger::createDisplay
1. new DisplayToken（Binder对象，用来自动释放）
2. DisplayDeviceState(DisplayDevice::DISPLAY_VIRTUAL)
3. mCurrentState.displays.add（添加到读取状态，后面与事务一起处理）

SurfaceFlinger处理客户端事务（SurfaceFlinger::setTransactionState）

SurfaceFlinger::setTransactionState
1. foreach displays（外部更新状态）
  1. setDisplayStateLocked
    1. mCurrentState.displays.indexOfKey（查找内部数组对应屏幕）
    2. if (what & DisplayState::eSurfaceChanged)（屏幕表面变化）
      1. flags |= eDisplayTransactionNeeded
    3. if (what & DisplayState::eLayerStackChanged)（图层栈变化）
      1. flags |= eDisplayTransactionNeeded
2. if (transactionFlags)
  1. setTransactionFlags
    1. signalTransaction
      1. mEventQueue.invalidate（排队Invalidate消息）

SurfaceFlinger处理增加虚拟屏幕事务（SurfaceFlinger:: handleMessageTransaction）

Invalidate消息处理，包含事务处理（handleMessageTransaction，详见“事务处理”），这里列举增加虚拟屏幕相关的部分。

SurfaceFlinger::handleMessageTransaction
1. handleTransactionLocked
  1. if (transactionFlags & eDisplayTransactionNeeded)
    1. 比较mCurrentState和mDrawingState，对增加的屏幕
      1. if (DisplayDeviceState::isVirtualDisplay)
        allocateHwcDisplayId（申请硬件虚拟屏幕ID，可能失败）
        new BufferQueue（GLES合成的表面）
        new VirtualDisplaySurface
      2. new DisplayDevice

连接WifiDisplay

DisplayManager启动连接Wifi设备（connectWifiDisplay）

DisplayManagerGlobal.connectWifiDisplay()
1. mDm.connectWifiDisplay()【DisplayManagerService】
  1. mWifiDisplayAdapter.requestConnectLocked()
    1. mDisplayController.requestConnect()
      1. connect()
        updateConnection()

WifiDisplayController更新连接状态（updateConnection）

关闭老的设备连接【略过】
new WifiP2pConfig()
new WpsInfo()
createWifiDisplay()
advertiseDisplay()【清空老的记录】
mWifiP2pManager.connect()【Wifi P2P连接】
等待WIFI_P2P_CONNECTION_CHANGED_ACTION

WifiDisplayController处理P2p连接变化广播（mWifiP2pReceiver）

mWifiP2pReceiver.onReceive()
1. handleConnectionChanged()
  1. mWifiP2pManager.requestGroupInfo()【等待回调】
GroupInfoListener.onGroupInfoAvailable()【requestGroupInfo回调】
1. updateConnection()【根据当前状态，应该到第6步】
  1. mWifiP2pManager.setMiracastMode()
  2. RemoteDisplay.listen()【侦听远端设备RTSP连接】

RemoteDisplay启动侦听

RemoteDisplay.listen()
1. new RemoteDisplay()
2. display.startListening
  1. nativeListen()【JNI】
    1. IServiceManager->getService()【IMediaPlayerService，"media.player"】
    2. new NativeRemoteDisplayClient【IRemoteDisplayClient】
    3. IMediaPlayerService->listenForRemoteDisplay()【返回IRemoteDisplay】
    4. new NativeRemoteDisplay()【包装IRemoteDisplay】

RemoteDisplay收到连接

NativeRemoteDisplayClient::onDisplayConnected(IGraphicBufferProducer)
1. android_view_Surface_createFromIGraphicBufferProducer()
  1. new Surface()【提供数据方】
2. RemoteDisplay.notifyDisplayConnected()【从JNI回调】
3. mHandler.post(mListener.onDisplayConnected())【Handler线程调用回调】

WifiDisplayController处理成功消息

RemoteDisplay.Listener.onDisplayConnected()
1. mListener.onDisplaySessionInfo()【WifiDisplayAdapter】
  1. mWifiDisplayListener.onDisplaySessionInfo()
2. createWifiDisplay()
3. advertiseDisplay()
  1. mHandler.post()【Handler线程post onDisplayConnected】

WifiDisplayAdapter处理成功消息

mListener.onDisplayConnected()
1. mWifiDisplayListener.onDisplayConnected()
  1. addDisplayDeviceLocked()
    1. new WifiDisplayDevice()
    2. sendDisplayDeviceEventLocked()
      1. mHandler.post()【mListener.onDisplayDeviceEvent()，通知到DisplayManagerService】
  2. scheduleStatusChangedBroadcastLocked()【异步发送广播DisplayManager.ACTION_WIFI_DISPLAY_STATUS_CHANGED】
  3. scheduleUpdateNotificationLocked()【异步更新通知栏UI】

DisplayManagerService处理成功消息

DisplayAdapterListener.onDisplayDeviceEvent()
1. DisplayManagerService.handleDisplayDeviceAdded()
  1. handleDisplayDeviceAddedLocked()
    1. mDisplayDevices.add()
    2. addLogicalDisplayLocked()
      1. new LogicalDisplay()
      2. mLogicalDisplays.put()
      3. sendDisplayEventLocked()【异步回调IDisplayManagerCallback.notifyDisplayEventAsync()，DisplayManagerGlobal.EVENT_DISPLAY_ADDED】
    3. updateDisplayBlankingLocked()【与PowerManager屏幕状态一致】
    4. scheduleTraversalLocked()【异步请求mWindowManagerFuncs.requestTraversal()】

DisplayManagerService处理更新事务

performTraversalInTransactionFromWindowManager()
1. performTraversalInTransactionLocked()
  1. handleDisplayDeviceAddedLocked()
  2. foreach device : mDisplayDevices
    1. configureDisplayInTransactionLocked()
      1. findLogicalDisplayForDeviceLocked()
      2. display.configureDisplayInTransactionLocked()
        device.setLayerStackInTransactionLocked()
        device.setProjectionInTransactionLocked()
    2. device.performTraversalInTransactionLocked()
      1. setSurfaceInTransactionLocked()【WifiDisplayDevice】

消息处理

SurfaceFlinger在onMessageReceived中处理消息，调用线程是MessageQueue线程。

在处理TRANSACTION消息时，需要做事务处理。

在处理INVALIDATE消息时，先做事务处理，然后更新失效区域，最后在MessageQueue中安排一个REFRESH消息。

在处理REFRESH消息时，做屏幕刷新。

事务处理（Transaction）

SurfaceFlinger在handleMessageTransaction中处理事务

handleMessageTransaction
1. handleTransaction(transactionFlags)
  1. handleTransactionLocked（具体的事务处理）
  2. invalidateHwcGeometry（）
    1. mHwWorkListDirty = true

具体的事务处理过程

handleTransactionLocked
1. if (transactionFlags & eTraversalNeeded)（这里只处理layer内部的事务）
2. if (transactionFlags & eDisplayTransactionNeeded)（处理设备插拔事务）
3. if (transactionFlags & eTraversalNeeded| eDisplayTransactionNeeded)（更新layer到Display的角度转换）
4. if (mLayersRemoved)（处理layer删除）
5. commitTransaction（提交事务完成）

layer内部事务处理过程

foreach mCurrentState.layersSortedByZ
1. if (!layer->getTransactionFlags) continue（该layer没有事务）
2. layer->doTransaction（返回变化的状态，记录可见区域变化）

设备插拔事务处理过程

foreach mDrawingState.displays
1. 如果mCurrentState.displays没有对应的（删除）
  1. DisplayDevice::disconnect(hwc)
  2. mEventThread->onHotplugReceived
2. 如果有对应的（保留）
  1. Surface变化
    1. 删除（稍后会添加），continue
  2. DisplayDevice::setLayerStack（layerStack变化）
  3. DisplayDevice::setProjection（orientation、viewport、frame变化）
foreach mCurrentState.displays
1. 如果mDrawingState.displays没有对应的（增加）
  1. if (DisplayDeviceState::isVirtualDisplay)
    1. allocateHwcDisplayId
    2. new BufferQueue(new GraphicBufferAlloc())
    3. new VirtualDisplaySurface
  2. else
    1. allocateHwcDisplayId
    2. new FramebufferSurface
  3. new DisplayDevice
  4. mEventThread->onHotplugReceived

更新layer到Display的角度转换

foreach mCurrentState.layersSortedByZ
1. 如果layerStack变化（因为先根据layerStack排序，可以减少查找次数）
  1. 查找对应的Display，没有一一对应关系，使用默认Display
2. layer->updateTransformHint(disp)

处理layer删除

foreach mDrawingState.layersSortedByZ
1. 如果mCurrentState.layersSortedByZ没有对应的（删除）
  1. invalidateLayerStack

提交事务完成

foreach mLayersPendingRemoval
1. layer->onRemoved
mDrawingState = mCurrentState

失效更新（Invalidate）

SurfaceFlinger在handleMessageInvalidate中处理失效更新

handleMessageInvalidate
1. handlePageFlip
  1. foreach layers
    1. layer->latchBuffer（锁住当前缓存，返回失效区域，还返回是否需要重新计算可见区域）
    2. layer->getDrawingState
    3. invalidateLayerStack（更新显示设备的失效区域）
  2. mVisibleRegionsDirty|= visibleRegions（可见区域失效）

layer锁住当前缓存

Layer::latchBuffer
1. SurfaceFlingerConsumer::updateTexImage
2. 如果上面返回BufferQueue::PRESENT_LATER
  1. SurfaceFlinger::signalLayerUpdate（再次安排更新任务）
  2. 返回空区域
3. if (--mQueuedFrames)（多个排队缓存）
  1. SurfaceFlinger::signalLayerUpdate（再次安排更新任务）
4. SurfaceFlingerConsumer::getCurrentBuffer
5. 如果crop、transform、scalingMode，bufWidth、bufHeight、Opacity变化了
  1. recomputeVisibleRegions = true（需要重新计算可见区域）
6. s.active.w、s.active.h、s.transform计算出outDirtyRegion（这里只是简单使用整个区域）

更新显示设备的失效区域

invalidateLayerStack
1. 根据layerStack查找mDisplays
2. hw->dirtyRegion.orSelf(dirty)

屏幕刷新（Refresh)

SurfaceFlinger在handleMessageRefresh中处理屏幕刷新

handleMessageRefresh
1. preComposition（预处理）
2. rebuildLayerStacks（重构Layer栈）
3. setUpHWComposer（构建硬件合成工作序列）
4. doDebugFlashRegions
5. doComposition（合成layers）
6. postComposition（合成后处理）

预处理（preComposition）

preComposition
1. foreach mDrawingState.layersSortedByZ
  1. if (layer->onPreComposition)（如果有等待的缓存，返回true）
    1. needExtraInvalidate = true
2. if (needExtraInvalidate)
  1. signalLayerUpdate（排队新的更新消息）

重构Layer栈（rebuildLayerStacks）

rebuildLayerStacks（mVisibleRegionsDirty为真时有用）
1. invalidateHwcGeometry（设置几何拓扑失效标志）
2. foreach mDisplays
  1. computeVisibleRegions（计算各个layer的失效区域，透明区域等等）

构建硬件合成工作序列（setUpHWComposer）

setUpHWComposer
1. foreach mDisplays
  1. hw->beginFrame
    1. mDisplaySurface->beginFrame（HWC prepare前调用）
2. if (mHwWorkListDirty)（几何拓扑失效，在事务处理时或者可见区域变化时设置）
  1. foreach mDisplays
    1. hwc.createWorkList（创建hwc_display_contents_1）
3. foreach mDisplays
  1. foreach mVisibleLayersSortedByZ
    1. layer->setPerFrameData（传递图像缓存到HWC图层）
      1. hwcLayer.setBuffer
4. hwc.prepare
5. foreach mDisplays
  1. hw->prepareFrame
    1. mDisplaySurface->prepareFrame（HWC prepare后调用）

合成layers（doComposition）

doComposition
1. foreach mDisplays
  1. doDisplayComposition（创建hwc_display_contents_1）
    1. doComposeSurfaces
      1. getRenderEngine
      2. if (hasGlesComposition)
        hw->makeCurrent
        if (hasHwcComposition)
        engine.clearWithColor
        else
        drawWormhole
        engine.fillRegionWithColor
      3. if (cur != end)（使用HWC）
        foreach mVisibleLayersSortedByZ
        switch (cur->getCompositionType())
        case HWC_OVERLAY
        layer->clearWithOpenGL
        case HWC_FRAMEBUFFER
        layer->draw
        layer->setAcquireFence（传递同步Fence到HWC）
        mSurfaceFlingerConsumer->getCurrentFence
        hwlayer.setAcquireFenceFd
      4. else（没有使用HWC）
        foreach mVisibleLayersSortedByZ
        layer->draw
    2. hw->swapBuffers
      1. eglSwapBuffers（如果没有HWC，或者hasGlesComposition并且supportsFramebufferTarget或者virtual display）
      2. mDisplaySurface->advanceFrame（GL合成后调用）
2. hw->compositionComplete
  1. mDisplaySurface->compositionComplete（GL合成后调用，兼容老的实现）
postFramebuffer
1. hwc.commit
2. foreach mDisplays
  1. hw->onSwapBuffersCompleted(hwc)
    1. mDisplaySurface->onFrameCommitted（HWC commit后调用）
  2. foreach mVisibleLayersSortedByZ
    1. layer->onLayerDisplayed（从HWC获取同步Fence）
      1. hwlayer->getAndResetReleaseFence
      2. mSurfaceFlingerConsumer->setReleaseFence

合成后处理（postComposition）

postComposition
1. foreach mDrawingState.layersSortedByZ
  1. layer->onPostComposition（记录每帧图像的时间，用于dump）
    1. mSurfaceFlingerConsumer->getCurrentFence
    2. mFrameTracker.setFrameReadyFence
    3. hwc.getDisplayFence
    4. mFrameTracker.setActualPresentFence
    5. mFrameTracker.advanceFrame
2. hwc.getDisplayFence
  1. mPrimaryDispSync.addPresentFence

您可能感兴趣的与本文相关的镜像