PowerManagerService.java revision 3d69256fdf3f2006d312824386a4b68b4c6f79bd
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 com.android.internal.app.IAppOpsService; 20import com.android.internal.app.IBatteryStats; 21import com.android.internal.os.BackgroundThread; 22import com.android.server.EventLogTags; 23import com.android.server.LocalServices; 24import com.android.server.ServiceThread; 25import com.android.server.am.BatteryStatsService; 26import com.android.server.lights.Light; 27import com.android.server.lights.LightsManager; 28import com.android.server.Watchdog; 29 30import android.Manifest; 31import android.content.BroadcastReceiver; 32import android.content.ContentResolver; 33import android.content.Context; 34import android.content.Intent; 35import android.content.IntentFilter; 36import android.content.pm.PackageManager; 37import android.content.res.Resources; 38import android.database.ContentObserver; 39import android.hardware.SensorManager; 40import android.hardware.SystemSensorManager; 41import android.hardware.display.DisplayManagerInternal; 42import android.hardware.display.DisplayManagerInternal.DisplayPowerRequest; 43import android.net.Uri; 44import android.os.BatteryManager; 45import android.os.BatteryManagerInternal; 46import android.os.Binder; 47import android.os.Handler; 48import android.os.IBinder; 49import android.os.IPowerManager; 50import android.os.Looper; 51import android.os.Message; 52import android.os.PowerManager; 53import android.os.PowerManagerInternal; 54import android.os.Process; 55import android.os.RemoteException; 56import android.os.SystemClock; 57import android.os.SystemProperties; 58import android.os.SystemService; 59import android.os.UserHandle; 60import android.os.WorkSource; 61import android.provider.Settings; 62import android.service.dreams.DreamManagerInternal; 63import android.util.EventLog; 64import android.util.Log; 65import android.util.Slog; 66import android.util.TimeUtils; 67import android.view.Display; 68import android.view.WindowManagerPolicy; 69 70import java.io.FileDescriptor; 71import java.io.PrintWriter; 72import java.util.ArrayList; 73 74import libcore.util.Objects; 75 76/** 77 * The power manager service is responsible for coordinating power management 78 * functions on the device. 79 */ 80public final class PowerManagerService extends com.android.server.SystemService 81 implements Watchdog.Monitor { 82 private static final String TAG = "PowerManagerService"; 83 84 private static final boolean DEBUG = false; 85 private static final boolean DEBUG_SPEW = DEBUG && true; 86 87 // Message: Sent when a user activity timeout occurs to update the power state. 88 private static final int MSG_USER_ACTIVITY_TIMEOUT = 1; 89 // Message: Sent when the device enters or exits a dreaming or dozing state. 90 private static final int MSG_SANDMAN = 2; 91 // Message: Sent when the screen on blocker is released. 92 private static final int MSG_SCREEN_ON_BLOCKER_RELEASED = 3; 93 // Message: Sent to poll whether the boot animation has terminated. 94 private static final int MSG_CHECK_IF_BOOT_ANIMATION_FINISHED = 4; 95 96 // Dirty bit: mWakeLocks changed 97 private static final int DIRTY_WAKE_LOCKS = 1 << 0; 98 // Dirty bit: mWakefulness changed 99 private static final int DIRTY_WAKEFULNESS = 1 << 1; 100 // Dirty bit: user activity was poked or may have timed out 101 private static final int DIRTY_USER_ACTIVITY = 1 << 2; 102 // Dirty bit: actual display power state was updated asynchronously 103 private static final int DIRTY_ACTUAL_DISPLAY_POWER_STATE_UPDATED = 1 << 3; 104 // Dirty bit: mBootCompleted changed 105 private static final int DIRTY_BOOT_COMPLETED = 1 << 4; 106 // Dirty bit: settings changed 107 private static final int DIRTY_SETTINGS = 1 << 5; 108 // Dirty bit: mIsPowered changed 109 private static final int DIRTY_IS_POWERED = 1 << 6; 110 // Dirty bit: mStayOn changed 111 private static final int DIRTY_STAY_ON = 1 << 7; 112 // Dirty bit: battery state changed 113 private static final int DIRTY_BATTERY_STATE = 1 << 8; 114 // Dirty bit: proximity state changed 115 private static final int DIRTY_PROXIMITY_POSITIVE = 1 << 9; 116 // Dirty bit: screen on blocker state became held or unheld 117 private static final int DIRTY_SCREEN_ON_BLOCKER_RELEASED = 1 << 10; 118 // Dirty bit: dock state changed 119 private static final int DIRTY_DOCK_STATE = 1 << 11; 120 121 // Wakefulness: The device is asleep and can only be awoken by a call to wakeUp(). 122 // The screen should be off or in the process of being turned off by the display controller. 123 // The device typically passes through the dozing state first. 124 private static final int WAKEFULNESS_ASLEEP = 0; 125 // Wakefulness: The device is fully awake. It can be put to sleep by a call to goToSleep(). 126 // When the user activity timeout expires, the device may start dreaming or go to sleep. 127 private static final int WAKEFULNESS_AWAKE = 1; 128 // Wakefulness: The device is dreaming. It can be awoken by a call to wakeUp(), 129 // which ends the dream. The device goes to sleep when goToSleep() is called, when 130 // the dream ends or when unplugged. 131 // User activity may brighten the screen but does not end the dream. 132 private static final int WAKEFULNESS_DREAMING = 2; 133 // Wakefulness: The device is dozing. It is almost asleep but is allowing a special 134 // low-power "doze" dream to run which keeps the display on but lets the application 135 // processor be suspended. It can be awoken by a call to wakeUp() which ends the dream. 136 // The device fully goes to sleep if the dream cannot be started or ends on its own. 137 private static final int WAKEFULNESS_DOZING = 3; 138 139 // Summarizes the state of all active wakelocks. 140 private static final int WAKE_LOCK_CPU = 1 << 0; 141 private static final int WAKE_LOCK_SCREEN_BRIGHT = 1 << 1; 142 private static final int WAKE_LOCK_SCREEN_DIM = 1 << 2; 143 private static final int WAKE_LOCK_BUTTON_BRIGHT = 1 << 3; 144 private static final int WAKE_LOCK_PROXIMITY_SCREEN_OFF = 1 << 4; 145 private static final int WAKE_LOCK_STAY_AWAKE = 1 << 5; // only set if already awake 146 private static final int WAKE_LOCK_DOZE = 1 << 6; 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 152 // Default timeout in milliseconds. This is only used until the settings 153 // provider populates the actual default value (R.integer.def_screen_off_timeout). 154 private static final int DEFAULT_SCREEN_OFF_TIMEOUT = 15 * 1000; 155 156 // The name of the boot animation service in init.rc. 157 private static final String BOOT_ANIMATION_SERVICE = "bootanim"; 158 159 // Poll interval in milliseconds for watching boot animation finished. 160 private static final int BOOT_ANIMATION_POLL_INTERVAL = 200; 161 162 // Used to send the hint to the PowerHAL indicating transitions 163 // from and to the low power mode. 164 private static final int POWER_HINT_LOW_POWER_MODE = 5; 165 166 private final Context mContext; 167 private final ServiceThread mHandlerThread; 168 private final PowerManagerHandler mHandler; 169 170 private LightsManager mLightsManager; 171 private BatteryManagerInternal mBatteryManagerInternal; 172 private DisplayManagerInternal mDisplayManagerInternal; 173 private IBatteryStats mBatteryStats; 174 private IAppOpsService mAppOps; 175 private WindowManagerPolicy mPolicy; 176 private Notifier mNotifier; 177 private WirelessChargerDetector mWirelessChargerDetector; 178 private SettingsObserver mSettingsObserver; 179 private DreamManagerInternal mDreamManager; 180 private Light mAttentionLight; 181 182 private final Object mLock = new Object(); 183 184 // A bitfield that indicates what parts of the power state have 185 // changed and need to be recalculated. 186 private int mDirty; 187 188 // Indicates whether the device is awake or asleep or somewhere in between. 189 // This is distinct from the screen power state, which is managed separately. 190 private int mWakefulness; 191 192 // True if the sandman has just been summoned for the first time since entering the 193 // dreaming or dozing state. Indicates whether a new dream should begin. 194 private boolean mSandmanSummoned; 195 196 // True if MSG_SANDMAN has been scheduled. 197 private boolean mSandmanScheduled; 198 199 // Table of all suspend blockers. 200 // There should only be a few of these. 201 private final ArrayList<SuspendBlocker> mSuspendBlockers = new ArrayList<SuspendBlocker>(); 202 203 // Table of all wake locks acquired by applications. 204 private final ArrayList<WakeLock> mWakeLocks = new ArrayList<WakeLock>(); 205 206 // A bitfield that summarizes the state of all active wakelocks. 207 private int mWakeLockSummary; 208 209 // True if the device is in an interactive state. 210 private boolean mInteractive; 211 private boolean mInteractiveChanging; 212 213 // If true, instructs the display controller to wait for the proximity sensor to 214 // go negative before turning the screen on. 215 private boolean mRequestWaitForNegativeProximity; 216 217 // Timestamp of the last time the device was awoken or put to sleep. 218 private long mLastWakeTime; 219 private long mLastSleepTime; 220 221 // Timestamp of the last call to user activity. 222 private long mLastUserActivityTime; 223 private long mLastUserActivityTimeNoChangeLights; 224 225 // A bitfield that summarizes the effect of the user activity timer. 226 // A zero value indicates that the user activity timer has expired. 227 private int mUserActivitySummary; 228 229 // The desired display power state. The actual state may lag behind the 230 // requested because it is updated asynchronously by the display power controller. 231 private final DisplayPowerRequest mDisplayPowerRequest = new DisplayPowerRequest(); 232 233 // True if the display power state has been fully applied, which means the display 234 // is actually on or actually off or whatever was requested. 235 private boolean mDisplayReady; 236 237 // The suspend blocker used to keep the CPU alive when an application has acquired 238 // a wake lock. 239 private final SuspendBlocker mWakeLockSuspendBlocker; 240 241 // True if the wake lock suspend blocker has been acquired. 242 private boolean mHoldingWakeLockSuspendBlocker; 243 244 // The suspend blocker used to keep the CPU alive when the display is on, the 245 // display is getting ready or there is user activity (in which case the display 246 // must be on). 247 private final SuspendBlocker mDisplaySuspendBlocker; 248 249 // True if the display suspend blocker has been acquired. 250 private boolean mHoldingDisplaySuspendBlocker; 251 252 // The screen on blocker used to keep the screen from turning on while the lock 253 // screen is coming up. 254 private final ScreenOnBlockerImpl mScreenOnBlocker; 255 256 // True if systemReady() has been called. 257 private boolean mSystemReady; 258 259 // True if boot completed occurred. We keep the screen on until this happens. 260 private boolean mBootCompleted; 261 262 // True if auto-suspend mode is enabled. 263 // Refer to autosuspend.h. 264 private boolean mHalAutoSuspendModeEnabled; 265 266 // True if interactive mode is enabled. 267 // Refer to power.h. 268 private boolean mHalInteractiveModeEnabled; 269 270 // True if the device is plugged into a power source. 271 private boolean mIsPowered; 272 273 // The current plug type, such as BatteryManager.BATTERY_PLUGGED_WIRELESS. 274 private int mPlugType; 275 276 // The current battery level percentage. 277 private int mBatteryLevel; 278 279 // The battery level percentage at the time the dream started. 280 // This is used to terminate a dream and go to sleep if the battery is 281 // draining faster than it is charging and the user activity timeout has expired. 282 private int mBatteryLevelWhenDreamStarted; 283 284 // The current dock state. 285 private int mDockState = Intent.EXTRA_DOCK_STATE_UNDOCKED; 286 287 // True to decouple auto-suspend mode from the display state. 288 private boolean mDecoupleHalAutoSuspendModeFromDisplayConfig; 289 290 // True to decouple interactive mode from the display state. 291 private boolean mDecoupleHalInteractiveModeFromDisplayConfig; 292 293 // True if the device should wake up when plugged or unplugged. 294 private boolean mWakeUpWhenPluggedOrUnpluggedConfig; 295 296 // True if the device should suspend when the screen is off due to proximity. 297 private boolean mSuspendWhenScreenOffDueToProximityConfig; 298 299 // True if dreams are supported on this device. 300 private boolean mDreamsSupportedConfig; 301 302 // Default value for dreams enabled 303 private boolean mDreamsEnabledByDefaultConfig; 304 305 // Default value for dreams activate-on-sleep 306 private boolean mDreamsActivatedOnSleepByDefaultConfig; 307 308 // Default value for dreams activate-on-dock 309 private boolean mDreamsActivatedOnDockByDefaultConfig; 310 311 // True if dreams can run while not plugged in. 312 private boolean mDreamsEnabledOnBatteryConfig; 313 314 // Minimum battery level to allow dreaming when powered. 315 // Use -1 to disable this safety feature. 316 private int mDreamsBatteryLevelMinimumWhenPoweredConfig; 317 318 // Minimum battery level to allow dreaming when not powered. 319 // Use -1 to disable this safety feature. 320 private int mDreamsBatteryLevelMinimumWhenNotPoweredConfig; 321 322 // If the battery level drops by this percentage and the user activity timeout 323 // has expired, then assume the device is receiving insufficient current to charge 324 // effectively and terminate the dream. Use -1 to disable this safety feature. 325 private int mDreamsBatteryLevelDrainCutoffConfig; 326 327 // True if dreams are enabled by the user. 328 private boolean mDreamsEnabledSetting; 329 330 // True if dreams should be activated on sleep. 331 private boolean mDreamsActivateOnSleepSetting; 332 333 // True if dreams should be activated on dock. 334 private boolean mDreamsActivateOnDockSetting; 335 336 // The minimum screen off timeout, in milliseconds. 337 private int mMinimumScreenOffTimeoutConfig; 338 339 // The screen dim duration, in milliseconds. 340 // This is subtracted from the end of the screen off timeout so the 341 // minimum screen off timeout should be longer than this. 342 private int mMaximumScreenDimDurationConfig; 343 344 // The maximum screen dim time expressed as a ratio relative to the screen 345 // off timeout. If the screen off timeout is very short then we want the 346 // dim timeout to also be quite short so that most of the time is spent on. 347 // Otherwise the user won't get much screen on time before dimming occurs. 348 private float mMaximumScreenDimRatioConfig; 349 350 // The screen off timeout setting value in milliseconds. 351 private int mScreenOffTimeoutSetting; 352 353 // The maximum allowable screen off timeout according to the device 354 // administration policy. Overrides other settings. 355 private int mMaximumScreenOffTimeoutFromDeviceAdmin = Integer.MAX_VALUE; 356 357 // The stay on while plugged in setting. 358 // A bitfield of battery conditions under which to make the screen stay on. 359 private int mStayOnWhilePluggedInSetting; 360 361 // True if the device should stay on. 362 private boolean mStayOn; 363 364 // True if the proximity sensor reads a positive result. 365 private boolean mProximityPositive; 366 367 // Screen brightness setting limits. 368 private int mScreenBrightnessSettingMinimum; 369 private int mScreenBrightnessSettingMaximum; 370 private int mScreenBrightnessSettingDefault; 371 372 // The screen brightness setting, from 0 to 255. 373 // Use -1 if no value has been set. 374 private int mScreenBrightnessSetting; 375 376 // The screen auto-brightness adjustment setting, from -1 to 1. 377 // Use 0 if there is no adjustment. 378 private float mScreenAutoBrightnessAdjustmentSetting; 379 380 // The screen brightness mode. 381 // One of the Settings.System.SCREEN_BRIGHTNESS_MODE_* constants. 382 private int mScreenBrightnessModeSetting; 383 384 // The screen brightness setting override from the window manager 385 // to allow the current foreground activity to override the brightness. 386 // Use -1 to disable. 387 private int mScreenBrightnessOverrideFromWindowManager = -1; 388 389 // The user activity timeout override from the window manager 390 // to allow the current foreground activity to override the user activity timeout. 391 // Use -1 to disable. 392 private long mUserActivityTimeoutOverrideFromWindowManager = -1; 393 394 // The screen brightness setting override from the settings application 395 // to temporarily adjust the brightness until next updated, 396 // Use -1 to disable. 397 private int mTemporaryScreenBrightnessSettingOverride = -1; 398 399 // The screen brightness adjustment setting override from the settings 400 // application to temporarily adjust the auto-brightness adjustment factor 401 // until next updated, in the range -1..1. 402 // Use NaN to disable. 403 private float mTemporaryScreenAutoBrightnessAdjustmentSettingOverride = Float.NaN; 404 405 // The screen state to use while dozing. 406 private int mDozeScreenStateOverrideFromDreamManager = Display.STATE_UNKNOWN; 407 408 // The screen brightness to use while dozing. 409 private int mDozeScreenBrightnessOverrideFromDreamManager = PowerManager.BRIGHTNESS_DEFAULT; 410 411 // Time when we last logged a warning about calling userActivity() without permission. 412 private long mLastWarningAboutUserActivityPermission = Long.MIN_VALUE; 413 414 // If true, the device is in low power mode. 415 private boolean mLowPowerModeEnabled; 416 417 // Current state of the low power mode setting. 418 private boolean mLowPowerModeSetting; 419 420 // Current state of whether the settings are allowing auto low power mode. 421 private boolean mAutoLowPowerModeEnabled; 422 423 // The user turned off low power mode below the trigger level 424 private boolean mAutoLowPowerModeSnoozing; 425 426 // True if the battery level is currently considered low. 427 private boolean mBatteryLevelLow; 428 429 private final ArrayList<PowerManagerInternal.LowPowerModeListener> mLowPowerModeListeners 430 = new ArrayList<PowerManagerInternal.LowPowerModeListener>(); 431 432 private native void nativeInit(); 433 434 private static native void nativeAcquireSuspendBlocker(String name); 435 private static native void nativeReleaseSuspendBlocker(String name); 436 private static native void nativeSetInteractive(boolean enable); 437 private static native void nativeSetAutoSuspend(boolean enable); 438 private static native void nativeSendPowerHint(int hintId, int data); 439 440 public PowerManagerService(Context context) { 441 super(context); 442 mContext = context; 443 mHandlerThread = new ServiceThread(TAG, 444 Process.THREAD_PRIORITY_DISPLAY, false /*allowIo*/); 445 mHandlerThread.start(); 446 mHandler = new PowerManagerHandler(mHandlerThread.getLooper()); 447 448 synchronized (mLock) { 449 mWakeLockSuspendBlocker = createSuspendBlockerLocked("PowerManagerService.WakeLocks"); 450 mDisplaySuspendBlocker = createSuspendBlockerLocked("PowerManagerService.Display"); 451 mDisplaySuspendBlocker.acquire(); 452 mHoldingDisplaySuspendBlocker = true; 453 mHalAutoSuspendModeEnabled = false; 454 mHalInteractiveModeEnabled = true; 455 456 mScreenOnBlocker = new ScreenOnBlockerImpl(); 457 mWakefulness = WAKEFULNESS_AWAKE; 458 mInteractive = true; 459 460 nativeInit(); 461 nativeSetAutoSuspend(false); 462 nativeSetInteractive(true); 463 } 464 } 465 466 @Override 467 public void onStart() { 468 publishBinderService(Context.POWER_SERVICE, new BinderService()); 469 publishLocalService(PowerManagerInternal.class, new LocalService()); 470 471 Watchdog.getInstance().addMonitor(this); 472 Watchdog.getInstance().addThread(mHandler); 473 } 474 475 @Override 476 public void onBootPhase(int phase) { 477 if (phase == PHASE_BOOT_COMPLETED) { 478 // This is our early signal that the system thinks it has finished booting. 479 // However, the boot animation may still be running for a few more seconds 480 // since it is ultimately in charge of when it terminates. 481 // Defer transitioning into the boot completed state until the animation exits. 482 // We do this so that the screen does not start to dim prematurely before 483 // the user has actually had a chance to interact with the device. 484 startWatchingForBootAnimationFinished(); 485 } 486 } 487 488 public void systemReady(IAppOpsService appOps) { 489 synchronized (mLock) { 490 mSystemReady = true; 491 mAppOps = appOps; 492 mDreamManager = getLocalService(DreamManagerInternal.class); 493 mDisplayManagerInternal = getLocalService(DisplayManagerInternal.class); 494 mPolicy = getLocalService(WindowManagerPolicy.class); 495 mBatteryManagerInternal = getLocalService(BatteryManagerInternal.class); 496 497 PowerManager pm = (PowerManager) mContext.getSystemService(Context.POWER_SERVICE); 498 mScreenBrightnessSettingMinimum = pm.getMinimumScreenBrightnessSetting(); 499 mScreenBrightnessSettingMaximum = pm.getMaximumScreenBrightnessSetting(); 500 mScreenBrightnessSettingDefault = pm.getDefaultScreenBrightnessSetting(); 501 502 SensorManager sensorManager = new SystemSensorManager(mContext, mHandler.getLooper()); 503 504 // The notifier runs on the system server's main looper so as not to interfere 505 // with the animations and other critical functions of the power manager. 506 mBatteryStats = BatteryStatsService.getService(); 507 mNotifier = new Notifier(Looper.getMainLooper(), mContext, mBatteryStats, 508 mAppOps, createSuspendBlockerLocked("PowerManagerService.Broadcasts"), 509 mScreenOnBlocker, mPolicy); 510 511 mWirelessChargerDetector = new WirelessChargerDetector(sensorManager, 512 createSuspendBlockerLocked("PowerManagerService.WirelessChargerDetector"), 513 mHandler); 514 mSettingsObserver = new SettingsObserver(mHandler); 515 516 mLightsManager = getLocalService(LightsManager.class); 517 mAttentionLight = mLightsManager.getLight(LightsManager.LIGHT_ID_ATTENTION); 518 519 // Initialize display power management. 520 mDisplayManagerInternal.initPowerManagement( 521 mDisplayPowerCallbacks, mHandler, sensorManager); 522 523 // Register for broadcasts from other components of the system. 524 IntentFilter filter = new IntentFilter(); 525 filter.addAction(Intent.ACTION_BATTERY_CHANGED); 526 filter.setPriority(IntentFilter.SYSTEM_HIGH_PRIORITY); 527 mContext.registerReceiver(new BatteryReceiver(), filter, null, mHandler); 528 529 filter = new IntentFilter(); 530 filter.addAction(Intent.ACTION_DREAMING_STARTED); 531 filter.addAction(Intent.ACTION_DREAMING_STOPPED); 532 mContext.registerReceiver(new DreamReceiver(), filter, null, mHandler); 533 534 filter = new IntentFilter(); 535 filter.addAction(Intent.ACTION_USER_SWITCHED); 536 mContext.registerReceiver(new UserSwitchedReceiver(), filter, null, mHandler); 537 538 filter = new IntentFilter(); 539 filter.addAction(Intent.ACTION_DOCK_EVENT); 540 mContext.registerReceiver(new DockReceiver(), filter, null, mHandler); 541 542 // Register for settings changes. 543 final ContentResolver resolver = mContext.getContentResolver(); 544 resolver.registerContentObserver(Settings.Secure.getUriFor( 545 Settings.Secure.SCREENSAVER_ENABLED), 546 false, mSettingsObserver, UserHandle.USER_ALL); 547 resolver.registerContentObserver(Settings.Secure.getUriFor( 548 Settings.Secure.SCREENSAVER_ACTIVATE_ON_SLEEP), 549 false, mSettingsObserver, UserHandle.USER_ALL); 550 resolver.registerContentObserver(Settings.Secure.getUriFor( 551 Settings.Secure.SCREENSAVER_ACTIVATE_ON_DOCK), 552 false, mSettingsObserver, UserHandle.USER_ALL); 553 resolver.registerContentObserver(Settings.System.getUriFor( 554 Settings.System.SCREEN_OFF_TIMEOUT), 555 false, mSettingsObserver, UserHandle.USER_ALL); 556 resolver.registerContentObserver(Settings.Global.getUriFor( 557 Settings.Global.STAY_ON_WHILE_PLUGGED_IN), 558 false, mSettingsObserver, UserHandle.USER_ALL); 559 resolver.registerContentObserver(Settings.System.getUriFor( 560 Settings.System.SCREEN_BRIGHTNESS), 561 false, mSettingsObserver, UserHandle.USER_ALL); 562 resolver.registerContentObserver(Settings.System.getUriFor( 563 Settings.System.SCREEN_BRIGHTNESS_MODE), 564 false, mSettingsObserver, UserHandle.USER_ALL); 565 resolver.registerContentObserver(Settings.System.getUriFor( 566 Settings.System.SCREEN_AUTO_BRIGHTNESS_ADJ), 567 false, mSettingsObserver, UserHandle.USER_ALL); 568 resolver.registerContentObserver(Settings.Global.getUriFor( 569 Settings.Global.LOW_POWER_MODE), 570 false, mSettingsObserver, UserHandle.USER_ALL); 571 resolver.registerContentObserver(Settings.Global.getUriFor( 572 Settings.Global.LOW_POWER_MODE_TRIGGER_LEVEL), 573 false, mSettingsObserver, UserHandle.USER_ALL); 574 // Go. 575 readConfigurationLocked(); 576 updateSettingsLocked(); 577 mDirty |= DIRTY_BATTERY_STATE; 578 updatePowerStateLocked(); 579 } 580 } 581 582 private void readConfigurationLocked() { 583 final Resources resources = mContext.getResources(); 584 585 mDecoupleHalAutoSuspendModeFromDisplayConfig = resources.getBoolean( 586 com.android.internal.R.bool.config_powerDecoupleAutoSuspendModeFromDisplay); 587 mDecoupleHalInteractiveModeFromDisplayConfig = resources.getBoolean( 588 com.android.internal.R.bool.config_powerDecoupleInteractiveModeFromDisplay); 589 mWakeUpWhenPluggedOrUnpluggedConfig = resources.getBoolean( 590 com.android.internal.R.bool.config_unplugTurnsOnScreen); 591 mSuspendWhenScreenOffDueToProximityConfig = resources.getBoolean( 592 com.android.internal.R.bool.config_suspendWhenScreenOffDueToProximity); 593 mDreamsSupportedConfig = resources.getBoolean( 594 com.android.internal.R.bool.config_dreamsSupported); 595 mDreamsEnabledByDefaultConfig = resources.getBoolean( 596 com.android.internal.R.bool.config_dreamsEnabledByDefault); 597 mDreamsActivatedOnSleepByDefaultConfig = resources.getBoolean( 598 com.android.internal.R.bool.config_dreamsActivatedOnSleepByDefault); 599 mDreamsActivatedOnDockByDefaultConfig = resources.getBoolean( 600 com.android.internal.R.bool.config_dreamsActivatedOnDockByDefault); 601 mDreamsEnabledOnBatteryConfig = resources.getBoolean( 602 com.android.internal.R.bool.config_dreamsEnabledOnBattery); 603 mDreamsBatteryLevelMinimumWhenPoweredConfig = resources.getInteger( 604 com.android.internal.R.integer.config_dreamsBatteryLevelMinimumWhenPowered); 605 mDreamsBatteryLevelMinimumWhenNotPoweredConfig = resources.getInteger( 606 com.android.internal.R.integer.config_dreamsBatteryLevelMinimumWhenNotPowered); 607 mDreamsBatteryLevelDrainCutoffConfig = resources.getInteger( 608 com.android.internal.R.integer.config_dreamsBatteryLevelDrainCutoff); 609 mMinimumScreenOffTimeoutConfig = resources.getInteger( 610 com.android.internal.R.integer.config_minimumScreenOffTimeout); 611 mMaximumScreenDimDurationConfig = resources.getInteger( 612 com.android.internal.R.integer.config_maximumScreenDimDuration); 613 mMaximumScreenDimRatioConfig = resources.getFraction( 614 com.android.internal.R.fraction.config_maximumScreenDimRatio, 1, 1); 615 } 616 617 private void updateSettingsLocked() { 618 final ContentResolver resolver = mContext.getContentResolver(); 619 620 mDreamsEnabledSetting = (Settings.Secure.getIntForUser(resolver, 621 Settings.Secure.SCREENSAVER_ENABLED, 622 mDreamsEnabledByDefaultConfig ? 1 : 0, 623 UserHandle.USER_CURRENT) != 0); 624 mDreamsActivateOnSleepSetting = (Settings.Secure.getIntForUser(resolver, 625 Settings.Secure.SCREENSAVER_ACTIVATE_ON_SLEEP, 626 mDreamsActivatedOnSleepByDefaultConfig ? 1 : 0, 627 UserHandle.USER_CURRENT) != 0); 628 mDreamsActivateOnDockSetting = (Settings.Secure.getIntForUser(resolver, 629 Settings.Secure.SCREENSAVER_ACTIVATE_ON_DOCK, 630 mDreamsActivatedOnDockByDefaultConfig ? 1 : 0, 631 UserHandle.USER_CURRENT) != 0); 632 mScreenOffTimeoutSetting = Settings.System.getIntForUser(resolver, 633 Settings.System.SCREEN_OFF_TIMEOUT, DEFAULT_SCREEN_OFF_TIMEOUT, 634 UserHandle.USER_CURRENT); 635 mStayOnWhilePluggedInSetting = Settings.Global.getInt(resolver, 636 Settings.Global.STAY_ON_WHILE_PLUGGED_IN, BatteryManager.BATTERY_PLUGGED_AC); 637 638 final int oldScreenBrightnessSetting = mScreenBrightnessSetting; 639 mScreenBrightnessSetting = Settings.System.getIntForUser(resolver, 640 Settings.System.SCREEN_BRIGHTNESS, mScreenBrightnessSettingDefault, 641 UserHandle.USER_CURRENT); 642 if (oldScreenBrightnessSetting != mScreenBrightnessSetting) { 643 mTemporaryScreenBrightnessSettingOverride = -1; 644 } 645 646 final float oldScreenAutoBrightnessAdjustmentSetting = 647 mScreenAutoBrightnessAdjustmentSetting; 648 mScreenAutoBrightnessAdjustmentSetting = Settings.System.getFloatForUser(resolver, 649 Settings.System.SCREEN_AUTO_BRIGHTNESS_ADJ, 0.0f, 650 UserHandle.USER_CURRENT); 651 if (oldScreenAutoBrightnessAdjustmentSetting != mScreenAutoBrightnessAdjustmentSetting) { 652 mTemporaryScreenAutoBrightnessAdjustmentSettingOverride = Float.NaN; 653 } 654 655 mScreenBrightnessModeSetting = Settings.System.getIntForUser(resolver, 656 Settings.System.SCREEN_BRIGHTNESS_MODE, 657 Settings.System.SCREEN_BRIGHTNESS_MODE_MANUAL, UserHandle.USER_CURRENT); 658 659 final boolean lowPowerModeEnabled = Settings.Global.getInt(resolver, 660 Settings.Global.LOW_POWER_MODE, 0) != 0; 661 final boolean autoLowPowerModeEnabled = Settings.Global.getInt(resolver, 662 Settings.Global.LOW_POWER_MODE_TRIGGER_LEVEL, 0) != 0; 663 if (lowPowerModeEnabled != mLowPowerModeSetting 664 || autoLowPowerModeEnabled != mAutoLowPowerModeEnabled) { 665 if (lowPowerModeEnabled != mLowPowerModeSetting) { 666 if (!mAutoLowPowerModeSnoozing && !lowPowerModeEnabled && !mIsPowered 667 && mAutoLowPowerModeEnabled) { 668 if (DEBUG_SPEW) { 669 Slog.d(TAG, "updateSettingsLocked: snoozing low power mode"); 670 } 671 mAutoLowPowerModeSnoozing = true; 672 } else if (mAutoLowPowerModeSnoozing && lowPowerModeEnabled) { 673 if (DEBUG_SPEW) { 674 Slog.d(TAG, "updateSettingsLocked: no longer snoozing low power mode"); 675 } 676 mAutoLowPowerModeSnoozing = true; 677 } 678 } 679 mLowPowerModeSetting = lowPowerModeEnabled; 680 mAutoLowPowerModeEnabled = autoLowPowerModeEnabled; 681 updateLowPowerModeLocked(); 682 } 683 684 mDirty |= DIRTY_SETTINGS; 685 } 686 687 void updateLowPowerModeLocked() { 688 if (mIsPowered && mLowPowerModeSetting) { 689 if (DEBUG_SPEW) { 690 Slog.d(TAG, "updateLowPowerModeLocked: powered, turning setting off"); 691 } 692 // Turn setting off if powered 693 Settings.Global.putInt(mContext.getContentResolver(), 694 Settings.Global.LOW_POWER_MODE, 0); 695 mLowPowerModeSetting = false; 696 } else if (!mIsPowered && mAutoLowPowerModeEnabled && !mAutoLowPowerModeSnoozing 697 && mBatteryLevelLow && !mLowPowerModeSetting) { 698 if (DEBUG_SPEW) { 699 Slog.d(TAG, "updateLowPowerModeLocked: trigger level reached, turning setting on"); 700 } 701 // Turn setting on if trigger level is enabled, and we're now below it 702 Settings.Global.putInt(mContext.getContentResolver(), 703 Settings.Global.LOW_POWER_MODE, 1); 704 mLowPowerModeSetting = true; 705 } 706 final boolean lowPowerModeEnabled = mLowPowerModeSetting; 707 if (mLowPowerModeEnabled != lowPowerModeEnabled) { 708 mLowPowerModeEnabled = lowPowerModeEnabled; 709 powerHintInternal(POWER_HINT_LOW_POWER_MODE, lowPowerModeEnabled ? 1 : 0); 710 mLowPowerModeEnabled = lowPowerModeEnabled; 711 BackgroundThread.getHandler().post(new Runnable() { 712 @Override 713 public void run() { 714 Intent intent = new Intent(PowerManager.ACTION_POWER_SAVE_MODE_CHANGING) 715 .putExtra(PowerManager.EXTRA_POWER_SAVE_MODE, mLowPowerModeEnabled) 716 .addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY); 717 mContext.sendBroadcast(intent); 718 ArrayList<PowerManagerInternal.LowPowerModeListener> listeners; 719 synchronized (mLock) { 720 listeners = new ArrayList<PowerManagerInternal.LowPowerModeListener>( 721 mLowPowerModeListeners); 722 } 723 for (int i=0; i<listeners.size(); i++) { 724 listeners.get(i).onLowPowerModeChanged(lowPowerModeEnabled); 725 } 726 intent = new Intent(PowerManager.ACTION_POWER_SAVE_MODE_CHANGED); 727 intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY); 728 mContext.sendBroadcast(intent); 729 } 730 }); 731 } 732 } 733 734 private void handleSettingsChangedLocked() { 735 updateSettingsLocked(); 736 updatePowerStateLocked(); 737 } 738 739 private void acquireWakeLockInternal(IBinder lock, int flags, String tag, String packageName, 740 WorkSource ws, String historyTag, int uid, int pid) { 741 synchronized (mLock) { 742 if (DEBUG_SPEW) { 743 Slog.d(TAG, "acquireWakeLockInternal: lock=" + Objects.hashCode(lock) 744 + ", flags=0x" + Integer.toHexString(flags) 745 + ", tag=\"" + tag + "\", ws=" + ws + ", uid=" + uid + ", pid=" + pid); 746 } 747 748 WakeLock wakeLock; 749 int index = findWakeLockIndexLocked(lock); 750 boolean notifyAcquire; 751 if (index >= 0) { 752 wakeLock = mWakeLocks.get(index); 753 if (!wakeLock.hasSameProperties(flags, tag, ws, uid, pid)) { 754 // Update existing wake lock. This shouldn't happen but is harmless. 755 notifyWakeLockChangingLocked(wakeLock, flags, tag, packageName, 756 uid, pid, ws, historyTag); 757 wakeLock.updateProperties(flags, tag, packageName, ws, historyTag, uid, pid); 758 } 759 notifyAcquire = false; 760 } else { 761 wakeLock = new WakeLock(lock, flags, tag, packageName, ws, historyTag, uid, pid); 762 try { 763 lock.linkToDeath(wakeLock, 0); 764 } catch (RemoteException ex) { 765 throw new IllegalArgumentException("Wake lock is already dead."); 766 } 767 mWakeLocks.add(wakeLock); 768 notifyAcquire = true; 769 } 770 771 applyWakeLockFlagsOnAcquireLocked(wakeLock, uid); 772 mDirty |= DIRTY_WAKE_LOCKS; 773 updatePowerStateLocked(); 774 if (notifyAcquire) { 775 // This needs to be done last so we are sure we have acquired the 776 // kernel wake lock. Otherwise we have a race where the system may 777 // go to sleep between the time we start the accounting in battery 778 // stats and when we actually get around to telling the kernel to 779 // stay awake. 780 notifyWakeLockAcquiredLocked(wakeLock); 781 } 782 } 783 } 784 785 @SuppressWarnings("deprecation") 786 private static boolean isScreenLock(final WakeLock wakeLock) { 787 switch (wakeLock.mFlags & PowerManager.WAKE_LOCK_LEVEL_MASK) { 788 case PowerManager.FULL_WAKE_LOCK: 789 case PowerManager.SCREEN_BRIGHT_WAKE_LOCK: 790 case PowerManager.SCREEN_DIM_WAKE_LOCK: 791 return true; 792 } 793 return false; 794 } 795 796 private void applyWakeLockFlagsOnAcquireLocked(WakeLock wakeLock, int uid) { 797 if ((wakeLock.mFlags & PowerManager.ACQUIRE_CAUSES_WAKEUP) != 0 798 && isScreenLock(wakeLock)) { 799 wakeUpNoUpdateLocked(SystemClock.uptimeMillis(), uid); 800 } 801 } 802 803 private void releaseWakeLockInternal(IBinder lock, int flags) { 804 synchronized (mLock) { 805 int index = findWakeLockIndexLocked(lock); 806 if (index < 0) { 807 if (DEBUG_SPEW) { 808 Slog.d(TAG, "releaseWakeLockInternal: lock=" + Objects.hashCode(lock) 809 + " [not found], flags=0x" + Integer.toHexString(flags)); 810 } 811 return; 812 } 813 814 WakeLock wakeLock = mWakeLocks.get(index); 815 if (DEBUG_SPEW) { 816 Slog.d(TAG, "releaseWakeLockInternal: lock=" + Objects.hashCode(lock) 817 + " [" + wakeLock.mTag + "], flags=0x" + Integer.toHexString(flags)); 818 } 819 820 mWakeLocks.remove(index); 821 notifyWakeLockReleasedLocked(wakeLock); 822 wakeLock.mLock.unlinkToDeath(wakeLock, 0); 823 824 if ((flags & PowerManager.WAIT_FOR_PROXIMITY_NEGATIVE) != 0) { 825 mRequestWaitForNegativeProximity = true; 826 } 827 828 applyWakeLockFlagsOnReleaseLocked(wakeLock); 829 mDirty |= DIRTY_WAKE_LOCKS; 830 updatePowerStateLocked(); 831 } 832 } 833 834 private void handleWakeLockDeath(WakeLock wakeLock) { 835 synchronized (mLock) { 836 if (DEBUG_SPEW) { 837 Slog.d(TAG, "handleWakeLockDeath: lock=" + Objects.hashCode(wakeLock.mLock) 838 + " [" + wakeLock.mTag + "]"); 839 } 840 841 int index = mWakeLocks.indexOf(wakeLock); 842 if (index < 0) { 843 return; 844 } 845 846 mWakeLocks.remove(index); 847 notifyWakeLockReleasedLocked(wakeLock); 848 849 applyWakeLockFlagsOnReleaseLocked(wakeLock); 850 mDirty |= DIRTY_WAKE_LOCKS; 851 updatePowerStateLocked(); 852 } 853 } 854 855 private void applyWakeLockFlagsOnReleaseLocked(WakeLock wakeLock) { 856 if ((wakeLock.mFlags & PowerManager.ON_AFTER_RELEASE) != 0 857 && isScreenLock(wakeLock)) { 858 userActivityNoUpdateLocked(SystemClock.uptimeMillis(), 859 PowerManager.USER_ACTIVITY_EVENT_OTHER, 860 PowerManager.USER_ACTIVITY_FLAG_NO_CHANGE_LIGHTS, 861 wakeLock.mOwnerUid); 862 } 863 } 864 865 private void updateWakeLockWorkSourceInternal(IBinder lock, WorkSource ws, String historyTag) { 866 synchronized (mLock) { 867 int index = findWakeLockIndexLocked(lock); 868 if (index < 0) { 869 if (DEBUG_SPEW) { 870 Slog.d(TAG, "updateWakeLockWorkSourceInternal: lock=" + Objects.hashCode(lock) 871 + " [not found], ws=" + ws); 872 } 873 throw new IllegalArgumentException("Wake lock not active"); 874 } 875 876 WakeLock wakeLock = mWakeLocks.get(index); 877 if (DEBUG_SPEW) { 878 Slog.d(TAG, "updateWakeLockWorkSourceInternal: lock=" + Objects.hashCode(lock) 879 + " [" + wakeLock.mTag + "], ws=" + ws); 880 } 881 882 if (!wakeLock.hasSameWorkSource(ws)) { 883 notifyWakeLockChangingLocked(wakeLock, wakeLock.mFlags, wakeLock.mTag, 884 wakeLock.mPackageName, wakeLock.mOwnerUid, wakeLock.mOwnerPid, 885 ws, historyTag); 886 wakeLock.mHistoryTag = historyTag; 887 wakeLock.updateWorkSource(ws); 888 } 889 } 890 } 891 892 private int findWakeLockIndexLocked(IBinder lock) { 893 final int count = mWakeLocks.size(); 894 for (int i = 0; i < count; i++) { 895 if (mWakeLocks.get(i).mLock == lock) { 896 return i; 897 } 898 } 899 return -1; 900 } 901 902 private void notifyWakeLockAcquiredLocked(WakeLock wakeLock) { 903 if (mSystemReady) { 904 wakeLock.mNotifiedAcquired = true; 905 mNotifier.onWakeLockAcquired(wakeLock.mFlags, wakeLock.mTag, wakeLock.mPackageName, 906 wakeLock.mOwnerUid, wakeLock.mOwnerPid, wakeLock.mWorkSource, 907 wakeLock.mHistoryTag); 908 } 909 } 910 911 private void notifyWakeLockChangingLocked(WakeLock wakeLock, int flags, String tag, 912 String packageName, int uid, int pid, WorkSource ws, String historyTag) { 913 if (mSystemReady && wakeLock.mNotifiedAcquired) { 914 mNotifier.onWakeLockChanging(wakeLock.mFlags, wakeLock.mTag, wakeLock.mPackageName, 915 wakeLock.mOwnerUid, wakeLock.mOwnerPid, wakeLock.mWorkSource, 916 wakeLock.mHistoryTag, flags, tag, packageName, uid, pid, ws, historyTag); 917 } 918 } 919 920 private void notifyWakeLockReleasedLocked(WakeLock wakeLock) { 921 if (mSystemReady && wakeLock.mNotifiedAcquired) { 922 wakeLock.mNotifiedAcquired = false; 923 mNotifier.onWakeLockReleased(wakeLock.mFlags, wakeLock.mTag, 924 wakeLock.mPackageName, wakeLock.mOwnerUid, wakeLock.mOwnerPid, 925 wakeLock.mWorkSource, wakeLock.mHistoryTag); 926 } 927 } 928 929 @SuppressWarnings("deprecation") 930 private boolean isWakeLockLevelSupportedInternal(int level) { 931 synchronized (mLock) { 932 switch (level) { 933 case PowerManager.PARTIAL_WAKE_LOCK: 934 case PowerManager.SCREEN_DIM_WAKE_LOCK: 935 case PowerManager.SCREEN_BRIGHT_WAKE_LOCK: 936 case PowerManager.FULL_WAKE_LOCK: 937 case PowerManager.DOZE_WAKE_LOCK: 938 return true; 939 940 case PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK: 941 return mSystemReady && mDisplayManagerInternal.isProximitySensorAvailable(); 942 943 default: 944 return false; 945 } 946 } 947 } 948 949 // Called from native code. 950 private void userActivityFromNative(long eventTime, int event, int flags) { 951 userActivityInternal(eventTime, event, flags, Process.SYSTEM_UID); 952 } 953 954 private void userActivityInternal(long eventTime, int event, int flags, int uid) { 955 synchronized (mLock) { 956 if (userActivityNoUpdateLocked(eventTime, event, flags, uid)) { 957 updatePowerStateLocked(); 958 } 959 } 960 } 961 962 private boolean userActivityNoUpdateLocked(long eventTime, int event, int flags, int uid) { 963 if (DEBUG_SPEW) { 964 Slog.d(TAG, "userActivityNoUpdateLocked: eventTime=" + eventTime 965 + ", event=" + event + ", flags=0x" + Integer.toHexString(flags) 966 + ", uid=" + uid); 967 } 968 969 if (eventTime < mLastSleepTime || eventTime < mLastWakeTime 970 || mWakefulness == WAKEFULNESS_ASLEEP || mWakefulness == WAKEFULNESS_DOZING 971 || !mBootCompleted || !mSystemReady) { 972 return false; 973 } 974 975 mNotifier.onUserActivity(event, uid); 976 977 if ((flags & PowerManager.USER_ACTIVITY_FLAG_NO_CHANGE_LIGHTS) != 0) { 978 if (eventTime > mLastUserActivityTimeNoChangeLights 979 && eventTime > mLastUserActivityTime) { 980 mLastUserActivityTimeNoChangeLights = eventTime; 981 mDirty |= DIRTY_USER_ACTIVITY; 982 return true; 983 } 984 } else { 985 if (eventTime > mLastUserActivityTime) { 986 mLastUserActivityTime = eventTime; 987 mDirty |= DIRTY_USER_ACTIVITY; 988 return true; 989 } 990 } 991 return false; 992 } 993 994 private void wakeUpInternal(long eventTime, int uid) { 995 synchronized (mLock) { 996 if (wakeUpNoUpdateLocked(eventTime, uid)) { 997 updatePowerStateLocked(); 998 } 999 } 1000 } 1001 1002 private boolean wakeUpNoUpdateLocked(long eventTime, int uid) { 1003 if (DEBUG_SPEW) { 1004 Slog.d(TAG, "wakeUpNoUpdateLocked: eventTime=" + eventTime + ", uid=" + uid); 1005 } 1006 1007 if (eventTime < mLastSleepTime || mWakefulness == WAKEFULNESS_AWAKE 1008 || !mBootCompleted || !mSystemReady) { 1009 return false; 1010 } 1011 1012 switch (mWakefulness) { 1013 case WAKEFULNESS_ASLEEP: 1014 Slog.i(TAG, "Waking up from sleep (uid " + uid +")..."); 1015 break; 1016 case WAKEFULNESS_DREAMING: 1017 Slog.i(TAG, "Waking up from dream (uid " + uid +")..."); 1018 break; 1019 case WAKEFULNESS_DOZING: 1020 Slog.i(TAG, "Waking up from dozing (uid " + uid +")..."); 1021 break; 1022 } 1023 1024 mLastWakeTime = eventTime; 1025 mDirty |= DIRTY_WAKEFULNESS; 1026 mWakefulness = WAKEFULNESS_AWAKE; 1027 setInteractiveStateLocked(true, 0); 1028 1029 userActivityNoUpdateLocked( 1030 eventTime, PowerManager.USER_ACTIVITY_EVENT_OTHER, 0, uid); 1031 return true; 1032 } 1033 1034 private void goToSleepInternal(long eventTime, int reason, int flags, int uid) { 1035 synchronized (mLock) { 1036 if (goToSleepNoUpdateLocked(eventTime, reason, flags, uid)) { 1037 updatePowerStateLocked(); 1038 } 1039 } 1040 } 1041 1042 // This method is called goToSleep for historical reasons but we actually start 1043 // dozing before really going to sleep. 1044 @SuppressWarnings("deprecation") 1045 private boolean goToSleepNoUpdateLocked(long eventTime, int reason, int flags, int uid) { 1046 if (DEBUG_SPEW) { 1047 Slog.d(TAG, "goToSleepNoUpdateLocked: eventTime=" + eventTime 1048 + ", reason=" + reason + ", flags=" + flags + ", uid=" + uid); 1049 } 1050 1051 if (eventTime < mLastWakeTime 1052 || mWakefulness == WAKEFULNESS_ASLEEP 1053 || mWakefulness == WAKEFULNESS_DOZING 1054 || !mBootCompleted || !mSystemReady) { 1055 return false; 1056 } 1057 1058 switch (reason) { 1059 case PowerManager.GO_TO_SLEEP_REASON_DEVICE_ADMIN: 1060 Slog.i(TAG, "Going to sleep due to device administration policy " 1061 + "(uid " + uid +")..."); 1062 break; 1063 case PowerManager.GO_TO_SLEEP_REASON_TIMEOUT: 1064 Slog.i(TAG, "Going to sleep due to screen timeout (uid " + uid +")..."); 1065 break; 1066 case PowerManager.GO_TO_SLEEP_REASON_LID_SWITCH: 1067 Slog.i(TAG, "Going to sleep due to lid switch (uid " + uid +")..."); 1068 break; 1069 case PowerManager.GO_TO_SLEEP_REASON_POWER_BUTTON: 1070 Slog.i(TAG, "Going to sleep due to power button (uid " + uid +")..."); 1071 break; 1072 case PowerManager.GO_TO_SLEEP_REASON_HDMI: 1073 Slog.i(TAG, "Going to sleep due to HDMI standby (uid " + uid +")..."); 1074 break; 1075 default: 1076 Slog.i(TAG, "Going to sleep by application request (uid " + uid +")..."); 1077 reason = PowerManager.GO_TO_SLEEP_REASON_APPLICATION; 1078 break; 1079 } 1080 1081 mLastSleepTime = eventTime; 1082 mDirty |= DIRTY_WAKEFULNESS; 1083 mWakefulness = WAKEFULNESS_DOZING; 1084 mSandmanSummoned = true; 1085 setInteractiveStateLocked(false, reason); 1086 1087 // Report the number of wake locks that will be cleared by going to sleep. 1088 int numWakeLocksCleared = 0; 1089 final int numWakeLocks = mWakeLocks.size(); 1090 for (int i = 0; i < numWakeLocks; i++) { 1091 final WakeLock wakeLock = mWakeLocks.get(i); 1092 switch (wakeLock.mFlags & PowerManager.WAKE_LOCK_LEVEL_MASK) { 1093 case PowerManager.FULL_WAKE_LOCK: 1094 case PowerManager.SCREEN_BRIGHT_WAKE_LOCK: 1095 case PowerManager.SCREEN_DIM_WAKE_LOCK: 1096 numWakeLocksCleared += 1; 1097 break; 1098 } 1099 } 1100 EventLog.writeEvent(EventLogTags.POWER_SLEEP_REQUESTED, numWakeLocksCleared); 1101 1102 // Skip dozing if requested. 1103 if ((flags & PowerManager.GO_TO_SLEEP_FLAG_NO_DOZE) != 0) { 1104 reallyGoToSleepNoUpdateLocked(eventTime, uid); 1105 } 1106 return true; 1107 } 1108 1109 private void napInternal(long eventTime, int uid) { 1110 synchronized (mLock) { 1111 if (napNoUpdateLocked(eventTime, uid)) { 1112 updatePowerStateLocked(); 1113 } 1114 } 1115 } 1116 1117 private boolean napNoUpdateLocked(long eventTime, int uid) { 1118 if (DEBUG_SPEW) { 1119 Slog.d(TAG, "napNoUpdateLocked: eventTime=" + eventTime + ", uid=" + uid); 1120 } 1121 1122 if (eventTime < mLastWakeTime || mWakefulness != WAKEFULNESS_AWAKE 1123 || !mBootCompleted || !mSystemReady) { 1124 return false; 1125 } 1126 1127 Slog.i(TAG, "Nap time (uid " + uid +")..."); 1128 1129 mDirty |= DIRTY_WAKEFULNESS; 1130 mWakefulness = WAKEFULNESS_DREAMING; 1131 mSandmanSummoned = true; 1132 setInteractiveStateLocked(true, 0); 1133 return true; 1134 } 1135 1136 // Done dozing, drop everything and go to sleep. 1137 private boolean reallyGoToSleepNoUpdateLocked(long eventTime, int uid) { 1138 if (DEBUG_SPEW) { 1139 Slog.d(TAG, "reallyGoToSleepNoUpdateLocked: eventTime=" + eventTime 1140 + ", uid=" + uid); 1141 } 1142 1143 if (eventTime < mLastWakeTime || mWakefulness == WAKEFULNESS_ASLEEP 1144 || !mBootCompleted || !mSystemReady) { 1145 return false; 1146 } 1147 1148 Slog.i(TAG, "Sleeping (uid " + uid +")..."); 1149 1150 mDirty |= DIRTY_WAKEFULNESS; 1151 mWakefulness = WAKEFULNESS_ASLEEP; 1152 setInteractiveStateLocked(false, PowerManager.GO_TO_SLEEP_REASON_TIMEOUT); 1153 return true; 1154 } 1155 1156 private void setInteractiveStateLocked(boolean interactive, int reason) { 1157 if (mInteractive != interactive) { 1158 finishInteractiveStateChangeLocked(); 1159 1160 mInteractive = interactive; 1161 mInteractiveChanging = true; 1162 mNotifier.onInteractiveStateChangeStarted(interactive, reason); 1163 } 1164 } 1165 1166 private void finishInteractiveStateChangeLocked() { 1167 if (mInteractiveChanging) { 1168 mNotifier.onInteractiveStateChangeFinished(mInteractive); 1169 mInteractiveChanging = false; 1170 } 1171 } 1172 1173 /** 1174 * Updates the global power state based on dirty bits recorded in mDirty. 1175 * 1176 * This is the main function that performs power state transitions. 1177 * We centralize them here so that we can recompute the power state completely 1178 * each time something important changes, and ensure that we do it the same 1179 * way each time. The point is to gather all of the transition logic here. 1180 */ 1181 private void updatePowerStateLocked() { 1182 if (!mSystemReady || mDirty == 0) { 1183 return; 1184 } 1185 if (!Thread.holdsLock(mLock)) { 1186 Slog.wtf(TAG, "Power manager lock was not held when calling updatePowerStateLocked"); 1187 } 1188 1189 // Phase 0: Basic state updates. 1190 updateIsPoweredLocked(mDirty); 1191 updateStayOnLocked(mDirty); 1192 1193 // Phase 1: Update wakefulness. 1194 // Loop because the wake lock and user activity computations are influenced 1195 // by changes in wakefulness. 1196 final long now = SystemClock.uptimeMillis(); 1197 int dirtyPhase2 = 0; 1198 for (;;) { 1199 int dirtyPhase1 = mDirty; 1200 dirtyPhase2 |= dirtyPhase1; 1201 mDirty = 0; 1202 1203 updateWakeLockSummaryLocked(dirtyPhase1); 1204 updateUserActivitySummaryLocked(now, dirtyPhase1); 1205 if (!updateWakefulnessLocked(dirtyPhase1)) { 1206 break; 1207 } 1208 } 1209 1210 // Phase 2: Update dreams and display power state. 1211 updateDreamLocked(dirtyPhase2); 1212 updateDisplayPowerStateLocked(dirtyPhase2); 1213 1214 // Phase 3: Send notifications, if needed. 1215 if (mDisplayReady) { 1216 finishInteractiveStateChangeLocked(); 1217 } 1218 1219 // Phase 4: Update suspend blocker. 1220 // Because we might release the last suspend blocker here, we need to make sure 1221 // we finished everything else first! 1222 updateSuspendBlockerLocked(); 1223 } 1224 1225 /** 1226 * Updates the value of mIsPowered. 1227 * Sets DIRTY_IS_POWERED if a change occurred. 1228 */ 1229 private void updateIsPoweredLocked(int dirty) { 1230 if ((dirty & DIRTY_BATTERY_STATE) != 0) { 1231 final boolean wasPowered = mIsPowered; 1232 final int oldPlugType = mPlugType; 1233 final boolean oldLevelLow = mBatteryLevelLow; 1234 mIsPowered = mBatteryManagerInternal.isPowered(BatteryManager.BATTERY_PLUGGED_ANY); 1235 mPlugType = mBatteryManagerInternal.getPlugType(); 1236 mBatteryLevel = mBatteryManagerInternal.getBatteryLevel(); 1237 mBatteryLevelLow = mBatteryManagerInternal.getBatteryLevelLow(); 1238 1239 if (DEBUG_SPEW) { 1240 Slog.d(TAG, "updateIsPoweredLocked: wasPowered=" + wasPowered 1241 + ", mIsPowered=" + mIsPowered 1242 + ", oldPlugType=" + oldPlugType 1243 + ", mPlugType=" + mPlugType 1244 + ", mBatteryLevel=" + mBatteryLevel); 1245 } 1246 1247 if (wasPowered != mIsPowered || oldPlugType != mPlugType) { 1248 mDirty |= DIRTY_IS_POWERED; 1249 1250 // Update wireless dock detection state. 1251 final boolean dockedOnWirelessCharger = mWirelessChargerDetector.update( 1252 mIsPowered, mPlugType, mBatteryLevel); 1253 1254 // Treat plugging and unplugging the devices as a user activity. 1255 // Users find it disconcerting when they plug or unplug the device 1256 // and it shuts off right away. 1257 // Some devices also wake the device when plugged or unplugged because 1258 // they don't have a charging LED. 1259 final long now = SystemClock.uptimeMillis(); 1260 if (shouldWakeUpWhenPluggedOrUnpluggedLocked(wasPowered, oldPlugType, 1261 dockedOnWirelessCharger)) { 1262 wakeUpNoUpdateLocked(now, Process.SYSTEM_UID); 1263 } 1264 userActivityNoUpdateLocked( 1265 now, PowerManager.USER_ACTIVITY_EVENT_OTHER, 0, Process.SYSTEM_UID); 1266 1267 // Tell the notifier whether wireless charging has started so that 1268 // it can provide feedback to the user. 1269 if (dockedOnWirelessCharger) { 1270 mNotifier.onWirelessChargingStarted(); 1271 } 1272 } 1273 1274 if (wasPowered != mIsPowered || oldLevelLow != mBatteryLevelLow) { 1275 if (oldLevelLow != mBatteryLevelLow && !mBatteryLevelLow) { 1276 if (DEBUG_SPEW) { 1277 Slog.d(TAG, "updateIsPoweredLocked: resetting low power snooze"); 1278 } 1279 mAutoLowPowerModeSnoozing = false; 1280 } 1281 updateLowPowerModeLocked(); 1282 } 1283 } 1284 } 1285 1286 private boolean shouldWakeUpWhenPluggedOrUnpluggedLocked( 1287 boolean wasPowered, int oldPlugType, boolean dockedOnWirelessCharger) { 1288 // Don't wake when powered unless configured to do so. 1289 if (!mWakeUpWhenPluggedOrUnpluggedConfig) { 1290 return false; 1291 } 1292 1293 // Don't wake when undocked from wireless charger. 1294 // See WirelessChargerDetector for justification. 1295 if (wasPowered && !mIsPowered 1296 && oldPlugType == BatteryManager.BATTERY_PLUGGED_WIRELESS) { 1297 return false; 1298 } 1299 1300 // Don't wake when docked on wireless charger unless we are certain of it. 1301 // See WirelessChargerDetector for justification. 1302 if (!wasPowered && mIsPowered 1303 && mPlugType == BatteryManager.BATTERY_PLUGGED_WIRELESS 1304 && !dockedOnWirelessCharger) { 1305 return false; 1306 } 1307 1308 // If already dreaming and becoming powered, then don't wake. 1309 if (mIsPowered && mWakefulness == WAKEFULNESS_DREAMING) { 1310 return false; 1311 } 1312 1313 // Otherwise wake up! 1314 return true; 1315 } 1316 1317 /** 1318 * Updates the value of mStayOn. 1319 * Sets DIRTY_STAY_ON if a change occurred. 1320 */ 1321 private void updateStayOnLocked(int dirty) { 1322 if ((dirty & (DIRTY_BATTERY_STATE | DIRTY_SETTINGS)) != 0) { 1323 final boolean wasStayOn = mStayOn; 1324 if (mStayOnWhilePluggedInSetting != 0 1325 && !isMaximumScreenOffTimeoutFromDeviceAdminEnforcedLocked()) { 1326 mStayOn = mBatteryManagerInternal.isPowered(mStayOnWhilePluggedInSetting); 1327 } else { 1328 mStayOn = false; 1329 } 1330 1331 if (mStayOn != wasStayOn) { 1332 mDirty |= DIRTY_STAY_ON; 1333 } 1334 } 1335 } 1336 1337 /** 1338 * Updates the value of mWakeLockSummary to summarize the state of all active wake locks. 1339 * Note that most wake-locks are ignored when the system is asleep. 1340 * 1341 * This function must have no other side-effects. 1342 */ 1343 @SuppressWarnings("deprecation") 1344 private void updateWakeLockSummaryLocked(int dirty) { 1345 if ((dirty & (DIRTY_WAKE_LOCKS | DIRTY_WAKEFULNESS)) != 0) { 1346 mWakeLockSummary = 0; 1347 1348 final int numWakeLocks = mWakeLocks.size(); 1349 for (int i = 0; i < numWakeLocks; i++) { 1350 final WakeLock wakeLock = mWakeLocks.get(i); 1351 switch (wakeLock.mFlags & PowerManager.WAKE_LOCK_LEVEL_MASK) { 1352 case PowerManager.PARTIAL_WAKE_LOCK: 1353 mWakeLockSummary |= WAKE_LOCK_CPU; 1354 break; 1355 case PowerManager.FULL_WAKE_LOCK: 1356 mWakeLockSummary |= WAKE_LOCK_SCREEN_BRIGHT | WAKE_LOCK_BUTTON_BRIGHT; 1357 break; 1358 case PowerManager.SCREEN_BRIGHT_WAKE_LOCK: 1359 mWakeLockSummary |= WAKE_LOCK_SCREEN_BRIGHT; 1360 break; 1361 case PowerManager.SCREEN_DIM_WAKE_LOCK: 1362 mWakeLockSummary |= WAKE_LOCK_SCREEN_DIM; 1363 break; 1364 case PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK: 1365 mWakeLockSummary |= WAKE_LOCK_PROXIMITY_SCREEN_OFF; 1366 break; 1367 case PowerManager.DOZE_WAKE_LOCK: 1368 mWakeLockSummary |= WAKE_LOCK_DOZE; 1369 break; 1370 } 1371 } 1372 1373 // Cancel wake locks that make no sense based on the current state. 1374 if (mWakefulness != WAKEFULNESS_DOZING) { 1375 mWakeLockSummary &= ~WAKE_LOCK_DOZE; 1376 } 1377 if (mWakefulness == WAKEFULNESS_ASLEEP 1378 || (mWakeLockSummary & WAKE_LOCK_DOZE) != 0) { 1379 mWakeLockSummary &= ~(WAKE_LOCK_SCREEN_BRIGHT | WAKE_LOCK_SCREEN_DIM 1380 | WAKE_LOCK_BUTTON_BRIGHT); 1381 if (mWakefulness == WAKEFULNESS_ASLEEP) { 1382 mWakeLockSummary &= ~WAKE_LOCK_PROXIMITY_SCREEN_OFF; 1383 } 1384 } 1385 1386 // Infer implied wake locks where necessary based on the current state. 1387 if ((mWakeLockSummary & (WAKE_LOCK_SCREEN_BRIGHT | WAKE_LOCK_SCREEN_DIM)) != 0) { 1388 if (mWakefulness == WAKEFULNESS_AWAKE) { 1389 mWakeLockSummary |= WAKE_LOCK_CPU | WAKE_LOCK_STAY_AWAKE; 1390 } else if (mWakefulness == WAKEFULNESS_DREAMING) { 1391 mWakeLockSummary |= WAKE_LOCK_CPU; 1392 } 1393 } 1394 1395 if (DEBUG_SPEW) { 1396 Slog.d(TAG, "updateWakeLockSummaryLocked: mWakefulness=" 1397 + wakefulnessToString(mWakefulness) 1398 + ", mWakeLockSummary=0x" + Integer.toHexString(mWakeLockSummary)); 1399 } 1400 } 1401 } 1402 1403 /** 1404 * Updates the value of mUserActivitySummary to summarize the user requested 1405 * state of the system such as whether the screen should be bright or dim. 1406 * Note that user activity is ignored when the system is asleep. 1407 * 1408 * This function must have no other side-effects. 1409 */ 1410 private void updateUserActivitySummaryLocked(long now, int dirty) { 1411 // Update the status of the user activity timeout timer. 1412 if ((dirty & (DIRTY_WAKE_LOCKS | DIRTY_USER_ACTIVITY 1413 | DIRTY_WAKEFULNESS | DIRTY_SETTINGS)) != 0) { 1414 mHandler.removeMessages(MSG_USER_ACTIVITY_TIMEOUT); 1415 1416 long nextTimeout = 0; 1417 if (mWakefulness == WAKEFULNESS_AWAKE 1418 || mWakefulness == WAKEFULNESS_DREAMING 1419 || mWakefulness == WAKEFULNESS_DOZING) { 1420 final int screenOffTimeout = getScreenOffTimeoutLocked(); 1421 final int screenDimDuration = getScreenDimDurationLocked(screenOffTimeout); 1422 1423 mUserActivitySummary = 0; 1424 if (mLastUserActivityTime >= mLastWakeTime) { 1425 nextTimeout = mLastUserActivityTime 1426 + screenOffTimeout - screenDimDuration; 1427 if (now < nextTimeout) { 1428 mUserActivitySummary |= USER_ACTIVITY_SCREEN_BRIGHT; 1429 } else { 1430 nextTimeout = mLastUserActivityTime + screenOffTimeout; 1431 if (now < nextTimeout) { 1432 mUserActivitySummary |= USER_ACTIVITY_SCREEN_DIM; 1433 } 1434 } 1435 } 1436 if (mUserActivitySummary == 0 1437 && mLastUserActivityTimeNoChangeLights >= mLastWakeTime) { 1438 nextTimeout = mLastUserActivityTimeNoChangeLights + screenOffTimeout; 1439 if (now < nextTimeout) { 1440 if (mDisplayPowerRequest.policy == DisplayPowerRequest.POLICY_BRIGHT) { 1441 mUserActivitySummary = USER_ACTIVITY_SCREEN_BRIGHT; 1442 } else if (mDisplayPowerRequest.policy == DisplayPowerRequest.POLICY_DIM) { 1443 mUserActivitySummary = USER_ACTIVITY_SCREEN_DIM; 1444 } 1445 } 1446 } 1447 if (mUserActivitySummary != 0) { 1448 Message msg = mHandler.obtainMessage(MSG_USER_ACTIVITY_TIMEOUT); 1449 msg.setAsynchronous(true); 1450 mHandler.sendMessageAtTime(msg, nextTimeout); 1451 } 1452 } else { 1453 mUserActivitySummary = 0; 1454 } 1455 1456 if (DEBUG_SPEW) { 1457 Slog.d(TAG, "updateUserActivitySummaryLocked: mWakefulness=" 1458 + wakefulnessToString(mWakefulness) 1459 + ", mUserActivitySummary=0x" + Integer.toHexString(mUserActivitySummary) 1460 + ", nextTimeout=" + TimeUtils.formatUptime(nextTimeout)); 1461 } 1462 } 1463 } 1464 1465 /** 1466 * Called when a user activity timeout has occurred. 1467 * Simply indicates that something about user activity has changed so that the new 1468 * state can be recomputed when the power state is updated. 1469 * 1470 * This function must have no other side-effects besides setting the dirty 1471 * bit and calling update power state. Wakefulness transitions are handled elsewhere. 1472 */ 1473 private void handleUserActivityTimeout() { // runs on handler thread 1474 synchronized (mLock) { 1475 if (DEBUG_SPEW) { 1476 Slog.d(TAG, "handleUserActivityTimeout"); 1477 } 1478 1479 mDirty |= DIRTY_USER_ACTIVITY; 1480 updatePowerStateLocked(); 1481 } 1482 } 1483 1484 private int getScreenOffTimeoutLocked() { 1485 int timeout = mScreenOffTimeoutSetting; 1486 if (isMaximumScreenOffTimeoutFromDeviceAdminEnforcedLocked()) { 1487 timeout = Math.min(timeout, mMaximumScreenOffTimeoutFromDeviceAdmin); 1488 } 1489 if (mUserActivityTimeoutOverrideFromWindowManager >= 0) { 1490 timeout = (int)Math.min(timeout, mUserActivityTimeoutOverrideFromWindowManager); 1491 } 1492 return Math.max(timeout, mMinimumScreenOffTimeoutConfig); 1493 } 1494 1495 private int getScreenDimDurationLocked(int screenOffTimeout) { 1496 return Math.min(mMaximumScreenDimDurationConfig, 1497 (int)(screenOffTimeout * mMaximumScreenDimRatioConfig)); 1498 } 1499 1500 /** 1501 * Updates the wakefulness of the device. 1502 * 1503 * This is the function that decides whether the device should start dreaming 1504 * based on the current wake locks and user activity state. It may modify mDirty 1505 * if the wakefulness changes. 1506 * 1507 * Returns true if the wakefulness changed and we need to restart power state calculation. 1508 */ 1509 private boolean updateWakefulnessLocked(int dirty) { 1510 boolean changed = false; 1511 if ((dirty & (DIRTY_WAKE_LOCKS | DIRTY_USER_ACTIVITY | DIRTY_BOOT_COMPLETED 1512 | DIRTY_WAKEFULNESS | DIRTY_STAY_ON | DIRTY_PROXIMITY_POSITIVE 1513 | DIRTY_DOCK_STATE)) != 0) { 1514 if (mWakefulness == WAKEFULNESS_AWAKE && isItBedTimeYetLocked()) { 1515 if (DEBUG_SPEW) { 1516 Slog.d(TAG, "updateWakefulnessLocked: Bed time..."); 1517 } 1518 final long time = SystemClock.uptimeMillis(); 1519 if (shouldNapAtBedTimeLocked()) { 1520 changed = napNoUpdateLocked(time, Process.SYSTEM_UID); 1521 } else { 1522 changed = goToSleepNoUpdateLocked(time, 1523 PowerManager.GO_TO_SLEEP_REASON_TIMEOUT, 0, Process.SYSTEM_UID); 1524 } 1525 } 1526 } 1527 return changed; 1528 } 1529 1530 /** 1531 * Returns true if the device should automatically nap and start dreaming when the user 1532 * activity timeout has expired and it's bedtime. 1533 */ 1534 private boolean shouldNapAtBedTimeLocked() { 1535 return mDreamsActivateOnSleepSetting 1536 || (mDreamsActivateOnDockSetting 1537 && mDockState != Intent.EXTRA_DOCK_STATE_UNDOCKED); 1538 } 1539 1540 /** 1541 * Returns true if the device should go to sleep now. 1542 * Also used when exiting a dream to determine whether we should go back 1543 * to being fully awake or else go to sleep for good. 1544 */ 1545 private boolean isItBedTimeYetLocked() { 1546 return mBootCompleted && !isBeingKeptAwakeLocked(); 1547 } 1548 1549 /** 1550 * Returns true if the device is being kept awake by a wake lock, user activity 1551 * or the stay on while powered setting. We also keep the phone awake when 1552 * the proximity sensor returns a positive result so that the device does not 1553 * lock while in a phone call. This function only controls whether the device 1554 * will go to sleep or dream which is independent of whether it will be allowed 1555 * to suspend. 1556 */ 1557 private boolean isBeingKeptAwakeLocked() { 1558 return mStayOn 1559 || mProximityPositive 1560 || (mWakeLockSummary & WAKE_LOCK_STAY_AWAKE) != 0 1561 || (mUserActivitySummary & (USER_ACTIVITY_SCREEN_BRIGHT 1562 | USER_ACTIVITY_SCREEN_DIM)) != 0; 1563 } 1564 1565 /** 1566 * Determines whether to post a message to the sandman to update the dream state. 1567 */ 1568 private void updateDreamLocked(int dirty) { 1569 if ((dirty & (DIRTY_WAKEFULNESS 1570 | DIRTY_USER_ACTIVITY 1571 | DIRTY_WAKE_LOCKS 1572 | DIRTY_BOOT_COMPLETED 1573 | DIRTY_SETTINGS 1574 | DIRTY_IS_POWERED 1575 | DIRTY_STAY_ON 1576 | DIRTY_PROXIMITY_POSITIVE 1577 | DIRTY_BATTERY_STATE)) != 0) { 1578 scheduleSandmanLocked(); 1579 } 1580 } 1581 1582 private void scheduleSandmanLocked() { 1583 if (!mSandmanScheduled) { 1584 mSandmanScheduled = true; 1585 Message msg = mHandler.obtainMessage(MSG_SANDMAN); 1586 msg.setAsynchronous(true); 1587 mHandler.sendMessage(msg); 1588 } 1589 } 1590 1591 /** 1592 * Called when the device enters or exits a dreaming or dozing state. 1593 * 1594 * We do this asynchronously because we must call out of the power manager to start 1595 * the dream and we don't want to hold our lock while doing so. There is a risk that 1596 * the device will wake or go to sleep in the meantime so we have to handle that case. 1597 */ 1598 private void handleSandman() { // runs on handler thread 1599 // Handle preconditions. 1600 final boolean startDreaming; 1601 final int wakefulness; 1602 synchronized (mLock) { 1603 mSandmanScheduled = false; 1604 wakefulness = mWakefulness; 1605 if (mSandmanSummoned) { 1606 startDreaming = ((wakefulness == WAKEFULNESS_DREAMING && canDreamLocked()) 1607 || wakefulness == WAKEFULNESS_DOZING); 1608 mSandmanSummoned = false; 1609 } else { 1610 startDreaming = false; 1611 } 1612 } 1613 1614 // Start dreaming if needed. 1615 // We only control the dream on the handler thread, so we don't need to worry about 1616 // concurrent attempts to start or stop the dream. 1617 final boolean isDreaming; 1618 if (mDreamManager != null) { 1619 // Restart the dream whenever the sandman is summoned. 1620 if (startDreaming) { 1621 mDreamManager.stopDream(false /*immediate*/); 1622 mDreamManager.startDream(wakefulness == WAKEFULNESS_DOZING); 1623 } 1624 isDreaming = mDreamManager.isDreaming(); 1625 } else { 1626 isDreaming = false; 1627 } 1628 1629 // Update dream state. 1630 synchronized (mLock) { 1631 // Remember the initial battery level when the dream started. 1632 if (startDreaming && isDreaming) { 1633 mBatteryLevelWhenDreamStarted = mBatteryLevel; 1634 if (wakefulness == WAKEFULNESS_DOZING) { 1635 Slog.i(TAG, "Dozing..."); 1636 } else { 1637 Slog.i(TAG, "Dreaming..."); 1638 } 1639 } 1640 1641 // If preconditions changed, wait for the next iteration to determine 1642 // whether the dream should continue (or be restarted). 1643 if (mSandmanSummoned || mWakefulness != wakefulness) { 1644 return; // wait for next cycle 1645 } 1646 1647 // Determine whether the dream should continue. 1648 if (wakefulness == WAKEFULNESS_DREAMING) { 1649 if (isDreaming && canDreamLocked()) { 1650 if (mDreamsBatteryLevelDrainCutoffConfig >= 0 1651 && mBatteryLevel < mBatteryLevelWhenDreamStarted 1652 - mDreamsBatteryLevelDrainCutoffConfig 1653 && !isBeingKeptAwakeLocked()) { 1654 // If the user activity timeout expired and the battery appears 1655 // to be draining faster than it is charging then stop dreaming 1656 // and go to sleep. 1657 Slog.i(TAG, "Stopping dream because the battery appears to " 1658 + "be draining faster than it is charging. " 1659 + "Battery level when dream started: " 1660 + mBatteryLevelWhenDreamStarted + "%. " 1661 + "Battery level now: " + mBatteryLevel + "%."); 1662 } else { 1663 return; // continue dreaming 1664 } 1665 } 1666 1667 // Dream has ended or will be stopped. Update the power state. 1668 if (isItBedTimeYetLocked()) { 1669 goToSleepNoUpdateLocked(SystemClock.uptimeMillis(), 1670 PowerManager.GO_TO_SLEEP_REASON_TIMEOUT, 0, Process.SYSTEM_UID); 1671 updatePowerStateLocked(); 1672 } else { 1673 wakeUpNoUpdateLocked(SystemClock.uptimeMillis(), Process.SYSTEM_UID); 1674 updatePowerStateLocked(); 1675 } 1676 } else if (wakefulness == WAKEFULNESS_DOZING) { 1677 if (isDreaming) { 1678 return; // continue dozing 1679 } 1680 1681 // Doze has ended or will be stopped. Update the power state. 1682 reallyGoToSleepNoUpdateLocked(SystemClock.uptimeMillis(), Process.SYSTEM_UID); 1683 updatePowerStateLocked(); 1684 } 1685 } 1686 1687 // Stop dream. 1688 if (isDreaming) { 1689 mDreamManager.stopDream(false /*immediate*/); 1690 } 1691 } 1692 1693 /** 1694 * Returns true if the device is allowed to dream in its current state. 1695 * This function is not called when dozing. 1696 */ 1697 private boolean canDreamLocked() { 1698 if (mWakefulness != WAKEFULNESS_DREAMING 1699 || !mDreamsSupportedConfig 1700 || !mDreamsEnabledSetting 1701 || !mDisplayPowerRequest.isBrightOrDim() 1702 || !mBootCompleted) { 1703 return false; 1704 } 1705 if (!isBeingKeptAwakeLocked()) { 1706 if (!mIsPowered && !mDreamsEnabledOnBatteryConfig) { 1707 return false; 1708 } 1709 if (!mIsPowered 1710 && mDreamsBatteryLevelMinimumWhenNotPoweredConfig >= 0 1711 && mBatteryLevel < mDreamsBatteryLevelMinimumWhenNotPoweredConfig) { 1712 return false; 1713 } 1714 if (mIsPowered 1715 && mDreamsBatteryLevelMinimumWhenPoweredConfig >= 0 1716 && mBatteryLevel < mDreamsBatteryLevelMinimumWhenPoweredConfig) { 1717 return false; 1718 } 1719 } 1720 return true; 1721 } 1722 1723 private void handleScreenOnBlockerReleased() { 1724 synchronized (mLock) { 1725 mDirty |= DIRTY_SCREEN_ON_BLOCKER_RELEASED; 1726 updatePowerStateLocked(); 1727 } 1728 } 1729 1730 /** 1731 * Updates the display power state asynchronously. 1732 * When the update is finished, mDisplayReady will be set to true. The display 1733 * controller posts a message to tell us when the actual display power state 1734 * has been updated so we come back here to double-check and finish up. 1735 * 1736 * This function recalculates the display power state each time. 1737 */ 1738 private void updateDisplayPowerStateLocked(int dirty) { 1739 if ((dirty & (DIRTY_WAKE_LOCKS | DIRTY_USER_ACTIVITY | DIRTY_WAKEFULNESS 1740 | DIRTY_ACTUAL_DISPLAY_POWER_STATE_UPDATED | DIRTY_BOOT_COMPLETED 1741 | DIRTY_SETTINGS | DIRTY_SCREEN_ON_BLOCKER_RELEASED)) != 0) { 1742 mDisplayPowerRequest.policy = getDesiredScreenPolicyLocked(); 1743 1744 int screenBrightness = mScreenBrightnessSettingDefault; 1745 float screenAutoBrightnessAdjustment = 0.0f; 1746 boolean autoBrightness = (mScreenBrightnessModeSetting == 1747 Settings.System.SCREEN_BRIGHTNESS_MODE_AUTOMATIC); 1748 if (isValidBrightness(mScreenBrightnessOverrideFromWindowManager)) { 1749 screenBrightness = mScreenBrightnessOverrideFromWindowManager; 1750 autoBrightness = false; 1751 } else if (isValidBrightness(mTemporaryScreenBrightnessSettingOverride)) { 1752 screenBrightness = mTemporaryScreenBrightnessSettingOverride; 1753 } else if (isValidBrightness(mScreenBrightnessSetting)) { 1754 screenBrightness = mScreenBrightnessSetting; 1755 } 1756 if (autoBrightness) { 1757 screenBrightness = mScreenBrightnessSettingDefault; 1758 if (isValidAutoBrightnessAdjustment( 1759 mTemporaryScreenAutoBrightnessAdjustmentSettingOverride)) { 1760 screenAutoBrightnessAdjustment = 1761 mTemporaryScreenAutoBrightnessAdjustmentSettingOverride; 1762 } else if (isValidAutoBrightnessAdjustment( 1763 mScreenAutoBrightnessAdjustmentSetting)) { 1764 screenAutoBrightnessAdjustment = mScreenAutoBrightnessAdjustmentSetting; 1765 } 1766 } 1767 screenBrightness = Math.max(Math.min(screenBrightness, 1768 mScreenBrightnessSettingMaximum), mScreenBrightnessSettingMinimum); 1769 screenAutoBrightnessAdjustment = Math.max(Math.min( 1770 screenAutoBrightnessAdjustment, 1.0f), -1.0f); 1771 mDisplayPowerRequest.screenBrightness = screenBrightness; 1772 mDisplayPowerRequest.screenAutoBrightnessAdjustment = 1773 screenAutoBrightnessAdjustment; 1774 mDisplayPowerRequest.useAutoBrightness = autoBrightness; 1775 1776 mDisplayPowerRequest.useProximitySensor = shouldUseProximitySensorLocked(); 1777 1778 mDisplayPowerRequest.blockScreenOn = mScreenOnBlocker.isHeld(); 1779 1780 mDisplayPowerRequest.lowPowerMode = mLowPowerModeEnabled; 1781 1782 if (mDisplayPowerRequest.policy == DisplayPowerRequest.POLICY_DOZE) { 1783 mDisplayPowerRequest.dozeScreenState = mDozeScreenStateOverrideFromDreamManager; 1784 mDisplayPowerRequest.dozeScreenBrightness = 1785 mDozeScreenBrightnessOverrideFromDreamManager; 1786 } else { 1787 mDisplayPowerRequest.dozeScreenState = Display.STATE_UNKNOWN; 1788 mDisplayPowerRequest.dozeScreenBrightness = PowerManager.BRIGHTNESS_DEFAULT; 1789 } 1790 1791 mDisplayReady = mDisplayManagerInternal.requestPowerState(mDisplayPowerRequest, 1792 mRequestWaitForNegativeProximity); 1793 mRequestWaitForNegativeProximity = false; 1794 1795 if (DEBUG_SPEW) { 1796 Slog.d(TAG, "updateScreenStateLocked: mDisplayReady=" + mDisplayReady 1797 + ", policy=" + mDisplayPowerRequest.policy 1798 + ", mWakefulness=" + mWakefulness 1799 + ", mWakeLockSummary=0x" + Integer.toHexString(mWakeLockSummary) 1800 + ", mUserActivitySummary=0x" + Integer.toHexString(mUserActivitySummary) 1801 + ", mBootCompleted=" + mBootCompleted); 1802 } 1803 } 1804 } 1805 1806 private static boolean isValidBrightness(int value) { 1807 return value >= 0 && value <= 255; 1808 } 1809 1810 private static boolean isValidAutoBrightnessAdjustment(float value) { 1811 // Handles NaN by always returning false. 1812 return value >= -1.0f && value <= 1.0f; 1813 } 1814 1815 private int getDesiredScreenPolicyLocked() { 1816 if (mWakefulness == WAKEFULNESS_ASLEEP) { 1817 return DisplayPowerRequest.POLICY_OFF; 1818 } 1819 1820 if ((mWakeLockSummary & WAKE_LOCK_DOZE) != 0) { 1821 return DisplayPowerRequest.POLICY_DOZE; 1822 } 1823 1824 if ((mWakeLockSummary & WAKE_LOCK_SCREEN_BRIGHT) != 0 1825 || (mUserActivitySummary & USER_ACTIVITY_SCREEN_BRIGHT) != 0 1826 || !mBootCompleted) { 1827 return DisplayPowerRequest.POLICY_BRIGHT; 1828 } 1829 1830 return DisplayPowerRequest.POLICY_DIM; 1831 } 1832 1833 private final DisplayManagerInternal.DisplayPowerCallbacks mDisplayPowerCallbacks = 1834 new DisplayManagerInternal.DisplayPowerCallbacks() { 1835 private int mDisplayState = Display.STATE_UNKNOWN; 1836 1837 @Override 1838 public void onStateChanged() { 1839 synchronized (mLock) { 1840 mDirty |= DIRTY_ACTUAL_DISPLAY_POWER_STATE_UPDATED; 1841 updatePowerStateLocked(); 1842 } 1843 } 1844 1845 @Override 1846 public void onProximityPositive() { 1847 synchronized (mLock) { 1848 mProximityPositive = true; 1849 mDirty |= DIRTY_PROXIMITY_POSITIVE; 1850 updatePowerStateLocked(); 1851 } 1852 } 1853 1854 @Override 1855 public void onProximityNegative() { 1856 synchronized (mLock) { 1857 mProximityPositive = false; 1858 mDirty |= DIRTY_PROXIMITY_POSITIVE; 1859 userActivityNoUpdateLocked(SystemClock.uptimeMillis(), 1860 PowerManager.USER_ACTIVITY_EVENT_OTHER, 0, Process.SYSTEM_UID); 1861 updatePowerStateLocked(); 1862 } 1863 } 1864 1865 @Override 1866 public void onDisplayStateChange(int state) { 1867 // This method is only needed to support legacy display blanking behavior 1868 // where the display's power state is coupled to suspend or to the power HAL. 1869 // The order of operations matters here. 1870 synchronized (mLock) { 1871 if (mDisplayState != state) { 1872 mDisplayState = state; 1873 if (state == Display.STATE_OFF) { 1874 if (!mDecoupleHalInteractiveModeFromDisplayConfig) { 1875 setHalInteractiveModeLocked(false); 1876 } 1877 if (!mDecoupleHalAutoSuspendModeFromDisplayConfig) { 1878 setHalAutoSuspendModeLocked(true); 1879 } 1880 } else { 1881 if (!mDecoupleHalAutoSuspendModeFromDisplayConfig) { 1882 setHalAutoSuspendModeLocked(false); 1883 } 1884 if (!mDecoupleHalInteractiveModeFromDisplayConfig) { 1885 setHalInteractiveModeLocked(true); 1886 } 1887 } 1888 } 1889 } 1890 } 1891 1892 @Override 1893 public void acquireSuspendBlocker() { 1894 mDisplaySuspendBlocker.acquire(); 1895 } 1896 1897 @Override 1898 public void releaseSuspendBlocker() { 1899 mDisplaySuspendBlocker.release(); 1900 } 1901 1902 @Override 1903 public String toString() { 1904 synchronized (this) { 1905 return "state=" + Display.stateToString(mDisplayState); 1906 } 1907 } 1908 }; 1909 1910 private boolean shouldUseProximitySensorLocked() { 1911 return (mWakeLockSummary & WAKE_LOCK_PROXIMITY_SCREEN_OFF) != 0; 1912 } 1913 1914 /** 1915 * Updates the suspend blocker that keeps the CPU alive. 1916 * 1917 * This function must have no other side-effects. 1918 */ 1919 private void updateSuspendBlockerLocked() { 1920 final boolean needWakeLockSuspendBlocker = ((mWakeLockSummary & WAKE_LOCK_CPU) != 0); 1921 final boolean needDisplaySuspendBlocker = needDisplaySuspendBlockerLocked(); 1922 final boolean autoSuspend = !needDisplaySuspendBlocker; 1923 1924 // Disable auto-suspend if needed. 1925 if (!autoSuspend) { 1926 if (mDecoupleHalAutoSuspendModeFromDisplayConfig) { 1927 setHalAutoSuspendModeLocked(false); 1928 } 1929 if (mDecoupleHalInteractiveModeFromDisplayConfig) { 1930 setHalInteractiveModeLocked(true); 1931 } 1932 } 1933 1934 // First acquire suspend blockers if needed. 1935 if (needWakeLockSuspendBlocker && !mHoldingWakeLockSuspendBlocker) { 1936 mWakeLockSuspendBlocker.acquire(); 1937 mHoldingWakeLockSuspendBlocker = true; 1938 } 1939 if (needDisplaySuspendBlocker && !mHoldingDisplaySuspendBlocker) { 1940 mDisplaySuspendBlocker.acquire(); 1941 mHoldingDisplaySuspendBlocker = true; 1942 } 1943 1944 // Then release suspend blockers if needed. 1945 if (!needWakeLockSuspendBlocker && mHoldingWakeLockSuspendBlocker) { 1946 mWakeLockSuspendBlocker.release(); 1947 mHoldingWakeLockSuspendBlocker = false; 1948 } 1949 if (!needDisplaySuspendBlocker && mHoldingDisplaySuspendBlocker) { 1950 mDisplaySuspendBlocker.release(); 1951 mHoldingDisplaySuspendBlocker = false; 1952 } 1953 1954 // Enable auto-suspend if needed. 1955 if (autoSuspend) { 1956 if (mDecoupleHalInteractiveModeFromDisplayConfig) { 1957 setHalInteractiveModeLocked(false); 1958 } 1959 if (mDecoupleHalAutoSuspendModeFromDisplayConfig) { 1960 setHalAutoSuspendModeLocked(true); 1961 } 1962 } 1963 } 1964 1965 /** 1966 * Return true if we must keep a suspend blocker active on behalf of the display. 1967 * We do so if the screen is on or is in transition between states. 1968 */ 1969 private boolean needDisplaySuspendBlockerLocked() { 1970 if (!mDisplayReady) { 1971 return true; 1972 } 1973 if (mDisplayPowerRequest.isBrightOrDim()) { 1974 // If we asked for the screen to be on but it is off due to the proximity 1975 // sensor then we may suspend but only if the configuration allows it. 1976 // On some hardware it may not be safe to suspend because the proximity 1977 // sensor may not be correctly configured as a wake-up source. 1978 if (!mDisplayPowerRequest.useProximitySensor || !mProximityPositive 1979 || !mSuspendWhenScreenOffDueToProximityConfig) { 1980 return true; 1981 } 1982 } 1983 // Let the system suspend if the screen is off or dozing. 1984 return false; 1985 } 1986 1987 private void setHalAutoSuspendModeLocked(boolean enable) { 1988 if (enable != mHalAutoSuspendModeEnabled) { 1989 if (DEBUG) { 1990 Slog.d(TAG, "Setting HAL auto-suspend mode to " + enable); 1991 } 1992 mHalAutoSuspendModeEnabled = enable; 1993 nativeSetAutoSuspend(enable); 1994 } 1995 } 1996 1997 private void setHalInteractiveModeLocked(boolean enable) { 1998 if (enable != mHalInteractiveModeEnabled) { 1999 if (DEBUG) { 2000 Slog.d(TAG, "Setting HAL interactive mode to " + enable); 2001 } 2002 mHalInteractiveModeEnabled = enable; 2003 nativeSetInteractive(enable); 2004 } 2005 } 2006 2007 private boolean isInteractiveInternal() { 2008 synchronized (mLock) { 2009 return mInteractive; 2010 } 2011 } 2012 2013 private boolean isLowPowerModeInternal() { 2014 synchronized (mLock) { 2015 return mLowPowerModeEnabled; 2016 } 2017 } 2018 2019 private void handleBatteryStateChangedLocked() { 2020 mDirty |= DIRTY_BATTERY_STATE; 2021 updatePowerStateLocked(); 2022 } 2023 2024 private void startWatchingForBootAnimationFinished() { 2025 mHandler.sendEmptyMessage(MSG_CHECK_IF_BOOT_ANIMATION_FINISHED); 2026 } 2027 2028 private void checkIfBootAnimationFinished() { 2029 if (DEBUG) { 2030 Slog.d(TAG, "Check if boot animation finished..."); 2031 } 2032 2033 if (SystemService.isRunning(BOOT_ANIMATION_SERVICE)) { 2034 mHandler.sendEmptyMessageDelayed(MSG_CHECK_IF_BOOT_ANIMATION_FINISHED, 2035 BOOT_ANIMATION_POLL_INTERVAL); 2036 return; 2037 } 2038 2039 synchronized (mLock) { 2040 if (!mBootCompleted) { 2041 Slog.i(TAG, "Boot animation finished."); 2042 handleBootCompletedLocked(); 2043 } 2044 } 2045 } 2046 2047 private void handleBootCompletedLocked() { 2048 final long now = SystemClock.uptimeMillis(); 2049 mBootCompleted = true; 2050 mDirty |= DIRTY_BOOT_COMPLETED; 2051 userActivityNoUpdateLocked( 2052 now, PowerManager.USER_ACTIVITY_EVENT_OTHER, 0, Process.SYSTEM_UID); 2053 updatePowerStateLocked(); 2054 } 2055 2056 private void shutdownOrRebootInternal(final boolean shutdown, final boolean confirm, 2057 final String reason, boolean wait) { 2058 if (mHandler == null || !mSystemReady) { 2059 throw new IllegalStateException("Too early to call shutdown() or reboot()"); 2060 } 2061 2062 Runnable runnable = new Runnable() { 2063 @Override 2064 public void run() { 2065 synchronized (this) { 2066 if (shutdown) { 2067 ShutdownThread.shutdown(mContext, confirm); 2068 } else { 2069 ShutdownThread.reboot(mContext, reason, confirm); 2070 } 2071 } 2072 } 2073 }; 2074 2075 // ShutdownThread must run on a looper capable of displaying the UI. 2076 Message msg = Message.obtain(mHandler, runnable); 2077 msg.setAsynchronous(true); 2078 mHandler.sendMessage(msg); 2079 2080 // PowerManager.reboot() is documented not to return so just wait for the inevitable. 2081 if (wait) { 2082 synchronized (runnable) { 2083 while (true) { 2084 try { 2085 runnable.wait(); 2086 } catch (InterruptedException e) { 2087 } 2088 } 2089 } 2090 } 2091 } 2092 2093 private void crashInternal(final String message) { 2094 Thread t = new Thread("PowerManagerService.crash()") { 2095 @Override 2096 public void run() { 2097 throw new RuntimeException(message); 2098 } 2099 }; 2100 try { 2101 t.start(); 2102 t.join(); 2103 } catch (InterruptedException e) { 2104 Log.wtf(TAG, e); 2105 } 2106 } 2107 2108 private void setStayOnSettingInternal(int val) { 2109 Settings.Global.putInt(mContext.getContentResolver(), 2110 Settings.Global.STAY_ON_WHILE_PLUGGED_IN, val); 2111 } 2112 2113 private void setMaximumScreenOffTimeoutFromDeviceAdminInternal(int timeMs) { 2114 synchronized (mLock) { 2115 mMaximumScreenOffTimeoutFromDeviceAdmin = timeMs; 2116 mDirty |= DIRTY_SETTINGS; 2117 updatePowerStateLocked(); 2118 } 2119 } 2120 2121 private boolean isMaximumScreenOffTimeoutFromDeviceAdminEnforcedLocked() { 2122 return mMaximumScreenOffTimeoutFromDeviceAdmin >= 0 2123 && mMaximumScreenOffTimeoutFromDeviceAdmin < Integer.MAX_VALUE; 2124 } 2125 2126 private void setAttentionLightInternal(boolean on, int color) { 2127 Light light; 2128 synchronized (mLock) { 2129 if (!mSystemReady) { 2130 return; 2131 } 2132 light = mAttentionLight; 2133 } 2134 2135 // Control light outside of lock. 2136 light.setFlashing(color, Light.LIGHT_FLASH_HARDWARE, (on ? 3 : 0), 0); 2137 } 2138 2139 private void setScreenBrightnessOverrideFromWindowManagerInternal(int brightness) { 2140 synchronized (mLock) { 2141 if (mScreenBrightnessOverrideFromWindowManager != brightness) { 2142 mScreenBrightnessOverrideFromWindowManager = brightness; 2143 mDirty |= DIRTY_SETTINGS; 2144 updatePowerStateLocked(); 2145 } 2146 } 2147 } 2148 2149 private void setUserActivityTimeoutOverrideFromWindowManagerInternal(long timeoutMillis) { 2150 synchronized (mLock) { 2151 if (mUserActivityTimeoutOverrideFromWindowManager != timeoutMillis) { 2152 mUserActivityTimeoutOverrideFromWindowManager = timeoutMillis; 2153 mDirty |= DIRTY_SETTINGS; 2154 updatePowerStateLocked(); 2155 } 2156 } 2157 } 2158 2159 private void setTemporaryScreenBrightnessSettingOverrideInternal(int brightness) { 2160 synchronized (mLock) { 2161 if (mTemporaryScreenBrightnessSettingOverride != brightness) { 2162 mTemporaryScreenBrightnessSettingOverride = brightness; 2163 mDirty |= DIRTY_SETTINGS; 2164 updatePowerStateLocked(); 2165 } 2166 } 2167 } 2168 2169 private void setTemporaryScreenAutoBrightnessAdjustmentSettingOverrideInternal(float adj) { 2170 synchronized (mLock) { 2171 // Note: This condition handles NaN because NaN is not equal to any other 2172 // value, including itself. 2173 if (mTemporaryScreenAutoBrightnessAdjustmentSettingOverride != adj) { 2174 mTemporaryScreenAutoBrightnessAdjustmentSettingOverride = adj; 2175 mDirty |= DIRTY_SETTINGS; 2176 updatePowerStateLocked(); 2177 } 2178 } 2179 } 2180 2181 private void setDozeOverrideFromDreamManagerInternal( 2182 int screenState, int screenBrightness) { 2183 synchronized (mLock) { 2184 if (mDozeScreenStateOverrideFromDreamManager != screenState 2185 || mDozeScreenBrightnessOverrideFromDreamManager != screenBrightness) { 2186 mDozeScreenStateOverrideFromDreamManager = screenState; 2187 mDozeScreenBrightnessOverrideFromDreamManager = screenBrightness; 2188 mDirty |= DIRTY_SETTINGS; 2189 updatePowerStateLocked(); 2190 } 2191 } 2192 } 2193 2194 private void powerHintInternal(int hintId, int data) { 2195 nativeSendPowerHint(hintId, data); 2196 } 2197 2198 /** 2199 * Low-level function turn the device off immediately, without trying 2200 * to be clean. Most people should use {@link ShutdownThread} for a clean shutdown. 2201 */ 2202 public static void lowLevelShutdown() { 2203 SystemProperties.set("sys.powerctl", "shutdown"); 2204 } 2205 2206 /** 2207 * Low-level function to reboot the device. On success, this 2208 * function doesn't return. If more than 20 seconds passes from 2209 * the time a reboot is requested (120 seconds for reboot to 2210 * recovery), this method returns. 2211 * 2212 * @param reason code to pass to the kernel (e.g. "recovery"), or null. 2213 */ 2214 public static void lowLevelReboot(String reason) { 2215 if (reason == null) { 2216 reason = ""; 2217 } 2218 long duration; 2219 if (reason.equals(PowerManager.REBOOT_RECOVERY)) { 2220 // If we are rebooting to go into recovery, instead of 2221 // setting sys.powerctl directly we'll start the 2222 // pre-recovery service which will do some preparation for 2223 // recovery and then reboot for us. 2224 // 2225 // This preparation can take more than 20 seconds if 2226 // there's a very large update package, so lengthen the 2227 // timeout. 2228 SystemProperties.set("ctl.start", "pre-recovery"); 2229 duration = 120 * 1000L; 2230 } else { 2231 SystemProperties.set("sys.powerctl", "reboot," + reason); 2232 duration = 20 * 1000L; 2233 } 2234 try { 2235 Thread.sleep(duration); 2236 } catch (InterruptedException e) { 2237 Thread.currentThread().interrupt(); 2238 } 2239 } 2240 2241 @Override // Watchdog.Monitor implementation 2242 public void monitor() { 2243 // Grab and release lock for watchdog monitor to detect deadlocks. 2244 synchronized (mLock) { 2245 } 2246 } 2247 2248 private void dumpInternal(PrintWriter pw) { 2249 pw.println("POWER MANAGER (dumpsys power)\n"); 2250 2251 final WirelessChargerDetector wcd; 2252 synchronized (mLock) { 2253 pw.println("Power Manager State:"); 2254 pw.println(" mDirty=0x" + Integer.toHexString(mDirty)); 2255 pw.println(" mWakefulness=" + wakefulnessToString(mWakefulness)); 2256 pw.println(" mInteractive=" + mInteractive); 2257 pw.println(" mIsPowered=" + mIsPowered); 2258 pw.println(" mPlugType=" + mPlugType); 2259 pw.println(" mBatteryLevel=" + mBatteryLevel); 2260 pw.println(" mBatteryLevelWhenDreamStarted=" + mBatteryLevelWhenDreamStarted); 2261 pw.println(" mDockState=" + mDockState); 2262 pw.println(" mStayOn=" + mStayOn); 2263 pw.println(" mProximityPositive=" + mProximityPositive); 2264 pw.println(" mBootCompleted=" + mBootCompleted); 2265 pw.println(" mSystemReady=" + mSystemReady); 2266 pw.println(" mHalAutoSuspendModeEnabled=" + mHalAutoSuspendModeEnabled); 2267 pw.println(" mHalInteractiveModeEnabled=" + mHalInteractiveModeEnabled); 2268 pw.println(" mWakeLockSummary=0x" + Integer.toHexString(mWakeLockSummary)); 2269 pw.println(" mUserActivitySummary=0x" + Integer.toHexString(mUserActivitySummary)); 2270 pw.println(" mRequestWaitForNegativeProximity=" + mRequestWaitForNegativeProximity); 2271 pw.println(" mSandmanScheduled=" + mSandmanScheduled); 2272 pw.println(" mSandmanSummoned=" + mSandmanSummoned); 2273 pw.println(" mLowPowerModeEnabled=" + mLowPowerModeEnabled); 2274 pw.println(" mBatteryLevelLow=" + mBatteryLevelLow); 2275 pw.println(" mLastWakeTime=" + TimeUtils.formatUptime(mLastWakeTime)); 2276 pw.println(" mLastSleepTime=" + TimeUtils.formatUptime(mLastSleepTime)); 2277 pw.println(" mLastUserActivityTime=" + TimeUtils.formatUptime(mLastUserActivityTime)); 2278 pw.println(" mLastUserActivityTimeNoChangeLights=" 2279 + TimeUtils.formatUptime(mLastUserActivityTimeNoChangeLights)); 2280 pw.println(" mDisplayReady=" + mDisplayReady); 2281 pw.println(" mHoldingWakeLockSuspendBlocker=" + mHoldingWakeLockSuspendBlocker); 2282 pw.println(" mHoldingDisplaySuspendBlocker=" + mHoldingDisplaySuspendBlocker); 2283 2284 pw.println(); 2285 pw.println("Settings and Configuration:"); 2286 pw.println(" mDecoupleHalAutoSuspendModeFromDisplayConfig=" 2287 + mDecoupleHalAutoSuspendModeFromDisplayConfig); 2288 pw.println(" mDecoupleHalInteractiveModeFromDisplayConfig=" 2289 + mDecoupleHalInteractiveModeFromDisplayConfig); 2290 pw.println(" mWakeUpWhenPluggedOrUnpluggedConfig=" 2291 + mWakeUpWhenPluggedOrUnpluggedConfig); 2292 pw.println(" mSuspendWhenScreenOffDueToProximityConfig=" 2293 + mSuspendWhenScreenOffDueToProximityConfig); 2294 pw.println(" mDreamsSupportedConfig=" + mDreamsSupportedConfig); 2295 pw.println(" mDreamsEnabledByDefaultConfig=" + mDreamsEnabledByDefaultConfig); 2296 pw.println(" mDreamsActivatedOnSleepByDefaultConfig=" 2297 + mDreamsActivatedOnSleepByDefaultConfig); 2298 pw.println(" mDreamsActivatedOnDockByDefaultConfig=" 2299 + mDreamsActivatedOnDockByDefaultConfig); 2300 pw.println(" mDreamsEnabledOnBatteryConfig=" 2301 + mDreamsEnabledOnBatteryConfig); 2302 pw.println(" mDreamsBatteryLevelMinimumWhenPoweredConfig=" 2303 + mDreamsBatteryLevelMinimumWhenPoweredConfig); 2304 pw.println(" mDreamsBatteryLevelMinimumWhenNotPoweredConfig=" 2305 + mDreamsBatteryLevelMinimumWhenNotPoweredConfig); 2306 pw.println(" mDreamsBatteryLevelDrainCutoffConfig=" 2307 + mDreamsBatteryLevelDrainCutoffConfig); 2308 pw.println(" mDreamsEnabledSetting=" + mDreamsEnabledSetting); 2309 pw.println(" mDreamsActivateOnSleepSetting=" + mDreamsActivateOnSleepSetting); 2310 pw.println(" mDreamsActivateOnDockSetting=" + mDreamsActivateOnDockSetting); 2311 pw.println(" mLowPowerModeSetting=" + mLowPowerModeSetting); 2312 pw.println(" mAutoLowPowerModeEnabled=" + mAutoLowPowerModeEnabled); 2313 pw.println(" mAutoLowPowerModeSnoozing=" + mAutoLowPowerModeSnoozing); 2314 pw.println(" mMinimumScreenOffTimeoutConfig=" + mMinimumScreenOffTimeoutConfig); 2315 pw.println(" mMaximumScreenDimDurationConfig=" + mMaximumScreenDimDurationConfig); 2316 pw.println(" mMaximumScreenDimRatioConfig=" + mMaximumScreenDimRatioConfig); 2317 pw.println(" mScreenOffTimeoutSetting=" + mScreenOffTimeoutSetting); 2318 pw.println(" mMaximumScreenOffTimeoutFromDeviceAdmin=" 2319 + mMaximumScreenOffTimeoutFromDeviceAdmin + " (enforced=" 2320 + isMaximumScreenOffTimeoutFromDeviceAdminEnforcedLocked() + ")"); 2321 pw.println(" mStayOnWhilePluggedInSetting=" + mStayOnWhilePluggedInSetting); 2322 pw.println(" mScreenBrightnessSetting=" + mScreenBrightnessSetting); 2323 pw.println(" mScreenAutoBrightnessAdjustmentSetting=" 2324 + mScreenAutoBrightnessAdjustmentSetting); 2325 pw.println(" mScreenBrightnessModeSetting=" + mScreenBrightnessModeSetting); 2326 pw.println(" mScreenBrightnessOverrideFromWindowManager=" 2327 + mScreenBrightnessOverrideFromWindowManager); 2328 pw.println(" mUserActivityTimeoutOverrideFromWindowManager=" 2329 + mUserActivityTimeoutOverrideFromWindowManager); 2330 pw.println(" mTemporaryScreenBrightnessSettingOverride=" 2331 + mTemporaryScreenBrightnessSettingOverride); 2332 pw.println(" mTemporaryScreenAutoBrightnessAdjustmentSettingOverride=" 2333 + mTemporaryScreenAutoBrightnessAdjustmentSettingOverride); 2334 pw.println(" mDozeScreenStateOverrideFromDreamManager=" 2335 + mDozeScreenStateOverrideFromDreamManager); 2336 pw.println(" mDozeScreenBrightnessOverrideFromDreamManager=" 2337 + mDozeScreenBrightnessOverrideFromDreamManager); 2338 pw.println(" mScreenBrightnessSettingMinimum=" + mScreenBrightnessSettingMinimum); 2339 pw.println(" mScreenBrightnessSettingMaximum=" + mScreenBrightnessSettingMaximum); 2340 pw.println(" mScreenBrightnessSettingDefault=" + mScreenBrightnessSettingDefault); 2341 2342 final int screenOffTimeout = getScreenOffTimeoutLocked(); 2343 final int screenDimDuration = getScreenDimDurationLocked(screenOffTimeout); 2344 pw.println(); 2345 pw.println("Screen off timeout: " + screenOffTimeout + " ms"); 2346 pw.println("Screen dim duration: " + screenDimDuration + " ms"); 2347 2348 pw.println(); 2349 pw.println("Wake Locks: size=" + mWakeLocks.size()); 2350 for (WakeLock wl : mWakeLocks) { 2351 pw.println(" " + wl); 2352 } 2353 2354 pw.println(); 2355 pw.println("Suspend Blockers: size=" + mSuspendBlockers.size()); 2356 for (SuspendBlocker sb : mSuspendBlockers) { 2357 pw.println(" " + sb); 2358 } 2359 2360 pw.println(); 2361 pw.println("Screen On Blocker: " + mScreenOnBlocker); 2362 2363 pw.println(); 2364 pw.println("Display Power: " + mDisplayPowerCallbacks); 2365 2366 wcd = mWirelessChargerDetector; 2367 } 2368 2369 if (wcd != null) { 2370 wcd.dump(pw); 2371 } 2372 } 2373 2374 private SuspendBlocker createSuspendBlockerLocked(String name) { 2375 SuspendBlocker suspendBlocker = new SuspendBlockerImpl(name); 2376 mSuspendBlockers.add(suspendBlocker); 2377 return suspendBlocker; 2378 } 2379 2380 private static String wakefulnessToString(int wakefulness) { 2381 switch (wakefulness) { 2382 case WAKEFULNESS_ASLEEP: 2383 return "Asleep"; 2384 case WAKEFULNESS_AWAKE: 2385 return "Awake"; 2386 case WAKEFULNESS_DREAMING: 2387 return "Dreaming"; 2388 case WAKEFULNESS_DOZING: 2389 return "Dozing"; 2390 default: 2391 return Integer.toString(wakefulness); 2392 } 2393 } 2394 2395 private static WorkSource copyWorkSource(WorkSource workSource) { 2396 return workSource != null ? new WorkSource(workSource) : null; 2397 } 2398 2399 private final class BatteryReceiver extends BroadcastReceiver { 2400 @Override 2401 public void onReceive(Context context, Intent intent) { 2402 synchronized (mLock) { 2403 handleBatteryStateChangedLocked(); 2404 } 2405 } 2406 } 2407 2408 private final class DreamReceiver extends BroadcastReceiver { 2409 @Override 2410 public void onReceive(Context context, Intent intent) { 2411 synchronized (mLock) { 2412 scheduleSandmanLocked(); 2413 } 2414 } 2415 } 2416 2417 private final class UserSwitchedReceiver extends BroadcastReceiver { 2418 @Override 2419 public void onReceive(Context context, Intent intent) { 2420 synchronized (mLock) { 2421 handleSettingsChangedLocked(); 2422 } 2423 } 2424 } 2425 2426 private final class DockReceiver extends BroadcastReceiver { 2427 @Override 2428 public void onReceive(Context context, Intent intent) { 2429 synchronized (mLock) { 2430 int dockState = intent.getIntExtra(Intent.EXTRA_DOCK_STATE, 2431 Intent.EXTRA_DOCK_STATE_UNDOCKED); 2432 if (mDockState != dockState) { 2433 mDockState = dockState; 2434 mDirty |= DIRTY_DOCK_STATE; 2435 updatePowerStateLocked(); 2436 } 2437 } 2438 } 2439 } 2440 2441 private final class SettingsObserver extends ContentObserver { 2442 public SettingsObserver(Handler handler) { 2443 super(handler); 2444 } 2445 2446 @Override 2447 public void onChange(boolean selfChange, Uri uri) { 2448 synchronized (mLock) { 2449 handleSettingsChangedLocked(); 2450 } 2451 } 2452 } 2453 2454 /** 2455 * Handler for asynchronous operations performed by the power manager. 2456 */ 2457 private final class PowerManagerHandler extends Handler { 2458 public PowerManagerHandler(Looper looper) { 2459 super(looper, null, true /*async*/); 2460 } 2461 2462 @Override 2463 public void handleMessage(Message msg) { 2464 switch (msg.what) { 2465 case MSG_USER_ACTIVITY_TIMEOUT: 2466 handleUserActivityTimeout(); 2467 break; 2468 case MSG_SANDMAN: 2469 handleSandman(); 2470 break; 2471 case MSG_SCREEN_ON_BLOCKER_RELEASED: 2472 handleScreenOnBlockerReleased(); 2473 break; 2474 case MSG_CHECK_IF_BOOT_ANIMATION_FINISHED: 2475 checkIfBootAnimationFinished(); 2476 break; 2477 } 2478 } 2479 } 2480 2481 /** 2482 * Represents a wake lock that has been acquired by an application. 2483 */ 2484 private final class WakeLock implements IBinder.DeathRecipient { 2485 public final IBinder mLock; 2486 public int mFlags; 2487 public String mTag; 2488 public final String mPackageName; 2489 public WorkSource mWorkSource; 2490 public String mHistoryTag; 2491 public final int mOwnerUid; 2492 public final int mOwnerPid; 2493 public boolean mNotifiedAcquired; 2494 2495 public WakeLock(IBinder lock, int flags, String tag, String packageName, 2496 WorkSource workSource, String historyTag, int ownerUid, int ownerPid) { 2497 mLock = lock; 2498 mFlags = flags; 2499 mTag = tag; 2500 mPackageName = packageName; 2501 mWorkSource = copyWorkSource(workSource); 2502 mHistoryTag = historyTag; 2503 mOwnerUid = ownerUid; 2504 mOwnerPid = ownerPid; 2505 } 2506 2507 @Override 2508 public void binderDied() { 2509 PowerManagerService.this.handleWakeLockDeath(this); 2510 } 2511 2512 public boolean hasSameProperties(int flags, String tag, WorkSource workSource, 2513 int ownerUid, int ownerPid) { 2514 return mFlags == flags 2515 && mTag.equals(tag) 2516 && hasSameWorkSource(workSource) 2517 && mOwnerUid == ownerUid 2518 && mOwnerPid == ownerPid; 2519 } 2520 2521 public void updateProperties(int flags, String tag, String packageName, 2522 WorkSource workSource, String historyTag, int ownerUid, int ownerPid) { 2523 if (!mPackageName.equals(packageName)) { 2524 throw new IllegalStateException("Existing wake lock package name changed: " 2525 + mPackageName + " to " + packageName); 2526 } 2527 if (mOwnerUid != ownerUid) { 2528 throw new IllegalStateException("Existing wake lock uid changed: " 2529 + mOwnerUid + " to " + ownerUid); 2530 } 2531 if (mOwnerPid != ownerPid) { 2532 throw new IllegalStateException("Existing wake lock pid changed: " 2533 + mOwnerPid + " to " + ownerPid); 2534 } 2535 mFlags = flags; 2536 mTag = tag; 2537 updateWorkSource(workSource); 2538 mHistoryTag = historyTag; 2539 } 2540 2541 public boolean hasSameWorkSource(WorkSource workSource) { 2542 return Objects.equal(mWorkSource, workSource); 2543 } 2544 2545 public void updateWorkSource(WorkSource workSource) { 2546 mWorkSource = copyWorkSource(workSource); 2547 } 2548 2549 @Override 2550 public String toString() { 2551 return getLockLevelString() 2552 + " '" + mTag + "'" + getLockFlagsString() 2553 + " (uid=" + mOwnerUid + ", pid=" + mOwnerPid + ", ws=" + mWorkSource + ")"; 2554 } 2555 2556 @SuppressWarnings("deprecation") 2557 private String getLockLevelString() { 2558 switch (mFlags & PowerManager.WAKE_LOCK_LEVEL_MASK) { 2559 case PowerManager.FULL_WAKE_LOCK: 2560 return "FULL_WAKE_LOCK "; 2561 case PowerManager.SCREEN_BRIGHT_WAKE_LOCK: 2562 return "SCREEN_BRIGHT_WAKE_LOCK "; 2563 case PowerManager.SCREEN_DIM_WAKE_LOCK: 2564 return "SCREEN_DIM_WAKE_LOCK "; 2565 case PowerManager.PARTIAL_WAKE_LOCK: 2566 return "PARTIAL_WAKE_LOCK "; 2567 case PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK: 2568 return "PROXIMITY_SCREEN_OFF_WAKE_LOCK"; 2569 case PowerManager.DOZE_WAKE_LOCK: 2570 return "DOZE_WAKE_LOCK "; 2571 default: 2572 return "??? "; 2573 } 2574 } 2575 2576 private String getLockFlagsString() { 2577 String result = ""; 2578 if ((mFlags & PowerManager.ACQUIRE_CAUSES_WAKEUP) != 0) { 2579 result += " ACQUIRE_CAUSES_WAKEUP"; 2580 } 2581 if ((mFlags & PowerManager.ON_AFTER_RELEASE) != 0) { 2582 result += " ON_AFTER_RELEASE"; 2583 } 2584 return result; 2585 } 2586 } 2587 2588 private final class SuspendBlockerImpl implements SuspendBlocker { 2589 private final String mName; 2590 private int mReferenceCount; 2591 2592 public SuspendBlockerImpl(String name) { 2593 mName = name; 2594 } 2595 2596 @Override 2597 protected void finalize() throws Throwable { 2598 try { 2599 if (mReferenceCount != 0) { 2600 Log.wtf(TAG, "Suspend blocker \"" + mName 2601 + "\" was finalized without being released!"); 2602 mReferenceCount = 0; 2603 nativeReleaseSuspendBlocker(mName); 2604 } 2605 } finally { 2606 super.finalize(); 2607 } 2608 } 2609 2610 @Override 2611 public void acquire() { 2612 synchronized (this) { 2613 mReferenceCount += 1; 2614 if (mReferenceCount == 1) { 2615 if (DEBUG_SPEW) { 2616 Slog.d(TAG, "Acquiring suspend blocker \"" + mName + "\"."); 2617 } 2618 nativeAcquireSuspendBlocker(mName); 2619 } 2620 } 2621 } 2622 2623 @Override 2624 public void release() { 2625 synchronized (this) { 2626 mReferenceCount -= 1; 2627 if (mReferenceCount == 0) { 2628 if (DEBUG_SPEW) { 2629 Slog.d(TAG, "Releasing suspend blocker \"" + mName + "\"."); 2630 } 2631 nativeReleaseSuspendBlocker(mName); 2632 } else if (mReferenceCount < 0) { 2633 Log.wtf(TAG, "Suspend blocker \"" + mName 2634 + "\" was released without being acquired!", new Throwable()); 2635 mReferenceCount = 0; 2636 } 2637 } 2638 } 2639 2640 @Override 2641 public String toString() { 2642 synchronized (this) { 2643 return mName + ": ref count=" + mReferenceCount; 2644 } 2645 } 2646 } 2647 2648 private final class ScreenOnBlockerImpl implements ScreenOnBlocker { 2649 private int mNestCount; 2650 2651 public boolean isHeld() { 2652 synchronized (this) { 2653 return mNestCount != 0; 2654 } 2655 } 2656 2657 @Override 2658 public void acquire() { 2659 synchronized (this) { 2660 mNestCount += 1; 2661 if (DEBUG) { 2662 Slog.d(TAG, "Screen on blocked: mNestCount=" + mNestCount); 2663 } 2664 } 2665 } 2666 2667 @Override 2668 public void release() { 2669 synchronized (this) { 2670 mNestCount -= 1; 2671 if (mNestCount < 0) { 2672 Log.wtf(TAG, "Screen on blocker was released without being acquired!", 2673 new Throwable()); 2674 mNestCount = 0; 2675 } 2676 if (mNestCount == 0) { 2677 mHandler.sendEmptyMessage(MSG_SCREEN_ON_BLOCKER_RELEASED); 2678 } 2679 if (DEBUG) { 2680 Slog.d(TAG, "Screen on unblocked: mNestCount=" + mNestCount); 2681 } 2682 } 2683 } 2684 2685 @Override 2686 public String toString() { 2687 synchronized (this) { 2688 return "held=" + (mNestCount != 0) + ", mNestCount=" + mNestCount; 2689 } 2690 } 2691 } 2692 2693 private final class BinderService extends IPowerManager.Stub { 2694 @Override // Binder call 2695 public void acquireWakeLockWithUid(IBinder lock, int flags, String tag, 2696 String packageName, int uid) { 2697 if (uid < 0) { 2698 uid = Binder.getCallingUid(); 2699 } 2700 acquireWakeLock(lock, flags, tag, packageName, new WorkSource(uid), null); 2701 } 2702 2703 @Override // Binder call 2704 public void powerHint(int hintId, int data) { 2705 if (!mSystemReady) { 2706 // Service not ready yet, so who the heck cares about power hints, bah. 2707 return; 2708 } 2709 mContext.enforceCallingOrSelfPermission(android.Manifest.permission.DEVICE_POWER, null); 2710 powerHintInternal(hintId, data); 2711 } 2712 2713 @Override // Binder call 2714 public void acquireWakeLock(IBinder lock, int flags, String tag, String packageName, 2715 WorkSource ws, String historyTag) { 2716 if (lock == null) { 2717 throw new IllegalArgumentException("lock must not be null"); 2718 } 2719 if (packageName == null) { 2720 throw new IllegalArgumentException("packageName must not be null"); 2721 } 2722 PowerManager.validateWakeLockParameters(flags, tag); 2723 2724 mContext.enforceCallingOrSelfPermission(android.Manifest.permission.WAKE_LOCK, null); 2725 if (ws != null && ws.size() != 0) { 2726 mContext.enforceCallingOrSelfPermission( 2727 android.Manifest.permission.UPDATE_DEVICE_STATS, null); 2728 } else { 2729 ws = null; 2730 } 2731 2732 final int uid = Binder.getCallingUid(); 2733 final int pid = Binder.getCallingPid(); 2734 final long ident = Binder.clearCallingIdentity(); 2735 try { 2736 acquireWakeLockInternal(lock, flags, tag, packageName, ws, historyTag, uid, pid); 2737 } finally { 2738 Binder.restoreCallingIdentity(ident); 2739 } 2740 } 2741 2742 @Override // Binder call 2743 public void releaseWakeLock(IBinder lock, int flags) { 2744 if (lock == null) { 2745 throw new IllegalArgumentException("lock must not be null"); 2746 } 2747 2748 mContext.enforceCallingOrSelfPermission(android.Manifest.permission.WAKE_LOCK, null); 2749 2750 final long ident = Binder.clearCallingIdentity(); 2751 try { 2752 releaseWakeLockInternal(lock, flags); 2753 } finally { 2754 Binder.restoreCallingIdentity(ident); 2755 } 2756 } 2757 2758 @Override // Binder call 2759 public void updateWakeLockUids(IBinder lock, int[] uids) { 2760 WorkSource ws = null; 2761 2762 if (uids != null) { 2763 ws = new WorkSource(); 2764 // XXX should WorkSource have a way to set uids as an int[] instead of adding them 2765 // one at a time? 2766 for (int i = 0; i < uids.length; i++) { 2767 ws.add(uids[i]); 2768 } 2769 } 2770 updateWakeLockWorkSource(lock, ws, null); 2771 } 2772 2773 @Override // Binder call 2774 public void updateWakeLockWorkSource(IBinder lock, WorkSource ws, String historyTag) { 2775 if (lock == null) { 2776 throw new IllegalArgumentException("lock must not be null"); 2777 } 2778 2779 mContext.enforceCallingOrSelfPermission(android.Manifest.permission.WAKE_LOCK, null); 2780 if (ws != null && ws.size() != 0) { 2781 mContext.enforceCallingOrSelfPermission( 2782 android.Manifest.permission.UPDATE_DEVICE_STATS, null); 2783 } else { 2784 ws = null; 2785 } 2786 2787 final long ident = Binder.clearCallingIdentity(); 2788 try { 2789 updateWakeLockWorkSourceInternal(lock, ws, historyTag); 2790 } finally { 2791 Binder.restoreCallingIdentity(ident); 2792 } 2793 } 2794 2795 @Override // Binder call 2796 public boolean isWakeLockLevelSupported(int level) { 2797 final long ident = Binder.clearCallingIdentity(); 2798 try { 2799 return isWakeLockLevelSupportedInternal(level); 2800 } finally { 2801 Binder.restoreCallingIdentity(ident); 2802 } 2803 } 2804 2805 @Override // Binder call 2806 public void userActivity(long eventTime, int event, int flags) { 2807 final long now = SystemClock.uptimeMillis(); 2808 if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DEVICE_POWER) 2809 != PackageManager.PERMISSION_GRANTED) { 2810 // Once upon a time applications could call userActivity(). 2811 // Now we require the DEVICE_POWER permission. Log a warning and ignore the 2812 // request instead of throwing a SecurityException so we don't break old apps. 2813 synchronized (mLock) { 2814 if (now >= mLastWarningAboutUserActivityPermission + (5 * 60 * 1000)) { 2815 mLastWarningAboutUserActivityPermission = now; 2816 Slog.w(TAG, "Ignoring call to PowerManager.userActivity() because the " 2817 + "caller does not have DEVICE_POWER permission. " 2818 + "Please fix your app! " 2819 + " pid=" + Binder.getCallingPid() 2820 + " uid=" + Binder.getCallingUid()); 2821 } 2822 } 2823 return; 2824 } 2825 2826 if (eventTime > SystemClock.uptimeMillis()) { 2827 throw new IllegalArgumentException("event time must not be in the future"); 2828 } 2829 2830 final int uid = Binder.getCallingUid(); 2831 final long ident = Binder.clearCallingIdentity(); 2832 try { 2833 userActivityInternal(eventTime, event, flags, uid); 2834 } finally { 2835 Binder.restoreCallingIdentity(ident); 2836 } 2837 } 2838 2839 @Override // Binder call 2840 public void wakeUp(long eventTime) { 2841 if (eventTime > SystemClock.uptimeMillis()) { 2842 throw new IllegalArgumentException("event time must not be in the future"); 2843 } 2844 2845 mContext.enforceCallingOrSelfPermission( 2846 android.Manifest.permission.DEVICE_POWER, null); 2847 2848 final int uid = Binder.getCallingUid(); 2849 final long ident = Binder.clearCallingIdentity(); 2850 try { 2851 wakeUpInternal(eventTime, uid); 2852 } finally { 2853 Binder.restoreCallingIdentity(ident); 2854 } 2855 } 2856 2857 @Override // Binder call 2858 public void goToSleep(long eventTime, int reason, int flags) { 2859 if (eventTime > SystemClock.uptimeMillis()) { 2860 throw new IllegalArgumentException("event time must not be in the future"); 2861 } 2862 2863 mContext.enforceCallingOrSelfPermission( 2864 android.Manifest.permission.DEVICE_POWER, null); 2865 2866 final int uid = Binder.getCallingUid(); 2867 final long ident = Binder.clearCallingIdentity(); 2868 try { 2869 goToSleepInternal(eventTime, reason, flags, uid); 2870 } finally { 2871 Binder.restoreCallingIdentity(ident); 2872 } 2873 } 2874 2875 @Override // Binder call 2876 public void nap(long eventTime) { 2877 if (eventTime > SystemClock.uptimeMillis()) { 2878 throw new IllegalArgumentException("event time must not be in the future"); 2879 } 2880 2881 mContext.enforceCallingOrSelfPermission( 2882 android.Manifest.permission.DEVICE_POWER, null); 2883 2884 final int uid = Binder.getCallingUid(); 2885 final long ident = Binder.clearCallingIdentity(); 2886 try { 2887 napInternal(eventTime, uid); 2888 } finally { 2889 Binder.restoreCallingIdentity(ident); 2890 } 2891 } 2892 2893 @Override // Binder call 2894 public boolean isInteractive() { 2895 final long ident = Binder.clearCallingIdentity(); 2896 try { 2897 return isInteractiveInternal(); 2898 } finally { 2899 Binder.restoreCallingIdentity(ident); 2900 } 2901 } 2902 2903 @Override // Binder call 2904 public boolean isPowerSaveMode() { 2905 final long ident = Binder.clearCallingIdentity(); 2906 try { 2907 return isLowPowerModeInternal(); 2908 } finally { 2909 Binder.restoreCallingIdentity(ident); 2910 } 2911 } 2912 2913 /** 2914 * Reboots the device. 2915 * 2916 * @param confirm If true, shows a reboot confirmation dialog. 2917 * @param reason The reason for the reboot, or null if none. 2918 * @param wait If true, this call waits for the reboot to complete and does not return. 2919 */ 2920 @Override // Binder call 2921 public void reboot(boolean confirm, String reason, boolean wait) { 2922 mContext.enforceCallingOrSelfPermission(android.Manifest.permission.REBOOT, null); 2923 if (PowerManager.REBOOT_RECOVERY.equals(reason)) { 2924 mContext.enforceCallingOrSelfPermission(android.Manifest.permission.RECOVERY, null); 2925 } 2926 2927 final long ident = Binder.clearCallingIdentity(); 2928 try { 2929 shutdownOrRebootInternal(false, confirm, reason, wait); 2930 } finally { 2931 Binder.restoreCallingIdentity(ident); 2932 } 2933 } 2934 2935 /** 2936 * Shuts down the device. 2937 * 2938 * @param confirm If true, shows a shutdown confirmation dialog. 2939 * @param wait If true, this call waits for the shutdown to complete and does not return. 2940 */ 2941 @Override // Binder call 2942 public void shutdown(boolean confirm, boolean wait) { 2943 mContext.enforceCallingOrSelfPermission(android.Manifest.permission.REBOOT, null); 2944 2945 final long ident = Binder.clearCallingIdentity(); 2946 try { 2947 shutdownOrRebootInternal(true, confirm, null, wait); 2948 } finally { 2949 Binder.restoreCallingIdentity(ident); 2950 } 2951 } 2952 2953 /** 2954 * Crash the runtime (causing a complete restart of the Android framework). 2955 * Requires REBOOT permission. Mostly for testing. Should not return. 2956 */ 2957 @Override // Binder call 2958 public void crash(String message) { 2959 mContext.enforceCallingOrSelfPermission(android.Manifest.permission.REBOOT, null); 2960 2961 final long ident = Binder.clearCallingIdentity(); 2962 try { 2963 crashInternal(message); 2964 } finally { 2965 Binder.restoreCallingIdentity(ident); 2966 } 2967 } 2968 2969 /** 2970 * Set the setting that determines whether the device stays on when plugged in. 2971 * The argument is a bit string, with each bit specifying a power source that, 2972 * when the device is connected to that source, causes the device to stay on. 2973 * See {@link android.os.BatteryManager} for the list of power sources that 2974 * can be specified. Current values include 2975 * {@link android.os.BatteryManager#BATTERY_PLUGGED_AC} 2976 * and {@link android.os.BatteryManager#BATTERY_PLUGGED_USB} 2977 * 2978 * Used by "adb shell svc power stayon ..." 2979 * 2980 * @param val an {@code int} containing the bits that specify which power sources 2981 * should cause the device to stay on. 2982 */ 2983 @Override // Binder call 2984 public void setStayOnSetting(int val) { 2985 mContext.enforceCallingOrSelfPermission( 2986 android.Manifest.permission.WRITE_SETTINGS, null); 2987 2988 final long ident = Binder.clearCallingIdentity(); 2989 try { 2990 setStayOnSettingInternal(val); 2991 } finally { 2992 Binder.restoreCallingIdentity(ident); 2993 } 2994 } 2995 2996 /** 2997 * Used by device administration to set the maximum screen off timeout. 2998 * 2999 * This method must only be called by the device administration policy manager. 3000 */ 3001 @Override // Binder call 3002 public void setMaximumScreenOffTimeoutFromDeviceAdmin(int timeMs) { 3003 final long ident = Binder.clearCallingIdentity(); 3004 try { 3005 setMaximumScreenOffTimeoutFromDeviceAdminInternal(timeMs); 3006 } finally { 3007 Binder.restoreCallingIdentity(ident); 3008 } 3009 } 3010 3011 /** 3012 * Used by the settings application and brightness control widgets to 3013 * temporarily override the current screen brightness setting so that the 3014 * user can observe the effect of an intended settings change without applying 3015 * it immediately. 3016 * 3017 * The override will be canceled when the setting value is next updated. 3018 * 3019 * @param brightness The overridden brightness. 3020 * 3021 * @see android.provider.Settings.System#SCREEN_BRIGHTNESS 3022 */ 3023 @Override // Binder call 3024 public void setTemporaryScreenBrightnessSettingOverride(int brightness) { 3025 mContext.enforceCallingOrSelfPermission( 3026 android.Manifest.permission.DEVICE_POWER, null); 3027 3028 final long ident = Binder.clearCallingIdentity(); 3029 try { 3030 setTemporaryScreenBrightnessSettingOverrideInternal(brightness); 3031 } finally { 3032 Binder.restoreCallingIdentity(ident); 3033 } 3034 } 3035 3036 /** 3037 * Used by the settings application and brightness control widgets to 3038 * temporarily override the current screen auto-brightness adjustment setting so that the 3039 * user can observe the effect of an intended settings change without applying 3040 * it immediately. 3041 * 3042 * The override will be canceled when the setting value is next updated. 3043 * 3044 * @param adj The overridden brightness, or Float.NaN to disable the override. 3045 * 3046 * @see android.provider.Settings.System#SCREEN_AUTO_BRIGHTNESS_ADJ 3047 */ 3048 @Override // Binder call 3049 public void setTemporaryScreenAutoBrightnessAdjustmentSettingOverride(float adj) { 3050 mContext.enforceCallingOrSelfPermission( 3051 android.Manifest.permission.DEVICE_POWER, null); 3052 3053 final long ident = Binder.clearCallingIdentity(); 3054 try { 3055 setTemporaryScreenAutoBrightnessAdjustmentSettingOverrideInternal(adj); 3056 } finally { 3057 Binder.restoreCallingIdentity(ident); 3058 } 3059 } 3060 3061 /** 3062 * Used by the phone application to make the attention LED flash when ringing. 3063 */ 3064 @Override // Binder call 3065 public void setAttentionLight(boolean on, int color) { 3066 mContext.enforceCallingOrSelfPermission( 3067 android.Manifest.permission.DEVICE_POWER, null); 3068 3069 final long ident = Binder.clearCallingIdentity(); 3070 try { 3071 setAttentionLightInternal(on, color); 3072 } finally { 3073 Binder.restoreCallingIdentity(ident); 3074 } 3075 } 3076 3077 @Override // Binder call 3078 protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { 3079 if (mContext.checkCallingOrSelfPermission(Manifest.permission.DUMP) 3080 != PackageManager.PERMISSION_GRANTED) { 3081 pw.println("Permission Denial: can't dump PowerManager from from pid=" 3082 + Binder.getCallingPid() 3083 + ", uid=" + Binder.getCallingUid()); 3084 return; 3085 } 3086 3087 final long ident = Binder.clearCallingIdentity(); 3088 try { 3089 dumpInternal(pw); 3090 } finally { 3091 Binder.restoreCallingIdentity(ident); 3092 } 3093 } 3094 } 3095 3096 private final class LocalService extends PowerManagerInternal { 3097 @Override 3098 public void setScreenBrightnessOverrideFromWindowManager(int screenBrightness) { 3099 if (screenBrightness < PowerManager.BRIGHTNESS_DEFAULT 3100 || screenBrightness > PowerManager.BRIGHTNESS_ON) { 3101 screenBrightness = PowerManager.BRIGHTNESS_DEFAULT; 3102 } 3103 setScreenBrightnessOverrideFromWindowManagerInternal(screenBrightness); 3104 } 3105 3106 @Override 3107 public void setButtonBrightnessOverrideFromWindowManager(int screenBrightness) { 3108 // Do nothing. 3109 // Button lights are not currently supported in the new implementation. 3110 } 3111 3112 @Override 3113 public void setDozeOverrideFromDreamManager(int screenState, int screenBrightness) { 3114 switch (screenState) { 3115 case Display.STATE_UNKNOWN: 3116 case Display.STATE_OFF: 3117 case Display.STATE_DOZE: 3118 case Display.STATE_DOZE_SUSPEND: 3119 case Display.STATE_ON: 3120 break; 3121 default: 3122 screenState = Display.STATE_UNKNOWN; 3123 break; 3124 } 3125 if (screenBrightness < PowerManager.BRIGHTNESS_DEFAULT 3126 || screenBrightness > PowerManager.BRIGHTNESS_ON) { 3127 screenBrightness = PowerManager.BRIGHTNESS_DEFAULT; 3128 } 3129 setDozeOverrideFromDreamManagerInternal(screenState, screenBrightness); 3130 } 3131 3132 @Override 3133 public void setUserActivityTimeoutOverrideFromWindowManager(long timeoutMillis) { 3134 setUserActivityTimeoutOverrideFromWindowManagerInternal(timeoutMillis); 3135 } 3136 3137 @Override 3138 public boolean getLowPowerModeEnabled() { 3139 synchronized (mLock) { 3140 return mLowPowerModeEnabled; 3141 } 3142 } 3143 3144 @Override 3145 public void registerLowPowerModeObserver(LowPowerModeListener listener) { 3146 synchronized (mLock) { 3147 mLowPowerModeListeners.add(listener); 3148 } 3149 } 3150 } 3151} 3152