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