Support new conversation DND options

Test: atest
Bug: 137397357
Change-Id: I52420ffdc4b6618e66354a9c1bb99b0296bc4ea4

res/values/arrays.xml

@@ -1175,6 +1175,19 @@
         <item>zen_mode_from_none</item>
     </string-array>
 
+    <string-array name="zen_mode_conversations_entries" translatable="false">
+        <item>@string/zen_mode_from_all_conversations</item>
+        <item>@string/zen_mode_from_important_conversations</item>
+        <item>@string/zen_mode_from_no_conversations</item>
+    </string-array>
+
+    <!-- these values correspond with ZenPolicy.ConversationSenders -->
+    <string-array name="zen_mode_conversations_values" translatable="false">
+        <item>1</item>
+        <item>2</item>
+        <item>3</item>
+    </string-array>
+
     <!--String arrays for notification swipe direction -->
     <string-array name="swipe_direction_titles">
         <item>@string/swipe_direction_rtl</item>

res/values/strings.xml

@@ -8637,6 +8637,9 @@
     </plurals>
 
     <string name="zen_mode_conversations_title">Conversations</string>
+    <string name="zen_mode_from_all_conversations">From all conversations</string>
+    <string name="zen_mode_from_important_conversations">From important conversations</string>
+    <string name="zen_mode_from_no_conversations">Don\u2019t allow any conversations</string>
 
     <!-- [CHAR LIMIT=40] Zen mode settings: Messages option -->
     <string name="zen_mode_messages">Allow messages</string>

res/xml/zen_mode_people_settings.xml

@@ -59,6 +59,13 @@
    <PreferenceCategory
        android:title="@string/zen_mode_conversations_title"
        android:key="zen_mode_settings_category_conversations">
+
+      <!-- Conversations -->
+      <ListPreference
+          android:key="zen_mode_conversations"
+          android:title="@string/zen_mode_conversations_title"
+          android:entries="@array/zen_mode_conversations_entries"
+          android:entryValues="@array/zen_mode_conversations_values"/>
    </PreferenceCategory>
 
    <!-- Footer that shows if user is put into alarms only or total silence mode by an app -->

src/com/android/settings/notification/zen/ZenModeAllBypassingConversationsPreferenceController.java

@@ -1,210 +0,0 @@
-/*
- * Copyright (C) 2020 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.settings.notification.zen;
-
-import android.app.Application;
-import android.app.NotificationChannel;
-import android.app.settings.SettingsEnums;
-import android.content.Context;
-import android.os.Bundle;
-import android.provider.Settings;
-import android.text.TextUtils;
-
-import androidx.annotation.VisibleForTesting;
-import androidx.core.text.BidiFormatter;
-import androidx.fragment.app.Fragment;
-import androidx.preference.Preference;
-import androidx.preference.PreferenceCategory;
-import androidx.preference.PreferenceScreen;
-
-import com.android.settings.R;
-import com.android.settings.applications.AppInfoBase;
-import com.android.settings.core.PreferenceControllerMixin;
-import com.android.settings.core.SubSettingLauncher;
-import com.android.settings.notification.NotificationBackend;
-import com.android.settings.notification.app.ChannelNotificationSettings;
-import com.android.settingslib.applications.ApplicationsState;
-import com.android.settingslib.core.AbstractPreferenceController;
-import com.android.settingslib.widget.apppreference.AppPreference;
-
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * Adds a preference to the PreferenceScreen for each conversation notification channel that can
- * bypass DND.
- */
-public class ZenModeAllBypassingConversationsPreferenceController extends
-        AbstractPreferenceController implements PreferenceControllerMixin {
-
-    private final String KEY = "zen_mode_settings_category_conversations";
-
-    @VisibleForTesting ApplicationsState mApplicationsState;
-    @VisibleForTesting PreferenceCategory mCategory;
-    @VisibleForTesting Context mPrefContext;
-
-    private ApplicationsState.Session mAppSession;
-    private NotificationBackend mNotificationBackend = new NotificationBackend();
-    private Fragment mHostFragment;
-
-    public ZenModeAllBypassingConversationsPreferenceController(Context context, Application app,
-            Fragment host) {
-
-        this(context, app == null ? null : ApplicationsState.getInstance(app), host);
-    }
-
-    private ZenModeAllBypassingConversationsPreferenceController(Context context,
-            ApplicationsState appState, Fragment host) {
-        super(context);
-        mApplicationsState = appState;
-        mHostFragment = host;
-
-        if (mApplicationsState != null && host != null) {
-            mAppSession = mApplicationsState.newSession(mAppSessionCallbacks, host.getLifecycle());
-        }
-    }
-
-    @Override
-    public void displayPreference(PreferenceScreen screen) {
-        mCategory = screen.findPreference(KEY);
-        mPrefContext = screen.getContext();
-        updateNotificationChannelList();
-        super.displayPreference(screen);
-    }
-
-    @Override
-    public boolean isAvailable() {
-        return true;
-    }
-
-    @Override
-    public String getPreferenceKey() {
-        return KEY;
-    }
-
-    /**
-     * Call this method to trigger the notification channels list to refresh.
-     */
-    public void updateNotificationChannelList() {
-        if (mAppSession == null) {
-            return;
-        }
-
-        ApplicationsState.AppFilter filter = ApplicationsState.FILTER_ALL_ENABLED;
-        List<ApplicationsState.AppEntry> apps = mAppSession.rebuild(filter,
-                ApplicationsState.ALPHA_COMPARATOR);
-        if (apps != null) {
-            updateNotificationChannelList(apps);
-        }
-    }
-
-    @VisibleForTesting
-    void updateNotificationChannelList(List<ApplicationsState.AppEntry> apps) {
-        if (mCategory == null || apps == null) {
-            return;
-        }
-
-        List<Preference> channelsBypassingDnd = new ArrayList<>();
-        for (ApplicationsState.AppEntry entry : apps) {
-            String pkg = entry.info.packageName;
-            mApplicationsState.ensureIcon(entry);
-            for (NotificationChannel channel : mNotificationBackend
-                    .getNotificationChannelsBypassingDnd(pkg, entry.info.uid).getList()) {
-                if (TextUtils.isEmpty(channel.getConversationId())) {
-                    // only conversation channels
-                    continue;
-                }
-                Preference pref = new AppPreference(mPrefContext);
-                pref.setKey(pkg + "|" + channel.getId());
-                pref.setTitle(BidiFormatter.getInstance().unicodeWrap(entry.label));
-                // TODO: use badged shortcut icon instead of app icon
-                pref.setIcon(entry.icon);
-                pref.setSummary(BidiFormatter.getInstance().unicodeWrap(channel.getName()));
-
-                pref.setOnPreferenceClickListener(preference -> {
-                    Bundle args = new Bundle();
-                    args.putString(AppInfoBase.ARG_PACKAGE_NAME, entry.info.packageName);
-                    args.putInt(AppInfoBase.ARG_PACKAGE_UID, entry.info.uid);
-                    args.putString(Settings.EXTRA_CHANNEL_ID, channel.getId());
-                    new SubSettingLauncher(mContext)
-                            .setDestination(ChannelNotificationSettings.class.getName())
-                            .setArguments(args)
-                            .setTitleRes(R.string.notification_channel_title)
-                            .setResultListener(mHostFragment, 0)
-                            .setSourceMetricsCategory(
-                                    SettingsEnums.NOTIFICATION_ZEN_MODE_OVERRIDING_APP)
-                            .launch();
-                    return true;
-                });
-                channelsBypassingDnd.add(pref);
-            }
-
-            mCategory.removeAll();
-            if (channelsBypassingDnd.size() > 0) {
-                mCategory.setVisible(true);
-                for (Preference prefToAdd : channelsBypassingDnd) {
-                    mCategory.addPreference(prefToAdd);
-                }
-            } else {
-                mCategory.setVisible(false);
-            }
-        }
-    }
-
-    private final ApplicationsState.Callbacks mAppSessionCallbacks =
-            new ApplicationsState.Callbacks() {
-
-                @Override
-                public void onRunningStateChanged(boolean running) {
-                    updateNotificationChannelList();
-                }
-
-                @Override
-                public void onPackageListChanged() {
-                    updateNotificationChannelList();
-                }
-
-                @Override
-                public void onRebuildComplete(ArrayList<ApplicationsState.AppEntry> apps) {
-                    updateNotificationChannelList(apps);
-                }
-
-                @Override
-                public void onPackageIconChanged() {
-                    updateNotificationChannelList();
-                }
-
-                @Override
-                public void onPackageSizeChanged(String packageName) {
-                    updateNotificationChannelList();
-                }
-
-                @Override
-                public void onAllSizesComputed() { }
-
-                @Override
-                public void onLauncherInfoChanged() {
-                    updateNotificationChannelList();
-                }
-
-                @Override
-                public void onLoadEntriesCompleted() {
-                    // Add shortcut info
-                    updateNotificationChannelList();
-                }
-            };
-}

src/com/android/settings/notification/zen/ZenModeBackend.java

@@ -16,8 +16,12 @@
 
 package com.android.settings.notification.zen;
 
+import static android.app.NotificationManager.Policy.CONVERSATION_SENDERS_ANYONE;
+import static android.app.NotificationManager.Policy.CONVERSATION_SENDERS_IMPORTANT;
+import static android.app.NotificationManager.Policy.PRIORITY_CATEGORY_CONVERSATIONS;
 import static android.app.NotificationManager.Policy.SUPPRESSED_EFFECT_SCREEN_OFF;
 import static android.app.NotificationManager.Policy.SUPPRESSED_EFFECT_SCREEN_ON;
+import static android.service.notification.ZenPolicy.CONVERSATION_SENDERS_NONE;
 
 import android.app.ActivityManager;
 import android.app.AutomaticZenRule;
@@ -147,25 +151,35 @@ public class ZenModeBackend {
         return SOURCE_NONE;
     }
 
+    protected int getPriorityConversationSenders() {
+        if (isPriorityCategoryEnabled(PRIORITY_CATEGORY_CONVERSATIONS)) {
+            return mPolicy.priorityConversationSenders;
+        }
+        return CONVERSATION_SENDERS_NONE;
+    }
+
     protected void saveVisualEffectsPolicy(int category, boolean suppress) {
         Settings.Secure.putInt(mContext.getContentResolver(),
                 Settings.Secure.ZEN_SETTINGS_UPDATED, 1);
 
         int suppressedEffects = getNewSuppressedEffects(suppress, category);
         savePolicy(mPolicy.priorityCategories, mPolicy.priorityCallSenders,
-                mPolicy.priorityMessageSenders, suppressedEffects);
+                mPolicy.priorityMessageSenders, suppressedEffects,
+                mPolicy.priorityConversationSenders);
     }
 
     protected void saveSoundPolicy(int category, boolean allow) {
         int priorityCategories = getNewDefaultPriorityCategories(allow, category);
         savePolicy(priorityCategories, mPolicy.priorityCallSenders,
-                mPolicy.priorityMessageSenders, mPolicy.suppressedVisualEffects);
+                mPolicy.priorityMessageSenders, mPolicy.suppressedVisualEffects,
+                mPolicy.priorityConversationSenders);
     }
 
     protected void savePolicy(int priorityCategories, int priorityCallSenders,
-            int priorityMessageSenders, int suppressedVisualEffects) {
+            int priorityMessageSenders, int suppressedVisualEffects,
+            int priorityConversationSenders) {
         mPolicy = new NotificationManager.Policy(priorityCategories, priorityCallSenders,
-                priorityMessageSenders, suppressedVisualEffects);
+                priorityMessageSenders, suppressedVisualEffects, priorityConversationSenders);
         mNotificationManager.setNotificationPolicy(mPolicy);
     }
 
@@ -210,23 +224,21 @@ public class ZenModeBackend {
         }
 
         savePolicy(getNewDefaultPriorityCategories(allowSenders, category),
-            priorityCallSenders, priorityMessagesSenders, mPolicy.suppressedVisualEffects);
+            priorityCallSenders, priorityMessagesSenders, mPolicy.suppressedVisualEffects,
+                mPolicy.priorityConversationSenders);
 
         if (ZenModeSettingsBase.DEBUG) Log.d(TAG, "onPrefChange allow" +
                 stringCategory + "=" + allowSenders + " allow" + stringCategory + "From="
                 + ZenModeConfig.sourceToString(allowSendersFrom));
     }
 
-    protected String getSendersKey(int category) {
+    protected void saveConversationSenders(int val) {
-        switch (getZenMode()) {
+        final boolean allowSenders = val != CONVERSATION_SENDERS_NONE;
-            case Settings.Global.ZEN_MODE_NO_INTERRUPTIONS:
+
-            case Settings.Global.ZEN_MODE_ALARMS:
+        savePolicy(getNewDefaultPriorityCategories(allowSenders, PRIORITY_CATEGORY_CONVERSATIONS),
-                return getKeyFromSetting(SOURCE_NONE);
+                mPolicy.priorityCallSenders, mPolicy.priorityMessageSenders,
-            default:
+                mPolicy.suppressedVisualEffects, val);
-                int prioritySenders = getPrioritySenders(category);
+
-                return getKeyFromSetting(isPriorityCategoryEnabled(category)
-                        ? prioritySenders : SOURCE_NONE);
-            }
     }
 
     private int getPrioritySenders(int category) {
@@ -240,6 +252,10 @@ public class ZenModeBackend {
             return getPriorityMessageSenders();
         }
 
+        if (category == NotificationManager.Policy.PRIORITY_CATEGORY_CONVERSATIONS) {
+            return getPriorityConversationSenders();
+        }
+
         return categorySenders;
     }
 
@@ -271,11 +287,13 @@ public class ZenModeBackend {
         }
     }
 
-    protected int getAlarmsTotalSilenceCallsMessagesSummary(int category) {
+    protected int getAlarmsTotalSilencePeopleSummary(int category) {
         if (category == NotificationManager.Policy.PRIORITY_CATEGORY_MESSAGES) {
             return R.string.zen_mode_from_none_messages;
         } else if (category == NotificationManager.Policy.PRIORITY_CATEGORY_CALLS){
             return R.string.zen_mode_from_none_calls;
+        } else if (category == NotificationManager.Policy.PRIORITY_CATEGORY_CONVERSATIONS) {
+            return R.string.zen_mode_from_no_conversations;
         }
         return R.string.zen_mode_from_none;
     }
@@ -309,6 +327,21 @@ public class ZenModeBackend {
         }
     }
 
+    protected int getConversationSummary() {
+        int conversationType = getPriorityConversationSenders();
+
+        switch (conversationType) {
+            case NotificationManager.Policy.CONVERSATION_SENDERS_ANYONE:
+                return R.string.zen_mode_from_all_conversations;
+            case NotificationManager.Policy.CONVERSATION_SENDERS_IMPORTANT:
+                return R.string.zen_mode_from_important_conversations;
+            case NotificationManager.Policy.CONVERSATION_SENDERS_NONE:
+                return R.string.zen_mode_from_no_conversations;
+            default:
+                return R.string.zen_mode_from_no_conversations;
+        }
+    }
+
     protected int getContactsCallsSummary(ZenPolicy policy) {
         int peopleType = policy.getPriorityCallSenders();
         switch (peopleType) {
@@ -398,12 +431,21 @@ public class ZenModeBackend {
             messages = ZenPolicy.PEOPLE_TYPE_NONE;
         }
 
+        int conversations;
+        if (mPolicy.allowConversations()) {
+            // unlike the above, no mapping is needed because the values are the same
+            conversations = mPolicy.allowConversationsFrom();
+        } else {
+            conversations = CONVERSATION_SENDERS_NONE;
+        }
+
         return new ZenPolicy.Builder(zenPolicy)
                 .allowAlarms(mPolicy.allowAlarms())
                 .allowCalls(calls)
                 .allowEvents(mPolicy.allowEvents())
                 .allowMedia(mPolicy.allowMedia())
                 .allowMessages(messages)
+                .allowConversations(conversations)
                 .allowReminders(mPolicy.allowReminders())
                 .allowRepeatCallers(mPolicy.allowRepeatCallers())
                 .allowSystem(mPolicy.allowSystem())

src/com/android/settings/notification/zen/ZenModeCallsPreferenceController.java

@@ -56,7 +56,7 @@ public class ZenModeCallsPreferenceController extends
             case Settings.Global.ZEN_MODE_NO_INTERRUPTIONS:
             case Settings.Global.ZEN_MODE_ALARMS:
                 preference.setEnabled(false);
-                preference.setSummary(mBackend.getAlarmsTotalSilenceCallsMessagesSummary(
+                preference.setSummary(mBackend.getAlarmsTotalSilencePeopleSummary(
                         NotificationManager.Policy.PRIORITY_CATEGORY_CALLS));
                 break;
             default:

src/com/android/settings/notification/zen/ZenModeMessagesPreferenceController.java

@@ -55,7 +55,7 @@ public class ZenModeMessagesPreferenceController extends
             case Settings.Global.ZEN_MODE_NO_INTERRUPTIONS:
             case Settings.Global.ZEN_MODE_ALARMS:
                 preference.setEnabled(false);
-                preference.setSummary(mBackend.getAlarmsTotalSilenceCallsMessagesSummary(
+                preference.setSummary(mBackend.getAlarmsTotalSilencePeopleSummary(
                         NotificationManager.Policy.PRIORITY_CATEGORY_MESSAGES));
                 break;
             default:

src/com/android/settings/notification/zen/ZenModePeoplePreferenceController.java

@@ -55,7 +55,7 @@ public class ZenModePeoplePreferenceController extends
             case Settings.Global.ZEN_MODE_NO_INTERRUPTIONS:
             case Settings.Global.ZEN_MODE_ALARMS:
                 preference.setEnabled(false);
-                preference.setSummary(mBackend.getAlarmsTotalSilenceCallsMessagesSummary(
+                preference.setSummary(mBackend.getAlarmsTotalSilencePeopleSummary(
                         NotificationManager.Policy.PRIORITY_CATEGORY_MESSAGES));
                 break;
             default:

src/com/android/settings/notification/zen/ZenModePeopleSettings.java

@@ -65,8 +65,7 @@ public class ZenModePeopleSettings extends ZenModeSettingsBase implements Indexa
         controllers.add(new ZenModeRepeatCallersPreferenceController(context, lifecycle,
                 context.getResources().getInteger(com.android.internal.R.integer
                         .config_zen_repeat_callers_threshold)));
-        controllers.add(
+        controllers.add(new ZenModePriorityConversationsPreferenceController(context, lifecycle));
-                new ZenModeAllBypassingConversationsPreferenceController(context, app, host));
         controllers.add(new ZenModeSettingsFooterPreferenceController(context, lifecycle,
                 fragmentManager));
         return controllers;

src/com/android/settings/notification/zen/ZenModePriorityCallsPreferenceController.java

@@ -80,7 +80,7 @@ public class ZenModePriorityCallsPreferenceController extends AbstractZenModePre
             case Settings.Global.ZEN_MODE_ALARMS:
                 mPreference.setEnabled(false);
                 mPreference.setValue(ZenModeBackend.ZEN_MODE_FROM_NONE);
-                mPreference.setSummary(mBackend.getAlarmsTotalSilenceCallsMessagesSummary(
+                mPreference.setSummary(mBackend.getAlarmsTotalSilencePeopleSummary(
                         NotificationManager.Policy.PRIORITY_CATEGORY_CALLS));
                 break;
             default:

src/com/android/settings/notification/zen/ZenModePriorityConversationsPreferenceController.java

@@ -0,0 +1,104 @@
+/*
+ * Copyright (C) 2020 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.settings.notification.zen;
+
+import static android.service.notification.ZenPolicy.CONVERSATION_SENDERS_ANYONE;
+import static android.service.notification.ZenPolicy.CONVERSATION_SENDERS_IMPORTANT;
+import static android.service.notification.ZenPolicy.CONVERSATION_SENDERS_NONE;
+
+import android.app.NotificationManager;
+import android.content.Context;
+import android.provider.Settings;
+
+import androidx.preference.ListPreference;
+import androidx.preference.Preference;
+import androidx.preference.PreferenceScreen;
+
+import com.android.settings.R;
+import com.android.settingslib.core.lifecycle.Lifecycle;
+
+public class ZenModePriorityConversationsPreferenceController
+        extends AbstractZenModePreferenceController
+        implements Preference.OnPreferenceChangeListener {
+
+    protected static final String KEY = "zen_mode_conversations";
+    private final ZenModeBackend mBackend;
+    private ListPreference mPreference;
+
+    public ZenModePriorityConversationsPreferenceController(Context context, Lifecycle lifecycle) {
+        super(context, KEY, lifecycle);
+        mBackend = ZenModeBackend.getInstance(context);
+    }
+
+    @Override
+    public String getPreferenceKey() {
+        return KEY;
+    }
+
+    @Override
+    public boolean isAvailable() {
+        return true;
+    }
+
+    @Override
+    public void displayPreference(PreferenceScreen screen) {
+        super.displayPreference(screen);
+        mPreference = screen.findPreference(KEY);
+    }
+
+    @Override
+    public void updateState(Preference preference) {
+        super.updateState(preference);
+        updateValue(preference);
+    }
+
+    @Override
+    public boolean onPreferenceChange(Preference preference, Object selectedContactsFrom) {
+        mBackend.saveConversationSenders(Integer.parseInt(selectedContactsFrom.toString()));
+        updateValue(preference);
+        return true;
+    }
+
+    private void updateValue(Preference preference) {
+        mPreference = (ListPreference) preference;
+        switch (getZenMode()) {
+            case Settings.Global.ZEN_MODE_NO_INTERRUPTIONS:
+            case Settings.Global.ZEN_MODE_ALARMS:
+                mPreference.setEnabled(false);
+                mPreference.setValue(String.valueOf(CONVERSATION_SENDERS_NONE));
+                mPreference.setSummary(mBackend.getAlarmsTotalSilencePeopleSummary(
+                        NotificationManager.Policy.PRIORITY_CATEGORY_CONVERSATIONS));
+                break;
+            default:
+                preference.setEnabled(true);
+                preference.setSummary(mBackend.getConversationSummary());
+                int senders = mBackend.getPriorityConversationSenders();
+
+                switch (senders) {
+                    case CONVERSATION_SENDERS_NONE:
+                        mPreference.setValue(String.valueOf(CONVERSATION_SENDERS_NONE));
+                        break;
+                    case CONVERSATION_SENDERS_IMPORTANT:
+                        mPreference.setValue(String.valueOf(CONVERSATION_SENDERS_IMPORTANT));
+                        break;
+                    default:
+                        mPreference.setValue(String.valueOf(CONVERSATION_SENDERS_ANYONE));
+                        break;
+                }
+        }
+    }
+}

src/com/android/settings/notification/zen/ZenModePriorityMessagesPreferenceController.java

@@ -80,7 +80,7 @@ public class ZenModePriorityMessagesPreferenceController extends AbstractZenMode
             case Settings.Global.ZEN_MODE_ALARMS:
                 mPreference.setEnabled(false);
                 mPreference.setValue(ZenModeBackend.ZEN_MODE_FROM_NONE);
-                mPreference.setSummary(mBackend.getAlarmsTotalSilenceCallsMessagesSummary(
+                mPreference.setSummary(mBackend.getAlarmsTotalSilencePeopleSummary(
                         NotificationManager.Policy.PRIORITY_CATEGORY_MESSAGES));
                 break;
             default:

tests/robotests/src/com/android/settings/notification/zen/ZenModeBackendTest.java

@@ -1,25 +1,41 @@
 package com.android.settings.notification.zen;
 
+import static android.app.NotificationManager.Policy.CONVERSATION_SENDERS_ANYONE;
+import static android.app.NotificationManager.Policy.CONVERSATION_SENDERS_IMPORTANT;
+import static android.app.NotificationManager.Policy.CONVERSATION_SENDERS_NONE;
+import static android.app.NotificationManager.Policy.PRIORITY_CATEGORY_ALARMS;
+import static android.app.NotificationManager.Policy.PRIORITY_CATEGORY_CALLS;
+import static android.app.NotificationManager.Policy.PRIORITY_CATEGORY_CONVERSATIONS;
+import static android.app.NotificationManager.Policy.PRIORITY_CATEGORY_MESSAGES;
+import static android.app.NotificationManager.Policy.PRIORITY_SENDERS_ANY;
+import static android.app.NotificationManager.Policy.PRIORITY_SENDERS_CONTACTS;
+import static android.app.NotificationManager.Policy.PRIORITY_SENDERS_STARRED;
+import static android.app.NotificationManager.Policy.SUPPRESSED_EFFECT_AMBIENT;
+
 import static com.google.common.truth.Truth.assertThat;
 
 import static junit.framework.Assert.assertEquals;
 
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.mock;
+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.app.NotificationManager.Policy;
 import android.content.Context;
 import android.database.Cursor;
 import android.provider.Settings;
 import android.service.notification.ZenModeConfig;
 
-import com.android.settings.notification.zen.ZenModeBackend;
+import com.android.settings.R;
 
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 import org.mockito.invocation.InvocationOnMock;
@@ -55,60 +71,6 @@ public class ZenModeBackendTest {
         mBackend = new ZenModeBackend(mContext);
     }
 
-    @Test
-    public void updateState_checkRuleOrderingDescending() {
-        final int NUM_RULES = 4;
-        Map.Entry<String, AutomaticZenRule>[] 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<String, AutomaticZenRule>[] 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<String, AutomaticZenRule>[] 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());
-        }
-    }
-
-    @Test
-    public void updateSummary_nullCursorValues() {
-        Cursor testCursorWithNullValues = createMockCursor(3);
-        when(testCursorWithNullValues.getString(0)).thenReturn(null);
-
-        // expected - no null values
-        List<String> contacts = mBackend.getStarredContacts(testCursorWithNullValues);
-        for (String contact : contacts) {
-            assertThat(contact).isNotNull();
-        }
-    }
-
     private Cursor createMockCursor(int size) {
         Cursor mockCursor = mock(Cursor.class);
         when(mockCursor.moveToFirst()).thenReturn(true);
@@ -173,4 +135,133 @@ public class ZenModeBackendTest {
         ruleMap.entrySet().toArray(toReturn);
         return toReturn;
     }
+
+    @Test
+    public void updateState_checkRuleOrderingDescending() {
+        final int NUM_RULES = 4;
+        Map.Entry<String, AutomaticZenRule>[] 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<String, AutomaticZenRule>[] 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<String, AutomaticZenRule>[] 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());
+        }
+    }
+
+    @Test
+    public void updateSummary_nullCursorValues() {
+        Cursor testCursorWithNullValues = createMockCursor(3);
+        when(testCursorWithNullValues.getString(0)).thenReturn(null);
+
+        // expected - no null values
+        List<String> contacts = mBackend.getStarredContacts(testCursorWithNullValues);
+        for (String contact : contacts) {
+            assertThat(contact).isNotNull();
+        }
+    }
+
+    @Test
+    public void saveConversationSenders_importantToNone() {
+        when(mNotificationManager.getNotificationPolicy()).thenReturn(
+                new Policy(PRIORITY_CATEGORY_CALLS | PRIORITY_CATEGORY_CONVERSATIONS
+                        | PRIORITY_CATEGORY_MESSAGES | PRIORITY_CATEGORY_ALARMS,
+                        PRIORITY_SENDERS_CONTACTS,
+                        PRIORITY_SENDERS_STARRED,
+                        SUPPRESSED_EFFECT_AMBIENT,
+                        CONVERSATION_SENDERS_IMPORTANT));
+        mBackend = new ZenModeBackend(mContext);
+
+        mBackend.saveConversationSenders(CONVERSATION_SENDERS_NONE);
+
+        ArgumentCaptor<Policy> captor = ArgumentCaptor.forClass(Policy.class);
+        verify(mNotificationManager, times(1)).setNotificationPolicy(captor.capture());
+
+        Policy expected = new Policy(
+                PRIORITY_CATEGORY_CALLS | PRIORITY_CATEGORY_MESSAGES | PRIORITY_CATEGORY_ALARMS,
+                PRIORITY_SENDERS_CONTACTS,
+                PRIORITY_SENDERS_STARRED,
+                SUPPRESSED_EFFECT_AMBIENT,
+                CONVERSATION_SENDERS_NONE);
+        assertEquals(expected, captor.getValue());
+    }
+
+    @Test
+    public void saveConversationSenders_noneToAll() {
+        when(mNotificationManager.getNotificationPolicy()).thenReturn(new Policy(
+                PRIORITY_CATEGORY_CALLS | PRIORITY_CATEGORY_MESSAGES | PRIORITY_CATEGORY_ALARMS,
+                PRIORITY_SENDERS_CONTACTS,
+                PRIORITY_SENDERS_STARRED,
+                SUPPRESSED_EFFECT_AMBIENT,
+                CONVERSATION_SENDERS_NONE));
+        mBackend = new ZenModeBackend(mContext);
+
+        mBackend.saveConversationSenders(CONVERSATION_SENDERS_ANYONE);
+
+        ArgumentCaptor<Policy> captor = ArgumentCaptor.forClass(Policy.class);
+        verify(mNotificationManager, times(1)).setNotificationPolicy(captor.capture());
+
+        Policy expected = new Policy(PRIORITY_CATEGORY_CONVERSATIONS
+                | PRIORITY_CATEGORY_CALLS | PRIORITY_CATEGORY_MESSAGES | PRIORITY_CATEGORY_ALARMS,
+                PRIORITY_SENDERS_CONTACTS,
+                PRIORITY_SENDERS_STARRED,
+                SUPPRESSED_EFFECT_AMBIENT,
+                CONVERSATION_SENDERS_ANYONE);
+        assertEquals(expected, captor.getValue());
+    }
+
+    @Test
+    public void saveSenders_doesNotChangeConversations() {
+        when(mNotificationManager.getNotificationPolicy()).thenReturn(
+                new Policy(PRIORITY_CATEGORY_CALLS | PRIORITY_CATEGORY_CONVERSATIONS
+                        | PRIORITY_CATEGORY_MESSAGES | PRIORITY_CATEGORY_ALARMS,
+                        PRIORITY_SENDERS_CONTACTS,
+                        PRIORITY_SENDERS_STARRED,
+                        SUPPRESSED_EFFECT_AMBIENT,
+                        CONVERSATION_SENDERS_ANYONE));
+        mBackend = new ZenModeBackend(mContext);
+
+        mBackend.saveSenders(PRIORITY_CATEGORY_CALLS, PRIORITY_SENDERS_ANY);
+
+        ArgumentCaptor<Policy> captor = ArgumentCaptor.forClass(Policy.class);
+        verify(mNotificationManager, times(1)).setNotificationPolicy(captor.capture());
+
+        Policy expected = new Policy(PRIORITY_CATEGORY_CONVERSATIONS
+                | PRIORITY_CATEGORY_CALLS | PRIORITY_CATEGORY_MESSAGES | PRIORITY_CATEGORY_ALARMS,
+                PRIORITY_SENDERS_ANY,
+                PRIORITY_SENDERS_STARRED,
+                SUPPRESSED_EFFECT_AMBIENT,
+                CONVERSATION_SENDERS_ANYONE);
+        assertEquals(expected, captor.getValue());
+    }
+
 }

tests/robotests/src/com/android/settings/notification/zen/ZenModePriorityCallsPreferenceControllerTest.java

@@ -34,8 +34,6 @@ import androidx.preference.ListPreference;
 import androidx.preference.PreferenceScreen;
 
 import com.android.settings.R;
-import com.android.settings.notification.zen.ZenModeBackend;
-import com.android.settings.notification.zen.ZenModePriorityCallsPreferenceController;
 import com.android.settingslib.core.lifecycle.Lifecycle;
 
 import org.junit.Before;
@@ -88,7 +86,7 @@ public class ZenModePriorityCallsPreferenceControllerTest {
 
         when(mBackend.getPriorityCallSenders())
                 .thenReturn(NotificationManager.Policy.PRIORITY_SENDERS_STARRED);
-        when(mBackend.getAlarmsTotalSilenceCallsMessagesSummary(
+        when(mBackend.getAlarmsTotalSilencePeopleSummary(
                 NotificationManager.Policy.PRIORITY_CATEGORY_CALLS)).thenCallRealMethod();
         when(mBackend.getContactsSummary(NotificationManager.Policy.PRIORITY_CATEGORY_CALLS))
                 .thenCallRealMethod();

tests/robotests/src/com/android/settings/notification/zen/ZenModePriorityConversationsPreferenceControllerTest.java

@@ -0,0 +1,191 @@
+/*
+ * Copyright (C) 2020 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.settings.notification.zen;
+
+import static android.app.NotificationManager.Policy.CONVERSATION_SENDERS_ANYONE;
+import static android.app.NotificationManager.Policy.CONVERSATION_SENDERS_IMPORTANT;
+import static android.app.NotificationManager.Policy.CONVERSATION_SENDERS_NONE;
+import static android.app.NotificationManager.Policy.PRIORITY_CATEGORY_CONVERSATIONS;
+import static android.provider.Settings.Global.ZEN_MODE;
+import static android.provider.Settings.Global.ZEN_MODE_ALARMS;
+import static android.provider.Settings.Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS;
+import static android.provider.Settings.Global.ZEN_MODE_NO_INTERRUPTIONS;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.reset;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import android.app.NotificationManager;
+import android.content.ContentResolver;
+import android.content.Context;
+import android.provider.Settings;
+
+import androidx.preference.ListPreference;
+import androidx.preference.PreferenceScreen;
+
+import com.android.settings.R;
+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.robolectric.RobolectricTestRunner;
+import org.robolectric.RuntimeEnvironment;
+import org.robolectric.shadows.ShadowApplication;
+import org.robolectric.util.ReflectionHelpers;
+
+@RunWith(RobolectricTestRunner.class)
+public class ZenModePriorityConversationsPreferenceControllerTest {
+
+    private ZenModePriorityConversationsPreferenceController mController;
+
+    @Mock
+    private ZenModeBackend mBackend;
+    @Mock
+    private NotificationManager mNotificationManager;
+    @Mock
+    private ListPreference mockPref;
+    @Mock
+    private NotificationManager.Policy mPolicy;
+    @Mock
+    private PreferenceScreen mPreferenceScreen;
+    private ContentResolver mContentResolver;
+    private Context mContext;
+
+    @Before
+    public void setup() {
+        MockitoAnnotations.initMocks(this);
+        ShadowApplication shadowApplication = ShadowApplication.getInstance();
+        shadowApplication.setSystemService(Context.NOTIFICATION_SERVICE, mNotificationManager);
+
+        mContext = RuntimeEnvironment.application;
+        mContentResolver = RuntimeEnvironment.application.getContentResolver();
+        when(mNotificationManager.getNotificationPolicy()).thenReturn(mPolicy);
+
+        when(mBackend.getPriorityConversationSenders())
+            .thenReturn(CONVERSATION_SENDERS_IMPORTANT);
+        when(mBackend.getAlarmsTotalSilencePeopleSummary(PRIORITY_CATEGORY_CONVERSATIONS))
+                .thenCallRealMethod();
+        when(mBackend.getConversationSummary()).thenCallRealMethod();
+
+        mController = new ZenModePriorityConversationsPreferenceController(
+                mContext, mock(Lifecycle.class));
+        ReflectionHelpers.setField(mController, "mBackend", mBackend);
+
+        when(mPreferenceScreen.findPreference(mController.getPreferenceKey())).thenReturn(mockPref);
+        mController.displayPreference(mPreferenceScreen);
+    }
+
+    @Test
+    public void updateState_TotalSilence() {
+        Settings.Global.putInt(mContentResolver, ZEN_MODE, ZEN_MODE_NO_INTERRUPTIONS);
+
+        when(mBackend.isPriorityCategoryEnabled(PRIORITY_CATEGORY_CONVERSATIONS)).thenReturn(true);
+        final ListPreference mockPref = mock(ListPreference.class);
+        mController.updateState(mockPref);
+
+        verify(mockPref).setEnabled(false);
+        verify(mockPref).setSummary(R.string.zen_mode_from_no_conversations);
+    }
+
+    @Test
+    public void updateState_AlarmsOnly() {
+        Settings.Global.putInt(mContentResolver, ZEN_MODE, ZEN_MODE_ALARMS);
+
+        final ListPreference mockPref = mock(ListPreference.class);
+        mController.updateState(mockPref);
+
+        verify(mockPref).setEnabled(false);
+        verify(mockPref).setSummary(R.string.zen_mode_from_no_conversations);
+    }
+
+    @Test
+    public void updateState_Priority_important() {
+        Settings.Global.putInt(mContentResolver, ZEN_MODE, ZEN_MODE_IMPORTANT_INTERRUPTIONS);
+        when(mBackend.isPriorityCategoryEnabled(PRIORITY_CATEGORY_CONVERSATIONS)).thenReturn(true);
+
+        mController.updateState(mockPref);
+
+        verify(mockPref).setEnabled(true);
+        verify(mockPref).setSummary(R.string.zen_mode_from_important_conversations);
+        verify(mockPref).setValue(String.valueOf(CONVERSATION_SENDERS_IMPORTANT));
+    }
+
+    @Test
+    public void updateState_Priority_all() {
+        Settings.Global.putInt(mContentResolver, ZEN_MODE, ZEN_MODE_IMPORTANT_INTERRUPTIONS);
+        when(mBackend.getPriorityConversationSenders()).thenReturn(CONVERSATION_SENDERS_ANYONE);
+        when(mBackend.isPriorityCategoryEnabled(PRIORITY_CATEGORY_CONVERSATIONS)).thenReturn(true);
+
+
+        mController.updateState(mockPref);
+
+        verify(mockPref).setEnabled(true);
+        verify(mockPref).setSummary(R.string.zen_mode_from_all_conversations);
+        verify(mockPref).setValue(String.valueOf(CONVERSATION_SENDERS_ANYONE));
+    }
+
+    @Test
+    public void updateState_Priority_none() {
+        Settings.Global.putInt(mContentResolver, ZEN_MODE, ZEN_MODE_IMPORTANT_INTERRUPTIONS);
+        when(mBackend.getPriorityConversationSenders()).thenReturn(CONVERSATION_SENDERS_NONE);
+        when(mBackend.isPriorityCategoryEnabled(PRIORITY_CATEGORY_CONVERSATIONS)).thenReturn(false);
+
+        mController.updateState(mockPref);
+
+        verify(mockPref).setEnabled(true);
+        verify(mockPref).setSummary(R.string.zen_mode_from_no_conversations);
+        verify(mockPref).setValue(String.valueOf(CONVERSATION_SENDERS_NONE));
+    }
+
+    @Test
+    public void onPreferenceChange_noneToImportant() {
+        // start with none
+
+        Settings.Global.putInt(mContentResolver, ZEN_MODE, ZEN_MODE_IMPORTANT_INTERRUPTIONS);
+        when(mBackend.getPriorityConversationSenders()).thenReturn(CONVERSATION_SENDERS_NONE);
+        when(mBackend.isPriorityCategoryEnabled(PRIORITY_CATEGORY_CONVERSATIONS)).thenReturn(false);
+
+        mController.updateState(mockPref);
+        reset(mBackend);
+
+        mController.onPreferenceChange(mockPref, String.valueOf(CONVERSATION_SENDERS_IMPORTANT));
+
+        verify(mBackend).saveConversationSenders(CONVERSATION_SENDERS_IMPORTANT);
+        verify(mBackend).getPriorityConversationSenders();
+    }
+
+    @Test
+    public void onPreferenceChange_allToNone() {
+        // start with none
+
+        Settings.Global.putInt(mContentResolver, ZEN_MODE, ZEN_MODE_IMPORTANT_INTERRUPTIONS);
+        when(mBackend.getPriorityConversationSenders()).thenReturn(CONVERSATION_SENDERS_ANYONE);
+        when(mBackend.isPriorityCategoryEnabled(PRIORITY_CATEGORY_CONVERSATIONS)).thenReturn(true);
+
+        mController.updateState(mockPref);
+        reset(mBackend);
+
+        mController.onPreferenceChange(mockPref, String.valueOf(CONVERSATION_SENDERS_NONE));
+
+        verify(mBackend).saveConversationSenders(CONVERSATION_SENDERS_NONE);
+        verify(mBackend).getPriorityConversationSenders();
+    }
+}

tests/robotests/src/com/android/settings/notification/zen/ZenModePriorityMessagesPreferenceControllerTest.java

@@ -34,8 +34,6 @@ import androidx.preference.ListPreference;
 import androidx.preference.PreferenceScreen;
 
 import com.android.settings.R;
-import com.android.settings.notification.zen.ZenModeBackend;
-import com.android.settings.notification.zen.ZenModePriorityMessagesPreferenceController;
 import com.android.settingslib.core.lifecycle.Lifecycle;
 
 import org.junit.Before;
@@ -88,7 +86,7 @@ public class ZenModePriorityMessagesPreferenceControllerTest {
 
         when(mBackend.getPriorityMessageSenders())
             .thenReturn(NotificationManager.Policy.PRIORITY_SENDERS_STARRED);
-        when(mBackend.getAlarmsTotalSilenceCallsMessagesSummary(
+        when(mBackend.getAlarmsTotalSilencePeopleSummary(
                 NotificationManager.Policy.PRIORITY_CATEGORY_MESSAGES)).thenCallRealMethod();
         when(mBackend.getContactsSummary(NotificationManager.Policy.PRIORITY_CATEGORY_MESSAGES))
                 .thenCallRealMethod();