From 579a19a7932b044cce3c50e647062c0dda1de126 Mon Sep 17 00:00:00 2001 From: Neil Fuller Date: Mon, 30 May 2022 15:43:17 +0100 Subject: [PATCH] Switch auto time setting to use APIs Switch auto time setting to use TimeManager APIs instead of low-level direct settings access. This makes the AutoTimePreferenceController approach the same as AutoTimeZonePreferenceController. Most of the logic about what to display and whether toggles are enabled is moved to the service. This change has the side effect of adding support in SettingsUI for devices with no auto time detection mechanism configured at all, i.e. the auto time toggle will stop being shown in SettingsUI. There are no known devices that require this currently, but it is a theoretical possibility if config.xml is configured in particular ways. Bug: 172891783 Test: Manual testing with different settings for "time origin priorities" (i.e. empty, non-empty) Test: m ROBOTEST_FILTER=com.android.settings.datetime RunSettingsRoboTests -j40 Change-Id: I4112fb51adb0d06a1dbc39a44ea109d6df899153 --- .../AutoTimePreferenceController.java | 66 ++++++---- .../datetime/DatePreferenceController.java | 26 +++- .../settings/datetime/DateTimeSettings.java | 25 ++-- .../datetime/TimePreferenceController.java | 9 +- .../AutoTimePreferenceControllerTest.java | 122 +++++++++++++++--- .../AutoTimeZonePreferenceControllerTest.java | 44 +++---- .../DatePreferenceControllerTest.java | 35 ++++- .../TimePreferenceControllerTest.java | 12 +- 8 files changed, 244 insertions(+), 95 deletions(-) diff --git a/src/com/android/settings/datetime/AutoTimePreferenceController.java b/src/com/android/settings/datetime/AutoTimePreferenceController.java index 52c5c68e51f..8e54a9e968f 100644 --- a/src/com/android/settings/datetime/AutoTimePreferenceController.java +++ b/src/com/android/settings/datetime/AutoTimePreferenceController.java @@ -16,17 +16,22 @@ package com.android.settings.datetime; +import static android.app.time.Capabilities.CAPABILITY_NOT_ALLOWED; +import static android.app.time.Capabilities.CAPABILITY_NOT_APPLICABLE; +import static android.app.time.Capabilities.CAPABILITY_NOT_SUPPORTED; +import static android.app.time.Capabilities.CAPABILITY_POSSESSED; + +import android.app.time.TimeCapabilities; +import android.app.time.TimeCapabilitiesAndConfig; +import android.app.time.TimeConfiguration; +import android.app.time.TimeManager; import android.content.Context; -import android.os.UserHandle; -import android.os.UserManager; -import android.provider.Settings; import androidx.preference.Preference; +import androidx.preference.SwitchPreference; +import com.android.internal.annotations.VisibleForTesting; import com.android.settings.core.PreferenceControllerMixin; -import com.android.settingslib.RestrictedLockUtils; -import com.android.settingslib.RestrictedLockUtilsInternal; -import com.android.settingslib.RestrictedSwitchPreference; import com.android.settingslib.core.AbstractPreferenceController; public class AutoTimePreferenceController extends AbstractPreferenceController @@ -34,27 +39,39 @@ public class AutoTimePreferenceController extends AbstractPreferenceController private static final String KEY_AUTO_TIME = "auto_time"; private final UpdateTimeAndDateCallback mCallback; + private final TimeManager mTimeManager; public AutoTimePreferenceController(Context context, UpdateTimeAndDateCallback callback) { super(context); + mTimeManager = context.getSystemService(TimeManager.class); mCallback = callback; } @Override public boolean isAvailable() { - return true; + TimeCapabilities timeCapabilities = + getTimeCapabilitiesAndConfig().getCapabilities(); + int capability = timeCapabilities.getConfigureAutoDetectionEnabledCapability(); + + // The preference only has two states: present and not present. The preference is never + // present but disabled. + if (capability == CAPABILITY_NOT_SUPPORTED + || capability == CAPABILITY_NOT_ALLOWED + || capability == CAPABILITY_NOT_APPLICABLE) { + return false; + } else if (capability == CAPABILITY_POSSESSED) { + return true; + } else { + throw new IllegalStateException("Unknown capability=" + capability); + } } @Override public void updateState(Preference preference) { - if (!(preference instanceof RestrictedSwitchPreference)) { + if (!(preference instanceof SwitchPreference)) { return; } - if (!((RestrictedSwitchPreference) preference).isDisabledByAdmin()) { - ((RestrictedSwitchPreference) preference).setDisabledByAdmin( - getEnforcedAdminProperty()); - } - ((RestrictedSwitchPreference) preference).setChecked(isEnabled()); + ((SwitchPreference) preference).setChecked(isEnabled()); } @Override @@ -64,21 +81,24 @@ public class AutoTimePreferenceController extends AbstractPreferenceController @Override public boolean onPreferenceChange(Preference preference, Object newValue) { - boolean autoEnabled = (Boolean) newValue; - Settings.Global.putInt(mContext.getContentResolver(), Settings.Global.AUTO_TIME, - autoEnabled ? 1 : 0); + boolean autoTimeEnabled = (Boolean) newValue; + TimeConfiguration configuration = new TimeConfiguration.Builder() + .setAutoDetectionEnabled(autoTimeEnabled) + .build(); + boolean result = mTimeManager.updateTimeConfiguration(configuration); + mCallback.updateTimeAndDateDisplay(mContext); - return true; + return result; } + /** Returns whether the preference should be "checked", i.e. set to the "on" position. */ + @VisibleForTesting public boolean isEnabled() { - return Settings.Global.getInt(mContext.getContentResolver(), - Settings.Global.AUTO_TIME, 0) > 0; + TimeConfiguration config = getTimeCapabilitiesAndConfig().getConfiguration(); + return config.isAutoDetectionEnabled(); } - private RestrictedLockUtils.EnforcedAdmin getEnforcedAdminProperty() { - return RestrictedLockUtilsInternal.checkIfRestrictionEnforced( - mContext, UserManager.DISALLOW_CONFIG_DATE_TIME, - UserHandle.myUserId()); + private TimeCapabilitiesAndConfig getTimeCapabilitiesAndConfig() { + return mTimeManager.getTimeCapabilitiesAndConfig(); } } diff --git a/src/com/android/settings/datetime/DatePreferenceController.java b/src/com/android/settings/datetime/DatePreferenceController.java index ace24f6c7e9..66026d7b988 100644 --- a/src/com/android/settings/datetime/DatePreferenceController.java +++ b/src/com/android/settings/datetime/DatePreferenceController.java @@ -16,8 +16,12 @@ package com.android.settings.datetime; +import static android.app.time.Capabilities.CAPABILITY_POSSESSED; + import android.app.Activity; import android.app.DatePickerDialog; +import android.app.time.TimeCapabilities; +import android.app.time.TimeManager; import android.app.timedetector.ManualTimeSuggestion; import android.app.timedetector.TimeDetector; import android.content.Context; @@ -46,13 +50,12 @@ public class DatePreferenceController extends AbstractPreferenceController private static final String KEY_DATE = "date"; private final DatePreferenceHost mHost; - private final AutoTimePreferenceController mAutoTimePreferenceController; + private final TimeManager mTimeManager; - public DatePreferenceController(Context context, DatePreferenceHost host, - AutoTimePreferenceController autoTimePreferenceController) { + public DatePreferenceController(Context context, DatePreferenceHost host) { super(context); mHost = host; - mAutoTimePreferenceController = autoTimePreferenceController; + mTimeManager = context.getSystemService(TimeManager.class); } @Override @@ -68,7 +71,8 @@ public class DatePreferenceController extends AbstractPreferenceController final Calendar now = Calendar.getInstance(); preference.setSummary(DateFormat.getLongDateFormat(mContext).format(now.getTime())); if (!((RestrictedPreference) preference).isDisabledByAdmin()) { - preference.setEnabled(!mAutoTimePreferenceController.isEnabled()); + boolean enableManualDateSelection = isEnabled(); + preference.setEnabled(enableManualDateSelection); } } @@ -126,4 +130,16 @@ public class DatePreferenceController extends AbstractPreferenceController timeDetector.suggestManualTime(manualTimeSuggestion); } } + + /** + * Returns whether selecting the preference should prompt for the user to enter the date + * manually. Exposed as public so that the time controller can easily share the same logic as + * the rules are identical for time. + */ + public boolean isEnabled() { + TimeCapabilities timeZoneCapabilities = + mTimeManager.getTimeCapabilitiesAndConfig().getCapabilities(); + int suggestManualTimeCapability = timeZoneCapabilities.getSuggestManualTimeCapability(); + return suggestManualTimeCapability == CAPABILITY_POSSESSED; + } } diff --git a/src/com/android/settings/datetime/DateTimeSettings.java b/src/com/android/settings/datetime/DateTimeSettings.java index 169455a7296..3da42343e70 100644 --- a/src/com/android/settings/datetime/DateTimeSettings.java +++ b/src/com/android/settings/datetime/DateTimeSettings.java @@ -69,27 +69,28 @@ public class DateTimeSettings extends DashboardFragment implements final Intent intent = activity.getIntent(); final boolean isFromSUW = intent.getBooleanExtra(EXTRA_IS_FROM_SUW, false); - final AutoTimeZonePreferenceController autoTimeZonePreferenceController = - new AutoTimeZonePreferenceController( - activity, this /* UpdateTimeAndDateCallback */, isFromSUW); final AutoTimePreferenceController autoTimePreferenceController = new AutoTimePreferenceController( activity, this /* UpdateTimeAndDateCallback */); + controllers.add(autoTimePreferenceController); + DatePreferenceController datePreferenceController = new DatePreferenceController( + activity, this /* UpdateTimeAndDateCallback */); + controllers.add(datePreferenceController); + controllers.add(new TimePreferenceController( + activity, this /* UpdateTimeAndDateCallback */, datePreferenceController)); + + final AutoTimeZonePreferenceController autoTimeZonePreferenceController = + new AutoTimeZonePreferenceController( + activity, this /* UpdateTimeAndDateCallback */, isFromSUW); + controllers.add(autoTimeZonePreferenceController); + controllers.add(new TimeZonePreferenceController(activity)); + final AutoTimeFormatPreferenceController autoTimeFormatPreferenceController = new AutoTimeFormatPreferenceController( activity, this /* UpdateTimeAndDateCallback */); - - controllers.add(autoTimeZonePreferenceController); - controllers.add(autoTimePreferenceController); controllers.add(autoTimeFormatPreferenceController); - controllers.add(new TimeFormatPreferenceController( activity, this /* UpdateTimeAndDateCallback */, isFromSUW)); - controllers.add(new TimeZonePreferenceController(activity)); - controllers.add(new TimePreferenceController( - activity, this /* UpdateTimeAndDateCallback */, autoTimePreferenceController)); - controllers.add(new DatePreferenceController( - activity, this /* UpdateTimeAndDateCallback */, autoTimePreferenceController)); return controllers; } diff --git a/src/com/android/settings/datetime/TimePreferenceController.java b/src/com/android/settings/datetime/TimePreferenceController.java index 582234efaeb..368f1f2fd55 100644 --- a/src/com/android/settings/datetime/TimePreferenceController.java +++ b/src/com/android/settings/datetime/TimePreferenceController.java @@ -44,16 +44,16 @@ public class TimePreferenceController extends AbstractPreferenceController private static final String KEY_TIME = "time"; - private final AutoTimePreferenceController mAutoTimePreferenceController; + private final DatePreferenceController mDatePreferenceController; private final TimePreferenceHost mHost; public TimePreferenceController(Context context, TimePreferenceHost callback, - AutoTimePreferenceController autoTimePreferenceController) { + DatePreferenceController datePreferenceController) { super(context); mHost = callback; - mAutoTimePreferenceController = autoTimePreferenceController; + mDatePreferenceController = datePreferenceController; } @Override @@ -69,7 +69,8 @@ public class TimePreferenceController extends AbstractPreferenceController final Calendar now = Calendar.getInstance(); preference.setSummary(DateFormat.getTimeFormat(mContext).format(now.getTime())); if (!((RestrictedPreference) preference).isDisabledByAdmin()) { - preference.setEnabled(!mAutoTimePreferenceController.isEnabled()); + boolean enableManualTimeSelection = mDatePreferenceController.isEnabled(); + preference.setEnabled(enableManualTimeSelection); } } diff --git a/tests/robotests/src/com/android/settings/datetime/AutoTimePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/datetime/AutoTimePreferenceControllerTest.java index f75c04ca9e4..20fb87173d0 100644 --- a/tests/robotests/src/com/android/settings/datetime/AutoTimePreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/datetime/AutoTimePreferenceControllerTest.java @@ -18,17 +18,25 @@ package com.android.settings.datetime; 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.time.Capabilities; +import android.app.time.TimeCapabilities; +import android.app.time.TimeCapabilitiesAndConfig; +import android.app.time.TimeConfiguration; +import android.app.time.TimeManager; import android.content.Context; -import android.provider.Settings; +import android.os.UserHandle; -import com.android.settingslib.RestrictedSwitchPreference; +import androidx.preference.Preference; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; import org.robolectric.RobolectricTestRunner; import org.robolectric.RuntimeEnvironment; @@ -38,43 +46,123 @@ public class AutoTimePreferenceControllerTest { @Mock private UpdateTimeAndDateCallback mCallback; - private Context mContext; - private RestrictedSwitchPreference mPreference; private AutoTimePreferenceController mController; + private Preference mPreference; + @Mock + private TimeManager mTimeManager; @Before public void setUp() { MockitoAnnotations.initMocks(this); - mContext = RuntimeEnvironment.application; - mPreference = new RestrictedSwitchPreference(mContext); + mContext = spy(RuntimeEnvironment.application); + mPreference = new Preference(mContext); + when(mContext.getSystemService(TimeManager.class)).thenReturn(mTimeManager); + mController = new AutoTimePreferenceController(mContext, mCallback); } @Test - public void testIsEnabled_shouldReadFromSettingsProvider() { - // Disabled - Settings.Global.putInt(mContext.getContentResolver(), Settings.Global.AUTO_TIME, 0); - assertThat(mController.isEnabled()).isFalse(); + public void autoTimeNotSupported_notAvailable() { + TimeCapabilitiesAndConfig capabilitiesAndConfig = createCapabilitiesAndConfig( + /* autoSupported= */false, /* autoEnabled= */false); + when(mTimeManager.getTimeCapabilitiesAndConfig()).thenReturn(capabilitiesAndConfig); - // Enabled - Settings.Global.putInt(mContext.getContentResolver(), Settings.Global.AUTO_TIME, 1); - assertThat(mController.isEnabled()).isTrue(); + assertThat(mController.isAvailable()).isFalse(); + } + + @Test + public void autoTimeNotSupported_notEnable() { + TimeCapabilitiesAndConfig capabilitiesAndConfig = createCapabilitiesAndConfig( + /* autoSupported= */false, /* autoEnabled= */false); + when(mTimeManager.getTimeCapabilitiesAndConfig()).thenReturn(capabilitiesAndConfig); + + assertThat(mController.isEnabled()).isFalse(); + } + + @Test + public void testIsEnabled_shouldReadFromTimeManagerConfig() { + { + // Disabled + TimeCapabilitiesAndConfig capabilitiesAndConfig = createCapabilitiesAndConfig( + /* autoSupported= */true, /* autoEnabled= */false); + when(mTimeManager.getTimeCapabilitiesAndConfig()).thenReturn(capabilitiesAndConfig); + + assertThat(mController.isEnabled()).isFalse(); + } + + { + // Enabled + TimeCapabilitiesAndConfig capabilitiesAndConfig = createCapabilitiesAndConfig( + /* autoSupported= */true, /* autoEnabled= */true); + when(mTimeManager.getTimeCapabilitiesAndConfig()).thenReturn(capabilitiesAndConfig); + + assertThat(mController.isEnabled()).isTrue(); + } } @Test public void updatePreferenceChange_prefIsChecked_shouldUpdatePreferenceAndNotifyCallback() { - mController.onPreferenceChange(mPreference, true); + TimeCapabilitiesAndConfig capabilitiesAndConfig = createCapabilitiesAndConfig( + /* autoSupported= */true, /* autoEnabled= */false); + when(mTimeManager.getTimeCapabilitiesAndConfig()).thenReturn(capabilitiesAndConfig); + when(mTimeManager.updateTimeConfiguration(Mockito.any())).thenReturn(true); + + assertThat(mController.onPreferenceChange(mPreference, true)).isTrue(); + verify(mCallback).updateTimeAndDateDisplay(mContext); + + // Check the service was asked to change the configuration correctly. + TimeConfiguration timeConfiguration = new TimeConfiguration.Builder() + .setAutoDetectionEnabled(true) + .build(); + verify(mTimeManager).updateTimeConfiguration(timeConfiguration); + + // Update the mTimeManager mock so that it now returns the expected updated config. + TimeCapabilitiesAndConfig capabilitiesAndConfigAfterUpdate = + createCapabilitiesAndConfig(/* autoSupported= */true, /* autoEnabled= */true); + when(mTimeManager.getTimeCapabilitiesAndConfig()) + .thenReturn(capabilitiesAndConfigAfterUpdate); assertThat(mController.isEnabled()).isTrue(); - verify(mCallback).updateTimeAndDateDisplay(mContext); } @Test public void updatePreferenceChange_prefIsUnchecked_shouldUpdatePreferenceAndNotifyCallback() { - mController.onPreferenceChange(mPreference, false); + TimeCapabilitiesAndConfig capabilitiesAndConfig = createCapabilitiesAndConfig( + /* autoSupported= */true, /* autoEnabled= */true); + when(mTimeManager.getTimeCapabilitiesAndConfig()).thenReturn(capabilitiesAndConfig); + when(mTimeManager.updateTimeConfiguration(Mockito.any())).thenReturn(true); + + assertThat(mController.onPreferenceChange(mPreference, false)).isTrue(); + verify(mCallback).updateTimeAndDateDisplay(mContext); + + // Check the service was asked to change the configuration correctly. + TimeConfiguration timeConfiguration = new TimeConfiguration.Builder() + .setAutoDetectionEnabled(false) + .build(); + verify(mTimeManager).updateTimeConfiguration(timeConfiguration); + + // Update the mTimeManager mock so that it now returns the expected updated config. + TimeCapabilitiesAndConfig capabilitiesAndConfigAfterUpdate = + createCapabilitiesAndConfig(/* autoSupported= */true, /* autoEnabled= */false); + when(mTimeManager.getTimeCapabilitiesAndConfig()) + .thenReturn(capabilitiesAndConfigAfterUpdate); assertThat(mController.isEnabled()).isFalse(); - verify(mCallback).updateTimeAndDateDisplay(mContext); + } + + private static TimeCapabilitiesAndConfig createCapabilitiesAndConfig( + boolean autoSupported, boolean autoEnabled) { + int configureAutoDetectionEnabledCapability = + autoSupported ? Capabilities.CAPABILITY_POSSESSED + : Capabilities.CAPABILITY_NOT_SUPPORTED; + TimeCapabilities capabilities = new TimeCapabilities.Builder(UserHandle.SYSTEM) + .setConfigureAutoDetectionEnabledCapability(configureAutoDetectionEnabledCapability) + .setSuggestManualTimeCapability(Capabilities.CAPABILITY_POSSESSED) + .build(); + TimeConfiguration config = new TimeConfiguration.Builder() + .setAutoDetectionEnabled(autoEnabled) + .build(); + return new TimeCapabilitiesAndConfig(capabilities, config); } } diff --git a/tests/robotests/src/com/android/settings/datetime/AutoTimeZonePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/datetime/AutoTimeZonePreferenceControllerTest.java index f2ba580f3fe..45963a6c47b 100644 --- a/tests/robotests/src/com/android/settings/datetime/AutoTimeZonePreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/datetime/AutoTimeZonePreferenceControllerTest.java @@ -46,9 +46,7 @@ public class AutoTimeZonePreferenceControllerTest { @Mock private UpdateTimeAndDateCallback mCallback; - @Mock private Context mContext; - private AutoTimeZonePreferenceController mController; private Preference mPreference; @Mock private TimeManager mTimeManager; @@ -69,10 +67,10 @@ public class AutoTimeZonePreferenceControllerTest { /* autoSupported= */true, /* autoEnabled= */false); when(mTimeManager.getTimeZoneCapabilitiesAndConfig()).thenReturn(capabilitiesAndConfig); - mController = new AutoTimeZonePreferenceController( + AutoTimeZonePreferenceController controller = new AutoTimeZonePreferenceController( mContext, null /* callback */, true /* isFromSUW */); - assertThat(mController.isAvailable()).isFalse(); + assertThat(controller.isAvailable()).isFalse(); } @Test @@ -81,10 +79,10 @@ public class AutoTimeZonePreferenceControllerTest { /* autoSupported= */true, /* autoEnabled= */false); when(mTimeManager.getTimeZoneCapabilitiesAndConfig()).thenReturn(capabilitiesAndConfig); - mController = new AutoTimeZonePreferenceController( + AutoTimeZonePreferenceController controller = new AutoTimeZonePreferenceController( mContext, null /* callback */, false /* isFromSUW */); - assertThat(mController.isAvailable()).isTrue(); + assertThat(controller.isAvailable()).isTrue(); } @Test @@ -93,10 +91,10 @@ public class AutoTimeZonePreferenceControllerTest { /* autoSupported= */false, /* autoEnabled= */false); when(mTimeManager.getTimeZoneCapabilitiesAndConfig()).thenReturn(capabilitiesAndConfig); - mController = new AutoTimeZonePreferenceController( + AutoTimeZonePreferenceController controller = new AutoTimeZonePreferenceController( mContext, null /* callback */, false /* fromSUW */); - assertThat(mController.isAvailable()).isFalse(); + assertThat(controller.isAvailable()).isFalse(); } @Test @@ -105,10 +103,10 @@ public class AutoTimeZonePreferenceControllerTest { /* autoSupported= */false, /* autoEnabled= */false); when(mTimeManager.getTimeZoneCapabilitiesAndConfig()).thenReturn(capabilitiesAndConfig); - mController = new AutoTimeZonePreferenceController( + AutoTimeZonePreferenceController controller = new AutoTimeZonePreferenceController( mContext, null /* callback */, true /* fromSUW */); - assertThat(mController.isEnabled()).isFalse(); + assertThat(controller.isEnabled()).isFalse(); } @Test @@ -117,10 +115,10 @@ public class AutoTimeZonePreferenceControllerTest { /* autoSupported= */false, /* autoEnabled= */true); when(mTimeManager.getTimeZoneCapabilitiesAndConfig()).thenReturn(capabilitiesAndConfig); - mController = new AutoTimeZonePreferenceController( + AutoTimeZonePreferenceController controller = new AutoTimeZonePreferenceController( mContext, null /* callback */, true /* fromSUW */); - assertThat(mController.isEnabled()).isTrue(); + assertThat(controller.isEnabled()).isTrue(); } @Test @@ -129,15 +127,15 @@ public class AutoTimeZonePreferenceControllerTest { /* autoSupported= */false, /* autoEnabled= */false); when(mTimeManager.getTimeZoneCapabilitiesAndConfig()).thenReturn(capabilitiesAndConfig); - mController = new AutoTimeZonePreferenceController( + AutoTimeZonePreferenceController controller = new AutoTimeZonePreferenceController( mContext, null /* callback */, false /* fromSUW */); - assertThat(mController.isEnabled()).isFalse(); + assertThat(controller.isEnabled()).isFalse(); } @Test public void testIsEnabled_shouldReadFromTimeManagerConfig() { - mController = new AutoTimeZonePreferenceController( + AutoTimeZonePreferenceController controller = new AutoTimeZonePreferenceController( mContext, null /* callback */, false /* fromSUW */); { @@ -146,7 +144,7 @@ public class AutoTimeZonePreferenceControllerTest { /* autoSupported= */true, /* autoEnabled= */false); when(mTimeManager.getTimeZoneCapabilitiesAndConfig()).thenReturn(capabilitiesAndConfig); - assertThat(mController.isEnabled()).isFalse(); + assertThat(controller.isEnabled()).isFalse(); } { @@ -155,7 +153,7 @@ public class AutoTimeZonePreferenceControllerTest { /* autoSupported= */true, /* autoEnabled= */true); when(mTimeManager.getTimeZoneCapabilitiesAndConfig()).thenReturn(capabilitiesAndConfig); - assertThat(mController.isEnabled()).isTrue(); + assertThat(controller.isEnabled()).isTrue(); } } @@ -166,10 +164,10 @@ public class AutoTimeZonePreferenceControllerTest { when(mTimeManager.getTimeZoneCapabilitiesAndConfig()).thenReturn(capabilitiesAndConfig); when(mTimeManager.updateTimeZoneConfiguration(Mockito.any())).thenReturn(true); - mController = new AutoTimeZonePreferenceController( + AutoTimeZonePreferenceController controller = new AutoTimeZonePreferenceController( mContext, mCallback, false /* fromSUW */); - assertThat(mController.onPreferenceChange(mPreference, true)).isTrue(); + assertThat(controller.onPreferenceChange(mPreference, true)).isTrue(); verify(mCallback).updateTimeAndDateDisplay(mContext); // Check the service was asked to change the configuration correctly. @@ -184,7 +182,7 @@ public class AutoTimeZonePreferenceControllerTest { when(mTimeManager.getTimeZoneCapabilitiesAndConfig()) .thenReturn(capabilitiesAndConfigAfterUpdate); - assertThat(mController.isEnabled()).isTrue(); + assertThat(controller.isEnabled()).isTrue(); } @Test @@ -194,10 +192,10 @@ public class AutoTimeZonePreferenceControllerTest { when(mTimeManager.getTimeZoneCapabilitiesAndConfig()).thenReturn(capabilitiesAndConfig); when(mTimeManager.updateTimeZoneConfiguration(Mockito.any())).thenReturn(true); - mController = new AutoTimeZonePreferenceController( + AutoTimeZonePreferenceController controller = new AutoTimeZonePreferenceController( mContext, mCallback, false /* fromSUW */); - assertThat(mController.onPreferenceChange(mPreference, false)).isTrue(); + assertThat(controller.onPreferenceChange(mPreference, false)).isTrue(); verify(mCallback).updateTimeAndDateDisplay(mContext); // Check the service was asked to change the configuration correctly. @@ -212,7 +210,7 @@ public class AutoTimeZonePreferenceControllerTest { when(mTimeManager.getTimeZoneCapabilitiesAndConfig()) .thenReturn(capabilitiesAndConfigAfterUpdate); - assertThat(mController.isEnabled()).isFalse(); + assertThat(controller.isEnabled()).isFalse(); } private static TimeZoneCapabilitiesAndConfig createCapabilitiesAndConfig( diff --git a/tests/robotests/src/com/android/settings/datetime/DatePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/datetime/DatePreferenceControllerTest.java index f4d46664480..1b8148b911f 100644 --- a/tests/robotests/src/com/android/settings/datetime/DatePreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/datetime/DatePreferenceControllerTest.java @@ -21,8 +21,14 @@ import static com.google.common.truth.Truth.assertThat; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; +import android.app.time.Capabilities; +import android.app.time.TimeCapabilities; +import android.app.time.TimeCapabilitiesAndConfig; +import android.app.time.TimeConfiguration; +import android.app.time.TimeManager; import android.app.timedetector.TimeDetector; import android.content.Context; +import android.os.UserHandle; import com.android.settingslib.RestrictedPreference; @@ -42,9 +48,9 @@ public class DatePreferenceControllerTest { @Mock private TimeDetector mTimeDetector; @Mock - private DatePreferenceController.DatePreferenceHost mHost; + private TimeManager mTimeManager; @Mock - private AutoTimePreferenceController mAutoTimePreferenceController; + private DatePreferenceController.DatePreferenceHost mHost; private RestrictedPreference mPreference; private DatePreferenceController mController; @@ -53,8 +59,9 @@ public class DatePreferenceControllerTest { public void setUp() { MockitoAnnotations.initMocks(this); when(mContext.getSystemService(TimeDetector.class)).thenReturn(mTimeDetector); + when(mContext.getSystemService(TimeManager.class)).thenReturn(mTimeManager); mPreference = new RestrictedPreference(RuntimeEnvironment.application); - mController = new DatePreferenceController(mContext, mHost, mAutoTimePreferenceController); + mController = new DatePreferenceController(mContext, mHost); } @Test @@ -73,7 +80,9 @@ public class DatePreferenceControllerTest { // Make sure not disabled by admin. mPreference.setDisabledByAdmin(null); - when(mAutoTimePreferenceController.isEnabled()).thenReturn(true); + TimeCapabilitiesAndConfig capabilitiesAndConfig = createCapabilitiesAndConfig( + /* suggestManualAllowed= */false); + when(mTimeManager.getTimeCapabilitiesAndConfig()).thenReturn(capabilitiesAndConfig); mController.updateState(mPreference); assertThat(mPreference.isEnabled()).isFalse(); @@ -84,7 +93,9 @@ public class DatePreferenceControllerTest { // Make sure not disabled by admin. mPreference.setDisabledByAdmin(null); - when(mAutoTimePreferenceController.isEnabled()).thenReturn(false); + TimeCapabilitiesAndConfig capabilitiesAndConfig = createCapabilitiesAndConfig( + /* suggestManualAllowed= */true); + when(mTimeManager.getTimeCapabilitiesAndConfig()).thenReturn(capabilitiesAndConfig); mController.updateState(mPreference); assertThat(mPreference.isEnabled()).isTrue(); @@ -102,4 +113,18 @@ public class DatePreferenceControllerTest { // Should show date picker verify(mHost).showDatePicker(); } + + private static TimeCapabilitiesAndConfig createCapabilitiesAndConfig( + boolean suggestManualAllowed) { + int suggestManualCapability = suggestManualAllowed ? Capabilities.CAPABILITY_POSSESSED + : Capabilities.CAPABILITY_NOT_SUPPORTED; + TimeCapabilities capabilities = new TimeCapabilities.Builder(UserHandle.SYSTEM) + .setConfigureAutoDetectionEnabledCapability(Capabilities.CAPABILITY_POSSESSED) + .setSuggestManualTimeCapability(suggestManualCapability) + .build(); + TimeConfiguration config = new TimeConfiguration.Builder() + .setAutoDetectionEnabled(!suggestManualAllowed) + .build(); + return new TimeCapabilitiesAndConfig(capabilities, config); + } } diff --git a/tests/robotests/src/com/android/settings/datetime/TimePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/datetime/TimePreferenceControllerTest.java index 07975e3f0c2..3481f803d82 100644 --- a/tests/robotests/src/com/android/settings/datetime/TimePreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/datetime/TimePreferenceControllerTest.java @@ -41,7 +41,7 @@ public class TimePreferenceControllerTest { @Mock private TimePreferenceController.TimePreferenceHost mHost; @Mock - private AutoTimePreferenceController mAutoTimePreferenceController; + private DatePreferenceController mDatePreferenceController; private TimePreferenceController mController; private RestrictedPreference mPreference; @@ -50,7 +50,7 @@ public class TimePreferenceControllerTest { public void setUp() { MockitoAnnotations.initMocks(this); mPreference = new RestrictedPreference(RuntimeEnvironment.application); - mController = new TimePreferenceController(mContext, mHost, mAutoTimePreferenceController); + mController = new TimePreferenceController(mContext, mHost, mDatePreferenceController); } @Test @@ -59,22 +59,22 @@ public class TimePreferenceControllerTest { } @Test - public void updateState_autoTimeEnabled_shouldDisablePref() { + public void updateState_dateEntryDisabled_shouldDisablePref() { // Make sure not disabled by admin. mPreference.setDisabledByAdmin(null); - when(mAutoTimePreferenceController.isEnabled()).thenReturn(true); + when(mDatePreferenceController.isEnabled()).thenReturn(false); mController.updateState(mPreference); assertThat(mPreference.isEnabled()).isFalse(); } @Test - public void updateState_autoTimeDisabled_shouldEnablePref() { + public void updateState_dateEntryEnabled_shouldEnablePref() { // Make sure not disabled by admin. mPreference.setDisabledByAdmin(null); - when(mAutoTimePreferenceController.isEnabled()).thenReturn(false); + when(mDatePreferenceController.isEnabled()).thenReturn(true); mController.updateState(mPreference); assertThat(mPreference.isEnabled()).isTrue();