PowerManager源码

http://hi-android.info/src/android/os/PowerManager.java.html
PowerManager类为对Android电源进行管理提供了接口。它位于 android/os/PowerManager.java，但是它本身实现的东西很少，主要是调用了些更底层（C/C++）的函数.

关于如何通过PowerManager类来对Android电源进行管理请参考《 PowerManager》，《 Android电源管理简介》

源文件：PowerManager.java

package android.os;

import android.util.Log;

import com.android.internal.os.RuntimeInit;

public classPowerManager

{

private static final String TAG = "PowerManager";

private static final int WAKE_BIT_CPU_STRONG = 1;

private static final int WAKE_BIT_CPU_WEAK = 2;

private static final int WAKE_BIT_SCREEN_DIM = 4;

private static final int WAKE_BIT_SCREEN_BRIGHT = 8;

private static final int WAKE_BIT_KEYBOARD_BRIGHT = 16;

private static final int WAKE_BIT_PROXIMITY_SCREEN_OFF = 32;

private static final int LOCK_MASK = WAKE_BIT_CPU_STRONG

| WAKE_BIT_CPU_WEAK

| WAKE_BIT_SCREEN_DIM

| WAKE_BIT_SCREEN_BRIGHT

| WAKE_BIT_KEYBOARD_BRIGHT

| WAKE_BIT_PROXIMITY_SCREEN_OFF;

public static final int PARTIAL_WAKE_LOCK = WAKE_BIT_CPU_STRONG;

public static final int FULL_WAKE_LOCK = WAKE_BIT_CPU_WEAK | WAKE_BIT_SCREEN_BRIGHT

| WAKE_BIT_KEYBOARD_BRIGHT;

public static final int SCREEN_BRIGHT_WAKE_LOCK = WAKE_BIT_CPU_WEAK | WAKE_BIT_SCREEN_BRIGHT;

public static final int SCREEN_DIM_WAKE_LOCK = WAKE_BIT_CPU_WEAK | WAKE_BIT_SCREEN_DIM;

/**

* Wake lock that turns the screen off when the proximity sensor activates.

* Since not all devices have proximity sensors, use

* {@link #getSupportedWakeLockFlags() getSupportedWakeLockFlags()} to determine if

* this wake lock mode is supported.

*

* {@hide}

*/

public static final int PROXIMITY_SCREEN_OFF_WAKE_LOCK = WAKE_BIT_PROXIMITY_SCREEN_OFF;

/**

* Flag for {@link WakeLock#release release(int)} to defer releasing a

* {@link #WAKE_BIT_PROXIMITY_SCREEN_OFF} wakelock until the proximity sensor returns

* a negative value.

*

* {@hide}

*/

public static final int WAIT_FOR_PROXIMITY_NEGATIVE = 1;

public static final int ACQUIRE_CAUSES_WAKEUP = 0x10000000;

public static final int ON_AFTER_RELEASE = 0x20000000;

/**

* Class lets you say that you need to have the device on.

*

* <p>Call release when you are done and don't need the lock anymore.

*/

public class WakeLock

{

static final int RELEASE_WAKE_LOCK = 1;

Runnable mReleaser = new Runnable() {

public void run() {

release();

}

};

int mFlags;

String mTag;

IBinder mToken;

int mCount = 0;

boolean mRefCounted = true;

boolean mHeld = false;

WorkSource mWorkSource;

WakeLock(int flags, String tag)

{

switch (flags & LOCK_MASK) {

case PARTIAL_WAKE_LOCK:

case SCREEN_DIM_WAKE_LOCK:

case SCREEN_BRIGHT_WAKE_LOCK:

case FULL_WAKE_LOCK:

case PROXIMITY_SCREEN_OFF_WAKE_LOCK:

break;

default:

throw new IllegalArgumentException();

}

mFlags = flags;

mTag = tag;

mToken = new Binder();

}

/**

* Sets whether this WakeLock is ref counted.

*

* <p>Wake locks are reference counted by default.

*

* @param value true for ref counted, false for not ref counted.

*/

public void setReferenceCounted(boolean value)

{

mRefCounted = value;

}

/**

* Makes sure the device is on at the level you asked when you created

* the wake lock.

*/

public void acquire()

{

synchronized (mToken) {

if (!mRefCounted || mCount++ == 0) {

try {

mService.acquireWakeLock(mFlags, mToken, mTag, mWorkSource);

} catch (RemoteException e) {

}

mHeld = true;

}

}

}

/**

* Makes sure the device is on at the level you asked when you created

* the wake lock. The lock will be released after the given timeout.

*

* @param timeout Release the lock after the give timeout in milliseconds.

*/

public void acquire(long timeout) {

acquire();

mHandler.postDelayed(mReleaser, timeout);

}

/**

* Release your claim to the CPU or screen being on.

*

* <p>

* It may turn off shortly after you release it, or it may not if there

* are other wake locks held.

*/

public void release()

{

release(0);

}

/**

* Release your claim to the CPU or screen being on.

* @param flags Combination of flag values to modify the release behavior.

* Currently only {@link #WAIT_FOR_PROXIMITY_NEGATIVE} is supported.

*

* <p>

* It may turn off shortly after you release it, or it may not if there

* are other wake locks held.

*

* {@hide}

*/

public void release(int flags)

{

synchronized (mToken) {

if (!mRefCounted || --mCount == 0) {

try {

mService.releaseWakeLock(mToken, flags);

} catch (RemoteException e) {

}

mHeld = false;

}

if (mCount < 0) {

throw new RuntimeException("WakeLock under-locked " + mTag);

}

}

}

public boolean isHeld()

{

synchronized (mToken) {

return mHeld;

}

}

public void setWorkSource(WorkSource ws) {

synchronized (mToken) {

if (ws != null && ws.size() == 0) {

ws = null;

}

boolean changed = true;

if (ws == null) {

mWorkSource = null;

} else if (mWorkSource == null) {

changed = mWorkSource != null;

mWorkSource = new WorkSource(ws);

} else {

changed = mWorkSource.diff(ws);

if (changed) {

mWorkSource.set(ws);

}

}

if (changed && mHeld) {

try {

mService.updateWakeLockWorkSource(mToken, mWorkSource);

} catch (RemoteException e) {

}

}

}

}

public String toString() {

synchronized (mToken) {

return "WakeLock{"

+ Integer.toHexString(System.identityHashCode(this))

+ " held=" + mHeld + ", refCount=" + mCount + "}";

}

}

@Override

protected void finalize() throws Throwable

{

synchronized (mToken) {

if (mHeld) {

Log.wtf(TAG, "WakeLock finalized while still held: " + mTag);

try {

mService.releaseWakeLock(mToken, 0);

} catch (RemoteException e) {

}

}

}

}

}

public WakeLock newWakeLock(int flags, String tag)

{

if (tag == null) {

throw new NullPointerException("tag is null in PowerManager.newWakeLock");

}

return new WakeLock(flags, tag);

}

public void userActivity(long when, boolean noChangeLights)

{

try {

mService.userActivity(when, noChangeLights);

} catch (RemoteException e) {

}

}

public void goToSleep(long time)

{

try {

mService.goToSleep(time);

} catch (RemoteException e) {

}

}

/**

* sets the brightness of the backlights (screen, keyboard, button).

*

* @param brightness value from 0 to 255

*

* {@hide}

*/

public void setBacklightBrightness(int brightness)

{

try {

mService.setBacklightBrightness(brightness);

} catch (RemoteException e) {

}

}

/**

* Returns the set of flags for {@link #newWakeLock(int, String) newWakeLock()}

* that are supported on the device.

* For example, to test to see if the {@link #PROXIMITY_SCREEN_OFF_WAKE_LOCK}

* is supported:

*

* {@samplecode

* PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);

* int supportedFlags = pm.getSupportedWakeLockFlags();

* boolean proximitySupported = ((supportedFlags & PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK)

* == PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK);

* }

*

* @return the set of supported WakeLock flags.

*

* {@hide}

*/

public int getSupportedWakeLockFlags()

{

try {

return mService.getSupportedWakeLockFlags();

} catch (RemoteException e) {

return 0;

}

}

public boolean isScreenOn()

{

try {

return mService.isScreenOn();

} catch (RemoteException e) {

return false;

}

}

public void reboot(String reason)

{

try {

mService.reboot(reason);

} catch (RemoteException e) {

}

}

private PowerManager()

{

}

public PowerManager(IPowerManager service, Handler handler)

{

mService = service;

mHandler = handler;

}

IPowerManager mService;

Handler mHandler;

}

注意： * {@hide} 表示该方法对外部开发用户是隐藏了，Android的对外API中并不提供该方法。

只有在Android系统的framework或应用程序中才能用。