Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit a71e6d6b authored by dshivangi's avatar dshivangi
Browse files

Rename `wm.DeviceStateController.DeviceState` enum 

Rename `wm.DeviceStateController.DeviceState` enum to DeviceStateEnum.
This would help us separate `wm.DeviceStateController.DeviceState` enum from `hardware.devicestates.DeviceState`.
This change is necessary as we are going to use both entities named `DeviceState` in the same context, in a follow-up CL.

Bug: 407772602
Test: Check if no unit-tests fail in presubmits
Flag: EXEMPT refactor
Change-Id: Ibb854e2e80ef74c01a49122e0c5d5666001c1eaa
parent ae08a2ea

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
@@ -1542,7 +1542,7 @@ public class DisplayRotation { 
            pw.println(prefix + "  mLastHingeAngleEventTime="

                    + mFoldController.mLastHingeAngleEventTime);

            pw.println(prefix + "  mDeviceState="

                    + mFoldController.mDeviceState);

                    + mFoldController.mDeviceStateEnum);

        }



        if (!mRotationHistory.mRecords.isEmpty()) {
@@ -1575,7 +1575,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);

    }
@@ -1589,12 +1589,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);

                }

            }

        }
@@ -1651,8 +1651,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;
@@ -1706,8 +1706,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(
@@ -1767,35 +1768,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(
@@ -1813,32 +1814,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 */);
@@ -1887,8 +1888,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
@@ -2069,7 +2070,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;
@@ -2102,11 +2103,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();
@@ -2132,7 +2133,7 @@ public class DisplayRotation { 
                    pw.println(prefix + " halfFoldSavedRotation="

                            + mHalfFoldSavedRotation

                            + " mInHalfFoldTransition=" + mInHalfFoldTransition

                            + " mFoldState=" + mDeviceState);

                            + " mFoldState=" + mDeviceStateEnum);

                }

                if (mDisplayRotationCompatPolicySummary != null) {

                    pw.println(prefix + mDisplayRotationCompatPolicySummary);