android 获取和设置屏幕亮度的模式和值

最近有一个需求，是要能够设置Android的屏幕的亮度的模式和值。简单来说，就是把原生设置里面就有的功能再用自己的UI做一遍。
OK，接下来就是查看源码。
首先找到显示的java类，是在setting包下面的DisplaySettings.java。

<span style="font-size:18px;">package com.android.settings;

public class DisplaySettings extends SettingsPreferenceFragment implements
Preference.OnPreferenceChangeListener, OnPreferenceClickListener {
private static final String TAG = "DisplaySettings";</span>

很明显,它是的preferenceFragment。那么，我们看看它的xml文件。定位亮度对应的preference

<span style="font-size:18px;"> <!-- 亮度-->
<com.android.settings.BrightnessPreference
android:title="@string/brightness"
android:persistent="false"/></span>

接着打开BrightnessPrefere。

<span style="font-size:18px;">public class BrightnessPreference extends Preference {

public BrightnessPreference(Context context, AttributeSet attrs) {
super(context, attrs);
}
@Override
protected void onClick() {
Intent intent = new Intent(Intent.ACTION_SHOW_BRIGHTNESS_DIALOG);
getContext().sendBroadcastAsUser(intent, UserHandle.CURRENT_OR_SELF);
}
}</span>

很简单的逻辑，只是发送一个广播，那么，是谁来接受处理呢？就是SystemUI。

这里是一个自定义的Dialog，我们接着追踪代码。BrightnessDialog的代码很简单。就是自定义ContentView，重点是通过BrightnessControler来处理逻辑。

 

@Override

<span style="font-size:18px;"> public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Window window = getWindow();
window.setType(WindowManager.LayoutParams.TYPE_VOLUME_OVERLAY);
window.getAttributes().privateFlags |=
WindowManager.LayoutParams.PRIVATE_FLAG_SHOW_FOR_ALL_USERS;
window.clearFlags(WindowManager.LayoutParams.FLAG_DIM_BEHIND);
window.requestFeature(Window.FEATURE_NO_TITLE);

setContentView(R.layout.quick_settings_brightness_dialog);
setCanceledOnTouchOutside(true);
}

@Override
protected void onStart() {
super.onStart();
mBrightnessController = new BrightnessController(getContext(),
(ImageView) findViewById(R.id.brightness_icon),
(ToggleSlider) findViewById(R.id.brightness_slider));
dismissBrightnessDialog(mBrightnessDialogLongTimeout);
mBrightnessController.addStateChangedCallback(this);
}</span>

好了，终于找到处理的地方，接下来就是看懂他们

<span style="font-size:18px;">/*
* Copyright (C) 2013 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0 *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

package com.android.systemui.settings;

import android.content.ContentResolver;
import android.content.Context;
import android.database.ContentObserver;
import android.net.Uri;
import android.os.AsyncTask;
import android.os.Handler;
import android.os.IPowerManager;
import android.os.PowerManager;
import android.os.RemoteException;
import android.os.ServiceManager;
import android.os.UserHandle;
import android.provider.Settings;
import android.provider.Settings.SettingNotFoundException;
import android.widget.ImageView;

import java.util.ArrayList;

public class BrightnessController implements ToggleSlider.Listener {
private static final String TAG = "StatusBar.BrightnessController";

private final int mMinimumBacklight;
private final int mMaximumBacklight;

private final Context mContext;
private final ImageView mIcon;
private final ToggleSlider mControl;
private final boolean mAutomaticAvailable;
private final IPowerManager mPower;
private final CurrentUserTracker mUserTracker;
private final Handler mHandler;
private final BrightnessObserver mBrightnessObserver;

private ArrayList<BrightnessStateChangeCallback> mChangeCallbacks =
new ArrayList<BrightnessStateChangeCallback>();

public interface BrightnessStateChangeCallback {
public void onBrightnessLevelChanged();
}

/** ContentObserver to watch brightness **/
private class BrightnessObserver extends ContentObserver {

private final Uri BRIGHTNESS_MODE_URI =
Settings.System.getUriFor(Settings.System.SCREEN_BRIGHTNESS_MODE);
private final Uri BRIGHTNESS_URI =
Settings.System.getUriFor(Settings.System.SCREEN_BRIGHTNESS);

public BrightnessObserver(Handler handler) {
super(handler);
}

@Override
public void onChange(boolean selfChange) {
onChange(selfChange, null);
}

@Override
public void onChange(boolean selfChange, Uri uri) {
if (selfChange) return;
if (BRIGHTNESS_MODE_URI.equals(uri)) {
updateMode();
} else if (BRIGHTNESS_URI.equals(uri)) {
updateSlider();
} else {
updateMode();
updateSlider();
}
for (BrightnessStateChangeCallback cb : mChangeCallbacks) {
cb.onBrightnessLevelChanged();
}
}

public void startObserving() {
final ContentResolver cr = mContext.getContentResolver();
cr.unregisterContentObserver(this);
cr.registerContentObserver(
BRIGHTNESS_MODE_URI,
false, this, UserHandle.USER_ALL);
cr.registerContentObserver(
BRIGHTNESS_URI,
false, this, UserHandle.USER_ALL);
}

public void stopObserving() {
final ContentResolver cr = mContext.getContentResolver();
cr.unregisterContentObserver(this);
}

}

public BrightnessController(Context context, ImageView icon, ToggleSlider control) {
mContext = context;
mIcon = icon;
mControl = control;
mHandler = new Handler();
mUserTracker = new CurrentUserTracker(mContext) {
@Override
public void onUserSwitched(int newUserId) {
updateMode();
updateSlider();
}
};
mBrightnessObserver = new BrightnessObserver(mHandler);
mBrightnessObserver.startObserving();

PowerManager pm = (PowerManager)context.getSystemService(Context.POWER_SERVICE);
mMinimumBacklight = pm.getMinimumScreenBrightnessSetting();
mMaximumBacklight = pm.getMaximumScreenBrightnessSetting();

mAutomaticAvailable = context.getResources().getBoolean(
com.android.internal.R.bool.config_automatic_brightness_available);
mPower = IPowerManager.Stub.asInterface(ServiceManager.getService("power"));

// Update the slider and mode before attaching the listener so we don't receive the
// onChanged notifications for the initial values.
updateMode();
updateSlider();

control.setOnChangedListener(this);
}

public void addStateChangedCallback(BrightnessStateChangeCallback cb) {
mChangeCallbacks.add(cb);
}

public boolean removeStateChangedCallback(BrightnessStateChangeCallback cb) {
return mChangeCallbacks.remove(cb);
}

@Override
public void onInit(ToggleSlider control) {
// Do nothing
}

/** Unregister all call backs, both to and from the controller */
public void unregisterCallbacks() {
mBrightnessObserver.stopObserving();
mChangeCallbacks.clear();
mUserTracker.stopTracking();
}

public void onChanged(ToggleSlider view, boolean tracking, boolean automatic, int value) {
setMode(automatic ? Settings.System.SCREEN_BRIGHTNESS_MODE_AUTOMATIC
: Settings.System.SCREEN_BRIGHTNESS_MODE_MANUAL);
updateIcon(automatic);
if (!automatic) {
final int val = value + mMinimumBacklight;
setBrightness(val);
if (!tracking) {
AsyncTask.execute(new Runnable() {
public void run() {
Settings.System.putIntForUser(mContext.getContentResolver(),
Settings.System.SCREEN_BRIGHTNESS, val,
UserHandle.USER_CURRENT);
}
});
}
}

for (BrightnessStateChangeCallback cb : mChangeCallbacks) {
cb.onBrightnessLevelChanged();
}
}

private void setMode(int mode) {
Settings.System.putIntForUser(mContext.getContentResolver(),
Settings.System.SCREEN_BRIGHTNESS_MODE, mode,
mUserTracker.getCurrentUserId());
}

private void setBrightness(int brightness) {
try {
mPower.setTemporaryScreenBrightnessSettingOverride(brightness);
} catch (RemoteException ex) {
}
}

private void updateIcon(boolean automatic) {
if (mIcon != null) {
mIcon.setImageResource(automatic ?
com.android.systemui.R.drawable.ic_qs_brightness_auto_on :
com.android.systemui.R.drawable.ic_qs_brightness_auto_off);
}
}

/** Fetch the brightness mode from the
system settings and * update the icon
更新亮度的你模式
*/
private void updateMode() {
if (mAutomaticAvailable) {
int automatic;
try {
automatic = Settings.System.getIntForUser(mContext.getContentResolver(),
Settings.System.SCREEN_BRIGHTNESS_MODE,
UserHandle.USER_CURRENT);
} catch (SettingNotFoundException snfe) {
automatic = 0;
}
mControl.setChecked(automatic != 0);
updateIcon(automatic != 0);
} else {
mControl.setChecked(false);
updateIcon(false /*automatic*/);
}
}

/** Fetch the brightness from the system settings and update the slider
更新亮度的值
*/
private void updateSlider() {
int value;
try {
value = Settings.System.getIntForUser(mContext.getContentResolver(),
Settings.System.SCREEN_BRIGHTNESS,
UserHandle.USER_CURRENT);
} catch (SettingNotFoundException ex) {
value = mMaximumBacklight;
}
mControl.setMax(mMaximumBacklight - mMinimumBacklight);
mControl.setValue(value - mMinimumBacklight);
}
}</span>