Move orientation request into hierarchy. (90b04281) · Commits · e / os / android_frameworks_base

core/java/android/view/IWindowManager.aidl

+0 −6

Original line number	Diff line number	Diff line
		@@ -107,12 +107,6 @@ interface IWindowManager
		*/
		void endProlongedAnimations();

		// Re-evaluate the current orientation from the caller's state.
		// If there is a change, the new Configuration is returned and the
		// caller must call setNewConfiguration() sometime later.
		Configuration updateOrientationFromAppTokens(in Configuration currentConfig,
		IBinder freezeThisOneIfNeeded, int displayId);

		void startFreezingScreen(int exitAnim, int enterAnim);
		void stopFreezingScreen();

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

+4 −20

Original line number	Diff line number	Diff line
		@@ -2486,36 +2486,20 @@ final class ActivityRecord extends ConfigurationContainer {
		}

		void setRequestedOrientation(int requestedOrientation) {
		final int displayId = getDisplayId();
		final Configuration displayConfig =
		mRootActivityContainer.getDisplayOverrideConfiguration(displayId);

		final Configuration config = setOrientation(requestedOrientation,
		displayId, displayConfig, mayFreezeScreenLocked(app));
		if (config != null) {
		frozenBeforeDestroy = true;
		if (!mAtmService.updateDisplayOverrideConfigurationLocked(config, this,
		false /* deferResume */, displayId)) {
		mRootActivityContainer.resumeFocusedStacksTopActivities();
		}
		}
		setOrientation(requestedOrientation, mayFreezeScreenLocked(app));
		mAtmService.getTaskChangeNotificationController().notifyActivityRequestedOrientationChanged(
		task.taskId, requestedOrientation);
		}

		Configuration setOrientation(int requestedOrientation, int displayId,
		Configuration displayConfig, boolean freezeScreenIfNeeded) {
		private void setOrientation(int requestedOrientation, boolean freezeScreenIfNeeded) {
		if (mAppWindowToken == null) {
		Slog.w(TAG_WM,
		"Attempted to set orientation of non-existing app token: " + appToken);
		return null;
		return;
		}

		mAppWindowToken.setOrientation(requestedOrientation);

		final IBinder binder = freezeScreenIfNeeded ? appToken.asBinder() : null;
		return mAtmService.mWindowManager.updateOrientationFromAppTokens(displayConfig, binder,
		displayId);
		mAppWindowToken.setOrientation(requestedOrientation, binder, this);
		}

		int getOrientation() {

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

+82 −2

Original line number	Diff line number	Diff line
		@@ -397,10 +397,11 @@ class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowCo
		private final Matrix mTmpMatrix = new Matrix();
		private final Region mTmpRegion = new Region();


		/** Used for handing back size of display */
		private final Rect mTmpBounds = new Rect();

		private final Configuration mTmpConfiguration = new Configuration();

		/** Remove this display when animation on it has completed. */
		private boolean mDeferredRemoval;

		@@ -1156,6 +1157,36 @@ class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowCo
		mWmService.mH.obtainMessage(SEND_NEW_CONFIGURATION, this).sendToTarget();
		}

		@Override
		boolean onDescendantOrientationChanged(IBinder freezeDisplayToken,
		ConfigurationContainer requestingContainer) {
		final Configuration config = updateOrientationFromAppTokens(
		getRequestedOverrideConfiguration(), freezeDisplayToken, false);
		// If display rotation class tells us that it doesn't consider app requested orientation,
		// this display won't rotate just because of an app changes its requested orientation. Thus
		// it indicates that this display chooses not to handle this request.
		final boolean handled = getDisplayRotation().respectAppRequestedOrientation();
		if (config == null) {
		return handled;
		}

		if (handled && requestingContainer instanceof ActivityRecord) {
		final ActivityRecord activityRecord = (ActivityRecord) requestingContainer;
		final boolean kept = mWmService.mAtmService.updateDisplayOverrideConfigurationLocked(
		config, activityRecord, false /* deferResume */, getDisplayId());
		activityRecord.frozenBeforeDestroy = true;
		if (!kept) {
		mWmService.mAtmService.mRootActivityContainer.resumeFocusedStacksTopActivities();
		}
		} else {
		// We have a new configuration to push so we need to update ATMS for now.
		// TODO: Clean up display configuration push between ATMS and WMS after unification.
		mWmService.mAtmService.updateDisplayOverrideConfigurationLocked(
		config, null /* starting /, false / deferResume */, getDisplayId());
		}
		return handled;
		}

		/**
		* Determine the new desired orientation of this display.
		*
		@@ -1169,7 +1200,56 @@ class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowCo
		return updateOrientationFromAppTokens(false /* forceUpdate */);
		}

		boolean updateOrientationFromAppTokens(boolean forceUpdate) {
		/**
		* Update orientation of the target display, returning a non-null new Configuration if it has
		* changed from the current orientation. If a non-null configuration is returned, someone must
		* call {@link WindowManagerService#setNewDisplayOverrideConfiguration(Configuration,
		* DisplayContent)} to tell the window manager it can unfreeze the screen. This will typically
		* be done by calling {@link WindowManagerService#sendNewConfiguration(int)}.
		*/
		Configuration updateOrientationFromAppTokens(Configuration currentConfig,
		IBinder freezeDisplayToken, boolean forceUpdate) {
		if (!mDisplayReady) {
		return null;
		}

		Configuration config = null;
		if (updateOrientationFromAppTokens(forceUpdate)) {
		// If we changed the orientation but mOrientationChangeComplete is already true,
		// we used seamless rotation, and we don't need to freeze the screen.
		if (freezeDisplayToken != null && !mWmService.mRoot.mOrientationChangeComplete) {
		final AppWindowToken atoken = getAppWindowToken(freezeDisplayToken);
		if (atoken != null) {
		atoken.startFreezingScreen();
		}
		}
		config = new Configuration();
		computeScreenConfiguration(config);
		} else if (currentConfig != null) {
		// No obvious action we need to take, but if our current state mismatches the
		// activity manager's, update it, disregarding font scale, which should remain set
		// to the value of the previous configuration.
		// Here we're calling Configuration#unset() instead of setToDefaults() because we
		// need to keep override configs clear of non-empty values (e.g. fontSize).
		mTmpConfiguration.unset();
		mTmpConfiguration.updateFrom(currentConfig);
		computeScreenConfiguration(mTmpConfiguration);
		if (currentConfig.diff(mTmpConfiguration) != 0) {
		mWaitingForConfig = true;
		setLayoutNeeded();
		int[] anim = new int[2];
		getDisplayPolicy().selectRotationAnimationLw(anim);

		mWmService.startFreezingDisplayLocked(anim[0], anim[1], this);
		config = new Configuration(mTmpConfiguration);
		}
		}

		return config;
		}


		private boolean updateOrientationFromAppTokens(boolean forceUpdate) {
		final int req = getOrientation();
		if (req != mLastOrientation \|\| forceUpdate) {
		mLastOrientation = req;

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

+9 −0

Original line number	Diff line number	Diff line
		@@ -329,6 +329,15 @@ public class DisplayRotation {
		return mFixedToUserRotation;
		}

		/**
		* Returns {@code true} if this display rotation takes app requested orientation into
		* consideration; {@code false} otherwise. For the time being the only case where this is {@code
		* false} is when {@link #isFixedToUserRotation()} is {@code true}.
		*/
		boolean respectAppRequestedOrientation() {
		return !mFixedToUserRotation;
		}

		public int getLandscapeRotation() {
		return mLandscapeRotation;
		}

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

+9 −5

Original line number	Diff line number	Diff line
		@@ -597,11 +597,15 @@ class RootActivityContainer extends ConfigurationContainer

		// Force-update the orientation from the WindowManager, since we need the true configuration
		// to send to the client now.
		final Configuration config = mWindowManager.updateOrientationFromAppTokens(
		final DisplayContent displayContent = mRootWindowContainer.getDisplayContent(displayId);
		Configuration config = null;
		if (displayContent != null) {
		config = displayContent.updateOrientationFromAppTokens(
		getDisplayOverrideConfiguration(displayId),
		starting != null && starting.mayFreezeScreenLocked(starting.app)
		? starting.appToken : null,
		displayId, true /* forceUpdate */);
		true /* forceUpdate */);
		}
		if (starting != null && markFrozenIfConfigChanged && config != null) {
		starting.frozenBeforeDestroy = true;
		}