19066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project/* 29066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Copyright (C) 2007 The Android Open Source Project 39066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 49066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Licensed under the Apache License, Version 2.0 (the "License"); 59066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * you may not use this file except in compliance with the License. 69066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * You may obtain a copy of the License at 79066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 89066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * http://www.apache.org/licenses/LICENSE-2.0 99066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 109066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Unless required by applicable law or agreed to in writing, software 119066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * distributed under the License is distributed on an "AS IS" BASIS, 129066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 139066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * See the License for the specific language governing permissions and 149066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * limitations under the License. 159066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 169066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 179066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectpackage android.os; 189066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 199630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brownimport android.content.Context; 209066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectimport android.util.Log; 219066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 229066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project/** 231244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * This class gives you control of the power state of the device. 241244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * 251244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * <p> 261244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * <b>Device battery life will be significantly affected by the use of this API.</b> 271244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Do not acquire {@link WakeLock}s unless you really need them, use the minimum levels 281244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * possible, and be sure to release them as soon as possible. 291244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p><p> 301244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * You can obtain an instance of this class by calling 319066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * {@link android.content.Context#getSystemService(java.lang.String) Context.getSystemService()}. 321244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p><p> 331244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * The primary API you'll use is {@link #newWakeLock(int, String) newWakeLock()}. 341244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * This will create a {@link PowerManager.WakeLock} object. You can then use methods 351244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * on the wake lock object to control the power state of the device. 361244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p><p> 371244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * In practice it's quite simple: 389066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * {@samplecode 399066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE); 409066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * PowerManager.WakeLock wl = pm.newWakeLock(PowerManager.SCREEN_DIM_WAKE_LOCK, "My Tag"); 419066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * wl.acquire(); 429066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * ..screen will stay on during this section.. 439066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * wl.release(); 449066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * } 451244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p><p> 469630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * The following wake lock levels are defined, with varying effects on system power. 479630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * <i>These levels are mutually exclusive - you may only specify one of them.</i> 489066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 497b9a28892b1821a657bc9de5245528557d15a154Dirk Dougherty * <table> 509066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * <tr><th>Flag Value</th> 519066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * <th>CPU</th> <th>Screen</th> <th>Keyboard</th></tr> 529066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 537b9a28892b1821a657bc9de5245528557d15a154Dirk Dougherty * <tr><td>{@link #PARTIAL_WAKE_LOCK}</td> 549066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * <td>On*</td> <td>Off</td> <td>Off</td> 559066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * </tr> 569066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 577b9a28892b1821a657bc9de5245528557d15a154Dirk Dougherty * <tr><td>{@link #SCREEN_DIM_WAKE_LOCK}</td> 589066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * <td>On</td> <td>Dim</td> <td>Off</td> 599066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * </tr> 609066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 617b9a28892b1821a657bc9de5245528557d15a154Dirk Dougherty * <tr><td>{@link #SCREEN_BRIGHT_WAKE_LOCK}</td> 629066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * <td>On</td> <td>Bright</td> <td>Off</td> 639066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * </tr> 649066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 657b9a28892b1821a657bc9de5245528557d15a154Dirk Dougherty * <tr><td>{@link #FULL_WAKE_LOCK}</td> 669066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * <td>On</td> <td>Bright</td> <td>Bright</td> 679066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * </tr> 689066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * </table> 691244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p><p> 701244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * *<i>If you hold a partial wake lock, the CPU will continue to run, regardless of any 711244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * display timeouts or the state of the screen and even after the user presses the power button. 721244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * In all other wake locks, the CPU will run, but the user can still put the device to sleep 731244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * using the power button.</i> 741244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p><p> 751244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * In addition, you can add two more flags, which affect behavior of the screen only. 767b9a28892b1821a657bc9de5245528557d15a154Dirk Dougherty * <i>These flags have no effect when combined with a {@link #PARTIAL_WAKE_LOCK}.</i></p> 779066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 787b9a28892b1821a657bc9de5245528557d15a154Dirk Dougherty * <table> 799066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * <tr><th>Flag Value</th> <th>Description</th></tr> 809066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 817b9a28892b1821a657bc9de5245528557d15a154Dirk Dougherty * <tr><td>{@link #ACQUIRE_CAUSES_WAKEUP}</td> 829066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * <td>Normal wake locks don't actually turn on the illumination. Instead, they cause 839066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * the illumination to remain on once it turns on (e.g. from user activity). This flag 849066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * will force the screen and/or keyboard to turn on immediately, when the WakeLock is 859066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * acquired. A typical use would be for notifications which are important for the user to 869066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * see immediately.</td> 879066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * </tr> 889066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 897b9a28892b1821a657bc9de5245528557d15a154Dirk Dougherty * <tr><td>{@link #ON_AFTER_RELEASE}</td> 909066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * <td>If this flag is set, the user activity timer will be reset when the WakeLock is 919066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * released, causing the illumination to remain on a bit longer. This can be used to 929066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * reduce flicker if you are cycling between wake lock conditions.</td> 939066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * </tr> 949066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * </table> 957b9a28892b1821a657bc9de5245528557d15a154Dirk Dougherty * <p> 96d710fb500c121b3f9563ccfbe488f7c9d3ec4985Kenny Root * Any application using a WakeLock must request the {@code android.permission.WAKE_LOCK} 97d710fb500c121b3f9563ccfbe488f7c9d3ec4985Kenny Root * permission in an {@code <uses-permission>} element of the application's manifest. 981244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p> 999066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1001244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brownpublic final class PowerManager { 1019066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project private static final String TAG = "PowerManager"; 1021244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown 103155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown /* NOTE: Wake lock levels were previously defined as a bit field, except that only a few 104155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * combinations were actually supported so the bit field was removed. This explains 105155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * why the numbering scheme is so odd. If adding a new wake lock level, any unused 106155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * value can be used. 1079066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1089066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 1099066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 1101244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Wake lock level: Ensures that the CPU is running; the screen and keyboard 1111244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * backlight will be allowed to go off. 112155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * <p> 113155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * If the user presses the power button, then the screen will be turned off 114155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * but the CPU will be kept on until all partial wake locks have been released. 115155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * </p> 1169066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 117155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown public static final int PARTIAL_WAKE_LOCK = 0x00000001; 1189066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 1199066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 120155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * Wake lock level: Ensures that the screen is on (but may be dimmed); 121155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * the keyboard backlight will be allowed to go off. 122155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * <p> 123155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * If the user presses the power button, then the {@link #SCREEN_DIM_WAKE_LOCK} will be 124155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * implicitly released by the system, causing both the screen and the CPU to be turned off. 125155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * Contrast with {@link #PARTIAL_WAKE_LOCK}. 126155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * </p> 1279567a66a5e6f49dd8495fb5f6e2efb9f32e84b35Dianne Hackborn * 128155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * @deprecated Most applications should use 1291244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * {@link android.view.WindowManager.LayoutParams#FLAG_KEEP_SCREEN_ON} instead 130155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * of this type of wake lock, as it will be correctly managed by the platform 131155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * as the user moves between applications and doesn't require a special permission. 1329066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 133155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown @Deprecated 134155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown public static final int SCREEN_DIM_WAKE_LOCK = 0x00000006; 1359066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 1369066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 1371244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Wake lock level: Ensures that the screen is on at full brightness; 1381244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * the keyboard backlight will be allowed to go off. 139155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * <p> 140155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * If the user presses the power button, then the {@link #SCREEN_BRIGHT_WAKE_LOCK} will be 141155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * implicitly released by the system, causing both the screen and the CPU to be turned off. 142155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * Contrast with {@link #PARTIAL_WAKE_LOCK}. 143155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * </p> 1441244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * 1459567a66a5e6f49dd8495fb5f6e2efb9f32e84b35Dianne Hackborn * @deprecated Most applications should use 1469567a66a5e6f49dd8495fb5f6e2efb9f32e84b35Dianne Hackborn * {@link android.view.WindowManager.LayoutParams#FLAG_KEEP_SCREEN_ON} instead 1479567a66a5e6f49dd8495fb5f6e2efb9f32e84b35Dianne Hackborn * of this type of wake lock, as it will be correctly managed by the platform 1489567a66a5e6f49dd8495fb5f6e2efb9f32e84b35Dianne Hackborn * as the user moves between applications and doesn't require a special permission. 1499066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1509567a66a5e6f49dd8495fb5f6e2efb9f32e84b35Dianne Hackborn @Deprecated 151155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown public static final int SCREEN_BRIGHT_WAKE_LOCK = 0x0000000a; 1529066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 1539066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 154155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * Wake lock level: Ensures that the screen and keyboard backlight are on at 155155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * full brightness. 156155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * <p> 157155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * If the user presses the power button, then the {@link #FULL_WAKE_LOCK} will be 158155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * implicitly released by the system, causing both the screen and the CPU to be turned off. 159155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * Contrast with {@link #PARTIAL_WAKE_LOCK}. 160155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * </p> 161155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * 162155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * @deprecated Most applications should use 163155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * {@link android.view.WindowManager.LayoutParams#FLAG_KEEP_SCREEN_ON} instead 164155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * of this type of wake lock, as it will be correctly managed by the platform 165155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * as the user moves between applications and doesn't require a special permission. 1669066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 167155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown @Deprecated 168155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown public static final int FULL_WAKE_LOCK = 0x0000001a; 1699066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 1709066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 1711244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Wake lock level: Turns the screen off when the proximity sensor activates. 1721244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * <p> 17393cbbb25a56356cd36523809783a277fe92e312eJeff Brown * If the proximity sensor detects that an object is nearby, the screen turns off 17493cbbb25a56356cd36523809783a277fe92e312eJeff Brown * immediately. Shortly after the object moves away, the screen turns on again. 17593cbbb25a56356cd36523809783a277fe92e312eJeff Brown * </p><p> 17693cbbb25a56356cd36523809783a277fe92e312eJeff Brown * A proximity wake lock does not prevent the device from falling asleep 17793cbbb25a56356cd36523809783a277fe92e312eJeff Brown * unlike {@link #FULL_WAKE_LOCK}, {@link #SCREEN_BRIGHT_WAKE_LOCK} and 17893cbbb25a56356cd36523809783a277fe92e312eJeff Brown * {@link #SCREEN_DIM_WAKE_LOCK}. If there is no user activity and no other 17993cbbb25a56356cd36523809783a277fe92e312eJeff Brown * wake locks are held, then the device will fall asleep (and lock) as usual. 18093cbbb25a56356cd36523809783a277fe92e312eJeff Brown * However, the device will not fall asleep while the screen has been turned off 18193cbbb25a56356cd36523809783a277fe92e312eJeff Brown * by the proximity sensor because it effectively counts as ongoing user activity. 18293cbbb25a56356cd36523809783a277fe92e312eJeff Brown * </p><p> 1839630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * Since not all devices have proximity sensors, use {@link #isWakeLockLevelSupported} 1841244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * to determine whether this wake lock level is supported. 1856edb6db512198aa0eef66341d163926b3531bca3Craig Mautner * </p><p> 1866edb6db512198aa0eef66341d163926b3531bca3Craig Mautner * Cannot be used with {@link #ACQUIRE_CAUSES_WAKEUP}. 1871244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p> 188bc706a03a25f0dfe2cb0ecd1f6e4f7be905592a7Mike Lockwood * 189bc706a03a25f0dfe2cb0ecd1f6e4f7be905592a7Mike Lockwood * {@hide} 190bc706a03a25f0dfe2cb0ecd1f6e4f7be905592a7Mike Lockwood */ 191155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown public static final int PROXIMITY_SCREEN_OFF_WAKE_LOCK = 0x00000020; 192bc706a03a25f0dfe2cb0ecd1f6e4f7be905592a7Mike Lockwood 193bc706a03a25f0dfe2cb0ecd1f6e4f7be905592a7Mike Lockwood /** 194155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * Mask for the wake lock level component of a combined wake lock level and flags integer. 1950e39ea83c5578e0d55e120c91ff7cfeeb0c1cb2fMike Lockwood * 196155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * @hide 1970e39ea83c5578e0d55e120c91ff7cfeeb0c1cb2fMike Lockwood */ 198155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown public static final int WAKE_LOCK_LEVEL_MASK = 0x0000ffff; 1990e39ea83c5578e0d55e120c91ff7cfeeb0c1cb2fMike Lockwood 2000e39ea83c5578e0d55e120c91ff7cfeeb0c1cb2fMike Lockwood /** 2011244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Wake lock flag: Turn the screen on when the wake lock is acquired. 2021244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * <p> 2039066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Normally wake locks don't actually wake the device, they just cause 2041244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * the screen to remain on once it's already on. Think of the video player 2051244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * application as the normal behavior. Notifications that pop up and want 2069066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * the device to be on are the exception; use this flag to be like them. 2071244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p><p> 2081244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Cannot be used with {@link #PARTIAL_WAKE_LOCK}. 2091244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p> 2109066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 211155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown public static final int ACQUIRE_CAUSES_WAKEUP = 0x10000000; 2129066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 2139066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 2141244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Wake lock flag: When this wake lock is released, poke the user activity timer 2159066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * so the screen stays on for a little longer. 2169066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * <p> 2171244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Will not turn the screen on if it is not already on. 2181244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * See {@link #ACQUIRE_CAUSES_WAKEUP} if you want that. 2191244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p><p> 2201244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Cannot be used with {@link #PARTIAL_WAKE_LOCK}. 2211244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p> 2229066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 223155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown public static final int ON_AFTER_RELEASE = 0x20000000; 224155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown 225155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown /** 226155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * Flag for {@link WakeLock#release release(int)} to defer releasing a 227713df150b92a0a5eea877f99405e31eefbf93a09Dianne Hackborn * {@link #PROXIMITY_SCREEN_OFF_WAKE_LOCK} wake lock until the proximity sensor returns 228155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * a negative value. 229155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * 230155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * {@hide} 231155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown */ 232155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown public static final int WAIT_FOR_PROXIMITY_NEGATIVE = 1; 2337304c343821309dd15f769b18f1de2fa43751573Jeff Brown 2347304c343821309dd15f769b18f1de2fa43751573Jeff Brown /** 2357304c343821309dd15f769b18f1de2fa43751573Jeff Brown * Brightness value for fully on. 2367304c343821309dd15f769b18f1de2fa43751573Jeff Brown * @hide 2377304c343821309dd15f769b18f1de2fa43751573Jeff Brown */ 2387304c343821309dd15f769b18f1de2fa43751573Jeff Brown public static final int BRIGHTNESS_ON = 255; 2397304c343821309dd15f769b18f1de2fa43751573Jeff Brown 2407304c343821309dd15f769b18f1de2fa43751573Jeff Brown /** 2419630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * Brightness value for fully off. 2427304c343821309dd15f769b18f1de2fa43751573Jeff Brown * @hide 2437304c343821309dd15f769b18f1de2fa43751573Jeff Brown */ 2449630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown public static final int BRIGHTNESS_OFF = 0; 2457304c343821309dd15f769b18f1de2fa43751573Jeff Brown 246b696de5c10ebcc7bf42d8487fc0e56e0e937754dJeff Brown // Note: Be sure to update android.os.BatteryStats and PowerManager.h 247b696de5c10ebcc7bf42d8487fc0e56e0e937754dJeff Brown // if adding or modifying user activity event constants. 248b696de5c10ebcc7bf42d8487fc0e56e0e937754dJeff Brown 249b696de5c10ebcc7bf42d8487fc0e56e0e937754dJeff Brown /** 250b696de5c10ebcc7bf42d8487fc0e56e0e937754dJeff Brown * User activity event type: Unspecified event type. 251b696de5c10ebcc7bf42d8487fc0e56e0e937754dJeff Brown * @hide 252b696de5c10ebcc7bf42d8487fc0e56e0e937754dJeff Brown */ 253b696de5c10ebcc7bf42d8487fc0e56e0e937754dJeff Brown public static final int USER_ACTIVITY_EVENT_OTHER = 0; 254b696de5c10ebcc7bf42d8487fc0e56e0e937754dJeff Brown 255b696de5c10ebcc7bf42d8487fc0e56e0e937754dJeff Brown /** 256b696de5c10ebcc7bf42d8487fc0e56e0e937754dJeff Brown * User activity event type: Button or key pressed or released. 257b696de5c10ebcc7bf42d8487fc0e56e0e937754dJeff Brown * @hide 258b696de5c10ebcc7bf42d8487fc0e56e0e937754dJeff Brown */ 259b696de5c10ebcc7bf42d8487fc0e56e0e937754dJeff Brown public static final int USER_ACTIVITY_EVENT_BUTTON = 1; 260b696de5c10ebcc7bf42d8487fc0e56e0e937754dJeff Brown 261b696de5c10ebcc7bf42d8487fc0e56e0e937754dJeff Brown /** 262b696de5c10ebcc7bf42d8487fc0e56e0e937754dJeff Brown * User activity event type: Touch down, move or up. 263b696de5c10ebcc7bf42d8487fc0e56e0e937754dJeff Brown * @hide 264b696de5c10ebcc7bf42d8487fc0e56e0e937754dJeff Brown */ 265b696de5c10ebcc7bf42d8487fc0e56e0e937754dJeff Brown public static final int USER_ACTIVITY_EVENT_TOUCH = 2; 266b696de5c10ebcc7bf42d8487fc0e56e0e937754dJeff Brown 2679630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown /** 2689630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * User activity flag: Do not restart the user activity timeout or brighten 2699630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * the display in response to user activity if it is already dimmed. 2709630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * @hide 2719630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown */ 2729630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown public static final int USER_ACTIVITY_FLAG_NO_CHANGE_LIGHTS = 1 << 0; 2739630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown 2749630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown /** 2759630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * Go to sleep reason code: Going to sleep due by user request. 2769630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * @hide 2779630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown */ 2789630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown public static final int GO_TO_SLEEP_REASON_USER = 0; 2799630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown 2809630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown /** 2819630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * Go to sleep reason code: Going to sleep due by request of the 2829630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * device administration policy. 2839630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * @hide 2849630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown */ 2859630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown public static final int GO_TO_SLEEP_REASON_DEVICE_ADMIN = 1; 2869630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown 2879630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown /** 2889630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * Go to sleep reason code: Going to sleep due to a screen timeout. 2899630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * @hide 2909630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown */ 2919630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown public static final int GO_TO_SLEEP_REASON_TIMEOUT = 2; 2929630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown 2939630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown final Context mContext; 2941244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown final IPowerManager mService; 2951244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown final Handler mHandler; 2961244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown 2971244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown /** 2981244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * {@hide} 2991244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown */ 3009630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown public PowerManager(Context context, IPowerManager service, Handler handler) { 3019630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown mContext = context; 3021244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown mService = service; 3031244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown mHandler = handler; 3041244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 3051244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown 3061244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown /** 3079630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * Gets the minimum supported screen brightness setting. 3089630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * The screen may be allowed to become dimmer than this value but 3099630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * this is the minimum value that can be set by the user. 3109630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * @hide 3119630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown */ 3129630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown public int getMinimumScreenBrightnessSetting() { 3139630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown return mContext.getResources().getInteger( 314f9bba13692c10ff99a52f79d6d0f04c96117ff57Jeff Brown com.android.internal.R.integer.config_screenBrightnessSettingMinimum); 3159630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown } 3169630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown 3179630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown /** 3189630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * Gets the maximum supported screen brightness setting. 3199630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * The screen may be allowed to become dimmer than this value but 3209630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * this is the maximum value that can be set by the user. 3219630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * @hide 3229630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown */ 3239630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown public int getMaximumScreenBrightnessSetting() { 324f9bba13692c10ff99a52f79d6d0f04c96117ff57Jeff Brown return mContext.getResources().getInteger( 325f9bba13692c10ff99a52f79d6d0f04c96117ff57Jeff Brown com.android.internal.R.integer.config_screenBrightnessSettingMaximum); 3269630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown } 3279630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown 3289630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown /** 3299630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * Gets the default screen brightness setting. 3309630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * @hide 3319630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown */ 3329630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown public int getDefaultScreenBrightnessSetting() { 333f9bba13692c10ff99a52f79d6d0f04c96117ff57Jeff Brown return mContext.getResources().getInteger( 334f9bba13692c10ff99a52f79d6d0f04c96117ff57Jeff Brown com.android.internal.R.integer.config_screenBrightnessSettingDefault); 3359630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown } 3369630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown 3379630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown /** 338631938f26dbc89e7e9530bb85d9f37706dba59f3Jeff Brown * Returns true if the screen auto-brightness adjustment setting should 339631938f26dbc89e7e9530bb85d9f37706dba59f3Jeff Brown * be available in the UI. This setting is experimental and disabled by default. 340631938f26dbc89e7e9530bb85d9f37706dba59f3Jeff Brown * @hide 341631938f26dbc89e7e9530bb85d9f37706dba59f3Jeff Brown */ 342631938f26dbc89e7e9530bb85d9f37706dba59f3Jeff Brown public static boolean useScreenAutoBrightnessAdjustmentFeature() { 343631938f26dbc89e7e9530bb85d9f37706dba59f3Jeff Brown return SystemProperties.getBoolean("persist.power.useautobrightadj", false); 344631938f26dbc89e7e9530bb85d9f37706dba59f3Jeff Brown } 345631938f26dbc89e7e9530bb85d9f37706dba59f3Jeff Brown 346631938f26dbc89e7e9530bb85d9f37706dba59f3Jeff Brown /** 347db21284a7fb081065d26137891594bd8495b116fJeff Brown * Returns true if the twilight service should be used to adjust screen brightness 348db21284a7fb081065d26137891594bd8495b116fJeff Brown * policy. This setting is experimental and disabled by default. 349db21284a7fb081065d26137891594bd8495b116fJeff Brown * @hide 350db21284a7fb081065d26137891594bd8495b116fJeff Brown */ 351db21284a7fb081065d26137891594bd8495b116fJeff Brown public static boolean useTwilightAdjustmentFeature() { 352db21284a7fb081065d26137891594bd8495b116fJeff Brown return SystemProperties.getBoolean("persist.power.usetwilightadj", false); 353db21284a7fb081065d26137891594bd8495b116fJeff Brown } 354db21284a7fb081065d26137891594bd8495b116fJeff Brown 355db21284a7fb081065d26137891594bd8495b116fJeff Brown /** 3561244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Creates a new wake lock with the specified level and flags. 3571244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * <p> 3581244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * The {@code levelAndFlags} parameter specifies a wake lock level and optional flags 3591244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * combined using the logical OR operator. 3601244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p><p> 3611244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * The wake lock levels are: {@link #PARTIAL_WAKE_LOCK}, 3621244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * {@link #FULL_WAKE_LOCK}, {@link #SCREEN_DIM_WAKE_LOCK} 3631244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * and {@link #SCREEN_BRIGHT_WAKE_LOCK}. Exactly one wake lock level must be 3641244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * specified as part of the {@code levelAndFlags} parameter. 3651244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p><p> 3661244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * The wake lock flags are: {@link #ACQUIRE_CAUSES_WAKEUP} 3671244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * and {@link #ON_AFTER_RELEASE}. Multiple flags can be combined as part of the 3681244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * {@code levelAndFlags} parameters. 3691244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p><p> 3701244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Call {@link WakeLock#acquire() acquire()} on the object to acquire the 3711244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * wake lock, and {@link WakeLock#release release()} when you are done. 3721244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p><p> 3731244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * {@samplecode 3741244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * PowerManager pm = (PowerManager)mContext.getSystemService( 3751244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Context.POWER_SERVICE); 3761244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * PowerManager.WakeLock wl = pm.newWakeLock( 3771244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * PowerManager.SCREEN_DIM_WAKE_LOCK 3781244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * | PowerManager.ON_AFTER_RELEASE, 3791244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * TAG); 3801244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * wl.acquire(); 3811244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * // ... do work... 3821244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * wl.release(); 3831244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * } 3841244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p><p> 3851244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Although a wake lock can be created without special permissions, 3861244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * the {@link android.Manifest.permission#WAKE_LOCK} permission is 3871244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * required to actually acquire or release the wake lock that is returned. 3881244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p><p class="note"> 3891244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * If using this to keep the screen on, you should strongly consider using 3901244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * {@link android.view.WindowManager.LayoutParams#FLAG_KEEP_SCREEN_ON} instead. 3911244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * This window flag will be correctly managed by the platform 3921244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * as the user moves between applications and doesn't require a special permission. 3931244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p> 3941244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * 3951244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * @param levelAndFlags Combination of wake lock level and flag values defining 3961244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * the requested behavior of the WakeLock. 3971244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * @param tag Your class name (or other tag) for debugging purposes. 3981244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * 3991244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * @see WakeLock#acquire() 4001244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * @see WakeLock#release() 4011244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * @see #PARTIAL_WAKE_LOCK 4021244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * @see #FULL_WAKE_LOCK 4031244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * @see #SCREEN_DIM_WAKE_LOCK 4041244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * @see #SCREEN_BRIGHT_WAKE_LOCK 4051244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * @see #ACQUIRE_CAUSES_WAKEUP 4061244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * @see #ON_AFTER_RELEASE 4071244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown */ 4081244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown public WakeLock newWakeLock(int levelAndFlags, String tag) { 409155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown validateWakeLockParameters(levelAndFlags, tag); 41095d785346b4dae808a2d8f77356175e55a572d96Dianne Hackborn return new WakeLock(levelAndFlags, tag, mContext.getOpPackageName()); 411155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown } 412155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown 413155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown /** @hide */ 414155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown public static void validateWakeLockParameters(int levelAndFlags, String tag) { 415155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown switch (levelAndFlags & WAKE_LOCK_LEVEL_MASK) { 416155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown case PARTIAL_WAKE_LOCK: 417155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown case SCREEN_DIM_WAKE_LOCK: 418155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown case SCREEN_BRIGHT_WAKE_LOCK: 419155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown case FULL_WAKE_LOCK: 420155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown case PROXIMITY_SCREEN_OFF_WAKE_LOCK: 421155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown break; 422155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown default: 423155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown throw new IllegalArgumentException("Must specify a valid wake lock level."); 4241244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 4251244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown if (tag == null) { 4261244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown throw new IllegalArgumentException("The tag must not be null."); 4271244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 4281244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 4291244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown 4301244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown /** 4311244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Notifies the power manager that user activity happened. 4321244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * <p> 4339630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * Resets the auto-off timer and brightens the screen if the device 4349630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * is not asleep. This is what happens normally when a key or the touch 4359630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * screen is pressed or when some other user activity occurs. 4369630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * This method does not wake up the device if it has been put to sleep. 4371244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p><p> 4381244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Requires the {@link android.Manifest.permission#DEVICE_POWER} permission. 4391244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p> 4401244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * 4411244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * @param when The time of the user activity, in the {@link SystemClock#uptimeMillis()} 44262c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * time base. This timestamp is used to correctly order the user activity request with 4431244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * other power management functions. It should be set 4441244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * to the timestamp of the input event that caused the user activity. 4451244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * @param noChangeLights If true, does not cause the keyboard backlight to turn on 4461244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * because of this event. This is set when the power key is pressed. 4471244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * We want the device to stay on while the button is down, but we're about 4481244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * to turn off the screen so we don't want the keyboard backlight to turn on again. 4491244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Otherwise the lights flash on and then off and it looks weird. 4509630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * 4519630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * @see #wakeUp 4529630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * @see #goToSleep 4531244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown */ 4541244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown public void userActivity(long when, boolean noChangeLights) { 4551244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown try { 4569630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown mService.userActivity(when, USER_ACTIVITY_EVENT_OTHER, 4579630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown noChangeLights ? USER_ACTIVITY_FLAG_NO_CHANGE_LIGHTS : 0); 4581244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } catch (RemoteException e) { 4591244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 4601244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 4611244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown 4621244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown /** 4631244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Forces the device to go to sleep. 4641244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * <p> 4659630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * Overrides all the wake locks that are held. 4669630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * This is what happens when the power key is pressed to turn off the screen. 4671244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p><p> 4681244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Requires the {@link android.Manifest.permission#DEVICE_POWER} permission. 4691244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p> 4701244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * 4711244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * @param time The time when the request to go to sleep was issued, in the 4721244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * {@link SystemClock#uptimeMillis()} time base. This timestamp is used to correctly 47362c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * order the go to sleep request with other power management functions. It should be set 4741244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * to the timestamp of the input event that caused the request to go to sleep. 4759630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * 4769630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * @see #userActivity 4779630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * @see #wakeUp 4781244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown */ 4791244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown public void goToSleep(long time) { 4801244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown try { 4819630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown mService.goToSleep(time, GO_TO_SLEEP_REASON_USER); 4829630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown } catch (RemoteException e) { 4839630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown } 4849630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown } 4859630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown 4869630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown /** 4879630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * Forces the device to wake up from sleep. 4889630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * <p> 4899630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * If the device is currently asleep, wakes it up, otherwise does nothing. 4909630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * This is what happens when the power key is pressed to turn on the screen. 4919630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * </p><p> 4929630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * Requires the {@link android.Manifest.permission#DEVICE_POWER} permission. 4939630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * </p> 4949630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * 4959630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * @param time The time when the request to wake up was issued, in the 4969630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * {@link SystemClock#uptimeMillis()} time base. This timestamp is used to correctly 49762c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * order the wake up request with other power management functions. It should be set 4989630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * to the timestamp of the input event that caused the request to wake up. 4999630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * 5009630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * @see #userActivity 5019630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * @see #goToSleep 5029630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown */ 5039630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown public void wakeUp(long time) { 5049630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown try { 5059630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown mService.wakeUp(time); 5061244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } catch (RemoteException e) { 5071244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 5081244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 5091244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown 5101244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown /** 51162c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * Forces the device to start napping. 51262c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * <p> 51362c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * If the device is currently awake, starts dreaming, otherwise does nothing. 51462c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * When the dream ends or if the dream cannot be started, the device will 51562c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * either wake up or go to sleep depending on whether there has been recent 51662c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * user activity. 51762c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * </p><p> 51862c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * Requires the {@link android.Manifest.permission#DEVICE_POWER} permission. 51962c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * </p> 52062c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * 52162c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * @param time The time when the request to nap was issued, in the 52262c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * {@link SystemClock#uptimeMillis()} time base. This timestamp is used to correctly 52362c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * order the nap request with other power management functions. It should be set 52462c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * to the timestamp of the input event that caused the request to nap. 52562c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * 52662c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * @see #wakeUp 52762c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * @see #goToSleep 52862c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * 52962c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * @hide 53062c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown */ 53162c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown public void nap(long time) { 53262c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown try { 53362c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown mService.nap(time); 53462c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown } catch (RemoteException e) { 53562c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown } 53662c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown } 53762c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown 53862c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown /** 5391244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Sets the brightness of the backlights (screen, keyboard, button). 5401244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * <p> 5411244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Requires the {@link android.Manifest.permission#DEVICE_POWER} permission. 5421244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p> 5431244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * 5441244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * @param brightness The brightness value from 0 to 255. 5451244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * 5461244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * {@hide} 5471244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown */ 5481244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown public void setBacklightBrightness(int brightness) { 5491244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown try { 5509630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown mService.setTemporaryScreenBrightnessSettingOverride(brightness); 5511244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } catch (RemoteException e) { 5521244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 5531244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 5541244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown 5551244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown /** 5569630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * Returns true if the specified wake lock level is supported. 5571244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * 5589630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * @param level The wake lock level to check. 5599630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * @return True if the specified wake lock level is supported. 5601244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * 5611244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * {@hide} 5621244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown */ 5639630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown public boolean isWakeLockLevelSupported(int level) { 5641244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown try { 5659630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown return mService.isWakeLockLevelSupported(level); 5661244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } catch (RemoteException e) { 5679630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown return false; 5681244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 5691244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 5701244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown 5711244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown /** 5721244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Returns whether the screen is currently on. 5731244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * <p> 5741244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Only indicates whether the screen is on. The screen could be either bright or dim. 5751244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p><p> 5761244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * {@samplecode 5771244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE); 5781244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * boolean isScreenOn = pm.isScreenOn(); 5791244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * } 5801244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p> 5811244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * 5821244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * @return whether the screen is on (bright or dim). 5831244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown */ 5841244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown public boolean isScreenOn() { 5851244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown try { 5861244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown return mService.isScreenOn(); 5871244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } catch (RemoteException e) { 5881244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown return false; 5891244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 5901244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 5911244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown 5929066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 5931244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Reboot the device. Will not return if the reboot is successful. 594d710fb500c121b3f9563ccfbe488f7c9d3ec4985Kenny Root * <p> 5951244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Requires the {@link android.Manifest.permission#REBOOT} permission. 5961244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p> 5971244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * 5981244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * @param reason code to pass to the kernel (e.g., "recovery") to 5991244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * request special boot modes, or null. 6001244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown */ 6011244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown public void reboot(String reason) { 6021244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown try { 603c428aae6429c3fd5e2037c3793af399d9f6e23bfDianne Hackborn mService.reboot(false, reason, true); 6041244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } catch (RemoteException e) { 6051244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 6061244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 6071244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown 6081244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown /** 6091244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * A wake lock is a mechanism to indicate that your application needs 6101244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * to have the device stay on. 611d710fb500c121b3f9563ccfbe488f7c9d3ec4985Kenny Root * <p> 612d710fb500c121b3f9563ccfbe488f7c9d3ec4985Kenny Root * Any application using a WakeLock must request the {@code android.permission.WAKE_LOCK} 613d710fb500c121b3f9563ccfbe488f7c9d3ec4985Kenny Root * permission in an {@code <uses-permission>} element of the application's manifest. 6141244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Obtain a wake lock by calling {@link PowerManager#newWakeLock(int, String)}. 6151244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p><p> 6161244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Call {@link #acquire()} to acquire the wake lock and force the device to stay 6171244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * on at the level that was requested when the wake lock was created. 6181244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p><p> 6191244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Call {@link #release()} when you are done and don't need the lock anymore. 6201244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * It is very important to do this as soon as possible to avoid running down the 6211244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * device's battery excessively. 6221244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p> 6239066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 6241244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown public final class WakeLock { 6251244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown private final int mFlags; 6261244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown private final String mTag; 627713df150b92a0a5eea877f99405e31eefbf93a09Dianne Hackborn private final String mPackageName; 6281244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown private final IBinder mToken; 6291244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown private int mCount; 6301244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown private boolean mRefCounted = true; 6311244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown private boolean mHeld; 6321244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown private WorkSource mWorkSource; 6331244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown 6341244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown private final Runnable mReleaser = new Runnable() { 6359066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public void run() { 6369066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project release(); 6379066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 6389066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project }; 6399066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 640713df150b92a0a5eea877f99405e31eefbf93a09Dianne Hackborn WakeLock(int flags, String tag, String packageName) { 6419066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project mFlags = flags; 6429066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project mTag = tag; 643713df150b92a0a5eea877f99405e31eefbf93a09Dianne Hackborn mPackageName = packageName; 6449066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project mToken = new Binder(); 6459066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 6469066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 6471244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown @Override 6481244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown protected void finalize() throws Throwable { 6491244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown synchronized (mToken) { 6501244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown if (mHeld) { 6511244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown Log.wtf(TAG, "WakeLock finalized while still held: " + mTag); 6521244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown try { 6531244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown mService.releaseWakeLock(mToken, 0); 6541244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } catch (RemoteException e) { 6551244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 6561244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 6571244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 6581244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 6591244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown 6609066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 6611244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Sets whether this WakeLock is reference counted. 6621244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * <p> 6631244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Wake locks are reference counted by default. If a wake lock is 6641244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * reference counted, then each call to {@link #acquire()} must be 6651244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * balanced by an equal number of calls to {@link #release()}. If a wake 6661244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * lock is not reference counted, then one call to {@link #release()} is 6671244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * sufficient to undo the effect of all previous calls to {@link #acquire()}. 6681244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p> 6698310b42fbc086b0f05fc8ef45ac34c7e099c485eJoe Onorato * 6701244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * @param value True to make the wake lock reference counted, false to 6711244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * make the wake lock non-reference counted. 6729066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 6731244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown public void setReferenceCounted(boolean value) { 6741244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown synchronized (mToken) { 6751244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown mRefCounted = value; 6761244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 6779066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 6789066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 6799066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 6801244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Acquires the wake lock. 6811244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * <p> 6821244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Ensures that the device is on at the level requested when 6831244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * the wake lock was created. 6841244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p> 6859066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 6861244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown public void acquire() { 6879066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project synchronized (mToken) { 688d7350e3a56daa44e2d2c6e5175e6430492cf0dc9Joe Onorato acquireLocked(); 6899066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 6909066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 691d7350e3a56daa44e2d2c6e5175e6430492cf0dc9Joe Onorato 6929066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 6931244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Acquires the wake lock with a timeout. 6941244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * <p> 6951244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Ensures that the device is on at the level requested when 6961244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * the wake lock was created. The lock will be released after the given timeout 6971244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * expires. 6981244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p> 6991244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * 7001244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * @param timeout The timeout after which to release the wake lock, in milliseconds. 7019066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 7029066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public void acquire(long timeout) { 703d7350e3a56daa44e2d2c6e5175e6430492cf0dc9Joe Onorato synchronized (mToken) { 704d7350e3a56daa44e2d2c6e5175e6430492cf0dc9Joe Onorato acquireLocked(); 705d7350e3a56daa44e2d2c6e5175e6430492cf0dc9Joe Onorato mHandler.postDelayed(mReleaser, timeout); 706d7350e3a56daa44e2d2c6e5175e6430492cf0dc9Joe Onorato } 7079066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 7081244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown 709d7350e3a56daa44e2d2c6e5175e6430492cf0dc9Joe Onorato private void acquireLocked() { 710d7350e3a56daa44e2d2c6e5175e6430492cf0dc9Joe Onorato if (!mRefCounted || mCount++ == 0) { 711ff1baef86c3b34fe2aec33a22bc2d06112af4c03Jeff Brown // Do this even if the wake lock is already thought to be held (mHeld == true) 712ff1baef86c3b34fe2aec33a22bc2d06112af4c03Jeff Brown // because non-reference counted wake locks are not always properly released. 713ff1baef86c3b34fe2aec33a22bc2d06112af4c03Jeff Brown // For example, the keyguard's wake lock might be forcibly released by the 714ff1baef86c3b34fe2aec33a22bc2d06112af4c03Jeff Brown // power manager without the keyguard knowing. A subsequent call to acquire 715ff1baef86c3b34fe2aec33a22bc2d06112af4c03Jeff Brown // should immediately acquire the wake lock once again despite never having 716ff1baef86c3b34fe2aec33a22bc2d06112af4c03Jeff Brown // been explicitly released by the keyguard. 717d7350e3a56daa44e2d2c6e5175e6430492cf0dc9Joe Onorato mHandler.removeCallbacks(mReleaser); 718ff1baef86c3b34fe2aec33a22bc2d06112af4c03Jeff Brown try { 719713df150b92a0a5eea877f99405e31eefbf93a09Dianne Hackborn mService.acquireWakeLock(mToken, mFlags, mTag, mPackageName, mWorkSource); 720ff1baef86c3b34fe2aec33a22bc2d06112af4c03Jeff Brown } catch (RemoteException e) { 721d7350e3a56daa44e2d2c6e5175e6430492cf0dc9Joe Onorato } 722ff1baef86c3b34fe2aec33a22bc2d06112af4c03Jeff Brown mHeld = true; 723d7350e3a56daa44e2d2c6e5175e6430492cf0dc9Joe Onorato } 724d7350e3a56daa44e2d2c6e5175e6430492cf0dc9Joe Onorato } 7259066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 7269066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 7271244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Releases the wake lock. 7289066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * <p> 7291244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * This method releases your claim to the CPU or screen being on. 7301244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * The screen may turn off shortly after you release the wake lock, or it may 7311244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * not if there are other wake locks still held. 7321244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p> 7339066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 734d7350e3a56daa44e2d2c6e5175e6430492cf0dc9Joe Onorato public void release() { 7350e39ea83c5578e0d55e120c91ff7cfeeb0c1cb2fMike Lockwood release(0); 7360e39ea83c5578e0d55e120c91ff7cfeeb0c1cb2fMike Lockwood } 7370e39ea83c5578e0d55e120c91ff7cfeeb0c1cb2fMike Lockwood 7380e39ea83c5578e0d55e120c91ff7cfeeb0c1cb2fMike Lockwood /** 7391244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Releases the wake lock with flags to modify the release behavior. 7400e39ea83c5578e0d55e120c91ff7cfeeb0c1cb2fMike Lockwood * <p> 7411244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * This method releases your claim to the CPU or screen being on. 7421244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * The screen may turn off shortly after you release the wake lock, or it may 7431244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * not if there are other wake locks still held. 7441244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p> 7451244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * 7461244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * @param flags Combination of flag values to modify the release behavior. 7471244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Currently only {@link #WAIT_FOR_PROXIMITY_NEGATIVE} is supported. 7480e39ea83c5578e0d55e120c91ff7cfeeb0c1cb2fMike Lockwood * 7490e39ea83c5578e0d55e120c91ff7cfeeb0c1cb2fMike Lockwood * {@hide} 7500e39ea83c5578e0d55e120c91ff7cfeeb0c1cb2fMike Lockwood */ 751d7350e3a56daa44e2d2c6e5175e6430492cf0dc9Joe Onorato public void release(int flags) { 7529066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project synchronized (mToken) { 7539066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (!mRefCounted || --mCount == 0) { 754b5962e73e841455b8e2a4e2d5c0ef0a19d62a803Jake Hamby mHandler.removeCallbacks(mReleaser); 7551244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown if (mHeld) { 7561244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown try { 7571244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown mService.releaseWakeLock(mToken, flags); 7581244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } catch (RemoteException e) { 7591244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 7601244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown mHeld = false; 7619066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 7629066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 7639066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (mCount < 0) { 7649066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project throw new RuntimeException("WakeLock under-locked " + mTag); 7659066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 7669066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 7679066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 7689066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 7691244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown /** 7701244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Returns true if the wake lock has been acquired but not yet released. 7711244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * 7721244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * @return True if the wake lock is held. 7731244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown */ 7741244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown public boolean isHeld() { 7759066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project synchronized (mToken) { 7769066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return mHeld; 7779066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 7789066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 7799066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 7801244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown /** 7811244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Sets the work source associated with the wake lock. 7821244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * <p> 7831244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * The work source is used to determine on behalf of which application 7841244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * the wake lock is being held. This is useful in the case where a 7851244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * service is performing work on behalf of an application so that the 7861244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * cost of that work can be accounted to the application. 7871244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p> 7881244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * 7891244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * @param ws The work source, or null if none. 7901244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown */ 7917e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn public void setWorkSource(WorkSource ws) { 7927e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn synchronized (mToken) { 7937e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn if (ws != null && ws.size() == 0) { 7947e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn ws = null; 7957e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn } 7961244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown 7971244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown final boolean changed; 7987e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn if (ws == null) { 7991244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown changed = mWorkSource != null; 8007e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn mWorkSource = null; 8017e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn } else if (mWorkSource == null) { 8021244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown changed = true; 8037e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn mWorkSource = new WorkSource(ws); 8047e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn } else { 8057e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn changed = mWorkSource.diff(ws); 8067e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn if (changed) { 8077e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn mWorkSource.set(ws); 8087e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn } 8097e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn } 8101244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown 8117e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn if (changed && mHeld) { 8127e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn try { 8137e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn mService.updateWakeLockWorkSource(mToken, mWorkSource); 8147e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn } catch (RemoteException e) { 8157e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn } 8167e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn } 8177e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn } 8187e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn } 8197e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn 8201244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown @Override 8219066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public String toString() { 8229066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project synchronized (mToken) { 8239066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return "WakeLock{" 8249066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project + Integer.toHexString(System.identityHashCode(this)) 8259066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project + " held=" + mHeld + ", refCount=" + mCount + "}"; 8269066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 8279066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 828322591cb4b158dc2edbc3d95cd02e44f132feb5fCharles Mendis } 8299066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project} 830