PawletOS/app_Settings
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Refactor Date & Time Settings" into main

Browse Source
This commit is contained in:
Edgar Wang
2023-11-29 13:19:40 +00:00
committed by Android (Google) Code Review
parent b3632f2ef6 fdab44f9e7
commit 07b2af4120
16 changed files with 339 additions and 434 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
res/xml/date_time_prefs.xml
View File

@@ -24,19 +24,22 @@
android:key="auto_time"
android:title="@string/date_time_auto"
settings:useAdditionalSummary="true"
settings:userRestriction="no_config_date_time"/>
settings:userRestriction="no_config_date_time"
settings:controller="com.android.settings.datetime.AutoTimePreferenceController" />
<com.android.settingslib.RestrictedPreference
android:key="date"
android:title="@string/date_time_set_date_title"
android:summary="@string/summary_placeholder"
settings:userRestriction="no_config_date_time"/>
settings:userRestriction="no_config_date_time"
settings:controller="com.android.settings.datetime.DatePreferenceController" />
<com.android.settingslib.RestrictedPreference
android:key="time"
android:title="@string/date_time_set_time_title"
android:summary="@string/summary_placeholder"
settings:userRestriction="no_config_date_time"/>
settings:userRestriction="no_config_date_time"
settings:controller="com.android.settings.datetime.TimePreferenceController" />
<PreferenceCategory
android:key="timezone_preference_category"
@@ -45,7 +48,8 @@
<com.android.settingslib.RestrictedSwitchPreference
android:key="auto_zone"
android:title="@string/zone_auto_title"
settings:userRestriction="no_config_date_time"/>
settings:userRestriction="no_config_date_time"
settings:controller="com.android.settings.datetime.AutoTimeZonePreferenceController" />
<com.android.settingslib.widget.BannerMessagePreference
android:key="location_time_zone_detection_status"
@@ -53,7 +57,7 @@
settings:controller="com.android.settings.datetime.LocationProviderStatusPreferenceController"/>
<!-- This preference gets removed if location-based time zone detection is not supported -->
<SwitchPreferenceCompat
<SwitchPreference
android:key="location_time_zone_detection"
android:title="@string/location_time_zone_detection_toggle_title"
settings:controller="com.android.settings.datetime.LocationTimeZoneDetectionPreferenceController"/>
@@ -64,7 +68,8 @@
android:summary="@string/summary_placeholder"
android:fragment="com.android.settings.datetime.timezone.TimeZoneSettings"
settings:userRestriction="no_config_date_time"
settings:keywords="@string/keywords_time_zone"/>
settings:keywords="@string/keywords_time_zone"
settings:controller="com.android.settings.datetime.TimeZonePreferenceController" />
</PreferenceCategory>
@@ -72,13 +77,15 @@
android:key="time_format_preference_category"
android:title="@string/time_format_category_title"
settings:keywords="@string/keywords_time_format">
<SwitchPreferenceCompat
<SwitchPreference
android:key="auto_24hour"
android:title="@string/date_time_24hour_auto"/>
android:title="@string/date_time_24hour_auto"
settings:controller="com.android.settings.datetime.AutoTimeFormatPreferenceController" />
<SwitchPreferenceCompat
<SwitchPreference
android:key="24 hour"
android:title="@string/date_time_24hour" />
android:title="@string/date_time_24hour"
settings:controller="com.android.settings.datetime.TimeFormatPreferenceController" />
</PreferenceCategory>
</PreferenceScreen>

47
src/com/android/settings/datetime/AutoTimeFormatPreferenceController.java
View File

@@ -19,53 +19,33 @@ package com.android.settings.datetime;
import android.content.Context;
import android.provider.Settings;
import android.provider.Settings.System;
import android.text.TextUtils;
import android.text.format.DateFormat;
import androidx.preference.Preference;
import androidx.preference.TwoStatePreference;
import com.android.settings.core.PreferenceControllerMixin;
import com.android.settingslib.core.AbstractPreferenceController;
import com.android.settings.R;
import com.android.settings.core.TogglePreferenceController;
import java.util.Locale;
public class AutoTimeFormatPreferenceController extends AbstractPreferenceController
implements PreferenceControllerMixin {
public class AutoTimeFormatPreferenceController extends TogglePreferenceController {
private static final String KEY_AUTO_24_HOUR = "auto_24hour";
public AutoTimeFormatPreferenceController(Context context, UpdateTimeAndDateCallback callback) {
super(context);
public AutoTimeFormatPreferenceController(Context context, String preferenceKey) {
super(context, preferenceKey);
}
@Override
public boolean isAvailable() {
return true;
public int getAvailabilityStatus() {
return AVAILABLE;
}
@Override
public String getPreferenceKey() {
return KEY_AUTO_24_HOUR;
public boolean isChecked() {
return isAutoTimeFormatSelection(mContext);
}
@Override
public void updateState(Preference preference) {
if (!(preference instanceof TwoStatePreference)) {
return;
}
((TwoStatePreference) preference).setChecked(isAutoTimeFormatSelection(mContext));
}
@Override
public boolean handlePreferenceTreeClick(Preference preference) {
if (!(preference instanceof TwoStatePreference)
|| !TextUtils.equals(KEY_AUTO_24_HOUR, preference.getKey())) {
return false;
}
boolean auto24HourEnabled = ((TwoStatePreference) preference).isChecked();
public boolean setChecked(boolean isChecked) {
Boolean is24Hour;
if (auto24HourEnabled) {
if (isChecked) {
is24Hour = null;
} else {
is24Hour = is24HourLocale(mContext.getResources().getConfiguration().locale);
@@ -74,6 +54,11 @@ public class AutoTimeFormatPreferenceController extends AbstractPreferenceContro
return true;
}
@Override
public int getSliceHighlightMenuRes() {
return R.string.menu_key_system;
}
boolean is24HourLocale(Locale locale) {
return DateFormat.is24HourLocale(locale);
}

51
src/com/android/settings/datetime/AutoTimePreferenceController.java
View File

@@ -27,28 +27,26 @@ import android.app.time.TimeConfiguration;
import android.app.time.TimeManager;
import android.content.Context;
import androidx.preference.Preference;
import androidx.preference.TwoStatePreference;
import com.android.internal.annotations.VisibleForTesting;
import com.android.settings.core.PreferenceControllerMixin;
import com.android.settingslib.core.AbstractPreferenceController;
import com.android.settings.R;
import com.android.settings.core.TogglePreferenceController;
public class AutoTimePreferenceController extends AbstractPreferenceController
implements PreferenceControllerMixin, Preference.OnPreferenceChangeListener {
public class AutoTimePreferenceController extends TogglePreferenceController {
private static final String KEY_AUTO_TIME = "auto_time";
private final UpdateTimeAndDateCallback mCallback;
private UpdateTimeAndDateCallback mCallback;
private final TimeManager mTimeManager;
public AutoTimePreferenceController(Context context, UpdateTimeAndDateCallback callback) {
super(context);
public AutoTimePreferenceController(Context context, String preferenceKey) {
super(context, preferenceKey);
mTimeManager = context.getSystemService(TimeManager.class);
}
public void setDateAndTimeCallback(UpdateTimeAndDateCallback callback) {
mCallback = callback;
}
@Override
public boolean isAvailable() {
public int getAvailabilityStatus() {
TimeCapabilities timeCapabilities =
getTimeCapabilitiesAndConfig().getCapabilities();
int capability = timeCapabilities.getConfigureAutoDetectionEnabledCapability();
@@ -57,43 +55,31 @@ public class AutoTimePreferenceController extends AbstractPreferenceController
// This method handles the "is visible?" check.
switch (capability) {
case CAPABILITY_NOT_SUPPORTED:
return false;
return DISABLED_DEPENDENT_SETTING;
case CAPABILITY_POSSESSED:
return true;
case CAPABILITY_NOT_ALLOWED:
// This case is expected for enterprise restrictions, where the toggle should be
// present but disabled. Disabling is handled declaratively via the
// settings:userRestriction attribute in .xml. The client-side logic is expected to
// concur with the capabilities logic in the system server.
return true;
case CAPABILITY_NOT_APPLICABLE:
// CAPABILITY_NOT_APPLICABLE is not currently expected, so this is return value is
// arbitrary.
return true;
return AVAILABLE;
default:
throw new IllegalStateException("Unknown capability=" + capability);
}
}
@Override
public void updateState(Preference preference) {
if (!(preference instanceof TwoStatePreference)) {
return;
}
((TwoStatePreference) preference).setChecked(isEnabled());
public boolean isChecked() {
return isEnabled();
}
@Override
public String getPreferenceKey() {
return KEY_AUTO_TIME;
}
@Override
public boolean onPreferenceChange(Preference preference, Object newValue) {
boolean autoTimeEnabled = (Boolean) newValue;
public boolean setChecked(boolean isChecked) {
TimeConfiguration configuration = new TimeConfiguration.Builder()
.setAutoDetectionEnabled(autoTimeEnabled)
.setAutoDetectionEnabled(isChecked)
.build();
boolean result = mTimeManager.updateTimeConfiguration(configuration);
@@ -101,6 +87,11 @@ public class AutoTimePreferenceController extends AbstractPreferenceController
return result;
}
@Override
public int getSliceHighlightMenuRes() {
return R.string.menu_key_system;
}
/** Returns whether the preference should be "checked", i.e. set to the "on" position. */
@VisibleForTesting
public boolean isEnabled() {

75
src/com/android/settings/datetime/AutoTimeZonePreferenceController.java
View File

@@ -27,36 +27,42 @@ import android.app.time.TimeZoneCapabilitiesAndConfig;
import android.app.time.TimeZoneConfiguration;
import android.content.Context;
import androidx.preference.Preference;
import androidx.preference.PreferenceScreen;
import androidx.preference.TwoStatePreference;
import com.android.internal.annotations.VisibleForTesting;
import com.android.settings.R;
import com.android.settings.core.PreferenceControllerMixin;
import com.android.settingslib.core.AbstractPreferenceController;
import com.android.settings.core.TogglePreferenceController;
public class AutoTimeZonePreferenceController extends AbstractPreferenceController
implements PreferenceControllerMixin, Preference.OnPreferenceChangeListener {
public class AutoTimeZonePreferenceController extends TogglePreferenceController {
private static final String KEY_AUTO_TIME_ZONE = "auto_zone";
private final boolean mIsFromSUW;
private final UpdateTimeAndDateCallback mCallback;
private boolean mIsFromSUW;
private UpdateTimeAndDateCallback mCallback;
private final TimeManager mTimeManager;
public AutoTimeZonePreferenceController(Context context, UpdateTimeAndDateCallback callback,
boolean isFromSUW) {
super(context);
public AutoTimeZonePreferenceController(Context context, String preferenceKey) {
super(context, preferenceKey);
mTimeManager = context.getSystemService(TimeManager.class);
}
/**
* Set the Time and Date callback
*/
public AutoTimeZonePreferenceController setTimeAndDateCallback(
UpdateTimeAndDateCallback callback) {
mCallback = callback;
return this;
}
/**
* Set if current fragment is launched via SUW
*/
public AutoTimeZonePreferenceController setFromSUW(boolean isFromSUW) {
mIsFromSUW = isFromSUW;
return this;
}
@Override
public boolean isAvailable() {
public int getAvailabilityStatus() {
if (mIsFromSUW) {
return false;
return DISABLED_DEPENDENT_SETTING;
}
TimeZoneCapabilities timeZoneCapabilities =
@@ -67,43 +73,31 @@ public class AutoTimeZonePreferenceController extends AbstractPreferenceControll
// This method handles the "is visible?" check.
switch (capability) {
case CAPABILITY_NOT_SUPPORTED:
return false;
return DISABLED_DEPENDENT_SETTING;
case CAPABILITY_POSSESSED:
return true;
case CAPABILITY_NOT_ALLOWED:
// This case is expected for enterprise restrictions, where the toggle should be
// present but disabled. Disabling is handled declaratively via the
// settings:userRestriction attribute in .xml. The client-side logic is expected to
// concur with the capabilities logic in the system server.
return true;
case CAPABILITY_NOT_APPLICABLE:
// CAPABILITY_NOT_APPLICABLE is not currently expected, so this is return value is
// arbitrary.
return true;
return AVAILABLE;
default:
throw new IllegalStateException("Unknown capability=" + capability);
}
}
@Override
public String getPreferenceKey() {
return KEY_AUTO_TIME_ZONE;
public boolean isChecked() {
return isEnabled();
}
@Override
public void updateState(Preference preference) {
if (!(preference instanceof TwoStatePreference)) {
return;
}
((TwoStatePreference) preference).setChecked(isEnabled());
}
@Override
public boolean onPreferenceChange(Preference preference, Object newValue) {
boolean autoZoneEnabled = (Boolean) newValue;
public boolean setChecked(boolean isChecked) {
TimeZoneConfiguration configuration = new TimeZoneConfiguration.Builder()
.setAutoDetectionEnabled(autoZoneEnabled)
.setAutoDetectionEnabled(isChecked)
.build();
boolean result = mTimeManager.updateTimeZoneConfiguration(configuration);
@@ -111,6 +105,11 @@ public class AutoTimeZonePreferenceController extends AbstractPreferenceControll
return result;
}
@Override
public int getSliceHighlightMenuRes() {
return R.string.menu_key_system;
}
@Override
public CharSequence getSummary() {
// If auto time zone cannot enable telephony fallback and is capable of location, then auto
@@ -124,12 +123,6 @@ public class AutoTimeZonePreferenceController extends AbstractPreferenceControll
return "";
}
@Override
public void displayPreference(PreferenceScreen screen) {
super.displayPreference(screen);
refreshSummary(screen.findPreference(getPreferenceKey()));
}
@VisibleForTesting
boolean isEnabled() {
TimeZoneConfiguration config = getTimeZoneCapabilitiesAndConfig().getConfiguration();

48
src/com/android/settings/datetime/DatePreferenceController.java
View File

@@ -33,14 +33,12 @@ import android.widget.DatePicker;
import androidx.annotation.VisibleForTesting;
import androidx.preference.Preference;
import com.android.settings.core.PreferenceControllerMixin;
import com.android.settingslib.RestrictedPreference;
import com.android.settingslib.core.AbstractPreferenceController;
import com.android.settings.core.BasePreferenceController;
import java.util.Calendar;
public class DatePreferenceController extends AbstractPreferenceController
implements PreferenceControllerMixin, DatePickerDialog.OnDateSetListener {
public class DatePreferenceController extends BasePreferenceController
implements DatePickerDialog.OnDateSetListener {
public interface DatePreferenceHost extends UpdateTimeAndDateCallback {
void showDatePicker();
@@ -49,49 +47,45 @@ public class DatePreferenceController extends AbstractPreferenceController
public static final int DIALOG_DATEPICKER = 0;
private static final String TAG = "DatePreferenceController";
private static final String KEY_DATE = "date";
private final DatePreferenceHost mHost;
private DatePreferenceHost mHost;
private final TimeManager mTimeManager;
public DatePreferenceController(Context context, DatePreferenceHost host) {
super(context);
mHost = host;
public DatePreferenceController(Context context, String preferenceKey) {
super(context, preferenceKey);
mTimeManager = context.getSystemService(TimeManager.class);
}
public void setHost(DatePreferenceHost host) {
mHost = host;
}
@Override
public boolean isAvailable() {
return true;
public int getAvailabilityStatus() {
return isEnabled() ? AVAILABLE : DISABLED_DEPENDENT_SETTING;
}
@Override
public void updateState(Preference preference) {
if (!(preference instanceof RestrictedPreference)) {
return;
}
final Calendar now = Calendar.getInstance();
preference.setSummary(DateFormat.getLongDateFormat(mContext).format(now.getTime()));
if (!((RestrictedPreference) preference).isDisabledByAdmin()) {
boolean enableManualDateSelection = isEnabled();
preference.setEnabled(enableManualDateSelection);
}
super.updateState(preference);
preference.setEnabled(isEnabled());
}
@Override
public CharSequence getSummary() {
Calendar now = Calendar.getInstance();
return DateFormat.getLongDateFormat(mContext).format(now.getTime());
}
@Override
public boolean handlePreferenceTreeClick(Preference preference) {
if (!TextUtils.equals(preference.getKey(), KEY_DATE)) {
if (!TextUtils.equals(getPreferenceKey(), preference.getKey())) {
return false;
}
mHost.showDatePicker();
return true;
}
@Override
public String getPreferenceKey() {
return KEY_DATE;
}
@Override
public void onDateSet(DatePicker view, int year, int month, int day) {
setDate(year, month, day);

47
src/com/android/settings/datetime/DateTimeSettings.java
View File

@@ -16,21 +16,17 @@
package com.android.settings.datetime;
import android.app.Activity;
import android.app.Dialog;
import android.app.settings.SettingsEnums;
import android.app.timedetector.TimeDetectorHelper;
import android.content.Context;
import android.content.Intent;
import com.android.settings.R;
import com.android.settings.dashboard.DashboardFragment;
import com.android.settings.search.BaseSearchIndexProvider;
import com.android.settingslib.core.AbstractPreferenceController;
import com.android.settingslib.search.SearchIndexable;
import java.util.ArrayList;
import java.util.List;
import com.google.android.setupcompat.util.WizardManagerHelper;
@SearchIndexable
public class DateTimeSettings extends DashboardFragment implements
@@ -59,40 +55,19 @@ public class DateTimeSettings extends DashboardFragment implements
@Override
public void onAttach(Context context) {
super.onAttach(context);
boolean isFromSUW = WizardManagerHelper.isAnySetupWizard(getIntent());
getSettingsLifecycle().addObserver(new TimeChangeListenerMixin(context, this));
use(LocationTimeZoneDetectionPreferenceController.class).setFragment(this);
}
use(AutoTimePreferenceController.class).setDateAndTimeCallback(this);
use(DatePreferenceController.class).setHost(this);
use(TimePreferenceController.class).setHost(this);
use(AutoTimeZonePreferenceController.class)
.setTimeAndDateCallback(this)
.setFromSUW(isFromSUW);
use(TimeFormatPreferenceController.class)
.setTimeAndDateCallback(this)
.setFromSUW(isFromSUW);
@Override
protected List<AbstractPreferenceController> createPreferenceControllers(Context context) {
final List<AbstractPreferenceController> controllers = new ArrayList<>();
final Activity activity = getActivity();
final Intent intent = activity.getIntent();
final boolean isFromSUW = intent.getBooleanExtra(EXTRA_IS_FROM_SUW, false);
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(autoTimeFormatPreferenceController);
controllers.add(new TimeFormatPreferenceController(
activity, this /* UpdateTimeAndDateCallback */, isFromSUW));
return controllers;
}
@Override

90
src/com/android/settings/datetime/TimeFormatPreferenceController.java
View File

@@ -19,77 +19,93 @@ package com.android.settings.datetime;
import android.content.Context;
import android.content.Intent;
import android.provider.Settings;
import android.text.TextUtils;
import android.text.format.DateFormat;
import androidx.preference.Preference;
import androidx.preference.TwoStatePreference;
import com.android.settings.core.PreferenceControllerMixin;
import com.android.settingslib.core.AbstractPreferenceController;
import com.android.settings.R;
import com.android.settings.core.TogglePreferenceController;
import java.util.Calendar;
import java.util.Date;
public class TimeFormatPreferenceController extends AbstractPreferenceController
implements PreferenceControllerMixin {
public class TimeFormatPreferenceController extends TogglePreferenceController {
static final String HOURS_12 = "12";
static final String HOURS_24 = "24";
private static final String KEY_TIME_FORMAT = "24 hour";
// Used for showing the current date format, which looks like "12/31/2010", "2010/12/13", etc.
// The date value is stubs (independent of actual date).
private final Calendar mDummyDate;
private final boolean mIsFromSUW;
private final UpdateTimeAndDateCallback mUpdateTimeAndDateCallback;
private boolean mIsFromSUW;
private UpdateTimeAndDateCallback mUpdateTimeAndDateCallback;
public TimeFormatPreferenceController(Context context, UpdateTimeAndDateCallback callback,
boolean isFromSUW) {
super(context);
mIsFromSUW = isFromSUW;
public TimeFormatPreferenceController(Context context, String key) {
super(context, key);
mDummyDate = Calendar.getInstance();
}
/**
* Set the Time and Date callback
*/
public TimeFormatPreferenceController setTimeAndDateCallback(
UpdateTimeAndDateCallback callback) {
mUpdateTimeAndDateCallback = callback;
return this;
}
/**
* Set if current fragment is launched via SUW
*/
public TimeFormatPreferenceController setFromSUW(boolean isFromSUW) {
mIsFromSUW = isFromSUW;
return this;
}
@Override
public boolean isAvailable() {
return !mIsFromSUW;
public int getAvailabilityStatus() {
if (mIsFromSUW) {
return DISABLED_DEPENDENT_SETTING;
}
if (AutoTimeFormatPreferenceController.isAutoTimeFormatSelection(mContext)) {
return DISABLED_DEPENDENT_SETTING;
}
return AVAILABLE;
}
@Override
public void updateState(Preference preference) {
if (!(preference instanceof TwoStatePreference)) {
return;
}
preference.setEnabled(
!AutoTimeFormatPreferenceController.isAutoTimeFormatSelection(mContext));
((TwoStatePreference) preference).setChecked(is24Hour());
super.updateState(preference);
preference.setEnabled(getAvailabilityStatus() == AVAILABLE);
refreshSummary(preference);
}
@Override
public boolean isChecked() {
return is24Hour();
}
@Override
public boolean setChecked(boolean isChecked) {
update24HourFormat(mContext, isChecked);
mUpdateTimeAndDateCallback.updateTimeAndDateDisplay(mContext);
return true;
}
@Override
public CharSequence getSummary() {
final Calendar now = Calendar.getInstance();
mDummyDate.setTimeZone(now.getTimeZone());
// We use December 31st because it's unambiguous when demonstrating the date format.
// We use 13:00 so we can demonstrate the 12/24 hour options.
mDummyDate.set(now.get(Calendar.YEAR), 11, 31, 13, 0, 0);
final Date dummyDate = mDummyDate.getTime();
preference.setSummary(DateFormat.getTimeFormat(mContext).format(dummyDate));
return DateFormat.getTimeFormat(mContext).format(dummyDate);
}
@Override
public boolean handlePreferenceTreeClick(Preference preference) {
if (!(preference instanceof TwoStatePreference)
|| !TextUtils.equals(KEY_TIME_FORMAT, preference.getKey())) {
return false;
}
final boolean is24Hour = ((TwoStatePreference) preference).isChecked();
update24HourFormat(mContext, is24Hour);
mUpdateTimeAndDateCallback.updateTimeAndDateDisplay(mContext);
return true;
}
@Override
public String getPreferenceKey() {
return KEY_TIME_FORMAT;
public int getSliceHighlightMenuRes() {
return R.string.menu_key_system;
}
private boolean is24Hour() {

69
src/com/android/settings/datetime/TimePreferenceController.java
View File

@@ -16,7 +16,11 @@
package com.android.settings.datetime;
import static android.app.time.Capabilities.CAPABILITY_POSSESSED;
import android.app.TimePickerDialog;
import android.app.time.TimeCapabilities;
import android.app.time.TimeManager;
import android.app.timedetector.ManualTimeSuggestion;
import android.app.timedetector.TimeDetector;
import android.content.Context;
@@ -27,14 +31,12 @@ import android.widget.TimePicker;
import androidx.preference.Preference;
import com.android.settings.core.PreferenceControllerMixin;
import com.android.settingslib.RestrictedPreference;
import com.android.settingslib.core.AbstractPreferenceController;
import com.android.settings.core.BasePreferenceController;
import java.util.Calendar;
public class TimePreferenceController extends AbstractPreferenceController
implements PreferenceControllerMixin, TimePickerDialog.OnTimeSetListener {
public class TimePreferenceController extends BasePreferenceController
implements TimePickerDialog.OnTimeSetListener {
public interface TimePreferenceHost extends UpdateTimeAndDateCallback {
void showTimePicker();
@@ -43,52 +45,45 @@ public class TimePreferenceController extends AbstractPreferenceController
public static final int DIALOG_TIMEPICKER = 1;
private static final String TAG = "TimePreferenceController";
private static final String KEY_TIME = "time";
private final DatePreferenceController mDatePreferenceController;
private final TimePreferenceHost mHost;
private TimePreferenceHost mHost;
private TimeManager mTimeManager;
public TimePreferenceController(Context context, String preferenceKey) {
super(context, preferenceKey);
mTimeManager = context.getSystemService(TimeManager.class);
}
public TimePreferenceController(Context context,
TimePreferenceHost callback,
DatePreferenceController datePreferenceController) {
super(context);
mHost = callback;
mDatePreferenceController = datePreferenceController;
public void setHost(TimePreferenceHost host) {
mHost = host;
}
@Override
public boolean isAvailable() {
return true;
public int getAvailabilityStatus() {
return isEnabled() ? AVAILABLE : DISABLED_DEPENDENT_SETTING;
}
@Override
public void updateState(Preference preference) {
if (!(preference instanceof RestrictedPreference)) {
return;
}
final Calendar now = Calendar.getInstance();
preference.setSummary(DateFormat.getTimeFormat(mContext).format(now.getTime()));
if (!((RestrictedPreference) preference).isDisabledByAdmin()) {
boolean enableManualTimeSelection = mDatePreferenceController.isEnabled();
preference.setEnabled(enableManualTimeSelection);
}
super.updateState(preference);
preference.setEnabled(isEnabled());
}
@Override
public CharSequence getSummary() {
Calendar now = Calendar.getInstance();
return DateFormat.getTimeFormat(mContext).format(now.getTime());
}
@Override
public boolean handlePreferenceTreeClick(Preference preference) {
if (!TextUtils.equals(KEY_TIME, preference.getKey())) {
if (!TextUtils.equals(getPreferenceKey(), preference.getKey())) {
return false;
}
mHost.showTimePicker();
return true;
}
@Override
public String getPreferenceKey() {
return KEY_TIME;
}
@Override
public void onTimeSet(TimePicker view, int hourOfDay, int minute) {
if (mContext != null) {
@@ -132,4 +127,16 @@ public class TimePreferenceController extends AbstractPreferenceController
Log.w(TAG, "Unable to set time with suggestion=" + 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.getSetManualTimeCapability();
return suggestManualTimeCapability == CAPABILITY_POSSESSED;
}
}

43
src/com/android/settings/datetime/TimeZonePreferenceController.java
View File

@@ -25,45 +25,34 @@ import android.content.Context;
import androidx.annotation.VisibleForTesting;
import androidx.preference.Preference;
import com.android.settings.core.PreferenceControllerMixin;
import com.android.settingslib.RestrictedPreference;
import com.android.settingslib.core.AbstractPreferenceController;
import com.android.settings.core.BasePreferenceController;
import com.android.settingslib.datetime.ZoneGetter;
import java.util.Calendar;
public class TimeZonePreferenceController extends AbstractPreferenceController
implements PreferenceControllerMixin {
private static final String KEY_TIMEZONE = "timezone";
public class TimeZonePreferenceController extends BasePreferenceController {
private final TimeManager mTimeManager;
public TimeZonePreferenceController(Context context) {
super(context);
public TimeZonePreferenceController(Context context, String preferenceKey) {
super(context, preferenceKey);
mTimeManager = context.getSystemService(TimeManager.class);
}
@Override
public CharSequence getSummary() {
return getTimeZoneOffsetAndName();
}
@Override
public int getAvailabilityStatus() {
return shouldEnableManualTimeZoneSelection() ? AVAILABLE : DISABLED_DEPENDENT_SETTING;
}
@Override
public void updateState(Preference preference) {
if (!(preference instanceof RestrictedPreference)) {
return;
}
preference.setSummary(getTimeZoneOffsetAndName());
if (!((RestrictedPreference) preference).isDisabledByAdmin()) {
boolean enableManualTimeZoneSelection = shouldEnableManualTimeZoneSelection();
preference.setEnabled(enableManualTimeZoneSelection);
}
}
@Override
public boolean isAvailable() {
return true;
}
@Override
public String getPreferenceKey() {
return KEY_TIMEZONE;
super.updateState(preference);
preference.setEnabled(shouldEnableManualTimeZoneSelection());
}
@VisibleForTesting

42
tests/robotests/src/com/android/settings/datetime/AutoTimeFormatPreferenceControllerTest.java
View File

@@ -53,13 +53,13 @@ public class AutoTimeFormatPreferenceControllerTest {
MockitoAnnotations.initMocks(this);
mApplication = ShadowApplication.getInstance();
mContext = RuntimeEnvironment.application;
mController = new TestAutoTimeFormatPreferenceController(mContext, "test_key");
mPreference = new SwitchPreference(mContext);
mPreference.setKey("test_key");
}
@Test
public void updateState_24HourSet_shouldCheckPreference() {
mController = new TestAutoTimeFormatPreferenceController(mContext, mCallback);
mPreference = new SwitchPreference(mContext);
mPreference.setKey(mController.getPreferenceKey());
Settings.System.putString(mContext.getContentResolver(), Settings.System.TIME_12_24,
TimeFormatPreferenceController.HOURS_24);
@@ -70,9 +70,6 @@ public class AutoTimeFormatPreferenceControllerTest {
@Test
public void updateState_12HourSet_shouldCheckPreference() {
mController = new TestAutoTimeFormatPreferenceController(mContext, mCallback);
mPreference = new SwitchPreference(mContext);
mPreference.setKey(mController.getPreferenceKey());
Settings.System.putString(mContext.getContentResolver(), Settings.System.TIME_12_24,
TimeFormatPreferenceController.HOURS_12);
@@ -83,9 +80,6 @@ public class AutoTimeFormatPreferenceControllerTest {
@Test
public void updateState_autoSet_shouldNotCheckPreference() {
mController = new TestAutoTimeFormatPreferenceController(mContext, mCallback);
mPreference = new SwitchPreference(mContext);
mPreference.setKey(mController.getPreferenceKey());
Settings.System.putString(mContext.getContentResolver(), Settings.System.TIME_12_24, null);
mController.updateState(mPreference);
@@ -95,14 +89,7 @@ public class AutoTimeFormatPreferenceControllerTest {
@Test
public void updatePreference_autoSet_shouldSendIntent_12HourLocale() {
mController = new TestAutoTimeFormatPreferenceController(mContext, mCallback);
mPreference = new SwitchPreference(mContext);
mPreference.setKey(mController.getPreferenceKey());
mPreference.setChecked(false);
boolean result = mController.handlePreferenceTreeClick(mPreference);
assertThat(result).isTrue();
mController.setChecked(false);
List<Intent> intentsFired = mApplication.getBroadcastIntents();
assertThat(intentsFired.size()).isEqualTo(1);
@@ -114,15 +101,9 @@ public class AutoTimeFormatPreferenceControllerTest {
@Test
public void updatePreference_autoSet_shouldSendIntent_24HourLocale() {
mController = new TestAutoTimeFormatPreferenceController(mContext, mCallback);
mPreference = new SwitchPreference(mContext);
mPreference.setKey(mController.getPreferenceKey());
mPreference.setChecked(false);
mController.setIs24HourLocale(true);
boolean result = mController.handlePreferenceTreeClick(mPreference);
assertThat(result).isTrue();
mController.setChecked(false);
List<Intent> intentsFired = mApplication.getBroadcastIntents();
assertThat(intentsFired.size()).isEqualTo(1);
@@ -134,15 +115,9 @@ public class AutoTimeFormatPreferenceControllerTest {
@Test
public void updatePreference_24HourSet_shouldSendIntent() {
mController = new TestAutoTimeFormatPreferenceController(mContext, mCallback);
mPreference = new SwitchPreference(mContext);
mPreference.setKey(mController.getPreferenceKey());
mPreference.setChecked(true);
mController.setIs24HourLocale(false);
boolean result = mController.handlePreferenceTreeClick(mPreference);
assertThat(result).isTrue();
mController.setChecked(true);
List<Intent> intentsFired = mApplication.getBroadcastIntents();
assertThat(intentsFired.size()).isEqualTo(1);
@@ -161,9 +136,8 @@ public class AutoTimeFormatPreferenceControllerTest {
private boolean is24HourLocale = false;
private TestAutoTimeFormatPreferenceController(Context context,
UpdateTimeAndDateCallback callback) {
super(context, callback);
TestAutoTimeFormatPreferenceController(Context context, String preferenceKey) {
super(context, preferenceKey);
}
void setIs24HourLocale(boolean value) {

52
tests/robotests/src/com/android/settings/datetime/AutoTimePreferenceControllerTest.java
View File

@@ -16,6 +16,8 @@
package com.android.settings.datetime;
import static com.android.settings.core.BasePreferenceController.DISABLED_DEPENDENT_SETTING;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.spy;
@@ -59,7 +61,8 @@ public class AutoTimePreferenceControllerTest {
mPreference = new Preference(mContext);
when(mContext.getSystemService(TimeManager.class)).thenReturn(mTimeManager);
mController = new AutoTimePreferenceController(mContext, mCallback);
mController = new AutoTimePreferenceController(mContext, "test_key");
mController.setDateAndTimeCallback(mCallback);
}
@Test
@@ -68,7 +71,7 @@ public class AutoTimePreferenceControllerTest {
/* autoSupported= */false, /* autoEnabled= */false);
when(mTimeManager.getTimeCapabilitiesAndConfig()).thenReturn(capabilitiesAndConfig);
assertThat(mController.isAvailable()).isFalse();
assertThat(mController.getAvailabilityStatus()).isEqualTo(DISABLED_DEPENDENT_SETTING);
}
@Test
@@ -81,24 +84,23 @@ public class AutoTimePreferenceControllerTest {
}
@Test
public void testIsEnabled_shouldReadFromTimeManagerConfig() {
{
// Disabled
TimeCapabilitiesAndConfig capabilitiesAndConfig = createCapabilitiesAndConfig(
/* autoSupported= */true, /* autoEnabled= */false);
when(mTimeManager.getTimeCapabilitiesAndConfig()).thenReturn(capabilitiesAndConfig);
public void isEnabled_autoEnabledIsFalse_shouldReadFromTimeManagerConfig() {
// Disabled
TimeCapabilitiesAndConfig capabilitiesAndConfig = createCapabilitiesAndConfig(
/* autoSupported= */true, /* autoEnabled= */false);
when(mTimeManager.getTimeCapabilitiesAndConfig()).thenReturn(capabilitiesAndConfig);
assertThat(mController.isEnabled()).isFalse();
}
assertThat(mController.isEnabled()).isFalse();
}
{
// Enabled
TimeCapabilitiesAndConfig capabilitiesAndConfig = createCapabilitiesAndConfig(
/* autoSupported= */true, /* autoEnabled= */true);
when(mTimeManager.getTimeCapabilitiesAndConfig()).thenReturn(capabilitiesAndConfig);
@Test
public void isEnabled_autoEnabledIsTrue_shouldReadFromTimeManagerConfig() {
// Enabled
TimeCapabilitiesAndConfig capabilitiesAndConfig = createCapabilitiesAndConfig(
/* autoSupported= */true, /* autoEnabled= */true);
when(mTimeManager.getTimeCapabilitiesAndConfig()).thenReturn(capabilitiesAndConfig);
assertThat(mController.isEnabled()).isTrue();
}
assertThat(mController.isEnabled()).isTrue();
}
@Test
@@ -118,10 +120,10 @@ public class AutoTimePreferenceControllerTest {
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);
TimeCapabilitiesAndConfig capabilitiesAndConfigAfterUpdate = createCapabilitiesAndConfig(
/* autoSupported= */true, /* autoEnabled= */true);
when(mTimeManager.getTimeCapabilitiesAndConfig()).thenReturn(
capabilitiesAndConfigAfterUpdate);
assertThat(mController.isEnabled()).isTrue();
}
@@ -145,14 +147,14 @@ public class AutoTimePreferenceControllerTest {
// 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);
when(mTimeManager.getTimeCapabilitiesAndConfig()).thenReturn(
capabilitiesAndConfigAfterUpdate);
assertThat(mController.isEnabled()).isFalse();
}
private static TimeCapabilitiesAndConfig createCapabilitiesAndConfig(
boolean autoSupported, boolean autoEnabled) {
private static TimeCapabilitiesAndConfig createCapabilitiesAndConfig(boolean autoSupported,
boolean autoEnabled) {
int configureAutoDetectionEnabledCapability =
autoSupported ? Capabilities.CAPABILITY_POSSESSED
: Capabilities.CAPABILITY_NOT_SUPPORTED;

90
tests/robotests/src/com/android/settings/datetime/AutoTimeZonePreferenceControllerTest.java
View File

@@ -22,6 +22,8 @@ import static android.app.time.DetectorStatusTypes.DETECTOR_STATUS_RUNNING;
import static android.app.time.LocationTimeZoneAlgorithmStatus.PROVIDER_STATUS_NOT_PRESENT;
import static android.app.time.LocationTimeZoneAlgorithmStatus.PROVIDER_STATUS_NOT_READY;
import static com.android.settings.core.BasePreferenceController.DISABLED_DEPENDENT_SETTING;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.spy;
@@ -62,6 +64,8 @@ public class AutoTimeZonePreferenceControllerTest {
@Mock
private TimeManager mTimeManager;
private AutoTimeZonePreferenceController mController;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
@@ -70,6 +74,9 @@ public class AutoTimeZonePreferenceControllerTest {
mPreference = new Preference(mContext);
when(mContext.getSystemService(TimeManager.class)).thenReturn(mTimeManager);
mController = new AutoTimeZonePreferenceController(mContext, "test_key");
mController.setFromSUW(false);
}
@Test
@@ -78,10 +85,9 @@ public class AutoTimeZonePreferenceControllerTest {
/* autoSupported= */true, /* autoEnabled= */false);
when(mTimeManager.getTimeZoneCapabilitiesAndConfig()).thenReturn(capabilitiesAndConfig);
AutoTimeZonePreferenceController controller = new AutoTimeZonePreferenceController(
mContext, null /* callback */, true /* isFromSUW */);
mController.setFromSUW(true);
assertThat(controller.isAvailable()).isFalse();
assertThat(mController.getAvailabilityStatus()).isEqualTo(DISABLED_DEPENDENT_SETTING);
}
@Test
@@ -90,10 +96,9 @@ public class AutoTimeZonePreferenceControllerTest {
/* autoSupported= */true, /* autoEnabled= */false);
when(mTimeManager.getTimeZoneCapabilitiesAndConfig()).thenReturn(capabilitiesAndConfig);
AutoTimeZonePreferenceController controller = new AutoTimeZonePreferenceController(
mContext, null /* callback */, false /* isFromSUW */);
mController.setFromSUW(false);
assertThat(controller.isAvailable()).isTrue();
assertThat(mController.isAvailable()).isTrue();
}
@Test
@@ -102,10 +107,7 @@ public class AutoTimeZonePreferenceControllerTest {
/* autoSupported= */false, /* autoEnabled= */false);
when(mTimeManager.getTimeZoneCapabilitiesAndConfig()).thenReturn(capabilitiesAndConfig);
AutoTimeZonePreferenceController controller = new AutoTimeZonePreferenceController(
mContext, null /* callback */, false /* fromSUW */);
assertThat(controller.isAvailable()).isFalse();
assertThat(mController.getAvailabilityStatus()).isEqualTo(DISABLED_DEPENDENT_SETTING);
}
@Test
@@ -114,10 +116,9 @@ public class AutoTimeZonePreferenceControllerTest {
/* autoSupported= */false, /* autoEnabled= */false);
when(mTimeManager.getTimeZoneCapabilitiesAndConfig()).thenReturn(capabilitiesAndConfig);
AutoTimeZonePreferenceController controller = new AutoTimeZonePreferenceController(
mContext, null /* callback */, true /* fromSUW */);
mController.setFromSUW(true);
assertThat(controller.isEnabled()).isFalse();
assertThat(mController.getAvailabilityStatus()).isEqualTo(DISABLED_DEPENDENT_SETTING);
}
@Test
@@ -126,10 +127,9 @@ public class AutoTimeZonePreferenceControllerTest {
/* autoSupported= */false, /* autoEnabled= */true);
when(mTimeManager.getTimeZoneCapabilitiesAndConfig()).thenReturn(capabilitiesAndConfig);
AutoTimeZonePreferenceController controller = new AutoTimeZonePreferenceController(
mContext, null /* callback */, true /* fromSUW */);
mController.setFromSUW(true);
assertThat(controller.isEnabled()).isTrue();
assertThat(mController.isAvailable()).isTrue();
}
@Test
@@ -138,34 +138,27 @@ public class AutoTimeZonePreferenceControllerTest {
/* autoSupported= */false, /* autoEnabled= */false);
when(mTimeManager.getTimeZoneCapabilitiesAndConfig()).thenReturn(capabilitiesAndConfig);
AutoTimeZonePreferenceController controller = new AutoTimeZonePreferenceController(
mContext, null /* callback */, false /* fromSUW */);
assertThat(controller.isEnabled()).isFalse();
assertThat(mController.isEnabled()).isFalse();
}
@Test
public void testIsEnabled_shouldReadFromTimeManagerConfig() {
AutoTimeZonePreferenceController controller = new AutoTimeZonePreferenceController(
mContext, null /* callback */, false /* fromSUW */);
public void isEnabled_autoEnabledIsFalse_shouldReadFromTimeManagerConfig() {
// Disabled
TimeZoneCapabilitiesAndConfig capabilitiesAndConfig = createCapabilitiesAndConfig(
/* autoSupported= */true, /* autoEnabled= */false);
when(mTimeManager.getTimeZoneCapabilitiesAndConfig()).thenReturn(capabilitiesAndConfig);
{
// Disabled
TimeZoneCapabilitiesAndConfig capabilitiesAndConfig = createCapabilitiesAndConfig(
/* autoSupported= */true, /* autoEnabled= */false);
when(mTimeManager.getTimeZoneCapabilitiesAndConfig()).thenReturn(capabilitiesAndConfig);
assertThat(mController.isEnabled()).isFalse();
}
assertThat(controller.isEnabled()).isFalse();
}
@Test
public void isEnabled_autoEnabledIsTrue_shouldReadFromTimeManagerConfig() {
// Enabled
TimeZoneCapabilitiesAndConfig capabilitiesAndConfig = createCapabilitiesAndConfig(
/* autoSupported= */true, /* autoEnabled= */true);
when(mTimeManager.getTimeZoneCapabilitiesAndConfig()).thenReturn(capabilitiesAndConfig);
{
// Enabled
TimeZoneCapabilitiesAndConfig capabilitiesAndConfig = createCapabilitiesAndConfig(
/* autoSupported= */true, /* autoEnabled= */true);
when(mTimeManager.getTimeZoneCapabilitiesAndConfig()).thenReturn(capabilitiesAndConfig);
assertThat(controller.isEnabled()).isTrue();
}
assertThat(mController.isEnabled()).isTrue();
}
@Test
@@ -175,10 +168,9 @@ public class AutoTimeZonePreferenceControllerTest {
when(mTimeManager.getTimeZoneCapabilitiesAndConfig()).thenReturn(capabilitiesAndConfig);
when(mTimeManager.updateTimeZoneConfiguration(Mockito.any())).thenReturn(true);
AutoTimeZonePreferenceController controller = new AutoTimeZonePreferenceController(
mContext, mCallback, false /* fromSUW */);
mController.setTimeAndDateCallback(mCallback);
assertThat(controller.onPreferenceChange(mPreference, true)).isTrue();
assertThat(mController.onPreferenceChange(mPreference, true)).isTrue();
verify(mCallback).updateTimeAndDateDisplay(mContext);
// Check the service was asked to change the configuration correctly.
@@ -193,7 +185,7 @@ public class AutoTimeZonePreferenceControllerTest {
when(mTimeManager.getTimeZoneCapabilitiesAndConfig())
.thenReturn(capabilitiesAndConfigAfterUpdate);
assertThat(controller.isEnabled()).isTrue();
assertThat(mController.isEnabled()).isTrue();
}
@Test
@@ -203,10 +195,9 @@ public class AutoTimeZonePreferenceControllerTest {
when(mTimeManager.getTimeZoneCapabilitiesAndConfig()).thenReturn(capabilitiesAndConfig);
when(mTimeManager.updateTimeZoneConfiguration(Mockito.any())).thenReturn(true);
AutoTimeZonePreferenceController controller = new AutoTimeZonePreferenceController(
mContext, mCallback, false /* fromSUW */);
mController.setTimeAndDateCallback(mCallback);
assertThat(controller.onPreferenceChange(mPreference, false)).isTrue();
assertThat(mController.onPreferenceChange(mPreference, false)).isTrue();
verify(mCallback).updateTimeAndDateDisplay(mContext);
// Check the service was asked to change the configuration correctly.
@@ -221,13 +212,12 @@ public class AutoTimeZonePreferenceControllerTest {
when(mTimeManager.getTimeZoneCapabilitiesAndConfig())
.thenReturn(capabilitiesAndConfigAfterUpdate);
assertThat(controller.isEnabled()).isFalse();
assertThat(mController.isEnabled()).isFalse();
}
@Test
public void getSummary() {
AutoTimeZonePreferenceController controller = new AutoTimeZonePreferenceController(
mContext, mCallback, false /* fromSUW */);
mController.setTimeAndDateCallback(mCallback);
TimeZoneCapabilitiesAndConfig capabilitiesAndConfig = createCapabilitiesAndConfig(
/* autoSupported= */true, /* autoEnabled= */true, /* telephonySupported= */
@@ -235,7 +225,7 @@ public class AutoTimeZonePreferenceControllerTest {
when(mTimeManager.getTimeZoneCapabilitiesAndConfig()).thenReturn(capabilitiesAndConfig);
when(mTimeManager.updateTimeZoneConfiguration(Mockito.any())).thenReturn(true);
assertThat(controller.getSummary()).isEqualTo("");
assertThat(mController.getSummary()).isEqualTo("");
capabilitiesAndConfig = createCapabilitiesAndConfig(
/* autoSupported= */true, /* autoEnabled= */true, /* telephonySupported= */
@@ -243,7 +233,7 @@ public class AutoTimeZonePreferenceControllerTest {
when(mTimeManager.getTimeZoneCapabilitiesAndConfig()).thenReturn(capabilitiesAndConfig);
when(mTimeManager.updateTimeZoneConfiguration(Mockito.any())).thenReturn(true);
assertThat(controller.getSummary()).isEqualTo(
assertThat(mController.getSummary()).isEqualTo(
mContext.getString(R.string.auto_zone_requires_location_summary));
}

10
tests/robotests/src/com/android/settings/datetime/DatePreferenceControllerTest.java
View File

@@ -74,12 +74,8 @@ public class DatePreferenceControllerTest {
when(mContext.getSystemService(TimeDetector.class)).thenReturn(mTimeDetector);
when(mContext.getSystemService(TimeManager.class)).thenReturn(mTimeManager);
mPreference = new RestrictedPreference(RuntimeEnvironment.application);
mController = new DatePreferenceController(mContext, mHost);
}
@Test
public void isAlwaysAvailable() {
assertThat(mController.isAvailable()).isTrue();
mController = new DatePreferenceController(mContext, "test_key");
mController.setHost(mHost);
}
@Test
@@ -147,7 +143,7 @@ public class DatePreferenceControllerTest {
assertEquals(2020, calendar.get(Calendar.YEAR));
}
private static TimeCapabilitiesAndConfig createCapabilitiesAndConfig(
static TimeCapabilitiesAndConfig createCapabilitiesAndConfig(
boolean suggestManualAllowed) {
int suggestManualCapability = suggestManualAllowed ? Capabilities.CAPABILITY_POSSESSED
: Capabilities.CAPABILITY_NOT_SUPPORTED;

47
tests/robotests/src/com/android/settings/datetime/TimeFormatPreferenceControllerTest.java
View File

@@ -16,13 +16,15 @@
package com.android.settings.datetime;
import static com.android.settings.core.BasePreferenceController.AVAILABLE;
import static com.android.settings.core.BasePreferenceController.DISABLED_DEPENDENT_SETTING;
import static com.google.common.truth.Truth.assertThat;
import android.content.Context;
import android.content.Intent;
import android.provider.Settings;
import androidx.preference.PreferenceScreen;
import androidx.preference.SwitchPreference;
import org.junit.Before;
@@ -52,27 +54,30 @@ public class TimeFormatPreferenceControllerTest {
MockitoAnnotations.initMocks(this);
mApplication = ShadowApplication.getInstance();
mContext = RuntimeEnvironment.application;
mController = new TimeFormatPreferenceController(mContext, "test_key");
mController.setTimeAndDateCallback(mCallback);
mController.setFromSUW(false);
mPreference = new SwitchPreference(mContext);
mPreference.setKey("test_key");
}
@Test
public void isCalledFromSUW_NotAvailable() {
mController = new TimeFormatPreferenceController(mContext, mCallback, true);
mController.setFromSUW(true);
assertThat(mController.isAvailable()).isFalse();
assertThat(mController.getAvailabilityStatus()).isEqualTo(DISABLED_DEPENDENT_SETTING);
}
@Test
public void notCalledFromSUW_shouldBeAvailable() {
mController = new TimeFormatPreferenceController(mContext, mCallback, false);
assertThat(mController.isAvailable()).isTrue();
Settings.System.putString(mContext.getContentResolver(), Settings.System.TIME_12_24,
TimeFormatPreferenceController.HOURS_24);
assertThat(mController.getAvailabilityStatus()).isEqualTo(AVAILABLE);
}
@Test
public void updateState_24HourSet_shouldCheckPreference() {
mController = new TimeFormatPreferenceController(mContext, mCallback, false);
mPreference = new SwitchPreference(mContext);
mPreference.setKey(mController.getPreferenceKey());
Settings.System.putString(mContext.getContentResolver(), Settings.System.TIME_12_24,
TimeFormatPreferenceController.HOURS_24);
@@ -83,9 +88,6 @@ public class TimeFormatPreferenceControllerTest {
@Test
public void updateState_12HourSet_shouldNotCheckPreference() {
mController = new TimeFormatPreferenceController(mContext, mCallback, false);
mPreference = new SwitchPreference(mContext);
mPreference.setKey(mController.getPreferenceKey());
Settings.System.putString(mContext.getContentResolver(), Settings.System.TIME_12_24,
TimeFormatPreferenceController.HOURS_12);
@@ -96,10 +98,7 @@ public class TimeFormatPreferenceControllerTest {
@Test
public void updateState_autoSet_shouldNotEnablePreference() {
mController = new TimeFormatPreferenceController(mContext, mCallback, false);
Settings.System.putString(mContext.getContentResolver(), Settings.System.TIME_12_24, null);
mPreference = new SwitchPreference(mContext);
mPreference.setKey(mController.getPreferenceKey());
mController.updateState(mPreference);
@@ -108,14 +107,7 @@ public class TimeFormatPreferenceControllerTest {
@Test
public void updatePreference_12HourSet_shouldSendIntent() {
mController = new TimeFormatPreferenceController(mContext, mCallback, false);
mPreference = new SwitchPreference(mContext);
mPreference.setKey(mController.getPreferenceKey());
mPreference.setChecked(false);
boolean result = mController.handlePreferenceTreeClick(mPreference);
assertThat(result).isTrue();
mController.setChecked(false);
List<Intent> intentsFired = mApplication.getBroadcastIntents();
assertThat(intentsFired.size()).isEqualTo(1);
@@ -127,14 +119,7 @@ public class TimeFormatPreferenceControllerTest {
@Test
public void updatePreference_24HourSet_shouldSendIntent() {
mController = new TimeFormatPreferenceController(mContext, mCallback, false);
mPreference = new SwitchPreference(mContext);
mPreference.setKey(mController.getPreferenceKey());
mPreference.setChecked(true);
boolean result = mController.handlePreferenceTreeClick(mPreference);
assertThat(result).isTrue();
mController.setChecked(true);
List<Intent> intentsFired = mApplication.getBroadcastIntents();
assertThat(intentsFired.size()).isEqualTo(1);

28
tests/robotests/src/com/android/settings/datetime/TimePreferenceControllerTest.java
View File

@@ -18,9 +18,12 @@ 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.TimeCapabilitiesAndConfig;
import android.app.time.TimeManager;
import android.content.Context;
import com.android.settingslib.RestrictedPreference;
@@ -40,7 +43,7 @@ public class TimePreferenceControllerTest {
@Mock
private TimePreferenceController.TimePreferenceHost mHost;
@Mock
private DatePreferenceController mDatePreferenceController;
private TimeManager mTimeManager;
private TimePreferenceController mController;
private RestrictedPreference mPreference;
@@ -48,14 +51,11 @@ public class TimePreferenceControllerTest {
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mContext = RuntimeEnvironment.application;
mPreference = new RestrictedPreference(RuntimeEnvironment.application);
mController = new TimePreferenceController(mContext, mHost, mDatePreferenceController);
}
@Test
public void isAlwaysAvailable() {
assertThat(mController.isAvailable()).isTrue();
mContext = spy(RuntimeEnvironment.application);
when(mContext.getSystemService(TimeManager.class)).thenReturn(mTimeManager);
mPreference = new RestrictedPreference(mContext);
mController = new TimePreferenceController(mContext, "test_key");
mController.setHost(mHost);
}
@Test
@@ -63,7 +63,10 @@ public class TimePreferenceControllerTest {
// Make sure not disabled by admin.
mPreference.setDisabledByAdmin(null);
when(mDatePreferenceController.isEnabled()).thenReturn(false);
TimeCapabilitiesAndConfig capabilitiesAndConfig =
DatePreferenceControllerTest.createCapabilitiesAndConfig(/* suggestManualAllowed= */
false);
when(mTimeManager.getTimeCapabilitiesAndConfig()).thenReturn(capabilitiesAndConfig);
mController.updateState(mPreference);
assertThat(mPreference.isEnabled()).isFalse();
@@ -74,7 +77,10 @@ public class TimePreferenceControllerTest {
// Make sure not disabled by admin.
mPreference.setDisabledByAdmin(null);
when(mDatePreferenceController.isEnabled()).thenReturn(true);
TimeCapabilitiesAndConfig capabilitiesAndConfig =
DatePreferenceControllerTest.createCapabilitiesAndConfig(/* suggestManualAllowed= */
true);
when(mTimeManager.getTimeCapabilitiesAndConfig()).thenReturn(capabilitiesAndConfig);
mController.updateState(mPreference);
assertThat(mPreference.isEnabled()).isTrue();

7
tests/robotests/src/com/android/settings/datetime/TimeZonePreferenceControllerTest.java
View File

@@ -66,15 +66,10 @@ public class TimeZonePreferenceControllerTest {
mPreference = new RestrictedPreference(mContext);
mController = spy(new TimeZonePreferenceController(mContext));
mController = spy(new TimeZonePreferenceController(mContext, "test_key"));
doReturn("test timezone").when(mController).getTimeZoneOffsetAndName();
}
@Test
public void isAlwaysAvailable() {
assertThat(mController.isAvailable()).isTrue();
}
@Test
public void updateState_suggestManualNotAllowed_shouldDisablePref() {
// Make sure not disabled by admin.