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

Commit 5da1c6e2 authored by Mariia Sandrikova's avatar Mariia Sandrikova Committed by Automerger Merge Worker
Browse files

Remember and revert camera compat orientation change when camera closes am:... 

Remember and revert camera compat orientation change when camera closes am: c53fa6ba am: 762bb503 am: 6f5c242d am: 67b3b462

Original change: https://googleplex-android-review.googlesource.com/c/platform/frameworks/base/+/21096124



Change-Id: I7b32bf5e3f27ccb29d9853ee4d9bd15ecb02e0c3
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 8f8c01b9 67b3b462

data/etc/services.core.protolog.json

+30 −0
Original line number Diff line number Diff line
@@ -475,6 +475,18 @@ 
      "group": "WM_DEBUG_TASKS",

      "at": "com\/android\/server\/wm\/RecentTasks.java"

    },

    "-1643780158": {

      "message": "Saving original orientation before camera compat, last orientation is %d",

      "level": "VERBOSE",

      "group": "WM_DEBUG_ORIENTATION",

      "at": "com\/android\/server\/wm\/DisplayRotationCompatPolicy.java"

    },

    "-1639406696": {

      "message": "NOSENSOR override detected",

      "level": "VERBOSE",

      "group": "WM_DEBUG_ORIENTATION",

      "at": "com\/android\/server\/wm\/DisplayRotationReversionController.java"

    },

    "-1638958146": {

      "message": "Removing activity %s from task=%s adding to task=%s Callers=%s",

      "level": "INFO",
@@ -751,6 +763,12 @@ 
      "group": "WM_DEBUG_IME",

      "at": "com\/android\/server\/wm\/ImeInsetsSourceProvider.java"

    },

    "-1397175017": {

      "message": "Other orientation overrides are in place: not reverting",

      "level": "VERBOSE",

      "group": "WM_DEBUG_ORIENTATION",

      "at": "com\/android\/server\/wm\/DisplayRotationReversionController.java"

    },

    "-1394745488": {

      "message": "ControlAdapter onAnimationCancelled mSource: %s mControlTarget: %s",

      "level": "INFO",
@@ -1711,6 +1729,12 @@ 
      "group": "WM_DEBUG_WINDOW_TRANSITIONS",

      "at": "com\/android\/server\/wm\/Transition.java"

    },

    "-529187878": {

      "message": "Reverting orientation after camera compat force rotation",

      "level": "VERBOSE",

      "group": "WM_DEBUG_ORIENTATION",

      "at": "com\/android\/server\/wm\/DisplayRotationCompatPolicy.java"

    },

    "-521613870": {

      "message": "App died during pause, not stopping: %s",

      "level": "VERBOSE",
@@ -2383,6 +2407,12 @@ 
      "group": "WM_DEBUG_FOCUS_LIGHT",

      "at": "com\/android\/server\/wm\/WindowManagerService.java"

    },

    "138097009": {

      "message": "NOSENSOR override is absent: reverting",

      "level": "VERBOSE",

      "group": "WM_DEBUG_ORIENTATION",

      "at": "com\/android\/server\/wm\/DisplayRotationReversionController.java"

    },

    "140319294": {

      "message": "IME target changed within ActivityRecord",

      "level": "DEBUG",

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

+12 −0
Original line number Diff line number Diff line
@@ -775,6 +775,8 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp 
     */

    DisplayWindowPolicyControllerHelper mDwpcHelper;



    private final DisplayRotationReversionController mRotationReversionController;



    private final Consumer<WindowState> mUpdateWindowsForAnimator = w -> {

        WindowStateAnimator winAnimator = w.mWinAnimator;

        final ActivityRecord activity = w.mActivityRecord;
@@ -1204,6 +1206,7 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp 
                mWmService.mLetterboxConfiguration.isCameraCompatTreatmentEnabled(

                            /* checkDeviceConfig */ false)

                        ? new DisplayRotationCompatPolicy(this) : null;

        mRotationReversionController = new DisplayRotationReversionController(this);



        mInputMonitor = new InputMonitor(mWmService, this);

        mInsetsPolicy = new InsetsPolicy(mInsetsStateController, this);
@@ -1333,6 +1336,10 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp 
                .show(mA11yOverlayLayer);

    }



    DisplayRotationReversionController getRotationReversionController() {

        return mRotationReversionController;

    }



    boolean isReady() {

        // The display is ready when the system and the individual display are both ready.

        return mWmService.mDisplayReady && mDisplayReady;
@@ -1711,9 +1718,14 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp 
    }



    private boolean updateOrientation(boolean forceUpdate) {

        final WindowContainer prevOrientationSource = mLastOrientationSource;

        final int orientation = getOrientation();

        // The last orientation source is valid only after getOrientation.

        final WindowContainer orientationSource = getLastOrientationSource();

        if (orientationSource != prevOrientationSource

                && mRotationReversionController.isRotationReversionEnabled()) {

            mRotationReversionController.updateForNoSensorOverride();

        }

        final ActivityRecord r =

                orientationSource != null ? orientationSource.asActivityRecord() : null;

        if (r != null) {

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

+34 −6
Original line number Diff line number Diff line
@@ -33,6 +33,9 @@ import static com.android.server.wm.DisplayRotationProto.IS_FIXED_TO_USER_ROTATI 
import static com.android.server.wm.DisplayRotationProto.LAST_ORIENTATION;

import static com.android.server.wm.DisplayRotationProto.ROTATION;

import static com.android.server.wm.DisplayRotationProto.USER_ROTATION;

import static com.android.server.wm.DisplayRotationReversionController.REVERSION_TYPE_CAMERA_COMPAT;

import static com.android.server.wm.DisplayRotationReversionController.REVERSION_TYPE_HALF_FOLD;

import static com.android.server.wm.DisplayRotationReversionController.REVERSION_TYPE_NOSENSOR;

import static com.android.server.wm.WindowManagerDebugConfig.TAG_WITH_CLASS_NAME;

import static com.android.server.wm.WindowManagerDebugConfig.TAG_WM;

import static com.android.server.wm.WindowManagerService.WINDOWS_FREEZING_SCREENS_ACTIVE;
@@ -106,6 +109,9 @@ public class DisplayRotation { 
        int mExit;

    }



    @Nullable

    final FoldController mFoldController;



    private final WindowManagerService mService;

    private final DisplayContent mDisplayContent;

    private final DisplayPolicy mDisplayPolicy;
@@ -127,8 +133,6 @@ public class DisplayRotation { 
    private OrientationListener mOrientationListener;

    private StatusBarManagerInternal mStatusBarManagerInternal;

    private SettingsObserver mSettingsObserver;

    @Nullable

    private FoldController mFoldController;

    @NonNull

    private final DeviceStateController mDeviceStateController;

    @NonNull
@@ -299,7 +303,11 @@ public class DisplayRotation { 
            if (mSupportAutoRotation && mContext.getResources().getBoolean(

                    R.bool.config_windowManagerHalfFoldAutoRotateOverride)) {

                mFoldController = new FoldController();

            } else {

                mFoldController = null;

            }

        } else {

            mFoldController = null;

        }

    }
@@ -357,6 +365,11 @@ public class DisplayRotation { 
        return -1;

    }



    @VisibleForTesting

    boolean useDefaultSettingsProvider() {

        return isDefaultDisplay;

    }



    /**

     * Updates the configuration which may have different values depending on current user, e.g.

     * runtime resource overlay.
@@ -903,7 +916,7 @@ public class DisplayRotation { 
    @VisibleForTesting

    void setUserRotation(int userRotationMode, int userRotation) {

        mRotationChoiceShownToUserForConfirmation = ROTATION_UNDEFINED;

        if (isDefaultDisplay) {

        if (useDefaultSettingsProvider()) {

            // We'll be notified via settings listener, so we don't need to update internal values.

            final ContentResolver res = mContext.getContentResolver();

            final int accelerometerRotation =
@@ -1859,7 +1872,7 @@ public class DisplayRotation { 
                return false;

            }

            if (mDeviceState == DeviceStateController.DeviceState.HALF_FOLDED) {

                return !(isTabletop ^ mTabletopRotations.contains(mRotation));

                return isTabletop == mTabletopRotations.contains(mRotation);

            }

            return true;

        }
@@ -1883,7 +1896,8 @@ public class DisplayRotation { 
            return mDeviceState == DeviceStateController.DeviceState.OPEN

                    && !mShouldIgnoreSensorRotation // Ignore if the hinge angle still moving

                    && mInHalfFoldTransition

                    && mHalfFoldSavedRotation != -1 // Ignore if we've already reverted.

                    && mDisplayContent.getRotationReversionController().isOverrideActive(

                        REVERSION_TYPE_HALF_FOLD)

                    && mUserRotationMode

                        == WindowManagerPolicy.USER_ROTATION_LOCKED; // Ignore if we're unlocked.

        }
@@ -1891,6 +1905,8 @@ public class DisplayRotation { 
        int revertOverriddenRotation() {

            int savedRotation = mHalfFoldSavedRotation;

            mHalfFoldSavedRotation = -1;

            mDisplayContent.getRotationReversionController()

                    .revertOverride(REVERSION_TYPE_HALF_FOLD);

            mInHalfFoldTransition = false;

            return savedRotation;

        }
@@ -1910,6 +1926,8 @@ public class DisplayRotation { 
                    && mDeviceState != DeviceStateController.DeviceState.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;

                // Now mFoldState is set to HALF_FOLDED, the overrideFrozenRotation function will
@@ -2115,6 +2133,8 @@ public class DisplayRotation { 
            final int mHalfFoldSavedRotation;

            final boolean mInHalfFoldTransition;

            final DeviceStateController.DeviceState mDeviceState;

            @Nullable final boolean[] mRotationReversionSlots;



            @Nullable final String mDisplayRotationCompatPolicySummary;



            Record(DisplayRotation dr, int fromRotation, int toRotation) {
@@ -2155,6 +2175,8 @@ public class DisplayRotation { 
                        ? null

                        : dc.mDisplayRotationCompatPolicy

                                .getSummaryForDisplayRotationHistoryRecord();

                mRotationReversionSlots =

                        dr.mDisplayContent.getRotationReversionController().getSlotsCopy();

            }



            void dump(String prefix, PrintWriter pw) {
@@ -2180,6 +2202,12 @@ public class DisplayRotation { 
                if (mDisplayRotationCompatPolicySummary != null) {

                    pw.println(prefix + mDisplayRotationCompatPolicySummary);

                }

                if (mRotationReversionSlots != null) {

                    pw.println(prefix + " reversionSlots= NOSENSOR "

                            + mRotationReversionSlots[REVERSION_TYPE_NOSENSOR] + ", CAMERA "

                            + mRotationReversionSlots[REVERSION_TYPE_CAMERA_COMPAT] + " HALF_FOLD "

                            + mRotationReversionSlots[REVERSION_TYPE_HALF_FOLD]);

                }

            }

        }

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

+34 −0
Original line number Diff line number Diff line
@@ -33,6 +33,7 @@ import static android.view.Display.TYPE_INTERNAL; 


import static com.android.internal.protolog.ProtoLogGroup.WM_DEBUG_ORIENTATION;

import static com.android.internal.protolog.ProtoLogGroup.WM_DEBUG_STATES;

import static com.android.server.wm.DisplayRotationReversionController.REVERSION_TYPE_CAMERA_COMPAT;



import android.annotation.NonNull;

import android.annotation.Nullable;
@@ -156,6 +157,11 @@ final class DisplayRotationCompatPolicy { 
    @ScreenOrientation

    int getOrientation() {

        mLastReportedOrientation = getOrientationInternal();

        if (mLastReportedOrientation != SCREEN_ORIENTATION_UNSPECIFIED) {

            rememberOverriddenOrientationIfNeeded();

        } else {

            restoreOverriddenOrientationIfNeeded();

        }

        return mLastReportedOrientation;

    }
@@ -277,6 +283,34 @@ final class DisplayRotationCompatPolicy { 
                + " }";

    }



    private void restoreOverriddenOrientationIfNeeded() {

        if (!isOrientationOverridden()) {

            return;

        }

        if (mDisplayContent.getRotationReversionController().revertOverride(

                REVERSION_TYPE_CAMERA_COMPAT)) {

            ProtoLog.v(WM_DEBUG_ORIENTATION,

                    "Reverting orientation after camera compat force rotation");

            // Reset last orientation source since we have reverted the orientation.

            mDisplayContent.mLastOrientationSource = null;

        }

    }



    private boolean isOrientationOverridden() {

        return mDisplayContent.getRotationReversionController().isOverrideActive(

                REVERSION_TYPE_CAMERA_COMPAT);

    }



    private void rememberOverriddenOrientationIfNeeded() {

        if (!isOrientationOverridden()) {

            mDisplayContent.getRotationReversionController().beforeOverrideApplied(

                    REVERSION_TYPE_CAMERA_COMPAT);

            ProtoLog.v(WM_DEBUG_ORIENTATION,

                    "Saving original orientation before camera compat, last orientation is %d",

                    mDisplayContent.getLastOrientation());

        }

    }



    // Refreshing only when configuration changes after rotation.

    private boolean shouldRefreshActivity(ActivityRecord activity, Configuration newConfig,

            Configuration lastReportedConfig) {

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

0 → 100644
+148 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2023 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



package com.android.server.wm;



import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN;



import static com.android.internal.protolog.ProtoLogGroup.WM_DEBUG_ORIENTATION;



import android.annotation.Nullable;

import android.app.WindowConfiguration;

import android.content.ActivityInfoProto;

import android.view.Surface;



import com.android.internal.protolog.common.ProtoLog;

import com.android.server.policy.WindowManagerPolicy;



/**

 * Defines the behavior of reversion from device rotation overrides.

 *

 * <p>There are 3 override types:

 * <ol>

 *  <li>The top application has {@link SCREEN_ORIENTATION_NOSENSOR} set and is rotated to

 *  {@link ROTATION_0}.

 *  <li>Camera compat treatment has rotated the app {@link DisplayRotationCompatPolicy}.

 *  <li>The device is half-folded and has auto-rotate is temporarily enabled.

 * </ol>

 *

 * <p>Before an override is enabled, a component should call {@code beforeOverrideApplied}. When

 * it wishes to revert, it should call {@code revertOverride}. The user rotation will be restored

 * if there are no other overrides present.

 */

final class DisplayRotationReversionController {



    static final int REVERSION_TYPE_NOSENSOR = 0;

    static final int REVERSION_TYPE_CAMERA_COMPAT = 1;

    static final int REVERSION_TYPE_HALF_FOLD = 2;

    private static final int NUM_SLOTS = 3;



    @Surface.Rotation

    private int mUserRotationOverridden = WindowConfiguration.ROTATION_UNDEFINED;

    @WindowManagerPolicy.UserRotationMode

    private int mUserRotationModeOverridden;



    private final boolean[] mSlots = new boolean[NUM_SLOTS];

    private final DisplayContent mDisplayContent;



    DisplayRotationReversionController(DisplayContent content) {

        mDisplayContent = content;

    }



    boolean isRotationReversionEnabled() {

        return mDisplayContent.mDisplayRotationCompatPolicy != null

                || mDisplayContent.getDisplayRotation().mFoldController != null

                || mDisplayContent.getIgnoreOrientationRequest();

    }



    void beforeOverrideApplied(int slotIndex) {

        if (mSlots[slotIndex]) return;

        maybeSaveUserRotation();

        mSlots[slotIndex] = true;

    }



    boolean isOverrideActive(int slotIndex) {

        return mSlots[slotIndex];

    }



    @Nullable

    boolean[] getSlotsCopy() {

        return isRotationReversionEnabled() ? mSlots.clone() : null;

    }



    void updateForNoSensorOverride() {

        if (!mSlots[REVERSION_TYPE_NOSENSOR]) {

            if (isTopFullscreenActivityNoSensor()) {

                ProtoLog.v(WM_DEBUG_ORIENTATION, "NOSENSOR override detected");

                beforeOverrideApplied(REVERSION_TYPE_NOSENSOR);

            }

        } else {

            if (!isTopFullscreenActivityNoSensor()) {

                ProtoLog.v(WM_DEBUG_ORIENTATION, "NOSENSOR override is absent: reverting");

                revertOverride(REVERSION_TYPE_NOSENSOR);

            }

        }

    }



    boolean isAnyOverrideActive() {

        for (int i = 0; i < NUM_SLOTS; ++i) {

            if (mSlots[i]) {

                return true;

            }

        }

        return false;

    }



    boolean revertOverride(int slotIndex) {

        if (!mSlots[slotIndex]) return false;

        mSlots[slotIndex] = false;

        if (isAnyOverrideActive()) {

            ProtoLog.v(WM_DEBUG_ORIENTATION,

                    "Other orientation overrides are in place: not reverting");

            return false;

        }

        // Only override if the rotation is frozen and there are no other active slots.

        if (mDisplayContent.getDisplayRotation().isRotationFrozen()) {

            mDisplayContent.getDisplayRotation().setUserRotation(

                    mUserRotationModeOverridden,

                    mUserRotationOverridden);

            return true;

        } else {

            return false;

        }

    }



    private void maybeSaveUserRotation() {

        if (!isAnyOverrideActive()) {

            mUserRotationModeOverridden =

                    mDisplayContent.getDisplayRotation().getUserRotationMode();

            mUserRotationOverridden = mDisplayContent.getDisplayRotation().getUserRotation();

        }

    }



    private boolean isTopFullscreenActivityNoSensor() {

        final Task topFullscreenTask =

                mDisplayContent.getTask(

                        t -> t.getWindowingMode() == WINDOWING_MODE_FULLSCREEN);

        if (topFullscreenTask != null) {

            final ActivityRecord topActivity =

                    topFullscreenTask.topRunningActivity();

            return topActivity != null && topActivity.getOrientation()

                    == ActivityInfoProto.SCREEN_ORIENTATION_NOSENSOR;

        }

        return false;

    }

}