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

Commit 93141f06 authored by Rupesh Bansal's avatar Rupesh Bansal
Browse files

Added fallback strategy 

FallbackBrightnessStrategy is the last resort to which the system will
fall back if none of the other strategies qualify to set the
brightness state. This strategy is also being used for evaluating the
display brightness state when we have a manually set brightness. This
is a temporary state, and the logic for evaluating the manual brightness
will soon be moved to a separate strategy

Bug: 339647371
Test: atest com.android.server.display.brightness
Change-Id: I84de9f479bf6751af7ea0954fa2b76063d77a9f9
parent 552c1bdf

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

+43 −35
Original line number Diff line number Diff line
@@ -84,6 +84,7 @@ import com.android.server.display.brightness.BrightnessUtils; 
import com.android.server.display.brightness.DisplayBrightnessController;

import com.android.server.display.brightness.clamper.BrightnessClamperController;

import com.android.server.display.brightness.strategy.AutomaticBrightnessStrategy2;

import com.android.server.display.brightness.strategy.DisplayBrightnessStrategyConstants;

import com.android.server.display.color.ColorDisplayService.ColorDisplayServiceInternal;

import com.android.server.display.color.ColorDisplayService.ReduceBrightColorsListener;

import com.android.server.display.config.HysteresisLevels;
@@ -1440,13 +1441,17 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call 
            brightnessState = clampScreenBrightness(brightnessState);

        }



        if (Display.isDozeState(state)) {

            // If there's an offload session, we need to set the initial doze brightness before

            // the offload session starts controlling the brightness.

            // During the transition DOZE_SUSPEND -> DOZE -> DOZE_SUSPEND, this brightness strategy

        // will be selected again, meaning that no new brightness will be sent to the hardware and

        // the display will stay at the brightness level set by the offload session.

        if (Float.isNaN(brightnessState) && mFlags.isDisplayOffloadEnabled()

                && Display.isDozeState(state) && mDisplayOffloadSession != null) {

            // will be selected again, meaning that no new brightness will be sent to the hardware

            // and the display will stay at the brightness level set by the offload session.

            if ((Float.isNaN(brightnessState)

                    || displayBrightnessState.getDisplayBrightnessStrategyName()

                    .equals(DisplayBrightnessStrategyConstants.FALLBACK_BRIGHTNESS_STRATEGY_NAME))

                    && mFlags.isDisplayOffloadEnabled()

                    && mDisplayOffloadSession != null) {

                if (mAutomaticBrightnessController != null

                        && mAutomaticBrightnessStrategy.shouldUseAutoBrightness()) {

                    // Use the auto-brightness curve and the last observed lux
@@ -1475,11 +1480,14 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call 
            }



            // Use default brightness when dozing unless overridden.

        if (Float.isNaN(brightnessState) && Display.isDozeState(state)) {

            if (Float.isNaN(brightnessState)

                    || displayBrightnessState.getDisplayBrightnessStrategyName()

                    .equals(DisplayBrightnessStrategyConstants.FALLBACK_BRIGHTNESS_STRATEGY_NAME)) {

                rawBrightnessState = mScreenBrightnessDozeConfig;

                brightnessState = clampScreenBrightness(rawBrightnessState);

                mBrightnessReasonTemp.setReason(BrightnessReason.REASON_DOZE_DEFAULT);

            }

        }



        if (!mFlags.isRefactorDisplayPowerControllerEnabled()) {

            // The ALS is not available yet - use the screen off sensor to determine the initial
@@ -1502,7 +1510,7 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call 
        }



        // Apply manual brightness.

        if (Float.isNaN(brightnessState)) {

        if (Float.isNaN(brightnessState) && !mFlags.isRefactorDisplayPowerControllerEnabled()) {

            rawBrightnessState = currentBrightnessSetting;

            brightnessState = clampScreenBrightness(rawBrightnessState);

            if (brightnessState != currentBrightnessSetting) {

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

+18 −1
Original line number Diff line number Diff line
@@ -32,6 +32,7 @@ import com.android.server.display.brightness.strategy.AutomaticBrightnessStrateg 
import com.android.server.display.brightness.strategy.BoostBrightnessStrategy;

import com.android.server.display.brightness.strategy.DisplayBrightnessStrategy;

import com.android.server.display.brightness.strategy.DozeBrightnessStrategy;

import com.android.server.display.brightness.strategy.FallbackBrightnessStrategy;

import com.android.server.display.brightness.strategy.FollowerBrightnessStrategy;

import com.android.server.display.brightness.strategy.InvalidBrightnessStrategy;

import com.android.server.display.brightness.strategy.OffloadBrightnessStrategy;
@@ -85,6 +86,9 @@ public class DisplayBrightnessStrategySelector { 
    @Nullable

    private final AutoBrightnessFallbackStrategy mAutoBrightnessFallbackStrategy;



    @Nullable

    private final FallbackBrightnessStrategy mFallbackBrightnessStrategy;



    // A collective representation of all the strategies that the selector is aware of. This is

    // non null, but the strategies this is tracking can be null

    @NonNull
@@ -134,11 +138,14 @@ public class DisplayBrightnessStrategySelector { 
        } else {

            mOffloadBrightnessStrategy = null;

        }

        mFallbackBrightnessStrategy = (mDisplayManagerFlags

                .isRefactorDisplayPowerControllerEnabled())

                ? injector.getFallbackBrightnessStrategy() : null;

        mDisplayBrightnessStrategies = new DisplayBrightnessStrategy[]{mInvalidBrightnessStrategy,

                mScreenOffBrightnessStrategy, mDozeBrightnessStrategy, mFollowerBrightnessStrategy,

                mBoostBrightnessStrategy, mOverrideBrightnessStrategy, mTemporaryBrightnessStrategy,

                mAutomaticBrightnessStrategy1, mOffloadBrightnessStrategy,

                mAutoBrightnessFallbackStrategy};

                mAutoBrightnessFallbackStrategy, mFallbackBrightnessStrategy};

        mAllowAutoBrightnessWhileDozingConfig = context.getResources().getBoolean(

                R.bool.config_allowAutoBrightnessWhileDozing);

        mOldBrightnessStrategyName = mInvalidBrightnessStrategy.getName();
@@ -179,6 +186,12 @@ public class DisplayBrightnessStrategySelector { 
            displayBrightnessStrategy = mOffloadBrightnessStrategy;

        } else if (isAutoBrightnessFallbackStrategyValid()) {

            displayBrightnessStrategy = mAutoBrightnessFallbackStrategy;

        } else {

            // This will become the ultimate fallback strategy once the flag has been fully rolled

            // out

            if (mDisplayManagerFlags.isRefactorDisplayPowerControllerEnabled()) {

                displayBrightnessStrategy = mFallbackBrightnessStrategy;

            }

        }



        if (mDisplayManagerFlags.isRefactorDisplayPowerControllerEnabled()) {
@@ -347,5 +360,9 @@ public class DisplayBrightnessStrategySelector { 
        AutoBrightnessFallbackStrategy getAutoBrightnessFallbackStrategy() {

            return new AutoBrightnessFallbackStrategy(/* injector= */ null);

        }



        FallbackBrightnessStrategy getFallbackBrightnessStrategy() {

            return new FallbackBrightnessStrategy();

        }

    }

}

services/core/java/com/android/server/display/brightness/strategy/DisplayBrightnessStrategyConstants.java

+1 −0
Original line number Diff line number Diff line
@@ -18,4 +18,5 @@ package com.android.server.display.brightness.strategy; 


public class DisplayBrightnessStrategyConstants {

    static final String INVALID_BRIGHTNESS_STRATEGY_NAME = "InvalidBrightnessStrategy";

    public static final String FALLBACK_BRIGHTNESS_STRATEGY_NAME = "FallbackBrightnessStrategy";

}

services/core/java/com/android/server/display/brightness/strategy/FallbackBrightnessStrategy.java

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

 * Copyright (C) 2024 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.display.brightness.strategy;



import android.annotation.NonNull;



import com.android.server.display.DisplayBrightnessState;

import com.android.server.display.brightness.BrightnessReason;

import com.android.server.display.brightness.StrategyExecutionRequest;

import com.android.server.display.brightness.StrategySelectionNotifyRequest;



import java.io.PrintWriter;



/**

 * Manages the brightness of the associated display when no other strategy qualifies for

 * setting up the brightness state. This strategy is also being used for evaluating the

 * display brightness state when we have a manually set brightness. This is a temporary state, and

 * the logic for evaluating the manual brightness will be moved to a separate strategy

 */

public class FallbackBrightnessStrategy implements DisplayBrightnessStrategy{

    @Override

    public DisplayBrightnessState updateBrightness(

            StrategyExecutionRequest strategyExecutionRequest) {

        BrightnessReason brightnessReason = new BrightnessReason();

        brightnessReason.setReason(BrightnessReason.REASON_MANUAL);

        return new DisplayBrightnessState.Builder()

                .setBrightness(strategyExecutionRequest.getCurrentScreenBrightness())

                .setSdrBrightness(strategyExecutionRequest.getCurrentScreenBrightness())

                .setBrightnessReason(brightnessReason)

                .setDisplayBrightnessStrategyName(getName())

                // The fallback brightness might change due to clamping. Make sure we tell the rest

                // of the system by updating the setting

                .setShouldUpdateScreenBrightnessSetting(true)

                .build();

    }



    @NonNull

    @Override

    public String getName() {

        return DisplayBrightnessStrategyConstants.FALLBACK_BRIGHTNESS_STRATEGY_NAME;

    }



    @Override

    public int getReason() {

        return BrightnessReason.REASON_MANUAL;

    }



    @Override

    public void dump(PrintWriter writer) {



    }



    @Override

    public void strategySelectionPostProcessor(

            StrategySelectionNotifyRequest strategySelectionNotifyRequest) {



    }

}

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

+27 −0
Original line number Diff line number Diff line
@@ -46,6 +46,7 @@ import com.android.server.display.brightness.strategy.AutomaticBrightnessStrateg 
import com.android.server.display.brightness.strategy.BoostBrightnessStrategy;

import com.android.server.display.brightness.strategy.DisplayBrightnessStrategy;

import com.android.server.display.brightness.strategy.DozeBrightnessStrategy;

import com.android.server.display.brightness.strategy.FallbackBrightnessStrategy;

import com.android.server.display.brightness.strategy.FollowerBrightnessStrategy;

import com.android.server.display.brightness.strategy.InvalidBrightnessStrategy;

import com.android.server.display.brightness.strategy.OffloadBrightnessStrategy;
@@ -90,6 +91,8 @@ public final class DisplayBrightnessStrategySelectorTest { 
    @Mock

    private AutoBrightnessFallbackStrategy mAutoBrightnessFallbackStrategy;

    @Mock

    private FallbackBrightnessStrategy mFallbackBrightnessStrategy;

    @Mock

    private Resources mResources;

    @Mock

    private DisplayManagerFlags mDisplayManagerFlags;
@@ -155,6 +158,11 @@ public final class DisplayBrightnessStrategySelectorTest { 
                AutoBrightnessFallbackStrategy getAutoBrightnessFallbackStrategy() {

                    return mAutoBrightnessFallbackStrategy;

                }



                @Override

                FallbackBrightnessStrategy getFallbackBrightnessStrategy() {

                    return mFallbackBrightnessStrategy;

                }

            };



    @Rule
@@ -354,6 +362,25 @@ public final class DisplayBrightnessStrategySelectorTest { 
                                0.1f, false)));

    }



    @Test

    public void selectStrategy_selectsFallbackStrategyAsAnUltimateFallback() {

        when(mDisplayManagerFlags.isRefactorDisplayPowerControllerEnabled()).thenReturn(true);

        mDisplayBrightnessStrategySelector = new DisplayBrightnessStrategySelector(mContext,

                mInjector, DISPLAY_ID, mDisplayManagerFlags);

        DisplayManagerInternal.DisplayPowerRequest displayPowerRequest = mock(

                DisplayManagerInternal.DisplayPowerRequest.class);

        displayPowerRequest.policy = DisplayManagerInternal.DisplayPowerRequest.POLICY_BRIGHT;

        displayPowerRequest.screenBrightnessOverride = Float.NaN;

        when(mFollowerBrightnessStrategy.getBrightnessToFollow()).thenReturn(Float.NaN);

        when(mTemporaryBrightnessStrategy.getTemporaryScreenBrightness()).thenReturn(Float.NaN);

        when(mAutomaticBrightnessStrategy.shouldUseAutoBrightness()).thenReturn(false);

        when(mAutomaticBrightnessStrategy.isAutoBrightnessValid()).thenReturn(false);

        assertEquals(mDisplayBrightnessStrategySelector.selectStrategy(

                        new StrategySelectionRequest(displayPowerRequest, Display.STATE_ON,

                                0.1f, false)),

                mFallbackBrightnessStrategy);

    }



    @Test

    public void selectStrategyCallsPostProcessorForAllStrategies() {

        when(mDisplayManagerFlags.isRefactorDisplayPowerControllerEnabled()).thenReturn(true);