Merge "Set windowing mode in TDA instead of DisplayContent" into tm-qpr-dev (e37cf810) · Commits · e / os / android_frameworks_base

services/core/java/com/android/server/wm/DisplayContent.java

+1 −10

Original line number	Diff line number	Diff line
		@@ -1148,6 +1148,7 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp
		mMinSizeOfResizeableTaskDp = getMinimalTaskSizeDp();
		if (DEBUG_DISPLAY) Slog.v(TAG_WM, "Creating display=" + display);

		setWindowingMode(WINDOWING_MODE_FULLSCREEN);
		mWmService.mDisplayWindowSettings.applySettingsToDisplayLocked(this);
		}

		@@ -2651,16 +2652,6 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp
		}
		}

		@Override
		public void setWindowingMode(int windowingMode) {
		// Intentionally call onRequestedOverrideConfigurationChanged() directly to change windowing
		// mode and display windowing mode atomically.
		mTmpConfiguration.setTo(getRequestedOverrideConfiguration());
		mTmpConfiguration.windowConfiguration.setWindowingMode(windowingMode);
		mTmpConfiguration.windowConfiguration.setDisplayWindowingMode(windowingMode);
		onRequestedOverrideConfigurationChanged(mTmpConfiguration);
		}

		@Override
		void setDisplayWindowingMode(int windowingMode) {
		setWindowingMode(windowingMode);

services/core/java/com/android/server/wm/DisplayWindowSettings.java

+11 −5

Original line number	Diff line number	Diff line
		@@ -150,7 +150,10 @@ class DisplayWindowSettings {
		final SettingsProvider.SettingsEntry overrideSettings =
		mSettingsProvider.getOverrideSettings(displayInfo);
		overrideSettings.mWindowingMode = mode;
		dc.setWindowingMode(mode);
		final TaskDisplayArea defaultTda = dc.getDefaultTaskDisplayArea();
		if (defaultTda != null) {
		defaultTda.setWindowingMode(mode);
		}
		mSettingsProvider.updateOverrideSettings(displayInfo, overrideSettings);
		}

		@@ -253,8 +256,10 @@ class DisplayWindowSettings {

		// Setting windowing mode first, because it may override overscan values later.
		final int windowingMode = getWindowingModeLocked(settings, dc);
		dc.setWindowingMode(windowingMode);

		final TaskDisplayArea defaultTda = dc.getDefaultTaskDisplayArea();
		if (defaultTda != null) {
		defaultTda.setWindowingMode(windowingMode);
		}
		final int userRotationMode = settings.mUserRotationMode != null
		? settings.mUserRotationMode : WindowManagerPolicy.USER_ROTATION_FREE;
		final int userRotation = settings.mUserRotation != null
		@@ -311,10 +316,11 @@ class DisplayWindowSettings {
		* changed.
		*/
		boolean updateSettingsForDisplay(DisplayContent dc) {
		if (dc.getWindowingMode() != getWindowingModeLocked(dc)) {
		final TaskDisplayArea defaultTda = dc.getDefaultTaskDisplayArea();
		if (defaultTda != null && defaultTda.getWindowingMode() != getWindowingModeLocked(dc)) {
		// For the time being the only thing that may change is windowing mode, so just update
		// that.
		dc.setWindowingMode(getWindowingModeLocked(dc));
		defaultTda.setWindowingMode(getWindowingModeLocked(dc));
		return true;
		}
		return false;

services/core/java/com/android/server/wm/TaskDisplayArea.java

+11 −0

Original line number	Diff line number	Diff line
		@@ -172,6 +172,8 @@ final class TaskDisplayArea extends DisplayArea<WindowContainer> {
		*/
		private final boolean mCanHostHomeTask;

		private final Configuration mTempConfiguration = new Configuration();

		TaskDisplayArea(DisplayContent displayContent, WindowManagerService service, String name,
		int displayAreaFeature) {
		this(displayContent, service, name, displayAreaFeature, false /* createdByOrganizer */,
		@@ -1890,6 +1892,15 @@ final class TaskDisplayArea extends DisplayArea<WindowContainer> {
		mPreferredTopFocusableRootTask = null;
		}

		@Override
		public void setWindowingMode(int windowingMode) {
		mTempConfiguration.setTo(getRequestedOverrideConfiguration());
		WindowConfiguration tempRequestWindowConfiguration = mTempConfiguration.windowConfiguration;
		tempRequestWindowConfiguration.setWindowingMode(windowingMode);
		tempRequestWindowConfiguration.setDisplayWindowingMode(windowingMode);
		onRequestedOverrideConfigurationChanged(mTempConfiguration);
		}

		@Override
		TaskDisplayArea getTaskDisplayArea() {
		return this;

services/core/java/com/android/server/wm/TaskLaunchParamsModifier.java

+25 −18

Original line number	Diff line number	Diff line
		@@ -137,7 +137,7 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier {
		final DisplayContent display = suggestedDisplayArea.mDisplayContent;
		if (DEBUG) {
		appendLog("display-id=" + display.getDisplayId()
		+ " display-windowing-mode=" + display.getWindowingMode()
		+ " task-display-area-windowing-mode=" + suggestedDisplayArea.getWindowingMode()
		+ " suggested-display-area=" + suggestedDisplayArea);
		}

		@@ -156,7 +156,7 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier {
		// source is a freeform window in a fullscreen display launching an activity on the same
		// display.
		if (launchMode == WINDOWING_MODE_UNDEFINED
		&& canInheritWindowingModeFromSource(display, source)) {
		&& canInheritWindowingModeFromSource(display, suggestedDisplayArea, source)) {
		// The source's windowing mode may be different from its task, e.g. activity is set
		// to fullscreen and its task is pinned windowing mode when the activity is entering
		// pip.
		@@ -184,7 +184,8 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier {
		// is set with the suggestedDisplayArea. If it is set, but the eventual TaskDisplayArea is
		// different, we should recalculating the bounds.
		boolean hasInitialBoundsForSuggestedDisplayAreaInFreeformWindow = false;
		final boolean canApplyFreeformPolicy = canApplyFreeformWindowPolicy(display, launchMode);
		final boolean canApplyFreeformPolicy =
		canApplyFreeformWindowPolicy(suggestedDisplayArea, launchMode);
		if (mSupervisor.canUseActivityOptionsLaunchBounds(options)
		&& (canApplyFreeformPolicy \|\| canApplyPipWindowPolicy(launchMode))) {
		hasInitialBounds = true;
		@@ -239,7 +240,8 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier {
		== display.getDisplayId())) {
		// Only set windowing mode if display is in freeform. If the display is in fullscreen
		// mode we should only launch a task in fullscreen mode.
		if (currentParams.hasWindowingMode() && display.inFreeformWindowingMode()) {
		if (currentParams.hasWindowingMode()
		&& suggestedDisplayArea.inFreeformWindowingMode()) {
		launchMode = currentParams.mWindowingMode;
		fullyResolvedCurrentParam = launchMode != WINDOWING_MODE_FREEFORM;
		if (DEBUG) {
		@@ -267,11 +269,11 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier {
		// this step is to define the default policy when there is no initial bounds or a fully
		// resolved current params from callers.

		// hasInitialBoundsForSuggestedDisplayAreaInFreeformDisplay is set if the outParams.mBounds
		// hasInitialBoundsForSuggestedDisplayAreaInFreeformMode is set if the outParams.mBounds
		// is set with the suggestedDisplayArea. If it is set, but the eventual TaskDisplayArea is
		// different, we should recalcuating the bounds.
		boolean hasInitialBoundsForSuggestedDisplayAreaInFreeformDisplay = false;
		if (display.inFreeformWindowingMode()) {
		boolean hasInitialBoundsForSuggestedDisplayAreaInFreeformMode = false;
		if (suggestedDisplayArea.inFreeformWindowingMode()) {
		if (launchMode == WINDOWING_MODE_PINNED) {
		if (DEBUG) appendLog("picture-in-picture");
		} else if (!root.isResizeable()) {
		@@ -280,7 +282,7 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier {
		if (outParams.mBounds.isEmpty()) {
		getTaskBounds(root, suggestedDisplayArea, layout, launchMode,
		hasInitialBounds, outParams.mBounds);
		hasInitialBoundsForSuggestedDisplayAreaInFreeformDisplay = true;
		hasInitialBoundsForSuggestedDisplayAreaInFreeformMode = true;
		}
		if (DEBUG) appendLog("unresizable-freeform");
		} else {
		@@ -290,10 +292,10 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier {
		}
		}
		} else {
		if (DEBUG) appendLog("non-freeform-display");
		if (DEBUG) appendLog("non-freeform-task-display-area");
		}
		// If launch mode matches display windowing mode, let it inherit from display.
		outParams.mWindowingMode = launchMode == display.getWindowingMode()
		outParams.mWindowingMode = launchMode == suggestedDisplayArea.getWindowingMode()
		? WINDOWING_MODE_UNDEFINED : launchMode;

		if (phase == PHASE_WINDOWING_MODE) {
		@@ -303,7 +305,7 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier {
		// STEP 3: Finalize the display area. Here we allow WM shell route all launches that match
		// certain criteria to specific task display areas.
		final int resolvedMode = (launchMode != WINDOWING_MODE_UNDEFINED) ? launchMode
		: display.getWindowingMode();
		: suggestedDisplayArea.getWindowingMode();
		TaskDisplayArea taskDisplayArea = suggestedDisplayArea;
		// If launch task display area is set in options we should just use it. We assume the
		// suggestedDisplayArea has the right one in this case.
		@@ -320,14 +322,17 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier {
		mTmpDisplayArea = displayArea;
		return true;
		});
		// We may need to recalculate the bounds if the new TaskDisplayArea is different from
		// the suggested one we used to calculate the bounds.
		// We may need to recalculate the bounds and the windowing mode if the new
		// TaskDisplayArea is different from the suggested one we used to calculate the two
		// configurations.
		if (mTmpDisplayArea != null && mTmpDisplayArea != suggestedDisplayArea) {
		outParams.mWindowingMode = (launchMode == mTmpDisplayArea.getWindowingMode())
		? WINDOWING_MODE_UNDEFINED : launchMode;
		if (hasInitialBoundsForSuggestedDisplayAreaInFreeformWindow) {
		outParams.mBounds.setEmpty();
		getLayoutBounds(mTmpDisplayArea, root, layout, outParams.mBounds);
		hasInitialBounds = !outParams.mBounds.isEmpty();
		} else if (hasInitialBoundsForSuggestedDisplayAreaInFreeformDisplay) {
		} else if (hasInitialBoundsForSuggestedDisplayAreaInFreeformMode) {
		outParams.mBounds.setEmpty();
		getTaskBounds(root, mTmpDisplayArea, layout, launchMode,
		hasInitialBounds, outParams.mBounds);
		@@ -519,7 +524,7 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier {
		}

		private boolean canInheritWindowingModeFromSource(@NonNull DisplayContent display,
		@Nullable ActivityRecord source) {
		TaskDisplayArea suggestedDisplayArea, @Nullable ActivityRecord source) {
		if (source == null) {
		return false;
		}
		@@ -527,7 +532,7 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier {
		// There is not really any strong reason to tie the launching windowing mode and the source
		// on freeform displays. The launching windowing mode is more tied to the content of the new
		// activities.
		if (display.inFreeformWindowingMode()) {
		if (suggestedDisplayArea.inFreeformWindowingMode()) {
		return false;
		}

		@@ -543,9 +548,11 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier {
		return display.getDisplayId() == source.getDisplayId();
		}

		private boolean canApplyFreeformWindowPolicy(@NonNull DisplayContent display, int launchMode) {
		private boolean canApplyFreeformWindowPolicy(@NonNull TaskDisplayArea suggestedDisplayArea,
		int launchMode) {
		return mSupervisor.mService.mSupportsFreeformWindowManagement
		&& (display.inFreeformWindowingMode() \|\| launchMode == WINDOWING_MODE_FREEFORM);
		&& (suggestedDisplayArea.inFreeformWindowingMode()
		\|\| launchMode == WINDOWING_MODE_FREEFORM);
		}

		private boolean canApplyPipWindowPolicy(int launchMode) {

services/core/java/com/android/server/wm/WindowToken.java

+0 −7

Original line number	Diff line number	Diff line
		@@ -16,7 +16,6 @@

		package com.android.server.wm;

		import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN;
		import static android.app.WindowConfiguration.WINDOWING_MODE_PINNED;
		import static android.view.WindowManager.LayoutParams.TYPE_NAVIGATION_BAR;

		@@ -631,12 +630,6 @@ class WindowToken extends WindowContainer<WindowState> {
		getResolvedOverrideConfiguration().updateFrom(
		mFixedRotationTransformState.mRotatedOverrideConfiguration);
		}
		if (getTaskDisplayArea() == null) {
		// We only defined behaviors of system windows in fullscreen mode, i.e. windows not
		// contained in a task display area.
		getResolvedOverrideConfiguration().windowConfiguration.setWindowingMode(
		WINDOWING_MODE_FULLSCREEN);
		}
		}

		@Override