之前也写过勿扰模式的大概分析文章勿扰模式代码结构简析
不过只是大概讲了下相关文件的位置和作用，具体只分析了勿扰模式对来电铃声影响的代码。在做具体需求的时候发现勿扰模式远比我想象的复杂，本文记录下几个开发中遇到的勿扰模式相关知识。
系统通知拦截的实现
勿扰模式控制的就是通知的行为，发送通知的时候控制通知铃声是否响，通知的UI是否展现等等。入口的方法就在发送通知的时候
frameworks/base/services/core/java/com/android/server/notification/NotificationManagerService.java
void enqueueNotificationInternal(final String pkg, final String opPkg, final int callingUid,
final int callingPid, final String tag, final int id, final Notification notification,
int[] idOut, int incomingUserId) {
...
final NotificationRecord r = mNotificationList.get(i);
...
mHandler.post(new Runnable() {
@Override
public void run() {
synchronized (mNotificationList) {
...
applyZenModeLocked(r);
...
}
}
});
...
} private void applyZenModeLocked(NotificationRecord record) {
record.setIntercepted(mZenModeHelper.shouldIntercept(record));
} public boolean setIntercepted(boolean intercept) {
mIntercept = intercept;
return mIntercept;
}
那么勿扰模式判断的核心方法就是shouldIntercept
frameworks/base/services/core/java/com/android/server/notification/ZenModeHelper.java
public boolean shouldIntercept(NotificationRecord record) {
return mFiltering.shouldIntercept(mZenMode, mConfig, record);
} public boolean shouldIntercept(int zen, ZenModeConfig config, NotificationRecord record) {
if (isSystem(record)) { //勿扰拦截模式不控制系统通知
return false;
}
switch (zen) {
case Global.ZEN_MODE_NO_INTERRUPTIONS: //不拦截
// #notevenalarms
ZenLog.traceIntercepted(record, "none");
return true;
case Global.ZEN_MODE_ALARMS: //控制alarm，如闹钟
if (isAlarm(record)) {
// Alarms only
return false;
}
ZenLog.traceIntercepted(record, "alarmsOnly");
return true;
case Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS: //优先勿扰模式，特定联系人不拦截
if (isAlarm(record)) { //优先勿扰模式不拦截闹钟
// Alarms are always priority
return false;
}
// allow user-prioritized packages through in priority mode
if (record.getPackagePriority() == Notification.PRIORITY_MAX) {//最高优先级通知不拦截
ZenLog.traceNotIntercepted(record, "priorityApp");
return false;
}
if (isCall(record)) { //通话通知
if (config.allowRepeatCallers
&& REPEAT_CALLERS.isRepeat(mContext, extras(record))) {
ZenLog.traceNotIntercepted(record, "repeatCaller");
return false;
} //短时间重复来电不拦截，这个在勿扰模式设置中可以开启或者关闭
if (!config.allowCalls) {
ZenLog.traceIntercepted(record, "!allowCalls");
return true;
}
return shouldInterceptAudience(config.allowCallsFrom, record);
}
if (isMessage(record)) { //短信通知
if (!config.allowMessages) {
ZenLog.traceIntercepted(record, "!allowMessages");
return true;
}
return shouldInterceptAudience(config.allowMessagesFrom, record);
}
if (isEvent(record)) { //日程通知
if (!config.allowEvents) {
ZenLog.traceIntercepted(record, "!allowEvents");
return true;
}
return false;
}
if (isReminder(record)) { //提醒通知
if (!config.allowReminders) {
ZenLog.traceIntercepted(record, "!allowReminders");
return true;
}
return false;
}
ZenLog.traceIntercepted(record, "!priority");
return true;
default:
return false;
}
}
Android系统默认有“来自联系人”，“来自收藏联系人”等过滤选项，例如设置中选择“来自联系人”，那么优先勿扰模式下来自联系人的来电不会拦截，但是陌生号码来电不会响铃和显示UI。
勿扰模式的手动开关和自动规则
勿扰模式有手动开关和自动规则两种方式，我一开始偏执的认为勿扰模式设置中的开关是个总开关，自动规则要在总开关开启后才有效。不过实际验证和阅读代码后才知晓。手动开关和自动规则是互斥的关系，手动开关开启后自动规则无效，手动开关关闭后自动规则才有效，当然如果全部的自动规则都关闭或者规则数为0勿扰模式就完全无效了。
手动开启入口代码如下：
frameworks/base/services/core/java/com/android/server/notification/ZenModeHelper.java
setManualZenMode
private void setManualZenMode(int zenMode, Uri conditionId, String reason, String caller,
boolean setRingerMode) {
ZenModeConfig newConfig;
synchronized (mConfig) {
if (mConfig == null) return;
if (!Global.isValidZenMode(zenMode)) return;
if (DEBUG) Log.d(TAG, "setManualZenMode " + Global.zenModeToString(zenMode)
+ " conditionId=" + conditionId + " reason=" + reason
+ " setRingerMode=" + setRingerMode);
newConfig = mConfig.copy();
if (zenMode == Global.ZEN_MODE_OFF) {
newConfig.manualRule = null;
for (ZenRule automaticRule : newConfig.automaticRules.values()) {
if (automaticRule.isAutomaticActive()) {
automaticRule.snoozing = true;
}
}
} else {
final ZenRule newRule = new ZenRule();
newRule.enabled = true;
newRule.zenMode = zenMode;
newRule.conditionId = conditionId;
newRule.enabler = caller;
newConfig.manualRule = newRule;
}
setConfigLocked(newConfig, reason, setRingerMode);
}
} public ZenRule manualRule;
public ArrayMap<String, ZenRule> automaticRules = new ArrayMap<>();setConfigLocked
frameworks/base/services/core/java/com/android/server/notification/ZenModeHelper.java
private boolean setConfigLocked(ZenModeConfig config, String reason, boolean setRingerMode) {
final long identity = Binder.clearCallingIdentity();
try {
...
mConditions.evaluateConfig(config, false /*processSubscriptions*/); // may modify config
mConfigs.put(config.user, config);
...
final boolean policyChanged = !Objects.equals(getNotificationPolicy(mConfig),
getNotificationPolicy(config));
if (!config.equals(mConfig)) {
dispatchOnConfigChanged();
}
if (policyChanged) {
dispatchOnPolicyChanged();
}
mConfig = config;
mHandler.postApplyConfig(config, reason, setRingerMode);
return true;
} finally {
Binder.restoreCallingIdentity(identity);
}
}
private void applyConfig(ZenModeConfig config, String reason, boolean setRingerMode) {
final String val = Integer.toString(config.hashCode());
Global.putString(mContext.getContentResolver(), Global.ZEN_MODE_CONFIG_ETAG, val);
if (!evaluateZenMode(reason, setRingerMode)) {
applyRestrictions(); // evaluateZenMode will also apply restrictions if changed
}
mConditions.evaluateConfig(config, true /*processSubscriptions*/);
}其中evaluateConfig是自动规则起作用的核心方法，后面讲自动规则的时候详细分析，mConfigs保存ZenModeConfig数据，这段代码要关注的核心方法是evaluateZenMode，该方法依据各种设置更新勿扰相关变量
evaluateZenMode
private boolean evaluateZenMode(String reason, boolean setRingerMode) {
if (DEBUG) Log.d(TAG, "evaluateZenMode");
final ArraySet<ZenRule> automaticRules = new ArraySet<ZenRule>();
final int zen = computeZenMode(automaticRules); //确定当前勿扰模式
if (zen == mZenMode) return false;
ZenLog.traceSetZenMode(zen, reason);
mZenMode = zen; //mZenMode是最根本的设置，例如不拦截，拦截所有，优先勿扰等等
updateRingerModeAffectedStreams(); //更新音频系统设置
setZenModeSetting(mZenMode); //保存到SystemProvider
if (setRingerMode) {
applyZenToRingerMode(); //设置铃声模式
}
applyRestrictions();
mHandler.postDispatchOnZenModeChanged(); //通知观察者勿扰模式变化
return true;
}
frameworks/base/core/java/android/provider/Settings.java
/** @hide */ public static final int ZEN_MODE_OFF = 0; //勿扰模式关闭
/** @hide */ public static final int ZEN_MODE_IMPORTANT_INTERRUPTIONS = 1; //优先勿扰模式
/** @hide */ public static final int ZEN_MODE_NO_INTERRUPTIONS = 2; //不拦截
/** @hide */ public static final int ZEN_MODE_ALARMS = 3; //闹铃勿扰模式computeZenMode
computeZenMode又是evaluateZenMode方法的核心，代码如下：
private int computeZenMode(ArraySet<ZenRule> automaticRulesOut) {
if (mConfig == null) return Global.ZEN_MODE_OFF;
if (mConfig.manualRule != null) return mConfig.manualRule.zenMode;
int zen = Global.ZEN_MODE_OFF;
for (ZenRule automaticRule : mConfig.automaticRules.values()) {
if (automaticRule.isAutomaticActive()) {
if (zenSeverity(automaticRule.zenMode) > zenSeverity(zen)) {
zen = automaticRule.zenMode;
}
}
}
return zen;
}isAutomaticActive
frameworks/base/core/java/android/service/notification/ZenModeConfig.java
public boolean isAutomaticActive() {
return enabled && !snoozing && component != null && isTrueOrUnknown();
}
1.该规则是否启用，就是勿扰模式每条自动规则设置中最上面的switch，表示该规则开启或者关闭
2.snooze英文意思是打瞌睡，它值为true的话自动规则不起作用，查看代码，它在用户手动关闭勿扰模式的时候设置为true，在ZenModeConfig有变化或者condition有变化的时候把它设置为false
frameworks/base/services/core/java/com/android/server/notification/ZenModeConditions.java
private boolean updateSnoozing(ZenRule rule) {
if (rule != null && rule.snoozing && (mFirstEvaluation || !rule.isTrueOrUnknown())) {
rule.snoozing = false;
if (DEBUG) Log.d(TAG, "Snoozing reset for " + rule.conditionId);
return true;
}
return false;
}
3.规则的component不能为空，该值是在创建规则时传入的，例如ZenModeConfig中的
public static ComponentName getScheduleConditionProvider() {
return new ComponentName(SYSTEM_AUTHORITY, "ScheduleConditionProvider");
}总结
这里可以看出手动和自动规则其实都是ZenRule，不过手动只有一条，而自动规则可以有多条。从computeZenMode方法看到手动规则是优先自动规则的。
自动规则详解
ZenRule
定义于frameworks/base/core/java/android/service/notification/ZenModeConfig.java
public static class ZenRule implements Parcelable {
public boolean enabled;
public boolean snoozing; // user manually disabled this instance
public String name; // required for automatic
public int zenMode;
public Uri conditionId; // required for automatic
public Condition condition; // optional
public ComponentName component; // optional
public String id; // required for automatic (unique)
public long creationTime; // required for automatic
public String enabler; // package name, only used for manual rules.
...
}
snoozing 规则是否暂时不可用，具体含义见上面小节，表示用户手动关闭勿扰模式时附带的暂时关闭某些自动规则
name 规则名称
zenMode 规则模式
conditionId 和 condition，conditionId定义了规则，例如
public static Uri toScheduleConditionId(ScheduleInfo schedule) {
return new Uri.Builder().scheme(Condition.SCHEME)
.authority(SYSTEM_AUTHORITY)
.appendPath(SCHEDULE_PATH)
.appendQueryParameter("days", toDayList(schedule.days))
.appendQueryParameter("start", schedule.startHour + "." + schedule.startMinute)
.appendQueryParameter("end", schedule.endHour + "." + schedule.endMinute)
.appendQueryParameter("exitAtAlarm", String.valueOf(schedule.exitAtAlarm))
.build();
}
component是ConditionProvider的名字
id 唯一表ZenRule的数字
creationTime 创建时间
enableer 启用手动规则的package名称，三方app可以设定勿扰模式规则
ConditionProviderService
frameworks/base/core/java/android/service/notification/ConditionProviderService.java
public abstract class ConditionProviderService extends Service {
...
private final H mHandler = new H();
private Provider mProvider;
private INotificationManager mNoMan;
...
//三个接口，服务调用方可触发
abstract public void onConnected();
abstract public void onSubscribe(Uri conditionId);
abstract public void onUnsubscribe(Uri conditionId);
//通知condition变化给NotificationManagerService
public final void notifyCondition(Condition condition) {
if (condition == null) return;
notifyConditions(new Condition[]{ condition });
}
public final void notifyConditions(Condition... conditions) {
if (!isBound() || conditions == null) return;
try {
getNotificationInterface().notifyConditions(getPackageName(), mProvider, conditions);
} catch (android.os.RemoteException ex) {
Log.v(TAG, "Unable to contact notification manager", ex);
}
}
@Override
public IBinder onBind(Intent intent) {
if (mProvider == null) {
mProvider = new Provider();
}
return mProvider;
}
private final class Provider extends IConditionProvider.Stub {
...
}
}
该类继承ConditionProviderService并加入了一些接口，而继承SystemConditionProviderService的类有三个
frameworks/base/services/core/java/com/android/server/notification/CountdownConditionProvider.java
frameworks/base/services/core/java/com/android/server/notification/EventConditionProvider.java
frameworks/base/services/core/java/com/android/server/notification/ScheduleConditionProvider.java
frameworks/base/services/core/java/com/android/server/notification/EventConditionProvider.java
frameworks/base/services/core/java/com/android/server/notification/ScheduleConditionProvider.java
CountdownConditionProvider是倒计时条件，例如倒计时两个小时内勿扰模式启用；EventConditionProvider对应日程条件，如某日15:00~16:00开会，期间勿扰模式开启；ScheduleConditionProvider对应周期性的时间段勿扰模式开启，如每周一~周五的晚上22:00~次日早7:00勿扰模式开启。
名字起的有点儿误导，叫做Provider，但其实是Service，它们负责了真正的ZenRule规则的执行。
ConditionProviderService的创建
SystemConditionProviderService的三个实例初始化都在ZenModeConditions中
frameworks/base/services/core/java/com/android/server/notification/ZenModeConditions.java
public ZenModeConditions(ZenModeHelper helper, ConditionProviders conditionProviders) {
mHelper = helper;
mConditionProviders = conditionProviders;
if (mConditionProviders.isSystemProviderEnabled(ZenModeConfig.COUNTDOWN_PATH)) {
mConditionProviders.addSystemProvider(new CountdownConditionProvider());
}
if (mConditionProviders.isSystemProviderEnabled(ZenModeConfig.SCHEDULE_PATH)) {
mConditionProviders.addSystemProvider(new ScheduleConditionProvider());
}
if (mConditionProviders.isSystemProviderEnabled(ZenModeConfig.EVENT_PATH)) {
mConditionProviders.addSystemProvider(new EventConditionProvider());
}
mConditionProviders.setCallback(this);
}
frameworks/base/services/core/java/com/android/server/notification/ConditionProviders.java
public void addSystemProvider(SystemConditionProviderService service) {
mSystemConditionProviders.add(service);
service.attachBase(mContext);
registerService(service.asInterface(), service.getComponent(), UserHandle.USER_SYSTEM);
}
frameworks/base/services/core/java/com/android/server/notification/ManagedServices.java
ManagedServices和名字一样，作用就是管理service
public void registerService(IInterface service, ComponentName component, int userid) {
checkNotNull(service);
ManagedServiceInfo info = registerServiceImpl(service, component, userid);
if (info != null) {
onServiceAdded(info);
}
} private ManagedServiceInfo registerServiceImpl(ManagedServiceInfo info) {
synchronized (mMutex) {
try {
info.service.asBinder().linkToDeath(info, 0);
mServices.add(info);
return info;
} catch (RemoteException e) {
// already dead
}
}
return null;
} private void rebindServices(boolean forceRebind)
private void registerService(final ComponentName name, final int userid) {
synchronized (mMutex) {
registerServiceLocked(name, userid);
}
}
public void registerSystemService(final ComponentName name, final int userid) {
synchronized (mMutex) {
registerServiceLocked(name, userid, true /* isSystem */);
}
}
private void registerServiceLocked(final ComponentName name, final int userid,
final boolean isSystem) {
...
if (!mContext.bindServiceAsUser(intent,
serviceConnection,
BIND_AUTO_CREATE | BIND_FOREGROUND_SERVICE | BIND_ALLOW_WHITELIST_MANAGEMENT,
new UserHandle(userid))) {
mServicesBinding.remove(servicesBindingTag);
Slog.w(TAG, "Unable to bind " + getCaption() + " service: " + intent);
return;
}
...
}
1.rebindServices，例如SettingsProvider变化，包安装移除和User切换的时候会重新绑定服务
2.registerSystemService这个public方法是供三方app调用的
也就是说registerService整个过程并没有通过正常的途径绑定服务。
其实秘密在参数传递过程中service.asInterface()，SystemConditionProviderService中定义了抽象方法
abstract public IConditionProvider asInterface(); @Override
public IConditionProvider asInterface() {
return (IConditionProvider) onBind(null);
} @Override
public IBinder onBind(Intent intent) {
if (mProvider == null) {
mProvider = new Provider();
}
return mProvider;
} private final class Provider extends IConditionProvider.Stub {
@Override
public void onConnected() {
mHandler.obtainMessage(H.ON_CONNECTED).sendToTarget();
}
@Override
public void onSubscribe(Uri conditionId) { //这是通知conditions变化的起点
mHandler.obtainMessage(H.ON_SUBSCRIBE, conditionId).sendToTarget();
}
@Override
public void onUnsubscribe(Uri conditionId) {
mHandler.obtainMessage(H.ON_UNSUBSCRIBE, conditionId).sendToTarget();
}
}ZenModeConditions是ZenModeHelper的成员变量
public ZenModeHelper(Context context, Looper looper, ConditionProviders conditionProviders) {
...
mConditions = new ZenModeConditions(this, conditionProviders);
...
} public void onStart() {
...
mConditionProviders = new ConditionProviders(getContext(), mHandler, mUserProfiles);
mZenModeHelper = new ZenModeHelper(getContext(), mHandler.getLooper(), mConditionProviders);
}ConditionProviderService的使用
还记得前面讲过的“evaluateConfig是自动规则起作用的核心方法“”吗？不记得可以搜下本文章哦。
frameworks/base/services/core/java/com/android/server/notification/ZenModeConditions.java
public void evaluateConfig(ZenModeConfig config, boolean processSubscriptions) {
if (config == null) return;
if (config.manualRule != null && config.manualRule.condition != null
&& !config.manualRule.isTrueOrUnknown()) {
if (DEBUG) Log.d(TAG, "evaluateConfig: clearing manual rule");
config.manualRule = null; //会清除不在使用的手动规则，不然自动规则永远无法启用
}
final ArraySet<Uri> current = new ArraySet<>();
//先分析手动规则，在再分析自动规则
evaluateRule(config.manualRule, current, processSubscriptions);
for (ZenRule automaticRule : config.automaticRules.values()) {
evaluateRule(automaticRule, current, processSubscriptions);
//更新自动规则的打盹状态，是否要重新启用自动规则
updateSnoozing(automaticRule);
}
final int N = mSubscriptions.size();
for (int i = N - 1; i >= 0; i--) {
final Uri id = mSubscriptions.keyAt(i);
final ComponentName component = mSubscriptions.valueAt(i);
if (processSubscriptions) {
if (!current.contains(id)) {
//移除无用的condition
mConditionProviders.unsubscribeIfNecessary(component, id);
mSubscriptions.removeAt(i);
}
}
}
mFirstEvaluation = false;
}
private void evaluateRule(ZenRule rule, ArraySet<Uri> current, boolean processSubscriptions) {
if (rule == null || rule.conditionId == null) return;
final Uri id = rule.conditionId;
boolean isSystemCondition = false;
for (SystemConditionProviderService sp : mConditionProviders.getSystemProviders()) {
if (sp.isValidConditionId(id)) {
mConditionProviders.ensureRecordExists(sp.getComponent(), id, sp.asInterface());
//ensureRecordExists实际是生成了ConditionRecord
rule.component = sp.getComponent();
isSystemCondition = true;
}
}
...
if (processSubscriptions) {
//condition生效的代码
if (mConditionProviders.subscribeIfNecessary(rule.component, rule.conditionId)) {
mSubscriptions.put(rule.conditionId, rule.component);
} else {
rule.condition = null;
if (DEBUG) Log.d(TAG, "zmc failed to subscribe");
}
}
...
} public boolean subscribeIfNecessary(ComponentName component, Uri conditionId) {
synchronized (mMutex) {
final ConditionRecord r = getRecordLocked(conditionId, component, false /*create*/);
...
subscribeLocked(r);
return r.subscribed;
}
}
private void subscribeLocked(ConditionRecord r) {
if (DEBUG) Slog.d(TAG, "subscribeLocked " + r);
final IConditionProvider provider = provider(r);
...
provider.onSubscribe(r.id);
...
}
public void onSubscribe(Uri conditionId) {
...
evaluateSubscriptions();
}
private void evaluateSubscriptions() {
if (mAlarmManager == null) {
mAlarmManager = (AlarmManager) mContext.getSystemService(Context.ALARM_SERVICE);
}
final long now = System.currentTimeMillis();
synchronized (mSubscriptions) {
setRegistered(!mSubscriptions.isEmpty());
mNextAlarmTime = 0;
long nextUserAlarmTime = getNextAlarm();
for (Uri conditionId : mSubscriptions.keySet()) {
final ScheduleCalendar cal = mSubscriptions.get(conditionId);
if (cal != null && cal.isInSchedule(now)) { //如果在规则时间范围内
if (conditionSnoozed(conditionId) || cal.shouldExitForAlarm(now)) {
notifyCondition(conditionId, Condition.STATE_FALSE, "alarmCanceled");
addSnoozed(conditionId);
} else {
//通知condition变化
notifyCondition(conditionId, Condition.STATE_TRUE, "meetsSchedule");
}
cal.maybeSetNextAlarm(now, nextUserAlarmTime);
} else {
notifyCondition(conditionId, Condition.STATE_FALSE, "!meetsSchedule");
removeSnoozed(conditionId);
if (nextUserAlarmTime == 0) {
cal.maybeSetNextAlarm(now, nextUserAlarmTime);
} else {
notifyCondition(conditionId, Condition.STATE_FALSE, "!meetsSchedule");
if ((cal != null) && (nextUserAlarmTime == 0)) {
cal.maybeSetNextAlarm(now, nextUserAlarmTime);
}
}
if (cal != null) {
final long nextChangeTime = cal.getNextChangeTime(now);
if (nextChangeTime > 0 && nextChangeTime > now) {
if (mNextAlarmTime == 0 || nextChangeTime < mNextAlarmTime) {
mNextAlarmTime = nextChangeTime;
}
}
}
}
}
}
updateAlarm(now, mNextAlarmTime);
}
可见除了核心的通知condtion变化外大部分代码都和Alarm有关，那么alarm到底做了什么事情？
private void updateAlarm(long now, long time) {
final AlarmManager alarms = (AlarmManager) mContext.getSystemService(Context.ALARM_SERVICE);
final PendingIntent pendingIntent = PendingIntent.getBroadcast(mContext,
REQUEST_CODE_EVALUATE,
new Intent(ACTION_EVALUATE)
.addFlags(Intent.FLAG_RECEIVER_FOREGROUND)
.putExtra(EXTRA_TIME, time),
PendingIntent.FLAG_UPDATE_CURRENT);
alarms.cancel(pendingIntent);
if (time > now) {
if (DEBUG) Slog.d(TAG, String.format("Scheduling evaluate for %s, in %s, now=%s",
ts(time), formatDuration(time - now), ts(now)));
alarms.setExact(AlarmManager.RTC_WAKEUP, time, pendingIntent);
} else {
if (DEBUG) Slog.d(TAG, "Not scheduling evaluate");
}
} private BroadcastReceiver mReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
if (DEBUG) Slog.d(TAG, "onReceive " + intent.getAction());
synchronized (mSubscriptions) {
if (Intent.ACTION_TIMEZONE_CHANGED.equals(intent.getAction())) {
...
}
}
evaluateSubscriptions();
}
};后续notifyConditions消息传递流程
frameworks/base/services/core/java/com/android/server/notification/NotificationManagerService.java
ConditionProviderService中的notifyConditions调用的实际是NotificationManagerService的对应方法
public void notifyConditions(final String pkg, IConditionProvider provider,
final Condition[] conditions) {
final ManagedServiceInfo info = mConditionProviders.checkServiceToken(provider);
checkCallerIsSystemOrSameApp(pkg);
mHandler.post(new Runnable() {
@Override
public void run() {
mConditionProviders.notifyConditions(pkg, info, conditions);
}
});
} public void notifyConditions(String pkg, ManagedServiceInfo info, Condition[] conditions) {
...
final int N = conditions.length;
for (int i = 0; i < N; i++) {
final Condition c = conditions[i];
if (mCallback != null) {
mCallback.onConditionChanged(c.id, c);
}
}
} @Override
public void onConditionChanged(Uri id, Condition condition) {
if (DEBUG) Log.d(TAG, "onConditionChanged " + id + " " + condition);
ZenModeConfig config = mHelper.getConfig();
if (config == null) return;
//更新Condition
boolean updated = updateCondition(id, condition, config.manualRule);
for (ZenRule automaticRule : config.automaticRules.values()) {
updated |= updateCondition(id, condition, automaticRule);
updated |= updateSnoozing(automaticRule);
}
if (updated) {
//更新设置
mHelper.setConfig(config, "conditionChanged");
}
} public void setConfig(ZenModeConfig config, String reason) {
synchronized (mConfig) {
setConfigLocked(config, reason);
}
}规则的保存
还有个小问题就是规则是如何存储的，因为不可能只在内存中有，不然systemUI进程死了规则就没有了。
NotificationManagerService.java
private void handleSavePolicyFile() {
if (DBG) Slog.d(TAG, "handleSavePolicyFile");
synchronized (mPolicyFile) {
final FileOutputStream stream;
try {
stream = mPolicyFile.startWrite();
} catch (IOException e) {
Slog.w(TAG, "Failed to save policy file", e);
return;
}
try {
writePolicyXml(stream, false /*forBackup*/);
mPolicyFile.finishWrite(stream);
} catch (IOException e) {
Slog.w(TAG, "Failed to save policy file, restoring backup", e);
mPolicyFile.failWrite(stream);
}
}
BackupManager.dataChanged(getContext().getPackageName());
} private void writePolicyXml(OutputStream stream, boolean forBackup) throws IOException {
final XmlSerializer out = new FastXmlSerializer();
out.setOutput(stream, StandardCharsets.UTF_8.name());
out.startDocument(null, true);
out.startTag(null, TAG_NOTIFICATION_POLICY);
out.attribute(null, ATTR_VERSION, Integer.toString(DB_VERSION));
mZenModeHelper.writeXml(out, forBackup);
mRankingHelper.writeXml(out, forBackup);
out.endTag(null, TAG_NOTIFICATION_POLICY);
out.endDocument();
}
final File systemDir = new File(Environment.getDataDirectory(), "system");
mPolicyFile = new AtomicFile(new File(systemDir, "notification_policy.xml"));
ZenModeHelper.java
public void writeXml(XmlSerializer out, boolean forBackup) throws IOException {
final int N = mConfigs.size();
for (int i = 0; i < N; i++) {
//TODO: http://b/22388012
if (forBackup && mConfigs.keyAt(i) != UserHandle.USER_SYSTEM) {
continue;
}
mConfigs.valueAt(i).writeXml(out);
}
} public void writeXml(XmlSerializer out) throws IOException {
out.startTag(null, ZEN_TAG);
out.attribute(null, ZEN_ATT_VERSION, Integer.toString(XML_VERSION));
out.attribute(null, ZEN_ATT_USER, Integer.toString(user));
out.startTag(null, ALLOW_TAG);
out.attribute(null, ALLOW_ATT_CALLS, Boolean.toString(allowCalls));
out.attribute(null, ALLOW_ATT_REPEAT_CALLERS, Boolean.toString(allowRepeatCallers));
out.attribute(null, ALLOW_ATT_MESSAGES, Boolean.toString(allowMessages));
out.attribute(null, ALLOW_ATT_REMINDERS, Boolean.toString(allowReminders));
out.attribute(null, ALLOW_ATT_EVENTS, Boolean.toString(allowEvents));
out.attribute(null, ALLOW_ATT_CALLS_FROM, Integer.toString(allowCallsFrom));
out.attribute(null, ALLOW_ATT_MESSAGES_FROM, Integer.toString(allowMessagesFrom));
out.attribute(null, ALLOW_ATT_SCREEN_OFF, Boolean.toString(allowWhenScreenOff));
out.attribute(null, ALLOW_ATT_SCREEN_ON, Boolean.toString(allowWhenScreenOn));
out.endTag(null, ALLOW_TAG);
if (manualRule != null) {
out.startTag(null, MANUAL_TAG);
writeRuleXml(manualRule, out);
out.endTag(null, MANUAL_TAG);
}
final int N = automaticRules.size();
for (int i = 0; i < N; i++) {
final String id = automaticRules.keyAt(i);
final ZenRule automaticRule = automaticRules.valueAt(i);
out.startTag(null, AUTOMATIC_TAG);
out.attribute(null, RULE_ATT_ID, id);
writeRuleXml(automaticRule, out);
out.endTag(null, AUTOMATIC_TAG);
}
out.endTag(null, ZEN_TAG);
} public static void writeRuleXml(ZenRule rule, XmlSerializer out) throws IOException {
out.attribute(null, RULE_ATT_ENABLED, Boolean.toString(rule.enabled));
out.attribute(null, RULE_ATT_SNOOZING, Boolean.toString(rule.snoozing));
if (rule.name != null) {
out.attribute(null, RULE_ATT_NAME, rule.name);
}
out.attribute(null, RULE_ATT_ZEN, Integer.toString(rule.zenMode));
if (rule.component != null) {
out.attribute(null, RULE_ATT_COMPONENT, rule.component.flattenToString());
}
if (rule.conditionId != null) {
out.attribute(null, RULE_ATT_CONDITION_ID, rule.conditionId.toString());
}
out.attribute(null, RULE_ATT_CREATION_TIME, Long.toString(rule.creationTime));
if (rule.enabler != null) {
out.attribute(null, RULE_ATT_ENABLER, rule.enabler);
}
if (rule.condition != null) {
writeConditionXml(rule.condition, out);
}
}
扫一扫
1123
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
