欢迎您访问 最编程 本站为您分享编程语言代码，编程技术文章！

热门搜索/Hot Search

您现在的位置是： 首页

深入解析Android 12(S): SurfaceFlinger的启动流程与消息队列管理(第四部分)

最编程 2024-02-15 22:41:06
...

cc_binary {
    name: "surfaceflinger",
    defaults: ["libsurfaceflinger_binary"],
    init_rc: ["surfaceflinger.rc"],
    srcs: [
        ":surfaceflinger_binary_sources",
        // Note: SurfaceFlingerFactory is not in the filegroup so that it
        // can be easily replaced.
        "SurfaceFlingerFactory.cpp",
    ],
    shared_libs: [
        "libSurfaceFlingerProp",
    ],

     logtags: ["EventLog/EventLogTags.logtags"],
}

再来瞅瞅surfaceflinger.rc这个档案的内容，主要时设置一些SurfaceFlinger服务进程启动属性

service surfaceflinger /system/bin/surfaceflinger
    class core animation
    user system
    group graphics drmrpc readproc
    capabilities SYS_NICE
    onrestart restart zygote
    task_profiles HighPerformance
    socket pdx/system/vr/display/client     stream 0666 system graphics u:object_r:pdx_display_client_endpoint_socket:s0
    socket pdx/system/vr/display/manager    stream 0666 system graphics u:object_r:pdx_display_manager_endpoint_socket:s0
    socket pdx/system/vr/display/vsync      stream 0666 system graphics u:object_r:pdx_display_vsync_endpoint_socket:s0

这里我们就简简单单理解为：设备开机启动时，init进程解析surfaceflinger.rc，然后去执行/system/bin/surfaceflinger，从而启动了SurfaceFlinger服务进程。

如果在设备console下执行ps，你就可以看到这个进程PID了

console:/ $ ps -A | grep surfaceflinger
system          210      1  133412  38160 0                   0 S surfaceflinger

可执行档surfaceflinger的main函数入口

在此我们仅摘录主要的代码并注释如下：

* /frameworks/native/services/surfaceflinger/main_surfaceflinger.cpp

int main(int, char**) {
    ...
    
    // When SF is launched in its own process, limit the number of
    // binder threads to 4.
    ProcessState::self()->setThreadPoolMaxThreadCount(4);

    ...
    
    // start the thread pool
    sp<ProcessState> ps(ProcessState::self());
    ps->startThreadPool();

    ...
    
    // 创建SurfaceFlinger对象，由强指针指向。
    // SurfaceFlinger继承RefBase类，所以此处一旦new出对象赋给sp指针后，将立刻触发SurfaceFlinger类的onFirstRef方法的调用。
    // instantiate surfaceflinger
    sp<SurfaceFlinger> flinger = surfaceflinger::createSurfaceFlinger();

    ...

    // SurfaceFlinger类正式初始化
    // initialize before clients can connect
    flinger->init();

    // SurfaceFlinger向ServiceManager注册Binder服务，
    // 这样在其他进程中可以通过getService+SERVICE_NAME来获取SurfaceFlinger服务，继而可以和SurfaceFlinger类进行Binder通信。
    // publish surface flinger
    sp<IServiceManager> sm(defaultServiceManager());
    sm->addService(String16(SurfaceFlinger::getServiceName()), flinger, false,
                   IServiceManager::DUMP_FLAG_PRIORITY_CRITICAL | IServiceManager::DUMP_FLAG_PROTO);

    ...
    
    // SurfaceFlinger类进入主循环（此处注意SurfaceFlinger类未继承Threads类，不遵循Threads类的接口执行顺序）
    // run surface flinger in this thread
    flinger->run();

    return 0;
}

对于main函数，简简单单把握一下几点就可以了：

  1. 创建SurfaceFlinger对象，触发执行 SurfaceFlinger::onFirstRef()
  2. 调用SurfaceFlinger::init()进行初始化
  3. 注册服务到ServiceManager(名字是"SurfaceFlinger")
  4. 调用SurfaceFlinger::run()

 Tips：

在设备console上执行service list命令就可以看到注册的服务：注册的名称是SurfaceFlinger, 这个服务实现的接口是android.ui.ISurfaceComposer

console:/ $  service list | grep Surface
1       SurfaceFlinger: [android.ui.ISurfaceComposer]

SurfaceFlinger类定义

* /frameworks/native/services/surfaceflinger/SurfaceFlinger.h
class SurfaceFlinger : public BnSurfaceComposer,
                       public PriorityDumper,
                       private IBinder::DeathRecipient,
                       private HWC2::ComposerCallback,
                       private ISchedulerCallback {
♦ SurfaceComposer继承自BnSurfaceComposer，即为实现了ISurfaceComposer接口的Bn服务端；
♦ 实现了HWC2的ComposerCallback回调，监听Composer HAL的一些事件，比如Hotplug, Vsync ...
♦ 死亡通知DeathRecipient，当Binder服务端程序挂掉后，可以通知给绑定的Binder客户端程序；
♦ Dump信息PriorityDumper；

创建SurfaceFinger实例对象

调用surfaceflinger::createSurfaceFlinger()来创建SurfaceFlinger实例，并传递一个factory对象作为参数

* /frameworks/native/services/surfaceflinger/SurfaceFlingerFactory.cpp

sp<SurfaceFlinger> createSurfaceFlinger() {
    static DefaultFactory factory;

    return new SurfaceFlinger(factory);
}

来简单看一下Factory的定义：

* /frameworks/native/services/surfaceflinger/SurfaceFlingerFactory.h 

// The interface that SurfaceFlinger uses to create all of the implementations
// of each interface.
class Factory {
public:
    virtual std::unique_ptr<HWComposer> createHWComposer(const std::string& serviceName) = 0;
    virtual std::unique_ptr<MessageQueue> createMessageQueue() = 0;
    virtual std::unique_ptr<scheduler::VsyncConfiguration> createVsyncConfiguration(
            Fps currentRefreshRate) = 0;
    virtual std::unique_ptr<Scheduler> createScheduler(const scheduler::RefreshRateConfigs&,
                                                       ISchedulerCallback&) = 0;
    virtual sp<SurfaceInterceptor> createSurfaceInterceptor() = 0;

    virtual sp<StartPropertySetThread> createStartPropertySetThread(
            bool timestampPropertyValue) = 0;
    virtual sp<DisplayDevice> createDisplayDevice(DisplayDeviceCreationArgs&) = 0;
    virtual sp<GraphicBuffer> createGraphicBuffer(uint32_t width, uint32_t height,
                                                  PixelFormat format, uint32_t layerCount,
                                                  uint64_t usage, std::string requestorName) = 0;
    virtual void createBufferQueue(sp<IGraphicBufferProducer>* outProducer,
                                   sp<IGraphicBufferConsumer>* outConsumer,
                                   bool consumerIsSurfaceFlinger) = 0;
    virtual sp<IGraphicBufferProducer> createMonitoredProducer(const sp<IGraphicBufferProducer>&,
                                                               const sp<SurfaceFlinger>&,
                                                               const wp<Layer>&) = 0;
    virtual sp<BufferLayerConsumer> createBufferLayerConsumer(const sp<IGraphicBufferConsumer>&,
                                                              renderengine::RenderEngine&,
                                                              uint32_t tex, Layer*) = 0;

    virtual std::unique_ptr<surfaceflinger::NativeWindowSurface> createNativeWindowSurface(
            const sp<IGraphicBufferProducer>&) = 0;

    virtual std::unique_ptr<compositionengine::CompositionEngine> createCompositionEngine() = 0;

    virtual sp<BufferQueueLayer> createBufferQueueLayer(const LayerCreationArgs& args) = 0;
    virtual sp<BufferStateLayer> createBufferStateLayer(const LayerCreationArgs& args) = 0;
    virtual sp<EffectLayer> createEffectLayer(const LayerCreationArgs& args) = 0;
    virtual sp<ContainerLayer> createContainerLayer(const LayerCreationArgs& args) = 0;
    virtual std::unique_ptr<FrameTracer> createFrameTracer() = 0;
    virtual std::unique_ptr<frametimeline::FrameTimeline> createFrameTimeline(
            std::shared_ptr<TimeStats> timeStats, pid_t surfaceFlingerPid) = 0;

protected:
    ~Factory() = default;
};

 Factory中定义了各种create方法，其作用如注释中说明：The interface that SurfaceFlinger uses to create all of the implementations of each interface. 

SurfaceFlinger用Factory来创建所有实现了对应接口的对象。SurfaceFlinger中默认使用的是DefaultFactory，其中定义各种createXXX()方法的实现。具体可参见：/frameworks/native/services/surfaceflinger/SurfaceFlingerDefaultFactory.cpp

SurfaceFlinger构造函数

构造函数的代码就只截取部分贴在这里了，其中主要是读取一些属性值来对一些成员变量进行初始化。其中一些属性值是debug参数。另外就是利用mFactory的createXXX方法去实例化各种对象。

比如 ： 创建消息队列 mEventQueue(mFactory.createMessageQueue())

* /frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp 

SurfaceFlinger::SurfaceFlinger(Factory& factory, SkipInitializationTag)
      : mFactory(factory),
        mInterceptor(mFactory.createSurfaceInterceptor()),
        mTimeStats(std::make_shared<impl::TimeStats>()),
        mFrameTracer(mFactory.createFrameTracer()),
        mFrameTimeline(mFactory.createFrameTimeline(mTimeStats, getpid())),
        mEventQueue(mFactory.createMessageQueue()),
        mCompositionEngine(mFactory.createCompositionEngine()),
        mHwcServiceName(base::GetProperty("debug.sf.hwc_service_name"s, "default"s)),
        mTunnelModeEnabledReporter(new TunnelModeEnabledReporter()),
        mInternalDisplayDensity(getDensityFromProperty("ro.sf.lcd_density", true)),
        mEmulatedDisplayDensity(getDensityFromProperty("qemu.sf.lcd_density", false)),
        mPowerAdvisor(*this) {
    ALOGI("Using HWComposer service: %s", mHwcServiceName.c_str());

    mSetInputWindowsListener = new SetInputWindowsListener([&]() { setInputWindowsFinished(); });
}

SurfaceFlinger::SurfaceFlinger(Factory& factory) : SurfaceFlinger(factory, SkipInitialization) {
    ALOGI("SurfaceFlinger is starting");

    hasSyncFramework = running_without_sync_framework(true);

    dispSyncPresentTimeOffset = present_time_offset_from_vsync_ns(0);

    useHwcForRgbToYuv = force_hwc_copy_for_virtual_displays(false);

    maxFrameBufferAcquiredBuffers = max_frame_buffer_acquired_buffers(2);

    maxGraphicsWidth = std::max(max_graphics_width(0), 0);
    maxGraphicsHeight = std::max(max_graphics_height(0), 0);

    hasWideColorDisplay = has_wide_color_display(false);
  
  	...
    
    
  }

surfaceflinger 会去读取SurfaceFlingerProperties中的系统属性，具体可以参看源码：/frameworks/native/services/surfaceflinger/sysprop/

Tips:

关于系统属性的知识建议可以参见：

https://source.android.google.cn/devices/architecture/sysprops-apis?hl=zh-cn

https://blog.****.net/askfgx2010/article/details/112308665

SurfaceFlinger::onFirstRef

上面创建完SurfaceFlinger对象，立即就会执行到SurfaceFlinger::onFirstRef，这个方法中就做了一件事对消息队列做初始化，如下：

void SurfaceFlinger::onFirstRef() {
    mEventQueue->init(this);
}

消息队列运行的详细分析我们下节在讲，这里先不展开。

SurfaceFlinger::init

再回到可执行档surfaceflinger的main函数中，创建完SurfaceFlinger对象后，紧接着调用了SurfaceFlinger::init()方法：

* /frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp

void SurfaceFlinger::init() {
    ALOGI(  "SurfaceFlinger's main thread ready to run. "
            "Initializing graphics H/W...");
    Mutex::Autolock _l(mStateLock);

    // 对于CompositionEngine 属性进行设置， 创建 RenderEngine 对象
    // Get a RenderEngine for the given display / config (can't fail)
    // TODO(b/77156734): We need to stop casting and use HAL types when possible.
    // Sending maxFrameBufferAcquiredBuffers as the cache size is tightly tuned to single-display.
    mCompositionEngine->setRenderEngine(renderengine::RenderEngine::create(
            renderengine::RenderEngineCreationArgs::Builder()
                    .setPixelFormat(static_cast<int32_t>(defaultCompositionPixelFormat))
                    .setImageCacheSize(maxFrameBufferAcquiredBuffers)
                    .setUseColorManagerment(useColorManagement)
                    .setEnableProtectedContext(enable_protected_contents(false))
                    .setPrecacheToneMapperShaderOnly(false)
                    .setSupportsBackgroundBlur(mSupportsBlur)
                    .setContextPriority(
                            useContextPriority
                                    ? renderengine::RenderEngine::ContextPriority::REALTIME
                                    : renderengine::RenderEngine::ContextPriority::MEDIUM)
                    .build()));

    // Set SF main policy after initializing RenderEngine which has its own policy.
    if (!SetTaskProfiles(0, {"SFMainPolicy"})) {
        ALOGW("Failed to set main task profile");
    }

    // 创建HWComposer对象并传入一个name属性，再通过mCompositionEngine->setHwComposer设置对象属性。
    mCompositionEngine->setTimeStats(mTimeStats);
    mCompositionEngine->setHwComposer(getFactory().createHWComposer(mHwcServiceName));
    mCompositionEngine->getHwComposer().setCallback(this);
    ClientCache::getInstance().setRenderEngine(&getRenderEngine());

    if (base::GetBoolProperty("debug.sf.enable_hwc_vds"s, false)) {
        enableHalVirtualDisplays(true);
    }

// processDisplayHotplugEventsLocked(); 处理 任何初始热插拔和显示更改的结果
// 在此方法中主要有调用 initScheduler(displayId);
    // Process any initial hotplug and resulting display changes.
    processDisplayHotplugEventsLocked();
    const auto display = getDefaultDisplayDeviceLocked();
    LOG_ALWAYS_FATAL_IF(!display, "Missing internal display after registering composer callback.");
    const auto displayId = display->getPhysicalId();
    LOG_ALWAYS_FATAL_IF(!getHwComposer().isConnected(displayId),
                        "Internal display is disconnected.");

    // initialize our drawing state
    mDrawingState = mCurrentState;

    // 初始化Display信息
    // set initial conditions (e.g. unblank default device)
    initializeDisplays();

    mPowerAdvisor.init();

    char primeShaderCache[PROPERTY_VALUE_MAX];
    property_get("service.sf.prime_shader_cache", primeShaderCache, "1");
    if (atoi(primeShaderCache)) {
        if (setSchedFifo(false) != NO_ERROR) {
            ALOGW("Can't set SCHED_OTHER for primeCache");
        }

        mRenderEnginePrimeCacheFuture = getRenderEngine().primeCache();

        if (setSchedFifo(true) != NO_ERROR) {
            ALOGW("Can't set SCHED_OTHER for primeCache");
        }
    }

    getRenderEngine().onPrimaryDisplaySizeChanged(display->getSize());

    // Inform native graphics APIs whether the present timestamp is supported:

    const bool presentFenceReliable =
            !getHwComposer().hasCapability(hal::Capability::PRESENT_FENCE_IS_NOT_RELIABLE);
    mStartPropertySetThread = getFactory().createStartPropertySetThread(presentFenceReliable);
    // 开启一个设置属性的线程，在这个线程中使用property_set去设置一些属性值
    if (mStartPropertySetThread->Start() != NO_ERROR) {
        ALOGE("Run StartPropertySetThread failed!");
    }

    ALOGV("Done initializing");
}

SurfaceFlinger::init方法，完成的工作大概为:

♦ CompositionEngine的配置，创建RenderEngine对象用于Client合成模式（GPU）合成;

♦ 初始化HWComposer，注册回调接口mCompositionEngine->getHwComposer().setCallback(this)，HAL会回调一些方法;

♦ 处理Display显示屏幕的热插拔和更改的事件processDisplayHotplugEventsLocked;

♦ 初始化显示设备initializeDisplays;

♦ 开启一个设置属性的线程，在这个线程中使用property_set去设置一些属性值mStartPropertySetThread->Start();

 SurfaceFlinger::run

可执行档surfaceflinger的main函数中，把SurfaceFinger这个服务注册进ServiceManger中后，后续执行了SurfaceFlinger::run这个方法，代码如下：

* /frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp 

void SurfaceFlinger::run() {
    while (true) {
        mEventQueue->waitMessage();
    }
}

这个方法也很简单，一个while(true)的无限死循环，消息队列等待消息的到来。surfaceflinger主线程中等待消息处理。

讲到这里，大概SurfaceFlinger启动的流程就完成了，当然，很多细节我们没有深入去分析。

上一篇： 在团队聊天中难以加入讨论，如何更好地融入集体情绪呢？

下一篇： 在Android开发中，编译时期插桩技巧：让应用自行生成代码（第二部分）

推荐阅读