Implement new vibrate for calls in Settings.
Test: built and tested on device
Change-Id: Ia6ca7eb54472d44a9934d7f125a9f71e42c616a3
diff --git a/res/values/strings.xml b/res/values/strings.xml
index eede918..9ee199a 100644
--- a/res/values/strings.xml
+++ b/res/values/strings.xml
@@ -7572,6 +7572,15 @@
<!-- Sound: Title for the option managing whether or not to vibrate when ringing. [CHAR LIMIT=30] -->
<string name="vibrate_when_ringing_title">Vibrate for calls</string>
+ <!-- Sound: Option for vibrate when ringing setting: Never vibrate. [CHAR LIMIT=40] -->
+ <string name="vibrate_when_ringing_option_never_vibrate">Never vibrate</string>
+
+ <!-- Sound: Option for vibrate when ringing setting: Always vibrate. [CHAR LIMIT=40] -->
+ <string name="vibrate_when_ringing_option_always_vibrate">Always vibrate</string>
+
+ <!-- Sound: Option for vibrate when ringing setting: Ramping ringer. [CHAR LIMIT=80] -->
+ <string name="vibrate_when_ringing_option_ramping_ringer">Vibrate first then ring gradually</string>
+
<!-- Sound: Title for the other sounds option and associated settings page. [CHAR LIMIT=30] -->
<string name="other_sound_settings">Other sounds</string>
diff --git a/res/xml/sound_settings.xml b/res/xml/sound_settings.xml
index d82a324..a24a95f 100644
--- a/res/xml/sound_settings.xml
+++ b/res/xml/sound_settings.xml
@@ -88,11 +88,12 @@
settings:controller="com.android.settings.notification.NotificationVolumePreferenceController"/>
<!-- Also vibrate for calls -->
- <SwitchPreference
- android:key="vibrate_when_ringing"
+ <Preference
+ android:fragment="com.android.settings.sound.VibrateForCallsPreferenceFragment"
+ android:key="vibrate_for_calls"
android:title="@string/vibrate_when_ringing_title"
- settings:controller="com.android.settings.notification.VibrateWhenRingPreferenceController"
- android:order="-130"/>
+ android:order="-130"
+ settings:controller="com.android.settings.sound.VibrateForCallsPreferenceController"/>
<!-- Interruptions -->
<com.android.settingslib.RestrictedPreference
diff --git a/res/xml/vibrate_for_calls_settings.xml b/res/xml/vibrate_for_calls_settings.xml
new file mode 100644
index 0000000..5b6d217
--- /dev/null
+++ b/res/xml/vibrate_for_calls_settings.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ 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.
+ -->
+
+<PreferenceScreen
+ xmlns:android="http://schemas.android.com/apk/res/android"
+ android:title="@string/vibrate_when_ringing_title" />
diff --git a/src/com/android/settings/notification/VibrateWhenRingPreferenceController.java b/src/com/android/settings/notification/VibrateWhenRingPreferenceController.java
deleted file mode 100644
index 503b5bc..0000000
--- a/src/com/android/settings/notification/VibrateWhenRingPreferenceController.java
+++ /dev/null
@@ -1,144 +0,0 @@
-/*
- * Copyright (C) 2016 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.System.VIBRATE_WHEN_RINGING;
-
-import android.content.ContentResolver;
-import android.content.Context;
-import android.database.ContentObserver;
-import android.net.Uri;
-import android.os.Handler;
-import android.provider.DeviceConfig;
-import android.provider.Settings;
-import android.text.TextUtils;
-
-import androidx.preference.Preference;
-import androidx.preference.PreferenceScreen;
-
-import com.android.settings.Utils;
-import com.android.settings.core.TogglePreferenceController;
-import com.android.settingslib.core.lifecycle.LifecycleObserver;
-import com.android.settingslib.core.lifecycle.events.OnPause;
-import com.android.settingslib.core.lifecycle.events.OnResume;
-
-public class VibrateWhenRingPreferenceController extends TogglePreferenceController
- implements LifecycleObserver, OnResume, OnPause {
-
- /** Flag for whether or not to apply ramping ringer on incoming phone calls. */
- private static final String RAMPING_RINGER_ENABLED = "ramping_ringer_enabled";
- private static final String KEY_VIBRATE_WHEN_RINGING = "vibrate_when_ringing";
- private final int DEFAULT_VALUE = 0;
- private final int NOTIFICATION_VIBRATE_WHEN_RINGING = 1;
- private SettingObserver mSettingObserver;
-
- public VibrateWhenRingPreferenceController(Context context, String key) {
- super(context, key);
- }
-
- @Override
- public boolean isChecked() {
- return Settings.System.getInt(mContext.getContentResolver(),
- VIBRATE_WHEN_RINGING, DEFAULT_VALUE) != DEFAULT_VALUE;
- }
-
- @Override
- public boolean setChecked(boolean isChecked) {
- return Settings.System.putInt(mContext.getContentResolver(), VIBRATE_WHEN_RINGING,
- isChecked ? NOTIFICATION_VIBRATE_WHEN_RINGING : DEFAULT_VALUE);
- }
-
- @Override
- @AvailabilityStatus
- public int getAvailabilityStatus() {
- // If ramping ringer is enabled then this setting will be injected
- // with additional options.
- return Utils.isVoiceCapable(mContext) && !isRampingRingerEnabled()
- ? AVAILABLE
- : UNSUPPORTED_ON_DEVICE;
- }
-
- @Override
- public boolean isSliceable() {
- return TextUtils.equals(getPreferenceKey(), "vibrate_when_ringing");
- }
-
- @Override
- public boolean isPublicSlice() {
- return true;
- }
-
- @Override
- public void displayPreference(PreferenceScreen screen) {
- super.displayPreference(screen);
- Preference preference = screen.findPreference(KEY_VIBRATE_WHEN_RINGING);
- if (preference != null) {
- mSettingObserver = new SettingObserver(preference);
- preference.setPersistent(false);
- }
- }
-
- @Override
- public void onResume() {
- if (mSettingObserver != null) {
- mSettingObserver.register(true /* register */);
- }
- }
-
- @Override
- public void onPause() {
- if (mSettingObserver != null) {
- mSettingObserver.register(false /* register */);
- }
- }
-
- private final class SettingObserver extends ContentObserver {
-
- private final Uri VIBRATE_WHEN_RINGING_URI =
- Settings.System.getUriFor(VIBRATE_WHEN_RINGING);
-
- private final Preference mPreference;
-
- public SettingObserver(Preference preference) {
- super(new Handler());
- mPreference = preference;
- }
-
- public void register(boolean register) {
- final ContentResolver cr = mContext.getContentResolver();
- if (register) {
- cr.registerContentObserver(VIBRATE_WHEN_RINGING_URI, false, this);
- } else {
- cr.unregisterContentObserver(this);
- }
- }
-
- @Override
- public void onChange(boolean selfChange, Uri uri) {
- super.onChange(selfChange, uri);
- if (VIBRATE_WHEN_RINGING_URI.equals(uri)) {
- updateState(mPreference);
- }
- }
- }
-
- private boolean isRampingRingerEnabled() {
- return DeviceConfig.getBoolean(
- DeviceConfig.NAMESPACE_TELEPHONY, RAMPING_RINGER_ENABLED, false);
- }
-
-}
diff --git a/src/com/android/settings/sound/VibrateForCallsPreferenceController.java b/src/com/android/settings/sound/VibrateForCallsPreferenceController.java
new file mode 100644
index 0000000..31abd8a
--- /dev/null
+++ b/src/com/android/settings/sound/VibrateForCallsPreferenceController.java
@@ -0,0 +1,66 @@
+/*
+ * 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.sound;
+
+import android.content.Context;
+import android.provider.DeviceConfig;
+import android.provider.Settings;
+
+import androidx.annotation.VisibleForTesting;
+
+import com.android.settings.R;
+import com.android.settings.Utils;
+import com.android.settings.core.BasePreferenceController;
+
+/**
+ * Controller for vibrate for calls settings.
+ */
+public class VibrateForCallsPreferenceController extends BasePreferenceController {
+
+ private static final int ON = 1;
+ private static final int OFF = 0;
+ @VisibleForTesting
+ static final String RAMPING_RINGER_ENABLED = "ramping_ringer_enabled";
+
+ public VibrateForCallsPreferenceController(Context context, String preferenceKey) {
+ super(context, preferenceKey);
+ }
+
+ @Override
+ @AvailabilityStatus
+ public int getAvailabilityStatus() {
+ return Utils.isVoiceCapable(mContext) && !DeviceConfig.getBoolean(
+ DeviceConfig.NAMESPACE_TELEPHONY, RAMPING_RINGER_ENABLED, false)
+ ? AVAILABLE
+ : UNSUPPORTED_ON_DEVICE;
+ }
+
+ @Override
+ public CharSequence getSummary() {
+ if (Settings.Global.getInt(
+ mContext.getContentResolver(),
+ Settings.Global.APPLY_RAMPING_RINGER, OFF) == ON) {
+ return mContext.getText(R.string.vibrate_when_ringing_option_ramping_ringer);
+ } else if (Settings.System.getInt(
+ mContext.getContentResolver(),
+ Settings.System.VIBRATE_WHEN_RINGING, OFF) == ON) {
+ return mContext.getText(R.string.vibrate_when_ringing_option_always_vibrate);
+ } else {
+ return mContext.getText(R.string.vibrate_when_ringing_option_never_vibrate);
+ }
+ }
+}
diff --git a/src/com/android/settings/sound/VibrateForCallsPreferenceFragment.java b/src/com/android/settings/sound/VibrateForCallsPreferenceFragment.java
new file mode 100644
index 0000000..73b9f2f
--- /dev/null
+++ b/src/com/android/settings/sound/VibrateForCallsPreferenceFragment.java
@@ -0,0 +1,167 @@
+/*
+ * 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.sound;
+
+import android.app.settings.SettingsEnums;
+import android.content.Context;
+import android.graphics.drawable.Drawable;
+import android.provider.Settings;
+import android.text.TextUtils;
+import android.util.ArrayMap;
+import android.util.Log;
+
+import androidx.annotation.VisibleForTesting;
+
+import com.android.settings.R;
+import com.android.settings.widget.RadioButtonPickerFragment;
+import com.android.settingslib.widget.CandidateInfo;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Fragment for changing vibrate for calls options.
+ */
+public class VibrateForCallsPreferenceFragment extends RadioButtonPickerFragment {
+ private static final String TAG = "VibrateForCallsPreferenceFragment";
+
+ @VisibleForTesting
+ static final String KEY_NEVER_VIBRATE = "never_vibrate";
+ @VisibleForTesting
+ static final String KEY_ALWAYS_VIBRATE = "always_vibrate";
+ @VisibleForTesting
+ static final String KEY_RAMPING_RINGER = "ramping_ringer";
+
+ private static final int ON = 1;
+ private static final int OFF = 0;
+
+ private final Map<String, VibrateForCallsCandidateInfo> mCandidates;
+
+ public VibrateForCallsPreferenceFragment() {
+ mCandidates = new ArrayMap<>();
+ }
+
+ @Override
+ public void onAttach(Context context) {
+ super.onAttach(context);
+ loadCandidates(context);
+ }
+
+ private void loadCandidates(Context context) {
+ mCandidates.put(KEY_NEVER_VIBRATE,
+ new VibrateForCallsCandidateInfo(
+ KEY_NEVER_VIBRATE, R.string.vibrate_when_ringing_option_never_vibrate));
+ mCandidates.put(KEY_ALWAYS_VIBRATE,
+ new VibrateForCallsCandidateInfo(
+ KEY_ALWAYS_VIBRATE, R.string.vibrate_when_ringing_option_always_vibrate));
+ mCandidates.put(KEY_RAMPING_RINGER,
+ new VibrateForCallsCandidateInfo(
+ KEY_RAMPING_RINGER, R.string.vibrate_when_ringing_option_ramping_ringer));
+ }
+
+ private void updateSettings(VibrateForCallsCandidateInfo candidate) {
+ final String key = candidate.getKey();
+ if (TextUtils.equals(key, KEY_ALWAYS_VIBRATE)) {
+ Settings.System.putInt(
+ getContext().getContentResolver(), Settings.System.VIBRATE_WHEN_RINGING, ON);
+ Settings.Global.putInt(
+ getContext().getContentResolver(), Settings.Global.APPLY_RAMPING_RINGER, OFF);
+ } else if (TextUtils.equals(key, KEY_RAMPING_RINGER)) {
+ Settings.System.putInt(
+ getContext().getContentResolver(), Settings.System.VIBRATE_WHEN_RINGING, OFF);
+ Settings.Global.putInt(
+ getContext().getContentResolver(), Settings.Global.APPLY_RAMPING_RINGER, ON);
+ } else {
+ Settings.System.putInt(
+ getContext().getContentResolver(), Settings.System.VIBRATE_WHEN_RINGING, OFF);
+ Settings.Global.putInt(
+ getContext().getContentResolver(), Settings.Global.APPLY_RAMPING_RINGER, OFF);
+ }
+ }
+
+ @Override
+ protected List<? extends CandidateInfo> getCandidates() {
+ final List<VibrateForCallsCandidateInfo> candidates = new ArrayList<>();
+ candidates.add(mCandidates.get(KEY_NEVER_VIBRATE));
+ candidates.add(mCandidates.get(KEY_ALWAYS_VIBRATE));
+ candidates.add(mCandidates.get(KEY_RAMPING_RINGER));
+ return candidates;
+ }
+
+ @Override
+ protected String getDefaultKey() {
+ if (Settings.Global.getInt(
+ getContext().getContentResolver(),
+ Settings.Global.APPLY_RAMPING_RINGER, OFF) == ON) {
+ return KEY_RAMPING_RINGER;
+ } else if (Settings.System.getInt(
+ getContext().getContentResolver(),
+ Settings.System.VIBRATE_WHEN_RINGING, OFF) == ON) {
+ return KEY_ALWAYS_VIBRATE;
+ } else {
+ return KEY_NEVER_VIBRATE;
+ }
+ }
+
+ @Override
+ protected boolean setDefaultKey(String key) {
+ final VibrateForCallsCandidateInfo candidate = mCandidates.get(key);
+ if (candidate == null) {
+ Log.e(TAG, "Unknown vibrate for calls candidate (key = " + key + ")!");
+ return false;
+ }
+ updateSettings(candidate);
+ return true;
+ }
+
+ @Override
+ protected int getPreferenceScreenResId() {
+ return R.xml.vibrate_for_calls_settings;
+ }
+
+ @Override
+ public int getMetricsCategory() {
+ return SettingsEnums.VIBRATE_FOR_CALLS;
+ }
+
+ @VisibleForTesting
+ class VibrateForCallsCandidateInfo extends CandidateInfo {
+ private final String mKey;
+ private final int mLabelId;
+
+ VibrateForCallsCandidateInfo(String key, int labelId) {
+ super(true /* enabled */);
+ mKey = key;
+ mLabelId = labelId;
+ }
+
+ @Override
+ public CharSequence loadLabel() {
+ return getContext().getString(mLabelId);
+ }
+
+ @Override
+ public Drawable loadIcon() {
+ return null;
+ }
+
+ @Override
+ public String getKey() {
+ return mKey;
+ }
+ }
+}
diff --git a/tests/robotests/src/com/android/settings/notification/VibrateWhenRingPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/notification/VibrateWhenRingPreferenceControllerTest.java
deleted file mode 100644
index ec275c1..0000000
--- a/tests/robotests/src/com/android/settings/notification/VibrateWhenRingPreferenceControllerTest.java
+++ /dev/null
@@ -1,232 +0,0 @@
-/*
- * Copyright (C) 2016 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.System.VIBRATE_WHEN_RINGING;
-
-import static com.android.settings.core.BasePreferenceController.AVAILABLE;
-import static com.android.settings.core.BasePreferenceController.UNSUPPORTED_ON_DEVICE;
-
-import static com.google.common.truth.Truth.assertThat;
-
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.when;
-
-import android.content.ContentResolver;
-import android.content.Context;
-import android.provider.DeviceConfig;
-import android.provider.Settings;
-import android.telephony.TelephonyManager;
-
-import androidx.preference.Preference;
-import androidx.preference.PreferenceScreen;
-import androidx.preference.TwoStatePreference;
-
-import com.android.settings.testutils.shadow.ShadowDeviceConfig;
-
-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.annotation.Config;
-import org.robolectric.shadow.api.Shadow;
-import org.robolectric.shadows.ShadowContentResolver;
-
-@RunWith(RobolectricTestRunner.class)
-@Config(shadows={ShadowDeviceConfig.class})
-public class VibrateWhenRingPreferenceControllerTest {
-
- private static final String KEY_VIBRATE_WHEN_RINGING = "vibrate_when_ringing";
- private final int DEFAULT_VALUE = 0;
- private final int NOTIFICATION_VIBRATE_WHEN_RINGING = 1;
- private Context mContext;
- private ContentResolver mContentResolver;
- @Mock
- private PreferenceScreen mScreen;
- @Mock
- private TelephonyManager mTelephonyManager;
- private VibrateWhenRingPreferenceController mController;
- private Preference mPreference;
-
- @Before
- public void setUp() {
- MockitoAnnotations.initMocks(this);
- mContext = spy(RuntimeEnvironment.application);
- mContentResolver = mContext.getContentResolver();
- when(mContext.getSystemService(Context.TELEPHONY_SERVICE)).thenReturn(mTelephonyManager);
- mController = new VibrateWhenRingPreferenceController(mContext, KEY_VIBRATE_WHEN_RINGING);
- mPreference = new Preference(mContext);
- mPreference.setKey(mController.getPreferenceKey());
- when(mScreen.findPreference(mPreference.getKey())).thenReturn(mPreference);
- }
-
- @Test
- public void display_shouldDisplay() {
- when(mTelephonyManager.isVoiceCapable()).thenReturn(true);
- DeviceConfig.setProperty("telephony", "ramping_ringer_enabled", "false", false);
- mController.displayPreference(mScreen);
- assertThat(mPreference.isVisible()).isTrue();
- }
-
- @Test
- public void display_shouldNotDisplay_notVoiceCapable() {
- when(mTelephonyManager.isVoiceCapable()).thenReturn(false);
- DeviceConfig.setProperty("telephony", "ramping_ringer_enabled", "false", false);
- mController.displayPreference(mScreen);
- assertThat(mPreference.isVisible()).isFalse();
- }
-
- @Test
- public void display_shouldNotDisplay_RampingRingerEnabled() {
- when(mTelephonyManager.isVoiceCapable()).thenReturn(true);
- DeviceConfig.setProperty("telephony", "ramping_ringer_enabled", "true", false);
- mController.displayPreference(mScreen);
- assertThat(mPreference.isVisible()).isFalse();
- }
-
- @Test
- public void display_shouldNotDisplay_VoiceEnabled_RampingRingerEnabled() {
- when(mTelephonyManager.isVoiceCapable()).thenReturn(true);
- DeviceConfig.setProperty("telephony", "ramping_ringer_enabled", "true", false);
- mController.displayPreference(mScreen);
- assertThat(mPreference.isVisible()).isFalse();
- }
-
- @Test
- public void display_shouldNotDisplay_VoiceDisabled_RampingRingerEnabled() {
- when(mTelephonyManager.isVoiceCapable()).thenReturn(false);
- DeviceConfig.setProperty("telephony", "ramping_ringer_enabled", "true", false);
- mController.displayPreference(mScreen);
- assertThat(mPreference.isVisible()).isFalse();
- }
-
- @Test
- public void testOnPreferenceChange_turnOn_returnOn() {
- mController.onPreferenceChange(null, true);
- final int mode = Settings.System.getInt(mContext.getContentResolver(),
- VIBRATE_WHEN_RINGING, DEFAULT_VALUE);
-
- assertThat(mode).isEqualTo(NOTIFICATION_VIBRATE_WHEN_RINGING);
- }
-
- @Test
- public void testOnPreferenceChange_turnOff_returnOff() {
- mController.onPreferenceChange(null, false);
- final int mode = Settings.System.getInt(mContext.getContentResolver(),
- VIBRATE_WHEN_RINGING, DEFAULT_VALUE);
-
- assertThat(mode).isEqualTo(DEFAULT_VALUE);
- }
-
- @Test
- public void voiceCapable_availabled() {
- when(mTelephonyManager.isVoiceCapable()).thenReturn(true);
- DeviceConfig.setProperty("telephony", "ramping_ringer_enabled", "false", false);
- assertThat(mController.getAvailabilityStatus()).isEqualTo(AVAILABLE);
- }
-
- @Test
- public void voiceCapable_notAvailabled() {
- when(mTelephonyManager.isVoiceCapable()).thenReturn(false);
- DeviceConfig.setProperty("telephony", "ramping_ringer_enabled", "false", false);
- assertThat(mController.getAvailabilityStatus()).isEqualTo(UNSUPPORTED_ON_DEVICE);
- }
-
- @Test
- public void updateState_settingIsOn_preferenceShouldBeChecked() {
- final TwoStatePreference preference = mock(TwoStatePreference.class);
- Settings.System.putInt(mContext.getContentResolver(), VIBRATE_WHEN_RINGING, 1);
-
- mController.updateState(preference);
-
- assertThat(mController.isChecked()).isTrue();
- }
-
- @Test
- public void updateState_settingIsOff_preferenceShouldNotBeChecked() {
- final TwoStatePreference preference = mock(TwoStatePreference.class);
- Settings.System.putInt(mContext.getContentResolver(), VIBRATE_WHEN_RINGING, 0);
-
- mController.updateState(preference);
-
- assertThat(mController.isChecked()).isFalse();
- }
-
- @Test
- public void setChecked_settingsIsOn() {
- mController.setChecked(true);
- final int mode = Settings.System.getInt(mContext.getContentResolver(), VIBRATE_WHEN_RINGING,
- -1);
-
- assertThat(mode).isEqualTo(NOTIFICATION_VIBRATE_WHEN_RINGING);
- }
-
- @Test
- public void setChecked_settingsIsOff() {
- mController.setChecked(false);
- final int mode = Settings.System.getInt(mContext.getContentResolver(), VIBRATE_WHEN_RINGING,
- -1);
-
- assertThat(mode).isEqualTo(DEFAULT_VALUE);
- }
-
- @Test
- public void testObserver_onResume_shouldRegisterObserver() {
- final ShadowContentResolver shadowContentResolver = Shadow.extract(mContentResolver);
- mController.displayPreference(mScreen);
-
- mController.onResume();
-
- assertThat(shadowContentResolver.getContentObservers(
- Settings.System.getUriFor(VIBRATE_WHEN_RINGING))).isNotEmpty();
- }
-
- @Test
- public void testObserver_onPause_shouldUnregisterObserver() {
- final ShadowContentResolver shadowContentResolver = Shadow.extract(mContentResolver);
- mController.displayPreference(mScreen);
-
- mController.onResume();
- mController.onPause();
-
- assertThat(shadowContentResolver.getContentObservers(
- Settings.System.getUriFor(VIBRATE_WHEN_RINGING))).isEmpty();
- }
-
- @Test
- public void isSliceableCorrectKey_returnsTrue() {
- final VibrateWhenRingPreferenceController controller =
- new VibrateWhenRingPreferenceController(mContext, "vibrate_when_ringing");
- assertThat(controller.isSliceable()).isTrue();
- }
-
- @Test
- public void isSliceableIncorrectKey_returnsFalse() {
- final VibrateWhenRingPreferenceController controller =
- new VibrateWhenRingPreferenceController(mContext, "bad_key");
- assertThat(controller.isSliceable()).isFalse();
- }
-
- @Test
- public void isPublicSlice_returnTrue() {
- assertThat(mController.isPublicSlice()).isTrue();
- }
-}
diff --git a/tests/robotests/src/com/android/settings/sound/VibrateForCallsPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/sound/VibrateForCallsPreferenceControllerTest.java
new file mode 100644
index 0000000..bf2b0f3
--- /dev/null
+++ b/tests/robotests/src/com/android/settings/sound/VibrateForCallsPreferenceControllerTest.java
@@ -0,0 +1,120 @@
+/*
+ * 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.sound;
+
+import static com.android.settings.core.BasePreferenceController.AVAILABLE;
+import static com.android.settings.core.BasePreferenceController.UNSUPPORTED_ON_DEVICE;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.when;
+
+import android.content.ContentResolver;
+import android.content.Context;
+import android.provider.DeviceConfig;
+import android.provider.Settings;
+import android.telephony.TelephonyManager;
+
+import com.android.settings.R;
+import com.android.settings.testutils.shadow.ShadowDeviceConfig;
+
+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.annotation.Config;
+
+@RunWith(RobolectricTestRunner.class)
+@Config(shadows = {ShadowDeviceConfig.class})
+public class VibrateForCallsPreferenceControllerTest {
+
+ private static final int OFF = 0;
+ private static final int ON = 1;
+ private Context mContext;
+ private ContentResolver mContentResolver;
+ @Mock
+ private TelephonyManager mTelephonyManager;
+ private VibrateForCallsPreferenceController mController;
+
+ @Before
+ public void setUp() {
+ MockitoAnnotations.initMocks(this);
+ mContext = spy(RuntimeEnvironment.application);
+ mContentResolver = mContext.getContentResolver();
+ when(mContext.getSystemService(Context.TELEPHONY_SERVICE)).thenReturn(mTelephonyManager);
+ mController = new VibrateForCallsPreferenceController(
+ mContext, VibrateForCallsPreferenceController.RAMPING_RINGER_ENABLED);
+ }
+
+ @Test
+ public void getAvailabilityStatus_notVoiceCapable_returnUnsupportedOnDevice() {
+ when(mTelephonyManager.isVoiceCapable()).thenReturn(false);
+ DeviceConfig.setProperty(DeviceConfig.NAMESPACE_TELEPHONY,
+ VibrateForCallsPreferenceController.RAMPING_RINGER_ENABLED, "false", false);
+
+ assertThat(mController.getAvailabilityStatus()).isEqualTo(UNSUPPORTED_ON_DEVICE);
+ }
+
+ @Test
+ public void getAvailabilityStatus_rampingRingerEnabled_returnUnsupportedOnDevice() {
+ when(mTelephonyManager.isVoiceCapable()).thenReturn(true);
+ DeviceConfig.setProperty(DeviceConfig.NAMESPACE_TELEPHONY,
+ VibrateForCallsPreferenceController.RAMPING_RINGER_ENABLED, "true", false);
+
+ assertThat(mController.getAvailabilityStatus()).isEqualTo(UNSUPPORTED_ON_DEVICE);
+ }
+
+ @Test
+ public void getAvailabilityStatus_voiceCapableAndRampingRingerDisabled_returnAvailable() {
+ when(mTelephonyManager.isVoiceCapable()).thenReturn(true);
+ DeviceConfig.setProperty(DeviceConfig.NAMESPACE_TELEPHONY,
+ VibrateForCallsPreferenceController.RAMPING_RINGER_ENABLED, "false", false);
+
+ assertThat(mController.getAvailabilityStatus()).isEqualTo(AVAILABLE);
+ }
+
+ @Test
+ public void getSummary_applyRampingRinger_rampingRingerSummary() {
+ Settings.System.putInt(mContentResolver, Settings.System.VIBRATE_WHEN_RINGING, OFF);
+ Settings.Global.putInt(mContentResolver, Settings.Global.APPLY_RAMPING_RINGER, ON);
+
+ assertThat(mController.getSummary()).isEqualTo(
+ mContext.getText(R.string.vibrate_when_ringing_option_ramping_ringer));
+ }
+
+ @Test
+ public void getSummary_enableVibrateWhenRinging_alwaysVibrateSummary() {
+ Settings.System.putInt(mContentResolver, Settings.System.VIBRATE_WHEN_RINGING, ON);
+ Settings.Global.putInt(mContentResolver, Settings.Global.APPLY_RAMPING_RINGER, OFF);
+
+ assertThat(mController.getSummary()).isEqualTo(
+ mContext.getText(R.string.vibrate_when_ringing_option_always_vibrate));
+ }
+
+ @Test
+ public void getSummary_notApplyRampingRingerDisableVibrateWhenRinging_neverVibrateSummary() {
+ Settings.System.putInt(mContentResolver, Settings.System.VIBRATE_WHEN_RINGING, OFF);
+ Settings.Global.putInt(mContentResolver, Settings.Global.APPLY_RAMPING_RINGER, OFF);
+
+ assertThat(mController.getSummary()).isEqualTo(
+ mContext.getText(R.string.vibrate_when_ringing_option_never_vibrate));
+ }
+}
diff --git a/tests/robotests/src/com/android/settings/sound/VibrateForCallsPreferenceFragmentTest.java b/tests/robotests/src/com/android/settings/sound/VibrateForCallsPreferenceFragmentTest.java
new file mode 100644
index 0000000..0a766d6
--- /dev/null
+++ b/tests/robotests/src/com/android/settings/sound/VibrateForCallsPreferenceFragmentTest.java
@@ -0,0 +1,108 @@
+/*
+ * 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.sound;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.spy;
+
+import android.content.ContentResolver;
+import android.content.Context;
+import android.provider.Settings;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.RuntimeEnvironment;
+
+@RunWith(RobolectricTestRunner.class)
+public class VibrateForCallsPreferenceFragmentTest {
+
+ private static final int OFF = 0;
+ private static final int ON = 1;
+ private Context mContext;
+ private ContentResolver mContentResolver;
+ private VibrateForCallsPreferenceFragment mFragment;
+
+ @Before
+ public void setUp() {
+ mContext = spy(RuntimeEnvironment.application);
+ mContentResolver = mContext.getContentResolver();
+ mFragment = spy(new VibrateForCallsPreferenceFragment());
+ doReturn(mContext).when(mFragment).getContext();
+ mFragment.onAttach(mContext);
+ }
+
+ @Test
+ public void getDefaultKey_applyRampingRinger_keyRampingRinger() {
+ Settings.System.putInt(mContentResolver, Settings.System.VIBRATE_WHEN_RINGING, OFF);
+ Settings.Global.putInt(mContentResolver, Settings.Global.APPLY_RAMPING_RINGER, ON);
+
+ assertThat(mFragment.getDefaultKey()).isEqualTo(
+ VibrateForCallsPreferenceFragment.KEY_RAMPING_RINGER);
+ }
+
+ @Test
+ public void getDefaultKey_enableVibrateWhenRinging_keyAlwaysVibrate() {
+ Settings.System.putInt(mContentResolver, Settings.System.VIBRATE_WHEN_RINGING, ON);
+ Settings.Global.putInt(mContentResolver, Settings.Global.APPLY_RAMPING_RINGER, OFF);
+
+ assertThat(mFragment.getDefaultKey()).isEqualTo(
+ VibrateForCallsPreferenceFragment.KEY_ALWAYS_VIBRATE);
+ }
+
+ @Test
+ public void getDefaultKey_notApplyRampingRingerDisableVibrateWhenRinging_keyNeverVibrate() {
+ Settings.System.putInt(mContentResolver, Settings.System.VIBRATE_WHEN_RINGING, OFF);
+ Settings.Global.putInt(mContentResolver, Settings.Global.APPLY_RAMPING_RINGER, OFF);
+
+ assertThat(mFragment.getDefaultKey()).isEqualTo(
+ VibrateForCallsPreferenceFragment.KEY_NEVER_VIBRATE);
+ }
+
+ @Test
+ public void setDefaultKey_keyRampingRinger_applyRampingRingerDisableVibrateWhenRinging() {
+ mFragment.setDefaultKey(VibrateForCallsPreferenceFragment.KEY_RAMPING_RINGER);
+
+ assertThat(Settings.Global.getInt(
+ mContentResolver, Settings.Global.APPLY_RAMPING_RINGER, OFF)).isEqualTo(ON);
+ assertThat(Settings.System.getInt(
+ mContentResolver, Settings.System.VIBRATE_WHEN_RINGING, OFF)).isEqualTo(OFF);
+ }
+
+ @Test
+ public void setDefaultKey_keyAlwaysVibrate_notApplyRampingRingerEnableVibrateWhenRinging() {
+ mFragment.setDefaultKey(VibrateForCallsPreferenceFragment.KEY_ALWAYS_VIBRATE);
+
+ assertThat(Settings.Global.getInt(
+ mContentResolver, Settings.Global.APPLY_RAMPING_RINGER, OFF)).isEqualTo(OFF);
+ assertThat(Settings.System.getInt(
+ mContentResolver, Settings.System.VIBRATE_WHEN_RINGING, OFF)).isEqualTo(ON);
+ }
+
+ @Test
+ public void setDefaultKey_keyNeverVibrate_notApplyRampingRingerDisableVibrateWhenRinging() {
+ mFragment.setDefaultKey(VibrateForCallsPreferenceFragment.KEY_NEVER_VIBRATE);
+
+ assertThat(Settings.Global.getInt(
+ mContentResolver, Settings.Global.APPLY_RAMPING_RINGER, OFF)).isEqualTo(OFF);
+ assertThat(Settings.System.getInt(
+ mContentResolver, Settings.System.VIBRATE_WHEN_RINGING, OFF)).isEqualTo(OFF);
+ }
+}