image.png

image.png

PROXIMITY_SCREEN_OFF_WAKE_LOCK：pSensor导致的灭屏情况下系统不会进入休眠，正常情况下不影响系统休眠，常见的应用场景就是打电话时候靠近耳朵灭屏幕，远离亮屏幕；

    //添加权限
    <uses-permission android:name="android.permission.WAKE_LOCK"/>
    
    PowerManager powerManager = (PowerManager) this.getSystemService(Context.POWER_SERVICE);
    //创建WakeLock
    PowerManager.WakeLock wakeLock = powerManager.newWakeLock(PowerManager.SCREEN_BRIGHT_WAKE_LOCK
                        | PowerManager.ACQUIRE_CAUSES_WAKEUP
                        | PowerManager.ON_AFTER_RELEASE,
                "TestWakeLock"
        );
    //获取
    if(!wakeLock.isHeld()){
       //wakeLock.acquire(5000);
       wakeLock.acquire()；
    }
    //释放
    if (wakeLock.isHeld()){
       wakeLock.release();
    }

创建WakeLock时候需要注意2点，
1.Levelc中PARTIAL_WAKE_LOCK，SCREEN_DIM_WAKE_LOCK，SCREEN_BRIGHT_WAKE_LOCK，FULL_WAKE_LOCK只能有一个，否则会报：java.lang.IllegalArgumentException: Must specify a valid wake lock level.异常；
2.创建时候最好带一个TAG,方便定位释放获取多次未释放;

使用时候，判断是否已经isHeld，避免无效的操作，最好指定acquire时长，防止未释放;

分析源码：

//PowerManager.java
* @param levelAndFlags Combination of wake lock level and flag values defining
     * the requested behavior of the WakeLock.
     * @param tag Your class name (or other tag) for debugging purposes.
     *
     * @see WakeLock#acquire()
     * @see WakeLock#release()
     * @see #PARTIAL_WAKE_LOCK
     * @see #FULL_WAKE_LOCK
     * @see #SCREEN_DIM_WAKE_LOCK
     * @see #SCREEN_BRIGHT_WAKE_LOCK
     * @see #PROXIMITY_SCREEN_OFF_WAKE_LOCK
     * @see #ACQUIRE_CAUSES_WAKEUP
     * @see #ON_AFTER_RELEASE
     */
    public WakeLock newWakeLock(int levelAndFlags, String tag) {
        validateWakeLockParameters(levelAndFlags, tag);
        return new WakeLock(levelAndFlags, tag, mContext.getOpPackageName());
    }

使用过程以及支持设置的Flags在这里已经标记清楚；

        //判断是否获得WakeLock
         public boolean isHeld() {
            synchronized (mToken) {
                return mHeld;
            }
        }
        
              //设置是否引用计数，一般设置false，若true开启引用计数器，acquire多次则必须release多次才能释放掉。但是如果释放次数比acquire多则会抛出throw new RuntimeException("WakeLock under-locked " + mTag);异常。        
         public void setReferenceCounted(boolean value) {
            synchronized (mToken) {
                mRefCounted = value;
            }
        }
        
        public void acquire() {
            synchronized (mToken) {
                acquireLocked();
            }
        }
        
        public void acquire(long timeout) {
            synchronized (mToken) {
                acquireLocked();
                mHandler.postDelayed(mReleaser, timeout);
            }
        }

         private void acquireLocked() {
            mInternalCount++;
            mExternalCount++;
            
            //如果mRefCounted为false，那么每一次acquire都会执行PowerManagerService#acquireWakeLock，若mRefCounted为true,多次执行其中只有第一次执行，性能优化情况下建议设置setReferenceCounted为true；
            if (!mRefCounted || mInternalCount == 1) {
                mHandler.removeCallbacks(mReleaser);
                Trace.asyncTraceBegin(Trace.TRACE_TAG_POWER, mTraceName, 0);
                try {
                    //调用PowerManagerService#acquireWakeLock
                    mService.acquireWakeLock(mToken, mFlags, mTag, mPackageName, mWorkSource,
                            mHistoryTag);
                } catch (RemoteException e) {
                    throw e.rethrowFromSystemServer();
                }
                //标记已经aquire过
                mHeld = true;
            }
        }
        
       
        
        public void release() {
            release(0);
        }

        public void release(int flags) {
            synchronized (mToken) {
                if (mInternalCount > 0) {
                    mInternalCount--;
                }
                if ((flags & RELEASE_FLAG_TIMEOUT) == 0) {
                    mExternalCount--;
                }
                //如果mRefCounted为true时候，则需要和acquire次数匹配的release保证mInternalCount==0才会调用调用PowerManagerService#releaseWakeLock
                if (!mRefCounted || mInternalCount == 0) {
                    mHandler.removeCallbacks(mReleaser);
                    if (mHeld) {
                        ...
                            //调用PowerManagerService#releaseWakeLock
                            mService.releaseWakeLock(mToken, flags);
                        ...
                        mHeld = false;
                    }
                }
                ...
                //如果release次数超过acquire会跑出异常
                if (mRefCounted && mExternalCount < 0) {
                    throw new RuntimeException("WakeLock under-locked " + mTag);
                }
            }
        }
        

通过上述源码我们分析：
1.isHeld判断是否持有，可以避免无效操作；
2.在对性能有要求情况下setReferenceCounted设置为true，避免多次调用PowerManagerService的acquireWakeLock/releaseWakeLock方法；
3.当setReferenceCounted设置为true时候，需要注意release次数与acquire要匹配，如果匹配不上会报错，release少了不会释放WakeLock,多了会抛异常；

另外官网提示在Activity中推荐使用FLAG_KEEP_SCREEN_ON方式去点亮屏幕；

getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);

使用ADB命令查看WakeLock

adb shell dumpsys power | grep -i "wake"

  mWakefulness=Awake
  mWakefulnessChanging=false
  mWakeLockSummary=0x23
  mLastWakeTime=26248502 (918 ms ago)
  mHoldingWakeLockSuspendBlocker=true
  mWakeUpWhenPluggedOrUnpluggedConfig=true
  mWakeUpWhenPluggedOrUnpluggedInTheaterModeConfig=false
  mDrawWakeLockOverrideFromSidekick=false
  mDoubleTapWakeEnabled=false
Wake Locks: size=2
  SCREEN_BRIGHT_WAKE_LOCK        'wireless_charge' ACQ=-897ms (uid=1000 pid=2281)
  PARTIAL_WAKE_LOCK              'AudioMix' ACQ=-708ms (uid=1041 ws=WorkSource{1000})