Merge "Rename `wm.DeviceStateController.DeviceState` enum" into main (fd1745d6) · Commits · e / os / android_frameworks_base

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

+1 −1

Original line number	Diff line number	Diff line
		@@ -46,7 +46,7 @@ class AppCompatDeviceStateQuery {
		final DisplayContent dc = mActivityRecord.mDisplayContent;
		return dc != null && task != null && !dc.inTransition()
		&& dc.getDisplayRotation().isDeviceInPosture(
		DeviceStateController.DeviceState.HALF_FOLDED, isTabletop)
		DeviceStateController.DeviceStateEnum.HALF_FOLDED, isTabletop)
		&& task.getWindowingMode() == WINDOWING_MODE_FULLSCREEN;
		}

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

+1 −1

Original line number	Diff line number	Diff line
		@@ -54,7 +54,7 @@ public class DeviceStateAutoRotateSettingController {
		}

		/** Notify controller device state has changed */
		public void onDeviceStateChange(DeviceStateController.DeviceState deviceState) {
		public void onDeviceStateChange(DeviceStateController.DeviceStateEnum deviceStateEnum) {
		if (Flags.enableDeviceStateAutoRotateSettingLogging()) {
		mDeviceStateAutoRotateSettingIssueLogger.onDeviceStateChange();
		}

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

+20 −19

Original line number	Diff line number	Diff line
		@@ -67,15 +67,15 @@ final class DeviceStateController {
		@GuardedBy("mWmLock")
		@NonNull
		@VisibleForTesting
		final Map<Consumer<DeviceState>, Executor> mDeviceStateCallbacks = new ArrayMap<>();
		final Map<Consumer<DeviceStateEnum>, Executor> mDeviceStateCallbacks = new ArrayMap<>();

		private final boolean mMatchBuiltInDisplayOrientationToDefaultDisplay;

		@NonNull
		private DeviceState mCurrentDeviceState = DeviceState.UNKNOWN;
		private DeviceStateEnum mCurrentDeviceStateEnum = DeviceStateEnum.UNKNOWN;
		private int mCurrentState;

		public enum DeviceState {
		public enum DeviceStateEnum {
		UNKNOWN,
		OPEN,
		FOLDED,
		@@ -146,14 +146,14 @@ final class DeviceStateController {
		* post the work onto their own worker thread to avoid holding the WindowManagerGlobalLock for
		* an extended period of time.
		*/
		void registerDeviceStateCallback(@NonNull Consumer<DeviceState> callback,
		void registerDeviceStateCallback(@NonNull Consumer<DeviceStateEnum> callback,
		@NonNull @CallbackExecutor Executor executor) {
		synchronized (mWmLock) {
		mDeviceStateCallbacks.put(callback, executor);
		}
		}

		void unregisterDeviceStateCallback(@NonNull Consumer<DeviceState> callback) {
		void unregisterDeviceStateCallback(@NonNull Consumer<DeviceStateEnum> callback) {
		synchronized (mWmLock) {
		mDeviceStateCallbacks.remove(callback);
		}
		@@ -193,43 +193,44 @@ final class DeviceStateController {
		*/
		public void onDeviceStateReceivedByDisplayManager(int state) {
		mCurrentState = state;
		final DeviceState deviceState;
		final DeviceStateEnum deviceStateEnum;
		if (ArrayUtils.contains(mHalfFoldedDeviceStates, state)) {
		deviceState = DeviceState.HALF_FOLDED;
		deviceStateEnum = DeviceStateEnum.HALF_FOLDED;
		} else if (ArrayUtils.contains(mFoldedDeviceStates, state)) {
		deviceState = DeviceState.FOLDED;
		deviceStateEnum = DeviceStateEnum.FOLDED;
		} else if (ArrayUtils.contains(mRearDisplayDeviceStates, state)) {
		deviceState = DeviceState.REAR;
		deviceStateEnum = DeviceStateEnum.REAR;
		} else if (ArrayUtils.contains(mOpenDeviceStates, state)) {
		deviceState = DeviceState.OPEN;
		deviceStateEnum = DeviceStateEnum.OPEN;
		} else if (ArrayUtils.contains(mConcurrentDisplayDeviceStates, state)) {
		deviceState = DeviceState.CONCURRENT;
		deviceStateEnum = DeviceStateEnum.CONCURRENT;
		} else {

		deviceState = DeviceState.UNKNOWN;
		deviceStateEnum = DeviceStateEnum.UNKNOWN;
		}

		if (mCurrentDeviceState == null \|\| !mCurrentDeviceState.equals(deviceState)) {
		mCurrentDeviceState = deviceState;
		if (mCurrentDeviceStateEnum == null \|\| !mCurrentDeviceStateEnum.equals(deviceStateEnum)) {
		mCurrentDeviceStateEnum = deviceStateEnum;

		// Make a copy here because it's possible that the consumer tries to remove a callback
		// while we're still iterating through the list, which would end up in a
		// ConcurrentModificationException. Note that cannot use a List<Map.Entry> because the
		// entries are tied to the backing map. So, if a client removes a callback while
		// we are notifying clients, we will get a NPE.
		final List<Pair<Consumer<DeviceState>, Executor>> entries = copyDeviceStateCallbacks();
		final List<Pair<Consumer<DeviceStateEnum>, Executor>> entries =
		copyDeviceStateCallbacks();

		for (int i = 0; i < entries.size(); i++) {
		final Pair<Consumer<DeviceState>, Executor> entry = entries.get(i);
		entry.second.execute(() -> entry.first.accept(deviceState));
		final Pair<Consumer<DeviceStateEnum>, Executor> entry = entries.get(i);
		entry.second.execute(() -> entry.first.accept(deviceStateEnum));
		}
		}
		}

		@VisibleForTesting
		@NonNull
		List<Pair<Consumer<DeviceState>, Executor>> copyDeviceStateCallbacks() {
		final List<Pair<Consumer<DeviceState>, Executor>> entries = new ArrayList<>();
		List<Pair<Consumer<DeviceStateEnum>, Executor>> copyDeviceStateCallbacks() {
		final List<Pair<Consumer<DeviceStateEnum>, Executor>> entries = new ArrayList<>();

		synchronized (mWmLock) {
		mDeviceStateCallbacks.forEach((deviceStateConsumer, executor) -> {

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

+2 −2

Original line number	Diff line number	Diff line
		@@ -615,7 +615,7 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp

		@VisibleForTesting
		final DeviceStateController mDeviceStateController;
		final Consumer<DeviceStateController.DeviceState> mDeviceStateConsumer;
		final Consumer<DeviceStateController.DeviceStateEnum> mDeviceStateConsumer;
		final RemoteDisplayChangeController mRemoteDisplayChangeController;

		/** Windows added since {@link #mCurrentFocus} was set to null. Used for ANR blaming. */
		@@ -1205,7 +1205,7 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp
		mDeviceStateController, root.getDisplayRotationCoordinator());

		mDeviceStateConsumer =
		(@NonNull DeviceStateController.DeviceState newFoldState) -> {
		(@NonNull DeviceStateController.DeviceStateEnum newFoldState) -> {
		mDisplayRotation.foldStateChanged(newFoldState);
		};
		mDeviceStateController.registerDeviceStateCallback(mDeviceStateConsumer,

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

+32 −31

Original line number	Diff line number	Diff line
		@@ -1540,7 +1540,7 @@ public class DisplayRotation {
		pw.println(prefix + " mLastHingeAngleEventTime="
		+ mFoldController.mLastHingeAngleEventTime);
		pw.println(prefix + " mDeviceState="
		+ mFoldController.mDeviceState);
		+ mFoldController.mDeviceStateEnum);
		}

		if (!mRotationHistory.mRecords.isEmpty()) {
		@@ -1573,7 +1573,7 @@ public class DisplayRotation {
		proto.end(token);
		}

		boolean isDeviceInPosture(DeviceStateController.DeviceState state, boolean isTabletop) {
		boolean isDeviceInPosture(DeviceStateController.DeviceStateEnum state, boolean isTabletop) {
		if (mFoldController == null) return false;
		return mFoldController.isDeviceInPosture(state, isTabletop);
		}
		@@ -1587,12 +1587,12 @@ public class DisplayRotation {
		* that in case of physical display change the {@link DisplayRotation#physicalDisplayChanged}
		* method will be invoked after this one.
		*/
		void foldStateChanged(DeviceStateController.DeviceState deviceState) {
		void foldStateChanged(DeviceStateController.DeviceStateEnum deviceStateEnum) {
		if (mFoldController != null) {
		synchronized (mLock) {
		mFoldController.foldStateChanged(deviceState);
		mFoldController.foldStateChanged(deviceStateEnum);
		if (mDeviceStateAutoRotateSettingController != null) {
		mDeviceStateAutoRotateSettingController.onDeviceStateChange(deviceState);
		mDeviceStateAutoRotateSettingController.onDeviceStateChange(deviceStateEnum);
		}
		}
		}
		@@ -1649,8 +1649,8 @@ public class DisplayRotation {
		private final boolean mPauseAutorotationDuringUnfolding;
		@Surface.Rotation
		private int mHalfFoldSavedRotation = -1; // No saved rotation
		private DeviceStateController.DeviceState mDeviceState =
		DeviceStateController.DeviceState.UNKNOWN;
		private DeviceStateController.DeviceStateEnum mDeviceStateEnum =
		DeviceStateController.DeviceStateEnum.UNKNOWN;
		private long mLastHingeAngleEventTime = 0;
		private long mLastDisplaySwitchTime = 0;
		private boolean mShouldIgnoreSensorRotation;
		@@ -1704,8 +1704,9 @@ public class DisplayRotation {

		mActivityBoundsUpdateCallback = new Runnable() {
		public void run() {
		if (mDeviceState == DeviceStateController.DeviceState.OPEN
		\|\| mDeviceState == DeviceStateController.DeviceState.HALF_FOLDED) {
		if (mDeviceStateEnum == DeviceStateController.DeviceStateEnum.OPEN
		\|\| mDeviceStateEnum
		== DeviceStateController.DeviceStateEnum.HALF_FOLDED) {
		synchronized (mLock) {
		final Task topFullscreenTask =
		mDisplayContent.getTask(
		@@ -1765,35 +1766,35 @@ public class DisplayRotation {
		}
		}

		boolean isDeviceInPosture(DeviceStateController.DeviceState state, boolean isTabletop) {
		if (state != mDeviceState) {
		boolean isDeviceInPosture(DeviceStateController.DeviceStateEnum state, boolean isTabletop) {
		if (state != mDeviceStateEnum) {
		return false;
		}
		if (mDeviceState == DeviceStateController.DeviceState.HALF_FOLDED) {
		if (mDeviceStateEnum == DeviceStateController.DeviceStateEnum.HALF_FOLDED) {
		return isTabletop == mTabletopRotations.contains(mRotation);
		}
		return true;
		}

		DeviceStateController.DeviceState getFoldState() {
		return mDeviceState;
		DeviceStateController.DeviceStateEnum getFoldState() {
		return mDeviceStateEnum;
		}

		boolean isSeparatingHinge() {
		return mDeviceState == DeviceStateController.DeviceState.HALF_FOLDED
		\|\| (mDeviceState == DeviceStateController.DeviceState.OPEN
		return mDeviceStateEnum == DeviceStateController.DeviceStateEnum.HALF_FOLDED
		\|\| (mDeviceStateEnum == DeviceStateController.DeviceStateEnum.OPEN
		&& mIsDisplayAlwaysSeparatingHinge);
		}

		boolean overrideFrozenRotation() {
		return mAllowHalfFoldAutoRotationOverride
		&& mDeviceState == DeviceStateController.DeviceState.HALF_FOLDED;
		&& mDeviceStateEnum == DeviceStateController.DeviceStateEnum.HALF_FOLDED;
		}

		boolean shouldRevertOverriddenRotation() {
		// When transitioning to open.
		return mAllowHalfFoldAutoRotationOverride
		&& mDeviceState == DeviceStateController.DeviceState.OPEN
		&& mDeviceStateEnum == DeviceStateController.DeviceStateEnum.OPEN
		&& !mShouldIgnoreSensorRotation // Ignore if the hinge angle still moving
		&& mInHalfFoldTransition
		&& mDisplayContent.getRotationReversionController().isOverrideActive(
		@@ -1811,32 +1812,32 @@ public class DisplayRotation {
		return savedRotation;
		}

		void foldStateChanged(DeviceStateController.DeviceState newState) {
		void foldStateChanged(DeviceStateController.DeviceStateEnum newState) {
		ProtoLog.v(WM_DEBUG_ORIENTATION,
		"foldStateChanged: displayId %d, halfFoldStateChanged %s, "
		+ "saved rotation: %d, mUserRotation: %d, mLastSensorRotation: %d, "
		+ "mLastOrientation: %d, mRotation: %d",
		mDisplayContent.getDisplayId(), newState.name(), mHalfFoldSavedRotation,
		mUserRotation, mLastSensorRotation, mLastOrientation, mRotation);
		if (mDeviceState == DeviceStateController.DeviceState.UNKNOWN) {
		mDeviceState = newState;
		if (mDeviceStateEnum == DeviceStateController.DeviceStateEnum.UNKNOWN) {
		mDeviceStateEnum = newState;
		return;
		}
		if (newState == DeviceStateController.DeviceState.HALF_FOLDED
		&& mDeviceState != DeviceStateController.DeviceState.HALF_FOLDED) {
		if (newState == DeviceStateController.DeviceStateEnum.HALF_FOLDED
		&& mDeviceStateEnum != DeviceStateController.DeviceStateEnum.HALF_FOLDED) {
		// The device has transitioned to HALF_FOLDED state: save the current rotation and
		// update the device rotation.
		mDisplayContent.getRotationReversionController().beforeOverrideApplied(
		REVERSION_TYPE_HALF_FOLD);
		mHalfFoldSavedRotation = mRotation;
		mDeviceState = newState;
		mDeviceStateEnum = newState;
		// Now mFoldState is set to HALF_FOLDED, the overrideFrozenRotation function will
		// return true, so rotation is unlocked.
		mService.updateRotation(false /* alwaysSendConfiguration */,
		false /* forceRelayout */);
		} else {
		mInHalfFoldTransition = true;
		mDeviceState = newState;
		mDeviceStateEnum = newState;
		// Tell the device to update its orientation.
		mService.updateRotation(false /* alwaysSendConfiguration */,
		false /* forceRelayout */);
		@@ -1885,8 +1886,8 @@ public class DisplayRotation {
		mLastDisplaySwitchTime = uptimeMillis();

		final boolean isUnfolding =
		mDeviceState == DeviceStateController.DeviceState.OPEN
		\|\| mDeviceState == DeviceStateController.DeviceState.HALF_FOLDED;
		mDeviceStateEnum == DeviceStateController.DeviceStateEnum.OPEN
		\|\| mDeviceStateEnum == DeviceStateController.DeviceStateEnum.HALF_FOLDED;

		if (isUnfolding) {
		// Temporary disable rotation sensor updates when unfolding
		@@ -2067,7 +2068,7 @@ public class DisplayRotation {
		final long mTimestamp = System.currentTimeMillis();
		final int mHalfFoldSavedRotation;
		final boolean mInHalfFoldTransition;
		final DeviceStateController.DeviceState mDeviceState;
		final DeviceStateController.DeviceStateEnum mDeviceStateEnum;
		@Nullable final boolean[] mRotationReversionSlots;

		@Nullable final String mDisplayRotationCompatPolicySummary;
		@@ -2100,11 +2101,11 @@ public class DisplayRotation {
		if (dr.mFoldController != null) {
		mHalfFoldSavedRotation = dr.mFoldController.mHalfFoldSavedRotation;
		mInHalfFoldTransition = dr.mFoldController.mInHalfFoldTransition;
		mDeviceState = dr.mFoldController.mDeviceState;
		mDeviceStateEnum = dr.mFoldController.mDeviceStateEnum;
		} else {
		mHalfFoldSavedRotation = NO_FOLD_CONTROLLER;
		mInHalfFoldTransition = false;
		mDeviceState = DeviceStateController.DeviceState.UNKNOWN;
		mDeviceStateEnum = DeviceStateController.DeviceStateEnum.UNKNOWN;
		}
		mDisplayRotationCompatPolicySummary = dc.mAppCompatCameraPolicy
		.getSummaryForDisplayRotationHistoryRecord();
		@@ -2130,7 +2131,7 @@ public class DisplayRotation {
		pw.println(prefix + " halfFoldSavedRotation="
		+ mHalfFoldSavedRotation
		+ " mInHalfFoldTransition=" + mInHalfFoldTransition
		+ " mFoldState=" + mDeviceState);
		+ " mFoldState=" + mDeviceStateEnum);
		}
		if (mDisplayRotationCompatPolicySummary != null) {
		pw.println(prefix + mDisplayRotationCompatPolicySummary);