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

Commit dbff9152 authored by Rupesh Bansal's avatar Rupesh Bansal
Browse files

Use offload session flag for setting allowAutoBrightnessWhileDozing flag 

We recently added support to use the value from the offload session when
deciding if autobrightness is to be enabled while dozing in ag/26443561.
However it was not appropriately set via the DPC refactor route, which led to
autobrightness not being disabled when the device goes to doze suspend

Bug: 341027020
Test: atest com.android.server.display.brightness
Test: Manually verifying the light sensor is disabled when in doze
suspend

Change-Id: Iacaf3e7389d94aa79949252c03587b22739bc703
parent 7e725e06

services/core/java/com/android/server/display/DisplayPowerController.java

+7 −9
Original line number Diff line number Diff line
@@ -1361,7 +1361,7 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call 
        state = mPowerState.getScreenState();



        DisplayBrightnessState displayBrightnessState = mDisplayBrightnessController

                .updateBrightness(mPowerRequest, state);

                .updateBrightness(mPowerRequest, state, mDisplayOffloadSession);

        float brightnessState = displayBrightnessState.getBrightness();

        float rawBrightnessState = displayBrightnessState.getBrightness();

        mBrightnessReasonTemp.set(displayBrightnessState.getBrightnessReason());
@@ -1374,6 +1374,10 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call 
        if (displayBrightnessState.getBrightnessEvent() != null) {

            mTempBrightnessEvent.copyFrom(displayBrightnessState.getBrightnessEvent());

        }



        boolean allowAutoBrightnessWhileDozing =

                mDisplayBrightnessController.isAllowAutoBrightnessWhileDozing();



        if (!mFlags.isRefactorDisplayPowerControllerEnabled()) {

            // Set up the ScreenOff controller used when coming out of SCREEN_OFF and the ALS sensor

            // doesn't yet have a valid lux value to use with auto-brightness.
@@ -1381,8 +1385,7 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call 
                mScreenOffBrightnessSensorController

                        .setLightSensorEnabled(displayBrightnessState.getShouldUseAutoBrightness()

                        && mIsEnabled && (state == Display.STATE_OFF

                        || (state == Display.STATE_DOZE

                        && !mDisplayBrightnessController.isAllowAutoBrightnessWhileDozingConfig()))

                        || (state == Display.STATE_DOZE && !allowAutoBrightnessWhileDozing))

                        && mLeadDisplayId == Layout.NO_LEAD_DISPLAY);

            }

        }
@@ -1392,12 +1395,7 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call 
        final boolean wasShortTermModelActive =

                mAutomaticBrightnessStrategy.isShortTermModelActive();

        boolean userInitiatedChange = displayBrightnessState.isUserInitiatedChange();

        boolean allowAutoBrightnessWhileDozing =

                mDisplayBrightnessController.isAllowAutoBrightnessWhileDozingConfig();

        if (mFlags.offloadControlsDozeAutoBrightness() && mFlags.isDisplayOffloadEnabled()

                && mDisplayOffloadSession != null) {

            allowAutoBrightnessWhileDozing &= mDisplayOffloadSession.allowAutoBrightnessInDoze();

        }



        if (!mFlags.isRefactorDisplayPowerControllerEnabled()) {

            // Switch to doze auto-brightness mode if needed

            if (mFlags.areAutoBrightnessModesEnabled() && mAutomaticBrightnessController != null

services/core/java/com/android/server/display/brightness/DisplayBrightnessController.java

+17 −4
Original line number Diff line number Diff line
@@ -146,11 +146,13 @@ public final class DisplayBrightnessController { 
     */

    public DisplayBrightnessState updateBrightness(

            DisplayManagerInternal.DisplayPowerRequest displayPowerRequest,

            int targetDisplayState) {

            int targetDisplayState,

            DisplayManagerInternal.DisplayOffloadSession displayOffloadSession) {

        DisplayBrightnessState state;

        synchronized (mLock) {

            mDisplayBrightnessStrategy = mDisplayBrightnessStrategySelector.selectStrategy(

                    constructStrategySelectionRequest(displayPowerRequest, targetDisplayState));

                    constructStrategySelectionRequest(displayPowerRequest, targetDisplayState,

                            displayOffloadSession));

            state = mDisplayBrightnessStrategy

                        .updateBrightness(constructStrategyExecutionRequest(displayPowerRequest));

        }
@@ -204,6 +206,16 @@ public final class DisplayBrightnessController { 
     * Returns a boolean flag indicating if the light sensor is to be used to decide the screen

     * brightness when dozing

     */

    public boolean isAllowAutoBrightnessWhileDozing() {

        synchronized (mLock) {

            return mDisplayBrightnessStrategySelector.isAllowAutoBrightnessWhileDozing();

        }

    }



    /**

     * Returns the config value indicating the auto brightness while dozing is to be

     * allowed ot not. Note that this is a config value, but the actual status can differ from this.

     */

    public boolean isAllowAutoBrightnessWhileDozingConfig() {

        synchronized (mLock) {

            return mDisplayBrightnessStrategySelector.isAllowAutoBrightnessWhileDozingConfig();
@@ -587,14 +599,15 @@ public final class DisplayBrightnessController { 


    private StrategySelectionRequest constructStrategySelectionRequest(

            DisplayManagerInternal.DisplayPowerRequest displayPowerRequest,

            int targetDisplayState) {

            int targetDisplayState,

            DisplayManagerInternal.DisplayOffloadSession displayOffloadSession) {

        boolean userSetBrightnessChanged = updateUserSetScreenBrightness();

        float lastUserSetScreenBrightness;

        synchronized (mLock) {

            lastUserSetScreenBrightness = mLastUserSetScreenBrightness;

        }

        return new StrategySelectionRequest(displayPowerRequest, targetDisplayState,

                lastUserSetScreenBrightness, userSetBrightnessChanged);

                lastUserSetScreenBrightness, userSetBrightnessChanged, displayOffloadSession);

    }



    private StrategyExecutionRequest constructStrategyExecutionRequest(

services/core/java/com/android/server/display/brightness/DisplayBrightnessStrategySelector.java

+32 −4
Original line number Diff line number Diff line
@@ -48,9 +48,14 @@ import java.io.PrintWriter; 
 */

public class DisplayBrightnessStrategySelector {

    private static final String TAG = "DisplayBrightnessStrategySelector";

    // True if light sensor is to be used to automatically determine doze screen brightness.

    // True if the config to use the light sensor to automatically determine doze screen brightness

    // is enabled. Note that the actual value representing if the auto-brightness is to be kept

    // enabled while dozing can differ, but is dependent on this

    private final boolean mAllowAutoBrightnessWhileDozingConfig;



    // True if light sensor is to be used to automatically determine doze screen brightness.

    private boolean mAllowAutoBrightnessWhileDozing;



    // The brightness strategy used to manage the brightness state when the display is dozing.

    private final DozeBrightnessStrategy mDozeBrightnessStrategy;

    // The brightness strategy used to manage the brightness state when the display is in
@@ -149,6 +154,7 @@ public class DisplayBrightnessStrategySelector { 
                mAutoBrightnessFallbackStrategy, mFallbackBrightnessStrategy};

        mAllowAutoBrightnessWhileDozingConfig = context.getResources().getBoolean(

                R.bool.config_allowAutoBrightnessWhileDozing);

        mAllowAutoBrightnessWhileDozing = mAllowAutoBrightnessWhileDozingConfig;

        mOldBrightnessStrategyName = mInvalidBrightnessStrategy.getName();

    }
@@ -163,6 +169,7 @@ public class DisplayBrightnessStrategySelector { 
        int targetDisplayState = strategySelectionRequest.getTargetDisplayState();

        DisplayManagerInternal.DisplayPowerRequest displayPowerRequest = strategySelectionRequest

                .getDisplayPowerRequest();

        setAllowAutoBrightnessWhileDozing(strategySelectionRequest.getDisplayOffloadSession());

        if (targetDisplayState == Display.STATE_OFF) {

            displayBrightnessStrategy = mScreenOffBrightnessStrategy;

        } else if (shouldUseDozeBrightnessStrategy(displayPowerRequest)) {
@@ -231,6 +238,14 @@ public class DisplayBrightnessStrategySelector { 
     * Returns a boolean flag indicating if the light sensor is to be used to decide the screen

     * brightness when dozing

     */

    public boolean isAllowAutoBrightnessWhileDozing() {

        return mAllowAutoBrightnessWhileDozing;

    }



    /**

     * Returns the config value indicating whether auto brightness while dozing is to be

     * allowed ot not

     */

    public boolean isAllowAutoBrightnessWhileDozingConfig() {

        return mAllowAutoBrightnessWhileDozingConfig;

    }
@@ -251,6 +266,8 @@ public class DisplayBrightnessStrategySelector { 
        writer.println(

                "  mAllowAutoBrightnessWhileDozingConfig= "

                        + mAllowAutoBrightnessWhileDozingConfig);

        writer.println(

                "  mAllowAutoBrightnessWhileDozing= " + mAllowAutoBrightnessWhileDozing);

        IndentingPrintWriter ipw = new IndentingPrintWriter(writer, " ");

        for (DisplayBrightnessStrategy displayBrightnessStrategy : mDisplayBrightnessStrategies) {

            if (displayBrightnessStrategy != null) {
@@ -259,6 +276,17 @@ public class DisplayBrightnessStrategySelector { 
        }

    }



    @VisibleForTesting

    void setAllowAutoBrightnessWhileDozing(

            DisplayManagerInternal.DisplayOffloadSession displayOffloadSession) {

        mAllowAutoBrightnessWhileDozing = mAllowAutoBrightnessWhileDozingConfig;

        if (mDisplayManagerFlags.offloadControlsDozeAutoBrightness()

                && mDisplayManagerFlags.isDisplayOffloadEnabled()

                && displayOffloadSession != null) {

            mAllowAutoBrightnessWhileDozing &= displayOffloadSession.allowAutoBrightnessInDoze();

        }

    }



    private boolean isAutoBrightnessFallbackStrategyValid() {

        return mDisplayManagerFlags.isRefactorDisplayPowerControllerEnabled()

                && mAutoBrightnessFallbackStrategy != null
@@ -270,7 +298,7 @@ public class DisplayBrightnessStrategySelector { 
            StrategySelectionRequest strategySelectionRequest) {

        mAutomaticBrightnessStrategy1.setAutoBrightnessState(

                strategySelectionRequest.getTargetDisplayState(),

                mAllowAutoBrightnessWhileDozingConfig,

                mAllowAutoBrightnessWhileDozing,

                BrightnessReason.REASON_UNKNOWN,

                strategySelectionRequest.getDisplayPowerRequest().policy,

                strategySelectionRequest.getLastUserSetScreenBrightness(),
@@ -287,7 +315,7 @@ public class DisplayBrightnessStrategySelector { 
                selectedDisplayBrightnessStrategy,

                strategySelectionRequest.getLastUserSetScreenBrightness(),

                strategySelectionRequest.isUserSetBrightnessChanged(),

                isAllowAutoBrightnessWhileDozingConfig(),

                mAllowAutoBrightnessWhileDozing,

                getAutomaticBrightnessStrategy().shouldUseAutoBrightness());

    }
@@ -309,7 +337,7 @@ public class DisplayBrightnessStrategySelector { 
        // a user can define a different display state(displayPowerRequest.dozeScreenState) too

        // in the request with the Doze policy

        return displayPowerRequest.policy == DisplayManagerInternal.DisplayPowerRequest.POLICY_DOZE

                && !mAllowAutoBrightnessWhileDozingConfig

                && !mAllowAutoBrightnessWhileDozing

                && BrightnessUtils.isValidBrightnessValue(displayPowerRequest.dozeScreenBrightness);

    }

services/core/java/com/android/server/display/brightness/StrategySelectionRequest.java

+12 −3
Original line number Diff line number Diff line
@@ -38,13 +38,17 @@ public final class StrategySelectionRequest { 
    // Represents if the user set screen brightness was changed or not.

    private boolean mUserSetBrightnessChanged;



    private DisplayManagerInternal.DisplayOffloadSession mDisplayOffloadSession;



    public StrategySelectionRequest(DisplayManagerInternal.DisplayPowerRequest displayPowerRequest,

            int targetDisplayState, float lastUserSetScreenBrightness,

            boolean userSetBrightnessChanged) {

            boolean userSetBrightnessChanged,

            DisplayManagerInternal.DisplayOffloadSession displayOffloadSession) {

        mDisplayPowerRequest = displayPowerRequest;

        mTargetDisplayState = targetDisplayState;

        mLastUserSetScreenBrightness = lastUserSetScreenBrightness;

        mUserSetBrightnessChanged = userSetBrightnessChanged;

        mDisplayOffloadSession = displayOffloadSession;

    }



    public DisplayManagerInternal.DisplayPowerRequest getDisplayPowerRequest() {
@@ -64,6 +68,10 @@ public final class StrategySelectionRequest { 
        return mUserSetBrightnessChanged;

    }



    public DisplayManagerInternal.DisplayOffloadSession getDisplayOffloadSession() {

        return mDisplayOffloadSession;

    }



    @Override

    public boolean equals(Object obj) {

        if (!(obj instanceof StrategySelectionRequest)) {
@@ -73,12 +81,13 @@ public final class StrategySelectionRequest { 
        return Objects.equals(mDisplayPowerRequest, other.getDisplayPowerRequest())

                && mTargetDisplayState == other.getTargetDisplayState()

                && mLastUserSetScreenBrightness == other.getLastUserSetScreenBrightness()

                && mUserSetBrightnessChanged == other.isUserSetBrightnessChanged();

                && mUserSetBrightnessChanged == other.isUserSetBrightnessChanged()

                && mDisplayOffloadSession.equals(other.getDisplayOffloadSession());

    }



    @Override

    public int hashCode() {

        return Objects.hash(mDisplayPowerRequest, mTargetDisplayState,

                mLastUserSetScreenBrightness, mUserSetBrightnessChanged);

                mLastUserSetScreenBrightness, mUserSetBrightnessChanged, mDisplayOffloadSession);

    }

}

services/tests/displayservicetests/src/com/android/server/display/brightness/DisplayBrightnessControllerTest.java

+9 −1
Original line number Diff line number Diff line
@@ -33,6 +33,7 @@ import static org.mockito.Mockito.when; 
import android.content.Context;

import android.content.res.Resources;

import android.hardware.SensorManager;

import android.hardware.display.DisplayManagerInternal;

import android.hardware.display.DisplayManagerInternal.DisplayPowerRequest;

import android.os.Handler;

import android.os.HandlerExecutor;
@@ -119,7 +120,8 @@ public final class DisplayBrightnessControllerTest { 
        int targetDisplayState = Display.STATE_DOZE;

        when(mDisplayBrightnessStrategySelector.selectStrategy(

                any(StrategySelectionRequest.class))).thenReturn(displayBrightnessStrategy);

        mDisplayBrightnessController.updateBrightness(displayPowerRequest, targetDisplayState);

        mDisplayBrightnessController.updateBrightness(displayPowerRequest, targetDisplayState, mock(

                DisplayManagerInternal.DisplayOffloadSession.class));

        verify(displayBrightnessStrategy).updateBrightness(

                eq(new StrategyExecutionRequest(displayPowerRequest, DEFAULT_BRIGHTNESS,

                        /* userSetBrightnessChanged= */ false)));
@@ -127,6 +129,12 @@ public final class DisplayBrightnessControllerTest { 
                displayBrightnessStrategy);

    }



    @Test

    public void isAllowAutoBrightnessWhileDozingDelegatesToDozeBrightnessStrategy() {

        mDisplayBrightnessController.isAllowAutoBrightnessWhileDozing();

        verify(mDisplayBrightnessStrategySelector).isAllowAutoBrightnessWhileDozing();

    }



    @Test

    public void isAllowAutoBrightnessWhileDozingConfigDelegatesToDozeBrightnessStrategy() {

        mDisplayBrightnessController.isAllowAutoBrightnessWhileDozingConfig();