Android6.0 wakelock深入分析

这篇博客我们分析下Power的持锁，从PowerManager到PowerManagerService再到hal分析。

一、PowerManager的持锁接口

我们先来看下PowerManager对应用提供的接口：

    public WakeLock newWakeLock(int levelAndFlags, String tag) {
        validateWakeLockParameters(levelAndFlags, tag);//验证wakelock的flag是否有效
        return new WakeLock(levelAndFlags, tag, mContext.getOpPackageName());
    }

validateWakeLockParameters函数如下：主要对flag没有下面这些flag做过滤

    public static void validateWakeLockParameters(int levelAndFlags, String tag) {
        switch (levelAndFlags & WAKE_LOCK_LEVEL_MASK) {
            case PARTIAL_WAKE_LOCK://cpu锁
            case SCREEN_DIM_WAKE_LOCK://屏幕微亮，键盘暗
            case SCREEN_BRIGHT_WAKE_LOCK://屏幕亮，键盘暗
            case FULL_WAKE_LOCK://全亮
            case PROXIMITY_SCREEN_OFF_WAKE_LOCK:
            case DOZE_WAKE_LOCK:
            case DRAW_WAKE_LOCK:
                break;
            default:
                throw new IllegalArgumentException("Must specify a valid wake lock level.");
        }
        if (tag == null) {
            throw new IllegalArgumentException("The tag must not be null.");
        }
    }

我们再看WakeLock类，先看下面两个持锁，第二个timeout的持锁，先持锁，然后发送一个延迟消息再解锁。

        public void acquire() {
            synchronized (mToken) {
                acquireLocked();
            }
        }

        public void acquire(long timeout) {
            synchronized (mToken) {
                acquireLocked();
                mHandler.postDelayed(mReleaser, timeout);
            }
        }

        private final Runnable mReleaser = new Runnable() {
            public void run() {
                release();
            }
        };

再来看acquireLocked，流程最后是调用了service的acquireWakeLock，但是有一个细节我们注意下，这里有一个mCount的计数。也就是没调用一次这个函数，都会对wakelock的mCount加1。

        private void acquireLocked() {
            if (!mRefCounted || mCount++ == 0) {
                // Do this even if the wake lock is already thought to be held (mHeld == true)
                // because non-reference counted wake locks are not always properly released.
                // For example, the keyguard's wake lock might be forcibly released by the
                // power manager without the keyguard knowing.  A subsequent call to acquire
                // should immediately acquire the wake lock once again despite never having
                // been explicitly released by the keyguard.
                mHandler.removeCallbacks(mReleaser);
                Trace.asyncTraceBegin(Trace.TRACE_TAG_POWER, mTraceName, 0);
                try {
                    mService.acquireWakeLock(mToken, mFlags, mTag, mPackageName, mWorkSource,
                            mHistoryTag);
                } catch (RemoteException e) {
                }
                mHeld = true;
            }
        }

我们再来看看release函数，上面说的mCount计数，这里就会对这个计数进行判断，只有当计数为0，才会去调用service的releaseWakeLock函数。

        public void release(int flags) {
            synchronized (mToken) {
                if (!mRefCounted || --mCount == 0) {
                    mHandler.removeCallbacks(mReleaser);
                    if (mHeld) {
                        Trace.asyncTraceEnd(Trace.TRACE_TAG_POWER, mTraceName, 0);
                        try {
                            mService.releaseWakeLock(mToken, flags);
                        } catch (RemoteException e) {
                        }
                        mHeld = false;
                    }
                }
                if (mCount < 0) {
                    throw new RuntimeException("WakeLock under-locked " + mTag);
                }
            }
        }

所以我们总结下，使用PowerManager的wakelock持锁和释放锁。必须成对出现，当持了2次锁，也必须释放两次锁。才会调用service的释放锁，去真正释放。

二、PowerManagerService相关接口

Service的acquireWakeLock函数我们就不看了，主要是对wakelock的flag做验证，然后调用了acquireWakeLockInternal函数：

    private void acquireWakeLockInternal(IBinder lock, int flags, String tag, String packageName,
            WorkSource ws, String historyTag, int uid, int pid) {
        synchronized (mLock) {
            WakeLock wakeLock;
            int index = findWakeLockIndexLocked(lock);//查找wakelock，IBinder对象为wakelock唯一性
            boolean notifyAcquire;
            if (index >= 0) {
                wakeLock = mWakeLocks.get(index);
                if (!wakeLock.hasSameProperties(flags, tag, ws, uid, pid)) {
                    // Up