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 class PowerManager {     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或应用程序中才能用。