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();