Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Tidy up naming around "sync disabled" behavior"

Browse Source
This commit is contained in:
Neil Fuller
2021-06-28 16:25:11 +00:00
committed by Android (Google) Code Review
parent 993ee4cf45 b8e316c490
commit 4ede648e11
5 changed files with 72 additions and 67 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
core/java/android/provider/DeviceConfig.java
View File

@@ -868,31 +868,31 @@ public final class DeviceConfig {
/**
* Disables or re-enables bulk modifications ({@link #setProperties(Properties)}) to device
* config values. This is intended for use during tests to prevent a sync operation clearing
* config values, which could influence the outcome of the tests, i.e. by changing behavior.
* config values which could influence the outcome of the tests, i.e. by changing behavior.
*
* @param syncDisabledMode the mode to use, see {@link Settings.Config#SYNC_DISABLED_MODE_NONE},
* {@link Settings.Config#SYNC_DISABLED_MODE_PERSISTENT} and {@link
* Settings.Config#SYNC_DISABLED_MODE_UNTIL_REBOOT}
*
* @see #getSyncDisabled()
* @see #getSyncDisabledMode()
* @hide
*/
@RequiresPermission(WRITE_DEVICE_CONFIG)
public static void setSyncDisabled(@SyncDisabledMode int syncDisabledMode) {
public static void setSyncDisabledMode(@SyncDisabledMode int syncDisabledMode) {
ContentResolver contentResolver = ActivityThread.currentApplication().getContentResolver();
Settings.Config.setSyncDisabled(contentResolver, syncDisabledMode);
Settings.Config.setSyncDisabledMode(contentResolver, syncDisabledMode);
}
/**
* Returns the current mode of sync disabling.
*
* @see #setSyncDisabled(int)
* @see #setSyncDisabledMode(int)
* @hide
*/
@RequiresPermission(WRITE_DEVICE_CONFIG)
public static @SyncDisabledMode int getSyncDisabled() {
public static @SyncDisabledMode int getSyncDisabledMode() {
ContentResolver contentResolver = ActivityThread.currentApplication().getContentResolver();
return Settings.Config.getSyncDisabled(contentResolver);
return Settings.Config.getSyncDisabledMode(contentResolver);
}
/**

39
core/java/android/provider/Settings.java
View File

@@ -299,8 +299,8 @@ public final class Settings {
public static final String KEY_CONFIG_SET_ALL_RETURN = "config_set_all_return";
/** @hide */
public static final String KEY_CONFIG_GET_SYNC_DISABLED_RETURN =
"config_get_sync_disabled_return";
public static final String KEY_CONFIG_GET_SYNC_DISABLED_MODE_RETURN =
"config_get_sync_disabled_mode_return";
/**
* An int extra specifying a subscription ID.
@@ -2439,13 +2439,15 @@ public final class Settings {
public static final String CALL_METHOD_LIST_CONFIG = "LIST_config";
/** @hide - Private call() method to disable / re-enable syncs to the 'configuration' table */
public static final String CALL_METHOD_SET_SYNC_DISABLED_CONFIG = "SET_SYNC_DISABLED_config";
public static final String CALL_METHOD_SET_SYNC_DISABLED_MODE_CONFIG =
"SET_SYNC_DISABLED_MODE_config";
/**
* @hide - Private call() method to return the current mode of sync disabling for the
* 'configuration' table
*/
public static final String CALL_METHOD_GET_SYNC_DISABLED_CONFIG = "GET_SYNC_DISABLED_config";
public static final String CALL_METHOD_GET_SYNC_DISABLED_MODE_CONFIG =
"GET_SYNC_DISABLED_MODE_config";
/** @hide - Private call() method to register monitor callback for 'configuration' table */
public static final String CALL_METHOD_REGISTER_MONITOR_CALLBACK_CONFIG =
@@ -14335,8 +14337,11 @@ public final class Settings {
"are_user_disabled_hdr_formats_allowed";
/**
* Whether or not syncs (bulk set operations) for {@link DeviceConfig} are disabled
* currently. The value is boolean (1 or 0). The value '1' means that {@link
* Whether or not syncs (bulk set operations) for {@link DeviceConfig} are currently
* persistently disabled. This is only used for the {@link
* Config#SYNC_DISABLED_MODE_PERSISTENT persistent} mode, {@link
* Config#SYNC_DISABLED_MODE_UNTIL_REBOOT until_reboot} mode is not stored in settings.
* The value is boolean (1 or 0). The value '1' means that {@link
* DeviceConfig#setProperties(DeviceConfig.Properties)} will return {@code false}.
*
* @hide
@@ -16707,45 +16712,45 @@ public final class Settings {
}
/**
* Bridge method between {@link DeviceConfig#setSyncDisabled(int)} and the
* Bridge method between {@link DeviceConfig#setSyncDisabledMode(int)} and the
* {@link com.android.providers.settings.SettingsProvider} implementation.
*
* @hide
*/
@SuppressLint("AndroidFrameworkRequiresPermission")
@RequiresPermission(Manifest.permission.WRITE_DEVICE_CONFIG)
static void setSyncDisabled(
static void setSyncDisabledMode(
@NonNull ContentResolver resolver, @SyncDisabledMode int disableSyncMode) {
try {
Bundle args = new Bundle();
args.putInt(CALL_METHOD_SYNC_DISABLED_MODE_KEY, disableSyncMode);
IContentProvider cp = sProviderHolder.getProvider(resolver);
cp.call(resolver.getAttributionSource(),
sProviderHolder.mUri.getAuthority(), CALL_METHOD_SET_SYNC_DISABLED_CONFIG,
null, args);
cp.call(resolver.getAttributionSource(), sProviderHolder.mUri.getAuthority(),
CALL_METHOD_SET_SYNC_DISABLED_MODE_CONFIG, null, args);
} catch (RemoteException e) {
Log.w(TAG, "Can't set sync disabled " + DeviceConfig.CONTENT_URI, e);
Log.w(TAG, "Can't set sync disabled mode " + DeviceConfig.CONTENT_URI, e);
}
}
/**
* Bridge method between {@link DeviceConfig#getSyncDisabled()} and the
* Bridge method between {@link DeviceConfig#getSyncDisabledMode()} and the
* {@link com.android.providers.settings.SettingsProvider} implementation.
*
* @hide
*/
@SuppressLint("AndroidFrameworkRequiresPermission")
@RequiresPermission(Manifest.permission.WRITE_DEVICE_CONFIG)
static int getSyncDisabled(@NonNull ContentResolver resolver) {
static int getSyncDisabledMode(@NonNull ContentResolver resolver) {
try {
Bundle args = Bundle.EMPTY;
IContentProvider cp = sProviderHolder.getProvider(resolver);
Bundle bundle = cp.call(resolver.getAttributionSource(),
sProviderHolder.mUri.getAuthority(), CALL_METHOD_GET_SYNC_DISABLED_CONFIG,
sProviderHolder.mUri.getAuthority(),
CALL_METHOD_GET_SYNC_DISABLED_MODE_CONFIG,
null, args);
return bundle.getInt(KEY_CONFIG_GET_SYNC_DISABLED_RETURN);
return bundle.getInt(KEY_CONFIG_GET_SYNC_DISABLED_MODE_RETURN);
} catch (RemoteException e) {
Log.w(TAG, "Can't query sync disabled " + DeviceConfig.CONTENT_URI, e);
Log.w(TAG, "Can't query sync disabled mode " + DeviceConfig.CONTENT_URI, e);
}
return -1;
}

22
core/tests/coretests/src/android/provider/DeviceConfigTest.java
View File

@@ -773,10 +773,10 @@ public class DeviceConfigTest {
try {
// Ensure the device starts in a known state.
DeviceConfig.setSyncDisabled(Settings.Config.SYNC_DISABLED_MODE_NONE);
DeviceConfig.setSyncDisabledMode(Settings.Config.SYNC_DISABLED_MODE_NONE);
// Assert starting state.
assertThat(DeviceConfig.getSyncDisabled())
assertThat(DeviceConfig.getSyncDisabledMode())
.isEqualTo(Settings.Config.SYNC_DISABLED_MODE_NONE);
assertThat(DeviceConfig.setProperties(properties1)).isTrue();
assertThat(DeviceConfig.getProperties(NAMESPACE, KEY).getString(KEY, DEFAULT_VALUE))
@@ -784,16 +784,16 @@ public class DeviceConfigTest {
// Test disabled (persistent). Persistence is not actually tested, that would require
// a host test.
DeviceConfig.setSyncDisabled(Settings.Config.SYNC_DISABLED_MODE_PERSISTENT);
assertThat(DeviceConfig.getSyncDisabled())
DeviceConfig.setSyncDisabledMode(Settings.Config.SYNC_DISABLED_MODE_PERSISTENT);
assertThat(DeviceConfig.getSyncDisabledMode())
.isEqualTo(Settings.Config.SYNC_DISABLED_MODE_PERSISTENT);
assertThat(DeviceConfig.setProperties(properties2)).isFalse();
assertThat(DeviceConfig.getProperties(NAMESPACE, KEY).getString(KEY, DEFAULT_VALUE))
.isEqualTo(VALUE);
// Return to not disabled.
DeviceConfig.setSyncDisabled(Settings.Config.SYNC_DISABLED_MODE_NONE);
assertThat(DeviceConfig.getSyncDisabled())
DeviceConfig.setSyncDisabledMode(Settings.Config.SYNC_DISABLED_MODE_NONE);
assertThat(DeviceConfig.getSyncDisabledMode())
.isEqualTo(Settings.Config.SYNC_DISABLED_MODE_NONE);
assertThat(DeviceConfig.setProperties(properties2)).isTrue();
assertThat(DeviceConfig.getProperties(NAMESPACE, KEY).getString(KEY, DEFAULT_VALUE))
@@ -801,23 +801,23 @@ public class DeviceConfigTest {
// Test disabled (persistent). Absence of persistence is not actually tested, that would
// require a host test.
DeviceConfig.setSyncDisabled(Settings.Config.SYNC_DISABLED_MODE_UNTIL_REBOOT);
assertThat(DeviceConfig.getSyncDisabled())
DeviceConfig.setSyncDisabledMode(Settings.Config.SYNC_DISABLED_MODE_UNTIL_REBOOT);
assertThat(DeviceConfig.getSyncDisabledMode())
.isEqualTo(Settings.Config.SYNC_DISABLED_MODE_UNTIL_REBOOT);
assertThat(DeviceConfig.setProperties(properties1)).isFalse();
assertThat(DeviceConfig.getProperties(NAMESPACE, KEY).getString(KEY, DEFAULT_VALUE))
.isEqualTo(VALUE2);
// Return to not disabled.
DeviceConfig.setSyncDisabled(Settings.Config.SYNC_DISABLED_MODE_NONE);
assertThat(DeviceConfig.getSyncDisabled())
DeviceConfig.setSyncDisabledMode(Settings.Config.SYNC_DISABLED_MODE_NONE);
assertThat(DeviceConfig.getSyncDisabledMode())
.isEqualTo(Settings.Config.SYNC_DISABLED_MODE_NONE);
assertThat(DeviceConfig.setProperties(properties1)).isTrue();
assertThat(DeviceConfig.getProperties(NAMESPACE, KEY).getString(KEY, DEFAULT_VALUE))
.isEqualTo(VALUE);
} finally {
// Try to return to the default sync disabled state in case of failure.
DeviceConfig.setSyncDisabled(Settings.Config.SYNC_DISABLED_MODE_NONE);
DeviceConfig.setSyncDisabledMode(Settings.Config.SYNC_DISABLED_MODE_NONE);
// NAMESPACE will be cleared by cleanUp()
}

36
packages/SettingsProvider/src/com/android/providers/settings/DeviceConfigService.java
View File

@@ -118,7 +118,7 @@ public final class DeviceConfigService extends Binder {
}
// Parse args for those commands that have them.
int disableSyncMode = -1;
int syncDisabledModeArg = -1;
int resetMode = -1;
boolean makeDefault = false;
String namespace = null;
@@ -155,10 +155,10 @@ public final class DeviceConfigService extends Binder {
}
}
} else if (verb == CommandVerb.SET_SYNC_DISABLED_FOR_TESTS) {
if (disableSyncMode == -1) {
// DISABLE_SYNC_FOR_TESTS 1st arg (required)
disableSyncMode = parseDisableSyncMode(arg);
if (disableSyncMode == -1) {
if (syncDisabledModeArg == -1) {
// SET_SYNC_DISABLED_FOR_TESTS 1st arg (required)
syncDisabledModeArg = parseSyncDisabledMode(arg);
if (syncDisabledModeArg == -1) {
// invalid
perr.println("Invalid sync disabled mode: " + arg);
return -1;
@@ -248,13 +248,13 @@ public final class DeviceConfigService extends Binder {
DeviceConfig.resetToDefaults(resetMode, namespace);
break;
case SET_SYNC_DISABLED_FOR_TESTS:
DeviceConfig.setSyncDisabled(disableSyncMode);
DeviceConfig.setSyncDisabledMode(syncDisabledModeArg);
break;
case GET_SYNC_DISABLED_FOR_TESTS:
int syncDisabledMode = DeviceConfig.getSyncDisabled();
String syncDisabledModeString = formatDisableSyncMode(syncDisabledMode);
int syncDisabledModeInt = DeviceConfig.getSyncDisabledMode();
String syncDisabledModeString = formatSyncDisabledMode(syncDisabledModeInt);
if (syncDisabledModeString == null) {
perr.println("Unknown mode:" + syncDisabledMode);
perr.println("Unknown mode: " + syncDisabledModeInt);
return -1;
}
pout.println(syncDisabledModeString);
@@ -362,22 +362,22 @@ public final class DeviceConfigService extends Binder {
}
}
private static @SyncDisabledMode int parseDisableSyncMode(String arg) {
int disableSyncMode;
private static @SyncDisabledMode int parseSyncDisabledMode(String arg) {
int syncDisabledMode;
if ("none".equalsIgnoreCase(arg)) {
disableSyncMode = SYNC_DISABLED_MODE_NONE;
syncDisabledMode = SYNC_DISABLED_MODE_NONE;
} else if ("persistent".equalsIgnoreCase(arg)) {
disableSyncMode = SYNC_DISABLED_MODE_PERSISTENT;
syncDisabledMode = SYNC_DISABLED_MODE_PERSISTENT;
} else if ("until_reboot".equalsIgnoreCase(arg)) {
disableSyncMode = SYNC_DISABLED_MODE_UNTIL_REBOOT;
syncDisabledMode = SYNC_DISABLED_MODE_UNTIL_REBOOT;
} else {
disableSyncMode = -1;
syncDisabledMode = -1;
}
return disableSyncMode;
return syncDisabledMode;
}
private static String formatDisableSyncMode(@SyncDisabledMode int disableSyncMode) {
switch (disableSyncMode) {
private static String formatSyncDisabledMode(@SyncDisabledMode int syncDisabledMode) {
switch (syncDisabledMode) {
case SYNC_DISABLED_MODE_NONE:
return "none";
case SYNC_DISABLED_MODE_PERSISTENT:

28
packages/SettingsProvider/src/com/android/providers/settings/SettingsProvider.java
View File

@@ -471,16 +471,16 @@ public class SettingsProvider extends ContentProvider {
return result;
}
case Settings.CALL_METHOD_SET_SYNC_DISABLED_CONFIG: {
case Settings.CALL_METHOD_SET_SYNC_DISABLED_MODE_CONFIG: {
final int mode = getSyncDisabledMode(args);
setSyncDisabledConfig(mode);
setSyncDisabledModeConfig(mode);
break;
}
case Settings.CALL_METHOD_GET_SYNC_DISABLED_CONFIG: {
case Settings.CALL_METHOD_GET_SYNC_DISABLED_MODE_CONFIG: {
Bundle result = new Bundle();
result.putInt(Settings.KEY_CONFIG_GET_SYNC_DISABLED_RETURN,
getSyncDisabledConfig());
result.putInt(Settings.KEY_CONFIG_GET_SYNC_DISABLED_MODE_RETURN,
getSyncDisabledModeConfig());
return result;
}
@@ -1147,7 +1147,7 @@ public class SettingsProvider extends ContentProvider {
enforceWritePermission(Manifest.permission.WRITE_DEVICE_CONFIG);
synchronized (mLock) {
if (getSyncDisabledConfigLocked() != SYNC_DISABLED_MODE_NONE) {
if (getSyncDisabledModeConfigLocked() != SYNC_DISABLED_MODE_NONE) {
return SET_ALL_RESULT_DISABLED;
}
final int key = makeKey(SETTINGS_TYPE_CONFIG, UserHandle.USER_SYSTEM);
@@ -1157,32 +1157,32 @@ public class SettingsProvider extends ContentProvider {
}
}
private void setSyncDisabledConfig(@SyncDisabledMode int syncDisabledMode) {
private void setSyncDisabledModeConfig(@SyncDisabledMode int syncDisabledMode) {
if (DEBUG) {
Slog.v(LOG_TAG, "setSyncDisabledConfig(" + syncDisabledMode + ")");
Slog.v(LOG_TAG, "setSyncDisabledModeConfig(" + syncDisabledMode + ")");
}
enforceWritePermission(Manifest.permission.WRITE_DEVICE_CONFIG);
synchronized (mLock) {
setSyncDisabledConfigLocked(syncDisabledMode);
setSyncDisabledModeConfigLocked(syncDisabledMode);
}
}
private int getSyncDisabledConfig() {
private int getSyncDisabledModeConfig() {
if (DEBUG) {
Slog.v(LOG_TAG, "getSyncDisabledConfig");
Slog.v(LOG_TAG, "getSyncDisabledModeConfig");
}
enforceWritePermission(Manifest.permission.WRITE_DEVICE_CONFIG);
synchronized (mLock) {
return getSyncDisabledConfigLocked();
return getSyncDisabledModeConfigLocked();
}
}
@GuardedBy("mLock")
private void setSyncDisabledConfigLocked(@SyncDisabledMode int syncDisabledMode) {
private void setSyncDisabledModeConfigLocked(@SyncDisabledMode int syncDisabledMode) {
boolean persistentValue;
boolean inMemoryValue;
if (syncDisabledMode == SYNC_DISABLED_MODE_NONE) {
@@ -1214,7 +1214,7 @@ public class SettingsProvider extends ContentProvider {
}
@GuardedBy("mLock")
private int getSyncDisabledConfigLocked() {
private int getSyncDisabledModeConfigLocked() {
// Check the values used for both SYNC_DISABLED_MODE_PERSISTENT and
// SYNC_DISABLED_MODE_UNTIL_REBOOT.