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