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