前言
DisplayManagerService是Android Framework中管理显示屏幕相关的模块,各种Display的连接、配置等,都是通过DMS和来管理控制。
在DMS模块中,对显示屏幕的描述分为物理显示屏(physical display)和逻辑显示屏(logical display),物理屏主要从SurfaceFlinger中读取参数创建,代表实实在在的物理屏,描述其物理特性,不同物理屏有不同的属性。逻辑屏则是相对于对物理屏,侧重于同一个物理屏的不同逻辑设置,受应用和WMS模块影响,如显示区域、显示位置坐标、显示方向等。每一个物理屏幕都对应一个逻辑屏幕,可以修改逻辑屏幕参数,做到同一个物理屏的不同显示方式。
由于不同的物理显示屏有不同的属性和处理方式,因此DMS中通过一系列的屏幕适配器(DisplayAdapter)来和分别各种物理显示屏进行连接。
一、DMS模块常见类
1.1 全局管理类
- IDisplayManager: IBinder接口,负责DMS和其他组建的IPC工作;
- DisplayManagerService:继承于SystemService的系统服务,负责整个系统display的控制和管理;
- DisplayManagerService.LocalService: 继承于DisplayManagerInternal,负责system_server内部其他模块和DMS的交互;
- DisplayManagerService.BindService: 继承于IDisplayManager,是IDisplayManager的具体实现类;
- DisplayManagerService.CallbackRecord: DMS内部类,内部持有IDisplayManagerCallback对象,负责执行IDisplayManagerCallback的回调;
- DisplayManager: 暴露给App层的接口,内部持有DisplayManagerGlobal对象引用,利用DisplayManagerGlobal和DMS进行交互;
- IDisplayManagerCallback:一个IBinder接口,DMS中发生display相关动作后,会通过该接口回调通知给DisplayManagerGlobal;
- DisplayManagerGlobal:内部持有IDisplayManager对象引用,App层通过该对象和DMS进行跨IPC交互;
- DisplayManagerGlobal.DisplayManagerCallback: 继承于IDisplayManagerCallback接口,负责接收来自DMS中display事件的回调;
1.2 数据封装类
- DisplayDevice: 屏幕设备对象。
- DisplayDeviceRepository:屏幕设备管理者,内部持有DisplayDevice集合,负责管理屏幕设备对象。
- WifiDisplayDevice:DisplayDevice的子类,代表通过Wifi连接显示的物理屏幕;
- OverlayDisplayDevice:DisplayDevice的子类,开发者选项->模拟辅助显示开启后,创建的就是该类对象;
- VirtualDisplayDevice:DisplayDevice的子类,表示虚拟显示屏幕,用于屏幕录制等;
- LocalDisplayDevice:DisplayDevice的子类,代表内置物理屏幕,DMS启动后会通过SurfaceControl去读取内置屏幕数据,并创建该类对象;
- LogicalDisplay:代表逻辑显示屏,每一个physical display都会对应一个logical display;
- LogicalDisplayMapper:逻辑屏幕设备管理者,内部持有LogicalDisplay对象集合
- DisplayDeviceInfo: DisplayDevice信息封装类,在创建DisplayDevice时会进行创建,与之对应的是Logical display 的DisplayInfo;
- DisplayInfo:LogicalDisplay信息的封装类,基本数据由DisplayDeviceInfo中获得,app可以通过WMS来修改自己的参数;
- DisplayAdapter: 各物理屏和DMS进行连接的适配器;
- LocalDisplayAdapter: 继承于DisplayAdapter, 用于LocalDisplayDevice和DMS的连接;
- WifiDisplayAdapter: 继承于DisplayAdapter,用于WifiDisplayDevice的和DMS的连接;
- OverlayDisplayAdapter:继承于DisplayAdapter,用于OverlayDisplayDevice和DMS的连接;
- VirtualDisplayAdapter:继承于DisplayAdapter,用于VirtualDisplayDevice和DMS的连接;
- DisplayAdapter.Listener:用于通知DisplayDevice发生变化的接口,DMS中对其进行了实现,会接收以下三个事件并根据事件作出全局反应:a.添加了新的DisplayDevice ;b.DisplayDevice状态发生变化; c.移除DisplayDevice。
- DisplayViewport:携带有physical display参数,用于通知IMS display信息。
1.3 基本类结构的对应关系图
1.4 源码位置
包名 | 目录 | 描述 | 例子 |
---|---|---|---|
android.hardware.display | frameworks/base/core/java/android/hardware/display | DMS模块管理 | DisplayManager, DisplayMangaerGlobal, … |
android.view | frameworks/base/core/java/android/view | 逻辑屏配置项相关 | DisplayInfo, DisplayViewport, … |
com.android.server.display | frameworks/base/services/core/java/com/android/server/display | DMS核心 | DMS,DisplayDevice, … |
二、DisplayManagerService的启动流程
系统启动后会启动JVM虚拟机,SystemServer 是虚拟机的第一个进程,由init 进程fork 产生,主要用来启动frameworks层中的服务,DMS服务也是在这里被启动的,下面我们简单列出SystemServer中和DMS启动相关的源码。
frameworks/base/service/java/com/android/server/SystemServer.java
public final class SystemServer {
private DisplayManagerService mDisplayManagerService;
public static void main(String[] args) {
new SystemServer().run();
}
private void run() {
...代码省略...
try {
t.traceBegin("StartServices");
startBootstrapServices(t);//引导服务
startCoreServices(t);//核心服务
startOtherServices(t);//其他服务
} catch (Throwable ex) {
Slog.e("System", "******************************************");
Slog.e("System", "************ Failure starting system services", ex);
throw ex;
} finally {
t.traceEnd(); // StartServices
}
...代码省略...
}
private void startBootstrapServices(@NonNull TimingsTraceAndSlog t) {
...代码省略...
// Display manager is needed to provide display metrics before package manager
// starts up.
t.traceBegin("StartDisplayManager");
mDisplayManagerService = mSystemServiceManager.startService(DisplayManagerService.class);//通过反射构建对象实例
t.traceEnd();
// We need the default display before we can initialize the package manager.
t.traceBegin("WaitForDisplay");
mSystemServiceManager.startBootPhase(t, SystemService.PHASE_WAIT_FOR_DEFAULT_DISPLAY);//调用DMS的onBootPhase方法
t.traceEnd();
...代码省略...
// DisplayManagerService needs to setup android.display scheduling related policies
// since setSystemProcess() would have overridden policies due to setProcessGroup
mDisplayManagerService.setupSchedulerPolicies();//调用DMS的setupSchedulerPolicies方法
...代码省略...
}
private void startOtherServices(@NonNull TimingsTraceAndSlog t) {
...代码省略...
t.traceBegin("DisplayManagerWindowManagerAndInputReady");
mDisplayManagerService.windowManagerAndInputReady();//调用DMS的windowManagerAndInputReady方法
t.traceEnd();
...代码省略...
t.traceBegin("MakeDisplayManagerServiceReady");
try {
mDisplayManagerService.systemReady(safeMode, mOnlyCore);//调用DMS的systemReady方法
} catch (Throwable e) {
reportWtf("making Display Manager Service ready", e);
}
t.traceEnd();
}
}
2.1 构造方法
DisplayManagerService实例对象是通过SystemServiceManager的startService方法获得的,该方法内部先是通过反射构建DisplayManagerService对象实例的,然后还会调用该对象的onStart方法,先来看下构造方法。
frameworks/base/services/core/java/com/android/server/display/DisplayManagerService.java
public final class DisplayManagerService extends SystemService {
private final Context mContext;
//android.display线程的Handler
private final DisplayManagerHandler mHandler;
//android.ui线程Handler
private final Handler mUiHandler;
//主要负责管理和协调设备的显示模式,包括分辨率、刷新率等。
//它优化了系统的显示设置,以平衡性能和电池使用,并确保在多显示器配置下的显示效果一致。
private final DisplayModeDirector mDisplayModeDirector;
//屏幕设备管理者, 此类内容维护了一个 DisplayDevice 对象的集合,这些对象代表了系统中所有的显示设备。
//可以通过这个类跟踪各个显示设备的状态、属性和配置。
private final DisplayDeviceRepository mDisplayDeviceRepo;
//主要负责逻辑显示设备的映射和管理,确保物理显示设备的状态和配置能够正确映射到逻辑显示设备上。
//这个类对于支持多显示器和虚拟显示设备的系统功能至关重要。
private final LogicalDisplayMapper mLogicalDisplayMapper;
private final Injector mInjector;
//负责同步和管理屏幕亮度设置,以确保多个显示设备或显示区域的亮度一致,同时优化用户体验和系统协调。
private final BrightnessSynchronizer mBrightnessSynchronizer;
public DisplayManagerService(Context context) {
this(context, new Injector());
}
@VisibleForTesting
DisplayManagerService(Context context, Injector injector) {
super(context);
mInjector = injector;
mContext = context;
//android.display线程handler
mHandler = new DisplayManagerHandler(DisplayThread.get().getLooper());
//android.ui线程Handler
mUiHandler = UiThread.getHandler();
//管理所有的屏幕设备
mDisplayDeviceRepo = new DisplayDeviceRepository(mSyncRoot, mPersistentDataStore);
//负责逻辑显示设备的映射和管理
mLogicalDisplayMapper = new LogicalDisplayMapper(mContext, mDisplayDeviceRepo,
new LogicalDisplayListener(), mSyncRoot, mHandler);
//负责管理和协调设备的显示模式
mDisplayModeDirector = new DisplayModeDirector(context, mHandler);
//负责同步和管理屏幕亮度设置
mBrightnessSynchronizer = new BrightnessSynchronizer(mContext);
Resources resources = mContext.getResources();
mDefaultDisplayDefaultColorMode = mContext.getResources().getInteger(
com.android.internal.R.integer.config_defaultDisplayDefaultColorMode);
mDefaultDisplayTopInset = SystemProperties.getInt(PROP_DEFAULT_DISPLAY_TOP_INSET, -1);
float[] lux = getFloatArray(resources.obtainTypedArray(
com.android.internal.R.array.config_minimumBrightnessCurveLux));
float[] nits = getFloatArray(resources.obtainTypedArray(
com.android.internal.R.array.config_minimumBrightnessCurveNits));
mMinimumBrightnessCurve = new Curve(lux, nits);
mMinimumBrightnessSpline = Spline.createSpline(lux, nits);
mCurrentUserId = UserHandle.USER_SYSTEM;
ColorSpace[] colorSpaces = SurfaceControl.getCompositionColorSpaces();
mWideColorSpace = colorSpaces[1];
mAllowNonNativeRefreshRateOverride = mInjector.getAllowNonNativeRefreshRateOverride();
mSystemReady = false;
}
}
2.2 执行onStart方法
public final class DisplayManagerService extends SystemService {
private final PersistentDataStore mPersistentDataStore = new PersistentDataStore();
@Override
public void onStart() {
// 加载数据
synchronized (mSyncRoot) {
mPersistentDataStore.loadIfNeeded();//加载display中的固定数据
loadStableDisplayValuesLocked();
}
// 在android.display线程中创建默认DisplayAdapter,并进行注册
mHandler.sendEmptyMessage(MSG_REGISTER_DEFAULT_DISPLAY_ADAPTERS);
// If there was a runtime restart then we may have stale caches left around, so we need to
// make sure to invalidate them upon every start.
DisplayManagerGlobal.invalidateLocalDisplayInfoCaches();
//向ServiceManager注册BinderService,以便其他模块可以跨进程调用
publishBinderService(Context.DISPLAY_SERVICE, new BinderService(),
true /*allowIsolated*/);
//注册Local Service
publishLocalService(DisplayManagerInternal.class, new LocalService());
}
}
2.2.1 加载display中的固定数据
frameworks/base/services/core/java/com/android/server/display/PersistentDataStore.java
final class PersistentDataStore {
private Injector mInjector;
public PersistentDataStore() {
this(new Injector());
}
@VisibleForTesting
PersistentDataStore(Injector injector) {
mInjector = injector;
}
public void loadIfNeeded() {
if (!mLoaded) {
load();
mLoaded = true;
}
}
private void load() {
clearState();
final InputStream is;
try {
is = mInjector.openRead();
} catch (FileNotFoundException ex) {
return;
}
TypedXmlPullParser parser;
try {
parser = Xml.resolvePullParser(is);
loadFromXml(parser);
} catch (IOException ex) {
Slog.w(TAG, "Failed to load display manager persistent store data.", ex);
clearState();
} catch (XmlPullParserException ex) {
Slog.w(TAG, "Failed to load display manager persistent store data.", ex);
clearState();
} finally {
IoUtils.closeQuietly(is);
}
}
static class Injector {
private final AtomicFile mAtomicFile;
public Injector() {
//display配置的文件路径
mAtomicFile = new AtomicFile(new File("/data/system/display-manager-state.xml"), "display-state");
}
public InputStream openRead() throws FileNotFoundException {
return mAtomicFile.openRead();
}
public OutputStream startWrite() throws IOException {
return mAtomicFile.startWrite();
}
public void finishWrite(OutputStream os, boolean success) {
if (!(os instanceof FileOutputStream)) {
throw new IllegalArgumentException("Unexpected OutputStream as argument: " + os);
}
FileOutputStream fos = (FileOutputStream) os;
if (success) {
mAtomicFile.finishWrite(fos);
} else {
mAtomicFile.failWrite(fos);
}
}
}
}
利用PersistentDataStore加载display中的固定数据,这些数据都是以xml文件的形式,保存在/data/system/display-manager-state.xml中;
2.2.2 注册屏幕适配器
public final class DisplayManagerService extends SystemService {
private static final int MSG_REGISTER_DEFAULT_DISPLAY_ADAPTERS = 1;
private static final int MSG_REGISTER_ADDITIONAL_DISPLAY_ADAPTERS = 2;
@Override
public void onStart() {
...代码省略...
// android.display线程中创建默认DisplayAdapter,并进行注册
mHandler.sendEmptyMessage(MSG_REGISTER_DEFAULT_DISPLAY_ADAPTERS);
...代码省略...
}
private final class DisplayManagerHandler extends Handler {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case MSG_REGISTER_DEFAULT_DISPLAY_ADAPTERS:
//注册默认的屏幕适配器
registerDefaultDisplayAdapters();
break;
case MSG_REGISTER_ADDITIONAL_DISPLAY_ADAPTERS:
//注册额外的屏幕设备适配器
registerAdditionalDisplayAdapters();
break;
...代码省略...
}
}
}
private void registerDefaultDisplayAdapters() {
synchronized (mSyncRoot) {
//注册默认的屏幕适配器
registerDisplayAdapterLocked(new LocalDisplayAdapter(
mSyncRoot, mContext, mHandler, mDisplayDeviceRepo));
//注册虚拟的屏幕适配器
mVirtualDisplayAdapter = mInjector.getVirtualDisplayAdapter(mSyncRoot, mContext,
mHandler, mDisplayDeviceRepo);
if (mVirtualDisplayAdapter != null) {
registerDisplayAdapterLocked(mVirtualDisplayAdapter);
}
}
}
}
2.3 执行onBootPhase方法
DisplayManagerService的onStart()方法被执行完毕后,onBootPhase()方法将会被执行。
public final class DisplayManagerService extends SystemService {
@Override
public void onBootPhase(int phase) {
if (phase == PHASE_WAIT_FOR_DEFAULT_DISPLAY) {
synchronized (mSyncRoot) {
//Injector的getDefaultDisplayDelayTimeout默认返回10秒
long timeout = SystemClock.uptimeMillis() + mInjector.getDefaultDisplayDelayTimeout();
// 超过timeout之后,如果默认屏幕的逻辑显示屏为空,则抛出异常
while (mLogicalDisplayMapper.getDisplayLocked(Display.DEFAULT_DISPLAY) == null
|| mVirtualDisplayAdapter == null) {
long delay = timeout - SystemClock.uptimeMillis();
if (delay <= 0) {
throw new RuntimeException("Timeout waiting for default display "
+ "to be initialized. DefaultDisplay="
+ mLogicalDisplayMapper.getDisplayLocked(Display.DEFAULT_DISPLAY)
+ ", mVirtualDisplayAdapter=" + mVirtualDisplayAdapter);
}
if (DEBUG) {
Slog.d(TAG, "waitForDefaultDisplay: waiting, timeout=" + delay);
}
try {
mSyncRoot.wait(delay);
} catch (InterruptedException ex) {
}
}
}
} else if (phase == PHASE_BOOT_COMPLETED) {
mDisplayModeDirector.onBootCompleted();
}
}
}
PHASE_WAIT_FOR_DEFAULT_DISPLAY阶段是最早的一个启动阶段,当一些引导服务启动完毕后,启动后续服务时,检查DMS是否已经创建默认逻辑屏,如果在10s内没有完成默认LogicalDisplay的创建,则抛出异常。
2.4 执行setupSchedulerPolicies方法
public final class DisplayManagerService extends SystemService {
public void setupSchedulerPolicies() {
// 给android.display、android.anim、android.anim.lf三个线程设置组和CPU集
Process.setThreadGroupAndCpuset(DisplayThread.get().getThreadId(),
Process.THREAD_GROUP_TOP_APP);
Process.setThreadGroupAndCpuset(AnimationThread.get().getThreadId(),
Process.THREAD_GROUP_TOP_APP);
Process.setThreadGroupAndCpuset(SurfaceAnimationThread.get().getThreadId(),
Process.THREAD_GROUP_TOP_APP);
}
}
给以上三个线程设置线程组和调度集,将线程组设为Process.THREAD_GROUP_TOP_APP,以确保更加高效的执行。
2.5 执行windowManagerAndInputReady方法
当SystemServer中启动WindowManagerService和InputManagerService后,将调用此方法通知DMS。
public final class DisplayManagerService extends SystemService {
private static final int MSG_REQUEST_TRAVERSAL = 4;
//WMS和输入法启动完毕
public void windowManagerAndInputReady() {
synchronized (mSyncRoot) {
mWindowManagerInternal = LocalServices.getService(WindowManagerInternal.class);
mInputManagerInternal = LocalServices.getService(InputManagerInternal.class);
//获取设备状态服务并设置回调对象
DeviceStateManager deviceStateManager = mContext.getSystemService(DeviceStateManager.class);
deviceStateManager.registerCallback(new HandlerExecutor(mHandler), new DeviceStateListener());
//通知WMS进行窗口更新流程
scheduleTraversalLocked(false);
}
}
private void scheduleTraversalLocked(boolean inTraversal) {
if (!mPendingTraversal && mWindowManagerInternal != null) {
mPendingTraversal = true;
if (!inTraversal) {
mHandler.sendEmptyMessage(MSG_REQUEST_TRAVERSAL);
}
}
}
private final class DisplayManagerHandler extends Handler {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
...代码省略...
case MSG_REQUEST_TRAVERSAL:
//通知WMS进行窗口更新流程
mWindowManagerInternal.requestTraversalFromDisplayManager();
break;
...代码省略...
}
}
}
}
先是获得WMS和IMS各自的LocalService对象,然后将发起显示内容更新流程,请求WMS模块进行窗口更新。DMS和WMS联系非常紧密,通常当DMS中相关属性发生变化后,会通知WMS进行窗口更新,WMS在更新过程中也会通知DMS,应用来自窗口的Display相关属性。
2.6 执行systemReady方法
此方法DMS在SystemServer中被调用的最后一个方法,通知DMS启动完成:
public final class DisplayManagerService extends SystemService {
private static final String PROP_DEFAULT_DISPLAY_TOP_INSET = "persist.sys.displayinset.top";
private static final int MSG_REGISTER_DEFAULT_DISPLAY_ADAPTERS = 1;//注册物理屏幕适配器、虚拟屏幕适配器
private static final int MSG_REGISTER_ADDITIONAL_DISPLAY_ADAPTERS = 2;//注册其他屏幕适配器
public void systemReady(boolean safeMode, boolean onlyCore) {
synchronized (mSyncRoot) {
mSafeMode = safeMode;
mOnlyCore = onlyCore;
mSystemReady = true;//启动完成
//将默认Display的top inset存储到persist.sys.displayinset.top中
recordTopInsetLocked(mLogicalDisplayMapper.getDisplayLocked(Display.DEFAULT_DISPLAY));
updateSettingsLocked();
updateUserDisabledHdrTypesFromSettingsLocked();
}
mDisplayModeDirector.setDesiredDisplayModeSpecsListener(new DesiredDisplayModeSpecsObserver());
mDisplayModeDirector.start(mSensorManager);
//注册除了物理屏幕适配器、虚拟屏幕适配器以外的其他屏幕适配器
mHandler.sendEmptyMessage(MSG_REGISTER_ADDITIONAL_DISPLAY_ADAPTERS);
mSettingsObserver = new SettingsObserver();
mBrightnessSynchronizer.startSynchronizing();
}
private void recordTopInsetLocked(@Nullable LogicalDisplay d) {
if (!mSystemReady || d == null) {
return;
}
int topInset = d.getInsets().top;
if (topInset == mDefaultDisplayTopInset) {
return;
}
mDefaultDisplayTopInset = topInset;
//将默认Display的top inset存储到persist.sys.displayinset.top中
SystemProperties.set(PROP_DEFAULT_DISPLAY_TOP_INSET, Integer.toString(topInset));
}
private final class DisplayManagerHandler extends Handler {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case MSG_REGISTER_DEFAULT_DISPLAY_ADAPTERS:
//注册默认的屏幕适配器
registerDefaultDisplayAdapters();
break;
case MSG_REGISTER_ADDITIONAL_DISPLAY_ADAPTERS:
//注册额外的屏幕设备适配器
registerAdditionalDisplayAdapters();
break;
...代码省略...
}
}
}
//注册额外的屏幕适配器对象
private void registerAdditionalDisplayAdapters() {
synchronized (mSyncRoot) {
if (shouldRegisterNonEssentialDisplayAdaptersLocked()) {
registerOverlayDisplayAdapterLocked();//注册模拟辅助设备屏幕适配器
registerWifiDisplayAdapterLocked();//注册WIFI屏幕适配器
}
}
}
private void registerOverlayDisplayAdapterLocked() {
registerDisplayAdapterLocked(new OverlayDisplayAdapter(
mSyncRoot, mContext, mHandler, mDisplayDeviceRepo, 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, mDisplayDeviceRepo,
mPersistentDataStore);
registerDisplayAdapterLocked(mWifiDisplayAdapter);
}
}
private void registerDisplayAdapterLocked(DisplayAdapter adapter) {
//将适配器对面添加到适配器集合中
mDisplayAdapters.add(adapter);
adapter.registerLocked();
}
}
此方法该会通过mHandler发起注册其他DeviceAdapter的操作,最终完成四种DisplayAdapter的注册。
文章评论