diff --git a/res/drawable/ic_volume_ringer_mute.xml b/res/drawable/ic_volume_ringer_mute.xml new file mode 100644 index 00000000000..03357e990e6 --- /dev/null +++ b/res/drawable/ic_volume_ringer_mute.xml @@ -0,0 +1,38 @@ + + + + + + + + + + + diff --git a/res/drawable/ic_volume_ringer_vibrate.xml b/res/drawable/ic_volume_ringer_vibrate.xml new file mode 100644 index 00000000000..d6afe10e692 --- /dev/null +++ b/res/drawable/ic_volume_ringer_vibrate.xml @@ -0,0 +1,28 @@ + + + + + + + diff --git a/src/com/android/settings/dashboard/conditional/AbnormalRingerConditionBase.java b/src/com/android/settings/dashboard/conditional/AbnormalRingerConditionBase.java new file mode 100644 index 00000000000..eaec6d08cc7 --- /dev/null +++ b/src/com/android/settings/dashboard/conditional/AbnormalRingerConditionBase.java @@ -0,0 +1,83 @@ +/* + * Copyright (C) 2018 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.dashboard.conditional; + +import android.content.BroadcastReceiver; +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.media.AudioManager; +import android.provider.Settings; + +import com.android.settings.R; + +public abstract class AbnormalRingerConditionBase extends Condition { + + private final IntentFilter mFilter; + + protected final AudioManager mAudioManager; + + private final RingerModeChangeReceiver mReceiver; + + AbnormalRingerConditionBase(ConditionManager manager) { + super(manager); + mAudioManager = + (AudioManager) mManager.getContext().getSystemService(Context.AUDIO_SERVICE); + mReceiver = new RingerModeChangeReceiver(this); + + mFilter = new IntentFilter(AudioManager.INTERNAL_RINGER_MODE_CHANGED_ACTION); + manager.getContext().registerReceiver(mReceiver, mFilter); + } + + @Override + public CharSequence[] getActions() { + return new CharSequence[] { + mManager.getContext().getText(R.string.condition_device_muted_action_turn_on_sound) + }; + } + + @Override + public void onPrimaryClick() { + mManager.getContext().startActivity( + new Intent(Settings.ACTION_SOUND_SETTINGS) + .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)); + } + + @Override + public void onActionClick(int index) { + mAudioManager.setRingerModeInternal(AudioManager.RINGER_MODE_NORMAL); + mAudioManager.setStreamVolume(AudioManager.STREAM_RING, 1, 0 /* flags */); + refreshState(); + } + + static class RingerModeChangeReceiver extends BroadcastReceiver { + + private final AbnormalRingerConditionBase mCondition; + + public RingerModeChangeReceiver(AbnormalRingerConditionBase condition) { + mCondition = condition; + } + + @Override + public void onReceive(Context context, Intent intent) { + final String action = intent.getAction(); + if (AudioManager.INTERNAL_RINGER_MODE_CHANGED_ACTION.equals(action)) { + mCondition.refreshState(); + } + } + } +} diff --git a/src/com/android/settings/dashboard/conditional/AirplaneModeCondition.java b/src/com/android/settings/dashboard/conditional/AirplaneModeCondition.java index 448510f75a2..792a090ddf9 100644 --- a/src/com/android/settings/dashboard/conditional/AirplaneModeCondition.java +++ b/src/com/android/settings/dashboard/conditional/AirplaneModeCondition.java @@ -20,7 +20,6 @@ import android.content.Context; import android.content.Intent; import android.content.IntentFilter; import android.graphics.drawable.Drawable; -import android.graphics.drawable.Icon; import android.net.ConnectivityManager; import android.provider.Settings; import android.util.Log; diff --git a/src/com/android/settings/dashboard/conditional/ConditionManager.java b/src/com/android/settings/dashboard/conditional/ConditionManager.java index a60019a853c..2754d8a5e64 100644 --- a/src/com/android/settings/dashboard/conditional/ConditionManager.java +++ b/src/com/android/settings/dashboard/conditional/ConditionManager.java @@ -24,6 +24,7 @@ import android.util.Xml; import com.android.settingslib.core.lifecycle.LifecycleObserver; import com.android.settingslib.core.lifecycle.events.OnPause; import com.android.settingslib.core.lifecycle.events.OnResume; + import org.xmlpull.v1.XmlPullParser; import org.xmlpull.v1.XmlPullParserException; import org.xmlpull.v1.XmlSerializer; @@ -153,6 +154,8 @@ public class ConditionManager implements LifecycleObserver, OnResume, OnPause { addIfMissing(BackgroundDataCondition.class, conditions); addIfMissing(WorkModeCondition.class, conditions); addIfMissing(NightDisplayCondition.class, conditions); + addIfMissing(RingerMutedCondition.class, conditions); + addIfMissing(RingerVibrateCondition.class, conditions); Collections.sort(conditions, CONDITION_COMPARATOR); } @@ -183,6 +186,10 @@ public class ConditionManager implements LifecycleObserver, OnResume, OnPause { return new WorkModeCondition(this); } else if (NightDisplayCondition.class == clz) { return new NightDisplayCondition(this); + } else if (RingerMutedCondition.class == clz) { + return new RingerMutedCondition(this); + } else if (RingerVibrateCondition.class == clz) { + return new RingerVibrateCondition(this); } Log.e(TAG, "unknown condition class: " + clz.getSimpleName()); return null; diff --git a/src/com/android/settings/dashboard/conditional/RingerMutedCondition.java b/src/com/android/settings/dashboard/conditional/RingerMutedCondition.java new file mode 100644 index 00000000000..bdd92e2d239 --- /dev/null +++ b/src/com/android/settings/dashboard/conditional/RingerMutedCondition.java @@ -0,0 +1,63 @@ +/* + * Copyright (C) 2018 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.dashboard.conditional; + +import android.app.NotificationManager; +import android.graphics.drawable.Drawable; +import android.media.AudioManager; +import android.provider.Settings; + +import com.android.internal.logging.nano.MetricsProto; +import com.android.settings.R; + +public class RingerMutedCondition extends AbnormalRingerConditionBase { + + private final NotificationManager mNotificationManager; + + RingerMutedCondition(ConditionManager manager) { + super(manager); + mNotificationManager = mManager.getContext().getSystemService(NotificationManager.class); + } + + @Override + public void refreshState() { + int zen = mNotificationManager.getZenMode(); + boolean zenModeEnabled = zen != Settings.Global.ZEN_MODE_OFF; + boolean isSilent = mAudioManager.getRingerModeInternal() == AudioManager.RINGER_MODE_SILENT; + setActive(isSilent && !zenModeEnabled); + } + + @Override + public int getMetricsConstant() { + return MetricsProto.MetricsEvent.SETTINGS_CONDITION_DEVICE_MUTED; + } + + @Override + public Drawable getIcon() { + return mManager.getContext().getDrawable(R.drawable.ic_volume_ringer_mute); + } + + @Override + public CharSequence getTitle() { + return mManager.getContext().getText(R.string.condition_device_muted_title); + } + + @Override + public CharSequence getSummary() { + return mManager.getContext().getText(R.string.condition_device_muted_summary); + } +} diff --git a/src/com/android/settings/dashboard/conditional/RingerVibrateCondition.java b/src/com/android/settings/dashboard/conditional/RingerVibrateCondition.java new file mode 100644 index 00000000000..6af05c1faed --- /dev/null +++ b/src/com/android/settings/dashboard/conditional/RingerVibrateCondition.java @@ -0,0 +1,55 @@ +/* + * Copyright (C) 2018 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.dashboard.conditional; + +import android.graphics.drawable.Drawable; +import android.media.AudioManager; + +import com.android.internal.logging.nano.MetricsProto; +import com.android.settings.R; + +public class RingerVibrateCondition extends AbnormalRingerConditionBase { + + RingerVibrateCondition(ConditionManager manager) { + super(manager); + } + + @Override + public void refreshState() { + setActive(mAudioManager.getRingerModeInternal() == AudioManager.RINGER_MODE_VIBRATE); + } + + @Override + public int getMetricsConstant() { + return MetricsProto.MetricsEvent.SETTINGS_CONDITION_DEVICE_VIBRATE; + } + + @Override + public Drawable getIcon() { + return mManager.getContext().getDrawable(R.drawable.ic_volume_ringer_vibrate); + } + + @Override + public CharSequence getTitle() { + return mManager.getContext().getText(R.string.condition_device_vibrate_title); + } + + @Override + public CharSequence getSummary() { + return mManager.getContext().getText(R.string.condition_device_vibrate_summary); + } +} diff --git a/src/com/android/settings/notification/RingVolumePreferenceController.java b/src/com/android/settings/notification/RingVolumePreferenceController.java index 8b7822507f9..5acca0458cb 100644 --- a/src/com/android/settings/notification/RingVolumePreferenceController.java +++ b/src/com/android/settings/notification/RingVolumePreferenceController.java @@ -22,16 +22,14 @@ import android.content.ComponentName; import android.content.Context; import android.content.Intent; import android.content.IntentFilter; -import android.content.pm.PackageManager; -import android.content.pm.ServiceInfo; import android.media.AudioManager; import android.os.Handler; import android.os.Looper; import android.os.Message; import android.os.Vibrator; -import android.util.Log; import com.android.internal.annotations.VisibleForTesting; +import com.android.settings.R; import com.android.settings.Utils; import com.android.settings.notification.VolumeSeekBarPreference.Callback; import com.android.settingslib.core.lifecycle.Lifecycle; @@ -99,7 +97,7 @@ public class RingVolumePreferenceController extends VolumeSeekBarPreferenceContr @Override public int getMuteIcon() { - return com.android.internal.R.drawable.ic_audio_ring_notif_mute; + return R.drawable.ic_volume_ringer_vibrate; } private void updateRingerMode() { diff --git a/tests/robotests/src/com/android/settings/dashboard/conditional/AbnormalRingerConditionBaseTest.java b/tests/robotests/src/com/android/settings/dashboard/conditional/AbnormalRingerConditionBaseTest.java new file mode 100644 index 00000000000..c72131fa8e2 --- /dev/null +++ b/tests/robotests/src/com/android/settings/dashboard/conditional/AbnormalRingerConditionBaseTest.java @@ -0,0 +1,98 @@ +/* + * Copyright (C) 2018 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.dashboard.conditional; + +import static com.google.common.truth.Truth.assertThat; +import static org.mockito.Mockito.when; + +import android.content.Context; +import android.content.Intent; +import android.graphics.drawable.Drawable; +import android.media.AudioManager; + +import com.android.settings.testutils.SettingsRobolectricTestRunner; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.robolectric.RuntimeEnvironment; + +@RunWith(SettingsRobolectricTestRunner.class) +public class AbnormalRingerConditionBaseTest { + + @Mock + private ConditionManager mConditionManager; + + private Context mContext; + private TestCondition mCondition; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + mContext = RuntimeEnvironment.application; + when(mConditionManager.getContext()).thenReturn(mContext); + mCondition = new TestCondition(mConditionManager); + } + + @Test + public void newInstance_shouldMonitorRingerStateChangeBroadcast() { + final Intent broadcast1 = new Intent("foo.bar.action"); + final Intent broadcast2 = new Intent(AudioManager.INTERNAL_RINGER_MODE_CHANGED_ACTION); + + mContext.sendBroadcast(broadcast1); + assertThat(mCondition.mRefreshCalled).isFalse(); + + mContext.sendBroadcast(broadcast2); + assertThat(mCondition.mRefreshCalled).isTrue(); + } + + private static class TestCondition extends AbnormalRingerConditionBase { + private boolean mRefreshCalled; + + TestCondition(ConditionManager manager) { + super(manager); + } + + @Override + public void refreshState() { + mRefreshCalled = true; + } + + @Override + public int getMetricsConstant() { + return 0; + } + + @Override + public Drawable getIcon() { + return null; + } + + @Override + public CharSequence getTitle() { + return null; + } + + @Override + public CharSequence getSummary() { + return null; + } + + } +} diff --git a/tests/robotests/src/com/android/settings/dashboard/conditional/RingerMutedConditionTest.java b/tests/robotests/src/com/android/settings/dashboard/conditional/RingerMutedConditionTest.java new file mode 100644 index 00000000000..13cb1c23408 --- /dev/null +++ b/tests/robotests/src/com/android/settings/dashboard/conditional/RingerMutedConditionTest.java @@ -0,0 +1,96 @@ +/* + * Copyright (C) 2018 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.dashboard.conditional; + + +import static com.google.common.truth.Truth.assertThat; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import android.app.NotificationManager; +import android.content.Context; +import android.media.AudioManager; +import android.provider.Settings; + +import com.android.settings.R; +import com.android.settings.testutils.SettingsRobolectricTestRunner; +import com.android.settings.testutils.shadow.ShadowAudioManager; +import com.android.settings.testutils.shadow.ShadowNotificationManager; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.robolectric.RuntimeEnvironment; +import org.robolectric.annotation.Config; +import org.robolectric.shadow.api.Shadow; + +@RunWith(SettingsRobolectricTestRunner.class) +@Config(shadows = {ShadowNotificationManager.class, ShadowAudioManager.class}) +public class RingerMutedConditionTest { + private static final String TAG = "RingerMutedConditionTest"; + @Mock + private ConditionManager mConditionManager; + + private Context mContext; + private ShadowNotificationManager mNotificationManager; + private ShadowAudioManager mAudioManager; + private RingerMutedCondition mCondition; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + mContext = RuntimeEnvironment.application; + mAudioManager = Shadow.extract(mContext.getSystemService(Context.AUDIO_SERVICE)); + mNotificationManager = Shadow.extract( + mContext.getSystemService(NotificationManager.class)); + when(mConditionManager.getContext()).thenReturn(mContext); + mCondition = spy(new RingerMutedCondition(mConditionManager)); + } + + @Test + public void verifyText() { + assertThat(mCondition.getTitle()).isEqualTo( + mContext.getText(R.string.condition_device_muted_title)); + assertThat(mCondition.getSummary()).isEqualTo( + mContext.getText(R.string.condition_device_muted_summary)); + assertThat(mCondition.getActions()[0]).isEqualTo( + mContext.getText(R.string.condition_device_muted_action_turn_on_sound)); + } + + @Test + public void refreshState_zenModeOn_shouldNotActivate() { + mAudioManager.setRingerModeInternal(AudioManager.RINGER_MODE_SILENT); + mNotificationManager.setZenMode(Settings.Global.ZEN_MODE_NO_INTERRUPTIONS, null, TAG); + + mCondition.refreshState(); + + verify(mCondition).setActive(false); + } + + @Test + public void refreshState_zenModeOff_shouldActivate() { + mAudioManager.setRingerModeInternal(AudioManager.RINGER_MODE_SILENT); + mNotificationManager.setZenMode(Settings.Global.ZEN_MODE_OFF, null, TAG); + + mCondition.refreshState(); + + verify(mCondition).setActive(true); + } +} diff --git a/tests/robotests/src/com/android/settings/dashboard/conditional/RingerVibrateConditionTest.java b/tests/robotests/src/com/android/settings/dashboard/conditional/RingerVibrateConditionTest.java new file mode 100644 index 00000000000..a134fac5721 --- /dev/null +++ b/tests/robotests/src/com/android/settings/dashboard/conditional/RingerVibrateConditionTest.java @@ -0,0 +1,60 @@ +/* + * Copyright (C) 2018 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.dashboard.conditional; + + +import static com.google.common.truth.Truth.assertThat; +import static org.mockito.Mockito.when; + +import android.content.Context; + +import com.android.settings.R; +import com.android.settings.testutils.SettingsRobolectricTestRunner; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.robolectric.RuntimeEnvironment; + +@RunWith(SettingsRobolectricTestRunner.class) +public class RingerVibrateConditionTest { + @Mock + private ConditionManager mConditionManager; + + private Context mContext; + private RingerVibrateCondition mCondition; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + mContext = RuntimeEnvironment.application; + when(mConditionManager.getContext()).thenReturn(mContext); + mCondition = new RingerVibrateCondition(mConditionManager); + } + + @Test + public void verifyText() { + assertThat(mCondition.getTitle()).isEqualTo( + mContext.getText(R.string.condition_device_vibrate_title)); + assertThat(mCondition.getSummary()).isEqualTo( + mContext.getText(R.string.condition_device_vibrate_summary)); + assertThat(mCondition.getActions()[0]).isEqualTo( + mContext.getText(R.string.condition_device_muted_action_turn_on_sound)); + } +} diff --git a/tests/robotests/src/com/android/settings/testutils/shadow/ShadowAudioManager.java b/tests/robotests/src/com/android/settings/testutils/shadow/ShadowAudioManager.java new file mode 100644 index 00000000000..ed53eeaaf54 --- /dev/null +++ b/tests/robotests/src/com/android/settings/testutils/shadow/ShadowAudioManager.java @@ -0,0 +1,38 @@ +/* + * Copyright (C) 2018 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.testutils.shadow; + +import android.media.AudioManager; + +import org.robolectric.annotation.Implementation; +import org.robolectric.annotation.Implements; + +@Implements(AudioManager.class) +public class ShadowAudioManager { + + private int mRingerMode; + + @Implementation + public void setRingerModeInternal(int mode) { + mRingerMode = mode; + } + + @Implementation + private int getRingerModeInternal() { + return mRingerMode; + } +} diff --git a/tests/robotests/src/com/android/settings/testutils/shadow/ShadowNotificationManager.java b/tests/robotests/src/com/android/settings/testutils/shadow/ShadowNotificationManager.java new file mode 100644 index 00000000000..307870319b6 --- /dev/null +++ b/tests/robotests/src/com/android/settings/testutils/shadow/ShadowNotificationManager.java @@ -0,0 +1,41 @@ +/* + * Copyright (C) 2018 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.testutils.shadow; + +import android.app.NotificationManager; +import android.net.Uri; + +import org.robolectric.annotation.Implementation; +import org.robolectric.annotation.Implements; + +@Implements(NotificationManager.class) +public class ShadowNotificationManager { + + private int mZenMode; + + + @Implementation + public void setZenMode(int mode, Uri conditionId, String reason) { + mZenMode = mode; + } + + @Implementation + public int getZenMode() { + return mZenMode; + } +} +