上小节我们实现了对通知灯控制，该小节我们讲解怎么实现对背光灯的控制，一般来说，操作是比较简单的，我们只需要往数据库中写入亮度就可以了，那么为什么会这么简单，当然是有其他的程序（ContentObserber）在监视数据库，当数据改变的时候，检测的程序，就会相应的去改变backlight的亮度。那么我们先来分析一下源码是怎么实现的
源码分析
倒序分析
还是根据lights.h文件中的
#define LIGHT_ID_BACKLIGHT "backlight"
在源码中搜索LIGHT_ID_BACKLIGHT，我们可以找到文件LocalDisplayAdapter.java
LightsManager lights = LocalServices.getService(LightsManager.class);
mBacklight = lights.getLight(LightsManager.LIGHT_ID_BACKLIGHT);
与通知灯类似，先通过LocalServices.getService获取灯光服务，在通过灯光服务
lights.getLight获得一个Light类的实例化mBacklight，然后通过mBacklight我们就能实现所有对背光灯操作了。在文件中查找mBacklight被引用的地方，我们可以找到：
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);
} finally {
Trace.traceEnd(Trace.TRACE_TAG_POWER);
}
}
该为一个私有方法，只能在本类中使用，其中在 run()方法中被调用，看到run方法，我们知道这是一个线程，那么我们看看该线程做了那么事情，一般来说大部分都在休眠状态，只有在我们调节了屏幕亮度的时候他才会有所动作，其中有代码如下：
if (Display.isSuspendedState(oldState){......}
if (brightnessChanged) {
setDisplayBrightness(brightness);
}
// Enter the final desired state, possibly suspended.
if (state != currentState) {
setDisplayState(state);
}
可以看出，当背光灯改变的时候，就会调动 setDisplayBrightness(brightness)方法，方法会调用JNI访问C函数，最终实现对驱动的控制。下面我们从上层开始往底层分析，scheduleScreenUpdate
顺序分析
打开PowerManagerService.java文件，在其中搜索ContentObserver（内容观察），我们可以发现调用了很多次resolver.registerContentObserver()与mContext.registerReceiver()方法如下：
mContext.registerReceiver(new BatteryReceiver(), filter, null, mHandler);
mContext.registerReceiver(new DreamReceiver(), filter, null, mHandler);
mContext.registerReceiver(new UserSwitchedReceiver(), filter, null, mHandler);
mContext.registerReceiver(new DockReceiver(), filter, null, mHandler);
resolver.registerContentObserver(SCREENSAVER_ENABLED)
resolver.registerContentObserver(SCREENSAVER_ACTIVATE_ON_SLEEP),
resolver.registerContentObserver(SCREENSAVER_ACTIVATE_ON_DOCK),
resolver.registerContentObserver(SCREEN_OFF_TIMEOUT),
....................................................
我们先分析 mContext.registerReceiver(new BatteryReceiver(), filter, null, mHandler)，注册了一个电池监听，当电池发生时，执行BatteryReceiver方法中的onReceive方法内部调用过程如下：
BatteryReceiver():
onReceive()
handleBatteryStateChangedLocked()
updatePowerStateLocked();
DreamReceiver():该方法最终发送一个消息，然后handleMessage方法进行处理
DreamReceiver()
scheduleSandmanLocked();
sendMessage(msg)
handleMessage(Message msg)
handleSandman();
updatePowerStateLocked();
UserSwitchedReceiver():
UserSwitchedReceiver():
handleSettingsChangedLocked();
updateSettingsLocked();
DockReceiver()
DockReceiver()
updatePowerStateLocked();
通过上面的分析，我们很直观的了解到，mContext.registerReceiver注册的4个监听，到最后都是调用updatePowerStateLocked()方法，
下面我们分析resolver.registerContentObserver，假设我们注册SCREENSAVER_ENABLED之后，对应的
mSettingsObserver中某些方法被调用，如onChange：
onChange()
handleSettingsChangedLocked();
updatePowerStateLocked();
可以看到，最终函数调用了updatePowerStateLocked()，为了大家直观的分析，有如下截图：
那么我们现在来分析一下updatePowerStateLocked()方法：
updatePowerStateLocked()
// Phase 0: Basic state updates.
updateIsPoweredLocked(mDirty);
updateStayOnLocked(mDirty);
updateScreenBrightnessBoostLocked(mDirty);
// Phase 1: Update wakefulness.
// Loop because the wake lock and user activity computations are influenced
// by changes in wakefulness.
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;
}
}
// Phase 2: Update display power state.
boolean displayBecameReady = updateDisplayPowerStateLocked(dirtyPhase2);
// Phase 3: Update dream state (depends on display ready signal).
updateDreamLocked(dirtyPhase2, displayBecameReady);
// Phase 4: Send notifications, if needed.
finishWakefulnessChangeIfNeededLocked();
// Phase 5: Update suspend blocker.
// Because we might release the last suspend blocker here, we need to make sure
// we finished everything else first!
updateSuspendBlockerLocked();
他做了五个步骤，但是现在我们只关注Phase 2: Update display power state.，即我们的显示器部分，updateDisplayPowerStateLocked方法，调用过程如下
updateDisplayPowerStateLocked()
mDisplayManagerInternal.requestPowerState()
其中mDisplayManagerInternal是DisplayManagerInternal（抽象类）的实例化，我们在源码中进行搜索，看他是被如何实现的，最终我们锁定DisplayManagerService.java文件，查看代码，可知由LocalService继承实现。可以在其中找到代码：
private DisplayPowerController mDisplayPowerController;
public boolean requestPowerState(DisplayPowerRequest request,
boolean waitForNegativeProximity) {
return mDisplayPowerController.requestPowerState(request,
waitForNegativeProximity);
}
我们在DisplayPowerController.java文件中可以找到requestPowerState的定义，
通过前面的分析现在我们来住一个总结：PowerManagerService是一个总入口，背光灯，电池等等和电源相关的，都从这里开始，其中我们的Display仅仅是其中的一部分，DisplayPowerController就是我们显示器电源的相关控制（即显示器电源管理），下面我们将对他进行分析。
DisplayPowerController分析
在其私有成员中，我们可以看到很多私有成员（只列举部分）：
private final IBatteryStats mBatteryStats;
private final SensorManager mSensorManager;
......
从上面我们可以看到一个mSensorManager的成员，在我们打电话的时候，如果靠近耳朵，屏幕会自动熄灭，那么他肯定存在相关的传感器。当我们电池电量过低的时候，会发出通知询问我们是否降低屏幕的亮度。这些成员都是为了和我们屏幕的亮度进行配合使用，前面提到会调用requestPowerState()方法，我们现在看看做了哪些工作，
requestPowerState()
sendUpdatePowerStateLocked();
mHandler.sendMessage(msg);
updatePowerState();
animateScreenBrightness() //慢慢的改变屏幕的变化
mScreenBrightnessRampAnimator.animateTo() //于 RampAnimator.java文件定义
查看源码，我们可以知道，requestPowerState()最终发送一个消息，然后由updatePowerState()处理，下面我来查看：
mScreenBrightnessRampAnimator = new RampAnimator<DisplayPowerState>(
mPowerState, DisplayPowerState.SCREEN_BRIGHTNESS);
在源码中搜索SCREEN_BRIGHTNESS然后锁定DisplayPowerState.java 文件，找到setScreenBrightness方法
setScreenBrightness()
scheduleScreenUpdate()
scheduleScreenUpdate函数最终通过Handler发送mScreenUpdateRunnable对象来更新亮度值. 从run函数中可以看出只有当mColorFadeLevel > 0f时才能给brightness设置亮度值,.
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函数.
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); //亮屏调用设置状态,亮度
}
}
};
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.
requestGlobalDisplayStateInternal() //于DisplayManagerService.java文件定义
applyGlobalDisplayStateLocked() //于DisplayManagerService.java文件定义
updateDisplayStateLocked() //于DisplayManagerService.java文件定义
requestDisplayStateLocked() //于LocalDisplayAdapter.java文件定义
run() //于LocalDisplayAdapter.java文件定义
setDisplayBrightness() //于LocalDisplayAdapter.java文件定义
setBrightness(brightness) //于BrightnessController.java文件定义
这样就和我们之前的倒序分析联系到一起了，实现对背光灯的控制。明白了之后，我们开始在原来APP的基础上进行修改，实现对backlight的控制
APP编写
在原来的AS工程上进行修改。
界面设计
首先我们要在原来的基础上增加一个小部件，该部件用来控制背光灯，该小部件为SeekBar（拖动条），在activity_main.xml文件中，添加如下代码：
android:layout_width="match_parent"
android:layout_height="match_parent"
+ android:orientation="vertical"
+ <SeekBar
+ android:id="@+id/seekBar"
+ android:layout_width="fill_parent"
+ android:layout_height="wrap_content"
+ android:max="100"/>
这样我们的Seekbar的界面就设计完成了如下：
下面我们将编写APP应用程序
APP应用程序
首先我们在MainActivity.java文件的class MainActivity中，定义一个私有成员：
+ private SeekBar mBackligtSeekBar = null;
然后我们在onCreate()方法中，对他进行实例化与我们界面设计的SeekBar绑定在一起。
+ mBackligtSeekBar = (SeekBar)findViewById(R.id.seekBar);
然后我们就需要实现Seekbar的监听方法，如下：