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