This preference is controlled by the setting key{@link Settings.System#VIBRATE_ON}, and it + * will disable the entire settings screen once the settings is turned OFF. All device haptics will + * be disabled by this setting, except the flagged alerts and accessibility touch feedback. + */ +public class VibrationMainSwitchPreferenceController extends SettingsMainSwitchPreferenceController + implements LifecycleObserver, OnStart, OnStop { + + private final ContentObserver mSettingObserver; + + public VibrationMainSwitchPreferenceController(Context context, String preferenceKey) { + super(context, preferenceKey); + mSettingObserver = new ContentObserver(new Handler(/* async= */ true)) { + @Override + public void onChange(boolean selfChange, Uri uri) { + updateState(mSwitchPreference); + } + }; + } + + @Override + public int getAvailabilityStatus() { + return AVAILABLE; + } + + @Override + public void onStart() { + mContext.getContentResolver().registerContentObserver( + Settings.System.getUriFor(VibrationPreferenceConfig.MAIN_SWITCH_SETTING_KEY), + /* notifyForDescendants= */ false, + mSettingObserver); + } + + @Override + public void onStop() { + mContext.getContentResolver().unregisterContentObserver(mSettingObserver); + } + + @Override + public boolean isChecked() { + return VibrationPreferenceConfig.isMainVibrationSwitchEnabled( + mContext.getContentResolver()); + } + + @Override + public boolean setChecked(boolean isChecked) { + return Settings.System.putInt(mContext.getContentResolver(), + VibrationPreferenceConfig.MAIN_SWITCH_SETTING_KEY, + isChecked ? ON : OFF); + } + + @Override + public int getSliceHighlightMenuRes() { + return R.string.menu_key_accessibility; + } +} diff --git a/src/com/android/settings/accessibility/VibrationPreferenceConfig.java b/src/com/android/settings/accessibility/VibrationPreferenceConfig.java index aa59554b64a..1b0b1635456 100644 --- a/src/com/android/settings/accessibility/VibrationPreferenceConfig.java +++ b/src/com/android/settings/accessibility/VibrationPreferenceConfig.java @@ -16,6 +16,8 @@ package com.android.settings.accessibility; +import static com.android.settings.accessibility.AccessibilityUtil.State.ON; + import android.content.ContentResolver; import android.content.Context; import android.database.ContentObserver; @@ -36,12 +38,23 @@ import com.android.settingslib.core.AbstractPreferenceController; */ public abstract class VibrationPreferenceConfig { + /** + * SettingsProvider key for the main "Vibration & haptics" toggle preference, that can disable + * all device vibrations. + */ + public static final String MAIN_SWITCH_SETTING_KEY = Settings.System.VIBRATE_ON; + protected final ContentResolver mContentResolver; private final Vibrator mVibrator; private final String mSettingKey; private final int mDefaultIntensity; private final VibrationAttributes mVibrationAttributes; + /** Returns true if the user setting for enabling device vibrations is enabled. */ + public static boolean isMainVibrationSwitchEnabled(ContentResolver contentResolver) { + return Settings.System.getInt(contentResolver, MAIN_SWITCH_SETTING_KEY, ON) == ON; + } + public VibrationPreferenceConfig(Context context, String settingKey, int vibrationUsage) { mContentResolver = context.getContentResolver(); mVibrator = context.getSystemService(Vibrator.class); @@ -52,11 +65,16 @@ public abstract class VibrationPreferenceConfig { .build(); } - /** Return the setting key for this setting preference. */ + /** Returns the setting key for this setting preference. */ public String getSettingKey() { return mSettingKey; } + /** Returns true if this setting preference is enabled for user update. */ + public boolean isPreferenceEnabled() { + return isMainVibrationSwitchEnabled(mContentResolver); + } + /** Returns the default intensity to be displayed when the setting value is not set. */ public int getDefaultIntensity() { return mDefaultIntensity; @@ -80,6 +98,9 @@ public abstract class VibrationPreferenceConfig { /** {@link ContentObserver} for a setting described by a {@link VibrationPreferenceConfig}. */ public static final class SettingObserver extends ContentObserver { + private static final Uri MAIN_SWITCH_SETTING_URI = + Settings.System.getUriFor(MAIN_SWITCH_SETTING_KEY); + private final Uri mUri; private AbstractPreferenceController mPreferenceController; private Preference mPreference; @@ -92,7 +113,11 @@ public abstract class VibrationPreferenceConfig { @Override public void onChange(boolean selfChange, Uri uri) { - if (mUri.equals(uri) && mPreferenceController != null && mPreference != null) { + if (mPreferenceController == null || mPreference == null) { + // onDisplayPreference not triggered yet, nothing to update. + return; + } + if (mUri.equals(uri) || MAIN_SWITCH_SETTING_URI.equals(uri)) { mPreferenceController.updateState(mPreference); } } @@ -103,6 +128,8 @@ public abstract class VibrationPreferenceConfig { */ public void register(ContentResolver contentResolver) { contentResolver.registerContentObserver(mUri, /* notifyForDescendants= */ false, this); + contentResolver.registerContentObserver(MAIN_SWITCH_SETTING_URI, + /* notifyForDescendants= */ false, this); } /** diff --git a/src/com/android/settings/accessibility/VibrationRampingRingerTogglePreferenceController.java b/src/com/android/settings/accessibility/VibrationRampingRingerTogglePreferenceController.java index 21a5e36d25f..37a0257cb20 100644 --- a/src/com/android/settings/accessibility/VibrationRampingRingerTogglePreferenceController.java +++ b/src/com/android/settings/accessibility/VibrationRampingRingerTogglePreferenceController.java @@ -21,7 +21,6 @@ import android.database.ContentObserver; import android.media.AudioManager; import android.net.Uri; import android.os.Handler; -import android.os.VibrationAttributes; import android.os.Vibrator; import android.provider.DeviceConfig; import android.provider.Settings; @@ -57,8 +56,9 @@ public class VibrationRampingRingerTogglePreferenceController private final DeviceConfigProvider mDeviceConfigProvider; private final ContentObserver mSettingObserver; - private final Vibrator mVibrator; private final AudioManager mAudioManager; + private final VibrationPreferenceConfig mRingVibrationPreferenceConfig; + private final VibrationPreferenceConfig.SettingObserver mRingSettingObserver; private Preference mPreference; @@ -70,8 +70,10 @@ public class VibrationRampingRingerTogglePreferenceController String preferenceKey, DeviceConfigProvider deviceConfigProvider) { super(context, preferenceKey); mDeviceConfigProvider = deviceConfigProvider; - mVibrator = context.getSystemService(Vibrator.class); mAudioManager = context.getSystemService(AudioManager.class); + mRingVibrationPreferenceConfig = new RingVibrationPreferenceConfig(context); + mRingSettingObserver = new VibrationPreferenceConfig.SettingObserver( + mRingVibrationPreferenceConfig); mSettingObserver = new ContentObserver(new Handler(/* async= */ true)) { @Override public void onChange(boolean selfChange, Uri uri) { @@ -91,18 +93,16 @@ public class VibrationRampingRingerTogglePreferenceController @Override public void onStart() { + mRingSettingObserver.register(mContext.getContentResolver()); mContext.getContentResolver().registerContentObserver( Settings.System.getUriFor(Settings.System.APPLY_RAMPING_RINGER), /* notifyForDescendants= */ false, mSettingObserver); - mContext.getContentResolver().registerContentObserver( - Settings.System.getUriFor(Settings.System.RING_VIBRATION_INTENSITY), - /* notifyForDescendants= */ false, - mSettingObserver); } @Override public void onStop() { + mRingSettingObserver.unregister(mContext.getContentResolver()); mContext.getContentResolver().unregisterContentObserver(mSettingObserver); } @@ -110,6 +110,7 @@ public class VibrationRampingRingerTogglePreferenceController public void displayPreference(PreferenceScreen screen) { super.displayPreference(screen); mPreference = screen.findPreference(getPreferenceKey()); + mRingSettingObserver.onDisplayPreference(this, mPreference); mPreference.setEnabled(isRingVibrationEnabled()); } @@ -141,9 +142,8 @@ public class VibrationRampingRingerTogglePreferenceController } private boolean isRingVibrationEnabled() { - final int ringIntensity = Settings.System.getInt(mContext.getContentResolver(), - Settings.System.RING_VIBRATION_INTENSITY, - mVibrator.getDefaultVibrationIntensity(VibrationAttributes.USAGE_RINGTONE)); - return ringIntensity != Vibrator.VIBRATION_INTENSITY_OFF; + return mRingVibrationPreferenceConfig.isPreferenceEnabled() + && (mRingVibrationPreferenceConfig.readIntensity() + != Vibrator.VIBRATION_INTENSITY_OFF); } } diff --git a/src/com/android/settings/accessibility/VibrationTogglePreferenceController.java b/src/com/android/settings/accessibility/VibrationTogglePreferenceController.java index 5278b662b36..8f158cc04b5 100644 --- a/src/com/android/settings/accessibility/VibrationTogglePreferenceController.java +++ b/src/com/android/settings/accessibility/VibrationTogglePreferenceController.java @@ -58,16 +58,29 @@ public abstract class VibrationTogglePreferenceController extends TogglePreferen super.displayPreference(screen); final Preference preference = screen.findPreference(getPreferenceKey()); mSettingsContentObserver.onDisplayPreference(this, preference); + preference.setEnabled(mPreferenceConfig.isPreferenceEnabled()); + } + + @Override + public void updateState(Preference preference) { + super.updateState(preference); + if (preference != null) { + preference.setEnabled(mPreferenceConfig.isPreferenceEnabled()); + } } @Override public boolean isChecked() { - final int position = mPreferenceConfig.readIntensity(); - return position != Vibrator.VIBRATION_INTENSITY_OFF; + return mPreferenceConfig.isPreferenceEnabled() + && (mPreferenceConfig.readIntensity() != Vibrator.VIBRATION_INTENSITY_OFF); } @Override public boolean setChecked(boolean isChecked) { + if (!mPreferenceConfig.isPreferenceEnabled()) { + // Ignore toggle updates when the preference is disabled. + return false; + } final int newIntensity = isChecked ? mPreferenceConfig.getDefaultIntensity() : Vibrator.VIBRATION_INTENSITY_OFF; diff --git a/tests/robotests/src/com/android/settings/accessibility/VibrationIntensityPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/accessibility/VibrationIntensityPreferenceControllerTest.java index ba48f66e899..048bce4c37a 100644 --- a/tests/robotests/src/com/android/settings/accessibility/VibrationIntensityPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/accessibility/VibrationIntensityPreferenceControllerTest.java @@ -38,11 +38,14 @@ import org.mockito.Mock; import org.mockito.MockitoAnnotations; import org.robolectric.RobolectricTestRunner; +/** Tests for {@link VibrationIntensityPreferenceController}. */ @RunWith(RobolectricTestRunner.class) public class VibrationIntensityPreferenceControllerTest { private static final String SETTING_KEY = Settings.System.NOTIFICATION_VIBRATION_INTENSITY; private static final int VIBRATION_USAGE = VibrationAttributes.USAGE_NOTIFICATION; + private static final int OFF = 0; + private static final int ON = 1; /** Basic implementation of preference controller to test generic behavior. */ private static class TestPreferenceController extends VibrationIntensityPreferenceController { @@ -77,12 +80,33 @@ public class VibrationIntensityPreferenceControllerTest { @Test public void missingSetting_shouldReturnDefault() { VibrationIntensityPreferenceController controller = createPreferenceController(3); - Settings.System.putString(mContext.getContentResolver(), SETTING_KEY, null); + Settings.System.putString(mContext.getContentResolver(), SETTING_KEY, /* value= */ null); controller.updateState(mPreference); assertThat(mPreference.getProgress()) .isEqualTo(mVibrator.getDefaultVibrationIntensity(VIBRATION_USAGE)); } + @Test + public void updateState_mainSwitchUpdates_shouldPreserveSettingBetweenUpdates() { + VibrationIntensityPreferenceController controller = createPreferenceController(3); + updateSetting(SETTING_KEY, Vibrator.VIBRATION_INTENSITY_LOW); + + updateSetting(VibrationPreferenceConfig.MAIN_SWITCH_SETTING_KEY, ON); + controller.updateState(mPreference); + assertThat(mPreference.getProgress()).isEqualTo(Vibrator.VIBRATION_INTENSITY_LOW); + assertThat(mPreference.isEnabled()).isTrue(); + + updateSetting(VibrationPreferenceConfig.MAIN_SWITCH_SETTING_KEY, OFF); + controller.updateState(mPreference); + assertThat(mPreference.getProgress()).isEqualTo(Vibrator.VIBRATION_INTENSITY_OFF); + assertThat(mPreference.isEnabled()).isFalse(); + + updateSetting(VibrationPreferenceConfig.MAIN_SWITCH_SETTING_KEY, ON); + controller.updateState(mPreference); + assertThat(mPreference.getProgress()).isEqualTo(Vibrator.VIBRATION_INTENSITY_LOW); + assertThat(mPreference.isEnabled()).isTrue(); + } + @Test public void updateState_allLevelsSupported_shouldDisplayIntensityInSliderPosition() { VibrationIntensityPreferenceController controller = createPreferenceController(3); @@ -146,6 +170,22 @@ public class VibrationIntensityPreferenceControllerTest { assertThat(mPreference.getProgress()).isEqualTo(Vibrator.VIBRATION_INTENSITY_OFF); } + @Test + public void setProgress_mainSwitchDisabled_ignoresUpdates() throws Exception { + VibrationIntensityPreferenceController controller = createPreferenceController(3); + updateSetting(SETTING_KEY, Vibrator.VIBRATION_INTENSITY_LOW); + controller.updateState(mPreference); + assertThat(mPreference.getProgress()).isEqualTo(Vibrator.VIBRATION_INTENSITY_LOW); + + updateSetting(VibrationPreferenceConfig.MAIN_SWITCH_SETTING_KEY, OFF); + controller.updateState(mPreference); + assertThat(mPreference.getProgress()).isEqualTo(Vibrator.VIBRATION_INTENSITY_OFF); + assertThat(mPreference.isEnabled()).isFalse(); + + assertThat(controller.setSliderPosition(Vibrator.VIBRATION_INTENSITY_HIGH)).isFalse(); + assertThat(readSetting(SETTING_KEY)).isEqualTo(Vibrator.VIBRATION_INTENSITY_LOW); + assertThat(mPreference.getProgress()).isEqualTo(Vibrator.VIBRATION_INTENSITY_OFF); + } @Test public void setProgress_allSupportedPositions_updatesIntensitySetting() throws Exception { VibrationIntensityPreferenceController controller = createPreferenceController(3); diff --git a/tests/robotests/src/com/android/settings/accessibility/VibrationMainSwitchPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/accessibility/VibrationMainSwitchPreferenceControllerTest.java new file mode 100644 index 00000000000..6f5700347a7 --- /dev/null +++ b/tests/robotests/src/com/android/settings/accessibility/VibrationMainSwitchPreferenceControllerTest.java @@ -0,0 +1,106 @@ +/* + * Copyright (C) 2022 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.accessibility; + +import static com.android.settings.accessibility.AccessibilityUtil.State.OFF; +import static com.android.settings.accessibility.AccessibilityUtil.State.ON; +import static com.android.settings.core.BasePreferenceController.AVAILABLE; + +import static com.google.common.truth.Truth.assertThat; + +import static org.mockito.Mockito.when; + +import android.content.Context; +import android.provider.Settings; + +import androidx.preference.PreferenceScreen; +import androidx.test.core.app.ApplicationProvider; + +import com.android.settingslib.core.lifecycle.Lifecycle; +import com.android.settingslib.widget.MainSwitchPreference; + +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; + +/** Tests for {@link VibrationMainSwitchPreferenceController}. */ +@RunWith(RobolectricTestRunner.class) +public class VibrationMainSwitchPreferenceControllerTest { + + private static final String PREFERENCE_KEY = "preference_key"; + + @Mock private PreferenceScreen mScreen; + + private Lifecycle mLifecycle; + private Context mContext; + private VibrationMainSwitchPreferenceController mController; + private MainSwitchPreference mPreference; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + mLifecycle = new Lifecycle(() -> mLifecycle); + mContext = ApplicationProvider.getApplicationContext(); + mController = new VibrationMainSwitchPreferenceController(mContext, PREFERENCE_KEY); + mLifecycle.addObserver(mController); + mPreference = new MainSwitchPreference(mContext); + mPreference.setTitle("Test title"); + when(mScreen.findPreference(mController.getPreferenceKey())).thenReturn(mPreference); + mController.displayPreference(mScreen); + } + + @Test + public void verifyConstants() { + assertThat(mController.getPreferenceKey()).isEqualTo(PREFERENCE_KEY); + assertThat(mController.getAvailabilityStatus()).isEqualTo(AVAILABLE); + } + + @Test + public void updateState_shouldReturnTheSettingState() { + updateSetting(Settings.System.VIBRATE_ON, ON); + mController.updateState(mPreference); + assertThat(mPreference.isChecked()).isTrue(); + + updateSetting(Settings.System.VIBRATE_ON, OFF); + mController.updateState(mPreference); + assertThat(mPreference.isChecked()).isFalse(); + } + + @Test + public void setChecked_updatesSetting() throws Settings.SettingNotFoundException { + updateSetting(Settings.System.VIBRATE_ON, OFF); + mController.updateState(mPreference); + assertThat(mPreference.isChecked()).isFalse(); + + mController.setChecked(true); + assertThat(readSetting(Settings.System.VIBRATE_ON)).isEqualTo(ON); + + mController.setChecked(false); + assertThat(readSetting(Settings.System.VIBRATE_ON)).isEqualTo(OFF); + } + + private void updateSetting(String key, int value) { + Settings.System.putInt(mContext.getContentResolver(), key, value); + } + + private int readSetting(String settingKey) throws Settings.SettingNotFoundException { + return Settings.System.getInt(mContext.getContentResolver(), settingKey); + } +} diff --git a/tests/robotests/src/com/android/settings/accessibility/VibrationTogglePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/accessibility/VibrationTogglePreferenceControllerTest.java new file mode 100644 index 00000000000..cb4a07e865f --- /dev/null +++ b/tests/robotests/src/com/android/settings/accessibility/VibrationTogglePreferenceControllerTest.java @@ -0,0 +1,172 @@ +/* + * Copyright (C) 2022 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.accessibility; + +import static com.google.common.truth.Truth.assertThat; + +import static org.mockito.Mockito.when; + +import android.content.Context; +import android.os.VibrationAttributes; +import android.os.Vibrator; +import android.provider.Settings; + +import androidx.preference.PreferenceScreen; +import androidx.preference.SwitchPreference; +import androidx.test.core.app.ApplicationProvider; + +import com.android.settingslib.core.lifecycle.Lifecycle; + +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; + +/** Tests for {@link VibrationTogglePreferenceController}. */ +@RunWith(RobolectricTestRunner.class) +public class VibrationTogglePreferenceControllerTest { + + private static final String SETTING_KEY = Settings.System.NOTIFICATION_VIBRATION_INTENSITY; + private static final int VIBRATION_USAGE = VibrationAttributes.USAGE_NOTIFICATION; + private static final int OFF = 0; + private static final int ON = 1; + + /** Basic implementation of preference controller to test generic behavior. */ + private static class TestPreferenceController extends VibrationTogglePreferenceController { + + TestPreferenceController(Context context) { + super(context, "preference_key", + new VibrationPreferenceConfig(context, SETTING_KEY, VIBRATION_USAGE) {}); + } + + @Override + public int getAvailabilityStatus() { + return AVAILABLE; + } + } + + @Mock private PreferenceScreen mScreen; + + private Lifecycle mLifecycle; + private Context mContext; + private Vibrator mVibrator; + private SwitchPreference mPreference; + private VibrationTogglePreferenceController mController; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + mLifecycle = new Lifecycle(() -> mLifecycle); + mContext = ApplicationProvider.getApplicationContext(); + mVibrator = mContext.getSystemService(Vibrator.class); + mController = new TestPreferenceController(mContext); + mLifecycle.addObserver(mController); + mPreference = new SwitchPreference(mContext); + mPreference.setTitle("Test title"); + when(mScreen.findPreference(mController.getPreferenceKey())).thenReturn(mPreference); + mController.displayPreference(mScreen); + } + + @Test + public void missingSetting_shouldBeCheckedByDefault() { + Settings.System.putString(mContext.getContentResolver(), SETTING_KEY, /* value= */ null); + mController.updateState(mPreference); + assertThat(mPreference.isChecked()).isTrue(); + } + + @Test + public void updateState_mainSwitchUpdates_shouldPreserveSettingBetweenUpdates() { + updateSetting(SETTING_KEY, Vibrator.VIBRATION_INTENSITY_LOW); + + updateSetting(VibrationPreferenceConfig.MAIN_SWITCH_SETTING_KEY, ON); + mController.updateState(mPreference); + assertThat(mPreference.isChecked()).isTrue(); + assertThat(mPreference.isEnabled()).isTrue(); + + updateSetting(VibrationPreferenceConfig.MAIN_SWITCH_SETTING_KEY, OFF); + mController.updateState(mPreference); + assertThat(mPreference.isChecked()).isFalse(); + assertThat(mPreference.isEnabled()).isFalse(); + + updateSetting(VibrationPreferenceConfig.MAIN_SWITCH_SETTING_KEY, ON); + mController.updateState(mPreference); + assertThat(mPreference.isChecked()).isTrue(); + assertThat(mPreference.isEnabled()).isTrue(); + } + + @Test + public void updateState_shouldUpdateToggleState() { + updateSetting(SETTING_KEY, Vibrator.VIBRATION_INTENSITY_HIGH); + mController.updateState(mPreference); + assertThat(mPreference.isChecked()).isTrue(); + + updateSetting(SETTING_KEY, Vibrator.VIBRATION_INTENSITY_OFF); + mController.updateState(mPreference); + assertThat(mPreference.isChecked()).isFalse(); + + updateSetting(SETTING_KEY, Vibrator.VIBRATION_INTENSITY_MEDIUM); + mController.updateState(mPreference); + assertThat(mPreference.isChecked()).isTrue(); + + updateSetting(SETTING_KEY, Vibrator.VIBRATION_INTENSITY_OFF); + mController.updateState(mPreference); + assertThat(mPreference.isChecked()).isFalse(); + + updateSetting(SETTING_KEY, Vibrator.VIBRATION_INTENSITY_LOW); + mController.updateState(mPreference); + assertThat(mPreference.isChecked()).isTrue(); + } + + @Test + public void setProgress_mainSwitchDisabled_ignoresUpdates() throws Exception { + updateSetting(SETTING_KEY, Vibrator.VIBRATION_INTENSITY_LOW); + mController.updateState(mPreference); + assertThat(mPreference.isChecked()).isTrue(); + + updateSetting(VibrationPreferenceConfig.MAIN_SWITCH_SETTING_KEY, OFF); + mController.updateState(mPreference); + assertThat(mPreference.isChecked()).isFalse(); + + mController.setChecked(true); + assertThat(readSetting(SETTING_KEY)).isEqualTo(Vibrator.VIBRATION_INTENSITY_LOW); + assertThat(mPreference.isChecked()).isFalse(); + assertThat(mPreference.isEnabled()).isFalse(); + + } + @Test + public void setProgress_updatesCheckedState() throws Exception { + mController.setChecked(false); + assertThat(readSetting(SETTING_KEY)).isEqualTo(Vibrator.VIBRATION_INTENSITY_OFF); + + mController.setChecked(true); + assertThat(readSetting(SETTING_KEY)) + .isEqualTo(mVibrator.getDefaultVibrationIntensity(VIBRATION_USAGE)); + + mController.setChecked(false); + assertThat(readSetting(SETTING_KEY)).isEqualTo(Vibrator.VIBRATION_INTENSITY_OFF); + } + + private void updateSetting(String key, int value) { + Settings.System.putInt(mContext.getContentResolver(), key, value); + } + + private int readSetting(String settingKey) throws Settings.SettingNotFoundException { + return Settings.System.getInt(mContext.getContentResolver(), settingKey); + } +}