Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Move DisplayPowerRequest logic into PowerGroup." into tm-dev

Browse Source
This commit is contained in:
TreeHugger Robot
2022-03-03 08:52:24 +00:00
committed by Android (Google) Code Review
parent 4415e6e1e3 8f2b1f4184
commit accbe584f2
4 changed files with 670 additions and 183 deletions
Download Patch File Download Diff File Expand all files Collapse all files

151
services/core/java/com/android/server/power/PowerGroup.java
View File

@@ -22,12 +22,21 @@ import static android.os.PowerManagerInternal.WAKEFULNESS_DOZING;
import static android.os.PowerManagerInternal.WAKEFULNESS_DREAMING;
import static android.os.PowerManagerInternal.isInteractive;
import static com.android.server.power.PowerManagerService.USER_ACTIVITY_SCREEN_BRIGHT;
import static com.android.server.power.PowerManagerService.WAKE_LOCK_DOZE;
import static com.android.server.power.PowerManagerService.WAKE_LOCK_DRAW;
import static com.android.server.power.PowerManagerService.WAKE_LOCK_SCREEN_BRIGHT;
import android.hardware.display.DisplayManagerInternal;
import android.hardware.display.DisplayManagerInternal.DisplayPowerRequest;
import android.os.PowerManager;
import android.os.PowerSaveState;
import android.os.Trace;
import android.util.Slog;
import android.view.Display;
import com.android.internal.annotations.VisibleForTesting;
/**
* Used to store power related requests to every display in a
* {@link com.android.server.display.DisplayGroup}.
@@ -40,8 +49,11 @@ public class PowerGroup {
private static final String TAG = PowerGroup.class.getSimpleName();
private static final boolean DEBUG = false;
private final DisplayPowerRequest mDisplayPowerRequest;
@VisibleForTesting
final DisplayPowerRequest mDisplayPowerRequest = new DisplayPowerRequest();
private final PowerGroupListener mWakefulnessListener;
private final Notifier mNotifier;
private final DisplayManagerInternal mDisplayManagerInternal;
private final boolean mSupportsSandman;
private final int mGroupId;
/** True if DisplayManagerService has applied all the latest display states that were requested
@@ -63,12 +75,13 @@ public class PowerGroup {
/** Timestamp (milliseconds since boot) of the last time the power group was put to sleep. */
private long mLastSleepTime;
PowerGroup(int groupId, PowerGroupListener wakefulnessListener,
DisplayPowerRequest displayPowerRequest, int wakefulness, boolean ready,
PowerGroup(int groupId, PowerGroupListener wakefulnessListener, Notifier notifier,
DisplayManagerInternal displayManagerInternal, int wakefulness, boolean ready,
boolean supportsSandman, long eventTime) {
mGroupId = groupId;
mWakefulnessListener = wakefulnessListener;
mDisplayPowerRequest = displayPowerRequest;
mNotifier = notifier;
mDisplayManagerInternal = displayManagerInternal;
mWakefulness = wakefulness;
mReady = ready;
mSupportsSandman = supportsSandman;
@@ -76,18 +89,17 @@ public class PowerGroup {
mLastSleepTime = eventTime;
}
PowerGroup(int wakefulness, PowerGroupListener wakefulnessListener, long eventTime) {
PowerGroup(int wakefulness, PowerGroupListener wakefulnessListener, Notifier notifier,
DisplayManagerInternal displayManagerInternal, long eventTime) {
mGroupId = Display.DEFAULT_DISPLAY_GROUP;
mWakefulnessListener = wakefulnessListener;
mDisplayPowerRequest = new DisplayPowerRequest();
mNotifier = notifier;
mDisplayManagerInternal = displayManagerInternal;
mWakefulness = wakefulness;
mReady = false;
mSupportsSandman = true;
mLastWakeTime = eventTime;
mLastSleepTime = eventTime; }
DisplayPowerRequest getDisplayPowerRequestLocked() {
return mDisplayPowerRequest;
mLastSleepTime = eventTime;
}
long getLastWakeTimeLocked() {
@@ -261,6 +273,23 @@ public class PowerGroup {
return mUserActivitySummary;
}
public boolean isPolicyBrightLocked() {
return mDisplayPowerRequest.policy == DisplayPowerRequest.POLICY_BRIGHT;
}
public boolean isPolicyDimLocked() {
return mDisplayPowerRequest.policy == DisplayPowerRequest.POLICY_DIM;
}
public boolean isPolicyVrLocked() {
return mDisplayPowerRequest.isVr();
}
public boolean isBrightOrDimLocked() {
return mDisplayPowerRequest.isBrightOrDim();
}
public void setUserActivitySummaryLocked(int summary) {
mUserActivitySummary = summary;
}
@@ -281,6 +310,108 @@ public class PowerGroup {
return mSupportsSandman;
}
/**
* Return true if we must keep a suspend blocker active on behalf of a power group.
* We do so if the screen is on or is in transition between states.
*/
boolean needSuspendBlockerLocked(boolean proximityPositive,
boolean suspendWhenScreenOffDueToProximityConfig) {
if (isBrightOrDimLocked()) {
// If we asked for the screen to be on but it is off due to the proximity
// sensor then we may suspend but only if the configuration allows it.
// On some hardware it may not be safe to suspend because the proximity
// sensor may not be correctly configured as a wake-up source.
if (!mDisplayPowerRequest.useProximitySensor || !proximityPositive
|| !suspendWhenScreenOffDueToProximityConfig) {
return true;
}
}
if (mDisplayPowerRequest.policy == DisplayPowerRequest.POLICY_DOZE
&& mDisplayPowerRequest.dozeScreenState == Display.STATE_ON) {
// Although we are in DOZE and would normally allow the device to suspend,
// the doze service has explicitly requested the display to remain in the ON
// state which means we should hold the display suspend blocker.
return true;
}
return false;
}
@VisibleForTesting
int getDesiredScreenPolicyLocked(boolean quiescent, boolean dozeAfterScreenOff,
boolean vrModeEnabled, boolean bootCompleted, boolean screenBrightnessBoostInProgress) {
final int wakefulness = getWakefulnessLocked();
final int wakeLockSummary = getWakeLockSummaryLocked();
if (wakefulness == WAKEFULNESS_ASLEEP || quiescent) {
return DisplayPowerRequest.POLICY_OFF;
} else if (wakefulness == WAKEFULNESS_DOZING) {
if ((wakeLockSummary & WAKE_LOCK_DOZE) != 0) {
return DisplayPowerRequest.POLICY_DOZE;
}
if (dozeAfterScreenOff) {
return DisplayPowerRequest.POLICY_OFF;
}
// Fall through and preserve the current screen policy if not configured to
// doze after screen off. This causes the screen off transition to be skipped.
}
// It is important that POLICY_VR check happens after the wakefulness checks above so
// that VR-mode does not prevent displays from transitioning to the correct state when
// dozing or sleeping.
if (vrModeEnabled) {
return DisplayPowerRequest.POLICY_VR;
}
if ((wakeLockSummary & WAKE_LOCK_SCREEN_BRIGHT) != 0
|| !bootCompleted
|| (getUserActivitySummaryLocked() & USER_ACTIVITY_SCREEN_BRIGHT) != 0
|| screenBrightnessBoostInProgress) {
return DisplayPowerRequest.POLICY_BRIGHT;
}
return DisplayPowerRequest.POLICY_DIM;
}
int getPolicyLocked() {
return mDisplayPowerRequest.policy;
}
boolean updateLocked(float screenBrightnessOverride, boolean autoBrightness,
boolean useProximitySensor, boolean boostScreenBrightness, int dozeScreenState,
float dozeScreenBrightness, boolean overrideDrawWakeLock,
PowerSaveState powerSaverState, boolean quiescent, boolean dozeAfterScreenOff,
boolean vrModeEnabled, boolean bootCompleted, boolean screenBrightnessBoostInProgress,
boolean waitForNegativeProximity) {
mDisplayPowerRequest.policy = getDesiredScreenPolicyLocked(quiescent, dozeAfterScreenOff,
vrModeEnabled, bootCompleted, screenBrightnessBoostInProgress);
mDisplayPowerRequest.screenBrightnessOverride = screenBrightnessOverride;
mDisplayPowerRequest.useAutoBrightness = autoBrightness;
mDisplayPowerRequest.useProximitySensor = useProximitySensor;
mDisplayPowerRequest.boostScreenBrightness = boostScreenBrightness;
if (mDisplayPowerRequest.policy == DisplayPowerRequest.POLICY_DOZE) {
mDisplayPowerRequest.dozeScreenState = dozeScreenState;
if ((getWakeLockSummaryLocked() & WAKE_LOCK_DRAW) != 0 && !overrideDrawWakeLock) {
if (mDisplayPowerRequest.dozeScreenState == Display.STATE_DOZE_SUSPEND) {
mDisplayPowerRequest.dozeScreenState = Display.STATE_DOZE;
}
if (mDisplayPowerRequest.dozeScreenState == Display.STATE_ON_SUSPEND) {
mDisplayPowerRequest.dozeScreenState = Display.STATE_ON;
}
}
mDisplayPowerRequest.dozeScreenBrightness = dozeScreenBrightness;
} else {
mDisplayPowerRequest.dozeScreenState = Display.STATE_UNKNOWN;
mDisplayPowerRequest.dozeScreenBrightness = PowerManager.BRIGHTNESS_INVALID_FLOAT;
}
mDisplayPowerRequest.lowPowerMode = powerSaverState.batterySaverEnabled;
mDisplayPowerRequest.screenLowPowerBrightnessFactor = powerSaverState.brightnessFactor;
boolean ready = mDisplayManagerInternal.requestPowerState(mGroupId, mDisplayPowerRequest,
waitForNegativeProximity);
mNotifier.onScreenPolicyUpdate(mGroupId, mDisplayPowerRequest.policy);
return ready;
}
protected interface PowerGroupListener {
/**
* Informs the recipient about a wakefulness change of a {@link PowerGroup}.

227
services/core/java/com/android/server/power/PowerManagerService.java
View File

@@ -54,7 +54,6 @@ import android.hardware.SystemSensorManager;
import android.hardware.devicestate.DeviceStateManager;
import android.hardware.display.AmbientDisplayConfiguration;
import android.hardware.display.DisplayManagerInternal;
import android.hardware.display.DisplayManagerInternal.DisplayPowerRequest;
import android.hardware.power.Boost;
import android.hardware.power.Mode;
import android.net.Uri;
@@ -196,19 +195,19 @@ public final class PowerManagerService extends SystemService
private static final int DIRTY_DISPLAY_GROUP_WAKEFULNESS = 1 << 16;
// Summarizes the state of all active wakelocks.
private static final int WAKE_LOCK_CPU = 1 << 0;
private static final int WAKE_LOCK_SCREEN_BRIGHT = 1 << 1;
private static final int WAKE_LOCK_SCREEN_DIM = 1 << 2;
private static final int WAKE_LOCK_BUTTON_BRIGHT = 1 << 3;
private static final int WAKE_LOCK_PROXIMITY_SCREEN_OFF = 1 << 4;
private static final int WAKE_LOCK_STAY_AWAKE = 1 << 5; // only set if already awake
private static final int WAKE_LOCK_DOZE = 1 << 6;
private static final int WAKE_LOCK_DRAW = 1 << 7;
static final int WAKE_LOCK_CPU = 1 << 0;
static final int WAKE_LOCK_SCREEN_BRIGHT = 1 << 1;
static final int WAKE_LOCK_SCREEN_DIM = 1 << 2;
static final int WAKE_LOCK_BUTTON_BRIGHT = 1 << 3;
static final int WAKE_LOCK_PROXIMITY_SCREEN_OFF = 1 << 4;
static final int WAKE_LOCK_STAY_AWAKE = 1 << 5; // only set if already awake
static final int WAKE_LOCK_DOZE = 1 << 6;
static final int WAKE_LOCK_DRAW = 1 << 7;
// Summarizes the user activity state.
private static final int USER_ACTIVITY_SCREEN_BRIGHT = 1 << 0;
private static final int USER_ACTIVITY_SCREEN_DIM = 1 << 1;
private static final int USER_ACTIVITY_SCREEN_DREAM = 1 << 2;
static final int USER_ACTIVITY_SCREEN_BRIGHT = 1 << 0;
static final int USER_ACTIVITY_SCREEN_DIM = 1 << 1;
static final int USER_ACTIVITY_SCREEN_DREAM = 1 << 2;
// Default timeout in milliseconds. This is only used until the settings
// provider populates the actual default value (R.integer.def_screen_off_timeout).
@@ -696,7 +695,8 @@ public final class PowerManagerService extends SystemService
final PowerGroup powerGroup = new PowerGroup(
groupId,
mPowerGroupWakefulnessChangeListener,
new DisplayPowerRequest(),
mNotifier,
mDisplayManagerInternal,
WAKEFULNESS_AWAKE,
/* ready= */ false,
supportsSandman,
@@ -1214,12 +1214,6 @@ public final class PowerManagerService extends SystemService
mPolicy = getLocalService(WindowManagerPolicy.class);
mBatteryManagerInternal = getLocalService(BatteryManagerInternal.class);
mAttentionDetector.systemReady(mContext);
mPowerGroups.append(Display.DEFAULT_DISPLAY_GROUP,
new PowerGroup(WAKEFULNESS_AWAKE, mPowerGroupWakefulnessChangeListener,
mClock.uptimeMillis()));
DisplayGroupPowerChangeListener displayGroupPowerChangeListener =
new DisplayGroupPowerChangeListener();
mDisplayManagerInternal.registerDisplayGroupListener(displayGroupPowerChangeListener);
SensorManager sensorManager = new SystemSensorManager(mContext, mHandler.getLooper());
@@ -1230,6 +1224,13 @@ public final class PowerManagerService extends SystemService
mInjector.createSuspendBlocker(this, "PowerManagerService.Broadcasts"),
mPolicy, mFaceDownDetector, mScreenUndimDetector);
mPowerGroups.append(Display.DEFAULT_DISPLAY_GROUP,
new PowerGroup(WAKEFULNESS_AWAKE, mPowerGroupWakefulnessChangeListener,
mNotifier, mDisplayManagerInternal, mClock.uptimeMillis()));
DisplayGroupPowerChangeListener displayGroupPowerChangeListener =
new DisplayGroupPowerChangeListener();
mDisplayManagerInternal.registerDisplayGroupListener(displayGroupPowerChangeListener);
mWirelessChargerDetector = mInjector.createWirelessChargerDetector(sensorManager,
mInjector.createSuspendBlocker(
this, "PowerManagerService.WirelessChargerDetector"),
@@ -2242,7 +2243,7 @@ public final class PowerManagerService extends SystemService
@GuardedBy("mLock")
private void finishWakefulnessChangeIfNeededLocked() {
if (mWakefulnessChanging && areAllDisplaysReadyLocked()) {
if (mWakefulnessChanging && areAllPowerGroupsReadyLocked()) {
if (getGlobalWakefulnessLocked() == WAKEFULNESS_DOZING
&& (mWakeLockSummary & WAKE_LOCK_DOZE) == 0) {
return; // wait until dream has enabled dozing
@@ -2259,9 +2260,12 @@ public final class PowerManagerService extends SystemService
}
}
/** Returns {@code true} if every display has its requested state matching its actual state. */
/**
* Returns {@code true} if all {@link PowerGroup}s are ready, i.e. every display has its
* requested state matching its actual state.
*/
@GuardedBy("mLock")
private boolean areAllDisplaysReadyLocked() {
private boolean areAllPowerGroupsReadyLocked() {
final int size = mPowerGroups.size();
for (int i = 0; i < size; i++) {
if (!mPowerGroups.valueAt(i).isReadyLocked()) {
@@ -2318,11 +2322,11 @@ public final class PowerManagerService extends SystemService
// Phase 2: Lock profiles that became inactive/not kept awake.
updateProfilesLocked(now);
// Phase 3: Update display power state.
final boolean displayBecameReady = updateDisplayPowerStateLocked(dirtyPhase2);
// Phase 3: Update power state of all PowerGroups.
final boolean powerGroupsBecameReady = updatePowerGroupsLocked(dirtyPhase2);
// Phase 4: Update dream state (depends on display ready signal).
updateDreamLocked(dirtyPhase2, displayBecameReady);
// Phase 4: Update dream state (depends on power group ready signal).
updateDreamLocked(dirtyPhase2, powerGroupsBecameReady);
// Phase 5: Send notifications, if needed.
finishWakefulnessChangeIfNeededLocked();
@@ -2513,7 +2517,7 @@ public final class PowerManagerService extends SystemService
final int numWakeLocks = mWakeLocks.size();
for (int i = 0; i < numWakeLocks; i++) {
final WakeLock wakeLock = mWakeLocks.get(i);
final Integer groupId = wakeLock.getDisplayGroupId();
final Integer groupId = wakeLock.getPowerGroupId();
// a wakelock with an invalid group ID should affect all groups
if (groupId == null || (groupId != Display.INVALID_DISPLAY_GROUP
&& !mPowerGroups.contains(groupId))) {
@@ -2727,12 +2731,9 @@ public final class PowerManagerService extends SystemService
>= powerGroup.getLastWakeTimeLocked()) {
groupNextTimeout = lastUserActivityTimeNoChangeLights + screenOffTimeout;
if (now < groupNextTimeout) {
final DisplayPowerRequest displayPowerRequest =
powerGroup.getDisplayPowerRequestLocked();
if (displayPowerRequest.policy == DisplayPowerRequest.POLICY_BRIGHT
|| displayPowerRequest.policy == DisplayPowerRequest.POLICY_VR) {
if (powerGroup.isPolicyBrightLocked() || powerGroup.isPolicyVrLocked()) {
groupUserActivitySummary = USER_ACTIVITY_SCREEN_BRIGHT;
} else if (displayPowerRequest.policy == DisplayPowerRequest.POLICY_DIM) {
} else if (powerGroup.isPolicyDimLocked()) {
groupUserActivitySummary = USER_ACTIVITY_SCREEN_DIM;
}
}
@@ -3102,7 +3103,7 @@ public final class PowerManagerService extends SystemService
* Determines whether to post a message to the sandman to update the dream state.
*/
@GuardedBy("mLock")
private void updateDreamLocked(int dirty, boolean displayBecameReady) {
private void updateDreamLocked(int dirty, boolean powerGroupBecameReady) {
if ((dirty & (DIRTY_WAKEFULNESS
| DIRTY_USER_ACTIVITY
| DIRTY_ACTUAL_DISPLAY_POWER_STATE_UPDATED
@@ -3113,8 +3114,8 @@ public final class PowerManagerService extends SystemService
| DIRTY_IS_POWERED
| DIRTY_STAY_ON
| DIRTY_PROXIMITY_POSITIVE
| DIRTY_BATTERY_STATE)) != 0 || displayBecameReady) {
if (areAllDisplaysReadyLocked()) {
| DIRTY_BATTERY_STATE)) != 0 || powerGroupBecameReady) {
if (areAllPowerGroupsReadyLocked()) {
scheduleSandmanLocked();
}
}
@@ -3266,13 +3267,12 @@ public final class PowerManagerService extends SystemService
*/
@GuardedBy("mLock")
private boolean canDreamLocked(final PowerGroup powerGroup) {
final DisplayPowerRequest displayPowerRequest = powerGroup.getDisplayPowerRequestLocked();
if (!mBootCompleted
|| getGlobalWakefulnessLocked() != WAKEFULNESS_DREAMING
|| !mDreamsSupportedConfig
|| !mDreamsEnabledSetting
|| !displayPowerRequest.isBrightOrDim()
|| displayPowerRequest.isVr()
|| !(powerGroup.isBrightOrDimLocked())
|| powerGroup.isPolicyVrLocked()
|| (powerGroup.getUserActivitySummaryLocked() & (USER_ACTIVITY_SCREEN_BRIGHT
| USER_ACTIVITY_SCREEN_DIM | USER_ACTIVITY_SCREEN_DREAM)) == 0) {
return false;
@@ -3303,24 +3303,24 @@ public final class PowerManagerService extends SystemService
}
/**
* Updates the display power state asynchronously.
* When the update is finished, the ready state of the displays will be updated. The display
* controllers post a message to tell us when the actual display power state
* Updates the state of all {@link PowerGroup}s asynchronously.
* When the update is finished, the ready state of the {@link PowerGroup} will be updated.
* The display controllers post a message to tell us when the actual display power state
* has been updated so we come back here to double-check and finish up.
*
* This function recalculates the display power state each time.
* This function recalculates the {@link PowerGroup} state each time.
*
* @return {@code true} if all displays became ready; {@code false} otherwise
* @return {@code true} if all {@link PowerGroup}s became ready; {@code false} otherwise
*/
@GuardedBy("mLock")
private boolean updateDisplayPowerStateLocked(int dirty) {
final boolean oldDisplayReady = areAllDisplaysReadyLocked();
private boolean updatePowerGroupsLocked(int dirty) {
final boolean oldPowerGroupsReady = areAllPowerGroupsReadyLocked();
if ((dirty & (DIRTY_WAKE_LOCKS | DIRTY_USER_ACTIVITY | DIRTY_WAKEFULNESS
| DIRTY_ACTUAL_DISPLAY_POWER_STATE_UPDATED | DIRTY_BOOT_COMPLETED
| DIRTY_SETTINGS | DIRTY_SCREEN_BRIGHTNESS_BOOST | DIRTY_VR_MODE_CHANGED |
DIRTY_QUIESCENT | DIRTY_DISPLAY_GROUP_WAKEFULNESS)) != 0) {
if ((dirty & DIRTY_QUIESCENT) != 0) {
if (areAllDisplaysReadyLocked()) {
if (areAllPowerGroupsReadyLocked()) {
sQuiescent = false;
} else {
mDirty |= DIRTY_QUIESCENT;
@@ -3330,9 +3330,6 @@ public final class PowerManagerService extends SystemService
for (int idx = 0; idx < mPowerGroups.size(); idx++) {
final PowerGroup powerGroup = mPowerGroups.valueAt(idx);
final int groupId = powerGroup.getGroupId();
final DisplayPowerRequest displayPowerRequest =
powerGroup.getDisplayPowerRequestLocked();
displayPowerRequest.policy = getDesiredScreenPolicyLocked(powerGroup);
// Determine appropriate screen brightness and auto-brightness adjustments.
final boolean autoBrightness;
@@ -3350,43 +3347,19 @@ public final class PowerManagerService extends SystemService
== Settings.System.SCREEN_BRIGHTNESS_MODE_AUTOMATIC);
screenBrightnessOverride = PowerManager.BRIGHTNESS_INVALID_FLOAT;
}
// Update display power request.
displayPowerRequest.screenBrightnessOverride = screenBrightnessOverride;
displayPowerRequest.useAutoBrightness = autoBrightness;
displayPowerRequest.useProximitySensor = shouldUseProximitySensorLocked();
displayPowerRequest.boostScreenBrightness = shouldBoostScreenBrightness();
updatePowerRequestFromBatterySaverPolicy(displayPowerRequest);
if (displayPowerRequest.policy == DisplayPowerRequest.POLICY_DOZE) {
displayPowerRequest.dozeScreenState = mDozeScreenStateOverrideFromDreamManager;
if ((powerGroup.getWakeLockSummaryLocked() & WAKE_LOCK_DRAW) != 0
&& !mDrawWakeLockOverrideFromSidekick) {
if (displayPowerRequest.dozeScreenState == Display.STATE_DOZE_SUSPEND) {
displayPowerRequest.dozeScreenState = Display.STATE_DOZE;
}
if (displayPowerRequest.dozeScreenState == Display.STATE_ON_SUSPEND) {
displayPowerRequest.dozeScreenState = Display.STATE_ON;
}
}
displayPowerRequest.dozeScreenBrightness =
mDozeScreenBrightnessOverrideFromDreamManagerFloat;
} else {
displayPowerRequest.dozeScreenState = Display.STATE_UNKNOWN;
displayPowerRequest.dozeScreenBrightness =
PowerManager.BRIGHTNESS_INVALID_FLOAT;
}
final boolean ready = mDisplayManagerInternal.requestPowerState(groupId,
displayPowerRequest, mRequestWaitForNegativeProximity);
mNotifier.onScreenPolicyUpdate(powerGroup.getGroupId(), displayPowerRequest.policy);
boolean ready = powerGroup.updateLocked(screenBrightnessOverride, autoBrightness,
shouldUseProximitySensorLocked(), shouldBoostScreenBrightness(),
mDozeScreenStateOverrideFromDreamManager,
mDozeScreenBrightnessOverrideFromDreamManagerFloat,
mDrawWakeLockOverrideFromSidekick,
mBatterySaverPolicy.getBatterySaverPolicy(ServiceType.SCREEN_BRIGHTNESS),
sQuiescent, mDozeAfterScreenOff, mIsVrModeEnabled, mBootCompleted,
mScreenBrightnessBoostInProgress, mRequestWaitForNegativeProximity);
int wakefulness = powerGroup.getWakefulnessLocked();
if (DEBUG_SPEW) {
Slog.d(TAG, "updateDisplayPowerStateLocked: displayReady=" + ready
+ ", groupId=" + groupId
+ ", policy=" + policyToString(displayPowerRequest.policy)
+ ", policy=" + policyToString(powerGroup.getPolicyLocked())
+ ", mWakefulness="
+ PowerManagerInternal.wakefulnessToString(wakefulness)
+ ", mWakeLockSummary=0x" + Integer.toHexString(
@@ -3394,9 +3367,8 @@ public final class PowerManagerService extends SystemService
+ ", mUserActivitySummary=0x" + Integer.toHexString(
powerGroup.getUserActivitySummaryLocked())
+ ", mBootCompleted=" + mBootCompleted
+ ", screenBrightnessOverride="
+ displayPowerRequest.screenBrightnessOverride
+ ", useAutoBrightness=" + displayPowerRequest.useAutoBrightness
+ ", screenBrightnessOverride=" + screenBrightnessOverride
+ ", useAutoBrightness=" + autoBrightness
+ ", mScreenBrightnessBoostInProgress="
+ mScreenBrightnessBoostInProgress
+ ", mIsVrModeEnabled= " + mIsVrModeEnabled
@@ -3420,7 +3392,7 @@ public final class PowerManagerService extends SystemService
mRequestWaitForNegativeProximity = false;
}
return areAllDisplaysReadyLocked() && !oldDisplayReady;
return areAllPowerGroupsReadyLocked() && !oldPowerGroupsReady;
}
@GuardedBy("mLock")
@@ -3457,40 +3429,9 @@ public final class PowerManagerService extends SystemService
@VisibleForTesting
@GuardedBy("mLock")
int getDesiredScreenPolicyLocked(int groupId) {
return getDesiredScreenPolicyLocked(mPowerGroups.get(groupId));
}
int getDesiredScreenPolicyLocked(final PowerGroup powerGroup) {
final int wakefulness = powerGroup.getWakefulnessLocked();
final int wakeLockSummary = powerGroup.getWakeLockSummaryLocked();
if (wakefulness == WAKEFULNESS_ASLEEP || sQuiescent) {
return DisplayPowerRequest.POLICY_OFF;
} else if (wakefulness == WAKEFULNESS_DOZING) {
if ((wakeLockSummary & WAKE_LOCK_DOZE) != 0) {
return DisplayPowerRequest.POLICY_DOZE;
}
if (mDozeAfterScreenOff) {
return DisplayPowerRequest.POLICY_OFF;
}
// Fall through and preserve the current screen policy if not configured to
// doze after screen off. This causes the screen off transition to be skipped.
}
// It is important that POLICY_VR check happens after the wakefulness checks above so
// that VR-mode does not prevent displays from transitioning to the correct state when
// dozing or sleeping.
if (mIsVrModeEnabled) {
return DisplayPowerRequest.POLICY_VR;
}
if ((wakeLockSummary & WAKE_LOCK_SCREEN_BRIGHT) != 0
|| !mBootCompleted
|| (powerGroup.getUserActivitySummaryLocked() & USER_ACTIVITY_SCREEN_BRIGHT) != 0
|| mScreenBrightnessBoostInProgress) {
return DisplayPowerRequest.POLICY_BRIGHT;
}
return DisplayPowerRequest.POLICY_DIM;
return mPowerGroups.get(groupId).getDesiredScreenPolicyLocked(sQuiescent,
mDozeAfterScreenOff, mIsVrModeEnabled, mBootCompleted,
mScreenBrightnessBoostInProgress);
}
private final DisplayManagerInternal.DisplayPowerCallbacks mDisplayPowerCallbacks =
@@ -3578,11 +3519,11 @@ public final class PowerManagerService extends SystemService
@GuardedBy("mLock")
private void updateSuspendBlockerLocked() {
final boolean needWakeLockSuspendBlocker = ((mWakeLockSummary & WAKE_LOCK_CPU) != 0);
final boolean needDisplaySuspendBlocker = needDisplaySuspendBlockerLocked();
final boolean needDisplaySuspendBlocker = needSuspendBlockerLocked();
final boolean autoSuspend = !needDisplaySuspendBlocker;
boolean interactive = false;
for (int idx = 0; idx < mPowerGroups.size() && !interactive; idx++) {
interactive = mPowerGroups.valueAt(idx).getDisplayPowerRequestLocked().isBrightOrDim();
interactive = mPowerGroups.valueAt(idx).isBrightOrDimLocked();
}
// Disable auto-suspend if needed.
@@ -3617,7 +3558,7 @@ public final class PowerManagerService extends SystemService
// until the display is actually ready so that all transitions have
// completed. This is probably a good sign that things have gotten
// too tangled over here...
if (interactive || areAllDisplaysReadyLocked()) {
if (interactive || areAllPowerGroupsReadyLocked()) {
setHalInteractiveModeLocked(interactive);
}
}
@@ -3643,12 +3584,11 @@ public final class PowerManagerService extends SystemService
}
/**
* Return true if we must keep a suspend blocker active on behalf of the display.
* We do so if the screen is on or is in transition between states.
* Return true if we must keep a suspend blocker active on behalf of a power group.
*/
@GuardedBy("mLock")
private boolean needDisplaySuspendBlockerLocked() {
if (!areAllDisplaysReadyLocked()) {
private boolean needSuspendBlockerLocked() {
if (!areAllPowerGroupsReadyLocked()) {
return true;
}
@@ -3666,24 +3606,9 @@ public final class PowerManagerService extends SystemService
}
for (int idx = 0; idx < mPowerGroups.size(); idx++) {
final DisplayPowerRequest displayPowerRequest =
mPowerGroups.valueAt(idx).getDisplayPowerRequestLocked();
if (displayPowerRequest.isBrightOrDim()) {
// If we asked for the screen to be on but it is off due to the proximity
// sensor then we may suspend but only if the configuration allows it.
// On some hardware it may not be safe to suspend because the proximity
// sensor may not be correctly configured as a wake-up source.
if (!displayPowerRequest.useProximitySensor || !mProximityPositive
|| !mSuspendWhenScreenOffDueToProximityConfig) {
return true;
}
}
if (displayPowerRequest.policy == DisplayPowerRequest.POLICY_DOZE
&& displayPowerRequest.dozeScreenState == Display.STATE_ON) {
// Although we are in DOZE and would normally allow the device to suspend,
// the doze service has explicitly requested the display to remain in the ON
// state which means we should hold the display suspend blocker.
final PowerGroup powerGroup = mPowerGroups.valueAt(idx);
if (powerGroup.needSuspendBlockerLocked(mProximityPositive,
mSuspendWhenScreenOffDueToProximityConfig)) {
return true;
}
}
@@ -3832,14 +3757,6 @@ public final class PowerManagerService extends SystemService
}
}
@VisibleForTesting
void updatePowerRequestFromBatterySaverPolicy(DisplayPowerRequest displayPowerRequest) {
PowerSaveState state = mBatterySaverPolicy.
getBatterySaverPolicy(ServiceType.SCREEN_BRIGHTNESS);
displayPowerRequest.lowPowerMode = state.batterySaverEnabled;
displayPowerRequest.screenLowPowerBrightnessFactor = state.brightnessFactor;
}
void setStayOnSettingInternal(int val) {
Settings.Global.putInt(mContext.getContentResolver(),
Settings.Global.STAY_ON_WHILE_PLUGGED_IN, val);
@@ -5170,8 +5087,8 @@ public final class PowerManagerService extends SystemService
mWorkSource = copyWorkSource(workSource);
}
/** Returns the DisplayGroup Id of this wakeLock or {@code null} if info not available. */
public Integer getDisplayGroupId() {
/** Returns the PowerGroup Id of this wakeLock or {@code null} if info not available.. */
public Integer getPowerGroupId() {
if (!mSystemReady || mDisplayId == Display.INVALID_DISPLAY) {
return Display.INVALID_DISPLAY_GROUP;
}

463
services/tests/servicestests/src/com/android/server/power/PowerGroupTest.java
View File

@@ -17,6 +17,11 @@
package com.android.server.power;
import static android.hardware.display.DisplayManagerInternal.DisplayPowerRequest.POLICY_BRIGHT;
import static android.hardware.display.DisplayManagerInternal.DisplayPowerRequest.POLICY_DIM;
import static android.hardware.display.DisplayManagerInternal.DisplayPowerRequest.POLICY_DOZE;
import static android.hardware.display.DisplayManagerInternal.DisplayPowerRequest.POLICY_OFF;
import static android.hardware.display.DisplayManagerInternal.DisplayPowerRequest.POLICY_VR;
import static android.os.PowerManager.GO_TO_SLEEP_REASON_APPLICATION;
import static android.os.PowerManager.GO_TO_SLEEP_REASON_DEVICE_ADMIN;
import static android.os.PowerManager.GO_TO_SLEEP_REASON_TIMEOUT;
@@ -26,6 +31,10 @@ import static android.os.PowerManagerInternal.WAKEFULNESS_AWAKE;
import static android.os.PowerManagerInternal.WAKEFULNESS_DOZING;
import static android.os.PowerManagerInternal.WAKEFULNESS_DREAMING;
import static com.android.server.power.PowerManagerService.USER_ACTIVITY_SCREEN_BRIGHT;
import static com.android.server.power.PowerManagerService.WAKE_LOCK_DOZE;
import static com.android.server.power.PowerManagerService.WAKE_LOCK_SCREEN_BRIGHT;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.ArgumentMatchers.anyInt;
@@ -33,7 +42,10 @@ import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.ArgumentMatchers.isNull;
import static org.mockito.Mockito.verify;
import android.hardware.display.DisplayManagerInternal.DisplayPowerRequest;
import android.hardware.display.DisplayManagerInternal;
import android.os.PowerManager;
import android.os.PowerSaveState;
import android.view.Display;
import org.junit.Before;
import org.junit.Test;
@@ -49,21 +61,31 @@ import org.mockito.MockitoAnnotations;
public class PowerGroupTest {
private static final int GROUP_ID = 0;
private static final int UID = 11;
private static final long TIMESTAMP_CREATE = 1;
private static final long TIMESTAMP1 = 999;
private static final long TIMESTAMP2 = TIMESTAMP1 + 10;
private static final long TIMESTAMP3 = TIMESTAMP2 + 10;
private static final int UID = 11;
private static final float PRECISION = 0.001f;
private static final float BRIGHTNESS = 0.99f;
private static final float BRIGHTNESS_DOZE = 0.5f;
private PowerGroup mPowerGroup;
@Mock
private PowerGroup.PowerGroupListener mWakefulnessCallbackMock;
@Mock private PowerGroup.PowerGroupListener mWakefulnessCallbackMock;
@Mock private Notifier mNotifier;
@Mock private DisplayManagerInternal mDisplayManagerInternal;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mPowerGroup = new PowerGroup(GROUP_ID, mWakefulnessCallbackMock, new DisplayPowerRequest(),
WAKEFULNESS_AWAKE, /* ready= */ true, /* supportsSandman= */true, TIMESTAMP_CREATE);
mPowerGroup = new PowerGroup(GROUP_ID, mWakefulnessCallbackMock, mNotifier,
mDisplayManagerInternal, WAKEFULNESS_AWAKE, /* ready= */ true,
/* supportsSandman= */ true, TIMESTAMP_CREATE);
}
@Test
@@ -126,4 +148,433 @@ public class PowerGroupTest {
eq(WAKEFULNESS_ASLEEP), eq(TIMESTAMP3), eq(GO_TO_SLEEP_REASON_DEVICE_ADMIN),
eq(UID), /* opUid= */anyInt(), /* opPackageName= */ isNull(), eq(details));
}
@Test
public void testUpdateWhileAwake_UpdatesDisplayPowerRequest() {
final boolean batterySaverEnabled = true;
float brightnessFactor = 0.7f;
PowerSaveState powerSaveState = new PowerSaveState.Builder()
.setBatterySaverEnabled(batterySaverEnabled)
.setBrightnessFactor(brightnessFactor)
.build();
mPowerGroup.updateLocked(/* screenBrightnessOverride= */ BRIGHTNESS,
/* autoBrightness = */ false,
/* useProximitySensor= */ false,
/* boostScreenBrightness= */ false,
/* dozeScreenStateOverride= */ Display.STATE_ON,
/* dozeScreenBrightness= */ BRIGHTNESS_DOZE,
/* overrideDrawWakeLock= */ false,
powerSaveState,
/* quiescent= */ false,
/* dozeAfterScreenOff= */ false,
/* vrModeEnabled= */ false,
/* bootCompleted= */ true,
/* screenBrightnessBoostInProgress= */ false,
/* waitForNegativeProximity= */ false);
DisplayManagerInternal.DisplayPowerRequest displayPowerRequest =
mPowerGroup.mDisplayPowerRequest;
assertThat(displayPowerRequest.policy).isEqualTo(POLICY_DIM);
assertThat(displayPowerRequest.screenBrightnessOverride).isWithin(PRECISION).of(BRIGHTNESS);
assertThat(displayPowerRequest.useAutoBrightness).isEqualTo(false);
assertThat(displayPowerRequest.useProximitySensor).isEqualTo(false);
assertThat(displayPowerRequest.boostScreenBrightness).isEqualTo(false);
assertThat(displayPowerRequest.dozeScreenState).isEqualTo(Display.STATE_UNKNOWN);
assertThat(displayPowerRequest.dozeScreenBrightness).isEqualTo(
PowerManager.BRIGHTNESS_INVALID_FLOAT);
assertThat(displayPowerRequest.lowPowerMode).isEqualTo(batterySaverEnabled);
assertThat(displayPowerRequest.screenLowPowerBrightnessFactor).isWithin(PRECISION).of(
brightnessFactor);
}
@Test
public void testUpdateWhileDozing_UpdatesDisplayPowerRequest() {
final boolean batterySaverEnabled = false;
float brightnessFactor = 0.3f;
PowerSaveState powerSaveState = new PowerSaveState.Builder()
.setBatterySaverEnabled(batterySaverEnabled)
.setBrightnessFactor(brightnessFactor)
.build();
mPowerGroup.dozeLocked(TIMESTAMP1, UID, GO_TO_SLEEP_REASON_APPLICATION);
assertThat(mPowerGroup.getWakefulnessLocked()).isEqualTo(WAKEFULNESS_DOZING);
mPowerGroup.setWakeLockSummaryLocked(WAKE_LOCK_DOZE);
mPowerGroup.updateLocked(/* screenBrightnessOverride= */ BRIGHTNESS,
/* autoBrightness = */ true,
/* useProximitySensor= */ true,
/* boostScreenBrightness= */ true,
/* dozeScreenStateOverride= */ Display.STATE_ON,
/* dozeScreenBrightness= */ BRIGHTNESS_DOZE,
/* overrideDrawWakeLock= */ false,
powerSaveState,
/* quiescent= */ false,
/* dozeAfterScreenOff= */ false,
/* vrModeEnabled= */ false,
/* bootCompleted= */ true,
/* screenBrightnessBoostInProgress= */ false,
/* waitForNegativeProximity= */ false);
DisplayManagerInternal.DisplayPowerRequest displayPowerRequest =
mPowerGroup.mDisplayPowerRequest;
assertThat(displayPowerRequest.policy).isEqualTo(POLICY_DOZE);
assertThat(displayPowerRequest.screenBrightnessOverride).isWithin(PRECISION).of(BRIGHTNESS);
assertThat(displayPowerRequest.useAutoBrightness).isEqualTo(true);
assertThat(displayPowerRequest.useProximitySensor).isEqualTo(true);
assertThat(displayPowerRequest.boostScreenBrightness).isEqualTo(true);
assertThat(displayPowerRequest.dozeScreenState).isEqualTo(Display.STATE_ON);
assertThat(displayPowerRequest.dozeScreenBrightness).isWithin(PRECISION).of(
BRIGHTNESS_DOZE);
assertThat(displayPowerRequest.lowPowerMode).isEqualTo(batterySaverEnabled);
assertThat(displayPowerRequest.screenLowPowerBrightnessFactor).isWithin(PRECISION).of(
brightnessFactor);
}
@Test
public void testUpdateWhileDozing_DozeAfterScreenOff() {
final boolean batterySaverEnabled = false;
float brightnessFactor = 0.3f;
PowerSaveState powerSaveState = new PowerSaveState.Builder()
.setBatterySaverEnabled(batterySaverEnabled)
.setBrightnessFactor(brightnessFactor)
.build();
mPowerGroup.dozeLocked(TIMESTAMP1, UID, GO_TO_SLEEP_REASON_APPLICATION);
assertThat(mPowerGroup.getWakefulnessLocked()).isEqualTo(WAKEFULNESS_DOZING);
mPowerGroup.updateLocked(/* screenBrightnessOverride= */ BRIGHTNESS,
/* autoBrightness = */ true,
/* useProximitySensor= */ true,
/* boostScreenBrightness= */ true,
/* dozeScreenStateOverride= */ Display.STATE_ON,
/* dozeScreenBrightness= */ BRIGHTNESS_DOZE,
/* overrideDrawWakeLock= */ false,
powerSaveState,
/* quiescent= */ false,
/* dozeAfterScreenOff= */ true,
/* vrModeEnabled= */ false,
/* bootCompleted= */ true,
/* screenBrightnessBoostInProgress= */ false,
/* waitForNegativeProximity= */ false);
DisplayManagerInternal.DisplayPowerRequest displayPowerRequest =
mPowerGroup.mDisplayPowerRequest;
assertThat(displayPowerRequest.policy).isEqualTo(POLICY_OFF);
assertThat(displayPowerRequest.screenBrightnessOverride).isWithin(PRECISION).of(BRIGHTNESS);
assertThat(displayPowerRequest.useAutoBrightness).isEqualTo(true);
assertThat(displayPowerRequest.useProximitySensor).isEqualTo(true);
assertThat(displayPowerRequest.boostScreenBrightness).isEqualTo(true);
assertThat(displayPowerRequest.dozeScreenState).isEqualTo(Display.STATE_UNKNOWN);
assertThat(displayPowerRequest.dozeScreenBrightness).isEqualTo(
PowerManager.BRIGHTNESS_INVALID_FLOAT);
assertThat(displayPowerRequest.lowPowerMode).isEqualTo(batterySaverEnabled);
assertThat(displayPowerRequest.screenLowPowerBrightnessFactor).isWithin(PRECISION).of(
brightnessFactor);
}
@Test
public void testUpdateQuiescent() {
final boolean batterySaverEnabled = false;
float brightnessFactor = 0.3f;
PowerSaveState powerSaveState = new PowerSaveState.Builder()
.setBatterySaverEnabled(batterySaverEnabled)
.setBrightnessFactor(brightnessFactor)
.build();
assertThat(mPowerGroup.getWakefulnessLocked()).isEqualTo(WAKEFULNESS_AWAKE);
mPowerGroup.updateLocked(/* screenBrightnessOverride= */ BRIGHTNESS,
/* autoBrightness = */ true,
/* useProximitySensor= */ true,
/* boostScreenBrightness= */ true,
/* dozeScreenStateOverride= */ Display.STATE_ON,
/* dozeScreenBrightness= */ BRIGHTNESS_DOZE,
/* overrideDrawWakeLock= */ false,
powerSaveState,
/* quiescent= */ true,
/* dozeAfterScreenOff= */ true,
/* vrModeEnabled= */ false,
/* bootCompleted= */ true,
/* screenBrightnessBoostInProgress= */ false,
/* waitForNegativeProximity= */ false);
DisplayManagerInternal.DisplayPowerRequest displayPowerRequest =
mPowerGroup.mDisplayPowerRequest;
assertThat(displayPowerRequest.policy).isEqualTo(POLICY_OFF);
assertThat(displayPowerRequest.screenBrightnessOverride).isWithin(PRECISION).of(BRIGHTNESS);
assertThat(displayPowerRequest.useAutoBrightness).isEqualTo(true);
assertThat(displayPowerRequest.useProximitySensor).isEqualTo(true);
assertThat(displayPowerRequest.boostScreenBrightness).isEqualTo(true);
assertThat(displayPowerRequest.dozeScreenState).isEqualTo(Display.STATE_UNKNOWN);
assertThat(displayPowerRequest.dozeScreenBrightness).isEqualTo(
PowerManager.BRIGHTNESS_INVALID_FLOAT);
assertThat(displayPowerRequest.lowPowerMode).isEqualTo(batterySaverEnabled);
assertThat(displayPowerRequest.screenLowPowerBrightnessFactor).isWithin(PRECISION).of(
brightnessFactor);
}
@Test
public void testUpdateWhileAsleep_VrModeEnabled() {
final boolean batterySaverEnabled = false;
float brightnessFactor = 0.3f;
PowerSaveState powerSaveState = new PowerSaveState.Builder()
.setBatterySaverEnabled(batterySaverEnabled)
.setBrightnessFactor(brightnessFactor)
.build();
mPowerGroup.sleepLocked(TIMESTAMP1, UID, GO_TO_SLEEP_REASON_TIMEOUT);
assertThat(mPowerGroup.getWakefulnessLocked()).isEqualTo(WAKEFULNESS_ASLEEP);
mPowerGroup.updateLocked(/* screenBrightnessOverride= */ BRIGHTNESS,
/* autoBrightness = */ true,
/* useProximitySensor= */ true,
/* boostScreenBrightness= */ true,
/* dozeScreenStateOverride= */ Display.STATE_ON,
/* dozeScreenBrightness= */ BRIGHTNESS_DOZE,
/* overrideDrawWakeLock= */ false,
powerSaveState,
/* quiescent= */ false,
/* dozeAfterScreenOff= */ true,
/* vrModeEnabled= */ true,
/* bootCompleted= */ true,
/* screenBrightnessBoostInProgress= */ false,
/* waitForNegativeProximity= */ false);
DisplayManagerInternal.DisplayPowerRequest displayPowerRequest =
mPowerGroup.mDisplayPowerRequest;
assertThat(displayPowerRequest.policy).isEqualTo(POLICY_OFF);
assertThat(displayPowerRequest.screenBrightnessOverride).isWithin(PRECISION).of(BRIGHTNESS);
assertThat(displayPowerRequest.useAutoBrightness).isEqualTo(true);
assertThat(displayPowerRequest.useProximitySensor).isEqualTo(true);
assertThat(displayPowerRequest.boostScreenBrightness).isEqualTo(true);
assertThat(displayPowerRequest.dozeScreenState).isEqualTo(Display.STATE_UNKNOWN);
assertThat(displayPowerRequest.dozeScreenBrightness).isEqualTo(
PowerManager.BRIGHTNESS_INVALID_FLOAT);
assertThat(displayPowerRequest.lowPowerMode).isEqualTo(batterySaverEnabled);
assertThat(displayPowerRequest.screenLowPowerBrightnessFactor).isWithin(PRECISION).of(
brightnessFactor);
}
@Test
public void testUpdateWhileAwake_VrModeEnabled() {
final boolean batterySaverEnabled = false;
float brightnessFactor = 0.3f;
PowerSaveState powerSaveState = new PowerSaveState.Builder()
.setBatterySaverEnabled(batterySaverEnabled)
.setBrightnessFactor(brightnessFactor)
.build();
assertThat(mPowerGroup.getWakefulnessLocked()).isEqualTo(WAKEFULNESS_AWAKE);
mPowerGroup.updateLocked(/* screenBrightnessOverride= */ BRIGHTNESS,
/* autoBrightness = */ true,
/* useProximitySensor= */ true,
/* boostScreenBrightness= */ true,
/* dozeScreenStateOverride= */ Display.STATE_ON,
/* dozeScreenBrightness= */ BRIGHTNESS_DOZE,
/* overrideDrawWakeLock= */ false,
powerSaveState,
/* quiescent= */ false,
/* dozeAfterScreenOff= */ true,
/* vrModeEnabled= */ true,
/* bootCompleted= */ true,
/* screenBrightnessBoostInProgress= */ false,
/* waitForNegativeProximity= */ false);
DisplayManagerInternal.DisplayPowerRequest displayPowerRequest =
mPowerGroup.mDisplayPowerRequest;
assertThat(displayPowerRequest.policy).isEqualTo(POLICY_VR);
assertThat(displayPowerRequest.screenBrightnessOverride).isWithin(PRECISION).of(BRIGHTNESS);
assertThat(displayPowerRequest.useAutoBrightness).isEqualTo(true);
assertThat(displayPowerRequest.useProximitySensor).isEqualTo(true);
assertThat(displayPowerRequest.boostScreenBrightness).isEqualTo(true);
assertThat(displayPowerRequest.dozeScreenState).isEqualTo(Display.STATE_UNKNOWN);
assertThat(displayPowerRequest.dozeScreenBrightness).isEqualTo(
PowerManager.BRIGHTNESS_INVALID_FLOAT);
assertThat(displayPowerRequest.lowPowerMode).isEqualTo(batterySaverEnabled);
assertThat(displayPowerRequest.screenLowPowerBrightnessFactor).isWithin(PRECISION).of(
brightnessFactor);
}
@Test
public void testUpdateWhileAsleep_UpdatesDisplayPowerRequest() {
final boolean batterySaverEnabled = false;
float brightnessFactor = 0.3f;
PowerSaveState powerSaveState = new PowerSaveState.Builder()
.setBatterySaverEnabled(batterySaverEnabled)
.setBrightnessFactor(brightnessFactor)
.build();
mPowerGroup.sleepLocked(TIMESTAMP1, UID, GO_TO_SLEEP_REASON_TIMEOUT);
assertThat(mPowerGroup.getWakefulnessLocked()).isEqualTo(WAKEFULNESS_ASLEEP);
mPowerGroup.updateLocked(/* screenBrightnessOverride= */ BRIGHTNESS,
/* autoBrightness = */ true,
/* useProximitySensor= */ true,
/* boostScreenBrightness= */ true,
/* dozeScreenStateOverride= */ Display.STATE_ON,
/* dozeScreenBrightness= */ BRIGHTNESS_DOZE,
/* overrideDrawWakeLock= */ false,
powerSaveState,
/* quiescent= */ false,
/* dozeAfterScreenOff= */ false,
/* vrModeEnabled= */ false,
/* bootCompleted= */ true,
/* screenBrightnessBoostInProgress= */ false,
/* waitForNegativeProximity= */ false);
DisplayManagerInternal.DisplayPowerRequest displayPowerRequest =
mPowerGroup.mDisplayPowerRequest;
assertThat(displayPowerRequest.policy).isEqualTo(POLICY_OFF);
assertThat(displayPowerRequest.screenBrightnessOverride).isWithin(PRECISION).of(BRIGHTNESS);
assertThat(displayPowerRequest.useAutoBrightness).isEqualTo(true);
assertThat(displayPowerRequest.useProximitySensor).isEqualTo(true);
assertThat(displayPowerRequest.boostScreenBrightness).isEqualTo(true);
assertThat(displayPowerRequest.dozeScreenState).isEqualTo(Display.STATE_UNKNOWN);
assertThat(displayPowerRequest.dozeScreenBrightness).isEqualTo(
PowerManager.BRIGHTNESS_INVALID_FLOAT);
assertThat(displayPowerRequest.lowPowerMode).isEqualTo(batterySaverEnabled);
assertThat(displayPowerRequest.screenLowPowerBrightnessFactor).isWithin(PRECISION).of(
brightnessFactor);
}
@Test
public void testUpdateWhileDreamingWithScreenBrightWakelock_UpdatesDisplayPowerRequest() {
final boolean batterySaverEnabled = false;
float brightnessFactor = 0.3f;
PowerSaveState powerSaveState = new PowerSaveState.Builder()
.setBatterySaverEnabled(batterySaverEnabled)
.setBrightnessFactor(brightnessFactor)
.build();
mPowerGroup.dreamLocked(TIMESTAMP1, UID);
assertThat(mPowerGroup.getWakefulnessLocked()).isEqualTo(WAKEFULNESS_DREAMING);
mPowerGroup.setWakeLockSummaryLocked(WAKE_LOCK_SCREEN_BRIGHT);
mPowerGroup.updateLocked(/* screenBrightnessOverride= */ BRIGHTNESS,
/* autoBrightness = */ true,
/* useProximitySensor= */ true,
/* boostScreenBrightness= */ true,
/* dozeScreenStateOverride= */ Display.STATE_ON,
/* dozeScreenBrightness= */ BRIGHTNESS_DOZE,
/* overrideDrawWakeLock= */ false,
powerSaveState,
/* quiescent= */ false,
/* dozeAfterScreenOff= */ false,
/* vrModeEnabled= */ false,
/* bootCompleted= */ true,
/* screenBrightnessBoostInProgress= */ false,
/* waitForNegativeProximity= */ false);
DisplayManagerInternal.DisplayPowerRequest displayPowerRequest =
mPowerGroup.mDisplayPowerRequest;
assertThat(displayPowerRequest.policy).isEqualTo(POLICY_BRIGHT);
assertThat(displayPowerRequest.screenBrightnessOverride).isWithin(PRECISION).of(BRIGHTNESS);
assertThat(displayPowerRequest.useAutoBrightness).isEqualTo(true);
assertThat(displayPowerRequest.useProximitySensor).isEqualTo(true);
assertThat(displayPowerRequest.boostScreenBrightness).isEqualTo(true);
assertThat(displayPowerRequest.dozeScreenState).isEqualTo(Display.STATE_UNKNOWN);
assertThat(displayPowerRequest.dozeScreenBrightness).isEqualTo(
PowerManager.BRIGHTNESS_INVALID_FLOAT);
assertThat(displayPowerRequest.lowPowerMode).isEqualTo(batterySaverEnabled);
assertThat(displayPowerRequest.screenLowPowerBrightnessFactor).isWithin(PRECISION).of(
brightnessFactor);
}
@Test
public void testUpdateWhileAwakeBootNotComplete_UpdatesDisplayPowerRequest() {
final boolean batterySaverEnabled = false;
float brightnessFactor = 0.3f;
PowerSaveState powerSaveState = new PowerSaveState.Builder()
.setBatterySaverEnabled(batterySaverEnabled)
.setBrightnessFactor(brightnessFactor)
.build();
assertThat(mPowerGroup.getWakefulnessLocked()).isEqualTo(WAKEFULNESS_AWAKE);
mPowerGroup.updateLocked(/* screenBrightnessOverride= */ BRIGHTNESS,
/* autoBrightness = */ true,
/* useProximitySensor= */ true,
/* boostScreenBrightness= */ true,
/* dozeScreenStateOverride= */ Display.STATE_ON,
/* dozeScreenBrightness= */ BRIGHTNESS_DOZE,
/* overrideDrawWakeLock= */ false,
powerSaveState,
/* quiescent= */ false,
/* dozeAfterScreenOff= */ false,
/* vrModeEnabled= */ false,
/* bootCompleted= */ false,
/* screenBrightnessBoostInProgress= */ false,
/* waitForNegativeProximity= */ false);
DisplayManagerInternal.DisplayPowerRequest displayPowerRequest =
mPowerGroup.mDisplayPowerRequest;
assertThat(displayPowerRequest.policy).isEqualTo(POLICY_BRIGHT);
assertThat(displayPowerRequest.screenBrightnessOverride).isWithin(PRECISION).of(BRIGHTNESS);
assertThat(displayPowerRequest.useAutoBrightness).isEqualTo(true);
assertThat(displayPowerRequest.useProximitySensor).isEqualTo(true);
assertThat(displayPowerRequest.boostScreenBrightness).isEqualTo(true);
assertThat(displayPowerRequest.dozeScreenState).isEqualTo(Display.STATE_UNKNOWN);
assertThat(displayPowerRequest.dozeScreenBrightness).isEqualTo(
PowerManager.BRIGHTNESS_INVALID_FLOAT);
assertThat(displayPowerRequest.lowPowerMode).isEqualTo(batterySaverEnabled);
assertThat(displayPowerRequest.screenLowPowerBrightnessFactor).isWithin(PRECISION).of(
brightnessFactor);
}
@Test
public void testUpdateWhileAwakeUserActivityScreenBright_UpdatesDisplayPowerRequest() {
final boolean batterySaverEnabled = false;
float brightnessFactor = 0.3f;
PowerSaveState powerSaveState = new PowerSaveState.Builder()
.setBatterySaverEnabled(batterySaverEnabled)
.setBrightnessFactor(brightnessFactor)
.build();
assertThat(mPowerGroup.getWakefulnessLocked()).isEqualTo(WAKEFULNESS_AWAKE);
mPowerGroup.setUserActivitySummaryLocked(USER_ACTIVITY_SCREEN_BRIGHT);
mPowerGroup.updateLocked(/* screenBrightnessOverride= */ BRIGHTNESS,
/* autoBrightness = */ true,
/* useProximitySensor= */ true,
/* boostScreenBrightness= */ true,
/* dozeScreenStateOverride= */ Display.STATE_ON,
/* dozeScreenBrightness= */ BRIGHTNESS_DOZE,
/* overrideDrawWakeLock= */ false,
powerSaveState,
/* quiescent= */ false,
/* dozeAfterScreenOff= */ false,
/* vrModeEnabled= */ false,
/* bootCompleted= */ true,
/* screenBrightnessBoostInProgress= */ false,
/* waitForNegativeProximity= */ false);
DisplayManagerInternal.DisplayPowerRequest displayPowerRequest =
mPowerGroup.mDisplayPowerRequest;
assertThat(displayPowerRequest.policy).isEqualTo(POLICY_BRIGHT);
assertThat(displayPowerRequest.screenBrightnessOverride).isWithin(PRECISION).of(BRIGHTNESS);
assertThat(displayPowerRequest.useAutoBrightness).isEqualTo(true);
assertThat(displayPowerRequest.useProximitySensor).isEqualTo(true);
assertThat(displayPowerRequest.boostScreenBrightness).isEqualTo(true);
assertThat(displayPowerRequest.dozeScreenState).isEqualTo(Display.STATE_UNKNOWN);
assertThat(displayPowerRequest.dozeScreenBrightness).isEqualTo(
PowerManager.BRIGHTNESS_INVALID_FLOAT);
assertThat(displayPowerRequest.lowPowerMode).isEqualTo(batterySaverEnabled);
assertThat(displayPowerRequest.screenLowPowerBrightnessFactor).isWithin(PRECISION).of(
brightnessFactor);
}
@Test
public void testUpdateWhileAwakeScreenBrightnessBoostInProgress_UpdatesDisplayPowerRequest() {
final boolean batterySaverEnabled = false;
float brightnessFactor = 0.3f;
PowerSaveState powerSaveState = new PowerSaveState.Builder()
.setBatterySaverEnabled(batterySaverEnabled)
.setBrightnessFactor(brightnessFactor)
.build();
assertThat(mPowerGroup.getWakefulnessLocked()).isEqualTo(WAKEFULNESS_AWAKE);
mPowerGroup.updateLocked(/* screenBrightnessOverride= */ BRIGHTNESS,
/* autoBrightness = */ true,
/* useProximitySensor= */ true,
/* boostScreenBrightness= */ true,
/* dozeScreenStateOverride= */ Display.STATE_ON,
/* dozeScreenBrightness= */ BRIGHTNESS_DOZE,
/* overrideDrawWakeLock= */ false,
powerSaveState,
/* quiescent= */ false,
/* dozeAfterScreenOff= */ false,
/* vrModeEnabled= */ false,
/* bootCompleted= */ true,
/* screenBrightnessBoostInProgress= */ true,
/* waitForNegativeProximity= */ false);
DisplayManagerInternal.DisplayPowerRequest displayPowerRequest =
mPowerGroup.mDisplayPowerRequest;
assertThat(displayPowerRequest.policy).isEqualTo(POLICY_BRIGHT);
assertThat(displayPowerRequest.screenBrightnessOverride).isWithin(PRECISION).of(BRIGHTNESS);
assertThat(displayPowerRequest.useAutoBrightness).isEqualTo(true);
assertThat(displayPowerRequest.useProximitySensor).isEqualTo(true);
assertThat(displayPowerRequest.boostScreenBrightness).isEqualTo(true);
assertThat(displayPowerRequest.dozeScreenState).isEqualTo(Display.STATE_UNKNOWN);
assertThat(displayPowerRequest.dozeScreenBrightness).isEqualTo(
PowerManager.BRIGHTNESS_INVALID_FLOAT);
assertThat(displayPowerRequest.lowPowerMode).isEqualTo(batterySaverEnabled);
assertThat(displayPowerRequest.screenLowPowerBrightnessFactor).isWithin(PRECISION).of(
brightnessFactor);
}
}

12
services/tests/servicestests/src/com/android/server/power/PowerManagerServiceTest.java
View File

@@ -123,7 +123,6 @@ public class PowerManagerServiceTest {
private static final String SYSTEM_PROPERTY_QUIESCENT = "ro.boot.quiescent";
private static final String SYSTEM_PROPERTY_REBOOT_REASON = "sys.boot.reason";
private static final float PRECISION = 0.001f;
private static final float BRIGHTNESS_FACTOR = 0.7f;
private static final boolean BATTERY_SAVER_ENABLED = true;
@@ -146,7 +145,6 @@ public class PowerManagerServiceTest {
private InattentiveSleepWarningController mInattentiveSleepWarningControllerMock;
private PowerManagerService mService;
private DisplayPowerRequest mDisplayPowerRequest;
private ContextWrapper mContextSpy;
private BatteryReceiver mBatteryReceiver;
private UserSwitchedReceiver mUserSwitchedReceiver;
@@ -195,7 +193,6 @@ public class PowerManagerServiceTest {
when(mSystemPropertiesMock.get(eq(SYSTEM_PROPERTY_QUIESCENT), anyString())).thenReturn("");
when(mAmbientDisplayConfigurationMock.ambientDisplayAvailable()).thenReturn(true);
mDisplayPowerRequest = new DisplayPowerRequest();
addLocalServiceMock(LightsManager.class, mLightsManagerMock);
addLocalServiceMock(DisplayManagerInternal.class, mDisplayManagerInternalMock);
addLocalServiceMock(BatteryManagerInternal.class, mBatteryManagerInternalMock);
@@ -418,15 +415,6 @@ public class PowerManagerServiceTest {
verify(mNativeWrapperMock).nativeSetPowerMode(eq(Mode.DOUBLE_TAP_TO_WAKE), eq(false));
}
@Test
public void testUpdatePowerScreenPolicy_UpdateDisplayPowerRequest() {
createService();
mService.updatePowerRequestFromBatterySaverPolicy(mDisplayPowerRequest);
assertThat(mDisplayPowerRequest.lowPowerMode).isEqualTo(BATTERY_SAVER_ENABLED);
assertThat(mDisplayPowerRequest.screenLowPowerBrightnessFactor)
.isWithin(PRECISION).of(BRIGHTNESS_FACTOR);
}
@Test
public void testGetLastShutdownReasonInternal() {
when(mSystemPropertiesMock.get(eq(SYSTEM_PROPERTY_REBOOT_REASON), any())).thenReturn(