diff --git a/res/drawable-nodpi/gentle_notifications_shade.png b/res/drawable-nodpi/gentle_notifications_shade.png new file mode 100644 index 00000000000..dddef5cf96c Binary files /dev/null and b/res/drawable-nodpi/gentle_notifications_shade.png differ diff --git a/res/drawable-nodpi/gentle_notifications_shade_lock.png b/res/drawable-nodpi/gentle_notifications_shade_lock.png new file mode 100644 index 00000000000..4d4de243420 Binary files /dev/null and b/res/drawable-nodpi/gentle_notifications_shade_lock.png differ diff --git a/res/drawable-nodpi/gentle_notifications_shade_status.png b/res/drawable-nodpi/gentle_notifications_shade_status.png new file mode 100644 index 00000000000..432dc3fa663 Binary files /dev/null and b/res/drawable-nodpi/gentle_notifications_shade_status.png differ diff --git a/res/drawable-nodpi/gentle_notifications_shade_status_lock.png b/res/drawable-nodpi/gentle_notifications_shade_status_lock.png new file mode 100644 index 00000000000..e8238dc1114 Binary files /dev/null and b/res/drawable-nodpi/gentle_notifications_shade_status_lock.png differ diff --git a/res/layout/drawable_layout.xml b/res/layout/drawable_layout.xml new file mode 100644 index 00000000000..fe5d4c4b46b --- /dev/null +++ b/res/layout/drawable_layout.xml @@ -0,0 +1,27 @@ + + + + + + + \ No newline at end of file diff --git a/res/values/strings.xml b/res/values/strings.xml index 93b7fa2528d..53e9248eec4 100644 --- a/res/values/strings.xml +++ b/res/values/strings.xml @@ -7872,6 +7872,33 @@ Swipe left to dismiss, right to show menu + + Gentle notifications + + + Also display in + + + Status bar + + + Lock screen + + + Gentle notifications are always silent and always appear in the pull-down shade + + + Display in pull-down shade only + + + Display in pull-down shade & on lock screen + + + Display in pull-down shade & status bar + + + Display in pull-down shade, status bar & on lock screen + Blink light diff --git a/res/xml/configure_notification_settings.xml b/res/xml/configure_notification_settings.xml index dd2cf8687d9..af27869b9ab 100644 --- a/res/xml/configure_notification_settings.xml +++ b/res/xml/configure_notification_settings.xml @@ -26,11 +26,11 @@ settings:controller="com.android.settings.widget.VideoPreferenceController" android:persistent="false" /> - + + + + + + + + + + + + + + + + diff --git a/src/com/android/settings/notification/GentleDrawablePreferenceController.java b/src/com/android/settings/notification/GentleDrawablePreferenceController.java new file mode 100644 index 00000000000..cdadf5acd24 --- /dev/null +++ b/src/com/android/settings/notification/GentleDrawablePreferenceController.java @@ -0,0 +1,81 @@ +/* + * Copyright (C) 2019 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; + +import android.content.Context; +import android.provider.Settings; +import android.widget.ImageView; + +import com.android.settings.R; +import com.android.settings.core.BasePreferenceController; +import com.android.settingslib.widget.LayoutPreference; + +import androidx.annotation.VisibleForTesting; +import androidx.preference.Preference; + +public class GentleDrawablePreferenceController extends BasePreferenceController { + + @VisibleForTesting + static final int ON = 1; + + private NotificationBackend mBackend; + + public GentleDrawablePreferenceController(Context context, String preferenceKey) { + super(context, preferenceKey); + mBackend = new NotificationBackend(); + } + + @VisibleForTesting + void setBackend(NotificationBackend backend) { + mBackend = backend; + } + + @Override + public void updateState(Preference preference) { + LayoutPreference pref = (LayoutPreference) preference; + boolean showOnLockscreen = showOnLockscreen(); + boolean showOnStatusBar = showOnStatusBar(); + + ImageView view = pref.findViewById(R.id.drawable); + + if (showOnLockscreen) { + if (showOnStatusBar) { + view.setImageResource(R.drawable.gentle_notifications_shade_status_lock); + } else { + view.setImageResource(R.drawable.gentle_notifications_shade_lock); + } + } else if (showOnStatusBar) { + view.setImageResource(R.drawable.gentle_notifications_shade_status); + } else { + view.setImageResource(R.drawable.gentle_notifications_shade); + } + } + + @Override + public int getAvailabilityStatus() { + return AVAILABLE; + } + + private boolean showOnLockscreen() { + return Settings.Secure.getInt(mContext.getContentResolver(), + Settings.Secure.LOCK_SCREEN_SHOW_SILENT_NOTIFICATIONS, 0) == ON; + } + + private boolean showOnStatusBar() { + return !mBackend.shouldHideSilentStatusBarIcons(mContext); + } +} diff --git a/src/com/android/settings/notification/GentleNotificationSettings.java b/src/com/android/settings/notification/GentleNotificationSettings.java new file mode 100644 index 00000000000..5de6ab787a3 --- /dev/null +++ b/src/com/android/settings/notification/GentleNotificationSettings.java @@ -0,0 +1,74 @@ +/* + * Copyright (C) 2019 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; + +import android.app.settings.SettingsEnums; +import android.content.Context; +import android.provider.SearchIndexableResource; + +import com.android.settings.R; +import com.android.settings.dashboard.DashboardFragment; +import com.android.settings.search.BaseSearchIndexProvider; +import com.android.settingslib.search.SearchIndexable; + +import java.util.Arrays; +import java.util.List; + +@SearchIndexable +public class GentleNotificationSettings extends DashboardFragment { + private static final String TAG = "GentleNotiSettings"; + + @Override + public int getMetricsCategory() { + return SettingsEnums.GENTLE_NOTIFICATIONS_SCREEN; + } + + @Override + protected String getLogTag() { + return TAG; + } + + @Override + protected int getPreferenceScreenResId() { + return R.xml.gentle_notification_settings; + } + + @Override + public void onAttach(Context context) { + super.onAttach(context); + + use(SilentStatusBarPreferenceController.class).setListener( + shown -> updatePreferenceStates()); + + use(SilentLockscreenPreferenceController.class).setListener( + shown -> updatePreferenceStates()); + } + + /** + * For Search. + */ + public static final SearchIndexProvider SEARCH_INDEX_DATA_PROVIDER = + new BaseSearchIndexProvider() { + @Override + public List getXmlResourcesToIndex( + Context context, boolean enabled) { + final SearchIndexableResource sir = new SearchIndexableResource(context); + sir.xmlResId = R.xml.gentle_notification_settings; + return Arrays.asList(sir); + } + }; +} diff --git a/src/com/android/settings/notification/GentleNotificationsPreferenceController.java b/src/com/android/settings/notification/GentleNotificationsPreferenceController.java new file mode 100644 index 00000000000..97e4e252d17 --- /dev/null +++ b/src/com/android/settings/notification/GentleNotificationsPreferenceController.java @@ -0,0 +1,78 @@ +/* + * Copyright (C) 2019 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; + +import static android.provider.Settings.Secure.NOTIFICATION_BUBBLES; + +import android.content.Context; +import android.provider.Settings; + +import com.android.settings.R; +import com.android.settings.core.BasePreferenceController; + +import androidx.annotation.VisibleForTesting; + +public class GentleNotificationsPreferenceController extends BasePreferenceController { + + @VisibleForTesting + static final int ON = 1; + + private NotificationBackend mBackend; + + public GentleNotificationsPreferenceController(Context context, String preferenceKey) { + super(context, preferenceKey); + mBackend = new NotificationBackend(); + } + + @VisibleForTesting + void setBackend(NotificationBackend backend) { + mBackend = backend; + } + + @Override + public CharSequence getSummary() { + boolean showOnLockscreen = showOnLockscreen(); + boolean showOnStatusBar = showOnStatusBar(); + + if (showOnLockscreen) { + if (showOnStatusBar) { + return mContext.getString( + R.string.gentle_notifications_display_summary_shade_status_lock); + } else { + return mContext.getString(R.string.gentle_notifications_display_summary_shade_lock); + } + } else if (showOnStatusBar) { + return mContext.getString(R.string.gentle_notifications_display_summary_shade_status); + } else { + return mContext.getString(R.string.gentle_notifications_display_summary_shade); + } + } + + @Override + public int getAvailabilityStatus() { + return AVAILABLE; + } + + private boolean showOnLockscreen() { + return Settings.Secure.getInt(mContext.getContentResolver(), + Settings.Secure.LOCK_SCREEN_SHOW_SILENT_NOTIFICATIONS, 0) == ON; + } + + private boolean showOnStatusBar() { + return !mBackend.shouldHideSilentStatusBarIcons(mContext); + } +} diff --git a/src/com/android/settings/notification/SilentLockscreenPreferenceController.java b/src/com/android/settings/notification/SilentLockscreenPreferenceController.java new file mode 100644 index 00000000000..219d312b956 --- /dev/null +++ b/src/com/android/settings/notification/SilentLockscreenPreferenceController.java @@ -0,0 +1,70 @@ +/* + * Copyright (C) 2019 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; + +import static android.provider.Settings.Secure.NOTIFICATION_NEW_INTERRUPTION_MODEL; + +import android.content.Context; +import android.os.UserHandle; +import android.provider.Settings; + +import com.android.settings.core.TogglePreferenceController; + +import com.google.common.annotations.VisibleForTesting; + +public class SilentLockscreenPreferenceController extends TogglePreferenceController { + + private static final String KEY = "lock_screen"; + private Listener mListener; + + public SilentLockscreenPreferenceController(Context context) { + super(context, KEY); + } + + @Override + public boolean isChecked() { + return Settings.Secure.getInt(mContext.getContentResolver(), + Settings.Secure.LOCK_SCREEN_SHOW_SILENT_NOTIFICATIONS, 0) == 1; + } + + @Override + public boolean setChecked(boolean isChecked) { + Settings.Secure.putInt(mContext.getContentResolver(), + Settings.Secure.LOCK_SCREEN_SHOW_SILENT_NOTIFICATIONS, isChecked ? 1 : 0); + if (mListener != null) { + mListener.onChange(isChecked); + } + return true; + } + + @Override + public int getAvailabilityStatus() { + return Settings.Secure.getInt( + mContext.getContentResolver(), NOTIFICATION_NEW_INTERRUPTION_MODEL, 1) != 0 + ? AVAILABLE : UNSUPPORTED_ON_DEVICE; + } + + public void setListener(Listener listener) { + mListener = listener; + } + + interface Listener { + void onChange(boolean shown); + } +} + + diff --git a/src/com/android/settings/notification/SilentStatusBarPreferenceController.java b/src/com/android/settings/notification/SilentStatusBarPreferenceController.java index 5bf943ac37a..e561508014e 100644 --- a/src/com/android/settings/notification/SilentStatusBarPreferenceController.java +++ b/src/com/android/settings/notification/SilentStatusBarPreferenceController.java @@ -28,9 +28,10 @@ import com.google.common.annotations.VisibleForTesting; public class SilentStatusBarPreferenceController extends TogglePreferenceController { - private static final String KEY = "hide_silent_icons"; + private static final String KEY = "silent_icons"; private static final int MY_USER_ID = UserHandle.myUserId(); private NotificationBackend mBackend; + private Listener mListener; public SilentStatusBarPreferenceController(Context context) { super(context, KEY); @@ -44,12 +45,15 @@ public class SilentStatusBarPreferenceController extends TogglePreferenceControl @Override public boolean isChecked() { - return mBackend.shouldHideSilentStatusBarIcons(mContext); + return !mBackend.shouldHideSilentStatusBarIcons(mContext); } @Override public boolean setChecked(boolean isChecked) { - mBackend.setHideSilentStatusIcons(isChecked); + mBackend.setHideSilentStatusIcons(!isChecked); + if (mListener != null) { + mListener.onChange(isChecked); + } return true; } @@ -60,6 +64,14 @@ public class SilentStatusBarPreferenceController extends TogglePreferenceControl ? AVAILABLE : UNSUPPORTED_ON_DEVICE; } + public void setListener(Listener listener) { + mListener = listener; + } + + interface Listener { + void onChange(boolean shown); + } + } diff --git a/tests/robotests/src/com/android/settings/notification/GentleDrawablePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/notification/GentleDrawablePreferenceControllerTest.java new file mode 100644 index 00000000000..c8d1e018bea --- /dev/null +++ b/tests/robotests/src/com/android/settings/notification/GentleDrawablePreferenceControllerTest.java @@ -0,0 +1,113 @@ +/* + * Copyright (C) 2019 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; + +import static com.google.common.truth.Truth.assertThat; + +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import android.content.Context; +import android.provider.Settings; +import android.widget.ImageView; + +import com.android.settings.R; +import com.android.settingslib.widget.LayoutPreference; + +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 androidx.preference.Preference; + +@RunWith(RobolectricTestRunner.class) +public class GentleDrawablePreferenceControllerTest { + + private Context mContext; + + private GentleDrawablePreferenceController mController; + @Mock + private LayoutPreference mPreference; + @Mock + NotificationBackend mBackend; + @Mock + ImageView mView; + + private static final String KEY = "gentle_notifications"; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + mContext = RuntimeEnvironment.application; + mController = new GentleDrawablePreferenceController(mContext, KEY); + mController.setBackend(mBackend); + when(mPreference.findViewById(R.id.drawable)).thenReturn(mView); + } + + @Test + public void display_shouldDisplay() { + assertThat(mController.isAvailable()).isTrue(); + } + + @Test + public void updateState_lock() { + Settings.Secure.putInt(mContext.getContentResolver(), + Settings.Secure.LOCK_SCREEN_SHOW_SILENT_NOTIFICATIONS, 1); + when(mBackend.shouldHideSilentStatusBarIcons(mContext)).thenReturn(true); + + mController.updateState(mPreference); + + verify(mView).setImageResource(R.drawable.gentle_notifications_shade_lock); + } + + @Test + public void updateState_status() { + Settings.Secure.putInt(mContext.getContentResolver(), + Settings.Secure.LOCK_SCREEN_SHOW_SILENT_NOTIFICATIONS, 0); + when(mBackend.shouldHideSilentStatusBarIcons(mContext)).thenReturn(false); + + mController.updateState(mPreference); + + verify(mView).setImageResource(R.drawable.gentle_notifications_shade_status); + } + + @Test + public void updateState_both() { + Settings.Secure.putInt(mContext.getContentResolver(), + Settings.Secure.LOCK_SCREEN_SHOW_SILENT_NOTIFICATIONS, 1); + when(mBackend.shouldHideSilentStatusBarIcons(mContext)).thenReturn(false); + + mController.updateState(mPreference); + + verify(mView).setImageResource(R.drawable.gentle_notifications_shade_status_lock); + } + + @Test + public void updateState_neither() { + Settings.Secure.putInt(mContext.getContentResolver(), + Settings.Secure.LOCK_SCREEN_SHOW_SILENT_NOTIFICATIONS, 0); + when(mBackend.shouldHideSilentStatusBarIcons(mContext)).thenReturn(true); + + mController.updateState(mPreference); + + verify(mView).setImageResource(R.drawable.gentle_notifications_shade); + } +} diff --git a/tests/robotests/src/com/android/settings/notification/GentleNotificationsPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/notification/GentleNotificationsPreferenceControllerTest.java new file mode 100644 index 00000000000..4821322cff7 --- /dev/null +++ b/tests/robotests/src/com/android/settings/notification/GentleNotificationsPreferenceControllerTest.java @@ -0,0 +1,109 @@ +/* + * Copyright (C) 2019 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; + +import static android.provider.Settings.Secure.NOTIFICATION_BUBBLES; + +import static com.android.settings.notification.BadgingNotificationPreferenceController.OFF; +import static com.android.settings.notification.BadgingNotificationPreferenceController.ON; + +import static com.google.common.truth.Truth.assertThat; + +import static org.mockito.Mockito.when; + +import android.content.Context; +import android.provider.Settings; + +import com.android.settings.R; + +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 androidx.preference.Preference; + +@RunWith(RobolectricTestRunner.class) +public class GentleNotificationsPreferenceControllerTest { + + private Context mContext; + + @Mock + NotificationBackend mBackend; + + private GentleNotificationsPreferenceController mController; + private Preference mPreference; + + private static final String KEY = "gentle_notifications"; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + mContext = RuntimeEnvironment.application; + mController = new GentleNotificationsPreferenceController(mContext, KEY); + mController.setBackend(mBackend); + mPreference = new Preference(mContext); + } + + @Test + public void display_shouldDisplay() { + assertThat(mPreference.isVisible()).isTrue(); + } + + @Test + public void getSummary_lock() { + Settings.Secure.putInt(mContext.getContentResolver(), + Settings.Secure.LOCK_SCREEN_SHOW_SILENT_NOTIFICATIONS, 1); + when(mBackend.shouldHideSilentStatusBarIcons(mContext)).thenReturn(true); + + assertThat(mController.getSummary()).isEqualTo( + mContext.getString(R.string.gentle_notifications_display_summary_shade_lock)); + } + + @Test + public void getSummary_status() { + Settings.Secure.putInt(mContext.getContentResolver(), + Settings.Secure.LOCK_SCREEN_SHOW_SILENT_NOTIFICATIONS, 0); + when(mBackend.shouldHideSilentStatusBarIcons(mContext)).thenReturn(false); + + assertThat(mController.getSummary()).isEqualTo( + mContext.getString(R.string.gentle_notifications_display_summary_shade_status)); + } + + @Test + public void getSummary_both() { + Settings.Secure.putInt(mContext.getContentResolver(), + Settings.Secure.LOCK_SCREEN_SHOW_SILENT_NOTIFICATIONS, 1); + when(mBackend.shouldHideSilentStatusBarIcons(mContext)).thenReturn(false); + + assertThat(mController.getSummary()).isEqualTo(mContext.getString( + R.string.gentle_notifications_display_summary_shade_status_lock)); + } + + @Test + public void getSummary_neither() { + Settings.Secure.putInt(mContext.getContentResolver(), + Settings.Secure.LOCK_SCREEN_SHOW_SILENT_NOTIFICATIONS, 0); + when(mBackend.shouldHideSilentStatusBarIcons(mContext)).thenReturn(true); + + assertThat(mController.getSummary()).isEqualTo( + mContext.getString(R.string.gentle_notifications_display_summary_shade)); + } +} diff --git a/tests/robotests/src/com/android/settings/notification/SilentLockscreenPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/notification/SilentLockscreenPreferenceControllerTest.java new file mode 100644 index 00000000000..dcfdea59a8a --- /dev/null +++ b/tests/robotests/src/com/android/settings/notification/SilentLockscreenPreferenceControllerTest.java @@ -0,0 +1,117 @@ +/* + * Copyright (C) 2019 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; + +import static android.provider.Settings.Secure.NOTIFICATION_NEW_INTERRUPTION_MODEL; + +import static com.google.common.truth.Truth.assertThat; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import android.content.Context; +import android.provider.Settings; + +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 androidx.preference.Preference; +import androidx.preference.PreferenceScreen; + +@RunWith(RobolectricTestRunner.class) +public class SilentLockscreenPreferenceControllerTest { + + @Mock + private PreferenceScreen mScreen; + + private Context mContext; + private SilentLockscreenPreferenceController mController; + private Preference mPreference; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + mContext = RuntimeEnvironment.application; + mController = new SilentLockscreenPreferenceController(mContext); + mPreference = new Preference(mContext); + mPreference.setKey(mController.getPreferenceKey()); + when(mScreen.findPreference(mController.getPreferenceKey())).thenReturn(mPreference); + } + + @Test + public void isAvailable_featureEnabled() { + Settings.Secure.putInt( + mContext.getContentResolver(), NOTIFICATION_NEW_INTERRUPTION_MODEL, 1); + assertThat(mController.isAvailable()).isTrue(); + } + + @Test + public void isAvailable_featureDisabled() { + Settings.Secure.putInt( + mContext.getContentResolver(), NOTIFICATION_NEW_INTERRUPTION_MODEL, 0); + assertThat(mController.isAvailable()).isFalse(); + } + + @Test + public void isChecked_settingIsOff_false() { + Settings.Secure.putInt(mContext.getContentResolver(), + Settings.Secure.LOCK_SCREEN_SHOW_SILENT_NOTIFICATIONS, 0); + assertThat(mController.isChecked()).isFalse(); + } + + @Test + public void isChecked_settingIsOn_true() { + Settings.Secure.putInt(mContext.getContentResolver(), + Settings.Secure.LOCK_SCREEN_SHOW_SILENT_NOTIFICATIONS, 1); + assertThat(mController.isChecked()).isTrue(); + } + + @Test + public void onPreferenceChange_on() { + mController.onPreferenceChange(mPreference, true); + assertThat(Settings.Secure.getInt(mContext.getContentResolver(), + Settings.Secure.LOCK_SCREEN_SHOW_SILENT_NOTIFICATIONS, 0)).isEqualTo(1); + } + + @Test + public void onPreferenceChange_off() { + mController.onPreferenceChange(mPreference, false); + assertThat(Settings.Secure.getInt(mContext.getContentResolver(), + Settings.Secure.LOCK_SCREEN_SHOW_SILENT_NOTIFICATIONS, 1)).isEqualTo(0); + } + + @Test + public void listenerTriggered() { + SilentLockscreenPreferenceController.Listener listener = mock( + SilentLockscreenPreferenceController.Listener.class); + mController.setListener(listener); + + mController.setChecked(false); + verify(listener).onChange(false); + + mController.setChecked(true); + verify(listener).onChange(true); + } +} + diff --git a/tests/robotests/src/com/android/settings/notification/SilentStatusBarPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/notification/SilentStatusBarPreferenceControllerTest.java index 9dd8ff9f5c6..55a85494e43 100644 --- a/tests/robotests/src/com/android/settings/notification/SilentStatusBarPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/notification/SilentStatusBarPreferenceControllerTest.java @@ -21,6 +21,7 @@ import static android.provider.Settings.Secure.NOTIFICATION_NEW_INTERRUPTION_MOD import static com.google.common.truth.Truth.assertThat; import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -79,26 +80,39 @@ public class SilentStatusBarPreferenceControllerTest { @Test public void isChecked_settingIsOff_false() { - when(mBackend.shouldHideSilentStatusBarIcons(any())).thenReturn(false); + when(mBackend.shouldHideSilentStatusBarIcons(any())).thenReturn(true); assertThat(mController.isChecked()).isFalse(); } @Test public void isChecked_settingIsOn_true() { - when(mBackend.shouldHideSilentStatusBarIcons(any())).thenReturn(true); + when(mBackend.shouldHideSilentStatusBarIcons(any())).thenReturn(false); assertThat(mController.isChecked()).isTrue(); } @Test public void onPreferenceChange_on() { mController.onPreferenceChange(mPreference, true); - verify(mBackend).setHideSilentStatusIcons(true); + verify(mBackend).setHideSilentStatusIcons(false); } @Test public void onPreferenceChange_off() { mController.onPreferenceChange(mPreference, false); - verify(mBackend).setHideSilentStatusIcons(false); + verify(mBackend).setHideSilentStatusIcons(true); + } + + @Test + public void listenerTriggered() { + SilentStatusBarPreferenceController.Listener listener = mock( + SilentStatusBarPreferenceController.Listener.class); + mController.setListener(listener); + + mController.setChecked(false); + verify(listener).onChange(false); + + mController.setChecked(true); + verify(listener).onChange(true); } }