安卓手机来电亮屏流程分析

来电亮屏流程分析

本文档是针对手机来电时候自主点亮屏幕这一流程的分析,很自然的就将其分为2个阶段,第一个是来电，第二个是点亮屏幕。

来电的流程：

来电消息是从RIL层接收到的，然后才开始传递上来。

AT : RING

AT : AT< RING

AT : RIL_URC_READER:RING

AT : RIL_URC_READER Enter processLine

use-Rlog/RLOG-RIL: Nw URC:RING

use-Rlog/RLOG-RIL: receiving RING!!!!!!

use-Rlog/RLOG-RIL: receiving first RING!!!!!!

use-Rlog/RLOG-RIL: sending ECPI!!!!!!

同时也向RIL.java上报UNSOL_RESPONSE_CALL_STATE_CHANGED消息，RIL.java收到将才标志转换为RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED，这告诉我们真正处理代码在哪个分支里，看下面代码：

processUnsolicited (Parcel p) {//主动上报的命令

…省略代码……

case RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED:

mCallStateRegistrants .notifyRegistrants(new AsyncResult(null, null, null);

break;

}

上面这个通知发到GsmCallTracker.java文件中的构造函数中，在这里面就能看到要找的事件（EVENT_CALL_STATE_CHANGE）了：

GsmCallTracker (GSMPhone phone) {

this.phone = phone;

cm = phone.mCM;

cm.registerForCallStateChanged(this, EVENT_CALL_STATE_CHANGE, null);

cm.registerForOn(this, EVENT_RADIO_AVAILABLE, null);

cm.registerForNotAvailable(this, EVENT_RADIO_NOT_AVAILABLE, null);

}

在文件BaseCommands.java中有对函数的实现：

public void registerForCallStateChanged(Handler h, int what, Object obj) {

Registrant r = new Registrant (h, what, obj);

mCallStateRegistrants.add(r);

}

当然EVENT_CALL_STATE_CHANGE这个消息的上会有很多原因，除了来电消息RING，还有挂断消息NOCARRIER、电话状态改变消息CLCC等，RIL都会作为EVENT_CALL_STATE_CHANGE报给GsmCallTracker.java，GsmCalTracker.java收到之后会，在handleMessage()对应分支中进行处理，代码如下：

case EVENT_CALL_STATE_CHANGE:

pollCallsWhenSafe();

break;

进入pollCallsWhenSafe（）方法中，又见消息，这回是主动查询CLCC，查询一下通话列表，即查询所有的通话详情，在这个分支 EVENT_POLL_CALLS_RESULT里获得查询结果：

protected void pollCallsWhenSafe() {

needsPoll = true;

if (checkNoOperationsPending()) {

lastRelevantPoll = obtainMessage(EVENT_POLL_CALLS_RESULT);

cm.getCurrentCalls(lastRelevantPoll);

}

处理EVENT_POLL_CALLS_RESULT消息是在GsmCallTracker.java中：

case EVENT_POLL_CALLS_RESULT:

ar = (AsyncResult)msg.obj;

if (msg == lastRelevantPoll) {

if (DBG_POLL) log(

"handle EVENT_POLL_CALL_RESULT: set needsPoll=F");

needsPoll = false;

lastRelevantPoll = null;

handlePollCalls((AsyncResult)msg.obj);

}

break;

进入handlePollCalls()方法中，在这个方法里将揭开CLCC命令返回参数和connections集合里的元素的是什么关系？handlePollCalls()方法中会进行一个for循环操作，底层查的通话列表用DriverCall类表示，FrameWork层则抽象为GsmConnection类，在这里先看一个关于CLCC命令的例子：

CLCC ： 1、0、2、0、0 1881234578 …..

先是CLCC这个command，后面

第一个参数表示 index序号，

每二个如是0表示来电、1表示去电，

第三个是电话状态，

第四个表示是数据业务还是语音业务，

第五个表示是否是视频会议，后面再跟着号码。

CLCC返回的电话列表中，第一个参数就是没路通话的编号，从1开始编号，同样可以看到GsmCallTracker中保存的GsmConnection的集合connections集合对象是一个数组，数组编号是从0开始的，所以我们会看到会有一个dc.index == i+1；的操作，对应关系就是这里建立的。之后会把底层查的DriverCall对象和GsmCallTracker中保存的GsmConnection对象进行比较。如DriverCall对象为空，我们本地保持的GsmConnection对象存在，很显然，是这路电话挂断了，反之如过DriverCall对象有，GsmConnection对象不存在，则是一个来电：

if (conn == null && dc != null){

if (newRinging != null) {

phone.notifyNewRingingConnection(newRinging);

}}

在phoneBase.java里发出通知

protected void notifyNewRingingConnectionP(Connection cn) {

if (!mIsVoiceCapable)

return;

syncResult ar = new AsyncResult(null, cn, null);

mNewRingingConnectionRegistrants.notifyRegistrants(ar);

}

再后面的代码就离开Framework层了，这里把来电消息通知给上层应用：

private void registerForNotifications() {

mCM.registerForNewRingingConnection(this,PHONE_NEW_RINGING_CONNECTION, null);

….后面的代码省略

}

public void registerForNewRingingConnection(

Handler h, int what, Object obj) {

checkCorrectThread(h);

mNewRingingConnectionRegistrants.addUnique(h, what, obj);

}

PHONE_NEW_RINGING_CONNECTION这个消息发送出去之后,是在CallNotifier.java文件中处理的：

public void handleMessage(Message msg) {

if(handleMessageMTK(msg)) {

return;

}

switch (msg.what) {

case CallStateMonitor.PHONE_NEW_RINGING_CONNECTION:

log("RINGING... (new)");

onNewRingingConnection((AsyncResult) msg.obj);

mSilentRingerRequested = false;

break;

}…省略代码…

}

下面有对来电铃音连接事件的处理：

/**

* Handles a "new ringing connection" event from the telephony layer.

private void onNewRingingConnection(AsyncResult r) {

Connection c = (Connection) r.result;

log("onNewRingingConnection(): state = " + mCM.getState() + ", conn = { " + c + " }");

Call ringing = c.getCall();

Phone phone = ringing.getPhone();

if (ignoreAllIncomingCalls(phone)) {//在这里面会有去查询黑名单或则其他操作，从而决定是否自动拒接来电

PhoneUtils.hangupRingingCall(ringing);

return;

}

…省略代码…

Call.State state = c.getState();//手机状态

// State will be either INCOMING or WAITING.

if (VDBG) log("- connection is ringing! state = " + state);

if (PhoneUtils.isRealIncomingCall(state)) {

PhoneUtils.setAudioControlState(PhoneUtils.AUDIO_RINGING);

if (mApplication.getWiredHeadsetManager().isHeadsetPlugged() && isIncomingMuteOrVibrate()) {

playCallWaitingTone();

}

PhoneUtils.setAudioMode();

} else {

mShouldSkipRing = true;

}

startIncomingCallQuery(c);

sendEmptyMessageDelayed(DELAY_AUTO_ANSWER, 3000);

if (VDBG) log("- onNewRingingConnection() done.");

}

在这之后会根据获取当前手机的状态模式判断是否处于摘机状态等。

PhoneConstants.State state = mCM.getState();

判断响铃的模式：

public void setRingerMode(int ringerMode) {…代码省略…}

startIncomingCallQuery(c)//取数据库查找相应的资源，比如用什么铃音就会去里面查找：

private void startIncomingCallQuery(Connection c) {

if (shouldStartQuery) {

setDefaultRingtoneUri(c);//设置默认的铃声

}

public void applyDeviceVolume(int device) {…代码省略…}//设置设备音量

public Uri getDefaultRingtone(int type) {}//根据传入的type类型设置默认的铃音,1为TYPE_RINGTONE，2为TYPE_NOTIFICATION

public static CallerInfoToken startGetCallerInfo(Context context, Connection c,CallerInfoAsyncQuery.OnQueryCompleteListener listener, Object cookie,RawGatewayInfo info){}//这里面可以看到呼叫方的号码，和当前电话用的什么网络。

startIncomingCallQuery中最后会执行响铃并通知有来电了：

private void ringAndNotifyOfIncomingCall(Connection c) {

mCallModeler.onNewRingingConnection(c);

}

函数onNewRingingConnection的实现：

Call onNewRingingConnection(Connection conn) {

Log.i(TAG, "onNewRingingConnection");

updateDualTalkCallInfo();

final Call call = getCallFromMap(mCallMap, conn, true);

if (call != null) {

updateCallFromConnection(call, conn, false);

for (int i = 0; i < mListeners.size(); ++i) {

mListeners.get(i).onIncoming(call);

}

PhoneGlobals.getInstance().updateWakeState();//这里开始更新唤醒状态

return call;

}

更新唤醒状态：

void updateWakeState() {

…省略代码…

requestWakeState(keepScreenOn ? WakeState.FULL : WakeState.SLEEP);

}

public void requestWakeState(WakeState ws) {

synchronized (this) {

if (mWakeState != ws) {

if(is82SMBPlugged()){

ws = WakeState.SLEEP;

}

switch (ws) {

case PARTIAL:

mPartialWakeLock.acquire();

if (mWakeLock.isHeld()) {

mWakeLock.release();

}

break;

case FULL:

mWakeLock.acquire();

if (mPartialWakeLock.isHeld()) {

mPartialWakeLock.release();

}

break;

case SLEEP:

default:

if (mWakeLock.isHeld()) {

mWakeLock.release();

}

if (mPartialWakeLock.isHeld()) {

mPartialWakeLock.release();

}

break;

}

mWakeState = ws;

}

以上就基本上完成了来电流程的总结。

亮屏的流程：

点亮屏幕是从唤醒开始的:

首先根据mProximityPositive的值检查屏幕当前是否处于远离状态,如果是远离状态的话才会去点亮,否则是不会去点亮的。

如果处于远离状态需要去判断唤醒锁是否需要更新，如果需要更新那么就会去执行更新操作。

函数wakeUpNoUpdateLocked(eventTime)的作用就是去判断唤醒锁是否需要更新，首先会根据mWakefulness的值去执行相应的操作，如果为WAKEFULNESS_ASLEEP，且mIPOShutdown为false时候，执行如下操作：

case WAKEFULNESS_ASLEEP://接收到唤醒消息

if (!mIPOShutdown) {

sendPendingNotificationsLocked();

mNotifier.onWakeUpStarted();//开始唤醒

mSendWakeUpFinishedNotificationWhenReady = true;

}

break;

要开始唤醒就需要捕获亮屏阻塞个数，每捕获一次就增加一个。然后更新广播锁,即是执行函数updatePendingBroadcastLocked()。首先也是捕获阻塞块，也是捕获一次就增加一个，然后发送一个MSG_BROADCAST的消息，且这个消息是异步执行的。

接收到MSG_BROADCAST这个消息后会执行sendNextBroadcast()方法。如果powerState的值等于POWER_STATE_AWAKE，那么就发送唤醒广播，否则就发送休眠广播。

if (powerState == POWER_STATE_AWAKE) {

sendWakeUpBroadcast();//发起唤醒广播

} else {

sendGoToSleepBroadcast(goToSleepReason);//发送休眠广播

}

判断用户界面锁是否更新，根据mUserActivityPending的值决定是否发送异步执行的消息MSG_USER_ACTIVITY，从而执行方法sendUserActivity()。

发送的唤醒广播最重要的操作就是执行方法：

ActivityManagerNative.getDefault().wakingUp()，这个方法不是立即就能完成的，可能会有一定延迟才能完成，但是当他完成后，且系统已经准备好就会发出一个唤醒已经结束的广播：

if (ActivityManagerNative.isSystemReady()) {

mContext.sendOrderedBroadcastAsUser(mScreenOnIntent, UserHandle.ALL, null,mWakeUpBroadcastDone, mHandler, 0, null, null);

} else {

EventLog.writeEvent(EventLogTags.POWER_SCREEN_BROADCAST_STOP, 2, 1);

sendNextBroadcast();

}

这个广播的接收器如下：

private final BroadcastReceiver mWakeUpBroadcastDone = new BroadcastReceiver(){

@Override

public void onReceive(Context context, Intent intent) {

EventLog.writeEvent(EventLogTags.POWER_SCREEN_BROADCAST_DONE, 1,

SystemClock.uptimeMillis() - mBroadcastStartTime, 1);

sendNextBroadcast();

}

这里的广播从发送到接收到有一定延迟，甚至可能出现有巨大延迟的状况,因为只有系统认为亮屏结束的时候才会认定广播接收完成。

当确认需要更新唤醒锁，即是wakeUpNoUpdateLocked(eventTime)的值为true时，就会去执行更新就是执行方法updatePowerStateLocked()。

updatePowerStateLocked(eventTime)这个函数非常重要，他会去更新很多锁的状态代码如下：

private void updatePowerStateLocked() {

if (!mSystemReady || mDirty == 0) {

return;

}

updateIsPoweredLocked(mDirty);

updateStayOnLocked(mDirty);

final long now = SystemClock.uptimeMillis();

int dirtyPhase2 = 0;

for (;;) {

int dirtyPhase1 = mDirty;

dirtyPhase2 |= dirtyPhase1;

mDirty = 0;

updateWakeLockSummaryLocked(dirtyPhase1);

updateUserActivitySummaryLocked(now, dirtyPhase1);

if (!updateWakefulnessLocked(dirtyPhase1)) {

break;

}

updateDreamLocked(dirtyPhase2);

updateDisplayPowerStateLocked(dirtyPhase2);

if (mDisplayReady) {

sendPendingNotificationsLocked();

}

updateSuspendBlockerLocked();

}

updateWakeLockSummaryLocked(dirtyPhase1)：更新唤醒锁主锁，根据wakeLocked中flag值与上PowerManager.WAKE_LOCK_LEVEL_MASK进行匹配，根据各种匹配结果对mWakeLockSummary进行赋值。这里一共有如下几种锁：

PARTIAL_WAKE_LOCK:保持CPU 运转，屏幕和键盘灯有可能是关闭的。

SCREEN_DIM_WAKE_LOCK：保持CPU 运转，允许保持屏幕显示但有可能是灰的，允许关闭键盘灯

SCREEN_BRIGHT_WAKE_LOCK：保持CPU 运转，允许保持屏幕高亮显示，允许关闭键盘灯

FULL_WAKE_LOCK：保持CPU 运转，保持屏幕高亮显示，键盘灯也保持亮度

我们这里关注的就是FULL_WAKE_LOCK，当mWakefulness不为WAKEFULNESS_ASLEEP

mWakeLockSummary |= WAKE_LOCK_CPU | WAKE_LOCK_SCREEN_BRIGHT | WAKE_LOCK_BUTTON_BRIGHT。如果此时mWakefulness还等于WAKEFULNESS_AWAKE那么还要或上WAKE_LOCK_STAY_AWAKE。

updateUserActivitySummaryLocked(now, dirtyPhase1)：这个函数作用就根据不同的情况设置mUserActivitySummary的值，而此时就需要注意给其赋值的三个参数，分别是：按键亮：USER_ACTIVITY_BUTTON_BRIGHT，屏幕亮：USER_ACTIVITY_SCREEN_BRIGHT，和屏幕暗：USER_ACTIVITY_SCREEN_DIM。

updateDisplayPowerStateLocked(dirtyPhase2)：这个函数的作用是更新显示状态锁的，这里面最重要的newScreenState屏幕状态值，screenBrightness屏幕亮度值。函数中会对按键背光亮灭做处理：

if ( ( (mWakeLockSummary & WAKE_LOCK_BUTTON_BRIGHT) != 0 ) ||

( (mUserActivitySummary & USER_ACTIVITY_BUTTON_BRIGHT) != 0) ) {

mButtonLight.setBrightness(screenBrightness);

} else {

mButtonLight.turnOff();

}

mDisplayReady显示是否准备好，他会通过mDisplayPowerController的requestPowerState方法判断得出，注意这里有延时，或者是说有了反馈消息才能获得mDisplayReady的值。requestPowerState方法返回的是mDisplayReadyLocked，而只有当change的值为false，即是状态锁没有更新的时候。在有更改的时候可能会去发送更新电源状态锁即是执行函数sendUpdatePowerStateLocked()，而这个函数的作用就是发出一个更新电源状态的消息：MSG_UPDATE_POWER_STATE。接收消息的地方是：

switch (msg.what) {

case MSG_UPDATE_POWER_STATE:

updatePowerState();

break;

}

updatePowerState():更新电源状态，这个函数很重要，后文重点说明。

updateSuspendBlockerLocked()：这个函数主要是对mWakeLockSuspendBlocker和mDisplaySuspendBlocker的获取和释放进行操作，并对对应的锁进行设值，获取设为true，释放设为false。

updateDreamLocked(dirtyPhase2)：更新休眠锁，这个函数是对休眠状态下进行一些处理。其中会发出一个MSG_SANDMAN消息，处理这个消息的是handleSandman()方法。

下面重点介绍下updatePowerState()方法：

private void updatePowerState() {

…省略代码…

…根据距离传感器设置亮灭屏和是否激活距离传感器…

…光感功能…

if (wantScreenOn(mPowerRequest.screenState)) {//反馈屏幕状态亮屏

if (mScreenAutoBrightness >= 0 && mLightSensorEnabled && mPowerRequest.useAutoBrightness) {

target = mScreenAutoBrightness;

slow = mUsingScreenAutoBrightness;

mUsingScreenAutoBrightness = true;

} else {

target = mPowerRequest.screenBrightness;

slow = false;

mUsingScreenAutoBrightness = false;

}

if (mPowerRequest.screenState == DisplayPowerRequest.SCREEN_STATE_DIM) {//灭屏

target = Math.min(target - SCREEN_DIM_MINIMUM_REDUCTION,

mScreenBrightnessDimConfig);

slow = false;

if (FeatureOption.MTK_AAL_SUPPORT) {

nativeSetScreenState(SCREEN_STATE_DIM, clampScreenBrightness(target));

}

} else if (wasDim) {

slow = false;

if (FeatureOption.MTK_AAL_SUPPORT) {

nativeSetScreenState(SCREEN_STATE_ON, clampScreenBrightness(target));

}

animateScreenBrightness(clampScreenBrightness(target),

slow ? BRIGHTNESS_RAMP_RATE_SLOW : BRIGHTNESS_RAMP_RATE_FAST);//动态决定缓慢改变亮度还是迅速改变

} else {

mUsingScreenAutoBrightness = false;

}

//动态执行屏幕亮或者屏幕灭

if (!mScreenOffBecauseOfProximity || mPowerRequest.forceWakeUpEnable) {

if (wantScreenOn(mPowerRequest.screenState)) {

if (!mElectronBeamOffAnimator.isStarted()) {

setScreenOn(true); //设置屏亮

mSbScreenOnIsStart = true;

if (mPowerRequest.blockScreenOn//亮屏处于阻塞状态且电量等级为0，0为灭屏，1为亮屏

&& mPowerState.getElectronBeamLevel() == 0.0f) {

blockScreenOn();//阻塞亮屏

mPowerState.updateElectronBeam();

} else {

unblockScreenOn();//开启亮屏

if (USE_ELECTRON_BEAM_ON_ANIMATION) {

条件一直为false，里面代码忽略

} else {//设置亮屏

mPowerState.setElectronBeamLevel(1.0f);

mPowerState.dismissElectronBeam();

mSbScreenOnIsStart = false;

}

} else {//灭屏时就会执行这里

if (!mElectronBeamOnAnimator.isStarted()) {

if (!mElectronBeamOffAnimator.isStarted()) {

if (mPowerState.getElectronBeamLevel() == 0.0f || mShutDownFlag_D) {

setScreenOn(false);//设置灭屏

mShutDownFlag_D = false;

} else if (mPowerState.prepareElectronBeam(

mElectronBeamFadesConfig ?

ElectronBeam.MODE_FADE :

ElectronBeam.MODE_COOL_DOWN)

&& mPowerState.isScreenOn()) {

mElectronBeamOffAnimator.start();

} else {;

mElectronBeamOffAnimator.end();

}

if (mustNotify

&& !mScreenOnWasBlocked

&& !mElectronBeamOnAnimator.isStarted()

&& !mElectronBeamOffAnimator.isStarted()

&& mPowerState.waitUntilClean(mCleanListener)) {

synchronized (mLock) {//确定显示是否准备好，亮度是否变化，异步

if (!mPendingRequestChangedLocked) {

mDisplayReadyLocked = true;

}

sendOnStateChangedWithWakelock();

}

setScreenOn(boolean on)：设置亮屏的方法：

if (mPowerState.isScreenOn() != on) {//要处于亮屏状态

mPowerState.setScreenOn(on);

if (on) {

mNotifier.onScreenOn();

} else {

mNotifier.onScreenOff();

}

public void setScreenOn(boolean on) {// mPowerState.setScreenOn(on)

if (mScreenOn != on) {

mScreenOn = on;

mScreenReady = false;

scheduleScreenUpdate();//使屏幕更新

}

public void onScreenOn() {

try {

mBatteryStats.noteScreenOn();

} catch (RemoteException ex) {

}

scheduleScreenUpdate()最终会去实现接口mScreenUpdateRunnable，会根据是否亮屏mScreenOn ，电子束等级mElectronBeamLevel，屏幕亮度值mScreenBrightness这三个参数设置更新后的屏幕亮度。然后会对方法返回值进行判断即是：

mPhotonicModulator .setState(mScreenOn, brightness)的返回值，它返回的是mChangeInProgress的值，如果为true，则认为屏幕更新准备好，如果为false，则认为屏幕更新没有准备好。在这函数执行中可能去实现一个接口，而接口mTask的实现是：

private final Runnable mTask = new Runnable() {

public void run() {

//申请变更知道完成

for (;;) {//强制重复执行，直到有条件跳出来

final boolean on;

final boolean onChanged;

final int backlight;

final boolean backlightChanged;

synchronized (mLock) {

on = mPendingOn;

onChanged = (on != mActualOn);

backlight = mPendingBacklight;

backlightChanged = (backlight != mActualBacklight);

if (!onChanged && !backlightChanged) {

mChangeInProgress = false;

break;

}

mActualOn = on;

mActualBacklight = backlight;

}

if (onChanged && on) {//有变化且是需点亮状态

mDisplayBlanker.unblankAllDisplays();//点亮屏幕

}

if (mShutDownFlag) {

try {

Thread.sleep(mDelay);

} catch (InterruptedException e) {}

}

if (backlightChanged) {//期望亮度值mPendingBacklight和真实亮度值mActualBacklight是否相等，相等时backlightChanged为false，否则为true

mBacklight.setBrightness(backlight);//这里会去底层设置点亮屏，非常重要，backlightChanged才会决定亮不亮屏

mDisplayBlanker.setBlNotify();

if (on) {

Handler monitorHandler = MessageMonitorLogger.getMsgLoggerHandler();

if (monitorHandler != null && monitorHandler.hasMessages(MessageMonitorLogger.START_MONITOR_EXECUTION_TIMEOUT_MSG, monitorHandler)) { monitorHandler.removeMessages(MessageMonitorLogger.START_MONITOR_EXECUTION_TIMEOUT_MSG, monitorHandler);

}

if (onChanged && !on) {//有变化且是需熄灭状态

mDisplayBlanker.blankAllDisplays();//熄灭屏幕

}

postScreenUpdateThreadSafe();

}

};

public void unblankAllDisplays() {//开启全显示，这里有可能会有延时

synchronized (this) {

nativeSetAutoSuspend(false);

nativeSetInteractive(true); mDisplayManagerService.unblankAllDisplaysFromPowerManager();

mBlanked = false;

mHDMI.hdmiPowerEnable(true);

mWfdShouldBypass = false;

}

unblankAllDisplaysFromPowerManager()：开启显示，最终会根据全显示的状态值来确定设备开不开启锁，代码如下：

switch (mAllDisplayBlankStateFromPowerManager) {

case DISPLAY_BLANK_STATE_BLANKED:

device.blankLocked();

break;

case DISPLAY_BLANK_STATE_UNBLANKED:

device.unblankLocked();

break;

}

wakingUp()是在ActivityManagerNative.getDefault().wakingUp()调用时才执行，而要掉这里应该是监听到了亮屏，监听器： mPolicy.screenTurningOn(mScreenOnListener)。

private final WindowManagerPolicy.ScreenOnListener mScreenOnListener =

new WindowManagerPolicy.ScreenOnListener() {

@Override

public void onScreenOn() {

synchronized (mLock) {

if (mScreenOnBlockerAcquired && !mPendingWakeUpBroadcast) {

mScreenOnBlockerAcquired = false;

mScreenOnBlocker.release();

}

}//这个很重要

public void wakingUp() {

if (checkCallingPermission(android.Manifest.permission.DEVICE_POWER)

!= PackageManager.PERMISSION_GRANTED) {

throw new SecurityException("Requires permission "

+ android.Manifest.permission.DEVICE_POWER);

}

synchronized(this) {

mWentToSleep = false;

updateEventDispatchingLocked();

comeOutOfSleepIfNeededLocked();//从休眠状态退出来

}

手机在感受到距离由近及远的时候也会去点亮屏幕：

private final SensorEventListener mProximitySensorListener = new SensorEventListener() {//距离传感器监听器

@Override

public void onSensorChanged(SensorEvent event) {

if (mProximitySensorEnabled) {

final long time = SystemClock.uptimeMillis();

final float distance = event.values[0];

boolean positive = distance >= 0.0f && distance < mProximityThreshold;

handleProximitySensorEvent(time, positive); // positive 的值为false，表示离开，为true，表示靠近。

}

};

当mDisplayReady为true时会执行方法sendPendingNotificationsLocked()，这个函数的作用就是发送关于锁结束的提示，无论是亮屏结束还是熄屏结束都会调用这里，实现的地方如下：

if (mSendWakeUpFinishedNotificationWhenReady) {//唤醒过程结束

mSendWakeUpFinishedNotificationWhenReady = false;

mNotifier.onWakeUpFinished();

}

if (mSendGoToSleepFinishedNotificationWhenReady) {//休眠过程结束

mSendGoToSleepFinishedNotificationWhenReady = false;

mNotifier.onGoToSleepFinished();

}

mSendWakeUpFinishedNotificationWhenReady这个值在刚进入唤醒阶段就被置为了true的，所以最重要的还是什么时候mDisplayReady的值为true。

真正执行亮屏的是底层驱动去做的,而通知底层驱动的是函数:

public void setBrightness(int brightness) {// Task中的

//mBacklight.setBrightness(backlight)

setBrightness(brightness, BRIGHTNESS_MODE_USER);

}

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);

}

protected void setLightLocked(int color, int mode, int onMS, int offMS, int brightnessMode) {

if (color != mColor || mode != mMode || onMS != mOnMS || offMS != mOffMS) {

setLight_native(mNativePointer, mId, color, mode, onMS, offMS, brightnessMode);//这个函数就会实现去通知底层驱动更新屏幕亮度

}

安卓手机来电亮屏流程分析相关推荐

Android手机亮屏流程分析
极力推荐Android 开发大总结文章:欢迎收藏程序员Android 力荐 ,Android 开发者需要的必备技能注:文章转于网络,点击查看原文 PowerManagerService 之前系列文章 ...
(原创)Android6.0亮屏流程分析
1.概述 Android的亮屏流程从android系统结构层次来分可以分为三个流程,App应用唤醒源:Framework层Power结合Display,Light服务做亮屏绘制准备工作:底层驱动点亮背 ...
单击屏幕亮屏流程分析
一. kernel部分 1.看TP驱动有没有事件上报 cat /dev/input/evnet1 或者看kernel log [ 4036.282237] bt541_ts_device 5-00 ...
Android 亮屏流程分析
https://blog.csdn.net/FightFightFight/article/details/79808100 相关文章: [Android Framework] 8.1 PowerMa ...
Android 8.1 PowerManagerService分析(四)——亮屏流程分析
欢迎大家关注我的掘金帐号我会在那里定期更新最新版本的Android Framework源码分析! 相关文章: [Android Framework] 8.1 PowerManagerService分 ...
android 7.0 解锁亮屏,Android7.0亮屏流程分析
亮屏的本质是改变屏幕的电源状态,经过一系列的调用会来到PowerManagerService中的updatePowerStateLocked() 1.PowerManagerService到Displ ...
Android 手机灭屏流程分析详解
参考地址:https://www.jianshu.com/p/9241f3a91095 本篇文章主要介绍 Android 开发中的部分知识点,通过阅读本篇文章,您将收获以下内容: 1.前言 2.Pow ...
Android P 亮屏慢分析
主要文件介绍 PowerManagerService.java:以下简称PMS或者PowerMS,主要处理系统中与power相关的计算,然后决策系统该如何反应.同时协调power如何与系统其他模块的交 ...
Android插拔usb亮屏流程
遇到一个问题,插拔usb,手机不亮屏.先来分析下,插拔usb亮屏流程. 关键流程 updatePowerStateLocked--->updateIsPoweredLockedprivate v ...

安卓手机来电亮屏流程分析

安卓手机来电亮屏流程分析相关推荐

最新文章

热门文章