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