Android P图形架构之DisplayManagerService解析

叁歲伎倆 2024-04-18 16:53 61阅读 0赞

顾名思义，DisplayManagerService是一个用于管理显示的服务。

源码：  
\\frameworks\\base\\services\\java\\com\\android\\server\\SystemServer.java  
\\frameworks\\base\\services\\core\\java\\com\\android\\server\\display\\DisplayManagerService.java  
\\frameworks\\base\\services\\core\\java\\com\\android\\server\\display\\DisplayDevice.java  
\\frameworks\\base\\services\\core\\java\\com\\android\\server\\display\\LogicalDisplay.java

作用：

*  管理显示器的全局生命周期， 决定如何根据当前连接的物理显示设备配置逻辑显示，在状态更改时向系统和应用程序发送通知等
 *  显示管理服务依赖于DisplayAdapter（LocalDisplayAdapter，OverlayDisplayAdapter，WifiDisplayAdapter）用于发现和配置连接到系统的物理显示设备
 *  设备连接的方式都有单独的DisplayAdapter，一个本地显示器的适配器，用于模拟无头系统（不接显示器）的非功能显示；一个用于开发的模拟overlay显示器；一个用wifi显示器
 *  显示适配器仅与显示管理器服务弱耦合
 *  显示适配器通过显示管理器服务注册的DisplayAdapter.Listener异步地将显示设备状态的变化传送到显示管理器服务

启动过程：  
DisplayManagerService是在SystemServer中启动的。  
\\frameworks\\base\\services\\java\\com\\android\\server\\SystemServer.java

private void startBootstrapServices() { 
    	//...
    	
    	// Display manager is needed to provide display metrics before package manager
    	// starts up.
    	traceBeginAndSlog("StartDisplayManager");
    	mDisplayManagerService = mSystemServiceManager.startService(DisplayManagerService.class);
    	traceEnd();
    
    	//...
    }

代码分析：

### LocalDisplayAdapter ###

DisplayManagerService的onStart()中发送了消息MSG\_REGISTER\_DEFAULT\_DISPLAY\_ADAPTERS，去执行了registerDefaultDisplayAdapters()，初始化了主屏显示器适配器LocalDisplayAdapter

@Override
    public void onStart() { 
        // We need to pre-load the persistent data store so it's ready before the default display
        // adapter is up so that we have it's configuration. We could load it lazily, but since
        // we're going to have to read it in eventually we may as well do it here rather than after
        // we've waited for the display to register itself with us.
    synchronized(mSyncRoot) { 
    mPersistentDataStore.loadIfNeeded();
    loadStableDisplayValuesLocked();
        }
        mHandler.sendEmptyMessage(MSG_REGISTER_DEFAULT_DISPLAY_ADAPTERS);
    
        publishBinderService(Context.DISPLAY_SERVICE, new BinderService(),
                true /*allowIsolated*/);
        publishLocalService(DisplayManagerInternal.class, new LocalService());
        publishLocalService(DisplayTransformManager.class, new DisplayTransformManager());
    }
    
    //加载LocalDisplayAdapter和getVirtualDisplayAdapter
    private void registerDefaultDisplayAdapters() { 
        // Register default display adapters.
        synchronized (mSyncRoot) { 
            // main display adapter
            registerDisplayAdapterLocked(new LocalDisplayAdapter(
                    mSyncRoot, mContext, mHandler, mDisplayAdapterListener));
    
            // Standalone VR devices rely on a virtual display as their primary display for
            // 2D UI. We register virtual display adapter along side the main display adapter
            // here so that it is ready by the time the system sends the home Intent for
            // early apps like SetupWizard/Launcher. In particular, SUW is displayed using
            // the virtual display inside VR before any VR-specific apps even run.
            mVirtualDisplayAdapter = mInjector.getVirtualDisplayAdapter(mSyncRoot, mContext,
                    mHandler, mDisplayAdapterListener);
            if (mVirtualDisplayAdapter != null) { 
                registerDisplayAdapterLocked(mVirtualDisplayAdapter);
            }
        }
    }

registerDisplayAdapterLocked把适配器放入了mDisplayAdapters中，并且执行了LocalDisplayAdapter的registerLocked();

// List of all currently registered display adapters.
    private final ArrayList<DisplayAdapter> mDisplayAdapters = new ArrayList<DisplayAdapter>();
    
    private void registerDisplayAdapterLocked(DisplayAdapter adapter) { 
        mDisplayAdapters.add(adapter);
        adapter.registerLocked();
    }

LocalDisplayAdapter中则去调用SurfaceFlinger获取物理显示屏的信息，并返回给DisplayManagerService，最终执行了handleDisplayDeviceAddedLocked()，来添加显示器设备。  
\\frameworks\\base\\services\\core\\java\\com\\android\\server\\display\\LocalDisplayAdapter.java

@Override
    public void registerLocked() { 
        super.registerLocked();
    
        mHotplugReceiver = new HotplugDisplayEventReceiver(getHandler().getLooper());
    
        for (int builtInDisplayId : BUILT_IN_DISPLAY_IDS_TO_SCAN) { 
            tryConnectDisplayLocked(builtInDisplayId);
        }
    }

添加显示器：

// List of all currently connected display devices.
    private final ArrayList<DisplayDevice> mDisplayDevices = new ArrayList<DisplayDevice>();
    
    private void handleDisplayDeviceAddedLocked(DisplayDevice device) { 
        DisplayDeviceInfo info = device.getDisplayDeviceInfoLocked();
        if (mDisplayDevices.contains(device)) { 
            Slog.w(TAG, "Attempted to add already added display device: " + info);
            return;
        }
    
        Slog.i(TAG, "Display device added: " + info);
        
        device.mDebugLastLoggedDeviceInfo = info;
    
        mDisplayDevices.add(device);
        LogicalDisplay display = addLogicalDisplayLocked(device);
        Runnable work = updateDisplayStateLocked(device);
        if (work != null) { 
            work.run();
        }
        scheduleTraversalLocked(false);
    }

handleDisplayDeviceAddedLocked()会将显示器设备统一放到mDisplayDevices中，并且执行了addLogicalDisplayLocked()，作用是在一个显示设备中添加逻辑显示，assignDisplayIdLocked()分配一个displayId，并且放入mLogicalDisplays中。

// List of all logical displays indexed by logical display id.
    private final SparseArray<LogicalDisplay> mLogicalDisplays = new SparseArray<LogicalDisplay>();
    
    // Adds a new logical display based on the given display device.
    // Sends notifications if needed.
    private LogicalDisplay addLogicalDisplayLocked(DisplayDevice device) { 
        DisplayDeviceInfo deviceInfo = device.getDisplayDeviceInfoLocked();
        boolean isDefault = (deviceInfo.flags
                & DisplayDeviceInfo.FLAG_DEFAULT_DISPLAY) != 0;
        if (isDefault && mLogicalDisplays.get(Display.DEFAULT_DISPLAY) != null) { 
            Slog.w(TAG, "Ignoring attempt to add a second default display: " + deviceInfo);
            isDefault = false;
        }
    
        if (!isDefault && mSingleDisplayDemoMode) { 
            Slog.i(TAG, "Not creating a logical display for a secondary display "
                    + " because single display demo mode is enabled: " + deviceInfo);
            return null;
        }
    
        final int displayId = assignDisplayIdLocked(isDefault);
        final int layerStack = assignLayerStackLocked(displayId);
    
        LogicalDisplay display = new LogicalDisplay(displayId, layerStack, device);
        display.updateLocked(mDisplayDevices);
        if (!display.isValidLocked()) { 
            // This should never happen currently.
            Slog.w(TAG, "Ignoring display device because the logical display "
                    + "created from it was not considered valid: " + deviceInfo);
            return null;
        }
    
        configureColorModeLocked(display, device);
        if (isDefault) { 
            recordStableDisplayStatsIfNeededLocked(display);
            recordTopInsetLocked(display);
        }
    
        mLogicalDisplays.put(displayId, display);
    
        // Wake up waitForDefaultDisplay.
        if (isDefault) { 
            mSyncRoot.notifyAll();
        }
    
        sendDisplayEventLocked(displayId, DisplayManagerGlobal.EVENT_DISPLAY_ADDED);
        return display;
    }

### OverlayDisplayAdapter、WifiDisplayAdapter ###

DisplayManagerService的systemReady()中，发送了MSG\_REGISTER\_ADDITIONAL\_DISPLAY\_ADAPTERS，并执行了registerAdditionalDisplayAdapters()，在registerAdditionalDisplayAdapters中完成了OverlayDisplayAdapter和WifiDisplayAdapter的注册。

/** * Called when the system is ready to go. */
    public void systemReady(boolean safeMode, boolean onlyCore) { 
        synchronized (mSyncRoot) { 
            mSafeMode = safeMode;
            mOnlyCore = onlyCore;
            mSystemReady = true;
            // Just in case the top inset changed before the system was ready. At this point, any
            // relevant configuration should be in place.
            recordTopInsetLocked(mLogicalDisplays.get(Display.DEFAULT_DISPLAY));
        }
    
        mHandler.sendEmptyMessage(MSG_REGISTER_ADDITIONAL_DISPLAY_ADAPTERS);
        mHandler.sendEmptyMessage(MSG_REGISTER_BRIGHTNESS_TRACKER);
    }
    
    private void registerAdditionalDisplayAdapters() { 
        synchronized (mSyncRoot) { 
            if (shouldRegisterNonEssentialDisplayAdaptersLocked()) { 
                registerOverlayDisplayAdapterLocked();
                registerWifiDisplayAdapterLocked();
            }
        }
    }

跟LocalDisplayAdapter流程类似:

private void registerOverlayDisplayAdapterLocked() { 
        registerDisplayAdapterLocked(new OverlayDisplayAdapter(
                mSyncRoot, mContext, mHandler, mDisplayAdapterListener, mUiHandler));
    }
    
    private void registerWifiDisplayAdapterLocked() { 
        if (mContext.getResources().getBoolean(
                com.android.internal.R.bool.config_enableWifiDisplay)
                || SystemProperties.getInt(FORCE_WIFI_DISPLAY_ENABLE, -1) == 1) { 
            mWifiDisplayAdapter = new WifiDisplayAdapter(
                    mSyncRoot, mContext, mHandler, mDisplayAdapterListener,
                    mPersistentDataStore);
            registerDisplayAdapterLocked(mWifiDisplayAdapter);
        }
    }

### VirtualDisplayAdapter ###

在加载LocalDisplayAdapter的时候就加载了虚拟显示适配器，因为虚拟显示必须依赖于物理屏。  
DisplayManagerService的onstart()中执行的，getVirtualDisplayAdapter()，加载虚拟屏。

private void registerDefaultDisplayAdapters() { 
        // Register default display adapters.
        synchronized (mSyncRoot) { 
            // main display adapter
            registerDisplayAdapterLocked(new LocalDisplayAdapter(
                    mSyncRoot, mContext, mHandler, mDisplayAdapterListener));
    
            // Standalone VR devices rely on a virtual display as their primary display for
            // 2D UI. We register virtual display adapter along side the main display adapter
            // here so that it is ready by the time the system sends the home Intent for
            // early apps like SetupWizard/Launcher. In particular, SUW is displayed using
            // the virtual display inside VR before any VR-specific apps even run.
            mVirtualDisplayAdapter = mInjector.getVirtualDisplayAdapter(mSyncRoot, mContext,
                    mHandler, mDisplayAdapterListener);
            if (mVirtualDisplayAdapter != null) { 
                registerDisplayAdapterLocked(mVirtualDisplayAdapter);
            }
        }
    }
    
    @VisibleForTesting
    static class Injector { 
        VirtualDisplayAdapter getVirtualDisplayAdapter(SyncRoot syncRoot, Context context,
                Handler handler, DisplayAdapter.Listener displayAdapterListener) { 
            return new VirtualDisplayAdapter(syncRoot, context, handler, displayAdapterListener);
        }
    
        long getDefaultDisplayDelayTimeout() { 
            return WAIT_FOR_DEFAULT_DISPLAY_TIMEOUT;
        }
    }