Fix Messages onClick.

The state of the preference doesn't change until after we get the
callback.

Test: ZenModePrioritySendersPreferenceControllerTest
Flag: android.app.modes_ui
Fixes: 337079247
Change-Id: I1c98561de89e9398f26300bb14710f18991f78f4

src/com/android/settings/notification/modes/ZenModePrioritySendersPreferenceController.java

@@ -72,7 +72,7 @@ class ZenModePrioritySendersPreferenceController
     static final String KEY_IMPORTANT = "conversations_important";
     static final String KEY_NONE = "senders_none";
 
-    private int mNumImportantConversations = CONVERSATION_SENDERS_UNSET;
+    private int mNumImportantConversations = 0;
 
     private static final Intent ALL_CONTACTS_INTENT =
             new Intent(Contacts.Intents.UI.LIST_DEFAULT)
@@ -230,6 +230,7 @@ class ZenModePrioritySendersPreferenceController
                     && ALL_CONTACTS_INTENT.resolveActivity(mPackageManager) != null) {
                 mContext.startActivity(ALL_CONTACTS_INTENT);
             } else if (KEY_IMPORTANT.equals(key)) {
+                // TODO: b/332937635 - set correct metrics category
                 new SubSettingLauncher(mContext)
                         .setDestination(ConversationListSettings.class.getName())
                         .setSourceMetricsCategory(SettingsEnums.DND_CONVERSATIONS)
@@ -315,7 +316,6 @@ class ZenModePrioritySendersPreferenceController
                 }
             }
         }
-
         // Error case check: if somehow, after all of that, endState is still
         // {PEOPLE_TYPE_UNSET, CONVERSATION_SENDERS_UNSET}, something has gone wrong.
         if (endState[0] == PEOPLE_TYPE_UNSET && endState[1] == CONVERSATION_SENDERS_UNSET) {
@@ -343,17 +343,15 @@ class ZenModePrioritySendersPreferenceController
     //     the contacts setting is additionally reset to "none".
     //   - if "anyone" is previously selected, and the user clicks one of the contacts values,
     //     then the conversations setting is additionally reset to "none".
-    int[] settingsToSaveOnClick(SelectorWithWidgetPreference preference,
+    int[] settingsToSaveOnClick(String key, boolean checked,
             int currSendersSetting, int currConvosSetting) {
         int[] savedSettings = new int[]{ PEOPLE_TYPE_UNSET, CONVERSATION_SENDERS_UNSET };
 
         // If the preference isn't a checkbox, always consider this to be "checking" the setting.
         // Otherwise, toggle.
-        final int[] endState = keyToSettingEndState(preference.getKey(),
+        final int[] endState = keyToSettingEndState(key, checked);
-                preference.isCheckBox() ? preference.isChecked() : true);
         final int prioritySendersSetting = endState[0];
         final int priorityConvosSetting = endState[1];
-
         if (prioritySendersSetting != PEOPLE_TYPE_UNSET
                 && prioritySendersSetting != currSendersSetting) {
             savedSettings[0] = prioritySendersSetting;
@@ -370,14 +368,14 @@ class ZenModePrioritySendersPreferenceController
             // Special-case handling for the "priority conversations" checkbox:
             // If a specific selection exists for priority senders (starred, contacts), we leave
             // it untouched. Otherwise (when the senders is set to "any"), set it to NONE.
-            if (preference.getKey() == KEY_IMPORTANT
+            if (key.equals(KEY_IMPORTANT)
                     && currSendersSetting == PEOPLE_TYPE_ANYONE) {
                 savedSettings[0] = PEOPLE_TYPE_NONE;
             }
 
             // Flip-side special case for clicking either "contacts" option: if a specific selection
             // exists for priority conversations, leave it untouched; otherwise, set to none.
-            if ((preference.getKey() == KEY_STARRED || preference.getKey() == KEY_CONTACTS)
+            if ((key.equals(KEY_STARRED) || key.equals(KEY_CONTACTS))
                     && currConvosSetting == CONVERSATION_SENDERS_ANYONE) {
                 savedSettings[1] = CONVERSATION_SENDERS_NONE;
             }
@@ -426,10 +424,9 @@ class ZenModePrioritySendersPreferenceController
                 public void onRadioButtonClicked(SelectorWithWidgetPreference preference) {
                     savePolicy(policy -> {
                         ZenPolicy previousPolicy = policy.build();
-                        // The settingsToSaveOnClick function takes whether the preference is a
+                        final int[] settingsToSave = settingsToSaveOnClick(
-                        // checkbox into account to determine whether this selection is checked or
+                                preference.getKey(),
-                        // unchecked.
+                                preference.isCheckBox() ? !preference.isChecked() : true,
-                        final int[] settingsToSave = settingsToSaveOnClick(preference,
                                 getPrioritySenders(previousPolicy),
                                 getPriorityConversationSenders(previousPolicy));
                         final int prioritySendersSetting = settingsToSave[0];

tests/robotests/src/com/android/settings/notification/modes/ZenModePrioritySendersPreferenceControllerTest.java

@@ -26,39 +26,41 @@ import static android.service.notification.ZenPolicy.PEOPLE_TYPE_CONTACTS;
 import static android.service.notification.ZenPolicy.PEOPLE_TYPE_NONE;
 import static android.service.notification.ZenPolicy.PEOPLE_TYPE_STARRED;
 import static android.service.notification.ZenPolicy.PEOPLE_TYPE_UNSET;
-import static android.service.notification.ZenPolicy.STATE_ALLOW;
-import static android.service.notification.ZenPolicy.STATE_DISALLOW;
 import static android.service.notification.ZenPolicy.STATE_UNSET;
+
 import static com.android.settings.notification.modes.ZenModePrioritySendersPreferenceController.KEY_ANY;
 import static com.android.settings.notification.modes.ZenModePrioritySendersPreferenceController.KEY_CONTACTS;
 import static com.android.settings.notification.modes.ZenModePrioritySendersPreferenceController.KEY_IMPORTANT;
 import static com.android.settings.notification.modes.ZenModePrioritySendersPreferenceController.KEY_NONE;
 import static com.android.settings.notification.modes.ZenModePrioritySendersPreferenceController.KEY_STARRED;
+
 import static com.google.common.truth.Truth.assertThat;
-import static org.junit.Assert.assertTrue;
+
-import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
-import static org.mockito.ArgumentMatchers.argThat;
-import static org.mockito.Mockito.never;
-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.Flags;
 import android.content.Context;
+import android.database.Cursor;
 import android.net.Uri;
 import android.platform.test.annotations.EnableFlags;
 import android.platform.test.flag.junit.SetFlagsRule;
 import android.service.notification.ZenPolicy;
+
+import androidx.preference.Preference;
 import androidx.preference.PreferenceCategory;
+import androidx.preference.PreferenceManager;
 import androidx.preference.PreferenceScreen;
+
 import com.android.settingslib.widget.SelectorWithWidgetPreference;
+
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.ArgumentCaptor;
-import org.mockito.ArgumentMatcher;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 import org.robolectric.RobolectricTestRunner;
@@ -78,9 +80,8 @@ public final class ZenModePrioritySendersPreferenceControllerTest {
     @Mock
     private ZenModesBackend mBackend;
 
-    @Mock
+    private PreferenceCategory mMessagesPrefCategory, mCallsPrefCategory;
-    private PreferenceCategory mMockMessagesPrefCategory, mMockCallsPrefCategory;
+
-    @Mock
     private PreferenceScreen mPreferenceScreen;
 
     @Before
@@ -93,12 +94,19 @@ public final class ZenModePrioritySendersPreferenceControllerTest {
                 mContext, "messages", true, mBackend);
         mCallsController = new ZenModePrioritySendersPreferenceController(
                 mContext, "calls", false, mBackend);
-        when(mMockMessagesPrefCategory.getContext()).thenReturn(mContext);
+        mMessagesPrefCategory = new PreferenceCategory(mContext);
-        when(mMockCallsPrefCategory.getContext()).thenReturn(mContext);
+        mMessagesPrefCategory.setKey(mMessagesController.getPreferenceKey());
-        when(mPreferenceScreen.findPreference(mMessagesController.getPreferenceKey()))
+        mCallsPrefCategory = new PreferenceCategory(mContext);
-                .thenReturn(mMockMessagesPrefCategory);
+        mCallsPrefCategory.setKey(mCallsController.getPreferenceKey());
-        when(mPreferenceScreen.findPreference(mCallsController.getPreferenceKey()))
+
-                .thenReturn(mMockCallsPrefCategory);
+        PreferenceManager preferenceManager = new PreferenceManager(mContext);
+        mPreferenceScreen = preferenceManager.createPreferenceScreen(mContext);
+        mPreferenceScreen.addPreference(mCallsPrefCategory);
+        mPreferenceScreen.addPreference(mMessagesPrefCategory);
+
+        Cursor cursor = mock(Cursor.class);
+        when(cursor.getCount()).thenReturn(1);
+        when(mBackend.queryAllContactsData()).thenReturn(cursor);
     }
 
     // Makes a preference with the provided key and whether it's a checkbox with
@@ -114,61 +122,34 @@ public final class ZenModePrioritySendersPreferenceControllerTest {
         return pref;
     }
 
-    // Extension of ArgumentMatcher to check that a preference argument has the correct preference
-    // key, but doesn't check any other properties.
-    private class PrefKeyMatcher implements ArgumentMatcher<SelectorWithWidgetPreference> {
-        private String mKey;
-        PrefKeyMatcher(String key) {
-            mKey = key;
-        }
-
-        public boolean matches(SelectorWithWidgetPreference pref) {
-            return pref.getKey() != null && pref.getKey().equals(mKey);
-        }
-
-        public String toString() {
-            return "SelectorWithWidgetPreference matcher for key " + mKey;
-        }
-    }
-
     @Test
     public void testDisplayPreferences_makeMessagesPrefs() {
-        ArgumentCaptor<SelectorWithWidgetPreference> prefCaptor =
-                ArgumentCaptor.forClass(SelectorWithWidgetPreference.class);
-        when(mMockMessagesPrefCategory.getPreferenceCount()).thenReturn(0);  // not yet created
         mMessagesController.displayPreference(mPreferenceScreen);
 
         // Starred contacts, Contacts, Priority Conversations, Any, None
-        verify(mMockMessagesPrefCategory, times(5)).addPreference(prefCaptor.capture());
+        assertThat(mMessagesPrefCategory.getPreferenceCount()).isEqualTo(5);
     }
 
     @Test
     public void testDisplayPreferences_makeCallsPrefs() {
-        ArgumentCaptor<SelectorWithWidgetPreference> prefCaptor =
-                ArgumentCaptor.forClass(SelectorWithWidgetPreference.class);
-        when(mMockCallsPrefCategory.getPreferenceCount()).thenReturn(0);  // not yet created
         mCallsController.displayPreference(mPreferenceScreen);
 
-        // Starred contacts, Contacts, Any, None
+        assertThat(mCallsPrefCategory.getPreferenceCount()).isEqualTo(4);
-        verify(mMockCallsPrefCategory, times(4)).addPreference(prefCaptor.capture());
+        assertThat((Comparable<?>) mCallsPrefCategory.findPreference(KEY_IMPORTANT)).isNull();
 
-        // Make sure we never have the conversation one
-        verify(mMockCallsPrefCategory, never())
-                .addPreference(argThat(new PrefKeyMatcher(KEY_IMPORTANT)));
     }
 
     @Test
     public void testDisplayPreferences_createdOnlyOnce() {
         // Return a nonzero number of child preference when asked.
         // Then when displayPreference is called, it should never make any new preferences.
-        when(mMockCallsPrefCategory.getPreferenceCount()).thenReturn(4); // already created
+        mCallsPrefCategory.addPreference(new Preference(mContext));
         mCallsController.displayPreference(mPreferenceScreen);
         mCallsController.displayPreference(mPreferenceScreen);
         mCallsController.displayPreference(mPreferenceScreen);
 
         // Even though we called display 3 times we shouldn't add more preferences here.
-        verify(mMockCallsPrefCategory, never())
+        assertThat(mCallsPrefCategory.getPreferenceCount()).isEqualTo(1);
-                .addPreference(any(SelectorWithWidgetPreference.class));
     }
 
     @Test
@@ -281,44 +262,34 @@ public final class ZenModePrioritySendersPreferenceControllerTest {
 
     @Test
     public void testSettingsToSaveOnClick_messagesCheck() {
-        SelectorWithWidgetPreference anyPref = makePreference(KEY_ANY, true, true);
-        SelectorWithWidgetPreference nonePref = makePreference(KEY_NONE, true, true);
-        SelectorWithWidgetPreference contactsPref = makePreference(KEY_CONTACTS, true, true);
-        SelectorWithWidgetPreference starredPref = makePreference(KEY_STARRED, true, true);
-        SelectorWithWidgetPreference impPref = makePreference(KEY_IMPORTANT, true, true);
         int[] endState;
 
         // For KEY_NONE everything should be none.
-        nonePref.setChecked(true);
         endState = mMessagesController.settingsToSaveOnClick(
-                nonePref, PEOPLE_TYPE_ANYONE, CONVERSATION_SENDERS_ANYONE);
+                KEY_NONE, true, PEOPLE_TYPE_ANYONE, CONVERSATION_SENDERS_ANYONE);
         assertThat(endState[0]).isEqualTo(PEOPLE_TYPE_NONE);
         assertThat(endState[1]).isEqualTo(CONVERSATION_SENDERS_NONE);
 
         // For KEY_ANY everything should be allowed.
-        anyPref.setChecked(true);
         endState = mMessagesController.settingsToSaveOnClick(
-                anyPref, PEOPLE_TYPE_NONE, CONVERSATION_SENDERS_NONE);
+                KEY_ANY, true, PEOPLE_TYPE_NONE, CONVERSATION_SENDERS_NONE);
         assertThat(endState[0]).isEqualTo(PEOPLE_TYPE_ANYONE);
         assertThat(endState[1]).isEqualTo(CONVERSATION_SENDERS_ANYONE);
 
         // For [starred] contacts, we should set the priority senders, but not the conversations
-        starredPref.setChecked(true);
         endState =  mMessagesController.settingsToSaveOnClick(
-                starredPref, PEOPLE_TYPE_NONE, CONVERSATION_SENDERS_NONE);
+                KEY_STARRED, true, PEOPLE_TYPE_NONE, CONVERSATION_SENDERS_NONE);
         assertThat(endState[0]).isEqualTo(PEOPLE_TYPE_STARRED);
         assertThat(endState[1]).isEqualTo(CONVERSATION_SENDERS_UNSET);
 
-        contactsPref.setChecked(true);
         endState = mMessagesController.settingsToSaveOnClick(
-                contactsPref, PEOPLE_TYPE_NONE, CONVERSATION_SENDERS_NONE);
+                KEY_CONTACTS, true, PEOPLE_TYPE_NONE, CONVERSATION_SENDERS_NONE);
         assertThat(endState[0]).isEqualTo(PEOPLE_TYPE_CONTACTS);
         assertThat(endState[1]).isEqualTo(CONVERSATION_SENDERS_UNSET);
 
         // For priority conversations, we should set the conversations but not priority senders
-        impPref.setChecked(true);
         endState = mMessagesController.settingsToSaveOnClick(
-                impPref, PEOPLE_TYPE_NONE, CONVERSATION_SENDERS_NONE);
+                KEY_IMPORTANT, true, PEOPLE_TYPE_NONE, CONVERSATION_SENDERS_NONE);
         assertThat(endState[0]).isEqualTo(PEOPLE_TYPE_UNSET);
         assertThat(endState[1]).isEqualTo(CONVERSATION_SENDERS_IMPORTANT);
     }
@@ -327,43 +298,32 @@ public final class ZenModePrioritySendersPreferenceControllerTest {
     public void testSettingsToSaveOnClick_messagesUncheck() {
         int[] endState;
 
-        SelectorWithWidgetPreference anyPref = makePreference(KEY_ANY, true, true);
-        SelectorWithWidgetPreference nonePref = makePreference(KEY_NONE, true, true);
-        SelectorWithWidgetPreference contactsPref = makePreference(KEY_CONTACTS, true, true);
-        SelectorWithWidgetPreference starredPref = makePreference(KEY_STARRED, true, true);
-        SelectorWithWidgetPreference impPref = makePreference(KEY_IMPORTANT, true, true);
-
         // For KEY_NONE, "unchecking" still means "none".
-        nonePref.setChecked(false);
         endState = mMessagesController.settingsToSaveOnClick(
-                nonePref, PEOPLE_TYPE_NONE, CONVERSATION_SENDERS_NONE);
+                KEY_NONE, false, PEOPLE_TYPE_NONE, CONVERSATION_SENDERS_NONE);
         assertThat(endState[0]).isEqualTo(PEOPLE_TYPE_UNSET);
         assertThat(endState[1]).isEqualTo(CONVERSATION_SENDERS_UNSET);
 
         // For KEY_ANY unchecking resets the state to "none".
-        anyPref.setChecked(false);
         endState = mMessagesController.settingsToSaveOnClick(
-                anyPref, PEOPLE_TYPE_ANYONE, CONVERSATION_SENDERS_ANYONE);
+                KEY_ANY, false, PEOPLE_TYPE_ANYONE, CONVERSATION_SENDERS_ANYONE);
         assertThat(endState[0]).isEqualTo(PEOPLE_TYPE_NONE);
         assertThat(endState[1]).isEqualTo(CONVERSATION_SENDERS_NONE);
 
         // For [starred] contacts, we should unset the priority senders, but not the conversations
-        starredPref.setChecked(false);
         endState = mMessagesController.settingsToSaveOnClick(
-                starredPref, PEOPLE_TYPE_STARRED, CONVERSATION_SENDERS_IMPORTANT);
+                KEY_STARRED, false, PEOPLE_TYPE_STARRED, CONVERSATION_SENDERS_IMPORTANT);
         assertThat(endState[0]).isEqualTo(PEOPLE_TYPE_NONE);
         assertThat(endState[1]).isEqualTo(CONVERSATION_SENDERS_UNSET);
 
-        contactsPref.setChecked(false);
         endState = mMessagesController.settingsToSaveOnClick(
-                contactsPref, PEOPLE_TYPE_CONTACTS, CONVERSATION_SENDERS_IMPORTANT);
+                KEY_CONTACTS, false, PEOPLE_TYPE_CONTACTS, CONVERSATION_SENDERS_IMPORTANT);
         assertThat(endState[0]).isEqualTo(PEOPLE_TYPE_NONE);
         assertThat(endState[1]).isEqualTo(CONVERSATION_SENDERS_UNSET);
 
         // For priority conversations, we should set the conversations but not priority senders
-        impPref.setChecked(false);
         endState = mMessagesController.settingsToSaveOnClick(
-                impPref, PEOPLE_TYPE_CONTACTS, CONVERSATION_SENDERS_IMPORTANT);
+                KEY_IMPORTANT, false, PEOPLE_TYPE_CONTACTS, CONVERSATION_SENDERS_IMPORTANT);
         assertThat(endState[0]).isEqualTo(PEOPLE_TYPE_UNSET);
         assertThat(endState[1]).isEqualTo(CONVERSATION_SENDERS_NONE);
     }
@@ -371,36 +331,28 @@ public final class ZenModePrioritySendersPreferenceControllerTest {
     @Test
     public void testSettingsToSaveOnClick_callsCheck() {
         int[] endState;
-        SelectorWithWidgetPreference anyPref = makePreference(KEY_ANY, true, true);
-        SelectorWithWidgetPreference nonePref = makePreference(KEY_NONE, true, true);
-        SelectorWithWidgetPreference contactsPref = makePreference(KEY_CONTACTS, true, true);
-        SelectorWithWidgetPreference starredPref = makePreference(KEY_STARRED, true, true);
 
         // For calls: we should never set conversations, as this is unrelated to calls.
         // For KEY_NONE senders should be none.
-        nonePref.setChecked(true);
         endState = mCallsController.settingsToSaveOnClick(
-                nonePref, PEOPLE_TYPE_CONTACTS, CONVERSATION_SENDERS_IMPORTANT);
+                KEY_NONE, true, PEOPLE_TYPE_CONTACTS, CONVERSATION_SENDERS_IMPORTANT);
         assertThat(endState[0]).isEqualTo(PEOPLE_TYPE_NONE);
         assertThat(endState[1]).isEqualTo(CONVERSATION_SENDERS_UNSET);
 
         // For KEY_ANY senders should be ANY.
-        anyPref.setChecked(true);
         endState = mCallsController.settingsToSaveOnClick(
-                anyPref, PEOPLE_TYPE_CONTACTS, CONVERSATION_SENDERS_IMPORTANT);
+                KEY_ANY, true, PEOPLE_TYPE_CONTACTS, CONVERSATION_SENDERS_IMPORTANT);
         assertThat(endState[0]).isEqualTo(PEOPLE_TYPE_ANYONE);
         assertThat(endState[1]).isEqualTo(CONVERSATION_SENDERS_UNSET);
 
         // For [starred] contacts, we should set the priority senders accordingly
-        starredPref.setChecked(true);
         endState = mCallsController.settingsToSaveOnClick(
-                starredPref, PEOPLE_TYPE_CONTACTS, CONVERSATION_SENDERS_IMPORTANT);
+                KEY_STARRED, true, PEOPLE_TYPE_CONTACTS, CONVERSATION_SENDERS_IMPORTANT);
         assertThat(endState[0]).isEqualTo(PEOPLE_TYPE_STARRED);
         assertThat(endState[1]).isEqualTo(CONVERSATION_SENDERS_UNSET);
 
-        contactsPref.setChecked(true);
         endState = mCallsController.settingsToSaveOnClick(
-                contactsPref, PEOPLE_TYPE_STARRED, CONVERSATION_SENDERS_IMPORTANT);
+                KEY_CONTACTS, true, PEOPLE_TYPE_STARRED, CONVERSATION_SENDERS_IMPORTANT);
         assertThat(endState[0]).isEqualTo(PEOPLE_TYPE_CONTACTS);
         assertThat(endState[1]).isEqualTo(CONVERSATION_SENDERS_UNSET);
     }
@@ -408,36 +360,28 @@ public final class ZenModePrioritySendersPreferenceControllerTest {
     @Test
     public void testSettingsToSaveOnClick_callsUncheck() {
         int[] endState;
-        SelectorWithWidgetPreference anyPref = makePreference(KEY_ANY, true, true);
-        SelectorWithWidgetPreference nonePref = makePreference(KEY_NONE, true, true);
-        SelectorWithWidgetPreference contactsPref = makePreference(KEY_CONTACTS, true, true);
-        SelectorWithWidgetPreference starredPref = makePreference(KEY_STARRED, true, true);
 
         // A calls setup should never set conversations settings.
         // For KEY_NONE, "unchecking" still means "none".
-        nonePref.setChecked(false);
         endState = mCallsController.settingsToSaveOnClick(
-                nonePref, PEOPLE_TYPE_NONE, CONVERSATION_SENDERS_NONE);
+                KEY_NONE, false, PEOPLE_TYPE_NONE, CONVERSATION_SENDERS_NONE);
         assertThat(endState[0]).isEqualTo(STATE_UNSET);
         assertThat(endState[1]).isEqualTo(CONVERSATION_SENDERS_UNSET);
 
         // For KEY_ANY unchecking resets the state to "none".
-        anyPref.setChecked(false);
         endState = mCallsController.settingsToSaveOnClick(
-                anyPref, PEOPLE_TYPE_ANYONE, CONVERSATION_SENDERS_ANYONE);
+                KEY_ANY, false, PEOPLE_TYPE_ANYONE, CONVERSATION_SENDERS_ANYONE);
         assertThat(endState[0]).isEqualTo(PEOPLE_TYPE_NONE);
         assertThat(endState[1]).isEqualTo(CONVERSATION_SENDERS_UNSET);
 
         // For [starred] contacts, we should unset the priority senders, but not the conversations
-        starredPref.setChecked(false);
         endState = mCallsController.settingsToSaveOnClick(
-                starredPref, PEOPLE_TYPE_STARRED, CONVERSATION_SENDERS_IMPORTANT);
+                KEY_STARRED, false, PEOPLE_TYPE_STARRED, CONVERSATION_SENDERS_IMPORTANT);
         assertThat(endState[0]).isEqualTo(PEOPLE_TYPE_NONE);
         assertThat(endState[1]).isEqualTo(CONVERSATION_SENDERS_UNSET);
 
-        contactsPref.setChecked(false);
         endState = mCallsController.settingsToSaveOnClick(
-                contactsPref, PEOPLE_TYPE_CONTACTS, CONVERSATION_SENDERS_IMPORTANT);
+                KEY_CONTACTS, false, PEOPLE_TYPE_CONTACTS, CONVERSATION_SENDERS_IMPORTANT);
         assertThat(endState[0]).isEqualTo(PEOPLE_TYPE_NONE);
         assertThat(endState[1]).isEqualTo(CONVERSATION_SENDERS_UNSET);
     }
@@ -446,64 +390,150 @@ public final class ZenModePrioritySendersPreferenceControllerTest {
     public void testSettingsToSave_messages_noChange() {
         int[] savedSettings;
 
-        SelectorWithWidgetPreference nonePref = makePreference(KEY_NONE, true, true);
-        nonePref.setChecked(true);
         savedSettings = mMessagesController.settingsToSaveOnClick(
-                nonePref, PEOPLE_TYPE_NONE, CONVERSATION_SENDERS_NONE);
+                KEY_NONE, true, PEOPLE_TYPE_NONE, CONVERSATION_SENDERS_NONE);
         assertThat(savedSettings[0]).isEqualTo(STATE_UNSET);
         assertThat(savedSettings[1]).isEqualTo(STATE_UNSET);
 
-        SelectorWithWidgetPreference anyPref = makePreference(KEY_ANY, true, true);
-        anyPref.setChecked(true);
         savedSettings = mMessagesController.settingsToSaveOnClick(
-                anyPref, PEOPLE_TYPE_ANYONE, CONVERSATION_SENDERS_ANYONE);
+                KEY_ANY, true, PEOPLE_TYPE_ANYONE, CONVERSATION_SENDERS_ANYONE);
         assertThat(savedSettings[0]).isEqualTo(STATE_UNSET);
         assertThat(savedSettings[1]).isEqualTo(STATE_UNSET);
 
-        SelectorWithWidgetPreference starredPref = makePreference(KEY_STARRED, true, true);
-        SelectorWithWidgetPreference contactsPref = makePreference(KEY_CONTACTS, true, true);
-        starredPref.setChecked(true);
         savedSettings = mMessagesController.settingsToSaveOnClick(
-                starredPref, PEOPLE_TYPE_STARRED, CONVERSATION_SENDERS_ANYONE);
+                KEY_STARRED, true, PEOPLE_TYPE_STARRED, CONVERSATION_SENDERS_ANYONE);
         assertThat(savedSettings[0]).isEqualTo(STATE_UNSET);
 
-        contactsPref.setChecked(true);
         savedSettings = mMessagesController.settingsToSaveOnClick(
-                contactsPref, PEOPLE_TYPE_CONTACTS, CONVERSATION_SENDERS_ANYONE);
+                KEY_CONTACTS, true, PEOPLE_TYPE_CONTACTS, CONVERSATION_SENDERS_ANYONE);
         assertThat(savedSettings[0]).isEqualTo(STATE_UNSET);
 
-        SelectorWithWidgetPreference impPref = makePreference(KEY_IMPORTANT, true, true);
-        impPref.setChecked(true);
         savedSettings = mMessagesController.settingsToSaveOnClick(
-                impPref, PEOPLE_TYPE_CONTACTS, CONVERSATION_SENDERS_IMPORTANT);
+                KEY_IMPORTANT, true, PEOPLE_TYPE_CONTACTS, CONVERSATION_SENDERS_IMPORTANT);
         assertThat(savedSettings[1]).isEqualTo(STATE_UNSET);
     }
 
     @Test
     public void testSettingsToSave_calls_noChange() {
         int[] savedSettings;
-        SelectorWithWidgetPreference nonePref = makePreference(KEY_NONE, false, false);
 
         savedSettings = mMessagesController.settingsToSaveOnClick(
-                nonePref, PEOPLE_TYPE_NONE, CONVERSATION_SENDERS_NONE);
+                KEY_NONE, true, PEOPLE_TYPE_NONE, CONVERSATION_SENDERS_NONE);
         assertThat(savedSettings[0]).isEqualTo(STATE_UNSET);
         assertThat(savedSettings[1]).isEqualTo(STATE_UNSET);
 
-        SelectorWithWidgetPreference anyPref = makePreference(KEY_ANY, false, false);
-
         savedSettings = mMessagesController.settingsToSaveOnClick(
-                anyPref, PEOPLE_TYPE_ANYONE, CONVERSATION_SENDERS_ANYONE);
+                KEY_ANY, true, PEOPLE_TYPE_ANYONE, CONVERSATION_SENDERS_ANYONE);
         assertThat(savedSettings[0]).isEqualTo(STATE_UNSET);
         assertThat(savedSettings[1]).isEqualTo(STATE_UNSET);
 
-        SelectorWithWidgetPreference starredPref = makePreference(KEY_STARRED, false, false);
-        SelectorWithWidgetPreference contactsPref = makePreference(KEY_CONTACTS, false, false);
         savedSettings = mMessagesController.settingsToSaveOnClick(
-                starredPref, PEOPLE_TYPE_STARRED, CONVERSATION_SENDERS_ANYONE);
+                KEY_STARRED, true, PEOPLE_TYPE_STARRED, CONVERSATION_SENDERS_ANYONE);
         assertThat(savedSettings[0]).isEqualTo(STATE_UNSET);
 
         savedSettings = mMessagesController.settingsToSaveOnClick(
-                contactsPref, PEOPLE_TYPE_CONTACTS, CONVERSATION_SENDERS_ANYONE);
+                KEY_CONTACTS, true, PEOPLE_TYPE_CONTACTS, CONVERSATION_SENDERS_ANYONE);
         assertThat(savedSettings[0]).isEqualTo(STATE_UNSET);
     }
+
+    @Test
+    public void testPreferenceClick_passesCorrectCheckedState_startingUnchecked_messages() {
+        ZenMode zenMode = new ZenMode("id",
+                new AutomaticZenRule.Builder("Driving", Uri.parse("drive"))
+                        .setType(AutomaticZenRule.TYPE_DRIVING)
+                        .setInterruptionFilter(INTERRUPTION_FILTER_PRIORITY)
+                        .setZenPolicy(new ZenPolicy.Builder()
+                                .disallowAllSounds()
+                                .build())
+                        .build(), true);
+
+        mMessagesController.displayPreference(mPreferenceScreen);
+        mMessagesController.updateZenMode(mMessagesPrefCategory, zenMode);
+
+        assertThat(((SelectorWithWidgetPreference) mMessagesPrefCategory.findPreference(KEY_NONE))
+                .isChecked());
+
+        mMessagesPrefCategory.findPreference(KEY_STARRED).performClick();
+
+        ArgumentCaptor<ZenMode> captor = ArgumentCaptor.forClass(ZenMode.class);
+        verify(mBackend).updateMode(captor.capture());
+        assertThat(captor.getValue().getPolicy().getPriorityMessageSenders())
+                .isEqualTo(PEOPLE_TYPE_STARRED);
+    }
+
+    @Test
+    public void testPreferenceClick_passesCorrectCheckedState_startingChecked_messages() {
+        ZenMode zenMode = new ZenMode("id",
+                new AutomaticZenRule.Builder("Driving", Uri.parse("drive"))
+                        .setType(AutomaticZenRule.TYPE_DRIVING)
+                        .setInterruptionFilter(INTERRUPTION_FILTER_PRIORITY)
+                        .setZenPolicy(new ZenPolicy.Builder()
+                                .allowAllSounds()
+                                .build())
+                        .build(), true);
+
+        mMessagesController.displayPreference(mPreferenceScreen);
+        mMessagesController.updateZenMode(mMessagesPrefCategory, zenMode);
+
+        assertThat(
+                ((SelectorWithWidgetPreference) mMessagesPrefCategory.findPreference(KEY_ANY))
+                .isChecked()).isTrue();
+
+        mMessagesPrefCategory.findPreference(KEY_ANY).performClick();
+
+        ArgumentCaptor<ZenMode> captor = ArgumentCaptor.forClass(ZenMode.class);
+        verify(mBackend).updateMode(captor.capture());
+        assertThat(captor.getValue().getPolicy().getPriorityMessageSenders())
+                .isEqualTo(PEOPLE_TYPE_NONE);
+    }
+
+    @Test
+    public void testPreferenceClick_passesCorrectCheckedState_startingUnchecked_calls() {
+        ZenMode zenMode = new ZenMode("id",
+                new AutomaticZenRule.Builder("Driving", Uri.parse("drive"))
+                        .setType(AutomaticZenRule.TYPE_DRIVING)
+                        .setInterruptionFilter(INTERRUPTION_FILTER_PRIORITY)
+                        .setZenPolicy(new ZenPolicy.Builder()
+                                .disallowAllSounds()
+                                .build())
+                        .build(), true);
+
+        mCallsController.displayPreference(mPreferenceScreen);
+        mCallsController.updateZenMode(mCallsPrefCategory, zenMode);
+
+        assertThat(
+                ((SelectorWithWidgetPreference) mCallsPrefCategory.findPreference(KEY_NONE))
+                .isChecked()).isTrue();
+
+        mCallsPrefCategory.findPreference(KEY_STARRED).performClick();
+        ArgumentCaptor<ZenMode> captor = ArgumentCaptor.forClass(ZenMode.class);
+        verify(mBackend).updateMode(captor.capture());
+        assertThat(captor.getValue().getPolicy().getPriorityCallSenders())
+                .isEqualTo(PEOPLE_TYPE_STARRED);
+    }
+
+    @Test
+    public void testPreferenceClick_passesCorrectCheckedState_startingChecked_calls() {
+        ZenMode zenMode = new ZenMode("id",
+                new AutomaticZenRule.Builder("Driving", Uri.parse("drive"))
+                        .setType(AutomaticZenRule.TYPE_DRIVING)
+                        .setInterruptionFilter(INTERRUPTION_FILTER_PRIORITY)
+                        .setZenPolicy(new ZenPolicy.Builder()
+                                .disallowAllSounds()
+                                .build())
+                        .build(), true);
+
+        mCallsController.displayPreference(mPreferenceScreen);
+        mCallsController.updateZenMode(mCallsPrefCategory, zenMode);
+
+        assertThat(
+                ((SelectorWithWidgetPreference) mCallsPrefCategory.findPreference(KEY_NONE))
+                .isChecked()).isTrue();
+
+        mCallsPrefCategory.findPreference(KEY_NONE).performClick();
+        ArgumentCaptor<ZenMode> captor = ArgumentCaptor.forClass(ZenMode.class);
+        verify(mBackend).updateMode(captor.capture());
+        assertThat(captor.getValue().getPolicy().getPriorityCallSenders())
+                .isEqualTo(PEOPLE_TYPE_NONE);
+    }
 }