Introducing the notion of DisplayBrightnessController, and making it use (5909714e) · Commits · e / os / android_frameworks_base

core/java/android/hardware/display/DisplayManagerInternal.java

+1 −1

Original line number	Diff line number	Diff line
		@@ -412,7 +412,7 @@ public abstract class DisplayManagerInternal {
		* the PowerManagerService to focus on the global power state and not
		* have to micro-manage screen off animations, auto-brightness and other effects.
		*/
		public static final class DisplayPowerRequest {
		public static class DisplayPowerRequest {
		// Policy: Turn screen off as if the user pressed the power button
		// including playing a screen off animation if applicable.
		public static final int POLICY_OFF = 0;

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

+16 −19

Original line number	Diff line number	Diff line
		@@ -68,6 +68,7 @@ import com.android.server.am.BatteryStatsService;
		import com.android.server.display.RampAnimator.DualRampAnimator;
		import com.android.server.display.brightness.BrightnessEvent;
		import com.android.server.display.brightness.BrightnessReason;
		import com.android.server.display.brightness.DisplayBrightnessController;
		import com.android.server.display.color.ColorDisplayService.ColorDisplayServiceInternal;
		import com.android.server.display.color.ColorDisplayService.ReduceBrightColorsListener;
		import com.android.server.display.utils.SensorUtils;
		@@ -209,9 +210,6 @@ final class DisplayPowerController2 implements AutomaticBrightnessController.Cal
		// True if auto-brightness should be used.
		private boolean mUseSoftwareAutoBrightnessConfig;

		// True if should use light sensor to automatically determine doze screen brightness.
		private final boolean mAllowAutoBrightnessWhileDozingConfig;

		// Whether or not the color fade on screen on / off is enabled.
		private final boolean mColorFadeEnabled;

		@@ -348,6 +346,8 @@ final class DisplayPowerController2 implements AutomaticBrightnessController.Cal
		private final BrightnessEvent mLastBrightnessEvent;
		private final BrightnessEvent mTempBrightnessEvent;

		private final DisplayBrightnessController mDisplayBrightnessController;

		// Keeps a record of brightness changes for dumpsys.
		private RingBuffer<BrightnessEvent> mBrightnessEventRingBuffer;

		@@ -499,9 +499,6 @@ final class DisplayPowerController2 implements AutomaticBrightnessController.Cal
		mScreenBrightnessForVrRangeMinimum = clampAbsoluteBrightness(
		pm.getBrightnessConstraint(PowerManager.BRIGHTNESS_CONSTRAINT_TYPE_MINIMUM_VR));

		mAllowAutoBrightnessWhileDozingConfig = resources.getBoolean(
		R.bool.config_allowAutoBrightnessWhileDozing);

		loadBrightnessRampRates();
		mSkipScreenOnBrightnessRamp = resources.getBoolean(
		R.bool.config_skipScreenOnBrightnessRamp);
		@@ -565,6 +562,8 @@ final class DisplayPowerController2 implements AutomaticBrightnessController.Cal
		mBrightnessBucketsInDozeConfig = resources.getBoolean(
		R.bool.config_displayBrightnessBucketsInDoze);

		mDisplayBrightnessController =
		new DisplayBrightnessController(context, null, mDisplayId);
		mCurrentScreenBrightnessSetting = getScreenBrightnessSetting();
		mScreenBrightnessForVr = getScreenBrightnessForVrSetting();
		mAutoBrightnessAdjustment = getAutoBrightnessAdjustmentSetting();
		@@ -1113,7 +1112,6 @@ final class DisplayPowerController2 implements AutomaticBrightnessController.Cal
		final int previousPolicy;
		boolean mustInitialize = false;
		int brightnessAdjustmentFlags = 0;
		mBrightnessReasonTemp.set(null);
		mTempBrightnessEvent.reset();
		synchronized (mLock) {
		if (mStopped) {
		@@ -1149,7 +1147,6 @@ final class DisplayPowerController2 implements AutomaticBrightnessController.Cal
		// We might override this below based on other factors.
		// Initialise brightness as invalid.
		int state;
		float brightnessState = PowerManager.BRIGHTNESS_INVALID_FLOAT;
		boolean performScreenOffTransition = false;
		switch (mPowerRequest.policy) {
		case DisplayPowerRequest.POLICY_OFF:
		@@ -1162,10 +1159,6 @@ final class DisplayPowerController2 implements AutomaticBrightnessController.Cal
		} else {
		state = Display.STATE_DOZE;
		}
		if (!mAllowAutoBrightnessWhileDozingConfig) {
		brightnessState = mPowerRequest.dozeScreenBrightness;
		mBrightnessReasonTemp.setReason(BrightnessReason.REASON_DOZE);
		}
		break;
		case DisplayPowerRequest.POLICY_VR:
		state = Display.STATE_VR;
		@@ -1198,10 +1191,10 @@ final class DisplayPowerController2 implements AutomaticBrightnessController.Cal
		animateScreenStateChange(state, performScreenOffTransition);
		state = mPowerState.getScreenState();

		if (state == Display.STATE_OFF) {
		brightnessState = PowerManager.BRIGHTNESS_OFF_FLOAT;
		mBrightnessReasonTemp.setReason(BrightnessReason.REASON_SCREEN_OFF);
		}
		DisplayBrightnessState displayBrightnessState = mDisplayBrightnessController
		.updateBrightness(mPowerRequest, state);
		float brightnessState = displayBrightnessState.getBrightness();
		mBrightnessReasonTemp.set(displayBrightnessState.getBrightnessReason());

		// Always use the VR brightness when in the VR state.
		if (state == Display.STATE_VR) {
		@@ -1219,7 +1212,8 @@ final class DisplayPowerController2 implements AutomaticBrightnessController.Cal
		}

		final boolean autoBrightnessEnabledInDoze =
		mAllowAutoBrightnessWhileDozingConfig && Display.isDozeState(state);
		mDisplayBrightnessController.isAllowAutoBrightnessWhileDozingConfig()
		&& Display.isDozeState(state);
		final boolean autoBrightnessEnabled = mPowerRequest.useAutoBrightness
		&& (state == Display.STATE_ON \|\| autoBrightnessEnabledInDoze)
		&& Float.isNaN(brightnessState)
		@@ -2282,8 +2276,6 @@ final class DisplayPowerController2 implements AutomaticBrightnessController.Cal
		pw.println(" mScreenBrightnessForVrRangeMaximum=" + mScreenBrightnessForVrRangeMaximum);
		pw.println(" mScreenBrightnessForVrDefault=" + mScreenBrightnessForVrDefault);
		pw.println(" mUseSoftwareAutoBrightnessConfig=" + mUseSoftwareAutoBrightnessConfig);
		pw.println(" mAllowAutoBrightnessWhileDozingConfig="
		+ mAllowAutoBrightnessWhileDozingConfig);
		pw.println(" mSkipScreenOnBrightnessRamp=" + mSkipScreenOnBrightnessRamp);
		pw.println(" mColorFadeFadesConfig=" + mColorFadeFadesConfig);
		pw.println(" mColorFadeEnabled=" + mColorFadeEnabled);
		@@ -2383,6 +2375,11 @@ final class DisplayPowerController2 implements AutomaticBrightnessController.Cal
		mWakelockController.dumpLocal(pw);
		}

		pw.println();
		if (mDisplayBrightnessController != null) {
		mDisplayBrightnessController.dump(pw);
		}

		if (mDisplayPowerProximityStateController != null) {
		mDisplayPowerProximityStateController.dumpLocal(pw);
		}

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

0 → 100644

+96 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2022 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;

		import android.content.Context;
		import android.hardware.display.DisplayManagerInternal;
		import android.util.IndentingPrintWriter;

		import com.android.internal.annotations.VisibleForTesting;
		import com.android.server.display.DisplayBrightnessState;
		import com.android.server.display.brightness.strategy.DisplayBrightnessStrategy;

		import java.io.PrintWriter;

		/**
		* Deploys different DozeBrightnessStrategy to choose the current brightness for a specified
		* display. Applies the chosen brightness.
		*/
		public final class DisplayBrightnessController {
		private final int mDisplayId;
		// Selects an appropriate strategy based on the request provided by the clients.
		private DisplayBrightnessStrategySelector mDisplayBrightnessStrategySelector;

		/**
		* The constructor of DisplayBrightnessController.
		*/
		public DisplayBrightnessController(Context context, Injector injector, int displayId) {
		if (injector == null) {
		injector = new Injector();
		}
		mDisplayId = displayId;
		mDisplayBrightnessStrategySelector = injector.getDisplayBrightnessStrategySelector(context,
		displayId);
		}

		/**
		* Updates the display brightness. This delegates the responsibility of selecting an appropriate
		* strategy to DisplayBrightnessStrategySelector, which is then applied to evaluate the
		* DisplayBrightnessState. In the future,
		* 1. This will account for clamping the brightness if needed.
		* 2. This will notify the system about the updated brightness
		*
		* @param displayPowerRequest The request to update the brightness
		* @param targetDisplayState The target display state of the system
		*/
		public DisplayBrightnessState updateBrightness(
		DisplayManagerInternal.DisplayPowerRequest displayPowerRequest,
		int targetDisplayState) {
		DisplayBrightnessStrategy displayBrightnessStrategy =
		mDisplayBrightnessStrategySelector.selectStrategy(displayPowerRequest,
		targetDisplayState);
		return displayBrightnessStrategy.updateBrightness(displayPowerRequest);
		}

		/**
		* Returns a boolean flag indicating if the light sensor is to be used to decide the screen
		* brightness when dozing
		*/
		public boolean isAllowAutoBrightnessWhileDozingConfig() {
		return mDisplayBrightnessStrategySelector.isAllowAutoBrightnessWhileDozingConfig();
		}

		/**
		* Used to dump the state.
		*
		* @param writer The PrintWriter used to dump the state.
		*/
		public void dump(PrintWriter writer) {
		writer.println();
		writer.println("DisplayBrightnessController:");
		IndentingPrintWriter ipw = new IndentingPrintWriter(writer, " ");
		mDisplayBrightnessStrategySelector.dump(ipw);
		}

		@VisibleForTesting
		static class Injector {
		DisplayBrightnessStrategySelector getDisplayBrightnessStrategySelector(Context context,
		int displayId) {
		return new DisplayBrightnessStrategySelector(context, /* injector= */ null, displayId);
		}
		}
		}

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

0 → 100644

+145 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2022 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;

		import android.annotation.NonNull;
		import android.content.Context;
		import android.hardware.display.DisplayManagerInternal;
		import android.util.Slog;
		import android.view.Display;

		import com.android.internal.R;
		import com.android.internal.annotations.VisibleForTesting;
		import com.android.server.display.brightness.strategy.DisplayBrightnessStrategy;
		import com.android.server.display.brightness.strategy.DozeBrightnessStrategy;
		import com.android.server.display.brightness.strategy.InvalidBrightnessStrategy;
		import com.android.server.display.brightness.strategy.ScreenOffBrightnessStrategy;

		import java.io.PrintWriter;

		/**
		* This maintains the logic needed to decide the eligible display brightness strategy.
		*/
		public class DisplayBrightnessStrategySelector {
		private static final String TAG = "DisplayBrightnessStrategySelector";
		// True if light sensor is to be used to automatically determine doze screen brightness.
		private final boolean mAllowAutoBrightnessWhileDozingConfig;

		// 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
		// screen off state.
		private final ScreenOffBrightnessStrategy mScreenOffBrightnessStrategy;
		// The brightness strategy used to manage the brightness state when the request state is
		// invalid.
		private final InvalidBrightnessStrategy mInvalidBrightnessStrategy;

		// We take note of the old brightness strategy so that we can know when the strategy changes.
		private String mOldBrightnessStrategyName;

		private final int mDisplayId;

		/**
		* The constructor of DozeBrightnessStrategy.
		*/
		public DisplayBrightnessStrategySelector(Context context, Injector injector, int displayId) {
		if (injector == null) {
		injector = new Injector();
		}
		mDisplayId = displayId;
		mDozeBrightnessStrategy = injector.getDozeBrightnessStrategy();
		mScreenOffBrightnessStrategy = injector.getScreenOffBrightnessStrategy();
		mInvalidBrightnessStrategy = injector.getInvalidBrightnessStrategy();
		mAllowAutoBrightnessWhileDozingConfig = context.getResources().getBoolean(
		R.bool.config_allowAutoBrightnessWhileDozing);
		mOldBrightnessStrategyName = mInvalidBrightnessStrategy.getName();
		}

		/**
		* Selects the appropriate DisplayBrightnessStrategy based on the request and the display state
		* to which the display is transitioning
		*/
		@NonNull
		public DisplayBrightnessStrategy selectStrategy(
		DisplayManagerInternal.DisplayPowerRequest displayPowerRequest,
		int targetDisplayState) {
		DisplayBrightnessStrategy displayBrightnessStrategy = mInvalidBrightnessStrategy;
		if (targetDisplayState == Display.STATE_OFF) {
		displayBrightnessStrategy = mScreenOffBrightnessStrategy;
		} else if (shouldUseDozeBrightnessStrategy(displayPowerRequest)) {
		displayBrightnessStrategy = mDozeBrightnessStrategy;
		}

		if (!mOldBrightnessStrategyName.equals(displayBrightnessStrategy.getName())) {
		Slog.i(TAG,
		"Changing the DisplayBrightnessStrategy from " + mOldBrightnessStrategyName
		+ " to" + displayBrightnessStrategy.getName() + " for display "
		+ mDisplayId);
		mOldBrightnessStrategyName = displayBrightnessStrategy.getName();
		}
		return displayBrightnessStrategy;
		}

		/**
		* Returns a boolean flag indicating if the light sensor is to be used to decide the screen
		* brightness when dozing
		*/
		public boolean isAllowAutoBrightnessWhileDozingConfig() {
		return mAllowAutoBrightnessWhileDozingConfig;
		}

		/**
		* Dumps the state of this class.
		*/
		public void dump(PrintWriter writer) {
		writer.println();
		writer.println("DisplayBrightnessStrategySelector:");
		writer.println(
		" mAllowAutoBrightnessWhileDozingConfig=" + mAllowAutoBrightnessWhileDozingConfig);
		}

		/**
		* Validates if the conditions are met to qualify for the DozeBrightnessStrategy.
		*/
		private boolean shouldUseDozeBrightnessStrategy(
		DisplayManagerInternal.DisplayPowerRequest displayPowerRequest) {
		// We are not checking the targetDisplayState, but rather relying on the policy because
		// a user can define a different display state(displayPowerRequest.dozeScreenState) too
		// in the request with the Doze policy
		if (displayPowerRequest.policy == DisplayManagerInternal.DisplayPowerRequest.POLICY_DOZE) {
		if (!mAllowAutoBrightnessWhileDozingConfig) {
		return true;
		}
		}
		return false;
		}

		@VisibleForTesting
		static class Injector {
		ScreenOffBrightnessStrategy getScreenOffBrightnessStrategy() {
		return new ScreenOffBrightnessStrategy();
		}

		DozeBrightnessStrategy getDozeBrightnessStrategy() {
		return new DozeBrightnessStrategy();
		}

		InvalidBrightnessStrategy getInvalidBrightnessStrategy() {
		return new InvalidBrightnessStrategy();
		}
		}
		}

services/core/java/com/android/server/display/brightness/strategy/DisplayBrightnessModeStrategy.java→services/core/java/com/android/server/display/brightness/strategy/DisplayBrightnessStrategy.java

+43 −0

Original line number	Diff line number	Diff line
		@@ -16,35 +16,28 @@

		package com.android.server.display.brightness.strategy;

		import android.annotation.NonNull;
		import android.hardware.display.DisplayManagerInternal;

		import com.android.server.display.DisplayBrightnessState;

		import java.io.PrintWriter;

		/**
		* An interface to define the general skeleton of how a BrightnessModeStrategy should look like
		* This is responsible for deciding the DisplayBrightnessState that the display should change to,
		* not taking into account clamping that might be needed
		* Decides the DisplayBrighntessState that the display should change to based on strategy-specific
		* logic within each implementation. Clamping should be done outside of DisplayBrightnessStrategy if
		* not an integral part of the strategy.
		*/
		public interface DisplayBrightnessModeStrategy {
		public interface DisplayBrightnessStrategy {
		/**
		* Decides the DisplayBrightnessState that the system should change to.
		*
		* @param displayPowerRequest The request to evaluate the updated brightness
		* @param displayState The target displayState to which the system should
		* change to after processing the request
		* @param displayBrightnessStateBuilder The DisplayBrightnessStateBuilder, consisting of
		* DisplayBrightnessState that have been constructed so far
		*/
		DisplayBrightnessState.Builder updateBrightness(
		DisplayManagerInternal.DisplayPowerRequest displayPowerRequest, int displayState,
		DisplayBrightnessState.Builder displayBrightnessStateBuilder);
		DisplayBrightnessState updateBrightness(
		DisplayManagerInternal.DisplayPowerRequest displayPowerRequest);

		/**
		* Used to dump the state.
		*
		* @param writer The PrintWriter used to dump the state.
		* Returns the name of the Strategy
		*/
		void dump(PrintWriter writer);
		@NonNull
		String getName();
		}