diff --git a/res/values/strings.xml b/res/values/strings.xml index eede918526c..9ee199a58d4 100644 --- a/res/values/strings.xml +++ b/res/values/strings.xml @@ -7572,6 +7572,15 @@ Vibrate for calls + + Never vibrate + + + Always vibrate + + + Vibrate first then ring gradually + Other sounds diff --git a/res/xml/sound_settings.xml b/res/xml/sound_settings.xml index d82a3242f79..a24a95f99a7 100644 --- a/res/xml/sound_settings.xml +++ b/res/xml/sound_settings.xml @@ -88,11 +88,12 @@ settings:controller="com.android.settings.notification.NotificationVolumePreferenceController"/> - + android:order="-130" + settings:controller="com.android.settings.sound.VibrateForCallsPreferenceController"/> + + + diff --git a/src/com/android/settings/notification/VibrateWhenRingPreferenceController.java b/src/com/android/settings/notification/VibrateWhenRingPreferenceController.java deleted file mode 100644 index 503b5bc0a83..00000000000 --- 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 00000000000..31abd8a4534 --- /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 00000000000..73b9f2fbd8e --- /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 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 getCandidates() { + final List 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 ec275c1c6ae..00000000000 --- 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 00000000000..bf2b0f36bb8 --- /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 00000000000..0a766d68414 --- /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); + } +}