Android7.0 PowerManagerService亮灭屏分析(三)

在前面两部分已经对绘制windows与设置设备状态进行了详细讲解. 之后接着就该对亮度值进行设置, 实现亮屏动作了.

在DisplayPowerController中的animateScreenBrightness函数通过亮度渐变动画来将亮度设置到目标亮度.

[java]view plain copy
// Brightness animation ramp rate in brightness units per second.  
private static final int BRIGHTNESS_RAMP_RATE_SLOW = 40;     //亮度渐变动画较慢的速率, 每秒变化40个亮度单位   
  
    mBrightnessRampRateFast = resources.getInteger(  
            com.android.internal.R.integer.config_brightness_ramp_rate_fast);   //从配置文件中获取较快的亮度速率  
  
    // Animate the screen brightness when the screen is on or dozing.  
    // Skip the animation when the screen is off or suspended.  
    if (!mPendingScreenOff) {  
        if (state == Display.STATE_ON || state == Display.STATE_DOZE) {  
            animateScreenBrightness(brightness,      //当亮屏或doze状态时有亮度渐变动画  
                    slowChange ? BRIGHTNESS_RAMP_RATE_SLOW : mBrightnessRampRateFast);  
        } else {  
            animateScreenBrightness(brightness, 0);   //灭屏时没有亮度渐变动画,直接将亮度设置为0  
        }  
    }  

在animateScreenBrightness函数中调用动画mScreenBrightnessRampAnimator对亮度值处理, 而mScreenBrightnessRampAnimator是在initialize()函数中进行初始化的, 在构造函数中将DisplayPowerState和DisplayPowerState.SCREEN_BRIGHTNESS传输过去.

[java]view plain copy
  private void initialize() {  
      //....  
        mScreenBrightnessRampAnimator = new RampAnimator<DisplayPowerState>(  //泛型为DisplayPowerState  
                mPowerState, DisplayPowerState.SCREEN_BRIGHTNESS);  
        mScreenBrightnessRampAnimator.setListener(mRampAnimatorListener);  
     //...  
}  
  
    private void animateScreenBrightness(int target, int rate) {  
        if (DEBUG) {  
            Slog.d(TAG, "Animating brightness: target=" + target +", rate=" + rate);  
        }  
        if (mScreenBrightnessRampAnimator.animateTo(target, rate)) {    //动画处理亮度值  
            try {  
                mBatteryStats.noteScreenBrightness(target);  
            } catch (RemoteException ex) {  
                // same process  
            }  
        }  
    }  

在RampAnimator的构造函数中将DisplayPowerState赋值给mObject, DisplayPowerState.SCREEN_BRIGHTNESS赋值给mProperty, 并且创建mChoreographer实例.

[java]view plain copy
public RampAnimator(T object, IntProperty<T> property) {  
    mObject = object;  
    mProperty = property;  
    mChoreographer = Choreographer.getInstance();  
}  

下面重点讲解animateTo函数.

[java]view plain copy
public boolean animateTo(int target, int rate) {  
    // Immediately jump to the target the first time.  
    if (mFirstTime || rate <= 0) {   //当第一次调用animateTo, 或者rate小于等于0时直接设置目标亮度.  
        if (mFirstTime || target != mCurrentValue) {  
            mFirstTime = false;   //之后就不是第一次调用该函数  
            mRate = 0;              //设置mRate为0  
            mTargetValue = target;   //设置目标亮度为target  
            mCurrentValue = target;  
            mProperty.setValue(mObject, target);   //调用DisplayPowerState.SCREEN_BRIGHTNESS设置亮度值  
            if (mAnimating) {  
                mAnimating = false;  
                cancelAnimationCallback();  
            }  
            if (mListener != null) {  
                mListener.onAnimationEnd();  //动画结束  
            }  
            return true;  
        }  
        return false;  
    }  
  
    // Adjust the rate based on the closest target.  
    // If a faster rate is specified, then use the new rate so that we converge  
    // more rapidly based on the new request.  
    // If a slower rate is specified, then use the new rate only if the current  
    // value is somewhere in between the new and the old target meaning that  
    // we will be ramping in a different direction to get there.  
    // Otherwise, continue at the previous rate.  
    if (!mAnimating  
            || rate > mRate  
            || (target <= mCurrentValue && mCurrentValue <= mTargetValue)  
            || (mTargetValue <= mCurrentValue && mCurrentValue <= target)) {  
        mRate = rate;   //重新调节亮度速率  
    }  
  
    final boolean changed = (mTargetValue != target);  //如果当前亮度值不等于目标亮度值,说明亮度改变了  
    mTargetValue = target;    //重新设置mTargetValue  
  
    // Start animating.  开始动画  
    if (!mAnimating && target != mCurrentValue) {    
        mAnimating = true;  
        mAnimatedValue = mCurrentValue;  
        mLastFrameTimeNanos = System.nanoTime();  
        postAnimationCallback();  
    }  
  
    return changed;   
}  

在postAnimationCallback中调用Choreographer的postCallback函数处理, 调用完成后回调回mAnimationCallback的run函数

[java]view plain copy
private void postAnimationCallback() {  
    mChoreographer.postCallback(Choreographer.CALLBACK_ANIMATION, mAnimationCallback, null);  
}  
  
private final Runnable mAnimationCallback = new Runnable() {  
    @Override // Choreographer callback  
    public void run() {  
        final long frameTimeNanos = mChoreographer.getFrameTimeNanos();  
        final float timeDelta = (frameTimeNanos - mLastFrameTimeNanos)  
                * 0.000000001f;  
        mLastFrameTimeNanos = frameTimeNanos;  //记录最后一次的frameTimeNanos  
  
        // Advance the animated value towards the target at the specified rate  
        // and clamp to the target. This gives us the new current value but  
        // we keep the animated value around to allow for fractional increments  
        // towards the target.  
        final float scale = ValueAnimator.getDurationScale();  
        if (scale == 0) {  
            // Animation off.  
            mAnimatedValue = mTargetValue;   //让scale为0时, 表示动画停止了, 将mAnimatedValue设置为目标亮度  
        } else {  
            final float amount = timeDelta * mRate / scale;  //计算每一次需要变化的亮度值  
            if (mTargetValue > mCurrentValue) {  
                mAnimatedValue = Math.min(mAnimatedValue + amount, mTargetValue);  //亮屏,每次增加亮度amount,不超过目标亮度  
            } else {  
                mAnimatedValue = Math.max(mAnimatedValue - amount, mTargetValue); //暗屏, 每次减少amount个亮度, 不超过目标亮度  
            }  
        }  
        final int oldCurrentValue = mCurrentValue;  
        mCurrentValue = Math.round(mAnimatedValue);  //获取当前要达到的亮度值  
  
        if (oldCurrentValue != mCurrentValue) {  
            mProperty.setValue(mObject, mCurrentValue);  //调用DisplayPowerState.SCREEN_BRIGHTNESS设置亮度值  
        }  
  
        if (mTargetValue != mCurrentValue) {  
            postAnimationCallback();   //如果还没有达到目标亮度,就会继续调用postAnimationCallback循环设置亮度值  
        } else {  
            mAnimating = false;  
            if (mListener != null) {  
                mListener.onAnimationEnd();  //否则,亮度动画结束  
            }  
        }  
    }  
};  

DisplayPowerState.SCREEN_BRIGHTNESS的setValue函数是在DisplayPowerState中实现的.

[java]view plain copy
public static final IntProperty<DisplayPowerState> SCREEN_BRIGHTNESS =  
        new IntProperty<DisplayPowerState>("screenBrightness") {  
    @Override  
    public void setValue(DisplayPowerState object, int value) {  
        object.setScreenBrightness(value);  //调用DisplayPowerState的setScreenBrightness函数,设置亮度值  
    }  
  
    @Override  
    public Integer get(DisplayPowerState object) {  
        return object.getScreenBrightness();  
    }  
};  
  
public void setScreenBrightness(int brightness) {  
    if (mScreenBrightness != brightness) {  
        if (DEBUG) {  
            Slog.d(TAG, "setScreenBrightness: brightness=" + brightness);  
        }  
  
        mScreenBrightness = brightness;  //设置全局的亮度值  
        if (mScreenState != Display.STATE_OFF) {  
            mScreenReady = false;  
            scheduleScreenUpdate();   //如果不是灭屏状态,更新屏幕状态  
        }  
    }  
}  

scheduleScreenUpdate函数最终通过Handler发送mScreenUpdateRunnable对象来更新亮度值. 从run函数中可以看出只有当mColorFadeLevel > 0f时才能给brightness设置亮度值, 所以说当windows没有绘制完成时就算mScreenBrightness有值不为0, 但是brightness仍然为0不能点亮屏幕.

[java]view plain copy
private final Runnable mScreenUpdateRunnable = new Runnable() {  
    @Override  
    public void run() {  
        mScreenUpdatePending = false;  
  
        int brightness = mScreenState != Display.STATE_OFF  
                && mColorFadeLevel > 0f ? mScreenBrightness : 0;    //判断设置亮度值  
        if (mPhotonicModulator.setState(mScreenState, brightness)) {  
            if (DEBUG) {  
                Slog.d(TAG, "Screen ready");  
            }  
            mScreenReady = true;  
            invokeCleanListenerIfNeeded();  
        } else {  
            if (DEBUG) {  
                Slog.d(TAG, "Screen not ready");  
            }  
        }  
    }  
};  

之后的流程就与设置设置状态的流程相同了, 调用DisplayManagerService中DisplayBlanker的requestDisplayState函数.

[java]view plain copy
DisplayBlanker blanker = new DisplayBlanker() {  
    @Override  
    public void requestDisplayState(int state, int brightness) {  
        // The order of operations is important for legacy reasons.  
        if (state == Display.STATE_OFF) {  
            requestGlobalDisplayStateInternal(state, brightness);  
        }  
  
        callbacks.onDisplayStateChange(state);      
  
        if (state != Display.STATE_OFF) {  
            requestGlobalDisplayStateInternal(state, brightness);  //亮屏调用设置状态,亮度  
        }  
    }  
};  

[java]view plain copy
private void requestGlobalDisplayStateInternal(int state, int brightness) {  
    if (state == Display.STATE_UNKNOWN) {  
        state = Display.STATE_ON;  
    }  
    if (state == Display.STATE_OFF) {  
        brightness = PowerManager.BRIGHTNESS_OFF;  //灭屏设置屏幕亮度为0  
    } else if (brightness < 0) {  
        brightness = PowerManager.BRIGHTNESS_DEFAULT;  //屏幕亮度小于0,设置为默认亮度  
    } else if (brightness > PowerManager.BRIGHTNESS_ON) {  
        brightness = PowerManager.BRIGHTNESS_ON;    //屏幕亮度大于255设置最大亮度值255  
    }  
  
    synchronized (mTempDisplayStateWorkQueue) {  
        try {  
            // Update the display state within the lock.  
            // Note that we do not need to schedule traversals here although it  
            // may happen as a side-effect of displays changing state.  
            synchronized (mSyncRoot) {  
                if (mGlobalDisplayState == state  
                        && mGlobalDisplayBrightness == brightness) {  
                    return; // no change     亮度与状态都没有改变就return  
                }  
  
                Trace.traceBegin(Trace.TRACE_TAG_POWER, "requestGlobalDisplayState("  
                        + Display.stateToString(state)  
                        + ", brightness=" + brightness + ")");  
                mGlobalDisplayState = state;  
                mGlobalDisplayBrightness = brightness;  
                applyGlobalDisplayStateLocked(mTempDisplayStateWorkQueue);   //应用全局状态  
            }  
  
            // Setting the display power state can take hundreds of milliseconds  
            // to complete so we defer the most expensive part of the work until  
            // after we have exited the critical section to avoid blocking other  
            // threads for a long time.  
            for (int i = 0; i < mTempDisplayStateWorkQueue.size(); i++) {  
                mTempDisplayStateWorkQueue.get(i).run();  //运行mTempDisplayStateWorkQueue队列中的runnable  
            }  
            Trace.traceEnd(Trace.TRACE_TAG_POWER);  
        } finally {  
            mTempDisplayStateWorkQueue.clear();  
        }  
    }  
}  

在applyGlobalDisplayStateLocked函数中获取所有的devices, 调用对应设备的requestDisplayStateLocked函数更新请求状态. 启动devices为LocalDisplayAdapter, 就会调用到该类的requestDisplayStateLocked获得runnable.

[java]view plain copy
private void applyGlobalDisplayStateLocked(List<Runnable> workQueue) {  
    final int count = mDisplayDevices.size();  
    for (int i = 0; i < count; i++) {   //遍历devices  
        DisplayDevice device = mDisplayDevices.get(i);  
        Runnable runnable = updateDisplayStateLocked(device);  //获得devices中的runnable  
        if (runnable != null) {  
            workQueue.add(runnable);  //将runnable加入workQueue队列, 即mTempDisplayStateWorkQueue队列  
        }  
    }  
}  
  
private Runnable updateDisplayStateLocked(DisplayDevice device) {  
    // Blank or unblank the display immediately to match the state requested  
    // by the display power controller (if known).  
    DisplayDeviceInfo info = device.getDisplayDeviceInfoLocked();  //获取devices信息  
    if ((info.flags & DisplayDeviceInfo.FLAG_NEVER_BLANK) == 0) {  
        return device.requestDisplayStateLocked(mGlobalDisplayState, mGlobalDisplayBrightness); //调用requestDisplayStateLocked函数  
    }  
    return null;  
}  

在requestDisplayStateLocked中主要的任务就是创建一个runnable返回到DisplayManagerService中,并且等待回调run函数.

[java]view plain copy
@Override  
public Runnable requestDisplayStateLocked(final int state, final int brightness) {  
    // Assume that the brightness is off if the display is being turned off.  
    assert state != Display.STATE_OFF || brightness == PowerManager.BRIGHTNESS_OFF;  
  
    final boolean stateChanged = (mState != state);  //状态是否改变  
    final boolean brightnessChanged = (mBrightness != brightness) && mBacklight != null;  //亮度值是否改变  
    if (stateChanged || brightnessChanged) {  //如果亮度值或者亮度状态发生改变就重新设置对应值  
        final int displayId = mBuiltInDisplayId;  
        final IBinder token = getDisplayTokenLocked();  
        final int oldState = mState;  
  
        if (stateChanged) {   //设置亮度时.状态已经设置好,无变化  
            mState = state;  
            updateDeviceInfoLocked();  
        }  
  
        if (brightnessChanged) {  
            mBrightness = brightness;  //设置mBrightness  
        }  
  
        // Defer actually setting the display state until after we have exited  
        // the critical section since it can take hundreds of milliseconds  
        // to complete.  
        return new Runnable() {    //新建一个runnable返回  
            @Override  
            public void run() {  //在DisplayManagerService中调用run函数  
                // Exit a suspended state before making any changes.    
                int currentState = oldState;  
                if (Display.isSuspendedState(oldState)    //判断设置是否还是在suspend状态  
                        || oldState == Display.STATE_UNKNOWN) {  
                    if (!Display.isSuspendedState(state)) {  
                        setDisplayState(state);  
                        currentState = state;  
                    } else if (state == Display.STATE_DOZE_SUSPEND  
                            || oldState == Display.STATE_DOZE_SUSPEND) {  
                        setDisplayState(Display.STATE_DOZE);  
                        currentState = Display.STATE_DOZE;  
                    } else {  
                        return; // old state and new state is off  
                    }  
                }  
  
                // Apply brightness changes given that we are in a non-suspended state.  
                if (brightnessChanged) {  
                    if (isPowerDebug()) {  
                        Slog.d(TAG, "set display brightness=" + brightness);  
                    }  
                    setDisplayBrightness(brightness);    //设置屏幕亮度  
                }  
  
                // Enter the final desired state, possibly suspended.  
                if (state != currentState) {  
                    if(isPowerDebug()) {  
                        Slog.d(TAG, "set display state=" + state);  
                    }  
                    setDisplayState(state);  
                }  
            }  

[java]view plain copy
            private void setDisplayBrightness(int brightness) {  
                if (DEBUG) {  
                    Slog.d(TAG, "setDisplayBrightness("  
                            + "id=" + displayId + ", brightness=" + brightness + ")");  
                }  
  
                Trace.traceBegin(Trace.TRACE_TAG_POWER, "setDisplayBrightness("  
                        + "id=" + displayId + ", brightness=" + brightness + ")");  
                try {  
                    mBacklight.setBrightness(brightness);   //调用LightService设置亮度  
                } finally {  
                    Trace.traceEnd(Trace.TRACE_TAG_POWER);  
                }  
            }  
        };  
    }  
    return null;  
}  

[java]view plain copy
@Override  
public void setBrightness(int brightness) {  
    setBrightness(brightness, BRIGHTNESS_MODE_USER);   //亮度模式默认为BRIGHTNESS_MODE_USER  
}  
  
@Override  
public void setBrightness(int brightness, int brightnessMode) {  
    synchronized (this) {  
        int color = brightness & 0x000000ff;  
        color = 0xff000000 | (color << 16) | (color << 8) | color;   //设置光颜色  
        setLightLocked(color, LIGHT_FLASH_NONE, 0, 0, brightnessMode);  
    }  
}  
private void setLightLocked(int color, int mode, int onMS, int offMS, int brightnessMode) {  
    if (!LightsUtilsFactory.getInstance().isBatteryOpenWhenNotificationCome(mId, color)){  
        if (!mLocked && (color != mColor || mode != mMode || onMS != mOnMS || offMS != mOffMS ||  
                mBrightnessMode != brightnessMode)) {  
            if (DEBUG || isDebugNotifyLight()) Slog.v(TAG, "setLight #" + mId + ": color=#"  
                    + Integer.toHexString(color) + ": brightnessMode=" + brightnessMode);  
            mLastColor = mColor;  
            mColor = color;  
            mMode = mode;  
            mOnMS = onMS;  
            mOffMS = offMS;  
            mLastBrightnessMode = mBrightnessMode;  
            mBrightnessMode = brightnessMode;  
            Trace.traceBegin(Trace.TRACE_TAG_POWER, "setLight(" + mId + ", 0x"  
                    + Integer.toHexString(color) + ")");  
            try {  
                setLight_native(mNativePointer, mId, color, mode, onMS, offMS, brightnessMode);  //调用jni层设置亮度  
            } finally {  
                Trace.traceEnd(Trace.TRACE_TAG_POWER);  
            }  
        }  
    }  
}  

通过JNI调用com_android_server_lights_LightsService.cpp的setLight_native函数

[java]view plain copy
static void setLight_native(JNIEnv* /* env */, jobject /* clazz */, jlong ptr,  
        jint light, jint colorARGB, jint flashMode, jint onMS, jint offMS, jint brightnessMode)  
{  
    Devices* devices = (Devices*)ptr;  
    light_state_t state;  
  
    if (light < 0 || light >= LIGHT_COUNT || devices->lights[light] == NULL) {  
        return ;  
    }  
  
    uint32_t version = devices->lights[light]->common.version;  
  
    memset(&state, 0, sizeof(light_state_t));  
  
    if (brightnessMode == BRIGHTNESS_MODE_LOW_PERSISTENCE) {  
        if (light != LIGHT_INDEX_BACKLIGHT) {  
            ALOGE("Cannot set low-persistence mode for non-backlight device.");  
            return;  
        }  
        if (version < LIGHTS_DEVICE_API_VERSION_2_0) {  
            // HAL impl has not been upgraded to support this.  
            return;  
        }  
    } else {  
        // Only set non-brightness settings when not in low-persistence mode  
        state.color = colorARGB;  
        state.flashMode = flashMode;  
        state.flashOnMS = onMS;  
        state.flashOffMS = offMS;  
    }  
  
    state.brightnessMode = brightnessMode;  
  
    {  
        ALOGD_IF_SLOW(50, "Excessive delay setting light");   //当设置亮度耗时大于50ms,就会输出该行log.  
        devices->lights[light]->set_light(devices->lights[light], &state);  
    }  
}  

之后调用BSP向亮度节点写入亮度值. 从而点亮屏幕.

灭屏流程分析

灭屏总览

Android7.0 PowerManagerService亮灭屏分析(三)

在点击power键灭屏过程中，主要流程就是input对按键事件的传输，传送到上层处理。在PhoneWindowManager中判断是否为灭屏事件, 之后就是在power中进行对亮屏状态的处理，计算一系列的数值，并且与AMS，WMS等模块进行交互，最后调用底层LCD进行最终的设备状态与亮度的设置。灭屏流程与亮屏流程有很多共同流程，在这里只讲解灭屏的独特流程。
Android7.0 PowerManagerService亮灭屏分析(三)
当wakefulness状态发生改变，AMS收到通知。如果亮屏操作，AMS就会通过函数comeOutOfSleepIfNeedLocked调用到ActivityStackSupervisor中，将sleep超时消息移除，如果抓的有partial锁，就将其释放，最后将在栈顶的activity显示出来。
当亮屏时通过InputManagerService将当前屏幕状态传入JNI中进行记录，当再次发生power键事件可以方便确认该事件是需要亮屏还是灭屏。
灭屏时首先在Notifier中通过PhoneWindowManager来通知keyguard系统开始灭屏。
灭屏动画
在PowerManagerService中获得屏幕的请求状态为OFF，即设置state为Display.STATE_OFF，在这里将performScreenOffTransition为true。

[java]view plain copy
case DisplayPowerRequest.POLICY_OFF:  
    state = Display.STATE_OFF;  
    performScreenOffTransition = true;  
    break;  

调用animateScreenStateChange进行处理屏幕状态。

[java]view plain copy
// Animate the screen state change unless already animating.  
// The transition may be deferred, so after this point we will use the  
// actual state instead of the desired one.  
animateScreenStateChange(state, performScreenOffTransition);  
state = mPowerState.getScreenState();  

如果目标亮度不为STATE_ON，STATE_DOZE，STATE_DOZE_SUSPEND屏幕就要去睡眠了。

[java]view plain copy
// Want screen off.  
mPendingScreenOff = true;  
if (mPowerState.getColorFadeLevel() == 0.0f) {  
    // Turn the screen off.  
    // A black surface is already hiding the contents of the screen.  
    setScreenState(Display.STATE_OFF);  
    mPendingScreenOff = false;  
    mPowerState.dismissColorFadeResources();  
} else if (performScreenOffTransition  
        && mPowerState.prepareColorFade(mContext,  
                mColorFadeFadesConfig ?  
                        ColorFade.MODE_FADE : ColorFade.MODE_COOL_DOWN)  
        && mPowerState.getScreenState() != Display.STATE_OFF) {  
    // Perform the screen off animation.  
    mColorFadeOffAnimator.start();  
} else {  
    // Skip the screen off animation and add a black surface to hide the  
    // contents of the screen.  
    mColorFadeOffAnimator.end();  
}  

在这里就要判断ColorFadeLevel是不是0.0，由于亮屏时将ColorFadeLevel设置为1.0所以走else语句，如果performScreenOffTransition为true并且将ColorFade准备好了就开始灭屏动画将ColorFadeLevel从1.0渐变为0.0。但是前面知道将performScreenOffTransition设置为了false，所以就没有了灭屏动画，直接将ColorFadeLevel设置为0.0。之后就调用setScreenState设置状态。
发送灭屏广播
Android7.0 PowerManagerService亮灭屏分析(三)

power是通过WindowManagerPolicy与PhoneWindowManager进行交互，当屏幕在finishedGoingToSleep时需要通知window进行更新手势监听，更新方向监听，更新锁屏超时时间。之后发送灭屏广播通知关心灭屏事件的模块。

到此为止亮灭屏流程讲解完毕.