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