From a68a6b19e93dce5d375569840eb91596eeb4b1cd Mon Sep 17 00:00:00 2001 From: Riddle Hsu Date: Thu, 18 Feb 2021 23:15:34 +0800 Subject: Reduce unnecessary config propagation of default display Global config is also the override config of default display. When updating the override config, the hierarchy is already notified. So it doesn't need to update twice. Previously, the first update from mRootWindowContainer.onConfigurationChanged only recomputes the old config again because the override doesn't change. This may reduce up to 3ms (depends on the amount of window container in default display). Also remove unused parameter deferResume. Bug: 159103089 Bug: 178472794 Test: CtsWindowManagerDeviceTestCases Change-Id: I1437a26e435666c13faaf27e0b0ef81adf739fe0 --- .../server/wm/ActivityTaskManagerService.java | 25 +++++++--------------- .../android/server/wm/ConfigurationContainer.java | 4 ++++ .../java/com/android/server/wm/DisplayContent.java | 6 +++--- .../com/android/server/wm/RootWindowContainer.java | 14 ++++++++++++ 4 files changed, 29 insertions(+), 20 deletions(-) diff --git a/services/core/java/com/android/server/wm/ActivityTaskManagerService.java b/services/core/java/com/android/server/wm/ActivityTaskManagerService.java index 2e98c2cbc5c2..6773e06ab27a 100644 --- a/services/core/java/com/android/server/wm/ActivityTaskManagerService.java +++ b/services/core/java/com/android/server/wm/ActivityTaskManagerService.java @@ -4005,8 +4005,7 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub { deferWindowLayout(); try { if (values != null) { - changes = updateGlobalConfigurationLocked(values, initLocale, persistent, userId, - deferResume); + changes = updateGlobalConfigurationLocked(values, initLocale, persistent, userId); } if (!deferResume) { @@ -4025,7 +4024,7 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub { /** Update default (global) configuration and notify listeners about changes. */ int updateGlobalConfigurationLocked(@NonNull Configuration values, boolean initLocale, - boolean persistent, int userId, boolean deferResume) { + boolean persistent, int userId) { final DisplayContent defaultDisplay = mRootWindowContainer.getDisplayContent(DEFAULT_DISPLAY); @@ -4037,7 +4036,7 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub { // setting WindowManagerService.mWaitingForConfig to true, it is important that we call // performDisplayOverrideConfigUpdate in order to send the new display configuration // (even if there are no actual changes) to unfreeze the window. - defaultDisplay.performDisplayOverrideConfigUpdate(values, deferResume); + defaultDisplay.performDisplayOverrideConfigUpdate(values); return 0; } @@ -4085,9 +4084,6 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub { mTempConfig.seq = increaseConfigurationSeqLocked(); - // Update stored global config and notify everyone about the change. - mRootWindowContainer.onConfigurationChanged(mTempConfig); - Slog.i(TAG, "Config changes=" + Integer.toHexString(changes) + " " + mTempConfig); // TODO(multi-display): Update UsageEvents#Event to include displayId. mUsageStatsInternal.reportConfigurationChange(mTempConfig, mAmInternal.getCurrentUserId()); @@ -4106,13 +4102,10 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub { // resources have that config before following boot code is executed. mSystemThread.applyConfigurationToResources(mTempConfig); - // We need another copy of global config because we're scheduling some calls instead of - // running them in place. We need to be sure that object we send will be handled unchanged. - final Configuration configCopy = new Configuration(mTempConfig); if (persistent && Settings.System.hasInterestingConfigurationChanges(changes)) { final Message msg = PooledLambda.obtainMessage( ActivityTaskManagerService::sendPutConfigurationForUserMsg, - this, userId, configCopy); + this, userId, new Configuration(mTempConfig)); mH.sendMessage(msg); } @@ -4121,8 +4114,8 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub { final int pid = pidMap.keyAt(i); final WindowProcessController app = pidMap.get(pid); ProtoLog.v(WM_DEBUG_CONFIGURATION, "Update process config of %s to new " - + "config %s", app.mName, configCopy); - app.onConfigurationChanged(configCopy); + + "config %s", app.mName, mTempConfig); + app.onConfigurationChanged(mTempConfig); } final Message msg = PooledLambda.obtainMessage( @@ -4130,10 +4123,8 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub { mAmInternal, changes, initLocale); mH.sendMessage(msg); - // Override configuration of the default display duplicates global config, so we need to - // update it also. This will also notify WindowManager about changes. - defaultDisplay.performDisplayOverrideConfigUpdate(mRootWindowContainer.getConfiguration(), - deferResume); + // Update stored global config and notify everyone about the change. + mRootWindowContainer.onConfigurationChanged(mTempConfig); return changes; } diff --git a/services/core/java/com/android/server/wm/ConfigurationContainer.java b/services/core/java/com/android/server/wm/ConfigurationContainer.java index efcaaa42ec13..309b5ec25f0f 100644 --- a/services/core/java/com/android/server/wm/ConfigurationContainer.java +++ b/services/core/java/com/android/server/wm/ConfigurationContainer.java @@ -141,6 +141,10 @@ public abstract class ConfigurationContainer { mChangeListeners.get(i).onMergedOverrideConfigurationChanged( mMergedOverrideConfiguration); } + dispatchConfigurationToChildren(); + } + + void dispatchConfigurationToChildren() { for (int i = getChildCount() - 1; i >= 0; --i) { final ConfigurationContainer child = getChildAt(i); child.onConfigurationChanged(mFullConfiguration); diff --git a/services/core/java/com/android/server/wm/DisplayContent.java b/services/core/java/com/android/server/wm/DisplayContent.java index 86968ed6d175..7c687aab6aeb 100644 --- a/services/core/java/com/android/server/wm/DisplayContent.java +++ b/services/core/java/com/android/server/wm/DisplayContent.java @@ -5467,9 +5467,9 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp // apply the correct override config. changes = mAtmService.updateGlobalConfigurationLocked(values, false /* initLocale */, false /* persistent */, - UserHandle.USER_NULL /* userId */, deferResume); + UserHandle.USER_NULL /* userId */); } else { - changes = performDisplayOverrideConfigUpdate(values, deferResume); + changes = performDisplayOverrideConfigUpdate(values); } } @@ -5487,7 +5487,7 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp return kept; } - int performDisplayOverrideConfigUpdate(Configuration values, boolean deferResume) { + int performDisplayOverrideConfigUpdate(Configuration values) { mTempConfig.setTo(getRequestedOverrideConfiguration()); final int changes = mTempConfig.updateFrom(values); if (changes != 0) { diff --git a/services/core/java/com/android/server/wm/RootWindowContainer.java b/services/core/java/com/android/server/wm/RootWindowContainer.java index 6fbeaa4e944e..8e1a4b302376 100644 --- a/services/core/java/com/android/server/wm/RootWindowContainer.java +++ b/services/core/java/com/android/server/wm/RootWindowContainer.java @@ -649,6 +649,20 @@ class RootWindowContainer extends WindowContainer onConfigurationChanged(newConfiguration); } + @Override + void dispatchConfigurationToChildren() { + final Configuration configuration = getConfiguration(); + for (int i = getChildCount() - 1; i >= 0; i--) { + final DisplayContent displayContent = getChildAt(i); + if (displayContent.isDefaultDisplay) { + // The global configuration is also the override configuration of default display. + displayContent.performDisplayOverrideConfigUpdate(configuration); + } else { + displayContent.onConfigurationChanged(configuration); + } + } + } + @Override public void onConfigurationChanged(Configuration newParentConfig) { prepareFreezingTaskBounds(); -- cgit v1.2.3-59-g8ed1b