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