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. 1851244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p> 186bc706a03a25f0dfe2cb0ecd1f6e4f7be905592a7Mike Lockwood * 187bc706a03a25f0dfe2cb0ecd1f6e4f7be905592a7Mike Lockwood * {@hide} 188bc706a03a25f0dfe2cb0ecd1f6e4f7be905592a7Mike Lockwood */ 189155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown public static final int PROXIMITY_SCREEN_OFF_WAKE_LOCK = 0x00000020; 190bc706a03a25f0dfe2cb0ecd1f6e4f7be905592a7Mike Lockwood 191bc706a03a25f0dfe2cb0ecd1f6e4f7be905592a7Mike Lockwood /** 192155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * Mask for the wake lock level component of a combined wake lock level and flags integer. 1930e39ea83c5578e0d55e120c91ff7cfeeb0c1cb2fMike Lockwood * 194155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * @hide 1950e39ea83c5578e0d55e120c91ff7cfeeb0c1cb2fMike Lockwood */ 196155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown public static final int WAKE_LOCK_LEVEL_MASK = 0x0000ffff; 1970e39ea83c5578e0d55e120c91ff7cfeeb0c1cb2fMike Lockwood 1980e39ea83c5578e0d55e120c91ff7cfeeb0c1cb2fMike Lockwood /** 1991244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Wake lock flag: Turn the screen on when the wake lock is acquired. 2001244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * <p> 2019066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Normally wake locks don't actually wake the device, they just cause 2021244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * the screen to remain on once it's already on. Think of the video player 2031244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * application as the normal behavior. Notifications that pop up and want 2049066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * the device to be on are the exception; use this flag to be like them. 2051244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p><p> 2061244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Cannot be used with {@link #PARTIAL_WAKE_LOCK}. 2071244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p> 2089066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 209155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown public static final int ACQUIRE_CAUSES_WAKEUP = 0x10000000; 2109066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 2119066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 2121244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Wake lock flag: When this wake lock is released, poke the user activity timer 2139066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * so the screen stays on for a little longer. 2149066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * <p> 2151244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Will not turn the screen on if it is not already on. 2161244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * See {@link #ACQUIRE_CAUSES_WAKEUP} if you want that. 2171244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p><p> 2181244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Cannot be used with {@link #PARTIAL_WAKE_LOCK}. 2191244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p> 2209066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 221155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown public static final int ON_AFTER_RELEASE = 0x20000000; 222155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown 223155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown /** 224155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * Flag for {@link WakeLock#release release(int)} to defer releasing a 225155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * {@link #WAKE_BIT_PROXIMITY_SCREEN_OFF} wake lock until the proximity sensor returns 226155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * a negative value. 227155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * 228155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown * {@hide} 229155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown */ 230155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown public static final int WAIT_FOR_PROXIMITY_NEGATIVE = 1; 2317304c343821309dd15f769b18f1de2fa43751573Jeff Brown 2327304c343821309dd15f769b18f1de2fa43751573Jeff Brown /** 2337304c343821309dd15f769b18f1de2fa43751573Jeff Brown * Brightness value for fully on. 2347304c343821309dd15f769b18f1de2fa43751573Jeff Brown * @hide 2357304c343821309dd15f769b18f1de2fa43751573Jeff Brown */ 2367304c343821309dd15f769b18f1de2fa43751573Jeff Brown public static final int BRIGHTNESS_ON = 255; 2377304c343821309dd15f769b18f1de2fa43751573Jeff Brown 2387304c343821309dd15f769b18f1de2fa43751573Jeff Brown /** 2399630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * Brightness value for fully off. 2407304c343821309dd15f769b18f1de2fa43751573Jeff Brown * @hide 2417304c343821309dd15f769b18f1de2fa43751573Jeff Brown */ 2429630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown public static final int BRIGHTNESS_OFF = 0; 2437304c343821309dd15f769b18f1de2fa43751573Jeff Brown 244b696de5c10ebcc7bf42d8487fc0e56e0e937754dJeff Brown // Note: Be sure to update android.os.BatteryStats and PowerManager.h 245b696de5c10ebcc7bf42d8487fc0e56e0e937754dJeff Brown // if adding or modifying user activity event constants. 246b696de5c10ebcc7bf42d8487fc0e56e0e937754dJeff Brown 247b696de5c10ebcc7bf42d8487fc0e56e0e937754dJeff Brown /** 248b696de5c10ebcc7bf42d8487fc0e56e0e937754dJeff Brown * User activity event type: Unspecified event type. 249b696de5c10ebcc7bf42d8487fc0e56e0e937754dJeff Brown * @hide 250b696de5c10ebcc7bf42d8487fc0e56e0e937754dJeff Brown */ 251b696de5c10ebcc7bf42d8487fc0e56e0e937754dJeff Brown public static final int USER_ACTIVITY_EVENT_OTHER = 0; 252b696de5c10ebcc7bf42d8487fc0e56e0e937754dJeff Brown 253b696de5c10ebcc7bf42d8487fc0e56e0e937754dJeff Brown /** 254b696de5c10ebcc7bf42d8487fc0e56e0e937754dJeff Brown * User activity event type: Button or key pressed or released. 255b696de5c10ebcc7bf42d8487fc0e56e0e937754dJeff Brown * @hide 256b696de5c10ebcc7bf42d8487fc0e56e0e937754dJeff Brown */ 257b696de5c10ebcc7bf42d8487fc0e56e0e937754dJeff Brown public static final int USER_ACTIVITY_EVENT_BUTTON = 1; 258b696de5c10ebcc7bf42d8487fc0e56e0e937754dJeff Brown 259b696de5c10ebcc7bf42d8487fc0e56e0e937754dJeff Brown /** 260b696de5c10ebcc7bf42d8487fc0e56e0e937754dJeff Brown * User activity event type: Touch down, move or up. 261b696de5c10ebcc7bf42d8487fc0e56e0e937754dJeff Brown * @hide 262b696de5c10ebcc7bf42d8487fc0e56e0e937754dJeff Brown */ 263b696de5c10ebcc7bf42d8487fc0e56e0e937754dJeff Brown public static final int USER_ACTIVITY_EVENT_TOUCH = 2; 264b696de5c10ebcc7bf42d8487fc0e56e0e937754dJeff Brown 2659630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown /** 2669630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * User activity flag: Do not restart the user activity timeout or brighten 2679630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * the display in response to user activity if it is already dimmed. 2689630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * @hide 2699630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown */ 2709630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown public static final int USER_ACTIVITY_FLAG_NO_CHANGE_LIGHTS = 1 << 0; 2719630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown 2729630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown /** 2739630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * Go to sleep reason code: Going to sleep due by user request. 2749630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * @hide 2759630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown */ 2769630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown public static final int GO_TO_SLEEP_REASON_USER = 0; 2779630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown 2789630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown /** 2799630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * Go to sleep reason code: Going to sleep due by request of the 2809630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * device administration policy. 2819630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * @hide 2829630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown */ 2839630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown public static final int GO_TO_SLEEP_REASON_DEVICE_ADMIN = 1; 2849630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown 2859630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown /** 2869630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * Go to sleep reason code: Going to sleep due to a screen timeout. 2879630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * @hide 2889630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown */ 2899630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown public static final int GO_TO_SLEEP_REASON_TIMEOUT = 2; 2909630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown 2919630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown final Context mContext; 2921244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown final IPowerManager mService; 2931244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown final Handler mHandler; 2941244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown 2951244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown /** 2961244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * {@hide} 2971244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown */ 2989630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown public PowerManager(Context context, IPowerManager service, Handler handler) { 2999630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown mContext = context; 3001244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown mService = service; 3011244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown mHandler = handler; 3021244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 3031244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown 3041244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown /** 3059630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * Gets the minimum supported screen brightness setting. 3069630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * The screen may be allowed to become dimmer than this value but 3079630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * this is the minimum value that can be set by the user. 3089630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * @hide 3099630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown */ 3109630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown public int getMinimumScreenBrightnessSetting() { 3119630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown return mContext.getResources().getInteger( 312f9bba13692c10ff99a52f79d6d0f04c96117ff57Jeff Brown com.android.internal.R.integer.config_screenBrightnessSettingMinimum); 3139630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown } 3149630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown 3159630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown /** 3169630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * Gets the maximum supported screen brightness setting. 3179630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * The screen may be allowed to become dimmer than this value but 3189630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * this is the maximum value that can be set by the user. 3199630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * @hide 3209630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown */ 3219630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown public int getMaximumScreenBrightnessSetting() { 322f9bba13692c10ff99a52f79d6d0f04c96117ff57Jeff Brown return mContext.getResources().getInteger( 323f9bba13692c10ff99a52f79d6d0f04c96117ff57Jeff Brown com.android.internal.R.integer.config_screenBrightnessSettingMaximum); 3249630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown } 3259630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown 3269630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown /** 3279630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * Gets the default screen brightness setting. 3289630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * @hide 3299630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown */ 3309630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown public int getDefaultScreenBrightnessSetting() { 331f9bba13692c10ff99a52f79d6d0f04c96117ff57Jeff Brown return mContext.getResources().getInteger( 332f9bba13692c10ff99a52f79d6d0f04c96117ff57Jeff Brown com.android.internal.R.integer.config_screenBrightnessSettingDefault); 3339630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown } 3349630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown 3359630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown /** 336631938f26dbc89e7e9530bb85d9f37706dba59f3Jeff Brown * Returns true if the screen auto-brightness adjustment setting should 337631938f26dbc89e7e9530bb85d9f37706dba59f3Jeff Brown * be available in the UI. This setting is experimental and disabled by default. 338631938f26dbc89e7e9530bb85d9f37706dba59f3Jeff Brown * @hide 339631938f26dbc89e7e9530bb85d9f37706dba59f3Jeff Brown */ 340631938f26dbc89e7e9530bb85d9f37706dba59f3Jeff Brown public static boolean useScreenAutoBrightnessAdjustmentFeature() { 341631938f26dbc89e7e9530bb85d9f37706dba59f3Jeff Brown return SystemProperties.getBoolean("persist.power.useautobrightadj", false); 342631938f26dbc89e7e9530bb85d9f37706dba59f3Jeff Brown } 343631938f26dbc89e7e9530bb85d9f37706dba59f3Jeff Brown 344631938f26dbc89e7e9530bb85d9f37706dba59f3Jeff Brown /** 345db21284a7fb081065d26137891594bd8495b116fJeff Brown * Returns true if the twilight service should be used to adjust screen brightness 346db21284a7fb081065d26137891594bd8495b116fJeff Brown * policy. This setting is experimental and disabled by default. 347db21284a7fb081065d26137891594bd8495b116fJeff Brown * @hide 348db21284a7fb081065d26137891594bd8495b116fJeff Brown */ 349db21284a7fb081065d26137891594bd8495b116fJeff Brown public static boolean useTwilightAdjustmentFeature() { 350db21284a7fb081065d26137891594bd8495b116fJeff Brown return SystemProperties.getBoolean("persist.power.usetwilightadj", false); 351db21284a7fb081065d26137891594bd8495b116fJeff Brown } 352db21284a7fb081065d26137891594bd8495b116fJeff Brown 353db21284a7fb081065d26137891594bd8495b116fJeff Brown /** 3541244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Creates a new wake lock with the specified level and flags. 3551244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * <p> 3561244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * The {@code levelAndFlags} parameter specifies a wake lock level and optional flags 3571244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * combined using the logical OR operator. 3581244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p><p> 3591244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * The wake lock levels are: {@link #PARTIAL_WAKE_LOCK}, 3601244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * {@link #FULL_WAKE_LOCK}, {@link #SCREEN_DIM_WAKE_LOCK} 3611244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * and {@link #SCREEN_BRIGHT_WAKE_LOCK}. Exactly one wake lock level must be 3621244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * specified as part of the {@code levelAndFlags} parameter. 3631244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p><p> 3641244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * The wake lock flags are: {@link #ACQUIRE_CAUSES_WAKEUP} 3651244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * and {@link #ON_AFTER_RELEASE}. Multiple flags can be combined as part of the 3661244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * {@code levelAndFlags} parameters. 3671244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p><p> 3681244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Call {@link WakeLock#acquire() acquire()} on the object to acquire the 3691244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * wake lock, and {@link WakeLock#release release()} when you are done. 3701244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p><p> 3711244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * {@samplecode 3721244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * PowerManager pm = (PowerManager)mContext.getSystemService( 3731244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Context.POWER_SERVICE); 3741244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * PowerManager.WakeLock wl = pm.newWakeLock( 3751244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * PowerManager.SCREEN_DIM_WAKE_LOCK 3761244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * | PowerManager.ON_AFTER_RELEASE, 3771244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * TAG); 3781244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * wl.acquire(); 3791244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * // ... do work... 3801244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * wl.release(); 3811244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * } 3821244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p><p> 3831244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Although a wake lock can be created without special permissions, 3841244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * the {@link android.Manifest.permission#WAKE_LOCK} permission is 3851244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * required to actually acquire or release the wake lock that is returned. 3861244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p><p class="note"> 3871244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * If using this to keep the screen on, you should strongly consider using 3881244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * {@link android.view.WindowManager.LayoutParams#FLAG_KEEP_SCREEN_ON} instead. 3891244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * This window flag will be correctly managed by the platform 3901244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * as the user moves between applications and doesn't require a special permission. 3911244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p> 3921244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * 3931244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * @param levelAndFlags Combination of wake lock level and flag values defining 3941244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * the requested behavior of the WakeLock. 3951244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * @param tag Your class name (or other tag) for debugging purposes. 3961244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * 3971244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * @see WakeLock#acquire() 3981244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * @see WakeLock#release() 3991244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * @see #PARTIAL_WAKE_LOCK 4001244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * @see #FULL_WAKE_LOCK 4011244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * @see #SCREEN_DIM_WAKE_LOCK 4021244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * @see #SCREEN_BRIGHT_WAKE_LOCK 4031244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * @see #ACQUIRE_CAUSES_WAKEUP 4041244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * @see #ON_AFTER_RELEASE 4051244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown */ 4061244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown public WakeLock newWakeLock(int levelAndFlags, String tag) { 407155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown validateWakeLockParameters(levelAndFlags, tag); 408155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown return new WakeLock(levelAndFlags, tag); 409155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown } 410155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown 411155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown /** @hide */ 412155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown public static void validateWakeLockParameters(int levelAndFlags, String tag) { 413155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown switch (levelAndFlags & WAKE_LOCK_LEVEL_MASK) { 414155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown case PARTIAL_WAKE_LOCK: 415155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown case SCREEN_DIM_WAKE_LOCK: 416155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown case SCREEN_BRIGHT_WAKE_LOCK: 417155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown case FULL_WAKE_LOCK: 418155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown case PROXIMITY_SCREEN_OFF_WAKE_LOCK: 419155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown break; 420155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown default: 421155fc70252fd9ccee1f05da4e6966a99ec86d499Jeff Brown throw new IllegalArgumentException("Must specify a valid wake lock level."); 4221244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 4231244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown if (tag == null) { 4241244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown throw new IllegalArgumentException("The tag must not be null."); 4251244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 4261244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 4271244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown 4281244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown /** 4291244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Notifies the power manager that user activity happened. 4301244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * <p> 4319630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * Resets the auto-off timer and brightens the screen if the device 4329630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * is not asleep. This is what happens normally when a key or the touch 4339630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * screen is pressed or when some other user activity occurs. 4349630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * This method does not wake up the device if it has been put to sleep. 4351244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p><p> 4361244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Requires the {@link android.Manifest.permission#DEVICE_POWER} permission. 4371244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p> 4381244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * 4391244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * @param when The time of the user activity, in the {@link SystemClock#uptimeMillis()} 44062c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * time base. This timestamp is used to correctly order the user activity request with 4411244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * other power management functions. It should be set 4421244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * to the timestamp of the input event that caused the user activity. 4431244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * @param noChangeLights If true, does not cause the keyboard backlight to turn on 4441244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * because of this event. This is set when the power key is pressed. 4451244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * We want the device to stay on while the button is down, but we're about 4461244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * to turn off the screen so we don't want the keyboard backlight to turn on again. 4471244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Otherwise the lights flash on and then off and it looks weird. 4489630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * 4499630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * @see #wakeUp 4509630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * @see #goToSleep 4511244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown */ 4521244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown public void userActivity(long when, boolean noChangeLights) { 4531244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown try { 4549630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown mService.userActivity(when, USER_ACTIVITY_EVENT_OTHER, 4559630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown noChangeLights ? USER_ACTIVITY_FLAG_NO_CHANGE_LIGHTS : 0); 4561244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } catch (RemoteException e) { 4571244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 4581244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 4591244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown 4601244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown /** 4611244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Forces the device to go to sleep. 4621244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * <p> 4639630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * Overrides all the wake locks that are held. 4649630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * This is what happens when the power key is pressed to turn off the screen. 4651244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p><p> 4661244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Requires the {@link android.Manifest.permission#DEVICE_POWER} permission. 4671244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p> 4681244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * 4691244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * @param time The time when the request to go to sleep was issued, in the 4701244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * {@link SystemClock#uptimeMillis()} time base. This timestamp is used to correctly 47162c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * order the go to sleep request with other power management functions. It should be set 4721244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * to the timestamp of the input event that caused the request to go to sleep. 4739630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * 4749630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * @see #userActivity 4759630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * @see #wakeUp 4761244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown */ 4771244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown public void goToSleep(long time) { 4781244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown try { 4799630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown mService.goToSleep(time, GO_TO_SLEEP_REASON_USER); 4809630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown } catch (RemoteException e) { 4819630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown } 4829630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown } 4839630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown 4849630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown /** 4859630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * Forces the device to wake up from sleep. 4869630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * <p> 4879630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * If the device is currently asleep, wakes it up, otherwise does nothing. 4889630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * This is what happens when the power key is pressed to turn on the screen. 4899630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * </p><p> 4909630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * Requires the {@link android.Manifest.permission#DEVICE_POWER} permission. 4919630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * </p> 4929630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * 4939630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * @param time The time when the request to wake up was issued, in the 4949630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * {@link SystemClock#uptimeMillis()} time base. This timestamp is used to correctly 49562c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * order the wake up request with other power management functions. It should be set 4969630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * to the timestamp of the input event that caused the request to wake up. 4979630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * 4989630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * @see #userActivity 4999630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * @see #goToSleep 5009630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown */ 5019630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown public void wakeUp(long time) { 5029630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown try { 5039630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown mService.wakeUp(time); 5041244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } catch (RemoteException e) { 5051244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 5061244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 5071244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown 5081244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown /** 50962c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * Forces the device to start napping. 51062c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * <p> 51162c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * If the device is currently awake, starts dreaming, otherwise does nothing. 51262c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * When the dream ends or if the dream cannot be started, the device will 51362c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * either wake up or go to sleep depending on whether there has been recent 51462c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * user activity. 51562c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * </p><p> 51662c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * Requires the {@link android.Manifest.permission#DEVICE_POWER} permission. 51762c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * </p> 51862c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * 51962c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * @param time The time when the request to nap was issued, in the 52062c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * {@link SystemClock#uptimeMillis()} time base. This timestamp is used to correctly 52162c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * order the nap request with other power management functions. It should be set 52262c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * to the timestamp of the input event that caused the request to nap. 52362c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * 52462c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * @see #wakeUp 52562c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * @see #goToSleep 52662c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * 52762c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown * @hide 52862c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown */ 52962c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown public void nap(long time) { 53062c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown try { 53162c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown mService.nap(time); 53262c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown } catch (RemoteException e) { 53362c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown } 53462c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown } 53562c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown 53662c82e4d92cc0b856059f905d81885f7808a0e7dJeff Brown /** 5371244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Sets the brightness of the backlights (screen, keyboard, button). 5381244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * <p> 5391244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Requires the {@link android.Manifest.permission#DEVICE_POWER} permission. 5401244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p> 5411244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * 5421244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * @param brightness The brightness value from 0 to 255. 5431244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * 5441244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * {@hide} 5451244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown */ 5461244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown public void setBacklightBrightness(int brightness) { 5471244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown try { 5489630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown mService.setTemporaryScreenBrightnessSettingOverride(brightness); 5491244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } catch (RemoteException e) { 5501244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 5511244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 5521244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown 5531244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown /** 5549630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * Returns true if the specified wake lock level is supported. 5551244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * 5569630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * @param level The wake lock level to check. 5579630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown * @return True if the specified wake lock level is supported. 5581244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * 5591244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * {@hide} 5601244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown */ 5619630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown public boolean isWakeLockLevelSupported(int level) { 5621244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown try { 5639630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown return mService.isWakeLockLevelSupported(level); 5641244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } catch (RemoteException e) { 5659630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown return false; 5661244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 5671244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 5681244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown 5691244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown /** 5701244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Returns whether the screen is currently on. 5711244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * <p> 5721244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Only indicates whether the screen is on. The screen could be either bright or dim. 5731244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p><p> 5741244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * {@samplecode 5751244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE); 5761244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * boolean isScreenOn = pm.isScreenOn(); 5771244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * } 5781244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p> 5791244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * 5801244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * @return whether the screen is on (bright or dim). 5811244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown */ 5821244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown public boolean isScreenOn() { 5831244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown try { 5841244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown return mService.isScreenOn(); 5851244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } catch (RemoteException e) { 5861244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown return false; 5871244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 5881244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 5891244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown 5909066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 5911244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Reboot the device. Will not return if the reboot is successful. 592d710fb500c121b3f9563ccfbe488f7c9d3ec4985Kenny Root * <p> 5931244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Requires the {@link android.Manifest.permission#REBOOT} permission. 5941244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p> 5951244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * 5961244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * @param reason code to pass to the kernel (e.g., "recovery") to 5971244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * request special boot modes, or null. 5981244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown */ 5991244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown public void reboot(String reason) { 6001244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown try { 601c428aae6429c3fd5e2037c3793af399d9f6e23bfDianne Hackborn mService.reboot(false, reason, true); 6021244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } catch (RemoteException e) { 6031244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 6041244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 6051244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown 6061244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown /** 6071244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * A wake lock is a mechanism to indicate that your application needs 6081244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * to have the device stay on. 609d710fb500c121b3f9563ccfbe488f7c9d3ec4985Kenny Root * <p> 610d710fb500c121b3f9563ccfbe488f7c9d3ec4985Kenny Root * Any application using a WakeLock must request the {@code android.permission.WAKE_LOCK} 611d710fb500c121b3f9563ccfbe488f7c9d3ec4985Kenny Root * permission in an {@code <uses-permission>} element of the application's manifest. 6121244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Obtain a wake lock by calling {@link PowerManager#newWakeLock(int, String)}. 6131244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p><p> 6141244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Call {@link #acquire()} to acquire the wake lock and force the device to stay 6151244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * on at the level that was requested when the wake lock was created. 6161244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p><p> 6171244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Call {@link #release()} when you are done and don't need the lock anymore. 6181244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * It is very important to do this as soon as possible to avoid running down the 6191244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * device's battery excessively. 6201244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p> 6219066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 6221244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown public final class WakeLock { 6231244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown private final int mFlags; 6241244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown private final String mTag; 6251244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown private final IBinder mToken; 6261244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown private int mCount; 6271244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown private boolean mRefCounted = true; 6281244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown private boolean mHeld; 6291244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown private WorkSource mWorkSource; 6301244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown 6311244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown private final Runnable mReleaser = new Runnable() { 6329066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public void run() { 6339066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project release(); 6349066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 6359066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project }; 6369066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 6371244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown WakeLock(int flags, String tag) { 6389066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project mFlags = flags; 6399066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project mTag = tag; 6409066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project mToken = new Binder(); 6419066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 6429066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 6431244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown @Override 6441244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown protected void finalize() throws Throwable { 6451244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown synchronized (mToken) { 6461244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown if (mHeld) { 6471244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown Log.wtf(TAG, "WakeLock finalized while still held: " + mTag); 6481244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown try { 6491244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown mService.releaseWakeLock(mToken, 0); 6501244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } catch (RemoteException e) { 6511244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 6521244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 6531244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 6541244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 6551244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown 6569066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 6571244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Sets whether this WakeLock is reference counted. 6581244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * <p> 6591244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Wake locks are reference counted by default. If a wake lock is 6601244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * reference counted, then each call to {@link #acquire()} must be 6611244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * balanced by an equal number of calls to {@link #release()}. If a wake 6621244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * lock is not reference counted, then one call to {@link #release()} is 6631244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * sufficient to undo the effect of all previous calls to {@link #acquire()}. 6641244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p> 6658310b42fbc086b0f05fc8ef45ac34c7e099c485eJoe Onorato * 6661244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * @param value True to make the wake lock reference counted, false to 6671244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * make the wake lock non-reference counted. 6689066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 6691244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown public void setReferenceCounted(boolean value) { 6701244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown synchronized (mToken) { 6711244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown mRefCounted = value; 6721244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 6739066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 6749066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 6759066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 6761244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Acquires the wake lock. 6771244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * <p> 6781244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Ensures that the device is on at the level requested when 6791244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * the wake lock was created. 6801244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p> 6819066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 6821244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown public void acquire() { 6839066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project synchronized (mToken) { 684d7350e3a56daa44e2d2c6e5175e6430492cf0dc9Joe Onorato acquireLocked(); 6859066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 6869066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 687d7350e3a56daa44e2d2c6e5175e6430492cf0dc9Joe Onorato 6889066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 6891244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Acquires the wake lock with a timeout. 6901244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * <p> 6911244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Ensures that the device is on at the level requested when 6921244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * the wake lock was created. The lock will be released after the given timeout 6931244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * expires. 6941244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p> 6951244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * 6961244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * @param timeout The timeout after which to release the wake lock, in milliseconds. 6979066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 6989066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public void acquire(long timeout) { 699d7350e3a56daa44e2d2c6e5175e6430492cf0dc9Joe Onorato synchronized (mToken) { 700d7350e3a56daa44e2d2c6e5175e6430492cf0dc9Joe Onorato acquireLocked(); 701d7350e3a56daa44e2d2c6e5175e6430492cf0dc9Joe Onorato mHandler.postDelayed(mReleaser, timeout); 702d7350e3a56daa44e2d2c6e5175e6430492cf0dc9Joe Onorato } 7039066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 7041244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown 705d7350e3a56daa44e2d2c6e5175e6430492cf0dc9Joe Onorato private void acquireLocked() { 706d7350e3a56daa44e2d2c6e5175e6430492cf0dc9Joe Onorato if (!mRefCounted || mCount++ == 0) { 707ff1baef86c3b34fe2aec33a22bc2d06112af4c03Jeff Brown // Do this even if the wake lock is already thought to be held (mHeld == true) 708ff1baef86c3b34fe2aec33a22bc2d06112af4c03Jeff Brown // because non-reference counted wake locks are not always properly released. 709ff1baef86c3b34fe2aec33a22bc2d06112af4c03Jeff Brown // For example, the keyguard's wake lock might be forcibly released by the 710ff1baef86c3b34fe2aec33a22bc2d06112af4c03Jeff Brown // power manager without the keyguard knowing. A subsequent call to acquire 711ff1baef86c3b34fe2aec33a22bc2d06112af4c03Jeff Brown // should immediately acquire the wake lock once again despite never having 712ff1baef86c3b34fe2aec33a22bc2d06112af4c03Jeff Brown // been explicitly released by the keyguard. 713d7350e3a56daa44e2d2c6e5175e6430492cf0dc9Joe Onorato mHandler.removeCallbacks(mReleaser); 714ff1baef86c3b34fe2aec33a22bc2d06112af4c03Jeff Brown try { 7159630704ed3b265f008a8f64ec60a33cf9dcd3345Jeff Brown mService.acquireWakeLock(mToken, mFlags, mTag, mWorkSource); 716ff1baef86c3b34fe2aec33a22bc2d06112af4c03Jeff Brown } catch (RemoteException e) { 717d7350e3a56daa44e2d2c6e5175e6430492cf0dc9Joe Onorato } 718ff1baef86c3b34fe2aec33a22bc2d06112af4c03Jeff Brown mHeld = true; 719d7350e3a56daa44e2d2c6e5175e6430492cf0dc9Joe Onorato } 720d7350e3a56daa44e2d2c6e5175e6430492cf0dc9Joe Onorato } 7219066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 7229066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 7231244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Releases the wake lock. 7249066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * <p> 7251244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * This method releases your claim to the CPU or screen being on. 7261244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * The screen may turn off shortly after you release the wake lock, or it may 7271244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * not if there are other wake locks still held. 7281244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p> 7299066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 730d7350e3a56daa44e2d2c6e5175e6430492cf0dc9Joe Onorato public void release() { 7310e39ea83c5578e0d55e120c91ff7cfeeb0c1cb2fMike Lockwood release(0); 7320e39ea83c5578e0d55e120c91ff7cfeeb0c1cb2fMike Lockwood } 7330e39ea83c5578e0d55e120c91ff7cfeeb0c1cb2fMike Lockwood 7340e39ea83c5578e0d55e120c91ff7cfeeb0c1cb2fMike Lockwood /** 7351244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Releases the wake lock with flags to modify the release behavior. 7360e39ea83c5578e0d55e120c91ff7cfeeb0c1cb2fMike Lockwood * <p> 7371244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * This method releases your claim to the CPU or screen being on. 7381244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * The screen may turn off shortly after you release the wake lock, or it may 7391244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * not if there are other wake locks still held. 7401244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p> 7411244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * 7421244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * @param flags Combination of flag values to modify the release behavior. 7431244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Currently only {@link #WAIT_FOR_PROXIMITY_NEGATIVE} is supported. 7440e39ea83c5578e0d55e120c91ff7cfeeb0c1cb2fMike Lockwood * 7450e39ea83c5578e0d55e120c91ff7cfeeb0c1cb2fMike Lockwood * {@hide} 7460e39ea83c5578e0d55e120c91ff7cfeeb0c1cb2fMike Lockwood */ 747d7350e3a56daa44e2d2c6e5175e6430492cf0dc9Joe Onorato public void release(int flags) { 7489066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project synchronized (mToken) { 7499066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (!mRefCounted || --mCount == 0) { 750b5962e73e841455b8e2a4e2d5c0ef0a19d62a803Jake Hamby mHandler.removeCallbacks(mReleaser); 7511244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown if (mHeld) { 7521244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown try { 7531244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown mService.releaseWakeLock(mToken, flags); 7541244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } catch (RemoteException e) { 7551244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown } 7561244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown mHeld = false; 7579066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 7589066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 7599066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (mCount < 0) { 7609066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project throw new RuntimeException("WakeLock under-locked " + mTag); 7619066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 7629066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 7639066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 7649066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 7651244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown /** 7661244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Returns true if the wake lock has been acquired but not yet released. 7671244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * 7681244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * @return True if the wake lock is held. 7691244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown */ 7701244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown public boolean isHeld() { 7719066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project synchronized (mToken) { 7729066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return mHeld; 7739066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 7749066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 7759066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 7761244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown /** 7771244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * Sets the work source associated with the wake lock. 7781244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * <p> 7791244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * The work source is used to determine on behalf of which application 7801244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * the wake lock is being held. This is useful in the case where a 7811244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * service is performing work on behalf of an application so that the 7821244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * cost of that work can be accounted to the application. 7831244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * </p> 7841244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * 7851244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown * @param ws The work source, or null if none. 7861244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown */ 7877e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn public void setWorkSource(WorkSource ws) { 7887e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn synchronized (mToken) { 7897e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn if (ws != null && ws.size() == 0) { 7907e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn ws = null; 7917e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn } 7921244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown 7931244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown final boolean changed; 7947e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn if (ws == null) { 7951244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown changed = mWorkSource != null; 7967e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn mWorkSource = null; 7977e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn } else if (mWorkSource == null) { 7981244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown changed = true; 7997e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn mWorkSource = new WorkSource(ws); 8007e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn } else { 8017e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn changed = mWorkSource.diff(ws); 8027e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn if (changed) { 8037e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn mWorkSource.set(ws); 8047e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn } 8057e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn } 8061244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown 8077e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn if (changed && mHeld) { 8087e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn try { 8097e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn mService.updateWakeLockWorkSource(mToken, mWorkSource); 8107e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn } catch (RemoteException e) { 8117e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn } 8127e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn } 8137e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn } 8147e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn } 8157e9f4eb2608148436cef36c9969bf8a599b39e72Dianne Hackborn 8161244cdaedd5bb4518fc75c9a25b834190ea31877Jeff Brown @Override 8179066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public String toString() { 8189066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project synchronized (mToken) { 8199066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return "WakeLock{" 8209066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project + Integer.toHexString(System.identityHashCode(this)) 8219066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project + " held=" + mHeld + ", refCount=" + mCount + "}"; 8229066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 8239066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 824322591cb4b158dc2edbc3d95cd02e44f132feb5fCharles Mendis } 8259066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project} 826