PowerManagerService.java revision 694f24581ac4f14cc961c6b96368330ed6740772
1/* 2 * Copyright (C) 2007 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17package com.android.server.power; 18 19import android.Manifest; 20import android.annotation.IntDef; 21import android.app.ActivityManager; 22import android.content.BroadcastReceiver; 23import android.content.ContentResolver; 24import android.content.Context; 25import android.content.Intent; 26import android.content.IntentFilter; 27import android.content.pm.PackageManager; 28import android.content.res.Resources; 29import android.database.ContentObserver; 30import android.hardware.SensorManager; 31import android.hardware.SystemSensorManager; 32import android.hardware.display.DisplayManagerInternal; 33import android.hardware.display.DisplayManagerInternal.DisplayPowerRequest; 34import android.hardware.power.V1_0.PowerHint; 35import android.metrics.LogMaker; 36import android.net.Uri; 37import android.os.BatteryManager; 38import android.os.BatteryManagerInternal; 39import android.os.Binder; 40import android.os.Handler; 41import android.os.IBinder; 42import android.os.IPowerManager; 43import android.os.Looper; 44import android.os.Message; 45import android.os.PowerManager; 46import android.os.PowerManagerInternal; 47import android.os.PowerSaveState; 48import android.os.Process; 49import android.os.RemoteException; 50import android.os.ResultReceiver; 51import android.os.ShellCallback; 52import android.os.SystemClock; 53import android.os.SystemProperties; 54import android.os.Trace; 55import android.os.UserHandle; 56import android.os.WorkSource; 57import android.provider.Settings; 58import android.provider.Settings.SettingNotFoundException; 59import android.service.dreams.DreamManagerInternal; 60import android.service.power.PowerServiceDumpProto; 61import android.service.power.PowerServiceSettingsAndConfigurationDumpProto; 62import android.service.power.SuspendBlockerProto; 63import android.service.power.WakeLockProto; 64import android.service.vr.IVrManager; 65import android.service.vr.IVrStateCallbacks; 66import android.util.EventLog; 67import android.util.KeyValueListParser; 68import android.util.PrintWriterPrinter; 69import android.util.Slog; 70import android.util.SparseArray; 71import android.util.TimeUtils; 72import android.util.proto.ProtoOutputStream; 73import android.view.Display; 74import android.view.WindowManagerPolicy; 75import com.android.internal.annotations.VisibleForTesting; 76import com.android.internal.app.IAppOpsService; 77import com.android.internal.app.IBatteryStats; 78import com.android.internal.hardware.AmbientDisplayConfiguration; 79import com.android.internal.logging.MetricsLogger; 80import com.android.internal.logging.nano.MetricsProto.MetricsEvent; 81import com.android.internal.os.BackgroundThread; 82import com.android.internal.util.ArrayUtils; 83import com.android.internal.util.DumpUtils; 84import com.android.server.EventLogTags; 85import com.android.server.LockGuard; 86import com.android.server.RescueParty; 87import com.android.server.ServiceThread; 88import com.android.server.SystemService; 89import com.android.server.Watchdog; 90import com.android.server.am.BatteryStatsService; 91import com.android.server.lights.Light; 92import com.android.server.lights.LightsManager; 93import com.android.server.power.BatterySaverPolicy.ServiceType; 94import libcore.util.Objects; 95 96import java.io.FileDescriptor; 97import java.io.PrintWriter; 98import java.lang.annotation.Retention; 99import java.lang.annotation.RetentionPolicy; 100import java.util.ArrayList; 101import java.util.Arrays; 102 103import static android.os.PowerManagerInternal.WAKEFULNESS_ASLEEP; 104import static android.os.PowerManagerInternal.WAKEFULNESS_AWAKE; 105import static android.os.PowerManagerInternal.WAKEFULNESS_DOZING; 106import static android.os.PowerManagerInternal.WAKEFULNESS_DREAMING; 107 108/** 109 * The power manager service is responsible for coordinating power management 110 * functions on the device. 111 */ 112public final class PowerManagerService extends SystemService 113 implements Watchdog.Monitor { 114 private static final String TAG = "PowerManagerService"; 115 116 private static final boolean DEBUG = false; 117 private static final boolean DEBUG_SPEW = DEBUG && true; 118 119 // Message: Sent when a user activity timeout occurs to update the power state. 120 private static final int MSG_USER_ACTIVITY_TIMEOUT = 1; 121 // Message: Sent when the device enters or exits a dreaming or dozing state. 122 private static final int MSG_SANDMAN = 2; 123 // Message: Sent when the screen brightness boost expires. 124 private static final int MSG_SCREEN_BRIGHTNESS_BOOST_TIMEOUT = 3; 125 // Message: Polling to look for long held wake locks. 126 private static final int MSG_CHECK_FOR_LONG_WAKELOCKS = 4; 127 128 // Dirty bit: mWakeLocks changed 129 private static final int DIRTY_WAKE_LOCKS = 1 << 0; 130 // Dirty bit: mWakefulness changed 131 private static final int DIRTY_WAKEFULNESS = 1 << 1; 132 // Dirty bit: user activity was poked or may have timed out 133 private static final int DIRTY_USER_ACTIVITY = 1 << 2; 134 // Dirty bit: actual display power state was updated asynchronously 135 private static final int DIRTY_ACTUAL_DISPLAY_POWER_STATE_UPDATED = 1 << 3; 136 // Dirty bit: mBootCompleted changed 137 private static final int DIRTY_BOOT_COMPLETED = 1 << 4; 138 // Dirty bit: settings changed 139 private static final int DIRTY_SETTINGS = 1 << 5; 140 // Dirty bit: mIsPowered changed 141 private static final int DIRTY_IS_POWERED = 1 << 6; 142 // Dirty bit: mStayOn changed 143 private static final int DIRTY_STAY_ON = 1 << 7; 144 // Dirty bit: battery state changed 145 private static final int DIRTY_BATTERY_STATE = 1 << 8; 146 // Dirty bit: proximity state changed 147 private static final int DIRTY_PROXIMITY_POSITIVE = 1 << 9; 148 // Dirty bit: dock state changed 149 private static final int DIRTY_DOCK_STATE = 1 << 10; 150 // Dirty bit: brightness boost changed 151 private static final int DIRTY_SCREEN_BRIGHTNESS_BOOST = 1 << 11; 152 // Dirty bit: sQuiescent changed 153 private static final int DIRTY_QUIESCENT = 1 << 12; 154 // Dirty bit: VR Mode enabled changed 155 private static final int DIRTY_VR_MODE_CHANGED = 1 << 13; 156 157 // Summarizes the state of all active wakelocks. 158 private static final int WAKE_LOCK_CPU = 1 << 0; 159 private static final int WAKE_LOCK_SCREEN_BRIGHT = 1 << 1; 160 private static final int WAKE_LOCK_SCREEN_DIM = 1 << 2; 161 private static final int WAKE_LOCK_BUTTON_BRIGHT = 1 << 3; 162 private static final int WAKE_LOCK_PROXIMITY_SCREEN_OFF = 1 << 4; 163 private static final int WAKE_LOCK_STAY_AWAKE = 1 << 5; // only set if already awake 164 private static final int WAKE_LOCK_DOZE = 1 << 6; 165 private static final int WAKE_LOCK_DRAW = 1 << 7; 166 167 // Summarizes the user activity state. 168 private static final int USER_ACTIVITY_SCREEN_BRIGHT = 1 << 0; 169 private static final int USER_ACTIVITY_SCREEN_DIM = 1 << 1; 170 private static final int USER_ACTIVITY_SCREEN_DREAM = 1 << 2; 171 172 // Default timeout in milliseconds. This is only used until the settings 173 // provider populates the actual default value (R.integer.def_screen_off_timeout). 174 private static final int DEFAULT_SCREEN_OFF_TIMEOUT = 15 * 1000; 175 private static final int DEFAULT_SLEEP_TIMEOUT = -1; 176 177 // Screen brightness boost timeout. 178 // Hardcoded for now until we decide what the right policy should be. 179 // This should perhaps be a setting. 180 private static final int SCREEN_BRIGHTNESS_BOOST_TIMEOUT = 5 * 1000; 181 182 // How long a partial wake lock must be held until we consider it a long wake lock. 183 static final long MIN_LONG_WAKE_CHECK_INTERVAL = 60*1000; 184 185 // Power features defined in hardware/libhardware/include/hardware/power.h. 186 private static final int POWER_FEATURE_DOUBLE_TAP_TO_WAKE = 1; 187 188 // Default setting for double tap to wake. 189 private static final int DEFAULT_DOUBLE_TAP_TO_WAKE = 0; 190 191 // System property indicating that the screen should remain off until an explicit user action 192 private static final String SYSTEM_PROPERTY_QUIESCENT = "ro.boot.quiescent"; 193 194 private static final String TRACE_SCREEN_ON = "Screen turning on"; 195 196 /** If turning screen on takes more than this long, we show a warning on logcat. */ 197 private static final int SCREEN_ON_LATENCY_WARNING_MS = 200; 198 199 /** Constants for {@link #shutdownOrRebootInternal} */ 200 @Retention(RetentionPolicy.SOURCE) 201 @IntDef({HALT_MODE_SHUTDOWN, HALT_MODE_REBOOT, HALT_MODE_REBOOT_SAFE_MODE}) 202 public @interface HaltMode {} 203 private static final int HALT_MODE_SHUTDOWN = 0; 204 private static final int HALT_MODE_REBOOT = 1; 205 private static final int HALT_MODE_REBOOT_SAFE_MODE = 2; 206 207 private final Context mContext; 208 private final ServiceThread mHandlerThread; 209 private final PowerManagerHandler mHandler; 210 private final AmbientDisplayConfiguration mAmbientDisplayConfiguration; 211 private final BatterySaverPolicy mBatterySaverPolicy; 212 213 private LightsManager mLightsManager; 214 private BatteryManagerInternal mBatteryManagerInternal; 215 private DisplayManagerInternal mDisplayManagerInternal; 216 private IBatteryStats mBatteryStats; 217 private IAppOpsService mAppOps; 218 private WindowManagerPolicy mPolicy; 219 private Notifier mNotifier; 220 private WirelessChargerDetector mWirelessChargerDetector; 221 private SettingsObserver mSettingsObserver; 222 private DreamManagerInternal mDreamManager; 223 private Light mAttentionLight; 224 225 private final Object mLock = LockGuard.installNewLock(LockGuard.INDEX_POWER); 226 227 // A bitfield that indicates what parts of the power state have 228 // changed and need to be recalculated. 229 private int mDirty; 230 231 // Indicates whether the device is awake or asleep or somewhere in between. 232 // This is distinct from the screen power state, which is managed separately. 233 private int mWakefulness; 234 private boolean mWakefulnessChanging; 235 236 // True if the sandman has just been summoned for the first time since entering the 237 // dreaming or dozing state. Indicates whether a new dream should begin. 238 private boolean mSandmanSummoned; 239 240 // True if MSG_SANDMAN has been scheduled. 241 private boolean mSandmanScheduled; 242 243 // Table of all suspend blockers. 244 // There should only be a few of these. 245 private final ArrayList<SuspendBlocker> mSuspendBlockers = new ArrayList<SuspendBlocker>(); 246 247 // Table of all wake locks acquired by applications. 248 private final ArrayList<WakeLock> mWakeLocks = new ArrayList<WakeLock>(); 249 250 // A bitfield that summarizes the state of all active wakelocks. 251 private int mWakeLockSummary; 252 253 // Have we scheduled a message to check for long wake locks? This is when we will check. 254 private long mNotifyLongScheduled; 255 256 // Last time we checked for long wake locks. 257 private long mNotifyLongDispatched; 258 259 // The time we decided to do next long check. 260 private long mNotifyLongNextCheck; 261 262 // If true, instructs the display controller to wait for the proximity sensor to 263 // go negative before turning the screen on. 264 private boolean mRequestWaitForNegativeProximity; 265 266 // Timestamp of the last time the device was awoken or put to sleep. 267 private long mLastWakeTime; 268 private long mLastSleepTime; 269 270 // Timestamp of the last call to user activity. 271 private long mLastUserActivityTime; 272 private long mLastUserActivityTimeNoChangeLights; 273 274 // Timestamp of last interactive power hint. 275 private long mLastInteractivePowerHintTime; 276 277 // Timestamp of the last screen brightness boost. 278 private long mLastScreenBrightnessBoostTime; 279 private boolean mScreenBrightnessBoostInProgress; 280 281 // A bitfield that summarizes the effect of the user activity timer. 282 private int mUserActivitySummary; 283 284 // The desired display power state. The actual state may lag behind the 285 // requested because it is updated asynchronously by the display power controller. 286 private final DisplayPowerRequest mDisplayPowerRequest = new DisplayPowerRequest(); 287 288 // True if the display power state has been fully applied, which means the display 289 // is actually on or actually off or whatever was requested. 290 private boolean mDisplayReady; 291 292 // The suspend blocker used to keep the CPU alive when an application has acquired 293 // a wake lock. 294 private final SuspendBlocker mWakeLockSuspendBlocker; 295 296 // True if the wake lock suspend blocker has been acquired. 297 private boolean mHoldingWakeLockSuspendBlocker; 298 299 // The suspend blocker used to keep the CPU alive when the display is on, the 300 // display is getting ready or there is user activity (in which case the display 301 // must be on). 302 private final SuspendBlocker mDisplaySuspendBlocker; 303 304 // True if the display suspend blocker has been acquired. 305 private boolean mHoldingDisplaySuspendBlocker; 306 307 // True if systemReady() has been called. 308 private boolean mSystemReady; 309 310 // True if boot completed occurred. We keep the screen on until this happens. 311 private boolean mBootCompleted; 312 313 // Runnables that should be triggered on boot completed 314 private Runnable[] mBootCompletedRunnables; 315 316 // True if auto-suspend mode is enabled. 317 // Refer to autosuspend.h. 318 private boolean mHalAutoSuspendModeEnabled; 319 320 // True if interactive mode is enabled. 321 // Refer to power.h. 322 private boolean mHalInteractiveModeEnabled; 323 324 // True if the device is plugged into a power source. 325 private boolean mIsPowered; 326 327 // The current plug type, such as BatteryManager.BATTERY_PLUGGED_WIRELESS. 328 private int mPlugType; 329 330 // The current battery level percentage. 331 private int mBatteryLevel; 332 333 // The battery level percentage at the time the dream started. 334 // This is used to terminate a dream and go to sleep if the battery is 335 // draining faster than it is charging and the user activity timeout has expired. 336 private int mBatteryLevelWhenDreamStarted; 337 338 // The current dock state. 339 private int mDockState = Intent.EXTRA_DOCK_STATE_UNDOCKED; 340 341 // True to decouple auto-suspend mode from the display state. 342 private boolean mDecoupleHalAutoSuspendModeFromDisplayConfig; 343 344 // True to decouple interactive mode from the display state. 345 private boolean mDecoupleHalInteractiveModeFromDisplayConfig; 346 347 // True if the device should wake up when plugged or unplugged. 348 private boolean mWakeUpWhenPluggedOrUnpluggedConfig; 349 350 // True if the device should wake up when plugged or unplugged in theater mode. 351 private boolean mWakeUpWhenPluggedOrUnpluggedInTheaterModeConfig; 352 353 // True if the device should suspend when the screen is off due to proximity. 354 private boolean mSuspendWhenScreenOffDueToProximityConfig; 355 356 // True if dreams are supported on this device. 357 private boolean mDreamsSupportedConfig; 358 359 // Default value for dreams enabled 360 private boolean mDreamsEnabledByDefaultConfig; 361 362 // Default value for dreams activate-on-sleep 363 private boolean mDreamsActivatedOnSleepByDefaultConfig; 364 365 // Default value for dreams activate-on-dock 366 private boolean mDreamsActivatedOnDockByDefaultConfig; 367 368 // True if dreams can run while not plugged in. 369 private boolean mDreamsEnabledOnBatteryConfig; 370 371 // Minimum battery level to allow dreaming when powered. 372 // Use -1 to disable this safety feature. 373 private int mDreamsBatteryLevelMinimumWhenPoweredConfig; 374 375 // Minimum battery level to allow dreaming when not powered. 376 // Use -1 to disable this safety feature. 377 private int mDreamsBatteryLevelMinimumWhenNotPoweredConfig; 378 379 // If the battery level drops by this percentage and the user activity timeout 380 // has expired, then assume the device is receiving insufficient current to charge 381 // effectively and terminate the dream. Use -1 to disable this safety feature. 382 private int mDreamsBatteryLevelDrainCutoffConfig; 383 384 // True if dreams are enabled by the user. 385 private boolean mDreamsEnabledSetting; 386 387 // True if dreams should be activated on sleep. 388 private boolean mDreamsActivateOnSleepSetting; 389 390 // True if dreams should be activated on dock. 391 private boolean mDreamsActivateOnDockSetting; 392 393 // True if doze should not be started until after the screen off transition. 394 private boolean mDozeAfterScreenOffConfig; 395 396 // The minimum screen off timeout, in milliseconds. 397 private int mMinimumScreenOffTimeoutConfig; 398 399 // The screen dim duration, in milliseconds. 400 // This is subtracted from the end of the screen off timeout so the 401 // minimum screen off timeout should be longer than this. 402 private int mMaximumScreenDimDurationConfig; 403 404 // The maximum screen dim time expressed as a ratio relative to the screen 405 // off timeout. If the screen off timeout is very short then we want the 406 // dim timeout to also be quite short so that most of the time is spent on. 407 // Otherwise the user won't get much screen on time before dimming occurs. 408 private float mMaximumScreenDimRatioConfig; 409 410 // Whether device supports double tap to wake. 411 private boolean mSupportsDoubleTapWakeConfig; 412 413 // The screen off timeout setting value in milliseconds. 414 private int mScreenOffTimeoutSetting; 415 416 // The sleep timeout setting value in milliseconds. 417 private int mSleepTimeoutSetting; 418 419 // The maximum allowable screen off timeout according to the device 420 // administration policy. Overrides other settings. 421 private int mMaximumScreenOffTimeoutFromDeviceAdmin = Integer.MAX_VALUE; 422 423 // The stay on while plugged in setting. 424 // A bitfield of battery conditions under which to make the screen stay on. 425 private int mStayOnWhilePluggedInSetting; 426 427 // True if the device should stay on. 428 private boolean mStayOn; 429 430 // True if the lights should stay off until an explicit user action. 431 private static boolean sQuiescent; 432 433 // True if the proximity sensor reads a positive result. 434 private boolean mProximityPositive; 435 436 // Screen brightness setting limits. 437 private int mScreenBrightnessSettingMinimum; 438 private int mScreenBrightnessSettingMaximum; 439 private int mScreenBrightnessSettingDefault; 440 private int mScreenBrightnessForVrSettingDefault; 441 442 // The screen brightness setting, from 0 to 255. 443 // Use -1 if no value has been set. 444 private int mScreenBrightnessSetting; 445 446 // The screen brightness setting, from 0 to 255, to be used while in VR Mode. 447 private int mScreenBrightnessForVrSetting; 448 449 // The screen auto-brightness adjustment setting, from -1 to 1. 450 // Use 0 if there is no adjustment. 451 private float mScreenAutoBrightnessAdjustmentSetting; 452 453 // The screen brightness mode. 454 // One of the Settings.System.SCREEN_BRIGHTNESS_MODE_* constants. 455 private int mScreenBrightnessModeSetting; 456 457 // The screen brightness setting override from the window manager 458 // to allow the current foreground activity to override the brightness. 459 // Use -1 to disable. 460 private int mScreenBrightnessOverrideFromWindowManager = -1; 461 462 // The window manager has determined the user to be inactive via other means. 463 // Set this to false to disable. 464 private boolean mUserInactiveOverrideFromWindowManager; 465 466 // The next possible user activity timeout after being explicitly told the user is inactive. 467 // Set to -1 when not told the user is inactive since the last period spent dozing or asleep. 468 private long mOverriddenTimeout = -1; 469 470 // The user activity timeout override from the window manager 471 // to allow the current foreground activity to override the user activity timeout. 472 // Use -1 to disable. 473 private long mUserActivityTimeoutOverrideFromWindowManager = -1; 474 475 // The screen brightness setting override from the settings application 476 // to temporarily adjust the brightness until next updated, 477 // Use -1 to disable. 478 private int mTemporaryScreenBrightnessSettingOverride = -1; 479 480 // The screen brightness adjustment setting override from the settings 481 // application to temporarily adjust the auto-brightness adjustment factor 482 // until next updated, in the range -1..1. 483 // Use NaN to disable. 484 private float mTemporaryScreenAutoBrightnessAdjustmentSettingOverride = Float.NaN; 485 486 // The screen state to use while dozing. 487 private int mDozeScreenStateOverrideFromDreamManager = Display.STATE_UNKNOWN; 488 489 // The screen brightness to use while dozing. 490 private int mDozeScreenBrightnessOverrideFromDreamManager = PowerManager.BRIGHTNESS_DEFAULT; 491 492 // Time when we last logged a warning about calling userActivity() without permission. 493 private long mLastWarningAboutUserActivityPermission = Long.MIN_VALUE; 494 495 // If true, the device is in low power mode. 496 private boolean mLowPowerModeEnabled; 497 498 // Current state of the low power mode setting. 499 private boolean mLowPowerModeSetting; 500 501 // Current state of whether the settings are allowing auto low power mode. 502 private boolean mAutoLowPowerModeConfigured; 503 504 // The user turned off low power mode below the trigger level 505 private boolean mAutoLowPowerModeSnoozing; 506 507 // True if the battery level is currently considered low. 508 private boolean mBatteryLevelLow; 509 510 // True if we are currently in device idle mode. 511 private boolean mDeviceIdleMode; 512 513 // True if we are currently in light device idle mode. 514 private boolean mLightDeviceIdleMode; 515 516 // Set of app ids that we will always respect the wake locks for. 517 int[] mDeviceIdleWhitelist = new int[0]; 518 519 // Set of app ids that are temporarily allowed to acquire wakelocks due to high-pri message 520 int[] mDeviceIdleTempWhitelist = new int[0]; 521 522 private final SparseArray<UidState> mUidState = new SparseArray<>(); 523 524 // We are currently in the middle of a batch change of uids. 525 private boolean mUidsChanging; 526 527 // Some uids have actually changed while mUidsChanging was true. 528 private boolean mUidsChanged; 529 530 // True if theater mode is enabled 531 private boolean mTheaterModeEnabled; 532 533 // True if always on display is enabled 534 private boolean mAlwaysOnEnabled; 535 536 // True if double tap to wake is enabled 537 private boolean mDoubleTapWakeEnabled; 538 539 private final ArrayList<PowerManagerInternal.LowPowerModeListener> mLowPowerModeListeners 540 = new ArrayList<PowerManagerInternal.LowPowerModeListener>(); 541 542 // True if we are currently in VR Mode. 543 private boolean mIsVrModeEnabled; 544 545 /** 546 * All times are in milliseconds. These constants are kept synchronized with the system 547 * global Settings. Any access to this class or its fields should be done while 548 * holding the PowerManagerService.mLock lock. 549 */ 550 private final class Constants extends ContentObserver { 551 // Key names stored in the settings value. 552 private static final String KEY_NO_CACHED_WAKE_LOCKS = "no_cached_wake_locks"; 553 554 private static final boolean DEFAULT_NO_CACHED_WAKE_LOCKS = true; 555 556 // Prevent processes that are cached from holding wake locks? 557 public boolean NO_CACHED_WAKE_LOCKS = DEFAULT_NO_CACHED_WAKE_LOCKS; 558 559 private ContentResolver mResolver; 560 private final KeyValueListParser mParser = new KeyValueListParser(','); 561 562 public Constants(Handler handler) { 563 super(handler); 564 } 565 566 public void start(ContentResolver resolver) { 567 mResolver = resolver; 568 mResolver.registerContentObserver(Settings.Global.getUriFor( 569 Settings.Global.POWER_MANAGER_CONSTANTS), false, this); 570 updateConstants(); 571 } 572 573 @Override 574 public void onChange(boolean selfChange, Uri uri) { 575 updateConstants(); 576 } 577 578 private void updateConstants() { 579 synchronized (mLock) { 580 try { 581 mParser.setString(Settings.Global.getString(mResolver, 582 Settings.Global.POWER_MANAGER_CONSTANTS)); 583 } catch (IllegalArgumentException e) { 584 // Failed to parse the settings string, log this and move on 585 // with defaults. 586 Slog.e(TAG, "Bad alarm manager settings", e); 587 } 588 589 NO_CACHED_WAKE_LOCKS = mParser.getBoolean(KEY_NO_CACHED_WAKE_LOCKS, 590 DEFAULT_NO_CACHED_WAKE_LOCKS); 591 } 592 } 593 594 void dump(PrintWriter pw) { 595 pw.println(" Settings " + Settings.Global.POWER_MANAGER_CONSTANTS + ":"); 596 597 pw.print(" "); pw.print(KEY_NO_CACHED_WAKE_LOCKS); pw.print("="); 598 pw.println(NO_CACHED_WAKE_LOCKS); 599 } 600 601 void dumpProto(ProtoOutputStream proto) { 602 final long constantsToken = proto.start(PowerServiceDumpProto.CONSTANTS); 603 proto.write(PowerServiceDumpProto.ConstantsProto.IS_NO_CACHED_WAKE_LOCKS, 604 NO_CACHED_WAKE_LOCKS); 605 proto.end(constantsToken); 606 } 607 } 608 609 final Constants mConstants; 610 611 private native void nativeInit(); 612 613 private static native void nativeAcquireSuspendBlocker(String name); 614 private static native void nativeReleaseSuspendBlocker(String name); 615 private static native void nativeSetInteractive(boolean enable); 616 private static native void nativeSetAutoSuspend(boolean enable); 617 private static native void nativeSendPowerHint(int hintId, int data); 618 private static native void nativeSetFeature(int featureId, int data); 619 620 public PowerManagerService(Context context) { 621 super(context); 622 mContext = context; 623 mHandlerThread = new ServiceThread(TAG, 624 Process.THREAD_PRIORITY_DISPLAY, false /*allowIo*/); 625 mHandlerThread.start(); 626 mHandler = new PowerManagerHandler(mHandlerThread.getLooper()); 627 mConstants = new Constants(mHandler); 628 mAmbientDisplayConfiguration = new AmbientDisplayConfiguration(mContext); 629 mBatterySaverPolicy = new BatterySaverPolicy(mHandler); 630 631 synchronized (mLock) { 632 mWakeLockSuspendBlocker = createSuspendBlockerLocked("PowerManagerService.WakeLocks"); 633 mDisplaySuspendBlocker = createSuspendBlockerLocked("PowerManagerService.Display"); 634 mDisplaySuspendBlocker.acquire(); 635 mHoldingDisplaySuspendBlocker = true; 636 mHalAutoSuspendModeEnabled = false; 637 mHalInteractiveModeEnabled = true; 638 639 mWakefulness = WAKEFULNESS_AWAKE; 640 641 sQuiescent = SystemProperties.get(SYSTEM_PROPERTY_QUIESCENT, "0").equals("1"); 642 643 nativeInit(); 644 nativeSetAutoSuspend(false); 645 nativeSetInteractive(true); 646 nativeSetFeature(POWER_FEATURE_DOUBLE_TAP_TO_WAKE, 0); 647 } 648 } 649 650 @VisibleForTesting 651 PowerManagerService(Context context, BatterySaverPolicy batterySaverPolicy) { 652 super(context); 653 654 mBatterySaverPolicy = batterySaverPolicy; 655 mContext = context; 656 mHandlerThread = new ServiceThread(TAG, 657 Process.THREAD_PRIORITY_DISPLAY, false /*allowIo*/); 658 mHandlerThread.start(); 659 mHandler = new PowerManagerHandler(mHandlerThread.getLooper()); 660 mConstants = new Constants(mHandler); 661 mAmbientDisplayConfiguration = new AmbientDisplayConfiguration(mContext); 662 mDisplaySuspendBlocker = null; 663 mWakeLockSuspendBlocker = null; 664 } 665 666 @Override 667 public void onStart() { 668 publishBinderService(Context.POWER_SERVICE, new BinderService()); 669 publishLocalService(PowerManagerInternal.class, new LocalService()); 670 671 Watchdog.getInstance().addMonitor(this); 672 Watchdog.getInstance().addThread(mHandler); 673 } 674 675 @Override 676 public void onBootPhase(int phase) { 677 synchronized (mLock) { 678 if (phase == PHASE_THIRD_PARTY_APPS_CAN_START) { 679 incrementBootCount(); 680 681 } else if (phase == PHASE_BOOT_COMPLETED) { 682 final long now = SystemClock.uptimeMillis(); 683 mBootCompleted = true; 684 mDirty |= DIRTY_BOOT_COMPLETED; 685 userActivityNoUpdateLocked( 686 now, PowerManager.USER_ACTIVITY_EVENT_OTHER, 0, Process.SYSTEM_UID); 687 updatePowerStateLocked(); 688 689 if (!ArrayUtils.isEmpty(mBootCompletedRunnables)) { 690 Slog.d(TAG, "Posting " + mBootCompletedRunnables.length + " delayed runnables"); 691 for (Runnable r : mBootCompletedRunnables) { 692 BackgroundThread.getHandler().post(r); 693 } 694 } 695 mBootCompletedRunnables = null; 696 } 697 } 698 } 699 700 public void systemReady(IAppOpsService appOps) { 701 synchronized (mLock) { 702 mSystemReady = true; 703 mAppOps = appOps; 704 mDreamManager = getLocalService(DreamManagerInternal.class); 705 mDisplayManagerInternal = getLocalService(DisplayManagerInternal.class); 706 mPolicy = getLocalService(WindowManagerPolicy.class); 707 mBatteryManagerInternal = getLocalService(BatteryManagerInternal.class); 708 709 PowerManager pm = (PowerManager) mContext.getSystemService(Context.POWER_SERVICE); 710 mScreenBrightnessSettingMinimum = pm.getMinimumScreenBrightnessSetting(); 711 mScreenBrightnessSettingMaximum = pm.getMaximumScreenBrightnessSetting(); 712 mScreenBrightnessSettingDefault = pm.getDefaultScreenBrightnessSetting(); 713 mScreenBrightnessForVrSettingDefault = pm.getDefaultScreenBrightnessForVrSetting(); 714 715 SensorManager sensorManager = new SystemSensorManager(mContext, mHandler.getLooper()); 716 717 // The notifier runs on the system server's main looper so as not to interfere 718 // with the animations and other critical functions of the power manager. 719 mBatteryStats = BatteryStatsService.getService(); 720 mNotifier = new Notifier(Looper.getMainLooper(), mContext, mBatteryStats, 721 mAppOps, createSuspendBlockerLocked("PowerManagerService.Broadcasts"), 722 mPolicy); 723 724 mWirelessChargerDetector = new WirelessChargerDetector(sensorManager, 725 createSuspendBlockerLocked("PowerManagerService.WirelessChargerDetector"), 726 mHandler); 727 mSettingsObserver = new SettingsObserver(mHandler); 728 729 mLightsManager = getLocalService(LightsManager.class); 730 mAttentionLight = mLightsManager.getLight(LightsManager.LIGHT_ID_ATTENTION); 731 732 // Initialize display power management. 733 mDisplayManagerInternal.initPowerManagement( 734 mDisplayPowerCallbacks, mHandler, sensorManager); 735 736 // Go. 737 readConfigurationLocked(); 738 updateSettingsLocked(); 739 mDirty |= DIRTY_BATTERY_STATE; 740 updatePowerStateLocked(); 741 } 742 743 final ContentResolver resolver = mContext.getContentResolver(); 744 mConstants.start(resolver); 745 mBatterySaverPolicy.start(resolver); 746 747 // Register for settings changes. 748 resolver.registerContentObserver(Settings.Secure.getUriFor( 749 Settings.Secure.SCREENSAVER_ENABLED), 750 false, mSettingsObserver, UserHandle.USER_ALL); 751 resolver.registerContentObserver(Settings.Secure.getUriFor( 752 Settings.Secure.SCREENSAVER_ACTIVATE_ON_SLEEP), 753 false, mSettingsObserver, UserHandle.USER_ALL); 754 resolver.registerContentObserver(Settings.Secure.getUriFor( 755 Settings.Secure.SCREENSAVER_ACTIVATE_ON_DOCK), 756 false, mSettingsObserver, UserHandle.USER_ALL); 757 resolver.registerContentObserver(Settings.System.getUriFor( 758 Settings.System.SCREEN_OFF_TIMEOUT), 759 false, mSettingsObserver, UserHandle.USER_ALL); 760 resolver.registerContentObserver(Settings.Secure.getUriFor( 761 Settings.Secure.SLEEP_TIMEOUT), 762 false, mSettingsObserver, UserHandle.USER_ALL); 763 resolver.registerContentObserver(Settings.Global.getUriFor( 764 Settings.Global.STAY_ON_WHILE_PLUGGED_IN), 765 false, mSettingsObserver, UserHandle.USER_ALL); 766 resolver.registerContentObserver(Settings.System.getUriFor( 767 Settings.System.SCREEN_BRIGHTNESS), 768 false, mSettingsObserver, UserHandle.USER_ALL); 769 resolver.registerContentObserver(Settings.System.getUriFor( 770 Settings.System.SCREEN_BRIGHTNESS_FOR_VR), 771 false, mSettingsObserver, UserHandle.USER_ALL); 772 resolver.registerContentObserver(Settings.System.getUriFor( 773 Settings.System.SCREEN_BRIGHTNESS_MODE), 774 false, mSettingsObserver, UserHandle.USER_ALL); 775 resolver.registerContentObserver(Settings.System.getUriFor( 776 Settings.System.SCREEN_AUTO_BRIGHTNESS_ADJ), 777 false, mSettingsObserver, UserHandle.USER_ALL); 778 resolver.registerContentObserver(Settings.Global.getUriFor( 779 Settings.Global.LOW_POWER_MODE), 780 false, mSettingsObserver, UserHandle.USER_ALL); 781 resolver.registerContentObserver(Settings.Global.getUriFor( 782 Settings.Global.LOW_POWER_MODE_TRIGGER_LEVEL), 783 false, mSettingsObserver, UserHandle.USER_ALL); 784 resolver.registerContentObserver(Settings.Global.getUriFor( 785 Settings.Global.THEATER_MODE_ON), 786 false, mSettingsObserver, UserHandle.USER_ALL); 787 resolver.registerContentObserver(Settings.Secure.getUriFor( 788 Settings.Secure.DOZE_ALWAYS_ON), 789 false, mSettingsObserver, UserHandle.USER_ALL); 790 resolver.registerContentObserver(Settings.Secure.getUriFor( 791 Settings.Secure.DOUBLE_TAP_TO_WAKE), 792 false, mSettingsObserver, UserHandle.USER_ALL); 793 IVrManager vrManager = (IVrManager) getBinderService(Context.VR_SERVICE); 794 if (vrManager != null) { 795 try { 796 vrManager.registerListener(mVrStateCallbacks); 797 } catch (RemoteException e) { 798 Slog.e(TAG, "Failed to register VR mode state listener: " + e); 799 } 800 } 801 802 // Register for broadcasts from other components of the system. 803 IntentFilter filter = new IntentFilter(); 804 filter.addAction(Intent.ACTION_BATTERY_CHANGED); 805 filter.setPriority(IntentFilter.SYSTEM_HIGH_PRIORITY); 806 mContext.registerReceiver(new BatteryReceiver(), filter, null, mHandler); 807 808 filter = new IntentFilter(); 809 filter.addAction(Intent.ACTION_DREAMING_STARTED); 810 filter.addAction(Intent.ACTION_DREAMING_STOPPED); 811 mContext.registerReceiver(new DreamReceiver(), filter, null, mHandler); 812 813 filter = new IntentFilter(); 814 filter.addAction(Intent.ACTION_USER_SWITCHED); 815 mContext.registerReceiver(new UserSwitchedReceiver(), filter, null, mHandler); 816 817 filter = new IntentFilter(); 818 filter.addAction(Intent.ACTION_DOCK_EVENT); 819 mContext.registerReceiver(new DockReceiver(), filter, null, mHandler); 820 } 821 822 private void readConfigurationLocked() { 823 final Resources resources = mContext.getResources(); 824 825 mDecoupleHalAutoSuspendModeFromDisplayConfig = resources.getBoolean( 826 com.android.internal.R.bool.config_powerDecoupleAutoSuspendModeFromDisplay); 827 mDecoupleHalInteractiveModeFromDisplayConfig = resources.getBoolean( 828 com.android.internal.R.bool.config_powerDecoupleInteractiveModeFromDisplay); 829 mWakeUpWhenPluggedOrUnpluggedConfig = resources.getBoolean( 830 com.android.internal.R.bool.config_unplugTurnsOnScreen); 831 mWakeUpWhenPluggedOrUnpluggedInTheaterModeConfig = resources.getBoolean( 832 com.android.internal.R.bool.config_allowTheaterModeWakeFromUnplug); 833 mSuspendWhenScreenOffDueToProximityConfig = resources.getBoolean( 834 com.android.internal.R.bool.config_suspendWhenScreenOffDueToProximity); 835 mDreamsSupportedConfig = resources.getBoolean( 836 com.android.internal.R.bool.config_dreamsSupported); 837 mDreamsEnabledByDefaultConfig = resources.getBoolean( 838 com.android.internal.R.bool.config_dreamsEnabledByDefault); 839 mDreamsActivatedOnSleepByDefaultConfig = resources.getBoolean( 840 com.android.internal.R.bool.config_dreamsActivatedOnSleepByDefault); 841 mDreamsActivatedOnDockByDefaultConfig = resources.getBoolean( 842 com.android.internal.R.bool.config_dreamsActivatedOnDockByDefault); 843 mDreamsEnabledOnBatteryConfig = resources.getBoolean( 844 com.android.internal.R.bool.config_dreamsEnabledOnBattery); 845 mDreamsBatteryLevelMinimumWhenPoweredConfig = resources.getInteger( 846 com.android.internal.R.integer.config_dreamsBatteryLevelMinimumWhenPowered); 847 mDreamsBatteryLevelMinimumWhenNotPoweredConfig = resources.getInteger( 848 com.android.internal.R.integer.config_dreamsBatteryLevelMinimumWhenNotPowered); 849 mDreamsBatteryLevelDrainCutoffConfig = resources.getInteger( 850 com.android.internal.R.integer.config_dreamsBatteryLevelDrainCutoff); 851 mDozeAfterScreenOffConfig = resources.getBoolean( 852 com.android.internal.R.bool.config_dozeAfterScreenOff); 853 mMinimumScreenOffTimeoutConfig = resources.getInteger( 854 com.android.internal.R.integer.config_minimumScreenOffTimeout); 855 mMaximumScreenDimDurationConfig = resources.getInteger( 856 com.android.internal.R.integer.config_maximumScreenDimDuration); 857 mMaximumScreenDimRatioConfig = resources.getFraction( 858 com.android.internal.R.fraction.config_maximumScreenDimRatio, 1, 1); 859 mSupportsDoubleTapWakeConfig = resources.getBoolean( 860 com.android.internal.R.bool.config_supportDoubleTapWake); 861 } 862 863 private void updateSettingsLocked() { 864 final ContentResolver resolver = mContext.getContentResolver(); 865 866 mDreamsEnabledSetting = (Settings.Secure.getIntForUser(resolver, 867 Settings.Secure.SCREENSAVER_ENABLED, 868 mDreamsEnabledByDefaultConfig ? 1 : 0, 869 UserHandle.USER_CURRENT) != 0); 870 mDreamsActivateOnSleepSetting = (Settings.Secure.getIntForUser(resolver, 871 Settings.Secure.SCREENSAVER_ACTIVATE_ON_SLEEP, 872 mDreamsActivatedOnSleepByDefaultConfig ? 1 : 0, 873 UserHandle.USER_CURRENT) != 0); 874 mDreamsActivateOnDockSetting = (Settings.Secure.getIntForUser(resolver, 875 Settings.Secure.SCREENSAVER_ACTIVATE_ON_DOCK, 876 mDreamsActivatedOnDockByDefaultConfig ? 1 : 0, 877 UserHandle.USER_CURRENT) != 0); 878 mScreenOffTimeoutSetting = Settings.System.getIntForUser(resolver, 879 Settings.System.SCREEN_OFF_TIMEOUT, DEFAULT_SCREEN_OFF_TIMEOUT, 880 UserHandle.USER_CURRENT); 881 mSleepTimeoutSetting = Settings.Secure.getIntForUser(resolver, 882 Settings.Secure.SLEEP_TIMEOUT, DEFAULT_SLEEP_TIMEOUT, 883 UserHandle.USER_CURRENT); 884 mStayOnWhilePluggedInSetting = Settings.Global.getInt(resolver, 885 Settings.Global.STAY_ON_WHILE_PLUGGED_IN, BatteryManager.BATTERY_PLUGGED_AC); 886 mTheaterModeEnabled = Settings.Global.getInt(mContext.getContentResolver(), 887 Settings.Global.THEATER_MODE_ON, 0) == 1; 888 mAlwaysOnEnabled = mAmbientDisplayConfiguration.alwaysOnEnabled(UserHandle.USER_CURRENT); 889 890 if (mSupportsDoubleTapWakeConfig) { 891 boolean doubleTapWakeEnabled = Settings.Secure.getIntForUser(resolver, 892 Settings.Secure.DOUBLE_TAP_TO_WAKE, DEFAULT_DOUBLE_TAP_TO_WAKE, 893 UserHandle.USER_CURRENT) != 0; 894 if (doubleTapWakeEnabled != mDoubleTapWakeEnabled) { 895 mDoubleTapWakeEnabled = doubleTapWakeEnabled; 896 nativeSetFeature(POWER_FEATURE_DOUBLE_TAP_TO_WAKE, mDoubleTapWakeEnabled ? 1 : 0); 897 } 898 } 899 900 final int oldScreenBrightnessSetting = getCurrentBrightnessSettingLocked(); 901 902 mScreenBrightnessForVrSetting = Settings.System.getIntForUser(resolver, 903 Settings.System.SCREEN_BRIGHTNESS_FOR_VR, mScreenBrightnessForVrSettingDefault, 904 UserHandle.USER_CURRENT); 905 906 mScreenBrightnessSetting = Settings.System.getIntForUser(resolver, 907 Settings.System.SCREEN_BRIGHTNESS, mScreenBrightnessSettingDefault, 908 UserHandle.USER_CURRENT); 909 910 if (oldScreenBrightnessSetting != getCurrentBrightnessSettingLocked()) { 911 mTemporaryScreenBrightnessSettingOverride = -1; 912 } 913 914 final float oldScreenAutoBrightnessAdjustmentSetting = 915 mScreenAutoBrightnessAdjustmentSetting; 916 mScreenAutoBrightnessAdjustmentSetting = Settings.System.getFloatForUser(resolver, 917 Settings.System.SCREEN_AUTO_BRIGHTNESS_ADJ, 0.0f, 918 UserHandle.USER_CURRENT); 919 if (oldScreenAutoBrightnessAdjustmentSetting != mScreenAutoBrightnessAdjustmentSetting) { 920 mTemporaryScreenAutoBrightnessAdjustmentSettingOverride = Float.NaN; 921 } 922 923 mScreenBrightnessModeSetting = Settings.System.getIntForUser(resolver, 924 Settings.System.SCREEN_BRIGHTNESS_MODE, 925 Settings.System.SCREEN_BRIGHTNESS_MODE_MANUAL, UserHandle.USER_CURRENT); 926 927 final boolean lowPowerModeEnabled = Settings.Global.getInt(resolver, 928 Settings.Global.LOW_POWER_MODE, 0) != 0; 929 final boolean autoLowPowerModeConfigured = Settings.Global.getInt(resolver, 930 Settings.Global.LOW_POWER_MODE_TRIGGER_LEVEL, 0) != 0; 931 if (lowPowerModeEnabled != mLowPowerModeSetting 932 || autoLowPowerModeConfigured != mAutoLowPowerModeConfigured) { 933 mLowPowerModeSetting = lowPowerModeEnabled; 934 mAutoLowPowerModeConfigured = autoLowPowerModeConfigured; 935 updateLowPowerModeLocked(); 936 } 937 938 mDirty |= DIRTY_SETTINGS; 939 } 940 941 private int getCurrentBrightnessSettingLocked() { 942 return mIsVrModeEnabled ? mScreenBrightnessForVrSetting : mScreenBrightnessSetting; 943 } 944 945 private void postAfterBootCompleted(Runnable r) { 946 if (mBootCompleted) { 947 BackgroundThread.getHandler().post(r); 948 } else { 949 Slog.d(TAG, "Delaying runnable until system is booted"); 950 mBootCompletedRunnables = ArrayUtils.appendElement(Runnable.class, 951 mBootCompletedRunnables, r); 952 } 953 } 954 955 private void updateLowPowerModeLocked() { 956 if ((mIsPowered || !mBatteryLevelLow && !mBootCompleted) && mLowPowerModeSetting) { 957 if (DEBUG_SPEW) { 958 Slog.d(TAG, "updateLowPowerModeLocked: powered or booting with sufficient battery," 959 + " turning setting off"); 960 } 961 // Turn setting off if powered 962 Settings.Global.putInt(mContext.getContentResolver(), 963 Settings.Global.LOW_POWER_MODE, 0); 964 mLowPowerModeSetting = false; 965 } 966 final boolean autoLowPowerModeEnabled = !mIsPowered && mAutoLowPowerModeConfigured 967 && !mAutoLowPowerModeSnoozing && mBatteryLevelLow; 968 final boolean lowPowerModeEnabled = mLowPowerModeSetting || autoLowPowerModeEnabled; 969 970 if (mLowPowerModeEnabled != lowPowerModeEnabled) { 971 mLowPowerModeEnabled = lowPowerModeEnabled; 972 powerHintInternal(PowerHint.LOW_POWER, lowPowerModeEnabled ? 1 : 0); 973 postAfterBootCompleted(new Runnable() { 974 @Override 975 public void run() { 976 Intent intent = new Intent(PowerManager.ACTION_POWER_SAVE_MODE_CHANGING) 977 .putExtra(PowerManager.EXTRA_POWER_SAVE_MODE, mLowPowerModeEnabled) 978 .addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY); 979 mContext.sendBroadcast(intent); 980 ArrayList<PowerManagerInternal.LowPowerModeListener> listeners; 981 synchronized (mLock) { 982 listeners = new ArrayList<PowerManagerInternal.LowPowerModeListener>( 983 mLowPowerModeListeners); 984 } 985 for (int i = 0; i < listeners.size(); i++) { 986 final PowerManagerInternal.LowPowerModeListener listener = listeners.get(i); 987 final PowerSaveState result = 988 mBatterySaverPolicy.getBatterySaverPolicy( 989 listener.getServiceType(), lowPowerModeEnabled); 990 listener.onLowPowerModeChanged(result); 991 } 992 intent = new Intent(PowerManager.ACTION_POWER_SAVE_MODE_CHANGED); 993 intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY); 994 mContext.sendBroadcastAsUser(intent, UserHandle.ALL); 995 // Send internal version that requires signature permission. 996 intent = new Intent(PowerManager.ACTION_POWER_SAVE_MODE_CHANGED_INTERNAL); 997 intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY); 998 mContext.sendBroadcastAsUser(intent, UserHandle.ALL, 999 Manifest.permission.DEVICE_POWER); 1000 } 1001 }); 1002 } 1003 } 1004 1005 private void handleSettingsChangedLocked() { 1006 updateSettingsLocked(); 1007 updatePowerStateLocked(); 1008 } 1009 1010 private void acquireWakeLockInternal(IBinder lock, int flags, String tag, String packageName, 1011 WorkSource ws, String historyTag, int uid, int pid) { 1012 synchronized (mLock) { 1013 if (DEBUG_SPEW) { 1014 Slog.d(TAG, "acquireWakeLockInternal: lock=" + Objects.hashCode(lock) 1015 + ", flags=0x" + Integer.toHexString(flags) 1016 + ", tag=\"" + tag + "\", ws=" + ws + ", uid=" + uid + ", pid=" + pid); 1017 } 1018 1019 WakeLock wakeLock; 1020 int index = findWakeLockIndexLocked(lock); 1021 boolean notifyAcquire; 1022 if (index >= 0) { 1023 wakeLock = mWakeLocks.get(index); 1024 if (!wakeLock.hasSameProperties(flags, tag, ws, uid, pid)) { 1025 // Update existing wake lock. This shouldn't happen but is harmless. 1026 notifyWakeLockChangingLocked(wakeLock, flags, tag, packageName, 1027 uid, pid, ws, historyTag); 1028 wakeLock.updateProperties(flags, tag, packageName, ws, historyTag, uid, pid); 1029 } 1030 notifyAcquire = false; 1031 } else { 1032 UidState state = mUidState.get(uid); 1033 if (state == null) { 1034 state = new UidState(uid); 1035 state.mProcState = ActivityManager.PROCESS_STATE_NONEXISTENT; 1036 mUidState.put(uid, state); 1037 } 1038 state.mNumWakeLocks++; 1039 wakeLock = new WakeLock(lock, flags, tag, packageName, ws, historyTag, uid, pid, 1040 state); 1041 try { 1042 lock.linkToDeath(wakeLock, 0); 1043 } catch (RemoteException ex) { 1044 throw new IllegalArgumentException("Wake lock is already dead."); 1045 } 1046 mWakeLocks.add(wakeLock); 1047 setWakeLockDisabledStateLocked(wakeLock); 1048 notifyAcquire = true; 1049 } 1050 1051 applyWakeLockFlagsOnAcquireLocked(wakeLock, uid); 1052 mDirty |= DIRTY_WAKE_LOCKS; 1053 updatePowerStateLocked(); 1054 if (notifyAcquire) { 1055 // This needs to be done last so we are sure we have acquired the 1056 // kernel wake lock. Otherwise we have a race where the system may 1057 // go to sleep between the time we start the accounting in battery 1058 // stats and when we actually get around to telling the kernel to 1059 // stay awake. 1060 notifyWakeLockAcquiredLocked(wakeLock); 1061 } 1062 } 1063 } 1064 1065 @SuppressWarnings("deprecation") 1066 private static boolean isScreenLock(final WakeLock wakeLock) { 1067 switch (wakeLock.mFlags & PowerManager.WAKE_LOCK_LEVEL_MASK) { 1068 case PowerManager.FULL_WAKE_LOCK: 1069 case PowerManager.SCREEN_BRIGHT_WAKE_LOCK: 1070 case PowerManager.SCREEN_DIM_WAKE_LOCK: 1071 return true; 1072 } 1073 return false; 1074 } 1075 1076 private void applyWakeLockFlagsOnAcquireLocked(WakeLock wakeLock, int uid) { 1077 if ((wakeLock.mFlags & PowerManager.ACQUIRE_CAUSES_WAKEUP) != 0 1078 && isScreenLock(wakeLock)) { 1079 String opPackageName; 1080 int opUid; 1081 if (wakeLock.mWorkSource != null && wakeLock.mWorkSource.getName(0) != null) { 1082 opPackageName = wakeLock.mWorkSource.getName(0); 1083 opUid = wakeLock.mWorkSource.get(0); 1084 } else { 1085 opPackageName = wakeLock.mPackageName; 1086 opUid = wakeLock.mWorkSource != null ? wakeLock.mWorkSource.get(0) 1087 : wakeLock.mOwnerUid; 1088 } 1089 wakeUpNoUpdateLocked(SystemClock.uptimeMillis(), wakeLock.mTag, opUid, 1090 opPackageName, opUid); 1091 } 1092 } 1093 1094 private void releaseWakeLockInternal(IBinder lock, int flags) { 1095 synchronized (mLock) { 1096 int index = findWakeLockIndexLocked(lock); 1097 if (index < 0) { 1098 if (DEBUG_SPEW) { 1099 Slog.d(TAG, "releaseWakeLockInternal: lock=" + Objects.hashCode(lock) 1100 + " [not found], flags=0x" + Integer.toHexString(flags)); 1101 } 1102 return; 1103 } 1104 1105 WakeLock wakeLock = mWakeLocks.get(index); 1106 if (DEBUG_SPEW) { 1107 Slog.d(TAG, "releaseWakeLockInternal: lock=" + Objects.hashCode(lock) 1108 + " [" + wakeLock.mTag + "], flags=0x" + Integer.toHexString(flags)); 1109 } 1110 1111 if ((flags & PowerManager.RELEASE_FLAG_WAIT_FOR_NO_PROXIMITY) != 0) { 1112 mRequestWaitForNegativeProximity = true; 1113 } 1114 1115 wakeLock.mLock.unlinkToDeath(wakeLock, 0); 1116 removeWakeLockLocked(wakeLock, index); 1117 } 1118 } 1119 1120 private void handleWakeLockDeath(WakeLock wakeLock) { 1121 synchronized (mLock) { 1122 if (DEBUG_SPEW) { 1123 Slog.d(TAG, "handleWakeLockDeath: lock=" + Objects.hashCode(wakeLock.mLock) 1124 + " [" + wakeLock.mTag + "]"); 1125 } 1126 1127 int index = mWakeLocks.indexOf(wakeLock); 1128 if (index < 0) { 1129 return; 1130 } 1131 1132 removeWakeLockLocked(wakeLock, index); 1133 } 1134 } 1135 1136 private void removeWakeLockLocked(WakeLock wakeLock, int index) { 1137 mWakeLocks.remove(index); 1138 UidState state = wakeLock.mUidState; 1139 state.mNumWakeLocks--; 1140 if (state.mNumWakeLocks <= 0 && 1141 state.mProcState == ActivityManager.PROCESS_STATE_NONEXISTENT) { 1142 mUidState.remove(state.mUid); 1143 } 1144 notifyWakeLockReleasedLocked(wakeLock); 1145 1146 applyWakeLockFlagsOnReleaseLocked(wakeLock); 1147 mDirty |= DIRTY_WAKE_LOCKS; 1148 updatePowerStateLocked(); 1149 } 1150 1151 private void applyWakeLockFlagsOnReleaseLocked(WakeLock wakeLock) { 1152 if ((wakeLock.mFlags & PowerManager.ON_AFTER_RELEASE) != 0 1153 && isScreenLock(wakeLock)) { 1154 userActivityNoUpdateLocked(SystemClock.uptimeMillis(), 1155 PowerManager.USER_ACTIVITY_EVENT_OTHER, 1156 PowerManager.USER_ACTIVITY_FLAG_NO_CHANGE_LIGHTS, 1157 wakeLock.mOwnerUid); 1158 } 1159 } 1160 1161 private void updateWakeLockWorkSourceInternal(IBinder lock, WorkSource ws, String historyTag, 1162 int callingUid) { 1163 synchronized (mLock) { 1164 int index = findWakeLockIndexLocked(lock); 1165 if (index < 0) { 1166 if (DEBUG_SPEW) { 1167 Slog.d(TAG, "updateWakeLockWorkSourceInternal: lock=" + Objects.hashCode(lock) 1168 + " [not found], ws=" + ws); 1169 } 1170 throw new IllegalArgumentException("Wake lock not active: " + lock 1171 + " from uid " + callingUid); 1172 } 1173 1174 WakeLock wakeLock = mWakeLocks.get(index); 1175 if (DEBUG_SPEW) { 1176 Slog.d(TAG, "updateWakeLockWorkSourceInternal: lock=" + Objects.hashCode(lock) 1177 + " [" + wakeLock.mTag + "], ws=" + ws); 1178 } 1179 1180 if (!wakeLock.hasSameWorkSource(ws)) { 1181 notifyWakeLockChangingLocked(wakeLock, wakeLock.mFlags, wakeLock.mTag, 1182 wakeLock.mPackageName, wakeLock.mOwnerUid, wakeLock.mOwnerPid, 1183 ws, historyTag); 1184 wakeLock.mHistoryTag = historyTag; 1185 wakeLock.updateWorkSource(ws); 1186 } 1187 } 1188 } 1189 1190 private int findWakeLockIndexLocked(IBinder lock) { 1191 final int count = mWakeLocks.size(); 1192 for (int i = 0; i < count; i++) { 1193 if (mWakeLocks.get(i).mLock == lock) { 1194 return i; 1195 } 1196 } 1197 return -1; 1198 } 1199 1200 private void notifyWakeLockAcquiredLocked(WakeLock wakeLock) { 1201 if (mSystemReady && !wakeLock.mDisabled) { 1202 wakeLock.mNotifiedAcquired = true; 1203 mNotifier.onWakeLockAcquired(wakeLock.mFlags, wakeLock.mTag, wakeLock.mPackageName, 1204 wakeLock.mOwnerUid, wakeLock.mOwnerPid, wakeLock.mWorkSource, 1205 wakeLock.mHistoryTag); 1206 restartNofifyLongTimerLocked(wakeLock); 1207 } 1208 } 1209 1210 private void enqueueNotifyLongMsgLocked(long time) { 1211 mNotifyLongScheduled = time; 1212 Message msg = mHandler.obtainMessage(MSG_CHECK_FOR_LONG_WAKELOCKS); 1213 msg.setAsynchronous(true); 1214 mHandler.sendMessageAtTime(msg, time); 1215 } 1216 1217 private void restartNofifyLongTimerLocked(WakeLock wakeLock) { 1218 wakeLock.mAcquireTime = SystemClock.uptimeMillis(); 1219 if ((wakeLock.mFlags & PowerManager.WAKE_LOCK_LEVEL_MASK) 1220 == PowerManager.PARTIAL_WAKE_LOCK && mNotifyLongScheduled == 0) { 1221 enqueueNotifyLongMsgLocked(wakeLock.mAcquireTime + MIN_LONG_WAKE_CHECK_INTERVAL); 1222 } 1223 } 1224 1225 private void notifyWakeLockLongStartedLocked(WakeLock wakeLock) { 1226 if (mSystemReady && !wakeLock.mDisabled) { 1227 wakeLock.mNotifiedLong = true; 1228 mNotifier.onLongPartialWakeLockStart(wakeLock.mTag, wakeLock.mOwnerUid, 1229 wakeLock.mWorkSource, wakeLock.mHistoryTag); 1230 } 1231 } 1232 1233 private void notifyWakeLockLongFinishedLocked(WakeLock wakeLock) { 1234 if (wakeLock.mNotifiedLong) { 1235 wakeLock.mNotifiedLong = false; 1236 mNotifier.onLongPartialWakeLockFinish(wakeLock.mTag, wakeLock.mOwnerUid, 1237 wakeLock.mWorkSource, wakeLock.mHistoryTag); 1238 } 1239 } 1240 1241 private void notifyWakeLockChangingLocked(WakeLock wakeLock, int flags, String tag, 1242 String packageName, int uid, int pid, WorkSource ws, String historyTag) { 1243 if (mSystemReady && wakeLock.mNotifiedAcquired) { 1244 mNotifier.onWakeLockChanging(wakeLock.mFlags, wakeLock.mTag, wakeLock.mPackageName, 1245 wakeLock.mOwnerUid, wakeLock.mOwnerPid, wakeLock.mWorkSource, 1246 wakeLock.mHistoryTag, flags, tag, packageName, uid, pid, ws, historyTag); 1247 notifyWakeLockLongFinishedLocked(wakeLock); 1248 // Changing the wake lock will count as releasing the old wake lock(s) and 1249 // acquiring the new ones... we do this because otherwise once a wakelock 1250 // becomes long, if we just continued to treat it as long we can get in to 1251 // situations where we spam battery stats with every following change to it. 1252 restartNofifyLongTimerLocked(wakeLock); 1253 } 1254 } 1255 1256 private void notifyWakeLockReleasedLocked(WakeLock wakeLock) { 1257 if (mSystemReady && wakeLock.mNotifiedAcquired) { 1258 wakeLock.mNotifiedAcquired = false; 1259 wakeLock.mAcquireTime = 0; 1260 mNotifier.onWakeLockReleased(wakeLock.mFlags, wakeLock.mTag, 1261 wakeLock.mPackageName, wakeLock.mOwnerUid, wakeLock.mOwnerPid, 1262 wakeLock.mWorkSource, wakeLock.mHistoryTag); 1263 notifyWakeLockLongFinishedLocked(wakeLock); 1264 } 1265 } 1266 1267 @SuppressWarnings("deprecation") 1268 private boolean isWakeLockLevelSupportedInternal(int level) { 1269 synchronized (mLock) { 1270 switch (level) { 1271 case PowerManager.PARTIAL_WAKE_LOCK: 1272 case PowerManager.SCREEN_DIM_WAKE_LOCK: 1273 case PowerManager.SCREEN_BRIGHT_WAKE_LOCK: 1274 case PowerManager.FULL_WAKE_LOCK: 1275 case PowerManager.DOZE_WAKE_LOCK: 1276 case PowerManager.DRAW_WAKE_LOCK: 1277 return true; 1278 1279 case PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK: 1280 return mSystemReady && mDisplayManagerInternal.isProximitySensorAvailable(); 1281 1282 default: 1283 return false; 1284 } 1285 } 1286 } 1287 1288 // Called from native code. 1289 private void userActivityFromNative(long eventTime, int event, int flags) { 1290 userActivityInternal(eventTime, event, flags, Process.SYSTEM_UID); 1291 } 1292 1293 private void userActivityInternal(long eventTime, int event, int flags, int uid) { 1294 synchronized (mLock) { 1295 if (userActivityNoUpdateLocked(eventTime, event, flags, uid)) { 1296 updatePowerStateLocked(); 1297 } 1298 } 1299 } 1300 1301 private boolean userActivityNoUpdateLocked(long eventTime, int event, int flags, int uid) { 1302 if (DEBUG_SPEW) { 1303 Slog.d(TAG, "userActivityNoUpdateLocked: eventTime=" + eventTime 1304 + ", event=" + event + ", flags=0x" + Integer.toHexString(flags) 1305 + ", uid=" + uid); 1306 } 1307 1308 if (eventTime < mLastSleepTime || eventTime < mLastWakeTime 1309 || !mBootCompleted || !mSystemReady) { 1310 return false; 1311 } 1312 1313 Trace.traceBegin(Trace.TRACE_TAG_POWER, "userActivity"); 1314 try { 1315 if (eventTime > mLastInteractivePowerHintTime) { 1316 powerHintInternal(PowerHint.INTERACTION, 0); 1317 mLastInteractivePowerHintTime = eventTime; 1318 } 1319 1320 mNotifier.onUserActivity(event, uid); 1321 1322 if (mUserInactiveOverrideFromWindowManager) { 1323 mUserInactiveOverrideFromWindowManager = false; 1324 mOverriddenTimeout = -1; 1325 } 1326 1327 if (mWakefulness == WAKEFULNESS_ASLEEP 1328 || mWakefulness == WAKEFULNESS_DOZING 1329 || (flags & PowerManager.USER_ACTIVITY_FLAG_INDIRECT) != 0) { 1330 return false; 1331 } 1332 1333 if ((flags & PowerManager.USER_ACTIVITY_FLAG_NO_CHANGE_LIGHTS) != 0) { 1334 if (eventTime > mLastUserActivityTimeNoChangeLights 1335 && eventTime > mLastUserActivityTime) { 1336 mLastUserActivityTimeNoChangeLights = eventTime; 1337 mDirty |= DIRTY_USER_ACTIVITY; 1338 if (event == PowerManager.USER_ACTIVITY_EVENT_BUTTON) { 1339 mDirty |= DIRTY_QUIESCENT; 1340 } 1341 1342 return true; 1343 } 1344 } else { 1345 if (eventTime > mLastUserActivityTime) { 1346 mLastUserActivityTime = eventTime; 1347 mDirty |= DIRTY_USER_ACTIVITY; 1348 if (event == PowerManager.USER_ACTIVITY_EVENT_BUTTON) { 1349 mDirty |= DIRTY_QUIESCENT; 1350 } 1351 return true; 1352 } 1353 } 1354 } finally { 1355 Trace.traceEnd(Trace.TRACE_TAG_POWER); 1356 } 1357 return false; 1358 } 1359 1360 private void wakeUpInternal(long eventTime, String reason, int uid, String opPackageName, 1361 int opUid) { 1362 synchronized (mLock) { 1363 if (wakeUpNoUpdateLocked(eventTime, reason, uid, opPackageName, opUid)) { 1364 updatePowerStateLocked(); 1365 } 1366 } 1367 } 1368 1369 private boolean wakeUpNoUpdateLocked(long eventTime, String reason, int reasonUid, 1370 String opPackageName, int opUid) { 1371 if (DEBUG_SPEW) { 1372 Slog.d(TAG, "wakeUpNoUpdateLocked: eventTime=" + eventTime + ", uid=" + reasonUid); 1373 } 1374 1375 if (eventTime < mLastSleepTime || mWakefulness == WAKEFULNESS_AWAKE 1376 || !mBootCompleted || !mSystemReady) { 1377 return false; 1378 } 1379 1380 Trace.asyncTraceBegin(Trace.TRACE_TAG_POWER, TRACE_SCREEN_ON, 0); 1381 1382 Trace.traceBegin(Trace.TRACE_TAG_POWER, "wakeUp"); 1383 try { 1384 switch (mWakefulness) { 1385 case WAKEFULNESS_ASLEEP: 1386 Slog.i(TAG, "Waking up from sleep (uid " + reasonUid +")..."); 1387 break; 1388 case WAKEFULNESS_DREAMING: 1389 Slog.i(TAG, "Waking up from dream (uid " + reasonUid +")..."); 1390 break; 1391 case WAKEFULNESS_DOZING: 1392 Slog.i(TAG, "Waking up from dozing (uid " + reasonUid +")..."); 1393 break; 1394 } 1395 1396 mLastWakeTime = eventTime; 1397 setWakefulnessLocked(WAKEFULNESS_AWAKE, 0); 1398 1399 mNotifier.onWakeUp(reason, reasonUid, opPackageName, opUid); 1400 userActivityNoUpdateLocked( 1401 eventTime, PowerManager.USER_ACTIVITY_EVENT_OTHER, 0, reasonUid); 1402 } finally { 1403 Trace.traceEnd(Trace.TRACE_TAG_POWER); 1404 } 1405 return true; 1406 } 1407 1408 private void goToSleepInternal(long eventTime, int reason, int flags, int uid) { 1409 synchronized (mLock) { 1410 if (goToSleepNoUpdateLocked(eventTime, reason, flags, uid)) { 1411 updatePowerStateLocked(); 1412 } 1413 } 1414 } 1415 1416 // This method is called goToSleep for historical reasons but we actually start 1417 // dozing before really going to sleep. 1418 @SuppressWarnings("deprecation") 1419 private boolean goToSleepNoUpdateLocked(long eventTime, int reason, int flags, int uid) { 1420 if (DEBUG_SPEW) { 1421 Slog.d(TAG, "goToSleepNoUpdateLocked: eventTime=" + eventTime 1422 + ", reason=" + reason + ", flags=" + flags + ", uid=" + uid); 1423 } 1424 1425 if (eventTime < mLastWakeTime 1426 || mWakefulness == WAKEFULNESS_ASLEEP 1427 || mWakefulness == WAKEFULNESS_DOZING 1428 || !mBootCompleted || !mSystemReady) { 1429 return false; 1430 } 1431 1432 Trace.traceBegin(Trace.TRACE_TAG_POWER, "goToSleep"); 1433 try { 1434 switch (reason) { 1435 case PowerManager.GO_TO_SLEEP_REASON_DEVICE_ADMIN: 1436 Slog.i(TAG, "Going to sleep due to device administration policy " 1437 + "(uid " + uid +")..."); 1438 break; 1439 case PowerManager.GO_TO_SLEEP_REASON_TIMEOUT: 1440 Slog.i(TAG, "Going to sleep due to screen timeout (uid " + uid +")..."); 1441 break; 1442 case PowerManager.GO_TO_SLEEP_REASON_LID_SWITCH: 1443 Slog.i(TAG, "Going to sleep due to lid switch (uid " + uid +")..."); 1444 break; 1445 case PowerManager.GO_TO_SLEEP_REASON_POWER_BUTTON: 1446 Slog.i(TAG, "Going to sleep due to power button (uid " + uid +")..."); 1447 break; 1448 case PowerManager.GO_TO_SLEEP_REASON_SLEEP_BUTTON: 1449 Slog.i(TAG, "Going to sleep due to sleep button (uid " + uid +")..."); 1450 break; 1451 case PowerManager.GO_TO_SLEEP_REASON_HDMI: 1452 Slog.i(TAG, "Going to sleep due to HDMI standby (uid " + uid +")..."); 1453 break; 1454 default: 1455 Slog.i(TAG, "Going to sleep by application request (uid " + uid +")..."); 1456 reason = PowerManager.GO_TO_SLEEP_REASON_APPLICATION; 1457 break; 1458 } 1459 1460 mLastSleepTime = eventTime; 1461 mSandmanSummoned = true; 1462 setWakefulnessLocked(WAKEFULNESS_DOZING, reason); 1463 1464 // Report the number of wake locks that will be cleared by going to sleep. 1465 int numWakeLocksCleared = 0; 1466 final int numWakeLocks = mWakeLocks.size(); 1467 for (int i = 0; i < numWakeLocks; i++) { 1468 final WakeLock wakeLock = mWakeLocks.get(i); 1469 switch (wakeLock.mFlags & PowerManager.WAKE_LOCK_LEVEL_MASK) { 1470 case PowerManager.FULL_WAKE_LOCK: 1471 case PowerManager.SCREEN_BRIGHT_WAKE_LOCK: 1472 case PowerManager.SCREEN_DIM_WAKE_LOCK: 1473 numWakeLocksCleared += 1; 1474 break; 1475 } 1476 } 1477 EventLog.writeEvent(EventLogTags.POWER_SLEEP_REQUESTED, numWakeLocksCleared); 1478 1479 // Skip dozing if requested. 1480 if ((flags & PowerManager.GO_TO_SLEEP_FLAG_NO_DOZE) != 0) { 1481 reallyGoToSleepNoUpdateLocked(eventTime, uid); 1482 } 1483 } finally { 1484 Trace.traceEnd(Trace.TRACE_TAG_POWER); 1485 } 1486 return true; 1487 } 1488 1489 private void napInternal(long eventTime, int uid) { 1490 synchronized (mLock) { 1491 if (napNoUpdateLocked(eventTime, uid)) { 1492 updatePowerStateLocked(); 1493 } 1494 } 1495 } 1496 1497 private boolean napNoUpdateLocked(long eventTime, int uid) { 1498 if (DEBUG_SPEW) { 1499 Slog.d(TAG, "napNoUpdateLocked: eventTime=" + eventTime + ", uid=" + uid); 1500 } 1501 1502 if (eventTime < mLastWakeTime || mWakefulness != WAKEFULNESS_AWAKE 1503 || !mBootCompleted || !mSystemReady) { 1504 return false; 1505 } 1506 1507 Trace.traceBegin(Trace.TRACE_TAG_POWER, "nap"); 1508 try { 1509 Slog.i(TAG, "Nap time (uid " + uid +")..."); 1510 1511 mSandmanSummoned = true; 1512 setWakefulnessLocked(WAKEFULNESS_DREAMING, 0); 1513 } finally { 1514 Trace.traceEnd(Trace.TRACE_TAG_POWER); 1515 } 1516 return true; 1517 } 1518 1519 // Done dozing, drop everything and go to sleep. 1520 private boolean reallyGoToSleepNoUpdateLocked(long eventTime, int uid) { 1521 if (DEBUG_SPEW) { 1522 Slog.d(TAG, "reallyGoToSleepNoUpdateLocked: eventTime=" + eventTime 1523 + ", uid=" + uid); 1524 } 1525 1526 if (eventTime < mLastWakeTime || mWakefulness == WAKEFULNESS_ASLEEP 1527 || !mBootCompleted || !mSystemReady) { 1528 return false; 1529 } 1530 1531 Trace.traceBegin(Trace.TRACE_TAG_POWER, "reallyGoToSleep"); 1532 try { 1533 Slog.i(TAG, "Sleeping (uid " + uid +")..."); 1534 1535 setWakefulnessLocked(WAKEFULNESS_ASLEEP, PowerManager.GO_TO_SLEEP_REASON_TIMEOUT); 1536 } finally { 1537 Trace.traceEnd(Trace.TRACE_TAG_POWER); 1538 } 1539 return true; 1540 } 1541 1542 private void setWakefulnessLocked(int wakefulness, int reason) { 1543 if (mWakefulness != wakefulness) { 1544 mWakefulness = wakefulness; 1545 mWakefulnessChanging = true; 1546 mDirty |= DIRTY_WAKEFULNESS; 1547 mNotifier.onWakefulnessChangeStarted(wakefulness, reason); 1548 } 1549 } 1550 1551 /** 1552 * Logs the time the device would have spent awake before user activity timeout, 1553 * had the system not been told the user was inactive. 1554 */ 1555 private void logSleepTimeoutRecapturedLocked() { 1556 final long now = SystemClock.uptimeMillis(); 1557 final long savedWakeTimeMs = mOverriddenTimeout - now; 1558 if (savedWakeTimeMs >= 0) { 1559 EventLog.writeEvent(EventLogTags.POWER_SOFT_SLEEP_REQUESTED, savedWakeTimeMs); 1560 mOverriddenTimeout = -1; 1561 } 1562 } 1563 1564 private void logScreenOn() { 1565 Trace.asyncTraceEnd(Trace.TRACE_TAG_POWER, TRACE_SCREEN_ON, 0); 1566 1567 final int latencyMs = (int) (SystemClock.uptimeMillis() - mLastWakeTime); 1568 1569 LogMaker log = new LogMaker(MetricsEvent.SCREEN); 1570 log.setType(MetricsEvent.TYPE_OPEN); 1571 log.setSubtype(0); // not user initiated 1572 log.setLatency(latencyMs); // How long it took. 1573 MetricsLogger.action(log); 1574 EventLogTags.writePowerScreenState(1, 0, 0, 0, latencyMs); 1575 1576 if (latencyMs >= SCREEN_ON_LATENCY_WARNING_MS) { 1577 Slog.w(TAG, "Screen on took " + latencyMs+ " ms"); 1578 } 1579 } 1580 1581 private void finishWakefulnessChangeIfNeededLocked() { 1582 if (mWakefulnessChanging && mDisplayReady) { 1583 if (mWakefulness == WAKEFULNESS_DOZING 1584 && (mWakeLockSummary & WAKE_LOCK_DOZE) == 0) { 1585 return; // wait until dream has enabled dozing 1586 } 1587 if (mWakefulness == WAKEFULNESS_DOZING || mWakefulness == WAKEFULNESS_ASLEEP) { 1588 logSleepTimeoutRecapturedLocked(); 1589 } 1590 if (mWakefulness == WAKEFULNESS_AWAKE) { 1591 logScreenOn(); 1592 } 1593 mWakefulnessChanging = false; 1594 mNotifier.onWakefulnessChangeFinished(); 1595 } 1596 } 1597 1598 /** 1599 * Updates the global power state based on dirty bits recorded in mDirty. 1600 * 1601 * This is the main function that performs power state transitions. 1602 * We centralize them here so that we can recompute the power state completely 1603 * each time something important changes, and ensure that we do it the same 1604 * way each time. The point is to gather all of the transition logic here. 1605 */ 1606 private void updatePowerStateLocked() { 1607 if (!mSystemReady || mDirty == 0) { 1608 return; 1609 } 1610 if (!Thread.holdsLock(mLock)) { 1611 Slog.wtf(TAG, "Power manager lock was not held when calling updatePowerStateLocked"); 1612 } 1613 1614 Trace.traceBegin(Trace.TRACE_TAG_POWER, "updatePowerState"); 1615 try { 1616 // Phase 0: Basic state updates. 1617 updateIsPoweredLocked(mDirty); 1618 updateStayOnLocked(mDirty); 1619 updateScreenBrightnessBoostLocked(mDirty); 1620 1621 // Phase 1: Update wakefulness. 1622 // Loop because the wake lock and user activity computations are influenced 1623 // by changes in wakefulness. 1624 final long now = SystemClock.uptimeMillis(); 1625 int dirtyPhase2 = 0; 1626 for (;;) { 1627 int dirtyPhase1 = mDirty; 1628 dirtyPhase2 |= dirtyPhase1; 1629 mDirty = 0; 1630 1631 updateWakeLockSummaryLocked(dirtyPhase1); 1632 updateUserActivitySummaryLocked(now, dirtyPhase1); 1633 if (!updateWakefulnessLocked(dirtyPhase1)) { 1634 break; 1635 } 1636 } 1637 1638 // Phase 2: Update display power state. 1639 boolean displayBecameReady = updateDisplayPowerStateLocked(dirtyPhase2); 1640 1641 // Phase 3: Update dream state (depends on display ready signal). 1642 updateDreamLocked(dirtyPhase2, displayBecameReady); 1643 1644 // Phase 4: Send notifications, if needed. 1645 finishWakefulnessChangeIfNeededLocked(); 1646 1647 // Phase 5: Update suspend blocker. 1648 // Because we might release the last suspend blocker here, we need to make sure 1649 // we finished everything else first! 1650 updateSuspendBlockerLocked(); 1651 } finally { 1652 Trace.traceEnd(Trace.TRACE_TAG_POWER); 1653 } 1654 } 1655 1656 /** 1657 * Updates the value of mIsPowered. 1658 * Sets DIRTY_IS_POWERED if a change occurred. 1659 */ 1660 private void updateIsPoweredLocked(int dirty) { 1661 if ((dirty & DIRTY_BATTERY_STATE) != 0) { 1662 final boolean wasPowered = mIsPowered; 1663 final int oldPlugType = mPlugType; 1664 final boolean oldLevelLow = mBatteryLevelLow; 1665 mIsPowered = mBatteryManagerInternal.isPowered(BatteryManager.BATTERY_PLUGGED_ANY); 1666 mPlugType = mBatteryManagerInternal.getPlugType(); 1667 mBatteryLevel = mBatteryManagerInternal.getBatteryLevel(); 1668 mBatteryLevelLow = mBatteryManagerInternal.getBatteryLevelLow(); 1669 1670 if (DEBUG_SPEW) { 1671 Slog.d(TAG, "updateIsPoweredLocked: wasPowered=" + wasPowered 1672 + ", mIsPowered=" + mIsPowered 1673 + ", oldPlugType=" + oldPlugType 1674 + ", mPlugType=" + mPlugType 1675 + ", mBatteryLevel=" + mBatteryLevel); 1676 } 1677 1678 if (wasPowered != mIsPowered || oldPlugType != mPlugType) { 1679 mDirty |= DIRTY_IS_POWERED; 1680 1681 // Update wireless dock detection state. 1682 final boolean dockedOnWirelessCharger = mWirelessChargerDetector.update( 1683 mIsPowered, mPlugType, mBatteryLevel); 1684 1685 // Treat plugging and unplugging the devices as a user activity. 1686 // Users find it disconcerting when they plug or unplug the device 1687 // and it shuts off right away. 1688 // Some devices also wake the device when plugged or unplugged because 1689 // they don't have a charging LED. 1690 final long now = SystemClock.uptimeMillis(); 1691 if (shouldWakeUpWhenPluggedOrUnpluggedLocked(wasPowered, oldPlugType, 1692 dockedOnWirelessCharger)) { 1693 wakeUpNoUpdateLocked(now, "android.server.power:POWER", Process.SYSTEM_UID, 1694 mContext.getOpPackageName(), Process.SYSTEM_UID); 1695 } 1696 userActivityNoUpdateLocked( 1697 now, PowerManager.USER_ACTIVITY_EVENT_OTHER, 0, Process.SYSTEM_UID); 1698 1699 // Tell the notifier whether wireless charging has started so that 1700 // it can provide feedback to the user. 1701 if (dockedOnWirelessCharger) { 1702 mNotifier.onWirelessChargingStarted(); 1703 } 1704 } 1705 1706 if (wasPowered != mIsPowered || oldLevelLow != mBatteryLevelLow) { 1707 if (oldLevelLow != mBatteryLevelLow && !mBatteryLevelLow) { 1708 if (DEBUG_SPEW) { 1709 Slog.d(TAG, "updateIsPoweredLocked: resetting low power snooze"); 1710 } 1711 mAutoLowPowerModeSnoozing = false; 1712 } 1713 updateLowPowerModeLocked(); 1714 } 1715 } 1716 } 1717 1718 private boolean shouldWakeUpWhenPluggedOrUnpluggedLocked( 1719 boolean wasPowered, int oldPlugType, boolean dockedOnWirelessCharger) { 1720 // Don't wake when powered unless configured to do so. 1721 if (!mWakeUpWhenPluggedOrUnpluggedConfig) { 1722 return false; 1723 } 1724 1725 // Don't wake when undocked from wireless charger. 1726 // See WirelessChargerDetector for justification. 1727 if (wasPowered && !mIsPowered 1728 && oldPlugType == BatteryManager.BATTERY_PLUGGED_WIRELESS) { 1729 return false; 1730 } 1731 1732 // Don't wake when docked on wireless charger unless we are certain of it. 1733 // See WirelessChargerDetector for justification. 1734 if (!wasPowered && mIsPowered 1735 && mPlugType == BatteryManager.BATTERY_PLUGGED_WIRELESS 1736 && !dockedOnWirelessCharger) { 1737 return false; 1738 } 1739 1740 // If already dreaming and becoming powered, then don't wake. 1741 if (mIsPowered && mWakefulness == WAKEFULNESS_DREAMING) { 1742 return false; 1743 } 1744 1745 // Don't wake while theater mode is enabled. 1746 if (mTheaterModeEnabled && !mWakeUpWhenPluggedOrUnpluggedInTheaterModeConfig) { 1747 return false; 1748 } 1749 1750 // On Always On Display, SystemUI shows the charging indicator 1751 if (mAlwaysOnEnabled && mWakefulness == WAKEFULNESS_DOZING) { 1752 return false; 1753 } 1754 1755 // Otherwise wake up! 1756 return true; 1757 } 1758 1759 /** 1760 * Updates the value of mStayOn. 1761 * Sets DIRTY_STAY_ON if a change occurred. 1762 */ 1763 private void updateStayOnLocked(int dirty) { 1764 if ((dirty & (DIRTY_BATTERY_STATE | DIRTY_SETTINGS)) != 0) { 1765 final boolean wasStayOn = mStayOn; 1766 if (mStayOnWhilePluggedInSetting != 0 1767 && !isMaximumScreenOffTimeoutFromDeviceAdminEnforcedLocked()) { 1768 mStayOn = mBatteryManagerInternal.isPowered(mStayOnWhilePluggedInSetting); 1769 } else { 1770 mStayOn = false; 1771 } 1772 1773 if (mStayOn != wasStayOn) { 1774 mDirty |= DIRTY_STAY_ON; 1775 } 1776 } 1777 } 1778 1779 /** 1780 * Updates the value of mWakeLockSummary to summarize the state of all active wake locks. 1781 * Note that most wake-locks are ignored when the system is asleep. 1782 * 1783 * This function must have no other side-effects. 1784 */ 1785 @SuppressWarnings("deprecation") 1786 private void updateWakeLockSummaryLocked(int dirty) { 1787 if ((dirty & (DIRTY_WAKE_LOCKS | DIRTY_WAKEFULNESS)) != 0) { 1788 mWakeLockSummary = 0; 1789 1790 final int numWakeLocks = mWakeLocks.size(); 1791 for (int i = 0; i < numWakeLocks; i++) { 1792 final WakeLock wakeLock = mWakeLocks.get(i); 1793 switch (wakeLock.mFlags & PowerManager.WAKE_LOCK_LEVEL_MASK) { 1794 case PowerManager.PARTIAL_WAKE_LOCK: 1795 if (!wakeLock.mDisabled) { 1796 // We only respect this if the wake lock is not disabled. 1797 mWakeLockSummary |= WAKE_LOCK_CPU; 1798 } 1799 break; 1800 case PowerManager.FULL_WAKE_LOCK: 1801 mWakeLockSummary |= WAKE_LOCK_SCREEN_BRIGHT | WAKE_LOCK_BUTTON_BRIGHT; 1802 break; 1803 case PowerManager.SCREEN_BRIGHT_WAKE_LOCK: 1804 mWakeLockSummary |= WAKE_LOCK_SCREEN_BRIGHT; 1805 break; 1806 case PowerManager.SCREEN_DIM_WAKE_LOCK: 1807 mWakeLockSummary |= WAKE_LOCK_SCREEN_DIM; 1808 break; 1809 case PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK: 1810 mWakeLockSummary |= WAKE_LOCK_PROXIMITY_SCREEN_OFF; 1811 break; 1812 case PowerManager.DOZE_WAKE_LOCK: 1813 mWakeLockSummary |= WAKE_LOCK_DOZE; 1814 break; 1815 case PowerManager.DRAW_WAKE_LOCK: 1816 mWakeLockSummary |= WAKE_LOCK_DRAW; 1817 break; 1818 } 1819 } 1820 1821 // Cancel wake locks that make no sense based on the current state. 1822 if (mWakefulness != WAKEFULNESS_DOZING) { 1823 mWakeLockSummary &= ~(WAKE_LOCK_DOZE | WAKE_LOCK_DRAW); 1824 } 1825 if (mWakefulness == WAKEFULNESS_ASLEEP 1826 || (mWakeLockSummary & WAKE_LOCK_DOZE) != 0) { 1827 mWakeLockSummary &= ~(WAKE_LOCK_SCREEN_BRIGHT | WAKE_LOCK_SCREEN_DIM 1828 | WAKE_LOCK_BUTTON_BRIGHT); 1829 if (mWakefulness == WAKEFULNESS_ASLEEP) { 1830 mWakeLockSummary &= ~WAKE_LOCK_PROXIMITY_SCREEN_OFF; 1831 } 1832 } 1833 1834 // Infer implied wake locks where necessary based on the current state. 1835 if ((mWakeLockSummary & (WAKE_LOCK_SCREEN_BRIGHT | WAKE_LOCK_SCREEN_DIM)) != 0) { 1836 if (mWakefulness == WAKEFULNESS_AWAKE) { 1837 mWakeLockSummary |= WAKE_LOCK_CPU | WAKE_LOCK_STAY_AWAKE; 1838 } else if (mWakefulness == WAKEFULNESS_DREAMING) { 1839 mWakeLockSummary |= WAKE_LOCK_CPU; 1840 } 1841 } 1842 if ((mWakeLockSummary & WAKE_LOCK_DRAW) != 0) { 1843 mWakeLockSummary |= WAKE_LOCK_CPU; 1844 } 1845 1846 if (DEBUG_SPEW) { 1847 Slog.d(TAG, "updateWakeLockSummaryLocked: mWakefulness=" 1848 + PowerManagerInternal.wakefulnessToString(mWakefulness) 1849 + ", mWakeLockSummary=0x" + Integer.toHexString(mWakeLockSummary)); 1850 } 1851 } 1852 } 1853 1854 void checkForLongWakeLocks() { 1855 synchronized (mLock) { 1856 final long now = SystemClock.uptimeMillis(); 1857 mNotifyLongDispatched = now; 1858 final long when = now - MIN_LONG_WAKE_CHECK_INTERVAL; 1859 long nextCheckTime = Long.MAX_VALUE; 1860 final int numWakeLocks = mWakeLocks.size(); 1861 for (int i = 0; i < numWakeLocks; i++) { 1862 final WakeLock wakeLock = mWakeLocks.get(i); 1863 if ((wakeLock.mFlags & PowerManager.WAKE_LOCK_LEVEL_MASK) 1864 == PowerManager.PARTIAL_WAKE_LOCK) { 1865 if (wakeLock.mNotifiedAcquired && !wakeLock.mNotifiedLong) { 1866 if (wakeLock.mAcquireTime < when) { 1867 // This wake lock has exceeded the long acquire time, report! 1868 notifyWakeLockLongStartedLocked(wakeLock); 1869 } else { 1870 // This wake lock could still become a long one, at this time. 1871 long checkTime = wakeLock.mAcquireTime + MIN_LONG_WAKE_CHECK_INTERVAL; 1872 if (checkTime < nextCheckTime) { 1873 nextCheckTime = checkTime; 1874 } 1875 } 1876 } 1877 } 1878 } 1879 mNotifyLongScheduled = 0; 1880 mHandler.removeMessages(MSG_CHECK_FOR_LONG_WAKELOCKS); 1881 if (nextCheckTime != Long.MAX_VALUE) { 1882 mNotifyLongNextCheck = nextCheckTime; 1883 enqueueNotifyLongMsgLocked(nextCheckTime); 1884 } else { 1885 mNotifyLongNextCheck = 0; 1886 } 1887 } 1888 } 1889 1890 /** 1891 * Updates the value of mUserActivitySummary to summarize the user requested 1892 * state of the system such as whether the screen should be bright or dim. 1893 * Note that user activity is ignored when the system is asleep. 1894 * 1895 * This function must have no other side-effects. 1896 */ 1897 private void updateUserActivitySummaryLocked(long now, int dirty) { 1898 // Update the status of the user activity timeout timer. 1899 if ((dirty & (DIRTY_WAKE_LOCKS | DIRTY_USER_ACTIVITY 1900 | DIRTY_WAKEFULNESS | DIRTY_SETTINGS)) != 0) { 1901 mHandler.removeMessages(MSG_USER_ACTIVITY_TIMEOUT); 1902 1903 long nextTimeout = 0; 1904 if (mWakefulness == WAKEFULNESS_AWAKE 1905 || mWakefulness == WAKEFULNESS_DREAMING 1906 || mWakefulness == WAKEFULNESS_DOZING) { 1907 final int sleepTimeout = getSleepTimeoutLocked(); 1908 final int screenOffTimeout = getScreenOffTimeoutLocked(sleepTimeout); 1909 final int screenDimDuration = getScreenDimDurationLocked(screenOffTimeout); 1910 final boolean userInactiveOverride = mUserInactiveOverrideFromWindowManager; 1911 1912 mUserActivitySummary = 0; 1913 if (mLastUserActivityTime >= mLastWakeTime) { 1914 nextTimeout = mLastUserActivityTime 1915 + screenOffTimeout - screenDimDuration; 1916 if (now < nextTimeout) { 1917 mUserActivitySummary = USER_ACTIVITY_SCREEN_BRIGHT; 1918 } else { 1919 nextTimeout = mLastUserActivityTime + screenOffTimeout; 1920 if (now < nextTimeout) { 1921 mUserActivitySummary = USER_ACTIVITY_SCREEN_DIM; 1922 } 1923 } 1924 } 1925 if (mUserActivitySummary == 0 1926 && mLastUserActivityTimeNoChangeLights >= mLastWakeTime) { 1927 nextTimeout = mLastUserActivityTimeNoChangeLights + screenOffTimeout; 1928 if (now < nextTimeout) { 1929 if (mDisplayPowerRequest.policy == DisplayPowerRequest.POLICY_BRIGHT) { 1930 mUserActivitySummary = USER_ACTIVITY_SCREEN_BRIGHT; 1931 } else if (mDisplayPowerRequest.policy == DisplayPowerRequest.POLICY_DIM) { 1932 mUserActivitySummary = USER_ACTIVITY_SCREEN_DIM; 1933 } 1934 } 1935 } 1936 1937 if (mUserActivitySummary == 0) { 1938 if (sleepTimeout >= 0) { 1939 final long anyUserActivity = Math.max(mLastUserActivityTime, 1940 mLastUserActivityTimeNoChangeLights); 1941 if (anyUserActivity >= mLastWakeTime) { 1942 nextTimeout = anyUserActivity + sleepTimeout; 1943 if (now < nextTimeout) { 1944 mUserActivitySummary = USER_ACTIVITY_SCREEN_DREAM; 1945 } 1946 } 1947 } else { 1948 mUserActivitySummary = USER_ACTIVITY_SCREEN_DREAM; 1949 nextTimeout = -1; 1950 } 1951 } 1952 1953 if (mUserActivitySummary != USER_ACTIVITY_SCREEN_DREAM && userInactiveOverride) { 1954 if ((mUserActivitySummary & 1955 (USER_ACTIVITY_SCREEN_BRIGHT | USER_ACTIVITY_SCREEN_DIM)) != 0) { 1956 // Device is being kept awake by recent user activity 1957 if (nextTimeout >= now && mOverriddenTimeout == -1) { 1958 // Save when the next timeout would have occurred 1959 mOverriddenTimeout = nextTimeout; 1960 } 1961 } 1962 mUserActivitySummary = USER_ACTIVITY_SCREEN_DREAM; 1963 nextTimeout = -1; 1964 } 1965 1966 if (mUserActivitySummary != 0 && nextTimeout >= 0) { 1967 Message msg = mHandler.obtainMessage(MSG_USER_ACTIVITY_TIMEOUT); 1968 msg.setAsynchronous(true); 1969 mHandler.sendMessageAtTime(msg, nextTimeout); 1970 } 1971 } else { 1972 mUserActivitySummary = 0; 1973 } 1974 1975 if (DEBUG_SPEW) { 1976 Slog.d(TAG, "updateUserActivitySummaryLocked: mWakefulness=" 1977 + PowerManagerInternal.wakefulnessToString(mWakefulness) 1978 + ", mUserActivitySummary=0x" + Integer.toHexString(mUserActivitySummary) 1979 + ", nextTimeout=" + TimeUtils.formatUptime(nextTimeout)); 1980 } 1981 } 1982 } 1983 1984 /** 1985 * Called when a user activity timeout has occurred. 1986 * Simply indicates that something about user activity has changed so that the new 1987 * state can be recomputed when the power state is updated. 1988 * 1989 * This function must have no other side-effects besides setting the dirty 1990 * bit and calling update power state. Wakefulness transitions are handled elsewhere. 1991 */ 1992 private void handleUserActivityTimeout() { // runs on handler thread 1993 synchronized (mLock) { 1994 if (DEBUG_SPEW) { 1995 Slog.d(TAG, "handleUserActivityTimeout"); 1996 } 1997 1998 mDirty |= DIRTY_USER_ACTIVITY; 1999 updatePowerStateLocked(); 2000 } 2001 } 2002 2003 private int getSleepTimeoutLocked() { 2004 int timeout = mSleepTimeoutSetting; 2005 if (timeout <= 0) { 2006 return -1; 2007 } 2008 return Math.max(timeout, mMinimumScreenOffTimeoutConfig); 2009 } 2010 2011 private int getScreenOffTimeoutLocked(int sleepTimeout) { 2012 int timeout = mScreenOffTimeoutSetting; 2013 if (isMaximumScreenOffTimeoutFromDeviceAdminEnforcedLocked()) { 2014 timeout = Math.min(timeout, mMaximumScreenOffTimeoutFromDeviceAdmin); 2015 } 2016 if (mUserActivityTimeoutOverrideFromWindowManager >= 0) { 2017 timeout = (int)Math.min(timeout, mUserActivityTimeoutOverrideFromWindowManager); 2018 } 2019 if (sleepTimeout >= 0) { 2020 timeout = Math.min(timeout, sleepTimeout); 2021 } 2022 return Math.max(timeout, mMinimumScreenOffTimeoutConfig); 2023 } 2024 2025 private int getScreenDimDurationLocked(int screenOffTimeout) { 2026 return Math.min(mMaximumScreenDimDurationConfig, 2027 (int)(screenOffTimeout * mMaximumScreenDimRatioConfig)); 2028 } 2029 2030 /** 2031 * Updates the wakefulness of the device. 2032 * 2033 * This is the function that decides whether the device should start dreaming 2034 * based on the current wake locks and user activity state. It may modify mDirty 2035 * if the wakefulness changes. 2036 * 2037 * Returns true if the wakefulness changed and we need to restart power state calculation. 2038 */ 2039 private boolean updateWakefulnessLocked(int dirty) { 2040 boolean changed = false; 2041 if ((dirty & (DIRTY_WAKE_LOCKS | DIRTY_USER_ACTIVITY | DIRTY_BOOT_COMPLETED 2042 | DIRTY_WAKEFULNESS | DIRTY_STAY_ON | DIRTY_PROXIMITY_POSITIVE 2043 | DIRTY_DOCK_STATE)) != 0) { 2044 if (mWakefulness == WAKEFULNESS_AWAKE && isItBedTimeYetLocked()) { 2045 if (DEBUG_SPEW) { 2046 Slog.d(TAG, "updateWakefulnessLocked: Bed time..."); 2047 } 2048 final long time = SystemClock.uptimeMillis(); 2049 if (shouldNapAtBedTimeLocked()) { 2050 changed = napNoUpdateLocked(time, Process.SYSTEM_UID); 2051 } else { 2052 changed = goToSleepNoUpdateLocked(time, 2053 PowerManager.GO_TO_SLEEP_REASON_TIMEOUT, 0, Process.SYSTEM_UID); 2054 } 2055 } 2056 } 2057 return changed; 2058 } 2059 2060 /** 2061 * Returns true if the device should automatically nap and start dreaming when the user 2062 * activity timeout has expired and it's bedtime. 2063 */ 2064 private boolean shouldNapAtBedTimeLocked() { 2065 return mDreamsActivateOnSleepSetting 2066 || (mDreamsActivateOnDockSetting 2067 && mDockState != Intent.EXTRA_DOCK_STATE_UNDOCKED); 2068 } 2069 2070 /** 2071 * Returns true if the device should go to sleep now. 2072 * Also used when exiting a dream to determine whether we should go back 2073 * to being fully awake or else go to sleep for good. 2074 */ 2075 private boolean isItBedTimeYetLocked() { 2076 return mBootCompleted && !isBeingKeptAwakeLocked(); 2077 } 2078 2079 /** 2080 * Returns true if the device is being kept awake by a wake lock, user activity 2081 * or the stay on while powered setting. We also keep the phone awake when 2082 * the proximity sensor returns a positive result so that the device does not 2083 * lock while in a phone call. This function only controls whether the device 2084 * will go to sleep or dream which is independent of whether it will be allowed 2085 * to suspend. 2086 */ 2087 private boolean isBeingKeptAwakeLocked() { 2088 return mStayOn 2089 || mProximityPositive 2090 || (mWakeLockSummary & WAKE_LOCK_STAY_AWAKE) != 0 2091 || (mUserActivitySummary & (USER_ACTIVITY_SCREEN_BRIGHT 2092 | USER_ACTIVITY_SCREEN_DIM)) != 0 2093 || mScreenBrightnessBoostInProgress; 2094 } 2095 2096 /** 2097 * Determines whether to post a message to the sandman to update the dream state. 2098 */ 2099 private void updateDreamLocked(int dirty, boolean displayBecameReady) { 2100 if ((dirty & (DIRTY_WAKEFULNESS 2101 | DIRTY_USER_ACTIVITY 2102 | DIRTY_WAKE_LOCKS 2103 | DIRTY_BOOT_COMPLETED 2104 | DIRTY_SETTINGS 2105 | DIRTY_IS_POWERED 2106 | DIRTY_STAY_ON 2107 | DIRTY_PROXIMITY_POSITIVE 2108 | DIRTY_BATTERY_STATE)) != 0 || displayBecameReady) { 2109 if (mDisplayReady) { 2110 scheduleSandmanLocked(); 2111 } 2112 } 2113 } 2114 2115 private void scheduleSandmanLocked() { 2116 if (!mSandmanScheduled) { 2117 mSandmanScheduled = true; 2118 Message msg = mHandler.obtainMessage(MSG_SANDMAN); 2119 msg.setAsynchronous(true); 2120 mHandler.sendMessage(msg); 2121 } 2122 } 2123 2124 /** 2125 * Called when the device enters or exits a dreaming or dozing state. 2126 * 2127 * We do this asynchronously because we must call out of the power manager to start 2128 * the dream and we don't want to hold our lock while doing so. There is a risk that 2129 * the device will wake or go to sleep in the meantime so we have to handle that case. 2130 */ 2131 private void handleSandman() { // runs on handler thread 2132 // Handle preconditions. 2133 final boolean startDreaming; 2134 final int wakefulness; 2135 synchronized (mLock) { 2136 mSandmanScheduled = false; 2137 wakefulness = mWakefulness; 2138 if (mSandmanSummoned && mDisplayReady) { 2139 startDreaming = canDreamLocked() || canDozeLocked(); 2140 mSandmanSummoned = false; 2141 } else { 2142 startDreaming = false; 2143 } 2144 } 2145 2146 // Start dreaming if needed. 2147 // We only control the dream on the handler thread, so we don't need to worry about 2148 // concurrent attempts to start or stop the dream. 2149 final boolean isDreaming; 2150 if (mDreamManager != null) { 2151 // Restart the dream whenever the sandman is summoned. 2152 if (startDreaming) { 2153 mDreamManager.stopDream(false /*immediate*/); 2154 mDreamManager.startDream(wakefulness == WAKEFULNESS_DOZING); 2155 } 2156 isDreaming = mDreamManager.isDreaming(); 2157 } else { 2158 isDreaming = false; 2159 } 2160 2161 // Update dream state. 2162 synchronized (mLock) { 2163 // Remember the initial battery level when the dream started. 2164 if (startDreaming && isDreaming) { 2165 mBatteryLevelWhenDreamStarted = mBatteryLevel; 2166 if (wakefulness == WAKEFULNESS_DOZING) { 2167 Slog.i(TAG, "Dozing..."); 2168 } else { 2169 Slog.i(TAG, "Dreaming..."); 2170 } 2171 } 2172 2173 // If preconditions changed, wait for the next iteration to determine 2174 // whether the dream should continue (or be restarted). 2175 if (mSandmanSummoned || mWakefulness != wakefulness) { 2176 return; // wait for next cycle 2177 } 2178 2179 // Determine whether the dream should continue. 2180 if (wakefulness == WAKEFULNESS_DREAMING) { 2181 if (isDreaming && canDreamLocked()) { 2182 if (mDreamsBatteryLevelDrainCutoffConfig >= 0 2183 && mBatteryLevel < mBatteryLevelWhenDreamStarted 2184 - mDreamsBatteryLevelDrainCutoffConfig 2185 && !isBeingKeptAwakeLocked()) { 2186 // If the user activity timeout expired and the battery appears 2187 // to be draining faster than it is charging then stop dreaming 2188 // and go to sleep. 2189 Slog.i(TAG, "Stopping dream because the battery appears to " 2190 + "be draining faster than it is charging. " 2191 + "Battery level when dream started: " 2192 + mBatteryLevelWhenDreamStarted + "%. " 2193 + "Battery level now: " + mBatteryLevel + "%."); 2194 } else { 2195 return; // continue dreaming 2196 } 2197 } 2198 2199 // Dream has ended or will be stopped. Update the power state. 2200 if (isItBedTimeYetLocked()) { 2201 goToSleepNoUpdateLocked(SystemClock.uptimeMillis(), 2202 PowerManager.GO_TO_SLEEP_REASON_TIMEOUT, 0, Process.SYSTEM_UID); 2203 updatePowerStateLocked(); 2204 } else { 2205 wakeUpNoUpdateLocked(SystemClock.uptimeMillis(), "android.server.power:DREAM", 2206 Process.SYSTEM_UID, mContext.getOpPackageName(), Process.SYSTEM_UID); 2207 updatePowerStateLocked(); 2208 } 2209 } else if (wakefulness == WAKEFULNESS_DOZING) { 2210 if (isDreaming) { 2211 return; // continue dozing 2212 } 2213 2214 // Doze has ended or will be stopped. Update the power state. 2215 reallyGoToSleepNoUpdateLocked(SystemClock.uptimeMillis(), Process.SYSTEM_UID); 2216 updatePowerStateLocked(); 2217 } 2218 } 2219 2220 // Stop dream. 2221 if (isDreaming) { 2222 mDreamManager.stopDream(false /*immediate*/); 2223 } 2224 } 2225 2226 /** 2227 * Returns true if the device is allowed to dream in its current state. 2228 */ 2229 private boolean canDreamLocked() { 2230 if (mWakefulness != WAKEFULNESS_DREAMING 2231 || !mDreamsSupportedConfig 2232 || !mDreamsEnabledSetting 2233 || !mDisplayPowerRequest.isBrightOrDim() 2234 || mDisplayPowerRequest.isVr() 2235 || (mUserActivitySummary & (USER_ACTIVITY_SCREEN_BRIGHT 2236 | USER_ACTIVITY_SCREEN_DIM | USER_ACTIVITY_SCREEN_DREAM)) == 0 2237 || !mBootCompleted) { 2238 return false; 2239 } 2240 if (!isBeingKeptAwakeLocked()) { 2241 if (!mIsPowered && !mDreamsEnabledOnBatteryConfig) { 2242 return false; 2243 } 2244 if (!mIsPowered 2245 && mDreamsBatteryLevelMinimumWhenNotPoweredConfig >= 0 2246 && mBatteryLevel < mDreamsBatteryLevelMinimumWhenNotPoweredConfig) { 2247 return false; 2248 } 2249 if (mIsPowered 2250 && mDreamsBatteryLevelMinimumWhenPoweredConfig >= 0 2251 && mBatteryLevel < mDreamsBatteryLevelMinimumWhenPoweredConfig) { 2252 return false; 2253 } 2254 } 2255 return true; 2256 } 2257 2258 /** 2259 * Returns true if the device is allowed to doze in its current state. 2260 */ 2261 private boolean canDozeLocked() { 2262 return mWakefulness == WAKEFULNESS_DOZING; 2263 } 2264 2265 /** 2266 * Updates the display power state asynchronously. 2267 * When the update is finished, mDisplayReady will be set to true. The display 2268 * controller posts a message to tell us when the actual display power state 2269 * has been updated so we come back here to double-check and finish up. 2270 * 2271 * This function recalculates the display power state each time. 2272 * 2273 * @return True if the display became ready. 2274 */ 2275 private boolean updateDisplayPowerStateLocked(int dirty) { 2276 final boolean oldDisplayReady = mDisplayReady; 2277 if ((dirty & (DIRTY_WAKE_LOCKS | DIRTY_USER_ACTIVITY | DIRTY_WAKEFULNESS 2278 | DIRTY_ACTUAL_DISPLAY_POWER_STATE_UPDATED | DIRTY_BOOT_COMPLETED 2279 | DIRTY_SETTINGS | DIRTY_SCREEN_BRIGHTNESS_BOOST | DIRTY_VR_MODE_CHANGED | 2280 DIRTY_QUIESCENT)) != 0) { 2281 mDisplayPowerRequest.policy = getDesiredScreenPolicyLocked(); 2282 2283 // Determine appropriate screen brightness and auto-brightness adjustments. 2284 boolean brightnessSetByUser = true; 2285 int screenBrightness = mScreenBrightnessSettingDefault; 2286 float screenAutoBrightnessAdjustment = 0.0f; 2287 boolean autoBrightness = (mScreenBrightnessModeSetting == 2288 Settings.System.SCREEN_BRIGHTNESS_MODE_AUTOMATIC); 2289 if (!mBootCompleted) { 2290 // Keep the brightness steady during boot. This requires the 2291 // bootloader brightness and the default brightness to be identical. 2292 autoBrightness = false; 2293 brightnessSetByUser = false; 2294 } else if (mIsVrModeEnabled) { 2295 screenBrightness = mScreenBrightnessForVrSetting; 2296 autoBrightness = false; 2297 } else if (isValidBrightness(mScreenBrightnessOverrideFromWindowManager)) { 2298 screenBrightness = mScreenBrightnessOverrideFromWindowManager; 2299 autoBrightness = false; 2300 brightnessSetByUser = false; 2301 } else if (isValidBrightness(mTemporaryScreenBrightnessSettingOverride)) { 2302 screenBrightness = mTemporaryScreenBrightnessSettingOverride; 2303 } else if (isValidBrightness(mScreenBrightnessSetting)) { 2304 screenBrightness = mScreenBrightnessSetting; 2305 } 2306 if (autoBrightness) { 2307 screenBrightness = mScreenBrightnessSettingDefault; 2308 if (isValidAutoBrightnessAdjustment( 2309 mTemporaryScreenAutoBrightnessAdjustmentSettingOverride)) { 2310 screenAutoBrightnessAdjustment = 2311 mTemporaryScreenAutoBrightnessAdjustmentSettingOverride; 2312 } else if (isValidAutoBrightnessAdjustment( 2313 mScreenAutoBrightnessAdjustmentSetting)) { 2314 screenAutoBrightnessAdjustment = mScreenAutoBrightnessAdjustmentSetting; 2315 } 2316 } 2317 screenBrightness = Math.max(Math.min(screenBrightness, 2318 mScreenBrightnessSettingMaximum), mScreenBrightnessSettingMinimum); 2319 screenAutoBrightnessAdjustment = Math.max(Math.min( 2320 screenAutoBrightnessAdjustment, 1.0f), -1.0f); 2321 2322 // Update display power request. 2323 mDisplayPowerRequest.screenBrightness = screenBrightness; 2324 mDisplayPowerRequest.screenAutoBrightnessAdjustment = 2325 screenAutoBrightnessAdjustment; 2326 mDisplayPowerRequest.brightnessSetByUser = brightnessSetByUser; 2327 mDisplayPowerRequest.useAutoBrightness = autoBrightness; 2328 mDisplayPowerRequest.useProximitySensor = shouldUseProximitySensorLocked(); 2329 mDisplayPowerRequest.boostScreenBrightness = shouldBoostScreenBrightness(); 2330 2331 updatePowerRequestFromBatterySaverPolicy(mDisplayPowerRequest); 2332 2333 if (mDisplayPowerRequest.policy == DisplayPowerRequest.POLICY_DOZE) { 2334 mDisplayPowerRequest.dozeScreenState = mDozeScreenStateOverrideFromDreamManager; 2335 if (mDisplayPowerRequest.dozeScreenState == Display.STATE_DOZE_SUSPEND 2336 && (mWakeLockSummary & WAKE_LOCK_DRAW) != 0) { 2337 mDisplayPowerRequest.dozeScreenState = Display.STATE_DOZE; 2338 } 2339 mDisplayPowerRequest.dozeScreenBrightness = 2340 mDozeScreenBrightnessOverrideFromDreamManager; 2341 } else { 2342 mDisplayPowerRequest.dozeScreenState = Display.STATE_UNKNOWN; 2343 mDisplayPowerRequest.dozeScreenBrightness = PowerManager.BRIGHTNESS_DEFAULT; 2344 } 2345 2346 mDisplayReady = mDisplayManagerInternal.requestPowerState(mDisplayPowerRequest, 2347 mRequestWaitForNegativeProximity); 2348 mRequestWaitForNegativeProximity = false; 2349 2350 if ((dirty & DIRTY_QUIESCENT) != 0) { 2351 sQuiescent = false; 2352 } 2353 if (DEBUG_SPEW) { 2354 Slog.d(TAG, "updateDisplayPowerStateLocked: mDisplayReady=" + mDisplayReady 2355 + ", policy=" + mDisplayPowerRequest.policy 2356 + ", mWakefulness=" + mWakefulness 2357 + ", mWakeLockSummary=0x" + Integer.toHexString(mWakeLockSummary) 2358 + ", mUserActivitySummary=0x" + Integer.toHexString(mUserActivitySummary) 2359 + ", mBootCompleted=" + mBootCompleted 2360 + ", mScreenBrightnessBoostInProgress=" + mScreenBrightnessBoostInProgress 2361 + ", mIsVrModeEnabled= " + mIsVrModeEnabled 2362 + ", sQuiescent=" + sQuiescent); 2363 } 2364 } 2365 return mDisplayReady && !oldDisplayReady; 2366 } 2367 2368 private void updateScreenBrightnessBoostLocked(int dirty) { 2369 if ((dirty & DIRTY_SCREEN_BRIGHTNESS_BOOST) != 0) { 2370 if (mScreenBrightnessBoostInProgress) { 2371 final long now = SystemClock.uptimeMillis(); 2372 mHandler.removeMessages(MSG_SCREEN_BRIGHTNESS_BOOST_TIMEOUT); 2373 if (mLastScreenBrightnessBoostTime > mLastSleepTime) { 2374 final long boostTimeout = mLastScreenBrightnessBoostTime + 2375 SCREEN_BRIGHTNESS_BOOST_TIMEOUT; 2376 if (boostTimeout > now) { 2377 Message msg = mHandler.obtainMessage(MSG_SCREEN_BRIGHTNESS_BOOST_TIMEOUT); 2378 msg.setAsynchronous(true); 2379 mHandler.sendMessageAtTime(msg, boostTimeout); 2380 return; 2381 } 2382 } 2383 mScreenBrightnessBoostInProgress = false; 2384 mNotifier.onScreenBrightnessBoostChanged(); 2385 userActivityNoUpdateLocked(now, 2386 PowerManager.USER_ACTIVITY_EVENT_OTHER, 0, Process.SYSTEM_UID); 2387 } 2388 } 2389 } 2390 2391 private boolean shouldBoostScreenBrightness() { 2392 return !mIsVrModeEnabled && mScreenBrightnessBoostInProgress; 2393 } 2394 2395 private static boolean isValidBrightness(int value) { 2396 return value >= 0 && value <= 255; 2397 } 2398 2399 private static boolean isValidAutoBrightnessAdjustment(float value) { 2400 // Handles NaN by always returning false. 2401 return value >= -1.0f && value <= 1.0f; 2402 } 2403 2404 private int getDesiredScreenPolicyLocked() { 2405 if (mIsVrModeEnabled) { 2406 return DisplayPowerRequest.POLICY_VR; 2407 } 2408 2409 if (mWakefulness == WAKEFULNESS_ASLEEP || sQuiescent) { 2410 return DisplayPowerRequest.POLICY_OFF; 2411 } 2412 2413 if (mWakefulness == WAKEFULNESS_DOZING) { 2414 if ((mWakeLockSummary & WAKE_LOCK_DOZE) != 0) { 2415 return DisplayPowerRequest.POLICY_DOZE; 2416 } 2417 if (mDozeAfterScreenOffConfig) { 2418 return DisplayPowerRequest.POLICY_OFF; 2419 } 2420 // Fall through and preserve the current screen policy if not configured to 2421 // doze after screen off. This causes the screen off transition to be skipped. 2422 } 2423 2424 if ((mWakeLockSummary & WAKE_LOCK_SCREEN_BRIGHT) != 0 2425 || (mUserActivitySummary & USER_ACTIVITY_SCREEN_BRIGHT) != 0 2426 || !mBootCompleted 2427 || mScreenBrightnessBoostInProgress) { 2428 return DisplayPowerRequest.POLICY_BRIGHT; 2429 } 2430 2431 return DisplayPowerRequest.POLICY_DIM; 2432 } 2433 2434 private final DisplayManagerInternal.DisplayPowerCallbacks mDisplayPowerCallbacks = 2435 new DisplayManagerInternal.DisplayPowerCallbacks() { 2436 private int mDisplayState = Display.STATE_UNKNOWN; 2437 2438 @Override 2439 public void onStateChanged() { 2440 synchronized (mLock) { 2441 mDirty |= DIRTY_ACTUAL_DISPLAY_POWER_STATE_UPDATED; 2442 updatePowerStateLocked(); 2443 } 2444 } 2445 2446 @Override 2447 public void onProximityPositive() { 2448 synchronized (mLock) { 2449 mProximityPositive = true; 2450 mDirty |= DIRTY_PROXIMITY_POSITIVE; 2451 updatePowerStateLocked(); 2452 } 2453 } 2454 2455 @Override 2456 public void onProximityNegative() { 2457 synchronized (mLock) { 2458 mProximityPositive = false; 2459 mDirty |= DIRTY_PROXIMITY_POSITIVE; 2460 userActivityNoUpdateLocked(SystemClock.uptimeMillis(), 2461 PowerManager.USER_ACTIVITY_EVENT_OTHER, 0, Process.SYSTEM_UID); 2462 updatePowerStateLocked(); 2463 } 2464 } 2465 2466 @Override 2467 public void onDisplayStateChange(int state) { 2468 // This method is only needed to support legacy display blanking behavior 2469 // where the display's power state is coupled to suspend or to the power HAL. 2470 // The order of operations matters here. 2471 synchronized (mLock) { 2472 if (mDisplayState != state) { 2473 mDisplayState = state; 2474 if (state == Display.STATE_OFF) { 2475 if (!mDecoupleHalInteractiveModeFromDisplayConfig) { 2476 setHalInteractiveModeLocked(false); 2477 } 2478 if (!mDecoupleHalAutoSuspendModeFromDisplayConfig) { 2479 setHalAutoSuspendModeLocked(true); 2480 } 2481 } else { 2482 if (!mDecoupleHalAutoSuspendModeFromDisplayConfig) { 2483 setHalAutoSuspendModeLocked(false); 2484 } 2485 if (!mDecoupleHalInteractiveModeFromDisplayConfig) { 2486 setHalInteractiveModeLocked(true); 2487 } 2488 } 2489 } 2490 } 2491 } 2492 2493 @Override 2494 public void acquireSuspendBlocker() { 2495 mDisplaySuspendBlocker.acquire(); 2496 } 2497 2498 @Override 2499 public void releaseSuspendBlocker() { 2500 mDisplaySuspendBlocker.release(); 2501 } 2502 2503 @Override 2504 public String toString() { 2505 synchronized (this) { 2506 return "state=" + Display.stateToString(mDisplayState); 2507 } 2508 } 2509 }; 2510 2511 private boolean shouldUseProximitySensorLocked() { 2512 return !mIsVrModeEnabled && (mWakeLockSummary & WAKE_LOCK_PROXIMITY_SCREEN_OFF) != 0; 2513 } 2514 2515 /** 2516 * Updates the suspend blocker that keeps the CPU alive. 2517 * 2518 * This function must have no other side-effects. 2519 */ 2520 private void updateSuspendBlockerLocked() { 2521 final boolean needWakeLockSuspendBlocker = ((mWakeLockSummary & WAKE_LOCK_CPU) != 0); 2522 final boolean needDisplaySuspendBlocker = needDisplaySuspendBlockerLocked(); 2523 final boolean autoSuspend = !needDisplaySuspendBlocker; 2524 final boolean interactive = mDisplayPowerRequest.isBrightOrDim(); 2525 2526 // Disable auto-suspend if needed. 2527 // FIXME We should consider just leaving auto-suspend enabled forever since 2528 // we already hold the necessary wakelocks. 2529 if (!autoSuspend && mDecoupleHalAutoSuspendModeFromDisplayConfig) { 2530 setHalAutoSuspendModeLocked(false); 2531 } 2532 2533 // First acquire suspend blockers if needed. 2534 if (needWakeLockSuspendBlocker && !mHoldingWakeLockSuspendBlocker) { 2535 mWakeLockSuspendBlocker.acquire(); 2536 mHoldingWakeLockSuspendBlocker = true; 2537 } 2538 if (needDisplaySuspendBlocker && !mHoldingDisplaySuspendBlocker) { 2539 mDisplaySuspendBlocker.acquire(); 2540 mHoldingDisplaySuspendBlocker = true; 2541 } 2542 2543 // Inform the power HAL about interactive mode. 2544 // Although we could set interactive strictly based on the wakefulness 2545 // as reported by isInteractive(), it is actually more desirable to track 2546 // the display policy state instead so that the interactive state observed 2547 // by the HAL more accurately tracks transitions between AWAKE and DOZING. 2548 // Refer to getDesiredScreenPolicyLocked() for details. 2549 if (mDecoupleHalInteractiveModeFromDisplayConfig) { 2550 // When becoming non-interactive, we want to defer sending this signal 2551 // until the display is actually ready so that all transitions have 2552 // completed. This is probably a good sign that things have gotten 2553 // too tangled over here... 2554 if (interactive || mDisplayReady) { 2555 setHalInteractiveModeLocked(interactive); 2556 } 2557 } 2558 2559 // Then release suspend blockers if needed. 2560 if (!needWakeLockSuspendBlocker && mHoldingWakeLockSuspendBlocker) { 2561 mWakeLockSuspendBlocker.release(); 2562 mHoldingWakeLockSuspendBlocker = false; 2563 } 2564 if (!needDisplaySuspendBlocker && mHoldingDisplaySuspendBlocker) { 2565 mDisplaySuspendBlocker.release(); 2566 mHoldingDisplaySuspendBlocker = false; 2567 } 2568 2569 // Enable auto-suspend if needed. 2570 if (autoSuspend && mDecoupleHalAutoSuspendModeFromDisplayConfig) { 2571 setHalAutoSuspendModeLocked(true); 2572 } 2573 } 2574 2575 /** 2576 * Return true if we must keep a suspend blocker active on behalf of the display. 2577 * We do so if the screen is on or is in transition between states. 2578 */ 2579 private boolean needDisplaySuspendBlockerLocked() { 2580 if (!mDisplayReady) { 2581 return true; 2582 } 2583 if (mDisplayPowerRequest.isBrightOrDim()) { 2584 // If we asked for the screen to be on but it is off due to the proximity 2585 // sensor then we may suspend but only if the configuration allows it. 2586 // On some hardware it may not be safe to suspend because the proximity 2587 // sensor may not be correctly configured as a wake-up source. 2588 if (!mDisplayPowerRequest.useProximitySensor || !mProximityPositive 2589 || !mSuspendWhenScreenOffDueToProximityConfig) { 2590 return true; 2591 } 2592 } 2593 if (mScreenBrightnessBoostInProgress) { 2594 return true; 2595 } 2596 // Let the system suspend if the screen is off or dozing. 2597 return false; 2598 } 2599 2600 private void setHalAutoSuspendModeLocked(boolean enable) { 2601 if (enable != mHalAutoSuspendModeEnabled) { 2602 if (DEBUG) { 2603 Slog.d(TAG, "Setting HAL auto-suspend mode to " + enable); 2604 } 2605 mHalAutoSuspendModeEnabled = enable; 2606 Trace.traceBegin(Trace.TRACE_TAG_POWER, "setHalAutoSuspend(" + enable + ")"); 2607 try { 2608 nativeSetAutoSuspend(enable); 2609 } finally { 2610 Trace.traceEnd(Trace.TRACE_TAG_POWER); 2611 } 2612 } 2613 } 2614 2615 private void setHalInteractiveModeLocked(boolean enable) { 2616 if (enable != mHalInteractiveModeEnabled) { 2617 if (DEBUG) { 2618 Slog.d(TAG, "Setting HAL interactive mode to " + enable); 2619 } 2620 mHalInteractiveModeEnabled = enable; 2621 Trace.traceBegin(Trace.TRACE_TAG_POWER, "setHalInteractive(" + enable + ")"); 2622 try { 2623 nativeSetInteractive(enable); 2624 } finally { 2625 Trace.traceEnd(Trace.TRACE_TAG_POWER); 2626 } 2627 } 2628 } 2629 2630 private boolean isInteractiveInternal() { 2631 synchronized (mLock) { 2632 return PowerManagerInternal.isInteractive(mWakefulness); 2633 } 2634 } 2635 2636 private boolean isLowPowerModeInternal() { 2637 synchronized (mLock) { 2638 return mLowPowerModeEnabled; 2639 } 2640 } 2641 2642 private boolean setLowPowerModeInternal(boolean mode) { 2643 synchronized (mLock) { 2644 if (DEBUG) Slog.d(TAG, "setLowPowerModeInternal " + mode + " mIsPowered=" + mIsPowered); 2645 if (mIsPowered) { 2646 return false; 2647 } 2648 Settings.Global.putInt(mContext.getContentResolver(), 2649 Settings.Global.LOW_POWER_MODE, mode ? 1 : 0); 2650 mLowPowerModeSetting = mode; 2651 2652 if (mAutoLowPowerModeConfigured && mBatteryLevelLow) { 2653 if (mode && mAutoLowPowerModeSnoozing) { 2654 if (DEBUG_SPEW) { 2655 Slog.d(TAG, "setLowPowerModeInternal: clearing low power mode snooze"); 2656 } 2657 mAutoLowPowerModeSnoozing = false; 2658 } else if (!mode && !mAutoLowPowerModeSnoozing) { 2659 if (DEBUG_SPEW) { 2660 Slog.d(TAG, "setLowPowerModeInternal: snoozing low power mode"); 2661 } 2662 mAutoLowPowerModeSnoozing = true; 2663 } 2664 } 2665 2666 updateLowPowerModeLocked(); 2667 return true; 2668 } 2669 } 2670 2671 boolean isDeviceIdleModeInternal() { 2672 synchronized (mLock) { 2673 return mDeviceIdleMode; 2674 } 2675 } 2676 2677 boolean isLightDeviceIdleModeInternal() { 2678 synchronized (mLock) { 2679 return mLightDeviceIdleMode; 2680 } 2681 } 2682 2683 private void handleBatteryStateChangedLocked() { 2684 mDirty |= DIRTY_BATTERY_STATE; 2685 updatePowerStateLocked(); 2686 } 2687 2688 private void shutdownOrRebootInternal(final @HaltMode int haltMode, final boolean confirm, 2689 final String reason, boolean wait) { 2690 if (mHandler == null || !mSystemReady) { 2691 if (RescueParty.isAttemptingFactoryReset()) { 2692 // If we're stuck in a really low-level reboot loop, and a 2693 // rescue party is trying to prompt the user for a factory data 2694 // reset, we must GET TO DA CHOPPA! 2695 PowerManagerService.lowLevelReboot(reason); 2696 } else { 2697 throw new IllegalStateException("Too early to call shutdown() or reboot()"); 2698 } 2699 } 2700 2701 Runnable runnable = new Runnable() { 2702 @Override 2703 public void run() { 2704 synchronized (this) { 2705 if (haltMode == HALT_MODE_REBOOT_SAFE_MODE) { 2706 ShutdownThread.rebootSafeMode(getUiContext(), confirm); 2707 } else if (haltMode == HALT_MODE_REBOOT) { 2708 ShutdownThread.reboot(getUiContext(), reason, confirm); 2709 } else { 2710 ShutdownThread.shutdown(getUiContext(), reason, confirm); 2711 } 2712 } 2713 } 2714 }; 2715 2716 // ShutdownThread must run on a looper capable of displaying the UI. 2717 Message msg = Message.obtain(mHandler, runnable); 2718 msg.setAsynchronous(true); 2719 mHandler.sendMessage(msg); 2720 2721 // PowerManager.reboot() is documented not to return so just wait for the inevitable. 2722 if (wait) { 2723 synchronized (runnable) { 2724 while (true) { 2725 try { 2726 runnable.wait(); 2727 } catch (InterruptedException e) { 2728 } 2729 } 2730 } 2731 } 2732 } 2733 2734 private void crashInternal(final String message) { 2735 Thread t = new Thread("PowerManagerService.crash()") { 2736 @Override 2737 public void run() { 2738 throw new RuntimeException(message); 2739 } 2740 }; 2741 try { 2742 t.start(); 2743 t.join(); 2744 } catch (InterruptedException e) { 2745 Slog.wtf(TAG, e); 2746 } 2747 } 2748 2749 @VisibleForTesting 2750 void updatePowerRequestFromBatterySaverPolicy(DisplayPowerRequest displayPowerRequest) { 2751 PowerSaveState state = mBatterySaverPolicy. 2752 getBatterySaverPolicy(ServiceType.SCREEN_BRIGHTNESS, mLowPowerModeEnabled); 2753 displayPowerRequest.lowPowerMode = state.batterySaverEnabled; 2754 displayPowerRequest.screenLowPowerBrightnessFactor = state.brightnessFactor; 2755 } 2756 2757 void setStayOnSettingInternal(int val) { 2758 Settings.Global.putInt(mContext.getContentResolver(), 2759 Settings.Global.STAY_ON_WHILE_PLUGGED_IN, val); 2760 } 2761 2762 void setMaximumScreenOffTimeoutFromDeviceAdminInternal(int timeMs) { 2763 synchronized (mLock) { 2764 mMaximumScreenOffTimeoutFromDeviceAdmin = timeMs; 2765 mDirty |= DIRTY_SETTINGS; 2766 updatePowerStateLocked(); 2767 } 2768 } 2769 2770 boolean setDeviceIdleModeInternal(boolean enabled) { 2771 synchronized (mLock) { 2772 if (mDeviceIdleMode == enabled) { 2773 return false; 2774 } 2775 mDeviceIdleMode = enabled; 2776 updateWakeLockDisabledStatesLocked(); 2777 } 2778 if (enabled) { 2779 EventLogTags.writeDeviceIdleOnPhase("power"); 2780 } else { 2781 EventLogTags.writeDeviceIdleOffPhase("power"); 2782 } 2783 return true; 2784 } 2785 2786 boolean setLightDeviceIdleModeInternal(boolean enabled) { 2787 synchronized (mLock) { 2788 if (mLightDeviceIdleMode != enabled) { 2789 mLightDeviceIdleMode = enabled; 2790 return true; 2791 } 2792 return false; 2793 } 2794 } 2795 2796 void setDeviceIdleWhitelistInternal(int[] appids) { 2797 synchronized (mLock) { 2798 mDeviceIdleWhitelist = appids; 2799 if (mDeviceIdleMode) { 2800 updateWakeLockDisabledStatesLocked(); 2801 } 2802 } 2803 } 2804 2805 void setDeviceIdleTempWhitelistInternal(int[] appids) { 2806 synchronized (mLock) { 2807 mDeviceIdleTempWhitelist = appids; 2808 if (mDeviceIdleMode) { 2809 updateWakeLockDisabledStatesLocked(); 2810 } 2811 } 2812 } 2813 2814 void startUidChangesInternal() { 2815 synchronized (mLock) { 2816 mUidsChanging = true; 2817 } 2818 } 2819 2820 void finishUidChangesInternal() { 2821 synchronized (mLock) { 2822 mUidsChanging = false; 2823 if (mUidsChanged) { 2824 updateWakeLockDisabledStatesLocked(); 2825 mUidsChanged = false; 2826 } 2827 } 2828 } 2829 2830 private void handleUidStateChangeLocked() { 2831 if (mUidsChanging) { 2832 mUidsChanged = true; 2833 } else { 2834 updateWakeLockDisabledStatesLocked(); 2835 } 2836 } 2837 2838 void updateUidProcStateInternal(int uid, int procState) { 2839 synchronized (mLock) { 2840 UidState state = mUidState.get(uid); 2841 if (state == null) { 2842 state = new UidState(uid); 2843 mUidState.put(uid, state); 2844 } 2845 final boolean oldShouldAllow = state.mProcState 2846 <= ActivityManager.PROCESS_STATE_RECEIVER; 2847 state.mProcState = procState; 2848 if (state.mNumWakeLocks > 0) { 2849 if (mDeviceIdleMode) { 2850 handleUidStateChangeLocked(); 2851 } else if (!state.mActive && oldShouldAllow != 2852 (procState <= ActivityManager.PROCESS_STATE_RECEIVER)) { 2853 // If this uid is not active, but the process state has changed such 2854 // that we may still want to allow it to hold a wake lock, then take care of it. 2855 handleUidStateChangeLocked(); 2856 } 2857 } 2858 } 2859 } 2860 2861 void uidGoneInternal(int uid) { 2862 synchronized (mLock) { 2863 final int index = mUidState.indexOfKey(uid); 2864 if (index >= 0) { 2865 UidState state = mUidState.valueAt(index); 2866 state.mProcState = ActivityManager.PROCESS_STATE_NONEXISTENT; 2867 state.mActive = false; 2868 mUidState.removeAt(index); 2869 if (mDeviceIdleMode && state.mNumWakeLocks > 0) { 2870 handleUidStateChangeLocked(); 2871 } 2872 } 2873 } 2874 } 2875 2876 void uidActiveInternal(int uid) { 2877 synchronized (mLock) { 2878 UidState state = mUidState.get(uid); 2879 if (state == null) { 2880 state = new UidState(uid); 2881 state.mProcState = ActivityManager.PROCESS_STATE_CACHED_EMPTY; 2882 mUidState.put(uid, state); 2883 } 2884 state.mActive = true; 2885 if (state.mNumWakeLocks > 0) { 2886 handleUidStateChangeLocked(); 2887 } 2888 } 2889 } 2890 2891 void uidIdleInternal(int uid) { 2892 synchronized (mLock) { 2893 UidState state = mUidState.get(uid); 2894 if (state != null) { 2895 state.mActive = false; 2896 if (state.mNumWakeLocks > 0) { 2897 handleUidStateChangeLocked(); 2898 } 2899 } 2900 } 2901 } 2902 2903 private void updateWakeLockDisabledStatesLocked() { 2904 boolean changed = false; 2905 final int numWakeLocks = mWakeLocks.size(); 2906 for (int i = 0; i < numWakeLocks; i++) { 2907 final WakeLock wakeLock = mWakeLocks.get(i); 2908 if ((wakeLock.mFlags & PowerManager.WAKE_LOCK_LEVEL_MASK) 2909 == PowerManager.PARTIAL_WAKE_LOCK) { 2910 if (setWakeLockDisabledStateLocked(wakeLock)) { 2911 changed = true; 2912 if (wakeLock.mDisabled) { 2913 // This wake lock is no longer being respected. 2914 notifyWakeLockReleasedLocked(wakeLock); 2915 } else { 2916 notifyWakeLockAcquiredLocked(wakeLock); 2917 } 2918 } 2919 } 2920 } 2921 if (changed) { 2922 mDirty |= DIRTY_WAKE_LOCKS; 2923 updatePowerStateLocked(); 2924 } 2925 } 2926 2927 private boolean setWakeLockDisabledStateLocked(WakeLock wakeLock) { 2928 if ((wakeLock.mFlags & PowerManager.WAKE_LOCK_LEVEL_MASK) 2929 == PowerManager.PARTIAL_WAKE_LOCK) { 2930 boolean disabled = false; 2931 final int appid = UserHandle.getAppId(wakeLock.mOwnerUid); 2932 if (appid >= Process.FIRST_APPLICATION_UID) { 2933 if (mDeviceIdleMode) { 2934 // If we are in idle mode, we will ignore all partial wake locks that are 2935 // for application uids that are not whitelisted. 2936 final UidState state = wakeLock.mUidState; 2937 if (Arrays.binarySearch(mDeviceIdleWhitelist, appid) < 0 && 2938 Arrays.binarySearch(mDeviceIdleTempWhitelist, appid) < 0 && 2939 state.mProcState != ActivityManager.PROCESS_STATE_NONEXISTENT && 2940 state.mProcState > ActivityManager.PROCESS_STATE_FOREGROUND_SERVICE) { 2941 disabled = true; 2942 } 2943 } else if (mConstants.NO_CACHED_WAKE_LOCKS) { 2944 disabled = !wakeLock.mUidState.mActive && 2945 wakeLock.mUidState.mProcState 2946 != ActivityManager.PROCESS_STATE_NONEXISTENT && 2947 wakeLock.mUidState.mProcState > ActivityManager.PROCESS_STATE_RECEIVER; 2948 } 2949 } 2950 if (wakeLock.mDisabled != disabled) { 2951 wakeLock.mDisabled = disabled; 2952 return true; 2953 } 2954 } 2955 return false; 2956 } 2957 2958 private boolean isMaximumScreenOffTimeoutFromDeviceAdminEnforcedLocked() { 2959 return mMaximumScreenOffTimeoutFromDeviceAdmin >= 0 2960 && mMaximumScreenOffTimeoutFromDeviceAdmin < Integer.MAX_VALUE; 2961 } 2962 2963 private void setAttentionLightInternal(boolean on, int color) { 2964 Light light; 2965 synchronized (mLock) { 2966 if (!mSystemReady) { 2967 return; 2968 } 2969 light = mAttentionLight; 2970 } 2971 2972 // Control light outside of lock. 2973 light.setFlashing(color, Light.LIGHT_FLASH_HARDWARE, (on ? 3 : 0), 0); 2974 } 2975 2976 private void boostScreenBrightnessInternal(long eventTime, int uid) { 2977 synchronized (mLock) { 2978 if (!mSystemReady || mWakefulness == WAKEFULNESS_ASLEEP 2979 || eventTime < mLastScreenBrightnessBoostTime) { 2980 return; 2981 } 2982 2983 Slog.i(TAG, "Brightness boost activated (uid " + uid +")..."); 2984 mLastScreenBrightnessBoostTime = eventTime; 2985 if (!mScreenBrightnessBoostInProgress) { 2986 mScreenBrightnessBoostInProgress = true; 2987 mNotifier.onScreenBrightnessBoostChanged(); 2988 } 2989 mDirty |= DIRTY_SCREEN_BRIGHTNESS_BOOST; 2990 2991 userActivityNoUpdateLocked(eventTime, 2992 PowerManager.USER_ACTIVITY_EVENT_OTHER, 0, uid); 2993 updatePowerStateLocked(); 2994 } 2995 } 2996 2997 private boolean isScreenBrightnessBoostedInternal() { 2998 synchronized (mLock) { 2999 return mScreenBrightnessBoostInProgress; 3000 } 3001 } 3002 3003 /** 3004 * Called when a screen brightness boost timeout has occurred. 3005 * 3006 * This function must have no other side-effects besides setting the dirty 3007 * bit and calling update power state. 3008 */ 3009 private void handleScreenBrightnessBoostTimeout() { // runs on handler thread 3010 synchronized (mLock) { 3011 if (DEBUG_SPEW) { 3012 Slog.d(TAG, "handleScreenBrightnessBoostTimeout"); 3013 } 3014 3015 mDirty |= DIRTY_SCREEN_BRIGHTNESS_BOOST; 3016 updatePowerStateLocked(); 3017 } 3018 } 3019 3020 private void setScreenBrightnessOverrideFromWindowManagerInternal(int brightness) { 3021 synchronized (mLock) { 3022 if (mScreenBrightnessOverrideFromWindowManager != brightness) { 3023 mScreenBrightnessOverrideFromWindowManager = brightness; 3024 mDirty |= DIRTY_SETTINGS; 3025 updatePowerStateLocked(); 3026 } 3027 } 3028 } 3029 3030 private void setUserInactiveOverrideFromWindowManagerInternal() { 3031 synchronized (mLock) { 3032 mUserInactiveOverrideFromWindowManager = true; 3033 mDirty |= DIRTY_USER_ACTIVITY; 3034 updatePowerStateLocked(); 3035 } 3036 } 3037 3038 private void setUserActivityTimeoutOverrideFromWindowManagerInternal(long timeoutMillis) { 3039 synchronized (mLock) { 3040 if (mUserActivityTimeoutOverrideFromWindowManager != timeoutMillis) { 3041 mUserActivityTimeoutOverrideFromWindowManager = timeoutMillis; 3042 mDirty |= DIRTY_SETTINGS; 3043 updatePowerStateLocked(); 3044 } 3045 } 3046 } 3047 3048 private void setTemporaryScreenBrightnessSettingOverrideInternal(int brightness) { 3049 synchronized (mLock) { 3050 if (mTemporaryScreenBrightnessSettingOverride != brightness) { 3051 mTemporaryScreenBrightnessSettingOverride = brightness; 3052 mDirty |= DIRTY_SETTINGS; 3053 updatePowerStateLocked(); 3054 } 3055 } 3056 } 3057 3058 private void setTemporaryScreenAutoBrightnessAdjustmentSettingOverrideInternal(float adj) { 3059 synchronized (mLock) { 3060 // Note: This condition handles NaN because NaN is not equal to any other 3061 // value, including itself. 3062 if (mTemporaryScreenAutoBrightnessAdjustmentSettingOverride != adj) { 3063 mTemporaryScreenAutoBrightnessAdjustmentSettingOverride = adj; 3064 mDirty |= DIRTY_SETTINGS; 3065 updatePowerStateLocked(); 3066 } 3067 } 3068 } 3069 3070 private void setDozeOverrideFromDreamManagerInternal( 3071 int screenState, int screenBrightness) { 3072 synchronized (mLock) { 3073 if (mDozeScreenStateOverrideFromDreamManager != screenState 3074 || mDozeScreenBrightnessOverrideFromDreamManager != screenBrightness) { 3075 mDozeScreenStateOverrideFromDreamManager = screenState; 3076 mDozeScreenBrightnessOverrideFromDreamManager = screenBrightness; 3077 mDirty |= DIRTY_SETTINGS; 3078 updatePowerStateLocked(); 3079 } 3080 } 3081 } 3082 3083 private void powerHintInternal(int hintId, int data) { 3084 nativeSendPowerHint(hintId, data); 3085 } 3086 3087 /** 3088 * Low-level function turn the device off immediately, without trying 3089 * to be clean. Most people should use {@link ShutdownThread} for a clean shutdown. 3090 * 3091 * @param reason code to pass to android_reboot() (e.g. "userrequested"), or null. 3092 */ 3093 public static void lowLevelShutdown(String reason) { 3094 if (reason == null) { 3095 reason = ""; 3096 } 3097 SystemProperties.set("sys.powerctl", "shutdown," + reason); 3098 } 3099 3100 /** 3101 * Low-level function to reboot the device. On success, this 3102 * function doesn't return. If more than 20 seconds passes from 3103 * the time a reboot is requested, this method returns. 3104 * 3105 * @param reason code to pass to the kernel (e.g. "recovery"), or null. 3106 */ 3107 public static void lowLevelReboot(String reason) { 3108 if (reason == null) { 3109 reason = ""; 3110 } 3111 if (reason.equals(PowerManager.REBOOT_RECOVERY) 3112 || reason.equals(PowerManager.REBOOT_RECOVERY_UPDATE)) { 3113 reason = "recovery"; 3114 } 3115 3116 // If the reason is "quiescent", it means that the boot process should proceed 3117 // without turning on the screen/lights. 3118 // The "quiescent" property is sticky, meaning that any number 3119 // of subsequent reboots should honor the property until it is reset. 3120 if (reason.equals(PowerManager.REBOOT_QUIESCENT)) { 3121 sQuiescent = true; 3122 reason = ""; 3123 } 3124 3125 if (sQuiescent) { 3126 // Pass the optional "quiescent" argument to the bootloader to let it know 3127 // that it should not turn the screen/lights on. 3128 reason = reason + ",quiescent"; 3129 } 3130 3131 SystemProperties.set("sys.powerctl", "reboot," + reason); 3132 try { 3133 Thread.sleep(20 * 1000L); 3134 } catch (InterruptedException e) { 3135 Thread.currentThread().interrupt(); 3136 } 3137 Slog.wtf(TAG, "Unexpected return from lowLevelReboot!"); 3138 } 3139 3140 @Override // Watchdog.Monitor implementation 3141 public void monitor() { 3142 // Grab and release lock for watchdog monitor to detect deadlocks. 3143 synchronized (mLock) { 3144 } 3145 } 3146 3147 private void dumpInternal(PrintWriter pw) { 3148 pw.println("POWER MANAGER (dumpsys power)\n"); 3149 3150 final WirelessChargerDetector wcd; 3151 synchronized (mLock) { 3152 pw.println("Power Manager State:"); 3153 mConstants.dump(pw); 3154 pw.println(" mDirty=0x" + Integer.toHexString(mDirty)); 3155 pw.println(" mWakefulness=" + PowerManagerInternal.wakefulnessToString(mWakefulness)); 3156 pw.println(" mWakefulnessChanging=" + mWakefulnessChanging); 3157 pw.println(" mIsPowered=" + mIsPowered); 3158 pw.println(" mPlugType=" + mPlugType); 3159 pw.println(" mBatteryLevel=" + mBatteryLevel); 3160 pw.println(" mBatteryLevelWhenDreamStarted=" + mBatteryLevelWhenDreamStarted); 3161 pw.println(" mDockState=" + mDockState); 3162 pw.println(" mStayOn=" + mStayOn); 3163 pw.println(" mProximityPositive=" + mProximityPositive); 3164 pw.println(" mBootCompleted=" + mBootCompleted); 3165 pw.println(" mSystemReady=" + mSystemReady); 3166 pw.println(" mHalAutoSuspendModeEnabled=" + mHalAutoSuspendModeEnabled); 3167 pw.println(" mHalInteractiveModeEnabled=" + mHalInteractiveModeEnabled); 3168 pw.println(" mWakeLockSummary=0x" + Integer.toHexString(mWakeLockSummary)); 3169 pw.print(" mNotifyLongScheduled="); 3170 if (mNotifyLongScheduled == 0) { 3171 pw.print("(none)"); 3172 } else { 3173 TimeUtils.formatDuration(mNotifyLongScheduled, SystemClock.uptimeMillis(), pw); 3174 } 3175 pw.println(); 3176 pw.print(" mNotifyLongDispatched="); 3177 if (mNotifyLongDispatched == 0) { 3178 pw.print("(none)"); 3179 } else { 3180 TimeUtils.formatDuration(mNotifyLongDispatched, SystemClock.uptimeMillis(), pw); 3181 } 3182 pw.println(); 3183 pw.print(" mNotifyLongNextCheck="); 3184 if (mNotifyLongNextCheck == 0) { 3185 pw.print("(none)"); 3186 } else { 3187 TimeUtils.formatDuration(mNotifyLongNextCheck, SystemClock.uptimeMillis(), pw); 3188 } 3189 pw.println(); 3190 pw.println(" mUserActivitySummary=0x" + Integer.toHexString(mUserActivitySummary)); 3191 pw.println(" mRequestWaitForNegativeProximity=" + mRequestWaitForNegativeProximity); 3192 pw.println(" mSandmanScheduled=" + mSandmanScheduled); 3193 pw.println(" mSandmanSummoned=" + mSandmanSummoned); 3194 pw.println(" mLowPowerModeEnabled=" + mLowPowerModeEnabled); 3195 pw.println(" mBatteryLevelLow=" + mBatteryLevelLow); 3196 pw.println(" mLightDeviceIdleMode=" + mLightDeviceIdleMode); 3197 pw.println(" mDeviceIdleMode=" + mDeviceIdleMode); 3198 pw.println(" mDeviceIdleWhitelist=" + Arrays.toString(mDeviceIdleWhitelist)); 3199 pw.println(" mDeviceIdleTempWhitelist=" + Arrays.toString(mDeviceIdleTempWhitelist)); 3200 pw.println(" mLastWakeTime=" + TimeUtils.formatUptime(mLastWakeTime)); 3201 pw.println(" mLastSleepTime=" + TimeUtils.formatUptime(mLastSleepTime)); 3202 pw.println(" mLastUserActivityTime=" + TimeUtils.formatUptime(mLastUserActivityTime)); 3203 pw.println(" mLastUserActivityTimeNoChangeLights=" 3204 + TimeUtils.formatUptime(mLastUserActivityTimeNoChangeLights)); 3205 pw.println(" mLastInteractivePowerHintTime=" 3206 + TimeUtils.formatUptime(mLastInteractivePowerHintTime)); 3207 pw.println(" mLastScreenBrightnessBoostTime=" 3208 + TimeUtils.formatUptime(mLastScreenBrightnessBoostTime)); 3209 pw.println(" mScreenBrightnessBoostInProgress=" 3210 + mScreenBrightnessBoostInProgress); 3211 pw.println(" mDisplayReady=" + mDisplayReady); 3212 pw.println(" mHoldingWakeLockSuspendBlocker=" + mHoldingWakeLockSuspendBlocker); 3213 pw.println(" mHoldingDisplaySuspendBlocker=" + mHoldingDisplaySuspendBlocker); 3214 3215 pw.println(); 3216 pw.println("Settings and Configuration:"); 3217 pw.println(" mDecoupleHalAutoSuspendModeFromDisplayConfig=" 3218 + mDecoupleHalAutoSuspendModeFromDisplayConfig); 3219 pw.println(" mDecoupleHalInteractiveModeFromDisplayConfig=" 3220 + mDecoupleHalInteractiveModeFromDisplayConfig); 3221 pw.println(" mWakeUpWhenPluggedOrUnpluggedConfig=" 3222 + mWakeUpWhenPluggedOrUnpluggedConfig); 3223 pw.println(" mWakeUpWhenPluggedOrUnpluggedInTheaterModeConfig=" 3224 + mWakeUpWhenPluggedOrUnpluggedInTheaterModeConfig); 3225 pw.println(" mTheaterModeEnabled=" 3226 + mTheaterModeEnabled); 3227 pw.println(" mSuspendWhenScreenOffDueToProximityConfig=" 3228 + mSuspendWhenScreenOffDueToProximityConfig); 3229 pw.println(" mDreamsSupportedConfig=" + mDreamsSupportedConfig); 3230 pw.println(" mDreamsEnabledByDefaultConfig=" + mDreamsEnabledByDefaultConfig); 3231 pw.println(" mDreamsActivatedOnSleepByDefaultConfig=" 3232 + mDreamsActivatedOnSleepByDefaultConfig); 3233 pw.println(" mDreamsActivatedOnDockByDefaultConfig=" 3234 + mDreamsActivatedOnDockByDefaultConfig); 3235 pw.println(" mDreamsEnabledOnBatteryConfig=" 3236 + mDreamsEnabledOnBatteryConfig); 3237 pw.println(" mDreamsBatteryLevelMinimumWhenPoweredConfig=" 3238 + mDreamsBatteryLevelMinimumWhenPoweredConfig); 3239 pw.println(" mDreamsBatteryLevelMinimumWhenNotPoweredConfig=" 3240 + mDreamsBatteryLevelMinimumWhenNotPoweredConfig); 3241 pw.println(" mDreamsBatteryLevelDrainCutoffConfig=" 3242 + mDreamsBatteryLevelDrainCutoffConfig); 3243 pw.println(" mDreamsEnabledSetting=" + mDreamsEnabledSetting); 3244 pw.println(" mDreamsActivateOnSleepSetting=" + mDreamsActivateOnSleepSetting); 3245 pw.println(" mDreamsActivateOnDockSetting=" + mDreamsActivateOnDockSetting); 3246 pw.println(" mDozeAfterScreenOffConfig=" + mDozeAfterScreenOffConfig); 3247 pw.println(" mLowPowerModeSetting=" + mLowPowerModeSetting); 3248 pw.println(" mAutoLowPowerModeConfigured=" + mAutoLowPowerModeConfigured); 3249 pw.println(" mAutoLowPowerModeSnoozing=" + mAutoLowPowerModeSnoozing); 3250 pw.println(" mMinimumScreenOffTimeoutConfig=" + mMinimumScreenOffTimeoutConfig); 3251 pw.println(" mMaximumScreenDimDurationConfig=" + mMaximumScreenDimDurationConfig); 3252 pw.println(" mMaximumScreenDimRatioConfig=" + mMaximumScreenDimRatioConfig); 3253 pw.println(" mScreenOffTimeoutSetting=" + mScreenOffTimeoutSetting); 3254 pw.println(" mSleepTimeoutSetting=" + mSleepTimeoutSetting); 3255 pw.println(" mMaximumScreenOffTimeoutFromDeviceAdmin=" 3256 + mMaximumScreenOffTimeoutFromDeviceAdmin + " (enforced=" 3257 + isMaximumScreenOffTimeoutFromDeviceAdminEnforcedLocked() + ")"); 3258 pw.println(" mStayOnWhilePluggedInSetting=" + mStayOnWhilePluggedInSetting); 3259 pw.println(" mScreenBrightnessSetting=" + mScreenBrightnessSetting); 3260 pw.println(" mScreenAutoBrightnessAdjustmentSetting=" 3261 + mScreenAutoBrightnessAdjustmentSetting); 3262 pw.println(" mScreenBrightnessModeSetting=" + mScreenBrightnessModeSetting); 3263 pw.println(" mScreenBrightnessOverrideFromWindowManager=" 3264 + mScreenBrightnessOverrideFromWindowManager); 3265 pw.println(" mUserActivityTimeoutOverrideFromWindowManager=" 3266 + mUserActivityTimeoutOverrideFromWindowManager); 3267 pw.println(" mUserInactiveOverrideFromWindowManager=" 3268 + mUserInactiveOverrideFromWindowManager); 3269 pw.println(" mTemporaryScreenBrightnessSettingOverride=" 3270 + mTemporaryScreenBrightnessSettingOverride); 3271 pw.println(" mTemporaryScreenAutoBrightnessAdjustmentSettingOverride=" 3272 + mTemporaryScreenAutoBrightnessAdjustmentSettingOverride); 3273 pw.println(" mDozeScreenStateOverrideFromDreamManager=" 3274 + mDozeScreenStateOverrideFromDreamManager); 3275 pw.println(" mDozeScreenBrightnessOverrideFromDreamManager=" 3276 + mDozeScreenBrightnessOverrideFromDreamManager); 3277 pw.println(" mScreenBrightnessSettingMinimum=" + mScreenBrightnessSettingMinimum); 3278 pw.println(" mScreenBrightnessSettingMaximum=" + mScreenBrightnessSettingMaximum); 3279 pw.println(" mScreenBrightnessSettingDefault=" + mScreenBrightnessSettingDefault); 3280 pw.println(" mScreenBrightnessForVrSettingDefault=" 3281 + mScreenBrightnessForVrSettingDefault); 3282 pw.println(" mScreenBrightnessForVrSetting=" + mScreenBrightnessForVrSetting); 3283 pw.println(" mDoubleTapWakeEnabled=" + mDoubleTapWakeEnabled); 3284 pw.println(" mIsVrModeEnabled=" + mIsVrModeEnabled); 3285 3286 final int sleepTimeout = getSleepTimeoutLocked(); 3287 final int screenOffTimeout = getScreenOffTimeoutLocked(sleepTimeout); 3288 final int screenDimDuration = getScreenDimDurationLocked(screenOffTimeout); 3289 pw.println(); 3290 pw.println("Sleep timeout: " + sleepTimeout + " ms"); 3291 pw.println("Screen off timeout: " + screenOffTimeout + " ms"); 3292 pw.println("Screen dim duration: " + screenDimDuration + " ms"); 3293 3294 pw.println(); 3295 pw.print("UID states (changing="); 3296 pw.print(mUidsChanging); 3297 pw.print(" changed="); 3298 pw.print(mUidsChanged); 3299 pw.println("):"); 3300 for (int i=0; i<mUidState.size(); i++) { 3301 final UidState state = mUidState.valueAt(i); 3302 pw.print(" UID "); UserHandle.formatUid(pw, mUidState.keyAt(i)); 3303 pw.print(": "); 3304 if (state.mActive) pw.print(" ACTIVE "); 3305 else pw.print("INACTIVE "); 3306 pw.print(" count="); 3307 pw.print(state.mNumWakeLocks); 3308 pw.print(" state="); 3309 pw.println(state.mProcState); 3310 } 3311 3312 pw.println(); 3313 pw.println("Looper state:"); 3314 mHandler.getLooper().dump(new PrintWriterPrinter(pw), " "); 3315 3316 pw.println(); 3317 pw.println("Wake Locks: size=" + mWakeLocks.size()); 3318 for (WakeLock wl : mWakeLocks) { 3319 pw.println(" " + wl); 3320 } 3321 3322 pw.println(); 3323 pw.println("Suspend Blockers: size=" + mSuspendBlockers.size()); 3324 for (SuspendBlocker sb : mSuspendBlockers) { 3325 pw.println(" " + sb); 3326 } 3327 3328 pw.println(); 3329 pw.println("Display Power: " + mDisplayPowerCallbacks); 3330 3331 mBatterySaverPolicy.dump(pw); 3332 3333 wcd = mWirelessChargerDetector; 3334 } 3335 3336 if (wcd != null) { 3337 wcd.dump(pw); 3338 } 3339 } 3340 3341 private void dumpProto(FileDescriptor fd) { 3342 final WirelessChargerDetector wcd; 3343 final ProtoOutputStream proto = new ProtoOutputStream(fd); 3344 3345 synchronized (mLock) { 3346 mConstants.dumpProto(proto); 3347 proto.write(PowerServiceDumpProto.DIRTY, mDirty); 3348 proto.write(PowerServiceDumpProto.WAKEFULNESS, mWakefulness); 3349 proto.write(PowerServiceDumpProto.IS_WAKEFULNESS_CHANGING, mWakefulnessChanging); 3350 proto.write(PowerServiceDumpProto.IS_POWERED, mIsPowered); 3351 proto.write(PowerServiceDumpProto.PLUG_TYPE, mPlugType); 3352 proto.write(PowerServiceDumpProto.BATTERY_LEVEL, mBatteryLevel); 3353 proto.write( 3354 PowerServiceDumpProto.BATTERY_LEVEL_WHEN_DREAM_STARTED, 3355 mBatteryLevelWhenDreamStarted); 3356 proto.write(PowerServiceDumpProto.DOCK_STATE, mDockState); 3357 proto.write(PowerServiceDumpProto.IS_STAY_ON, mStayOn); 3358 proto.write(PowerServiceDumpProto.IS_PROXIMITY_POSITIVE, mProximityPositive); 3359 proto.write(PowerServiceDumpProto.IS_BOOT_COMPLETED, mBootCompleted); 3360 proto.write(PowerServiceDumpProto.IS_SYSTEM_READY, mSystemReady); 3361 proto.write( 3362 PowerServiceDumpProto.IS_HAL_AUTO_SUSPEND_MODE_ENABLED, 3363 mHalAutoSuspendModeEnabled); 3364 proto.write( 3365 PowerServiceDumpProto.IS_HAL_AUTO_INTERACTIVE_MODE_ENABLED, 3366 mHalInteractiveModeEnabled); 3367 3368 final long activeWakeLocksToken = proto.start(PowerServiceDumpProto.ACTIVE_WAKE_LOCKS); 3369 proto.write( 3370 PowerServiceDumpProto.ActiveWakeLocksProto.IS_CPU, 3371 (mWakeLockSummary & WAKE_LOCK_CPU) != 0); 3372 proto.write( 3373 PowerServiceDumpProto.ActiveWakeLocksProto.IS_SCREEN_BRIGHT, 3374 (mWakeLockSummary & WAKE_LOCK_SCREEN_BRIGHT) != 0); 3375 proto.write( 3376 PowerServiceDumpProto.ActiveWakeLocksProto.IS_SCREEN_DIM, 3377 (mWakeLockSummary & WAKE_LOCK_SCREEN_DIM) != 0); 3378 proto.write( 3379 PowerServiceDumpProto.ActiveWakeLocksProto.IS_BUTTON_BRIGHT, 3380 (mWakeLockSummary & WAKE_LOCK_BUTTON_BRIGHT) != 0); 3381 proto.write( 3382 PowerServiceDumpProto.ActiveWakeLocksProto.IS_PROXIMITY_SCREEN_OFF, 3383 (mWakeLockSummary & WAKE_LOCK_PROXIMITY_SCREEN_OFF) != 0); 3384 proto.write( 3385 PowerServiceDumpProto.ActiveWakeLocksProto.IS_STAY_AWAKE, 3386 (mWakeLockSummary & WAKE_LOCK_STAY_AWAKE) != 0); 3387 proto.write( 3388 PowerServiceDumpProto.ActiveWakeLocksProto.IS_DOZE, 3389 (mWakeLockSummary & WAKE_LOCK_DOZE) != 0); 3390 proto.write( 3391 PowerServiceDumpProto.ActiveWakeLocksProto.IS_DRAW, 3392 (mWakeLockSummary & WAKE_LOCK_DRAW) != 0); 3393 proto.end(activeWakeLocksToken); 3394 3395 proto.write(PowerServiceDumpProto.NOTIFY_LONG_SCHEDULED_MS, mNotifyLongScheduled); 3396 proto.write(PowerServiceDumpProto.NOTIFY_LONG_DISPATCHED_MS, mNotifyLongDispatched); 3397 proto.write(PowerServiceDumpProto.NOTIFY_LONG_NEXT_CHECK_MS, mNotifyLongNextCheck); 3398 3399 final long userActivityToken = proto.start(PowerServiceDumpProto.USER_ACTIVITY); 3400 proto.write( 3401 PowerServiceDumpProto.UserActivityProto.IS_SCREEN_BRIGHT, 3402 (mUserActivitySummary & USER_ACTIVITY_SCREEN_BRIGHT) != 0); 3403 proto.write( 3404 PowerServiceDumpProto.UserActivityProto.IS_SCREEN_DIM, 3405 (mUserActivitySummary & USER_ACTIVITY_SCREEN_DIM) != 0); 3406 proto.write( 3407 PowerServiceDumpProto.UserActivityProto.IS_SCREEN_DREAM, 3408 (mUserActivitySummary & USER_ACTIVITY_SCREEN_DREAM) != 0); 3409 proto.end(userActivityToken); 3410 3411 proto.write( 3412 PowerServiceDumpProto.IS_REQUEST_WAIT_FOR_NEGATIVE_PROXIMITY, 3413 mRequestWaitForNegativeProximity); 3414 proto.write(PowerServiceDumpProto.IS_SANDMAN_SCHEDULED, mSandmanScheduled); 3415 proto.write(PowerServiceDumpProto.IS_SANDMAN_SUMMONED, mSandmanSummoned); 3416 proto.write(PowerServiceDumpProto.IS_LOW_POWER_MODE_ENABLED, mLowPowerModeEnabled); 3417 proto.write(PowerServiceDumpProto.IS_BATTERY_LEVEL_LOW, mBatteryLevelLow); 3418 proto.write(PowerServiceDumpProto.IS_LIGHT_DEVICE_IDLE_MODE, mLightDeviceIdleMode); 3419 proto.write(PowerServiceDumpProto.IS_DEVICE_IDLE_MODE, mDeviceIdleMode); 3420 3421 for (int id : mDeviceIdleWhitelist) { 3422 proto.write(PowerServiceDumpProto.DEVICE_IDLE_WHITELIST, id); 3423 } 3424 for (int id : mDeviceIdleTempWhitelist) { 3425 proto.write(PowerServiceDumpProto.DEVICE_IDLE_TEMP_WHITELIST, id); 3426 } 3427 3428 proto.write(PowerServiceDumpProto.LAST_WAKE_TIME_MS, mLastWakeTime); 3429 proto.write(PowerServiceDumpProto.LAST_SLEEP_TIME_MS, mLastSleepTime); 3430 proto.write(PowerServiceDumpProto.LAST_USER_ACTIVITY_TIME_MS, mLastUserActivityTime); 3431 proto.write( 3432 PowerServiceDumpProto.LAST_USER_ACTIVITY_TIME_NO_CHANGE_LIGHTS_MS, 3433 mLastUserActivityTimeNoChangeLights); 3434 proto.write( 3435 PowerServiceDumpProto.LAST_INTERACTIVE_POWER_HINT_TIME_MS, 3436 mLastInteractivePowerHintTime); 3437 proto.write( 3438 PowerServiceDumpProto.LAST_SCREEN_BRIGHTNESS_BOOST_TIME_MS, 3439 mLastScreenBrightnessBoostTime); 3440 proto.write( 3441 PowerServiceDumpProto.IS_SCREEN_BRIGHTNESS_BOOST_IN_PROGRESS, 3442 mScreenBrightnessBoostInProgress); 3443 proto.write(PowerServiceDumpProto.IS_DISPLAY_READY, mDisplayReady); 3444 proto.write( 3445 PowerServiceDumpProto.IS_HOLDING_WAKE_LOCK_SUSPEND_BLOCKER, 3446 mHoldingWakeLockSuspendBlocker); 3447 proto.write( 3448 PowerServiceDumpProto.IS_HOLDING_DISPLAY_SUSPEND_BLOCKER, 3449 mHoldingDisplaySuspendBlocker); 3450 3451 final long settingsAndConfigurationToken = 3452 proto.start(PowerServiceDumpProto.SETTINGS_AND_CONFIGURATION); 3453 proto.write( 3454 PowerServiceSettingsAndConfigurationDumpProto 3455 .IS_DECOUPLE_HAL_AUTO_SUSPEND_MODE_FROM_DISPLAY_CONFIG, 3456 mDecoupleHalAutoSuspendModeFromDisplayConfig); 3457 proto.write( 3458 PowerServiceSettingsAndConfigurationDumpProto 3459 .IS_DECOUPLE_HAL_INTERACTIVE_MODE_FROM_DISPLAY_CONFIG, 3460 mDecoupleHalInteractiveModeFromDisplayConfig); 3461 proto.write( 3462 PowerServiceSettingsAndConfigurationDumpProto 3463 .IS_WAKE_UP_WHEN_PLUGGED_OR_UNPLUGGED_CONFIG, 3464 mWakeUpWhenPluggedOrUnpluggedConfig); 3465 proto.write( 3466 PowerServiceSettingsAndConfigurationDumpProto 3467 .IS_WAKE_UP_WHEN_PLUGGED_OR_UNPLUGGED_IN_THEATER_MODE_CONFIG, 3468 mWakeUpWhenPluggedOrUnpluggedInTheaterModeConfig); 3469 proto.write( 3470 PowerServiceSettingsAndConfigurationDumpProto.IS_THEATER_MODE_ENABLED, 3471 mTheaterModeEnabled); 3472 proto.write( 3473 PowerServiceSettingsAndConfigurationDumpProto 3474 .IS_SUSPEND_WHEN_SCREEN_OFF_DUE_TO_PROXIMITY_CONFIG, 3475 mSuspendWhenScreenOffDueToProximityConfig); 3476 proto.write( 3477 PowerServiceSettingsAndConfigurationDumpProto.ARE_DREAMS_SUPPORTED_CONFIG, 3478 mDreamsSupportedConfig); 3479 proto.write( 3480 PowerServiceSettingsAndConfigurationDumpProto 3481 .ARE_DREAMS_ENABLED_BY_DEFAULT_CONFIG, 3482 mDreamsEnabledByDefaultConfig); 3483 proto.write( 3484 PowerServiceSettingsAndConfigurationDumpProto 3485 .ARE_DREAMS_ACTIVATED_ON_SLEEP_BY_DEFAULT_CONFIG, 3486 mDreamsActivatedOnSleepByDefaultConfig); 3487 proto.write( 3488 PowerServiceSettingsAndConfigurationDumpProto 3489 .ARE_DREAMS_ACTIVATED_ON_DOCK_BY_DEFAULT_CONFIG, 3490 mDreamsActivatedOnDockByDefaultConfig); 3491 proto.write( 3492 PowerServiceSettingsAndConfigurationDumpProto 3493 .ARE_DREAMS_ENABLED_ON_BATTERY_CONFIG, 3494 mDreamsEnabledOnBatteryConfig); 3495 proto.write( 3496 PowerServiceSettingsAndConfigurationDumpProto 3497 .DREAMS_BATTERY_LEVEL_MINIMUM_WHEN_POWERED_CONFIG, 3498 mDreamsBatteryLevelMinimumWhenPoweredConfig); 3499 proto.write( 3500 PowerServiceSettingsAndConfigurationDumpProto 3501 .DREAMS_BATTERY_LEVEL_MINIMUM_WHEN_NOT_POWERED_CONFIG, 3502 mDreamsBatteryLevelMinimumWhenNotPoweredConfig); 3503 proto.write( 3504 PowerServiceSettingsAndConfigurationDumpProto 3505 .DREAMS_BATTERY_LEVEL_DRAIN_CUTOFF_CONFIG, 3506 mDreamsBatteryLevelDrainCutoffConfig); 3507 proto.write( 3508 PowerServiceSettingsAndConfigurationDumpProto.ARE_DREAMS_ENABLED_SETTING, 3509 mDreamsEnabledSetting); 3510 proto.write( 3511 PowerServiceSettingsAndConfigurationDumpProto 3512 .ARE_DREAMS_ACTIVATE_ON_SLEEP_SETTING, 3513 mDreamsActivateOnSleepSetting); 3514 proto.write( 3515 PowerServiceSettingsAndConfigurationDumpProto 3516 .ARE_DREAMS_ACTIVATE_ON_DOCK_SETTING, 3517 mDreamsActivateOnDockSetting); 3518 proto.write( 3519 PowerServiceSettingsAndConfigurationDumpProto.IS_DOZE_AFTER_SCREEN_OFF_CONFIG, 3520 mDozeAfterScreenOffConfig); 3521 proto.write( 3522 PowerServiceSettingsAndConfigurationDumpProto.IS_LOW_POWER_MODE_SETTING, 3523 mLowPowerModeSetting); 3524 proto.write( 3525 PowerServiceSettingsAndConfigurationDumpProto.IS_AUTO_LOW_POWER_MODE_CONFIGURED, 3526 mAutoLowPowerModeConfigured); 3527 proto.write( 3528 PowerServiceSettingsAndConfigurationDumpProto.IS_AUTO_LOW_POWER_MODE_SNOOZING, 3529 mAutoLowPowerModeSnoozing); 3530 proto.write( 3531 PowerServiceSettingsAndConfigurationDumpProto 3532 .MINIMUM_SCREEN_OFF_TIMEOUT_CONFIG_MS, 3533 mMinimumScreenOffTimeoutConfig); 3534 proto.write( 3535 PowerServiceSettingsAndConfigurationDumpProto 3536 .MAXIMUM_SCREEN_DIM_DURATION_CONFIG_MS, 3537 mMaximumScreenDimDurationConfig); 3538 proto.write( 3539 PowerServiceSettingsAndConfigurationDumpProto.MAXIMUM_SCREEN_DIM_RATIO_CONFIG, 3540 mMaximumScreenDimRatioConfig); 3541 proto.write( 3542 PowerServiceSettingsAndConfigurationDumpProto.SCREEN_OFF_TIMEOUT_SETTING_MS, 3543 mScreenOffTimeoutSetting); 3544 proto.write( 3545 PowerServiceSettingsAndConfigurationDumpProto.SLEEP_TIMEOUT_SETTING_MS, 3546 mSleepTimeoutSetting); 3547 proto.write( 3548 PowerServiceSettingsAndConfigurationDumpProto 3549 .MAXIMUM_SCREEN_OFF_TIMEOUT_FROM_DEVICE_ADMIN_MS, 3550 mMaximumScreenOffTimeoutFromDeviceAdmin); 3551 proto.write( 3552 PowerServiceSettingsAndConfigurationDumpProto 3553 .IS_MAXIMUM_SCREEN_OFF_TIMEOUT_FROM_DEVICE_ADMIN_ENFORCED_LOCKED, 3554 isMaximumScreenOffTimeoutFromDeviceAdminEnforcedLocked()); 3555 3556 final long stayOnWhilePluggedInToken = 3557 proto.start( 3558 PowerServiceSettingsAndConfigurationDumpProto.STAY_ON_WHILE_PLUGGED_IN); 3559 proto.write( 3560 PowerServiceSettingsAndConfigurationDumpProto.StayOnWhilePluggedInProto 3561 .IS_STAY_ON_WHILE_PLUGGED_IN_AC, 3562 ((mStayOnWhilePluggedInSetting & BatteryManager.BATTERY_PLUGGED_AC) != 0)); 3563 proto.write( 3564 PowerServiceSettingsAndConfigurationDumpProto.StayOnWhilePluggedInProto 3565 .IS_STAY_ON_WHILE_PLUGGED_IN_USB, 3566 ((mStayOnWhilePluggedInSetting & BatteryManager.BATTERY_PLUGGED_USB) != 0)); 3567 proto.write( 3568 PowerServiceSettingsAndConfigurationDumpProto.StayOnWhilePluggedInProto 3569 .IS_STAY_ON_WHILE_PLUGGED_IN_WIRELESS, 3570 ((mStayOnWhilePluggedInSetting & BatteryManager.BATTERY_PLUGGED_WIRELESS) 3571 != 0)); 3572 proto.end(stayOnWhilePluggedInToken); 3573 3574 proto.write( 3575 PowerServiceSettingsAndConfigurationDumpProto.SCREEN_BRIGHTNESS_SETTING, 3576 mScreenBrightnessSetting); 3577 proto.write( 3578 PowerServiceSettingsAndConfigurationDumpProto 3579 .SCREEN_AUTO_BRIGHTNESS_ADJUSTMENT_SETTING, 3580 mScreenAutoBrightnessAdjustmentSetting); 3581 proto.write( 3582 PowerServiceSettingsAndConfigurationDumpProto.SCREEN_BRIGHTNESS_MODE_SETTING, 3583 mScreenBrightnessModeSetting); 3584 proto.write( 3585 PowerServiceSettingsAndConfigurationDumpProto 3586 .SCREEN_BRIGHTNESS_OVERRIDE_FROM_WINDOW_MANAGER, 3587 mScreenBrightnessOverrideFromWindowManager); 3588 proto.write( 3589 PowerServiceSettingsAndConfigurationDumpProto 3590 .USER_ACTIVITY_TIMEOUT_OVERRIDE_FROM_WINDOW_MANAGER_MS, 3591 mUserActivityTimeoutOverrideFromWindowManager); 3592 proto.write( 3593 PowerServiceSettingsAndConfigurationDumpProto 3594 .IS_USER_INACTIVE_OVERRIDE_FROM_WINDOW_MANAGER, 3595 mUserInactiveOverrideFromWindowManager); 3596 proto.write( 3597 PowerServiceSettingsAndConfigurationDumpProto 3598 .TEMPORARY_SCREEN_BRIGHTNESS_SETTING_OVERRIDE, 3599 mTemporaryScreenBrightnessSettingOverride); 3600 proto.write( 3601 PowerServiceSettingsAndConfigurationDumpProto 3602 .TEMPORARY_SCREEN_AUTO_BRIGHTNESS_ADJUSTMENT_SETTING_OVERRIDE, 3603 mTemporaryScreenAutoBrightnessAdjustmentSettingOverride); 3604 proto.write( 3605 PowerServiceSettingsAndConfigurationDumpProto 3606 .DOZE_SCREEN_STATE_OVERRIDE_FROM_DREAM_MANAGER, 3607 mDozeScreenStateOverrideFromDreamManager); 3608 proto.write( 3609 PowerServiceSettingsAndConfigurationDumpProto 3610 .DOZED_SCREEN_BRIGHTNESS_OVERRIDE_FROM_DREAM_MANAGER, 3611 mDozeScreenBrightnessOverrideFromDreamManager); 3612 3613 final long screenBrightnessSettingLimitsToken = 3614 proto.start( 3615 PowerServiceSettingsAndConfigurationDumpProto 3616 .SCREEN_BRIGHTNESS_SETTING_LIMITS); 3617 proto.write( 3618 PowerServiceSettingsAndConfigurationDumpProto.ScreenBrightnessSettingLimitsProto 3619 .SETTING_MINIMUM, 3620 mScreenBrightnessSettingMinimum); 3621 proto.write( 3622 PowerServiceSettingsAndConfigurationDumpProto.ScreenBrightnessSettingLimitsProto 3623 .SETTING_MAXIMUM, 3624 mScreenBrightnessSettingMaximum); 3625 proto.write( 3626 PowerServiceSettingsAndConfigurationDumpProto.ScreenBrightnessSettingLimitsProto 3627 .SETTING_DEFAULT, 3628 mScreenBrightnessSettingDefault); 3629 proto.write( 3630 PowerServiceSettingsAndConfigurationDumpProto.ScreenBrightnessSettingLimitsProto 3631 .SETTING_FOR_VR_DEFAULT, 3632 mScreenBrightnessForVrSettingDefault); 3633 proto.end(screenBrightnessSettingLimitsToken); 3634 3635 proto.write( 3636 PowerServiceSettingsAndConfigurationDumpProto.SCREEN_BRIGHTNESS_FOR_VR_SETTING, 3637 mScreenBrightnessForVrSetting); 3638 proto.write( 3639 PowerServiceSettingsAndConfigurationDumpProto.IS_DOUBLE_TAP_WAKE_ENABLED, 3640 mDoubleTapWakeEnabled); 3641 proto.write( 3642 PowerServiceSettingsAndConfigurationDumpProto.IS_VR_MODE_ENABLED, 3643 mIsVrModeEnabled); 3644 proto.end(settingsAndConfigurationToken); 3645 3646 final int sleepTimeout = getSleepTimeoutLocked(); 3647 final int screenOffTimeout = getScreenOffTimeoutLocked(sleepTimeout); 3648 final int screenDimDuration = getScreenDimDurationLocked(screenOffTimeout); 3649 proto.write(PowerServiceDumpProto.SLEEP_TIMEOUT_MS, sleepTimeout); 3650 proto.write(PowerServiceDumpProto.SCREEN_OFF_TIMEOUT_MS, screenOffTimeout); 3651 proto.write(PowerServiceDumpProto.SCREEN_DIM_DURATION_MS, screenDimDuration); 3652 proto.write(PowerServiceDumpProto.ARE_UIDS_CHANGING, mUidsChanging); 3653 proto.write(PowerServiceDumpProto.ARE_UIDS_CHANGED, mUidsChanged); 3654 3655 for (int i = 0; i < mUidState.size(); i++) { 3656 final UidState state = mUidState.valueAt(i); 3657 final long uIDToken = proto.start(PowerServiceDumpProto.UIDS); 3658 final int uid = mUidState.keyAt(i); 3659 proto.write(PowerServiceDumpProto.UidProto.UID, uid); 3660 proto.write(PowerServiceDumpProto.UidProto.UID_STRING, UserHandle.formatUid(uid)); 3661 proto.write(PowerServiceDumpProto.UidProto.IS_ACTIVE, state.mActive); 3662 proto.write(PowerServiceDumpProto.UidProto.NUM_WAKE_LOCKS, state.mNumWakeLocks); 3663 if (state.mProcState == ActivityManager.PROCESS_STATE_UNKNOWN) { 3664 proto.write(PowerServiceDumpProto.UidProto.IS_PROCESS_STATE_UNKNOWN, true); 3665 } else { 3666 proto.write(PowerServiceDumpProto.UidProto.PROCESS_STATE, state.mProcState); 3667 } 3668 proto.end(uIDToken); 3669 } 3670 3671 mHandler.getLooper().writeToProto(proto, PowerServiceDumpProto.LOOPER); 3672 3673 for (WakeLock wl : mWakeLocks) { 3674 wl.writeToProto(proto, PowerServiceDumpProto.WAKE_LOCKS); 3675 } 3676 3677 for (SuspendBlocker sb : mSuspendBlockers) { 3678 sb.writeToProto(proto, PowerServiceDumpProto.SUSPEND_BLOCKERS); 3679 } 3680 wcd = mWirelessChargerDetector; 3681 } 3682 3683 if (wcd != null) { 3684 wcd.writeToProto(proto, PowerServiceDumpProto.WIRELESS_CHARGER_DETECTOR); 3685 } 3686 proto.flush(); 3687 } 3688 3689 private SuspendBlocker createSuspendBlockerLocked(String name) { 3690 SuspendBlocker suspendBlocker = new SuspendBlockerImpl(name); 3691 mSuspendBlockers.add(suspendBlocker); 3692 return suspendBlocker; 3693 } 3694 3695 private void incrementBootCount() { 3696 synchronized (mLock) { 3697 int count; 3698 try { 3699 count = Settings.Global.getInt( 3700 getContext().getContentResolver(), Settings.Global.BOOT_COUNT); 3701 } catch (SettingNotFoundException e) { 3702 count = 0; 3703 } 3704 Settings.Global.putInt( 3705 getContext().getContentResolver(), Settings.Global.BOOT_COUNT, count + 1); 3706 } 3707 } 3708 3709 private static WorkSource copyWorkSource(WorkSource workSource) { 3710 return workSource != null ? new WorkSource(workSource) : null; 3711 } 3712 3713 private final class BatteryReceiver extends BroadcastReceiver { 3714 @Override 3715 public void onReceive(Context context, Intent intent) { 3716 synchronized (mLock) { 3717 handleBatteryStateChangedLocked(); 3718 } 3719 } 3720 } 3721 3722 private final class DreamReceiver extends BroadcastReceiver { 3723 @Override 3724 public void onReceive(Context context, Intent intent) { 3725 synchronized (mLock) { 3726 scheduleSandmanLocked(); 3727 } 3728 } 3729 } 3730 3731 private final class UserSwitchedReceiver extends BroadcastReceiver { 3732 @Override 3733 public void onReceive(Context context, Intent intent) { 3734 synchronized (mLock) { 3735 handleSettingsChangedLocked(); 3736 } 3737 } 3738 } 3739 3740 private final class DockReceiver extends BroadcastReceiver { 3741 @Override 3742 public void onReceive(Context context, Intent intent) { 3743 synchronized (mLock) { 3744 int dockState = intent.getIntExtra(Intent.EXTRA_DOCK_STATE, 3745 Intent.EXTRA_DOCK_STATE_UNDOCKED); 3746 if (mDockState != dockState) { 3747 mDockState = dockState; 3748 mDirty |= DIRTY_DOCK_STATE; 3749 updatePowerStateLocked(); 3750 } 3751 } 3752 } 3753 } 3754 3755 private final class SettingsObserver extends ContentObserver { 3756 public SettingsObserver(Handler handler) { 3757 super(handler); 3758 } 3759 3760 @Override 3761 public void onChange(boolean selfChange, Uri uri) { 3762 synchronized (mLock) { 3763 handleSettingsChangedLocked(); 3764 } 3765 } 3766 } 3767 3768 private final IVrStateCallbacks mVrStateCallbacks = new IVrStateCallbacks.Stub() { 3769 @Override 3770 public void onVrStateChanged(boolean enabled) { 3771 powerHintInternal(PowerHint.VR_MODE, enabled ? 1 : 0); 3772 3773 synchronized (mLock) { 3774 if (mIsVrModeEnabled != enabled) { 3775 mIsVrModeEnabled = enabled; 3776 mDirty |= DIRTY_VR_MODE_CHANGED; 3777 updatePowerStateLocked(); 3778 } 3779 } 3780 } 3781 }; 3782 3783 /** 3784 * Handler for asynchronous operations performed by the power manager. 3785 */ 3786 private final class PowerManagerHandler extends Handler { 3787 public PowerManagerHandler(Looper looper) { 3788 super(looper, null, true /*async*/); 3789 } 3790 3791 @Override 3792 public void handleMessage(Message msg) { 3793 switch (msg.what) { 3794 case MSG_USER_ACTIVITY_TIMEOUT: 3795 handleUserActivityTimeout(); 3796 break; 3797 case MSG_SANDMAN: 3798 handleSandman(); 3799 break; 3800 case MSG_SCREEN_BRIGHTNESS_BOOST_TIMEOUT: 3801 handleScreenBrightnessBoostTimeout(); 3802 break; 3803 case MSG_CHECK_FOR_LONG_WAKELOCKS: 3804 checkForLongWakeLocks(); 3805 break; 3806 } 3807 } 3808 } 3809 3810 /** 3811 * Represents a wake lock that has been acquired by an application. 3812 */ 3813 private final class WakeLock implements IBinder.DeathRecipient { 3814 public final IBinder mLock; 3815 public int mFlags; 3816 public String mTag; 3817 public final String mPackageName; 3818 public WorkSource mWorkSource; 3819 public String mHistoryTag; 3820 public final int mOwnerUid; 3821 public final int mOwnerPid; 3822 public final UidState mUidState; 3823 public long mAcquireTime; 3824 public boolean mNotifiedAcquired; 3825 public boolean mNotifiedLong; 3826 public boolean mDisabled; 3827 3828 public WakeLock(IBinder lock, int flags, String tag, String packageName, 3829 WorkSource workSource, String historyTag, int ownerUid, int ownerPid, 3830 UidState uidState) { 3831 mLock = lock; 3832 mFlags = flags; 3833 mTag = tag; 3834 mPackageName = packageName; 3835 mWorkSource = copyWorkSource(workSource); 3836 mHistoryTag = historyTag; 3837 mOwnerUid = ownerUid; 3838 mOwnerPid = ownerPid; 3839 mUidState = uidState; 3840 } 3841 3842 @Override 3843 public void binderDied() { 3844 PowerManagerService.this.handleWakeLockDeath(this); 3845 } 3846 3847 public boolean hasSameProperties(int flags, String tag, WorkSource workSource, 3848 int ownerUid, int ownerPid) { 3849 return mFlags == flags 3850 && mTag.equals(tag) 3851 && hasSameWorkSource(workSource) 3852 && mOwnerUid == ownerUid 3853 && mOwnerPid == ownerPid; 3854 } 3855 3856 public void updateProperties(int flags, String tag, String packageName, 3857 WorkSource workSource, String historyTag, int ownerUid, int ownerPid) { 3858 if (!mPackageName.equals(packageName)) { 3859 throw new IllegalStateException("Existing wake lock package name changed: " 3860 + mPackageName + " to " + packageName); 3861 } 3862 if (mOwnerUid != ownerUid) { 3863 throw new IllegalStateException("Existing wake lock uid changed: " 3864 + mOwnerUid + " to " + ownerUid); 3865 } 3866 if (mOwnerPid != ownerPid) { 3867 throw new IllegalStateException("Existing wake lock pid changed: " 3868 + mOwnerPid + " to " + ownerPid); 3869 } 3870 mFlags = flags; 3871 mTag = tag; 3872 updateWorkSource(workSource); 3873 mHistoryTag = historyTag; 3874 } 3875 3876 public boolean hasSameWorkSource(WorkSource workSource) { 3877 return Objects.equal(mWorkSource, workSource); 3878 } 3879 3880 public void updateWorkSource(WorkSource workSource) { 3881 mWorkSource = copyWorkSource(workSource); 3882 } 3883 3884 @Override 3885 public String toString() { 3886 StringBuilder sb = new StringBuilder(); 3887 sb.append(getLockLevelString()); 3888 sb.append(" '"); 3889 sb.append(mTag); 3890 sb.append("'"); 3891 sb.append(getLockFlagsString()); 3892 if (mDisabled) { 3893 sb.append(" DISABLED"); 3894 } 3895 if (mNotifiedAcquired) { 3896 sb.append(" ACQ="); 3897 TimeUtils.formatDuration(mAcquireTime-SystemClock.uptimeMillis(), sb); 3898 } 3899 if (mNotifiedLong) { 3900 sb.append(" LONG"); 3901 } 3902 sb.append(" (uid="); 3903 sb.append(mOwnerUid); 3904 if (mOwnerPid != 0) { 3905 sb.append(" pid="); 3906 sb.append(mOwnerPid); 3907 } 3908 if (mWorkSource != null) { 3909 sb.append(" ws="); 3910 sb.append(mWorkSource); 3911 } 3912 sb.append(")"); 3913 return sb.toString(); 3914 } 3915 3916 public void writeToProto(ProtoOutputStream proto, long fieldId) { 3917 final long wakeLockToken = proto.start(fieldId); 3918 proto.write(WakeLockProto.LOCK_LEVEL, (mFlags & PowerManager.WAKE_LOCK_LEVEL_MASK)); 3919 proto.write(WakeLockProto.TAG, mTag); 3920 3921 final long wakeLockFlagsToken = proto.start(WakeLockProto.FLAGS); 3922 proto.write(WakeLockProto.WakeLockFlagsProto.IS_ACQUIRE_CAUSES_WAKEUP, 3923 (mFlags & PowerManager.ACQUIRE_CAUSES_WAKEUP)!=0); 3924 proto.write(WakeLockProto.WakeLockFlagsProto.IS_ON_AFTER_RELEASE, 3925 (mFlags & PowerManager.ON_AFTER_RELEASE)!=0); 3926 proto.end(wakeLockFlagsToken); 3927 3928 proto.write(WakeLockProto.IS_DISABLED, mDisabled); 3929 if (mNotifiedAcquired) { 3930 proto.write(WakeLockProto.ACQ_MS, mAcquireTime); 3931 } 3932 proto.write(WakeLockProto.IS_NOTIFIED_LONG, mNotifiedLong); 3933 proto.write(WakeLockProto.UID, mOwnerUid); 3934 proto.write(WakeLockProto.PID, mOwnerPid); 3935 3936 if (mWorkSource != null) { 3937 mWorkSource.writeToProto(proto, WakeLockProto.WORK_SOURCE); 3938 } 3939 proto.end(wakeLockToken); 3940 } 3941 3942 @SuppressWarnings("deprecation") 3943 private String getLockLevelString() { 3944 switch (mFlags & PowerManager.WAKE_LOCK_LEVEL_MASK) { 3945 case PowerManager.FULL_WAKE_LOCK: 3946 return "FULL_WAKE_LOCK "; 3947 case PowerManager.SCREEN_BRIGHT_WAKE_LOCK: 3948 return "SCREEN_BRIGHT_WAKE_LOCK "; 3949 case PowerManager.SCREEN_DIM_WAKE_LOCK: 3950 return "SCREEN_DIM_WAKE_LOCK "; 3951 case PowerManager.PARTIAL_WAKE_LOCK: 3952 return "PARTIAL_WAKE_LOCK "; 3953 case PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK: 3954 return "PROXIMITY_SCREEN_OFF_WAKE_LOCK"; 3955 case PowerManager.DOZE_WAKE_LOCK: 3956 return "DOZE_WAKE_LOCK "; 3957 case PowerManager.DRAW_WAKE_LOCK: 3958 return "DRAW_WAKE_LOCK "; 3959 default: 3960 return "??? "; 3961 } 3962 } 3963 3964 private String getLockFlagsString() { 3965 String result = ""; 3966 if ((mFlags & PowerManager.ACQUIRE_CAUSES_WAKEUP) != 0) { 3967 result += " ACQUIRE_CAUSES_WAKEUP"; 3968 } 3969 if ((mFlags & PowerManager.ON_AFTER_RELEASE) != 0) { 3970 result += " ON_AFTER_RELEASE"; 3971 } 3972 return result; 3973 } 3974 } 3975 3976 private final class SuspendBlockerImpl implements SuspendBlocker { 3977 private final String mName; 3978 private final String mTraceName; 3979 private int mReferenceCount; 3980 3981 public SuspendBlockerImpl(String name) { 3982 mName = name; 3983 mTraceName = "SuspendBlocker (" + name + ")"; 3984 } 3985 3986 @Override 3987 protected void finalize() throws Throwable { 3988 try { 3989 if (mReferenceCount != 0) { 3990 Slog.wtf(TAG, "Suspend blocker \"" + mName 3991 + "\" was finalized without being released!"); 3992 mReferenceCount = 0; 3993 nativeReleaseSuspendBlocker(mName); 3994 Trace.asyncTraceEnd(Trace.TRACE_TAG_POWER, mTraceName, 0); 3995 } 3996 } finally { 3997 super.finalize(); 3998 } 3999 } 4000 4001 @Override 4002 public void acquire() { 4003 synchronized (this) { 4004 mReferenceCount += 1; 4005 if (mReferenceCount == 1) { 4006 if (DEBUG_SPEW) { 4007 Slog.d(TAG, "Acquiring suspend blocker \"" + mName + "\"."); 4008 } 4009 Trace.asyncTraceBegin(Trace.TRACE_TAG_POWER, mTraceName, 0); 4010 nativeAcquireSuspendBlocker(mName); 4011 } 4012 } 4013 } 4014 4015 @Override 4016 public void release() { 4017 synchronized (this) { 4018 mReferenceCount -= 1; 4019 if (mReferenceCount == 0) { 4020 if (DEBUG_SPEW) { 4021 Slog.d(TAG, "Releasing suspend blocker \"" + mName + "\"."); 4022 } 4023 nativeReleaseSuspendBlocker(mName); 4024 Trace.asyncTraceEnd(Trace.TRACE_TAG_POWER, mTraceName, 0); 4025 } else if (mReferenceCount < 0) { 4026 Slog.wtf(TAG, "Suspend blocker \"" + mName 4027 + "\" was released without being acquired!", new Throwable()); 4028 mReferenceCount = 0; 4029 } 4030 } 4031 } 4032 4033 @Override 4034 public String toString() { 4035 synchronized (this) { 4036 return mName + ": ref count=" + mReferenceCount; 4037 } 4038 } 4039 4040 public void writeToProto(ProtoOutputStream proto, long fieldId) { 4041 final long sbToken = proto.start(fieldId); 4042 synchronized (this) { 4043 proto.write(SuspendBlockerProto.NAME, mName); 4044 proto.write(SuspendBlockerProto.REFERENCE_COUNT, mReferenceCount); 4045 } 4046 proto.end(sbToken); 4047 } 4048 } 4049 4050 static final class UidState { 4051 final int mUid; 4052 int mNumWakeLocks; 4053 int mProcState; 4054 boolean mActive; 4055 4056 UidState(int uid) { 4057 mUid = uid; 4058 } 4059 } 4060 4061 private final class BinderService extends IPowerManager.Stub { 4062 @Override 4063 public void onShellCommand(FileDescriptor in, FileDescriptor out, 4064 FileDescriptor err, String[] args, ShellCallback callback, 4065 ResultReceiver resultReceiver) { 4066 (new PowerManagerShellCommand(this)).exec( 4067 this, in, out, err, args, callback, resultReceiver); 4068 } 4069 4070 @Override // Binder call 4071 public void acquireWakeLockWithUid(IBinder lock, int flags, String tag, 4072 String packageName, int uid) { 4073 if (uid < 0) { 4074 uid = Binder.getCallingUid(); 4075 } 4076 acquireWakeLock(lock, flags, tag, packageName, new WorkSource(uid), null); 4077 } 4078 4079 @Override // Binder call 4080 public void powerHint(int hintId, int data) { 4081 if (!mSystemReady) { 4082 // Service not ready yet, so who the heck cares about power hints, bah. 4083 return; 4084 } 4085 mContext.enforceCallingOrSelfPermission(android.Manifest.permission.DEVICE_POWER, null); 4086 powerHintInternal(hintId, data); 4087 } 4088 4089 @Override // Binder call 4090 public void acquireWakeLock(IBinder lock, int flags, String tag, String packageName, 4091 WorkSource ws, String historyTag) { 4092 if (lock == null) { 4093 throw new IllegalArgumentException("lock must not be null"); 4094 } 4095 if (packageName == null) { 4096 throw new IllegalArgumentException("packageName must not be null"); 4097 } 4098 PowerManager.validateWakeLockParameters(flags, tag); 4099 4100 mContext.enforceCallingOrSelfPermission(android.Manifest.permission.WAKE_LOCK, null); 4101 if ((flags & PowerManager.DOZE_WAKE_LOCK) != 0) { 4102 mContext.enforceCallingOrSelfPermission( 4103 android.Manifest.permission.DEVICE_POWER, null); 4104 } 4105 if (ws != null && ws.size() != 0) { 4106 mContext.enforceCallingOrSelfPermission( 4107 android.Manifest.permission.UPDATE_DEVICE_STATS, null); 4108 } else { 4109 ws = null; 4110 } 4111 4112 final int uid = Binder.getCallingUid(); 4113 final int pid = Binder.getCallingPid(); 4114 final long ident = Binder.clearCallingIdentity(); 4115 try { 4116 acquireWakeLockInternal(lock, flags, tag, packageName, ws, historyTag, uid, pid); 4117 } finally { 4118 Binder.restoreCallingIdentity(ident); 4119 } 4120 } 4121 4122 @Override // Binder call 4123 public void releaseWakeLock(IBinder lock, int flags) { 4124 if (lock == null) { 4125 throw new IllegalArgumentException("lock must not be null"); 4126 } 4127 4128 mContext.enforceCallingOrSelfPermission(android.Manifest.permission.WAKE_LOCK, null); 4129 4130 final long ident = Binder.clearCallingIdentity(); 4131 try { 4132 releaseWakeLockInternal(lock, flags); 4133 } finally { 4134 Binder.restoreCallingIdentity(ident); 4135 } 4136 } 4137 4138 @Override // Binder call 4139 public void updateWakeLockUids(IBinder lock, int[] uids) { 4140 WorkSource ws = null; 4141 4142 if (uids != null) { 4143 ws = new WorkSource(); 4144 // XXX should WorkSource have a way to set uids as an int[] instead of adding them 4145 // one at a time? 4146 for (int i = 0; i < uids.length; i++) { 4147 ws.add(uids[i]); 4148 } 4149 } 4150 updateWakeLockWorkSource(lock, ws, null); 4151 } 4152 4153 @Override // Binder call 4154 public void updateWakeLockWorkSource(IBinder lock, WorkSource ws, String historyTag) { 4155 if (lock == null) { 4156 throw new IllegalArgumentException("lock must not be null"); 4157 } 4158 4159 mContext.enforceCallingOrSelfPermission(android.Manifest.permission.WAKE_LOCK, null); 4160 if (ws != null && ws.size() != 0) { 4161 mContext.enforceCallingOrSelfPermission( 4162 android.Manifest.permission.UPDATE_DEVICE_STATS, null); 4163 } else { 4164 ws = null; 4165 } 4166 4167 final int callingUid = Binder.getCallingUid(); 4168 final long ident = Binder.clearCallingIdentity(); 4169 try { 4170 updateWakeLockWorkSourceInternal(lock, ws, historyTag, callingUid); 4171 } finally { 4172 Binder.restoreCallingIdentity(ident); 4173 } 4174 } 4175 4176 @Override // Binder call 4177 public boolean isWakeLockLevelSupported(int level) { 4178 final long ident = Binder.clearCallingIdentity(); 4179 try { 4180 return isWakeLockLevelSupportedInternal(level); 4181 } finally { 4182 Binder.restoreCallingIdentity(ident); 4183 } 4184 } 4185 4186 @Override // Binder call 4187 public void userActivity(long eventTime, int event, int flags) { 4188 final long now = SystemClock.uptimeMillis(); 4189 if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DEVICE_POWER) 4190 != PackageManager.PERMISSION_GRANTED 4191 && mContext.checkCallingOrSelfPermission( 4192 android.Manifest.permission.USER_ACTIVITY) 4193 != PackageManager.PERMISSION_GRANTED) { 4194 // Once upon a time applications could call userActivity(). 4195 // Now we require the DEVICE_POWER permission. Log a warning and ignore the 4196 // request instead of throwing a SecurityException so we don't break old apps. 4197 synchronized (mLock) { 4198 if (now >= mLastWarningAboutUserActivityPermission + (5 * 60 * 1000)) { 4199 mLastWarningAboutUserActivityPermission = now; 4200 Slog.w(TAG, "Ignoring call to PowerManager.userActivity() because the " 4201 + "caller does not have DEVICE_POWER or USER_ACTIVITY " 4202 + "permission. Please fix your app! " 4203 + " pid=" + Binder.getCallingPid() 4204 + " uid=" + Binder.getCallingUid()); 4205 } 4206 } 4207 return; 4208 } 4209 4210 if (eventTime > now) { 4211 throw new IllegalArgumentException("event time must not be in the future"); 4212 } 4213 4214 final int uid = Binder.getCallingUid(); 4215 final long ident = Binder.clearCallingIdentity(); 4216 try { 4217 userActivityInternal(eventTime, event, flags, uid); 4218 } finally { 4219 Binder.restoreCallingIdentity(ident); 4220 } 4221 } 4222 4223 @Override // Binder call 4224 public void wakeUp(long eventTime, String reason, String opPackageName) { 4225 if (eventTime > SystemClock.uptimeMillis()) { 4226 throw new IllegalArgumentException("event time must not be in the future"); 4227 } 4228 4229 mContext.enforceCallingOrSelfPermission( 4230 android.Manifest.permission.DEVICE_POWER, null); 4231 4232 final int uid = Binder.getCallingUid(); 4233 final long ident = Binder.clearCallingIdentity(); 4234 try { 4235 wakeUpInternal(eventTime, reason, uid, opPackageName, uid); 4236 } finally { 4237 Binder.restoreCallingIdentity(ident); 4238 } 4239 } 4240 4241 @Override // Binder call 4242 public void goToSleep(long eventTime, int reason, int flags) { 4243 if (eventTime > SystemClock.uptimeMillis()) { 4244 throw new IllegalArgumentException("event time must not be in the future"); 4245 } 4246 4247 mContext.enforceCallingOrSelfPermission( 4248 android.Manifest.permission.DEVICE_POWER, null); 4249 4250 final int uid = Binder.getCallingUid(); 4251 final long ident = Binder.clearCallingIdentity(); 4252 try { 4253 goToSleepInternal(eventTime, reason, flags, uid); 4254 } finally { 4255 Binder.restoreCallingIdentity(ident); 4256 } 4257 } 4258 4259 @Override // Binder call 4260 public void nap(long eventTime) { 4261 if (eventTime > SystemClock.uptimeMillis()) { 4262 throw new IllegalArgumentException("event time must not be in the future"); 4263 } 4264 4265 mContext.enforceCallingOrSelfPermission( 4266 android.Manifest.permission.DEVICE_POWER, null); 4267 4268 final int uid = Binder.getCallingUid(); 4269 final long ident = Binder.clearCallingIdentity(); 4270 try { 4271 napInternal(eventTime, uid); 4272 } finally { 4273 Binder.restoreCallingIdentity(ident); 4274 } 4275 } 4276 4277 @Override // Binder call 4278 public boolean isInteractive() { 4279 final long ident = Binder.clearCallingIdentity(); 4280 try { 4281 return isInteractiveInternal(); 4282 } finally { 4283 Binder.restoreCallingIdentity(ident); 4284 } 4285 } 4286 4287 @Override // Binder call 4288 public boolean isPowerSaveMode() { 4289 final long ident = Binder.clearCallingIdentity(); 4290 try { 4291 return isLowPowerModeInternal(); 4292 } finally { 4293 Binder.restoreCallingIdentity(ident); 4294 } 4295 } 4296 4297 // Binder call 4298 public PowerSaveState getPowerSaveState(@ServiceType int serviceType) { 4299 final long ident = Binder.clearCallingIdentity(); 4300 try { 4301 synchronized (mLock) { 4302 return mBatterySaverPolicy.getBatterySaverPolicy( 4303 serviceType, isLowPowerModeInternal()); 4304 } 4305 } finally { 4306 Binder.restoreCallingIdentity(ident); 4307 } 4308 } 4309 4310 @Override // Binder call 4311 public boolean setPowerSaveMode(boolean mode) { 4312 mContext.enforceCallingOrSelfPermission( 4313 android.Manifest.permission.DEVICE_POWER, null); 4314 final long ident = Binder.clearCallingIdentity(); 4315 try { 4316 return setLowPowerModeInternal(mode); 4317 } finally { 4318 Binder.restoreCallingIdentity(ident); 4319 } 4320 } 4321 4322 @Override // Binder call 4323 public boolean isDeviceIdleMode() { 4324 final long ident = Binder.clearCallingIdentity(); 4325 try { 4326 return isDeviceIdleModeInternal(); 4327 } finally { 4328 Binder.restoreCallingIdentity(ident); 4329 } 4330 } 4331 4332 @Override // Binder call 4333 public boolean isLightDeviceIdleMode() { 4334 final long ident = Binder.clearCallingIdentity(); 4335 try { 4336 return isLightDeviceIdleModeInternal(); 4337 } finally { 4338 Binder.restoreCallingIdentity(ident); 4339 } 4340 } 4341 4342 /** 4343 * Reboots the device. 4344 * 4345 * @param confirm If true, shows a reboot confirmation dialog. 4346 * @param reason The reason for the reboot, or null if none. 4347 * @param wait If true, this call waits for the reboot to complete and does not return. 4348 */ 4349 @Override // Binder call 4350 public void reboot(boolean confirm, String reason, boolean wait) { 4351 mContext.enforceCallingOrSelfPermission(android.Manifest.permission.REBOOT, null); 4352 if (PowerManager.REBOOT_RECOVERY.equals(reason) 4353 || PowerManager.REBOOT_RECOVERY_UPDATE.equals(reason)) { 4354 mContext.enforceCallingOrSelfPermission(android.Manifest.permission.RECOVERY, null); 4355 } 4356 4357 final long ident = Binder.clearCallingIdentity(); 4358 try { 4359 shutdownOrRebootInternal(HALT_MODE_REBOOT, confirm, reason, wait); 4360 } finally { 4361 Binder.restoreCallingIdentity(ident); 4362 } 4363 } 4364 4365 /** 4366 * Reboots the device into safe mode 4367 * 4368 * @param confirm If true, shows a reboot confirmation dialog. 4369 * @param wait If true, this call waits for the reboot to complete and does not return. 4370 */ 4371 @Override // Binder call 4372 public void rebootSafeMode(boolean confirm, boolean wait) { 4373 mContext.enforceCallingOrSelfPermission(android.Manifest.permission.REBOOT, null); 4374 4375 final long ident = Binder.clearCallingIdentity(); 4376 try { 4377 shutdownOrRebootInternal(HALT_MODE_REBOOT_SAFE_MODE, confirm, 4378 PowerManager.REBOOT_SAFE_MODE, wait); 4379 } finally { 4380 Binder.restoreCallingIdentity(ident); 4381 } 4382 } 4383 4384 /** 4385 * Shuts down the device. 4386 * 4387 * @param confirm If true, shows a shutdown confirmation dialog. 4388 * @param wait If true, this call waits for the shutdown to complete and does not return. 4389 */ 4390 @Override // Binder call 4391 public void shutdown(boolean confirm, String reason, boolean wait) { 4392 mContext.enforceCallingOrSelfPermission(android.Manifest.permission.REBOOT, null); 4393 4394 final long ident = Binder.clearCallingIdentity(); 4395 try { 4396 shutdownOrRebootInternal(HALT_MODE_SHUTDOWN, confirm, reason, wait); 4397 } finally { 4398 Binder.restoreCallingIdentity(ident); 4399 } 4400 } 4401 4402 /** 4403 * Crash the runtime (causing a complete restart of the Android framework). 4404 * Requires REBOOT permission. Mostly for testing. Should not return. 4405 */ 4406 @Override // Binder call 4407 public void crash(String message) { 4408 mContext.enforceCallingOrSelfPermission(android.Manifest.permission.REBOOT, null); 4409 4410 final long ident = Binder.clearCallingIdentity(); 4411 try { 4412 crashInternal(message); 4413 } finally { 4414 Binder.restoreCallingIdentity(ident); 4415 } 4416 } 4417 4418 /** 4419 * Set the setting that determines whether the device stays on when plugged in. 4420 * The argument is a bit string, with each bit specifying a power source that, 4421 * when the device is connected to that source, causes the device to stay on. 4422 * See {@link android.os.BatteryManager} for the list of power sources that 4423 * can be specified. Current values include 4424 * {@link android.os.BatteryManager#BATTERY_PLUGGED_AC} 4425 * and {@link android.os.BatteryManager#BATTERY_PLUGGED_USB} 4426 * 4427 * Used by "adb shell svc power stayon ..." 4428 * 4429 * @param val an {@code int} containing the bits that specify which power sources 4430 * should cause the device to stay on. 4431 */ 4432 @Override // Binder call 4433 public void setStayOnSetting(int val) { 4434 int uid = Binder.getCallingUid(); 4435 // if uid is of root's, we permit this operation straight away 4436 if (uid != Process.ROOT_UID) { 4437 if (!Settings.checkAndNoteWriteSettingsOperation(mContext, uid, 4438 Settings.getPackageNameForUid(mContext, uid), true)) { 4439 return; 4440 } 4441 } 4442 4443 final long ident = Binder.clearCallingIdentity(); 4444 try { 4445 setStayOnSettingInternal(val); 4446 } finally { 4447 Binder.restoreCallingIdentity(ident); 4448 } 4449 } 4450 4451 /** 4452 * Used by the settings application and brightness control widgets to 4453 * temporarily override the current screen brightness setting so that the 4454 * user can observe the effect of an intended settings change without applying 4455 * it immediately. 4456 * 4457 * The override will be canceled when the setting value is next updated. 4458 * 4459 * @param brightness The overridden brightness. 4460 * 4461 * @see android.provider.Settings.System#SCREEN_BRIGHTNESS 4462 */ 4463 @Override // Binder call 4464 public void setTemporaryScreenBrightnessSettingOverride(int brightness) { 4465 mContext.enforceCallingOrSelfPermission( 4466 android.Manifest.permission.DEVICE_POWER, null); 4467 4468 final long ident = Binder.clearCallingIdentity(); 4469 try { 4470 setTemporaryScreenBrightnessSettingOverrideInternal(brightness); 4471 } finally { 4472 Binder.restoreCallingIdentity(ident); 4473 } 4474 } 4475 4476 /** 4477 * Used by the settings application and brightness control widgets to 4478 * temporarily override the current screen auto-brightness adjustment setting so that the 4479 * user can observe the effect of an intended settings change without applying 4480 * it immediately. 4481 * 4482 * The override will be canceled when the setting value is next updated. 4483 * 4484 * @param adj The overridden brightness, or Float.NaN to disable the override. 4485 * 4486 * @see android.provider.Settings.System#SCREEN_AUTO_BRIGHTNESS_ADJ 4487 */ 4488 @Override // Binder call 4489 public void setTemporaryScreenAutoBrightnessAdjustmentSettingOverride(float adj) { 4490 mContext.enforceCallingOrSelfPermission( 4491 android.Manifest.permission.DEVICE_POWER, null); 4492 4493 final long ident = Binder.clearCallingIdentity(); 4494 try { 4495 setTemporaryScreenAutoBrightnessAdjustmentSettingOverrideInternal(adj); 4496 } finally { 4497 Binder.restoreCallingIdentity(ident); 4498 } 4499 } 4500 4501 /** 4502 * Used by the phone application to make the attention LED flash when ringing. 4503 */ 4504 @Override // Binder call 4505 public void setAttentionLight(boolean on, int color) { 4506 mContext.enforceCallingOrSelfPermission( 4507 android.Manifest.permission.DEVICE_POWER, null); 4508 4509 final long ident = Binder.clearCallingIdentity(); 4510 try { 4511 setAttentionLightInternal(on, color); 4512 } finally { 4513 Binder.restoreCallingIdentity(ident); 4514 } 4515 } 4516 4517 @Override // Binder call 4518 public void boostScreenBrightness(long eventTime) { 4519 if (eventTime > SystemClock.uptimeMillis()) { 4520 throw new IllegalArgumentException("event time must not be in the future"); 4521 } 4522 4523 mContext.enforceCallingOrSelfPermission( 4524 android.Manifest.permission.DEVICE_POWER, null); 4525 4526 final int uid = Binder.getCallingUid(); 4527 final long ident = Binder.clearCallingIdentity(); 4528 try { 4529 boostScreenBrightnessInternal(eventTime, uid); 4530 } finally { 4531 Binder.restoreCallingIdentity(ident); 4532 } 4533 } 4534 4535 @Override // Binder call 4536 public boolean isScreenBrightnessBoosted() { 4537 final long ident = Binder.clearCallingIdentity(); 4538 try { 4539 return isScreenBrightnessBoostedInternal(); 4540 } finally { 4541 Binder.restoreCallingIdentity(ident); 4542 } 4543 } 4544 4545 @Override // Binder call 4546 protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { 4547 if (!DumpUtils.checkDumpPermission(mContext, TAG, pw)) return; 4548 4549 final long ident = Binder.clearCallingIdentity(); 4550 4551 boolean isDumpProto = false; 4552 for (String arg : args) { 4553 if (arg.equals("--proto")) { 4554 isDumpProto = true; 4555 } 4556 } 4557 try { 4558 if (isDumpProto) { 4559 dumpProto(fd); 4560 } else { 4561 dumpInternal(pw); 4562 } 4563 } finally { 4564 Binder.restoreCallingIdentity(ident); 4565 } 4566 } 4567 } 4568 4569 private final class LocalService extends PowerManagerInternal { 4570 @Override 4571 public void setScreenBrightnessOverrideFromWindowManager(int screenBrightness) { 4572 if (screenBrightness < PowerManager.BRIGHTNESS_DEFAULT 4573 || screenBrightness > PowerManager.BRIGHTNESS_ON) { 4574 screenBrightness = PowerManager.BRIGHTNESS_DEFAULT; 4575 } 4576 setScreenBrightnessOverrideFromWindowManagerInternal(screenBrightness); 4577 } 4578 4579 @Override 4580 public void setButtonBrightnessOverrideFromWindowManager(int screenBrightness) { 4581 // Do nothing. 4582 // Button lights are not currently supported in the new implementation. 4583 } 4584 4585 @Override 4586 public void setDozeOverrideFromDreamManager(int screenState, int screenBrightness) { 4587 switch (screenState) { 4588 case Display.STATE_UNKNOWN: 4589 case Display.STATE_OFF: 4590 case Display.STATE_DOZE: 4591 case Display.STATE_DOZE_SUSPEND: 4592 case Display.STATE_ON: 4593 case Display.STATE_VR: 4594 break; 4595 default: 4596 screenState = Display.STATE_UNKNOWN; 4597 break; 4598 } 4599 if (screenBrightness < PowerManager.BRIGHTNESS_DEFAULT 4600 || screenBrightness > PowerManager.BRIGHTNESS_ON) { 4601 screenBrightness = PowerManager.BRIGHTNESS_DEFAULT; 4602 } 4603 setDozeOverrideFromDreamManagerInternal(screenState, screenBrightness); 4604 } 4605 4606 @Override 4607 public void setUserInactiveOverrideFromWindowManager() { 4608 setUserInactiveOverrideFromWindowManagerInternal(); 4609 } 4610 4611 @Override 4612 public void setUserActivityTimeoutOverrideFromWindowManager(long timeoutMillis) { 4613 setUserActivityTimeoutOverrideFromWindowManagerInternal(timeoutMillis); 4614 } 4615 4616 @Override 4617 public void setMaximumScreenOffTimeoutFromDeviceAdmin(int timeMs) { 4618 setMaximumScreenOffTimeoutFromDeviceAdminInternal(timeMs); 4619 } 4620 4621 @Override 4622 public PowerSaveState getLowPowerState(@ServiceType int serviceType) { 4623 synchronized (mLock) { 4624 return mBatterySaverPolicy.getBatterySaverPolicy(serviceType, mLowPowerModeEnabled); 4625 } 4626 } 4627 4628 @Override 4629 public void registerLowPowerModeObserver(LowPowerModeListener listener) { 4630 synchronized (mLock) { 4631 mLowPowerModeListeners.add(listener); 4632 } 4633 } 4634 4635 @Override 4636 public boolean setDeviceIdleMode(boolean enabled) { 4637 return setDeviceIdleModeInternal(enabled); 4638 } 4639 4640 @Override 4641 public boolean setLightDeviceIdleMode(boolean enabled) { 4642 return setLightDeviceIdleModeInternal(enabled); 4643 } 4644 4645 @Override 4646 public void setDeviceIdleWhitelist(int[] appids) { 4647 setDeviceIdleWhitelistInternal(appids); 4648 } 4649 4650 @Override 4651 public void setDeviceIdleTempWhitelist(int[] appids) { 4652 setDeviceIdleTempWhitelistInternal(appids); 4653 } 4654 4655 @Override 4656 public void startUidChanges() { 4657 startUidChangesInternal(); 4658 } 4659 4660 @Override 4661 public void finishUidChanges() { 4662 finishUidChangesInternal(); 4663 } 4664 4665 @Override 4666 public void updateUidProcState(int uid, int procState) { 4667 updateUidProcStateInternal(uid, procState); 4668 } 4669 4670 @Override 4671 public void uidGone(int uid) { 4672 uidGoneInternal(uid); 4673 } 4674 4675 @Override 4676 public void uidActive(int uid) { 4677 uidActiveInternal(uid); 4678 } 4679 4680 @Override 4681 public void uidIdle(int uid) { 4682 uidIdleInternal(uid); 4683 } 4684 4685 @Override 4686 public void powerHint(int hintId, int data) { 4687 powerHintInternal(hintId, data); 4688 } 4689 } 4690} 4691