diff --git a/res/layout/zen_rule_widget.xml b/res/layout/zen_rule_widget.xml index d502243049b..c6214e7bc8b 100644 --- a/res/layout/zen_rule_widget.xml +++ b/res/layout/zen_rule_widget.xml @@ -20,13 +20,13 @@ android:layout_height="match_parent" android:orientation="horizontal"> diff --git a/res/values/strings.xml b/res/values/strings.xml index f5a702338ef..4aa09515ca0 100644 --- a/res/values/strings.xml +++ b/res/values/strings.xml @@ -7117,6 +7117,12 @@ Schedules + + Delete schedules + + + Delete + Do Not Disturb @@ -7253,6 +7259,9 @@ Do Not Disturb was automatically turned on by an app (%s) + + Do Not Disturb is on for %s with custom settings. + Priority only @@ -7848,6 +7857,15 @@ Stop at the end time or next alarm, whichever comes first + + Do Not Disturb behavior + + + Use default settings + + + Create custom settings for this schedule + ,\u0020 diff --git a/res/xml/zen_mode_schedule_rule_settings.xml b/res/xml/zen_mode_schedule_rule_settings.xml index d05bbd2735f..c257d877356 100644 --- a/res/xml/zen_mode_schedule_rule_settings.xml +++ b/res/xml/zen_mode_schedule_rule_settings.xml @@ -43,4 +43,10 @@ android:summary="@string/zen_mode_schedule_alarm_summary" android:order="99" /> + + + diff --git a/src/com/android/settings/notification/AbstractZenModeAutomaticRulePreferenceController.java b/src/com/android/settings/notification/AbstractZenModeAutomaticRulePreferenceController.java index 5b4c2458f2d..d0f1ee69efa 100644 --- a/src/com/android/settings/notification/AbstractZenModeAutomaticRulePreferenceController.java +++ b/src/com/android/settings/notification/AbstractZenModeAutomaticRulePreferenceController.java @@ -25,7 +25,6 @@ import android.content.pm.PackageManager; import android.content.pm.ServiceInfo; import android.provider.Settings; import android.service.notification.ConditionProviderService; -import android.service.notification.ZenModeConfig; import androidx.fragment.app.Fragment; import androidx.preference.Preference; @@ -34,20 +33,15 @@ import com.android.internal.logging.nano.MetricsProto; import com.android.settings.core.PreferenceControllerMixin; import com.android.settingslib.core.lifecycle.Lifecycle; -import java.util.Arrays; -import java.util.Comparator; -import java.util.List; import java.util.Map; -import java.util.Set; abstract public class AbstractZenModeAutomaticRulePreferenceController extends AbstractZenModePreferenceController implements PreferenceControllerMixin { protected ZenModeBackend mBackend; protected Fragment mParent; - protected Set> mRules; + protected Map.Entry[] mRules; protected PackageManager mPm; - private static List mDefaultRuleIds; public AbstractZenModeAutomaticRulePreferenceController(Context context, String key, Fragment parent, Lifecycle lifecycle) { @@ -60,20 +54,14 @@ abstract public class AbstractZenModeAutomaticRulePreferenceController extends @Override public void updateState(Preference preference) { super.updateState(preference); - mRules = getZenModeRules(); + mRules = mBackend.getAutomaticZenRules(); } - private static List getDefaultRuleIds() { - if (mDefaultRuleIds == null) { - mDefaultRuleIds = ZenModeConfig.DEFAULT_RULE_IDS; + protected Map.Entry[] getRules() { + if (mRules == null) { + mRules = mBackend.getAutomaticZenRules(); } - return mDefaultRuleIds; - } - - private Set> getZenModeRules() { - Map ruleMap = - NotificationManager.from(mContext).getAutomaticZenRules(); - return ruleMap.entrySet(); + return mRules; } protected void showNameRuleDialog(final ZenRuleInfo ri, Fragment parent) { @@ -81,16 +69,6 @@ abstract public class AbstractZenModeAutomaticRulePreferenceController extends RuleNameChangeListener(ri)); } - protected Map.Entry[] sortedRules() { - if (mRules == null) { - mRules = getZenModeRules(); - } - final Map.Entry[] rt = - mRules.toArray(new Map.Entry[mRules.size()]); - Arrays.sort(rt, RULE_COMPARATOR); - return rt; - } - protected static Intent getRuleIntent(String settingsAction, ComponentName configurationActivity, String ruleId) { final Intent intent = new Intent() @@ -104,35 +82,6 @@ abstract public class AbstractZenModeAutomaticRulePreferenceController extends return intent; } - private static final Comparator> RULE_COMPARATOR = - new Comparator>() { - @Override - public int compare(Map.Entry lhs, - Map.Entry rhs) { - // if it's a default rule, should be at the top of automatic rules - boolean lhsIsDefaultRule = getDefaultRuleIds().contains(lhs.getKey()); - boolean rhsIsDefaultRule = getDefaultRuleIds().contains(rhs.getKey()); - if (lhsIsDefaultRule != rhsIsDefaultRule) { - return lhsIsDefaultRule ? -1 : 1; - } - - int byDate = Long.compare(lhs.getValue().getCreationTime(), - rhs.getValue().getCreationTime()); - if (byDate != 0) { - return byDate; - } else { - return key(lhs.getValue()).compareTo(key(rhs.getValue())); - } - } - - private String key(AutomaticZenRule rule) { - final int type = ZenModeConfig.isValidScheduleConditionId(rule.getConditionId()) - ? 1 : ZenModeConfig.isValidEventConditionId(rule.getConditionId()) - ? 2 : 3; - return type + rule.getName().toString(); - } - }; - public static ZenRuleInfo getRuleInfo(PackageManager pm, ServiceInfo si) { if (si == null || si.metaData == null) { return null; diff --git a/src/com/android/settings/notification/ZenAutomaticRuleHeaderPreferenceController.java b/src/com/android/settings/notification/ZenAutomaticRuleHeaderPreferenceController.java index 72bb0e3d611..c2db773b3c0 100644 --- a/src/com/android/settings/notification/ZenAutomaticRuleHeaderPreferenceController.java +++ b/src/com/android/settings/notification/ZenAutomaticRuleHeaderPreferenceController.java @@ -136,7 +136,7 @@ public class ZenAutomaticRuleHeaderPreferenceController extends AbstractZenModeP MetricsProto.MetricsEvent.ACTION_ZEN_MODE_RULE_NAME_CHANGE_OK); mRule.setName(ruleName); mRule.setModified(true); - mBackend.setZenRule(mId, mRule); + mBackend.updateZenRule(mId, mRule); } } } diff --git a/src/com/android/settings/notification/ZenAutomaticRuleSwitchPreferenceController.java b/src/com/android/settings/notification/ZenAutomaticRuleSwitchPreferenceController.java index f38deb35167..e5ca7544c2a 100644 --- a/src/com/android/settings/notification/ZenAutomaticRuleSwitchPreferenceController.java +++ b/src/com/android/settings/notification/ZenAutomaticRuleSwitchPreferenceController.java @@ -88,6 +88,6 @@ public class ZenAutomaticRuleSwitchPreferenceController extends final boolean enabled = isChecked; if (enabled == mRule.isEnabled()) return; mRule.setEnabled(enabled); - mBackend.setZenRule(mId, mRule); + mBackend.updateZenRule(mId, mRule); } } diff --git a/src/com/android/settings/notification/ZenModeAlarmsPreferenceController.java b/src/com/android/settings/notification/ZenModeAlarmsPreferenceController.java index 67d9e9374c2..b8776683971 100644 --- a/src/com/android/settings/notification/ZenModeAlarmsPreferenceController.java +++ b/src/com/android/settings/notification/ZenModeAlarmsPreferenceController.java @@ -21,12 +21,12 @@ import android.content.Context; import android.provider.Settings; import android.util.Log; -import com.android.internal.logging.nano.MetricsProto; -import com.android.settingslib.core.lifecycle.Lifecycle; - import androidx.preference.Preference; import androidx.preference.SwitchPreference; +import com.android.internal.logging.nano.MetricsProto; +import com.android.settingslib.core.lifecycle.Lifecycle; + public class ZenModeAlarmsPreferenceController extends AbstractZenModePreferenceController implements Preference.OnPreferenceChangeListener { @@ -78,6 +78,7 @@ public class ZenModeAlarmsPreferenceController extends mMetricsFeatureProvider.action(mContext, MetricsProto.MetricsEvent.ACTION_ZEN_ALLOW_ALARMS, allowAlarms); mBackend.saveSoundPolicy(Policy.PRIORITY_CATEGORY_ALARMS, allowAlarms); + return true; } } diff --git a/src/com/android/settings/notification/ZenModeAutomaticRulesPreferenceController.java b/src/com/android/settings/notification/ZenModeAutomaticRulesPreferenceController.java index 7679b0bf8a4..615b26c35d9 100644 --- a/src/com/android/settings/notification/ZenModeAutomaticRulesPreferenceController.java +++ b/src/com/android/settings/notification/ZenModeAutomaticRulesPreferenceController.java @@ -28,6 +28,7 @@ import androidx.preference.PreferenceScreen; import com.android.settingslib.core.lifecycle.Lifecycle; import java.util.Map; +import java.util.Objects; public class ZenModeAutomaticRulesPreferenceController extends AbstractZenModeAutomaticRulePreferenceController { @@ -62,16 +63,40 @@ public class ZenModeAutomaticRulesPreferenceController extends @Override public void updateState(Preference preference) { super.updateState(preference); + Map.Entry[] sortedRules = getRules(); + final int currNumPreferences = mPreferenceCategory.getPreferenceCount(); + if (currNumPreferences == sortedRules.length) { + for (int i = 0; i < sortedRules.length; i++) { + ZenRulePreference pref = (ZenRulePreference) mPreferenceCategory.getPreference(i); + // we are either: + // 1. updating the enabled state or name of the rule + // 2. rule was added or deleted, so reload the entire list + if (Objects.equals(pref.mId, sortedRules[i].getKey())) { + AutomaticZenRule rule = sortedRules[i].getValue(); + pref.setName(rule.getName()); + pref.setChecked(rule.isEnabled()); + } else { + reloadAllRules(sortedRules); + break; + } + } + } else { + reloadAllRules(sortedRules); + } + } + @VisibleForTesting + void reloadAllRules(Map.Entry[] rules) { mPreferenceCategory.removeAll(); - Map.Entry[] sortedRules = sortedRules(); - for (Map.Entry sortedRule : sortedRules) { - ZenRulePreference pref = new ZenRulePreference(mPreferenceCategory.getContext(), - sortedRule, mParent, mMetricsFeatureProvider); + for (Map.Entry rule : rules) { + ZenRulePreference pref = createZenRulePreference(rule); mPreferenceCategory.addPreference(pref); } } + + @VisibleForTesting + ZenRulePreference createZenRulePreference(Map.Entry rule) { + return new ZenRulePreference(mPreferenceCategory.getContext(), + rule, mParent, mMetricsFeatureProvider); + } } - - - diff --git a/src/com/android/settings/notification/ZenModeAutomationSettings.java b/src/com/android/settings/notification/ZenModeAutomationSettings.java index 44bc5f1eb68..c559a28bbb5 100644 --- a/src/com/android/settings/notification/ZenModeAutomationSettings.java +++ b/src/com/android/settings/notification/ZenModeAutomationSettings.java @@ -16,9 +16,15 @@ package com.android.settings.notification; +import android.app.AlertDialog; +import android.app.AutomaticZenRule; import android.content.Context; +import android.content.DialogInterface; import android.provider.SearchIndexableResource; import android.service.notification.ConditionProviderService; +import android.view.Menu; +import android.view.MenuInflater; +import android.view.MenuItem; import androidx.fragment.app.Fragment; @@ -34,10 +40,14 @@ import com.android.settingslib.search.SearchIndexable; import java.util.ArrayList; import java.util.List; +import java.util.Map; @SearchIndexable public class ZenModeAutomationSettings extends ZenModeSettingsBase { protected final ManagedServiceSettings.Config CONFIG = getConditionProviderConfig(); + private CharSequence[] mDeleteDialogRuleNames; + private String[] mDeleteDialogRuleIds; + private boolean[] mDeleteDialogChecked; @Override protected List createPreferenceControllers(Context context) { @@ -74,6 +84,52 @@ public class ZenModeAutomationSettings extends ZenModeSettingsBase { .setNoun("condition provider") .build(); } + private final int DELETE_RULES = 1; + + @Override + public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) { + menu.add(Menu.NONE, DELETE_RULES, Menu.NONE, R.string.zen_mode_delete_automatic_rules); + super.onCreateOptionsMenu(menu, inflater); + } + + @Override + public boolean onOptionsItemSelected(MenuItem item) { + switch (item.getItemId()) { + case DELETE_RULES: + Map.Entry[] rules = mBackend.getAutomaticZenRules(); + mDeleteDialogRuleNames = new CharSequence[rules.length]; + mDeleteDialogRuleIds = new String[rules.length]; + mDeleteDialogChecked = new boolean[rules.length]; + for (int i = 0; i < rules.length; i++) { + mDeleteDialogRuleNames[i] = rules[i].getValue().getName(); + mDeleteDialogRuleIds[i] = rules[i].getKey(); + } + new AlertDialog.Builder(mContext) + .setTitle(R.string.zen_mode_delete_automatic_rules) + .setMultiChoiceItems(mDeleteDialogRuleNames, null, + new DialogInterface.OnMultiChoiceClickListener() { + @Override + public void onClick(DialogInterface dialog, int which, + boolean isChecked) { + mDeleteDialogChecked[which] = isChecked; + } + }) + .setPositiveButton(R.string.zen_mode_schedule_delete, + new DialogInterface.OnClickListener() { + @Override + public void onClick(DialogInterface dialog, int which) { + for (int i = 0; i < rules.length; i++) { + if (mDeleteDialogChecked[i]) { + mBackend.removeZenRule(mDeleteDialogRuleIds[i]); + } + } + } + }).show(); + return true; + default: + return super.onOptionsItemSelected(item); + } + } /** * For Search. diff --git a/src/com/android/settings/notification/ZenModeBackend.java b/src/com/android/settings/notification/ZenModeBackend.java index de30e5dae09..4824825aa91 100644 --- a/src/com/android/settings/notification/ZenModeBackend.java +++ b/src/com/android/settings/notification/ZenModeBackend.java @@ -32,6 +32,11 @@ import androidx.annotation.VisibleForTesting; import com.android.settings.R; +import java.util.Arrays; +import java.util.Comparator; +import java.util.List; +import java.util.Map; + public class ZenModeBackend { @VisibleForTesting protected static final String ZEN_MODE_FROM_ANYONE = "zen_mode_from_anyone"; @@ -42,6 +47,7 @@ public class ZenModeBackend { @VisibleForTesting protected static final String ZEN_MODE_FROM_NONE = "zen_mode_from_none"; protected static final int SOURCE_NONE = -1; + private static List mDefaultRuleIds; private static ZenModeBackend sInstance; @@ -79,7 +85,7 @@ public class ZenModeBackend { Settings.Global.ZEN_MODE, mZenMode); } - protected boolean setZenRule(String id, AutomaticZenRule rule) { + protected boolean updateZenRule(String id, AutomaticZenRule rule) { return NotificationManager.from(mContext).updateAutomaticZenRule(id, rule); } @@ -294,13 +300,65 @@ public class ZenModeBackend { return NotificationManager.from(mContext).removeAutomaticZenRule(ruleId); } + public NotificationManager.Policy getConsolidatedPolicy() { + return NotificationManager.from(mContext).getConsolidatedNotificationPolicy(); + } + protected String addZenRule(AutomaticZenRule rule) { try { - String id = NotificationManager.from(mContext).addAutomaticZenRule(rule); - NotificationManager.from(mContext).getAutomaticZenRule(id); - return id; + return NotificationManager.from(mContext).addAutomaticZenRule(rule); } catch (Exception e) { return null; } } + + protected Map.Entry[] getAutomaticZenRules() { + Map ruleMap = + NotificationManager.from(mContext).getAutomaticZenRules(); + final Map.Entry[] rt = ruleMap.entrySet().toArray( + new Map.Entry[ruleMap.size()]); + Arrays.sort(rt, RULE_COMPARATOR); + return rt; + } + + protected AutomaticZenRule getAutomaticZenRule(String id) { + return NotificationManager.from(mContext).getAutomaticZenRule(id); + } + + private static List getDefaultRuleIds() { + if (mDefaultRuleIds == null) { + mDefaultRuleIds = ZenModeConfig.DEFAULT_RULE_IDS; + } + return mDefaultRuleIds; + } + + @VisibleForTesting + public static final Comparator> RULE_COMPARATOR = + new Comparator>() { + @Override + public int compare(Map.Entry lhs, + Map.Entry rhs) { + // if it's a default rule, should be at the top of automatic rules + boolean lhsIsDefaultRule = getDefaultRuleIds().contains(lhs.getKey()); + boolean rhsIsDefaultRule = getDefaultRuleIds().contains(rhs.getKey()); + if (lhsIsDefaultRule != rhsIsDefaultRule) { + return lhsIsDefaultRule ? -1 : 1; + } + + int byDate = Long.compare(lhs.getValue().getCreationTime(), + rhs.getValue().getCreationTime()); + if (byDate != 0) { + return byDate; + } else { + return key(lhs.getValue()).compareTo(key(rhs.getValue())); + } + } + + private String key(AutomaticZenRule rule) { + final int type = ZenModeConfig.isValidScheduleConditionId(rule.getConditionId()) + ? 1 : ZenModeConfig.isValidEventConditionId(rule.getConditionId()) + ? 2 : 3; + return type + rule.getName().toString(); + } + }; } diff --git a/src/com/android/settings/notification/ZenModeRuleSettingsBase.java b/src/com/android/settings/notification/ZenModeRuleSettingsBase.java index 9e5dbc33042..11b8084f73f 100644 --- a/src/com/android/settings/notification/ZenModeRuleSettingsBase.java +++ b/src/com/android/settings/notification/ZenModeRuleSettingsBase.java @@ -124,7 +124,7 @@ public abstract class ZenModeRuleSettingsBase extends ZenModeSettingsBase { protected void updateRule(Uri newConditionId) { mRule.setConditionId(newConditionId); - mBackend.setZenRule(mId, mRule); + mBackend.updateZenRule(mId, mRule); } @Override diff --git a/src/com/android/settings/notification/ZenModeScheduleRuleSettings.java b/src/com/android/settings/notification/ZenModeScheduleRuleSettings.java index f65a8b00c3d..0b2e1bcc27d 100644 --- a/src/com/android/settings/notification/ZenModeScheduleRuleSettings.java +++ b/src/com/android/settings/notification/ZenModeScheduleRuleSettings.java @@ -64,7 +64,6 @@ public class ZenModeScheduleRuleSettings extends ZenModeRuleSettingsBase { private TimePickerPreference mEnd; private SwitchPreference mExitAtAlarm; private AlertDialog mDayDialog; - private ScheduleInfo mSchedule; @Override @@ -186,7 +185,6 @@ public class ZenModeScheduleRuleSettings extends ZenModeRuleSettingsBase { final int summaryFormat = nextDay ? R.string.zen_mode_end_time_next_day_summary_format : 0; mEnd.setSummaryFormat(summaryFormat); } - @Override protected void updateControlsInternal() { updateDays(); diff --git a/src/com/android/settings/notification/ZenModeSettingsFooterPreferenceController.java b/src/com/android/settings/notification/ZenModeSettingsFooterPreferenceController.java index 6d5aac915da..f69eac749fa 100644 --- a/src/com/android/settings/notification/ZenModeSettingsFooterPreferenceController.java +++ b/src/com/android/settings/notification/ZenModeSettingsFooterPreferenceController.java @@ -16,16 +16,23 @@ package com.android.settings.notification; +import android.app.NotificationManager; import android.content.Context; +import android.icu.text.ListFormatter; import android.net.Uri; import android.provider.Settings; import android.service.notification.ZenModeConfig; +import android.util.Log; import androidx.preference.Preference; import com.android.settings.R; import com.android.settingslib.core.lifecycle.Lifecycle; +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; + public class ZenModeSettingsFooterPreferenceController extends AbstractZenModePreferenceController { protected static final String KEY = "footer_preference"; @@ -65,6 +72,31 @@ public class ZenModeSettingsFooterPreferenceController extends AbstractZenModePr protected String getFooterText() { ZenModeConfig config = getZenModeConfig(); + + NotificationManager.Policy appliedPolicy = mBackend.getConsolidatedPolicy(); + NotificationManager.Policy defaultPolicy = config.toNotificationPolicy(); + final boolean usingCustomPolicy = !Objects.equals(appliedPolicy, defaultPolicy); + + if (usingCustomPolicy) { + final List activeRules = getActiveRules(config); + final List rulesNames = new ArrayList<>(); + for (ZenModeConfig.ZenRule rule : activeRules) { + if (rule.name != null) { + rulesNames.add(rule.name); + } + } + if (rulesNames.size() > 0) { + String rules = ListFormatter.getInstance().format(rulesNames); + if (!rules.isEmpty()) { + return mContext.getString(R.string.zen_mode_settings_dnd_custom_settings_footer, + rules); + } + } + } + return getFooterUsingDefaultPolicy(config); + } + + private String getFooterUsingDefaultPolicy(ZenModeConfig config) { String footerText = ""; long latestEndTime = -1; @@ -116,4 +148,18 @@ public class ZenModeSettingsFooterPreferenceController extends AbstractZenModePr } return footerText; } + + private List getActiveRules(ZenModeConfig config) { + List zenRules = new ArrayList<>(); + if (config.manualRule != null) { + zenRules.add(config.manualRule); + } + + for (ZenModeConfig.ZenRule automaticRule : config.automaticRules.values()) { + if (automaticRule.isAutomaticActive()) { + zenRules.add(automaticRule); + } + } + return zenRules; + } } diff --git a/src/com/android/settings/notification/ZenRulePreference.java b/src/com/android/settings/notification/ZenRulePreference.java index 8058e6cc319..48a879b6dfa 100644 --- a/src/com/android/settings/notification/ZenRulePreference.java +++ b/src/com/android/settings/notification/ZenRulePreference.java @@ -19,17 +19,18 @@ package com.android.settings.notification; import android.app.AutomaticZenRule; import android.content.ComponentName; import android.content.Context; +import android.content.Intent; import android.content.pm.ApplicationInfo; import android.content.pm.PackageManager; import android.content.pm.ServiceInfo; import android.service.notification.ZenModeConfig; import android.view.View; +import android.widget.CheckBox; import androidx.fragment.app.Fragment; import androidx.preference.Preference; import androidx.preference.PreferenceViewHolder; -import com.android.internal.logging.nano.MetricsProto; import com.android.settings.R; import com.android.settings.utils.ManagedServiceSettings; import com.android.settings.utils.ZenServiceListing; @@ -37,11 +38,11 @@ import com.android.settingslib.TwoTargetPreference; import com.android.settingslib.core.instrumentation.MetricsFeatureProvider; import java.util.Map; +import java.util.Objects; public class ZenRulePreference extends TwoTargetPreference { private static final ManagedServiceSettings.Config CONFIG = ZenModeAutomationSettings.getConditionProviderConfig(); - final CharSequence mName; final String mId; boolean appExists; final Fragment mParent; @@ -51,16 +52,23 @@ public class ZenRulePreference extends TwoTargetPreference { final ZenServiceListing mServiceListing; final PackageManager mPm; final MetricsFeatureProvider mMetricsFeatureProvider; + final AutomaticZenRule mRule; + CharSequence mName; + + private boolean mIsSystemRule; + private Intent mIntent; + private boolean mChecked; + private CheckBox mCheckBox; public ZenRulePreference(Context context, final Map.Entry ruleEntry, Fragment parent, MetricsFeatureProvider metricsProvider) { super(context); - + setLayoutResource(R.layout.preference_checkable_two_target); mBackend = ZenModeBackend.getInstance(context); mContext = context; - final AutomaticZenRule rule = ruleEntry.getValue(); - mName = rule.getName(); + mRule = ruleEntry.getValue(); + mName = mRule.getName(); mId = ruleEntry.getKey(); mParent = parent; mPm = mContext.getPackageManager(); @@ -68,65 +76,97 @@ public class ZenRulePreference extends TwoTargetPreference { mServiceListing.reloadApprovedServices(); mPref = this; mMetricsFeatureProvider = metricsProvider; - - setAttributes(rule); + mChecked = mRule.isEnabled(); + setAttributes(mRule); + setWidgetLayoutResource(getSecondTargetResId()); } - @Override protected int getSecondTargetResId() { - if (mId != null && ZenModeConfig.DEFAULT_RULE_IDS.contains(mId)) { - return 0; + if (mIntent != null) { + return R.layout.zen_rule_widget; } - - return R.layout.zen_rule_widget; + return 0; } @Override public void onBindViewHolder(PreferenceViewHolder view) { super.onBindViewHolder(view); + View settingsWidget = view.findViewById(android.R.id.widget_frame); + View divider = view.findViewById(R.id.two_target_divider); + if (mIntent != null) { + divider.setVisibility(View.VISIBLE); + settingsWidget.setVisibility(View.VISIBLE); + settingsWidget.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + mContext.startActivity(mIntent); + } + }); + } else { + divider.setVisibility(View.GONE); + settingsWidget.setVisibility(View.GONE); + settingsWidget.setOnClickListener(null); + } - View v = view.findViewById(R.id.delete_zen_rule); - if (v != null) { - v.setOnClickListener(mDeleteListener); + View checkboxContainer = view.findViewById(R.id.checkbox_container); + if (checkboxContainer != null) { + checkboxContainer.setOnClickListener(mOnCheckBoxClickListener); + } + mCheckBox = (CheckBox) view.findViewById(com.android.internal.R.id.checkbox); + if (mCheckBox != null) { + mCheckBox.setChecked(mChecked); } } - private final View.OnClickListener mDeleteListener = new View.OnClickListener() { + public boolean isChecked() { + return mChecked; + } + + public void setChecked(boolean checked) { + mChecked = checked; + if (mCheckBox != null) { + mCheckBox.setChecked(checked); + } + } + + public void setName(String name) { + if (!Objects.equals(mName, name)) { + mName = name; + setTitle(mName); + } + } + + @Override + public void onClick() { + mOnCheckBoxClickListener.onClick(null); + } + + private View.OnClickListener mOnCheckBoxClickListener = new View.OnClickListener() { @Override public void onClick(View v) { - showDeleteRuleDialog(mParent, mId, mName.toString()); + mRule.setEnabled(!mChecked); + mBackend.updateZenRule(mId, mRule); + setChecked(mRule.isEnabled()); + setAttributes(mRule); } }; - private void showDeleteRuleDialog(final Fragment parent, final String ruleId, - final String ruleName) { - ZenDeleteRuleDialog.show(parent, ruleName, ruleId, - new ZenDeleteRuleDialog.PositiveClickListener() { - @Override - public void onOk(String id) { - mMetricsFeatureProvider.action(mContext, - MetricsProto.MetricsEvent.ACTION_ZEN_DELETE_RULE_OK); - mBackend.removeZenRule(id); - } - }); - } - protected void setAttributes(AutomaticZenRule rule) { final boolean isSchedule = ZenModeConfig.isValidScheduleConditionId( rule.getConditionId(), true); final boolean isEvent = ZenModeConfig.isValidEventConditionId(rule.getConditionId()); - final boolean isSystemRule = isSchedule || isEvent; + mIsSystemRule = isSchedule || isEvent; try { ApplicationInfo info = mPm.getApplicationInfo(rule.getOwner().getPackageName(), 0); - setSummary(computeRuleSummary(rule, isSystemRule, info.loadLabel(mPm))); + setSummary(computeRuleSummary(rule, mIsSystemRule, info.loadLabel(mPm))); } catch (PackageManager.NameNotFoundException e) { appExists = false; return; } appExists = true; - setTitle(rule.getName()); + setTitle(mName); setPersistent(false); final String action = isSchedule ? ZenModeScheduleRuleSettings.ACTION @@ -134,9 +174,8 @@ public class ZenRulePreference extends TwoTargetPreference { ServiceInfo si = mServiceListing.findService(rule.getOwner()); ComponentName settingsActivity = AbstractZenModeAutomaticRulePreferenceController. getSettingsActivity(si); - setIntent(AbstractZenModeAutomaticRulePreferenceController.getRuleIntent(action, - settingsActivity, mId)); - setSelectable(settingsActivity != null || isSystemRule); + mIntent = AbstractZenModeAutomaticRulePreferenceController.getRuleIntent(action, + settingsActivity, mId); setKey(mId); } diff --git a/tests/robotests/src/com/android/settings/notification/ZenModeAutomaticRulesPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/notification/ZenModeAutomaticRulesPreferenceControllerTest.java index ec50e2b6a35..3eae2667973 100644 --- a/tests/robotests/src/com/android/settings/notification/ZenModeAutomaticRulesPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/notification/ZenModeAutomaticRulesPreferenceControllerTest.java @@ -16,13 +16,17 @@ package com.android.settings.notification; -import static junit.framework.Assert.assertEquals; - +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyInt; +import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import android.app.AutomaticZenRule; -import android.app.NotificationManager; import android.content.Context; import android.provider.Settings; @@ -31,161 +35,122 @@ import androidx.preference.PreferenceCategory; import androidx.preference.PreferenceScreen; import com.android.settings.testutils.SettingsRobolectricTestRunner; -import com.android.settingslib.core.lifecycle.Lifecycle; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; import org.mockito.MockitoAnnotations; +import org.mockito.internal.util.reflection.FieldSetter; import org.robolectric.RuntimeEnvironment; -import org.robolectric.shadows.ShadowApplication; import org.robolectric.util.ReflectionHelpers; -import java.util.Arrays; import java.util.HashMap; -import java.util.List; import java.util.Map; @RunWith(SettingsRobolectricTestRunner.class) public class ZenModeAutomaticRulesPreferenceControllerTest { - private static final String GENERIC_RULE_NAME = "test"; - private static final String DEFAULT_ID_1 = "DEFAULT_1"; - private static final String DEFAULT_ID_2 = "DEFAULT_2"; - private ZenModeAutomaticRulesPreferenceController mController; - private final List mDefaultIds = Arrays.asList(DEFAULT_ID_1, DEFAULT_ID_2); - @Mock private ZenModeBackend mBackend; @Mock - private NotificationManager mNotificationManager; - @Mock private PreferenceCategory mockPref; @Mock - private NotificationManager.Policy mPolicy; - @Mock private PreferenceScreen mPreferenceScreen; - + @Mock + private ZenRulePreference mZenRulePreference; private Context mContext; @Before public void setup() { MockitoAnnotations.initMocks(this); - ShadowApplication shadowApplication = ShadowApplication.getInstance(); - shadowApplication.setSystemService(Context.NOTIFICATION_SERVICE, mNotificationManager); - mContext = RuntimeEnvironment.application; - when(mNotificationManager.getNotificationPolicy()).thenReturn(mPolicy); - mController = new ZenModeAutomaticRulesPreferenceController(mContext, mock(Fragment.class), - mock(Lifecycle.class)); - + mController = spy(new ZenModeAutomaticRulesPreferenceController(mContext, mock(Fragment.class), + null)); ReflectionHelpers.setField(mController, "mBackend", mBackend); - ReflectionHelpers.setField(mController, "mDefaultRuleIds", mDefaultIds); - when(mPreferenceScreen.findPreference(mController.getPreferenceKey())).thenReturn( mockPref); mController.displayPreference(mPreferenceScreen); + doReturn(mZenRulePreference).when(mController).createZenRulePreference(any()); } @Test - public void updateState_checkRuleOrderingDescending() { - final int NUM_RULES = 4; - when(mNotificationManager.getAutomaticZenRules()).thenReturn( - mockAutoZenRulesDecreasingCreationTime(NUM_RULES)); + public void testUpdateState_clearsPreferencesWhenAddingNewPreferences() { + final int NUM_RULES = 3; + Map rMap = new HashMap<>(); - Map.Entry[] rules = mController.sortedRules(); - assertEquals(NUM_RULES, rules.length); + String ruleId1 = "test1_id"; + String ruleId2 = "test2_id"; + String ruleId3 = "test3_id"; - // check ordering, most recent should be at the bottom/end (ie higher creation time) - for (int i = 0; i < NUM_RULES; i++) { - assertEquals(GENERIC_RULE_NAME + (NUM_RULES - 1 - i), rules[i].getKey()); - } + AutomaticZenRule autoRule1 = new AutomaticZenRule("test_rule_1", null, + null, Settings.Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS, true, 10); + AutomaticZenRule autoRule2 = new AutomaticZenRule("test_rule_2", null, + null, Settings.Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS, true, 20); + AutomaticZenRule autoRule3 = new AutomaticZenRule("test_rule_3", null, + null, Settings.Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS, true, 30); + + rMap.put(ruleId1, autoRule1); + rMap.put(ruleId2, autoRule2); + rMap.put(ruleId3, autoRule3); + + // should add 3 new preferences to mockPref + mockGetAutomaticZenRules(NUM_RULES, rMap); + mController.updateState(mockPref); + verify(mockPref, times(1)).removeAll(); + verify(mockPref, times(NUM_RULES)).addPreference(any()); } @Test - public void updateState_checkRuleOrderingAscending() { - final int NUM_RULES = 4; - when(mNotificationManager.getAutomaticZenRules()).thenReturn( - mockAutoZenRulesAscendingCreationTime(NUM_RULES)); + public void testUpdateState_clearsPreferencesWhenRemovingPreferences(){ + final int NUM_RULES = 2; + Map rMap = new HashMap<>(); - Map.Entry[] rules = mController.sortedRules(); - assertEquals(NUM_RULES, rules.length); + String ruleId1 = "test1_id"; + String ruleId2 = "test2_id"; - // check ordering, most recent should be at the bottom/end (ie higher creation time) - for (int i = 0; i < NUM_RULES; i++) { - assertEquals(GENERIC_RULE_NAME + i, rules[i].getKey()); - } + AutomaticZenRule autoRule1 = new AutomaticZenRule("test_rule_1", null, + null, Settings.Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS, true, 10); + AutomaticZenRule autoRule2 = new AutomaticZenRule("test_rule_2", null, + null, Settings.Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS, true, 20); + + rMap.put(ruleId1, autoRule1); + rMap.put(ruleId2, autoRule2); + + // update state should re-add all preferences since a preference was deleted + when(mockPref.getPreferenceCount()).thenReturn(NUM_RULES + 2); + mockGetAutomaticZenRules(NUM_RULES, rMap); + mController.updateState(mockPref); + verify(mockPref, times(1)).removeAll(); + verify(mockPref, times(NUM_RULES)).addPreference(any()); } @Test - public void updateState_checkRuleOrderingDescending_withDefaultRules() { - final int NUM_RULES = 4; + public void testUpdateState_updateEnableState() throws NoSuchFieldException { + final int NUM_RULES = 1; + Map rMap = new HashMap<>(); + String testId = "test1_id"; + AutomaticZenRule rule = new AutomaticZenRule("rule_name", null, + null, Settings.Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS, true, 10); + rMap.put(testId, rule); - Map ruleMap = mockAutoZenRulesDecreasingCreationTime(NUM_RULES); - ruleMap.put(DEFAULT_ID_2, new AutomaticZenRule("DEFAULT_1_NAME", null, - null, Settings.Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS, true, 20)); - ruleMap.put(DEFAULT_ID_1, new AutomaticZenRule("DEFAULT_1_NAME", null, - null, Settings.Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS, true, 10)); - when(mNotificationManager.getAutomaticZenRules()).thenReturn(ruleMap); + when(mockPref.getPreferenceCount()).thenReturn(NUM_RULES); + when(mockPref.getPreference(anyInt())).thenReturn(mZenRulePreference); - Map.Entry[] rules = mController.sortedRules(); - assertEquals(NUM_RULES + 2, rules.length); - - assertEquals(rules[0].getKey(), DEFAULT_ID_1); - assertEquals(rules[1].getKey(), DEFAULT_ID_2); - // NON-DEFAULT RULES check ordering, most recent at the bottom/end - for (int i = 0; i < NUM_RULES; i++) { - assertEquals(GENERIC_RULE_NAME + (NUM_RULES - 1 - i), rules[i + 2].getKey()); - } + // update state should NOT re-add all the preferences, should only update enable state + rule.setEnabled(false); + rMap.put(testId, rule); + mockGetAutomaticZenRules(NUM_RULES, rMap); + FieldSetter.setField(mZenRulePreference, ZenRulePreference.class.getDeclaredField("mId"), testId); + mController.updateState(mockPref); + verify(mZenRulePreference, times(1)).setChecked(false); + verify(mController, never()).reloadAllRules(any()); } - @Test - public void updateState_checkRuleOrderingMix() { - final int NUM_RULES = 4; - // map with creation times: 0, 2, 4, 6 - Map rMap = mockAutoZenRulesAscendingCreationTime(NUM_RULES); - - final String insertedRule1 = "insertedRule1"; - rMap.put(insertedRule1, new AutomaticZenRule(insertedRule1, null, null, - Settings.Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS, true, 5)); - - final String insertedRule2 = "insertedRule2"; - rMap.put(insertedRule2, new AutomaticZenRule(insertedRule2, null, null, - Settings.Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS, true, 3)); - - // rule map with rule creation times, 0, 2, 4, 6, 5, 3 - // sort should create ordering based on creation times: 0, 2, 3, 4, 5, 6 - when(mNotificationManager.getAutomaticZenRules()).thenReturn(rMap); - - Map.Entry[] rules = mController.sortedRules(); - assertEquals(NUM_RULES + 2, rules.length); // inserted 2 rules - - // check ordering of inserted rules - assertEquals(insertedRule1, rules[4].getKey()); - assertEquals(insertedRule2, rules[2].getKey()); - } - - private Map mockAutoZenRulesAscendingCreationTime(int numRules) { - Map ruleMap = new HashMap<>(); - - for (int i = 0; i < numRules; i++) { - ruleMap.put(GENERIC_RULE_NAME + i, new AutomaticZenRule(GENERIC_RULE_NAME + i, null, - null, Settings.Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS, true, i * 2)); - } - - return ruleMap; - } - - private Map mockAutoZenRulesDecreasingCreationTime(int numRules) { - Map ruleMap = new HashMap<>(); - - for (int i = 0; i < numRules; i++) { - ruleMap.put(GENERIC_RULE_NAME + i, new AutomaticZenRule(GENERIC_RULE_NAME + i, null, - null, Settings.Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS, true, numRules - i)); - } - - return ruleMap; + private void mockGetAutomaticZenRules(int numRules, Map rules) { + Map.Entry[] arr = new Map.Entry[numRules]; + rules.entrySet().toArray(arr); + when(mBackend.getAutomaticZenRules()).thenReturn(arr); } } diff --git a/tests/robotests/src/com/android/settings/notification/ZenModeBackendTest.java b/tests/robotests/src/com/android/settings/notification/ZenModeBackendTest.java new file mode 100644 index 00000000000..94a3c011e16 --- /dev/null +++ b/tests/robotests/src/com/android/settings/notification/ZenModeBackendTest.java @@ -0,0 +1,108 @@ +package com.android.settings.notification; + +import static junit.framework.Assert.assertEquals; + +import android.app.AutomaticZenRule; +import android.provider.Settings; +import android.service.notification.ZenModeConfig; + +import com.android.settings.testutils.SettingsRobolectricTestRunner; + +import org.junit.Test; +import org.junit.runner.RunWith; + +import java.util.Arrays; +import java.util.HashMap; +import java.util.Map; + +@RunWith(SettingsRobolectricTestRunner.class) +public class ZenModeBackendTest { + + private static final String GENERIC_RULE_NAME = "test"; + private static final String DEFAULT_ID_1 = ZenModeConfig.EVENTS_DEFAULT_RULE_ID; + private static final String DEFAULT_ID_2 = ZenModeConfig.EVERY_NIGHT_DEFAULT_RULE_ID; + + @Test + public void updateState_checkRuleOrderingDescending() { + final int NUM_RULES = 4; + Map.Entry[] rules = populateAutoZenRulesDescendingCreationTime( + NUM_RULES, false); + Arrays.sort(rules, ZenModeBackend.RULE_COMPARATOR); + + // check ordering, most recent should be at the end + for (int i = 0; i < NUM_RULES; i++) { + assertEquals(GENERIC_RULE_NAME + (NUM_RULES - 1 - i), rules[i].getKey()); + } + } + + @Test + public void updateState_checkRuleOrderingAscending() { + final int NUM_RULES = 4; + Map.Entry[] rules = populateAutoZenRulesAscendingCreationTime( + NUM_RULES, false); + Arrays.sort(rules, ZenModeBackend.RULE_COMPARATOR); + + // check ordering, most recent should be at the end + for (int i = 0; i < NUM_RULES; i++) { + assertEquals(GENERIC_RULE_NAME + i, rules[i].getKey()); + } + } + + @Test + public void updateState_checkRuleOrderingDescending_withDefaultRules() { + final int NUM_RULES = 4; + + Map.Entry[] rules = populateAutoZenRulesDescendingCreationTime(NUM_RULES, + true); + Arrays.sort(rules, ZenModeBackend.RULE_COMPARATOR); + + assertEquals(rules[0].getKey(), DEFAULT_ID_1); + assertEquals(rules[1].getKey(), DEFAULT_ID_2); + // NON-DEFAULT RULES check ordering, most recent at the bottom/end + for (int i = 0; i < NUM_RULES; i++) { + assertEquals(GENERIC_RULE_NAME + (NUM_RULES - 1 - i), rules[i + 2].getKey()); + } + } + + private Map.Entry[] populateAutoZenRulesAscendingCreationTime( + int numRules, boolean addDefaultRules) { + Map ruleMap = new HashMap<>(); + + for (int i = 0; i < numRules; i++) { + ruleMap.put(GENERIC_RULE_NAME + i, new AutomaticZenRule(GENERIC_RULE_NAME + i, null, + null, Settings.Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS, true, i * 2)); + } + + if (addDefaultRules) { + ruleMap.put(DEFAULT_ID_1, new AutomaticZenRule("DEFAULT_1_NAME", null, + null, Settings.Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS, true, 20)); + ruleMap.put(DEFAULT_ID_2, new AutomaticZenRule("DEFAULT_2_NAME", null, + null, Settings.Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS, true, 10)); + } + + Map.Entry[] toReturn = new Map.Entry[ruleMap.size()]; + ruleMap.entrySet().toArray(toReturn); + return toReturn; + } + + private Map.Entry[] populateAutoZenRulesDescendingCreationTime( + int numRules, boolean addDefaultRules) { + Map ruleMap = new HashMap<>(); + + for (int i = 0; i < numRules; i++) { + ruleMap.put(GENERIC_RULE_NAME + i, new AutomaticZenRule(GENERIC_RULE_NAME + i, null, + null, Settings.Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS, true, numRules - i)); + } + + if (addDefaultRules) { + ruleMap.put(DEFAULT_ID_1, new AutomaticZenRule("DEFAULT_1_NAME", null, + null, Settings.Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS, true, 10)); + ruleMap.put(DEFAULT_ID_2, new AutomaticZenRule("DEFAULT_2_NAME", null, + null, Settings.Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS, true, 20)); + } + + Map.Entry[] toReturn = new Map.Entry[ruleMap.size()]; + ruleMap.entrySet().toArray(toReturn); + return toReturn; + } +} diff --git a/tests/robotests/src/com/android/settings/notification/ZenModeSettingsFooterPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/notification/ZenModeSettingsFooterPreferenceControllerTest.java index c1634fb597c..ca9f9429228 100644 --- a/tests/robotests/src/com/android/settings/notification/ZenModeSettingsFooterPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/notification/ZenModeSettingsFooterPreferenceControllerTest.java @@ -126,7 +126,7 @@ public class ZenModeSettingsFooterPreferenceControllerTest { } @Test - public void app_manualRule_setFooterTitle() { + public void testDefaultNotifPolicy_app_manualRule_setFooterTitle() { Settings.Global.putInt(mContentResolver, ZEN_MODE, ZEN_MODE_IMPORTANT_INTERRUPTIONS); injectManualRuleFromApp(); mController.updateState(mockPref); @@ -137,7 +137,7 @@ public class ZenModeSettingsFooterPreferenceControllerTest { } @Test - public void time_manualRule_setFooterTitle() { + public void testDefaultNotifPolicy_time_manualRule_setFooterTitle() { Settings.Global.putInt(mContentResolver, ZEN_MODE, ZEN_MODE_IMPORTANT_INTERRUPTIONS); String placeholder = "placeholder"; injectManualRuleWithTimeCountdown(1000, placeholder); @@ -148,7 +148,7 @@ public class ZenModeSettingsFooterPreferenceControllerTest { } @Test - public void forever_manualRule_setFooterTitle() { + public void testDefaultNotifPolicy_forever_manualRule_setFooterTitle() { Settings.Global.putInt(mContentResolver, ZEN_MODE, ZEN_MODE_IMPORTANT_INTERRUPTIONS); injectManualRuleWithIndefiniteEnd(); mController.updateState(mockPref); @@ -158,7 +158,7 @@ public class ZenModeSettingsFooterPreferenceControllerTest { } @Test - public void automaticRule_noManualRule_setFooterTitle() { + public void testDefaultNotifPolicy_automaticRule_noManualRule_setFooterTitle() { Settings.Global.putInt(mContentResolver, ZEN_MODE, ZEN_MODE_IMPORTANT_INTERRUPTIONS); // no manual rule ReflectionHelpers.setField(mZenModeConfig, MANUAL_RULE_FIELD, null); @@ -174,7 +174,7 @@ public class ZenModeSettingsFooterPreferenceControllerTest { } @Test - public void manualRuleEndsLast_hasAutomaticRule_setFooterTitle() { + public void testDefaultNotifPolicy_manualRuleEndsLast_hasAutomaticRule_setFooterTitle() { Settings.Global.putInt(mContentResolver, ZEN_MODE, ZEN_MODE_IMPORTANT_INTERRUPTIONS); // manual rule that ends after automatic rule ends injectManualRuleWithIndefiniteEnd(); @@ -190,7 +190,7 @@ public class ZenModeSettingsFooterPreferenceControllerTest { } @Test - public void automaticRuleEndsLast_hasManualRule_setFooterTitle() { + public void testDefaultNotifPolicy_automaticRuleEndsLast_hasManualRule_setFooterTitle() { Settings.Global.putInt(mContentResolver, ZEN_MODE, ZEN_MODE_IMPORTANT_INTERRUPTIONS); // manual rule that ends before automatic rule ends injectManualRuleWithTimeCountdown(1000, ""); @@ -208,14 +208,15 @@ public class ZenModeSettingsFooterPreferenceControllerTest { } @Test - public void multipleAutomaticRules_appAutoRuleautomaticRuleApp_setFooterTitle() { + public void testDefaultNotifPolicy_multipleAutomaticRules_autoRuleApp_setFooterTitle() { Settings.Global.putInt(mContentResolver, ZEN_MODE, ZEN_MODE_IMPORTANT_INTERRUPTIONS); // automatic rule that ends after manual rule ends ZenRule rule1 = injectNewAutomaticRule(TEST_RULE_NAME + "1", false, false); when(mConfigWrapper.parseAutomaticRuleEndTime(rule1.conditionId)).thenReturn(10000L); - ZenRule rule2 = injectNewAutomaticRule(TEST_RULE_NAME + "2", true, true); + // automatic rule that is an app + injectNewAutomaticRule(TEST_RULE_NAME + "2", true, true); ZenRule rule3 = injectNewAutomaticRule(TEST_RULE_NAME + "3", true, false); when(mConfigWrapper.parseAutomaticRuleEndTime(rule3.conditionId)).thenReturn(9000L); @@ -229,7 +230,7 @@ public class ZenModeSettingsFooterPreferenceControllerTest { } @Test - public void multipleAutomaticRules_setFooterTitle() { + public void testDefaultNotifPolicy_multipleAutomaticRules_setFooterTitle() { Settings.Global.putInt(mContentResolver, ZEN_MODE, ZEN_MODE_IMPORTANT_INTERRUPTIONS); // automatic rule that ends after manual rule ends