getSettingsNamesLocked(int settingsType, int userId) {
// Don't enforce the instant app whitelist for now -- its too prone to unintended breakage
// in the current form.
return mSettingsRegistry.getSettingsNamesLocked(settingsType, userId);
}
private void enforceSettingReadable(String settingName, int settingsType, int userId) {
if (UserHandle.getAppId(Binder.getCallingUid()) < Process.FIRST_APPLICATION_UID) {
return;
}
ApplicationInfo ai = getCallingApplicationInfoOrThrow();
if (!ai.isInstantApp()) {
return;
}
if (!getInstantAppAccessibleSettings(settingsType).contains(settingName)
&& !getOverlayInstantAppAccessibleSettings(settingsType).contains(settingName)) {
// Don't enforce the instant app whitelist for now -- its too prone to unintended
// breakage in the current form.
Slog.w(LOG_TAG, "Instant App " + ai.packageName
+ " trying to access unexposed setting, this will be an error in the future.");
}
}
private ApplicationInfo getCallingApplicationInfoOrThrow() {
// We always use the callingUid for this lookup. This means that if hypothetically an
// app was installed in user A with cross user and in user B as an Instant App
// the app in A would be able to see all the settings in user B. However since cross
// user is a system permission and the app must be uninstalled in B and then installed as
// an Instant App that situation is not realistic or supported.
ApplicationInfo ai = null;
try {
ai = mPackageManager.getApplicationInfo(getCallingPackage(), 0
, UserHandle.getCallingUserId());
} catch (RemoteException ignored) {
}
if (ai == null) {
throw new IllegalStateException("Failed to lookup info for package "
+ getCallingPackage());
}
return ai;
}
private PackageInfo getCallingPackageInfoOrThrow(int userId) {
try {
PackageInfo packageInfo = mPackageManager.getPackageInfo(
getCallingPackage(), 0, userId);
if (packageInfo != null) {
return packageInfo;
}
} catch (RemoteException e) {
/* ignore */
}
throw new IllegalStateException("Calling package doesn't exist");
}
private int getGroupParentLocked(int userId) {
// Most frequent use case.
if (userId == UserHandle.USER_SYSTEM) {
return userId;
}
// We are in the same process with the user manager and the returned
// user info is a cached instance, so just look up instead of cache.
final long identity = Binder.clearCallingIdentity();
try {
// Just a lookup and not reentrant, so holding a lock is fine.
UserInfo userInfo = mUserManager.getProfileParent(userId);
return (userInfo != null) ? userInfo.id : userId;
} finally {
Binder.restoreCallingIdentity(identity);
}
}
private void enforceWritePermission(String permission) {
if (getContext().checkCallingOrSelfPermission(permission)
!= PackageManager.PERMISSION_GRANTED) {
throw new SecurityException("Permission denial: writing to settings requires:"
+ permission);
}
}
/*
* Used to parse changes to the value of Settings.Secure.LOCATION_PROVIDERS_ALLOWED.
* This setting contains a list of the currently enabled location providers.
* But helper functions in android.providers.Settings can enable or disable
* a single provider by using a "+" or "-" prefix before the provider name.
*
* See also {@link com.android.server.pm.UserRestrictionsUtils#isSettingRestrictedForUser()}.
* If DISALLOW_SHARE_LOCATION is set, the said method will only allow values with
* the "-" prefix.
*
* @returns whether the enabled location providers changed.
*/
@GuardedBy("mLock")
private boolean updateLocationProvidersAllowedLocked(String value, String tag,
int owningUserId, boolean makeDefault, boolean forceNotify) {
if (TextUtils.isEmpty(value)) {
return false;
}
Setting oldSetting = getSecureSetting(
Settings.Secure.LOCATION_PROVIDERS_ALLOWED, owningUserId);
if (oldSetting == null) {
return false;
}
String oldProviders = oldSetting.getValue();
List oldProvidersList = TextUtils.isEmpty(oldProviders)
? new ArrayList<>() : new ArrayList<>(Arrays.asList(oldProviders.split(",")));
Set newProvidersSet = new ArraySet<>();
newProvidersSet.addAll(oldProvidersList);
String[] providerUpdates = value.split(",");
boolean inputError = false;
for (String provider : providerUpdates) {
// do not update location_providers_allowed when input is invalid
if (TextUtils.isEmpty(provider)) {
inputError = true;
break;
}
final char prefix = provider.charAt(0);
// do not update location_providers_allowed when input is invalid
if (prefix != '+' && prefix != '-') {
inputError = true;
break;
}
// skip prefix
provider = provider.substring(1);
if (prefix == '+') {
newProvidersSet.add(provider);
} else if (prefix == '-') {
newProvidersSet.remove(provider);
}
}
String newProviders = TextUtils.join(",", newProvidersSet.toArray());
if (inputError == true || newProviders.equals(oldProviders)) {
// nothing changed, so no need to update the database
if (forceNotify) {
mSettingsRegistry.notifyForSettingsChange(
makeKey(SETTINGS_TYPE_SECURE, owningUserId),
Settings.Secure.LOCATION_PROVIDERS_ALLOWED);
}
return false;
}
return mSettingsRegistry.insertSettingLocked(SETTINGS_TYPE_SECURE,
owningUserId, Settings.Secure.LOCATION_PROVIDERS_ALLOWED, newProviders, tag,
makeDefault, getCallingPackage(), forceNotify, CRITICAL_SECURE_SETTINGS,
/* overrideableByRestore */ false);
}
private static void warnOrThrowForUndesiredSecureSettingsMutationForTargetSdk(
int targetSdkVersion, String name) {
// If the app targets Lollipop MR1 or older SDK we warn, otherwise crash.
if (targetSdkVersion <= Build.VERSION_CODES.LOLLIPOP_MR1) {
if (Settings.System.PRIVATE_SETTINGS.contains(name)) {
Slog.w(LOG_TAG, "You shouldn't not change private system settings."
+ " This will soon become an error.");
} else {
Slog.w(LOG_TAG, "You shouldn't keep your settings in the secure settings."
+ " This will soon become an error.");
}
} else {
if (Settings.System.PRIVATE_SETTINGS.contains(name)) {
throw new IllegalArgumentException("You cannot change private secure settings.");
} else {
throw new IllegalArgumentException("You cannot keep your settings in"
+ " the secure settings.");
}
}
}
private static int resolveCallingUserIdEnforcingPermissionsLocked(int requestingUserId) {
if (requestingUserId == UserHandle.getCallingUserId()) {
return requestingUserId;
}
return ActivityManager.handleIncomingUser(Binder.getCallingPid(),
Binder.getCallingUid(), requestingUserId, false, true,
"get/set setting for user", null);
}
private Bundle packageValueForCallResult(Setting setting, boolean trackingGeneration) {
if (!trackingGeneration) {
if (setting == null || setting.isNull()) {
return NULL_SETTING_BUNDLE;
}
return Bundle.forPair(Settings.NameValueTable.VALUE, setting.getValue());
}
Bundle result = new Bundle();
result.putString(Settings.NameValueTable.VALUE,
!setting.isNull() ? setting.getValue() : null);
mSettingsRegistry.mGenerationRegistry.addGenerationData(result, setting.getKey());
return result;
}
private Bundle packageValuesForCallResult(HashMap keyValues,
boolean trackingGeneration) {
Bundle result = new Bundle();
result.putSerializable(Settings.NameValueTable.VALUE, keyValues);
if (trackingGeneration) {
synchronized (mLock) {
mSettingsRegistry.mGenerationRegistry.addGenerationData(result,
mSettingsRegistry.getSettingsLocked(
SETTINGS_TYPE_CONFIG, UserHandle.USER_SYSTEM).mKey);
}
}
return result;
}
private void setMonitorCallback(RemoteCallback callback) {
if (callback == null) {
return;
}
getContext().enforceCallingOrSelfPermission(
Manifest.permission.MONITOR_DEVICE_CONFIG_ACCESS,
"Permission denial: registering for config access requires: "
+ Manifest.permission.MONITOR_DEVICE_CONFIG_ACCESS);
synchronized (mLock) {
mConfigMonitorCallback = callback;
}
}
private void reportDeviceConfigAccess(@Nullable String prefix) {
if (prefix == null) {
return;
}
String callingPackage = resolveCallingPackage();
String namespace = prefix.replace("/", "");
if (DeviceConfig.getPublicNamespaces().contains(namespace)) {
return;
}
synchronized (mLock) {
if (mConfigMonitorCallback != null) {
Bundle callbackResult = new Bundle();
callbackResult.putString(Settings.EXTRA_MONITOR_CALLBACK_TYPE,
Settings.EXTRA_ACCESS_CALLBACK);
callbackResult.putString(Settings.EXTRA_CALLING_PACKAGE, callingPackage);
callbackResult.putString(Settings.EXTRA_NAMESPACE, namespace);
mConfigMonitorCallback.sendResult(callbackResult);
}
}
}
private void reportDeviceConfigUpdate(@Nullable String prefix) {
if (prefix == null) {
return;
}
String namespace = prefix.replace("/", "");
if (DeviceConfig.getPublicNamespaces().contains(namespace)) {
return;
}
synchronized (mLock) {
if (mConfigMonitorCallback != null) {
Bundle callbackResult = new Bundle();
callbackResult.putString(Settings.EXTRA_MONITOR_CALLBACK_TYPE,
Settings.EXTRA_NAMESPACE_UPDATED_CALLBACK);
callbackResult.putString(Settings.EXTRA_NAMESPACE, namespace);
mConfigMonitorCallback.sendResult(callbackResult);
}
}
}
private static int getRequestingUserId(Bundle args) {
final int callingUserId = UserHandle.getCallingUserId();
return (args != null) ? args.getInt(Settings.CALL_METHOD_USER_KEY, callingUserId)
: callingUserId;
}
private boolean isTrackingGeneration(Bundle args) {
return args != null && args.containsKey(Settings.CALL_METHOD_TRACK_GENERATION_KEY);
}
private static String getSettingValue(Bundle args) {
return (args != null) ? args.getString(Settings.NameValueTable.VALUE) : null;
}
private static String getSettingTag(Bundle args) {
return (args != null) ? args.getString(Settings.CALL_METHOD_TAG_KEY) : null;
}
private static String getSettingPrefix(Bundle args) {
return (args != null) ? args.getString(Settings.CALL_METHOD_PREFIX_KEY) : null;
}
private static Map getSettingFlags(Bundle args) {
return (args != null) ? (HashMap) args.getSerializable(Settings.CALL_METHOD_FLAGS_KEY)
: Collections.emptyMap();
}
private static boolean getSettingMakeDefault(Bundle args) {
return (args != null) && args.getBoolean(Settings.CALL_METHOD_MAKE_DEFAULT_KEY);
}
private static boolean getSettingOverrideableByRestore(Bundle args) {
return (args != null) && args.getBoolean(Settings.CALL_METHOD_OVERRIDEABLE_BY_RESTORE_KEY);
}
private static int getResetModeEnforcingPermission(Bundle args) {
final int mode = (args != null) ? args.getInt(Settings.CALL_METHOD_RESET_MODE_KEY) : 0;
switch (mode) {
case Settings.RESET_MODE_UNTRUSTED_DEFAULTS: {
if (!isCallerSystemOrShellOrRootOnDebuggableBuild()) {
throw new SecurityException("Only system, shell/root on a "
+ "debuggable build can reset to untrusted defaults");
}
return mode;
}
case Settings.RESET_MODE_UNTRUSTED_CHANGES: {
if (!isCallerSystemOrShellOrRootOnDebuggableBuild()) {
throw new SecurityException("Only system, shell/root on a "
+ "debuggable build can reset untrusted changes");
}
return mode;
}
case Settings.RESET_MODE_TRUSTED_DEFAULTS: {
if (!isCallerSystemOrShellOrRootOnDebuggableBuild()) {
throw new SecurityException("Only system, shell/root on a "
+ "debuggable build can reset to trusted defaults");
}
return mode;
}
case Settings.RESET_MODE_PACKAGE_DEFAULTS: {
return mode;
}
}
throw new IllegalArgumentException("Invalid reset mode: " + mode);
}
private static boolean isCallerSystemOrShellOrRootOnDebuggableBuild() {
final int appId = UserHandle.getAppId(Binder.getCallingUid());
return appId == SYSTEM_UID || (Build.IS_DEBUGGABLE
&& (appId == SHELL_UID || appId == ROOT_UID));
}
private static String getValidTableOrThrow(Uri uri) {
if (uri.getPathSegments().size() > 0) {
String table = uri.getPathSegments().get(0);
if (DatabaseHelper.isValidTable(table)) {
return table;
}
throw new IllegalArgumentException("Bad root path: " + table);
}
throw new IllegalArgumentException("Invalid URI:" + uri);
}
private static MatrixCursor packageSettingForQuery(Setting setting, String[] projection) {
if (setting.isNull()) {
return new MatrixCursor(projection, 0);
}
MatrixCursor cursor = new MatrixCursor(projection, 1);
appendSettingToCursor(cursor, setting);
return cursor;
}
private static String[] normalizeProjection(String[] projection) {
if (projection == null) {
return ALL_COLUMNS;
}
final int columnCount = projection.length;
for (int i = 0; i < columnCount; i++) {
String column = projection[i];
if (!ArrayUtils.contains(ALL_COLUMNS, column)) {
throw new IllegalArgumentException("Invalid column: " + column);
}
}
return projection;
}
private static void appendSettingToCursor(MatrixCursor cursor, Setting setting) {
if (setting == null || setting.isNull()) {
return;
}
final int columnCount = cursor.getColumnCount();
String[] values = new String[columnCount];
for (int i = 0; i < columnCount; i++) {
String column = cursor.getColumnName(i);
switch (column) {
case Settings.NameValueTable._ID: {
values[i] = setting.getId();
} break;
case Settings.NameValueTable.NAME: {
values[i] = setting.getName();
} break;
case Settings.NameValueTable.VALUE: {
values[i] = setting.getValue();
} break;
case Settings.NameValueTable.IS_PRESERVED_IN_RESTORE: {
values[i] = String.valueOf(setting.isValuePreservedInRestore());
} break;
}
}
cursor.addRow(values);
}
private static boolean isKeyValid(String key) {
return !(TextUtils.isEmpty(key) || SettingsState.isBinary(key));
}
private String resolveCallingPackage() {
switch (Binder.getCallingUid()) {
case Process.ROOT_UID: {
return "root";
}
case Process.SHELL_UID: {
return "com.android.shell";
}
default: {
return getCallingPackage();
}
}
}
private static final class Arguments {
private static final Pattern WHERE_PATTERN_WITH_PARAM_NO_BRACKETS =
Pattern.compile("[\\s]*name[\\s]*=[\\s]*\\?[\\s]*");
private static final Pattern WHERE_PATTERN_WITH_PARAM_IN_BRACKETS =
Pattern.compile("[\\s]*\\([\\s]*name[\\s]*=[\\s]*\\?[\\s]*\\)[\\s]*");
private static final Pattern WHERE_PATTERN_NO_PARAM_IN_BRACKETS =
Pattern.compile("[\\s]*\\([\\s]*name[\\s]*=[\\s]*['\"].*['\"][\\s]*\\)[\\s]*");
private static final Pattern WHERE_PATTERN_NO_PARAM_NO_BRACKETS =
Pattern.compile("[\\s]*name[\\s]*=[\\s]*['\"].*['\"][\\s]*");
public final String table;
public final String name;
public Arguments(Uri uri, String where, String[] whereArgs, boolean supportAll) {
final int segmentSize = uri.getPathSegments().size();
switch (segmentSize) {
case 1: {
if (where != null
&& (WHERE_PATTERN_WITH_PARAM_NO_BRACKETS.matcher(where).matches()
|| WHERE_PATTERN_WITH_PARAM_IN_BRACKETS.matcher(where).matches())
&& whereArgs.length == 1) {
name = whereArgs[0];
table = computeTableForSetting(uri, name);
return;
} else if (where != null
&& (WHERE_PATTERN_NO_PARAM_NO_BRACKETS.matcher(where).matches()
|| WHERE_PATTERN_NO_PARAM_IN_BRACKETS.matcher(where).matches())) {
final int startIndex = Math.max(where.indexOf("'"),
where.indexOf("\"")) + 1;
final int endIndex = Math.max(where.lastIndexOf("'"),
where.lastIndexOf("\""));
name = where.substring(startIndex, endIndex);
table = computeTableForSetting(uri, name);
return;
} else if (supportAll && where == null && whereArgs == null) {
name = null;
table = computeTableForSetting(uri, null);
return;
}
} break;
case 2: {
if (where == null && whereArgs == null) {
name = uri.getPathSegments().get(1);
table = computeTableForSetting(uri, name);
return;
}
} break;
}
EventLogTags.writeUnsupportedSettingsQuery(
uri.toSafeString(), where, Arrays.toString(whereArgs));
String message = String.format( "Supported SQL:\n"
+ " uri content://some_table/some_property with null where and where args\n"
+ " uri content://some_table with query name=? and single name as arg\n"
+ " uri content://some_table with query name=some_name and null args\n"
+ " but got - uri:%1s, where:%2s whereArgs:%3s", uri, where,
Arrays.toString(whereArgs));
throw new IllegalArgumentException(message);
}
private static String computeTableForSetting(Uri uri, String name) {
String table = getValidTableOrThrow(uri);
if (name != null) {
if (sSystemMovedToSecureSettings.contains(name)) {
table = TABLE_SECURE;
}
if (sSystemMovedToGlobalSettings.contains(name)) {
table = TABLE_GLOBAL;
}
if (sSecureMovedToGlobalSettings.contains(name)) {
table = TABLE_GLOBAL;
}
if (sGlobalMovedToSecureSettings.contains(name)) {
table = TABLE_SECURE;
}
}
return table;
}
}
/**
* Schedule the job service to make a copy of all the settings files.
*/
public void scheduleWriteFallbackFilesJob() {
final Context context = getContext();
final JobScheduler jobScheduler =
(JobScheduler) context.getSystemService(Context.JOB_SCHEDULER_SERVICE);
if (jobScheduler == null) {
// Might happen: SettingsProvider is created before JobSchedulerService in system server
return;
}
// Check if the job is already scheduled. If so, skip scheduling another one
if (jobScheduler.getPendingJob(WRITE_FALLBACK_SETTINGS_FILES_JOB_ID) != null) {
return;
}
// Back up all settings files
final PersistableBundle bundle = new PersistableBundle();
final File globalSettingsFile = mSettingsRegistry.getSettingsFile(
makeKey(SETTINGS_TYPE_GLOBAL, UserHandle.USER_SYSTEM));
final File systemSettingsFile = mSettingsRegistry.getSettingsFile(
makeKey(SETTINGS_TYPE_SYSTEM, UserHandle.USER_SYSTEM));
final File secureSettingsFile = mSettingsRegistry.getSettingsFile(
makeKey(SETTINGS_TYPE_SECURE, UserHandle.USER_SYSTEM));
final File ssaidSettingsFile = mSettingsRegistry.getSettingsFile(
makeKey(SETTINGS_TYPE_SSAID, UserHandle.USER_SYSTEM));
final File configSettingsFile = mSettingsRegistry.getSettingsFile(
makeKey(SETTINGS_TYPE_CONFIG, UserHandle.USER_SYSTEM));
bundle.putString(TABLE_GLOBAL, globalSettingsFile.getAbsolutePath());
bundle.putString(TABLE_SYSTEM, systemSettingsFile.getAbsolutePath());
bundle.putString(TABLE_SECURE, secureSettingsFile.getAbsolutePath());
bundle.putString(TABLE_SSAID, ssaidSettingsFile.getAbsolutePath());
bundle.putString(TABLE_CONFIG, configSettingsFile.getAbsolutePath());
// Schedule the job to write the fallback files, once daily when phone is charging
jobScheduler.schedule(new JobInfo.Builder(WRITE_FALLBACK_SETTINGS_FILES_JOB_ID,
new ComponentName(context, WriteFallbackSettingsFilesJobService.class))
.setExtras(bundle)
.setPeriodic(ONE_DAY_INTERVAL_MILLIS)
.setRequiresCharging(true)
.setPersisted(true)
.build());
}
/**
* For each file in the given list, if it exists, copy it to a back up file. Ignore failures.
* @param filePaths List of paths of files that need to be backed up
*/
public static void writeFallBackSettingsFiles(List filePaths) {
final int numFiles = filePaths.size();
for (int i = 0; i < numFiles; i++) {
final String filePath = filePaths.get(i);
final File originalFile = new File(filePath);
if (SettingsState.stateFileExists(originalFile)) {
final File fallBackFile = new File(filePath + FALLBACK_FILE_SUFFIX);
try {
FileUtils.copy(originalFile, fallBackFile);
} catch (IOException ex) {
Slog.w(LOG_TAG, "Failed to write fallback file for: " + filePath);
}
}
}
}
final class SettingsRegistry {
private static final String DROPBOX_TAG_USERLOG = "restricted_profile_ssaid";
private static final String SETTINGS_FILE_GLOBAL = "settings_global.xml";
private static final String SETTINGS_FILE_SYSTEM = "settings_system.xml";
private static final String SETTINGS_FILE_SECURE = "settings_secure.xml";
private static final String SETTINGS_FILE_SSAID = "settings_ssaid.xml";
private static final String SETTINGS_FILE_CONFIG = "settings_config.xml";
private static final String SSAID_USER_KEY = "userkey";
private final SparseArray mSettingsStates = new SparseArray<>();
private GenerationRegistry mGenerationRegistry;
private final Handler mHandler;
private final BackupManager mBackupManager;
private String mSettingsCreationBuildId;
public SettingsRegistry() {
mHandler = new MyHandler(getContext().getMainLooper());
mGenerationRegistry = new GenerationRegistry(mLock);
mBackupManager = new BackupManager(getContext());
migrateAllLegacySettingsIfNeeded();
syncSsaidTableOnStart();
}
private void generateUserKeyLocked(int userId) {
// Generate a random key for each user used for creating a new ssaid.
final byte[] keyBytes = new byte[32];
final SecureRandom rand = new SecureRandom();
rand.nextBytes(keyBytes);
// Convert to string for storage in settings table.
final String userKey = HexEncoding.encodeToString(keyBytes, true /* upperCase */);
// Store the key in the ssaid table.
final SettingsState ssaidSettings = getSettingsLocked(SETTINGS_TYPE_SSAID, userId);
final boolean success = ssaidSettings.insertSettingLocked(SSAID_USER_KEY, userKey, null,
true, SettingsState.SYSTEM_PACKAGE_NAME);
if (!success) {
throw new IllegalStateException("Ssaid settings not accessible");
}
}
private byte[] getLengthPrefix(byte[] data) {
return ByteBuffer.allocate(4).putInt(data.length).array();
}
public Setting generateSsaidLocked(PackageInfo callingPkg, int userId) {
// Read the user's key from the ssaid table.
Setting userKeySetting = getSettingLocked(SETTINGS_TYPE_SSAID, userId, SSAID_USER_KEY);
if (userKeySetting == null || userKeySetting.isNull()
|| userKeySetting.getValue() == null) {
// Lazy initialize and store the user key.
generateUserKeyLocked(userId);
userKeySetting = getSettingLocked(SETTINGS_TYPE_SSAID, userId, SSAID_USER_KEY);
if (userKeySetting == null || userKeySetting.isNull()
|| userKeySetting.getValue() == null) {
throw new IllegalStateException("User key not accessible");
}
}
final String userKey = userKeySetting.getValue();
if (userKey == null || userKey.length() % 2 != 0) {
throw new IllegalStateException("User key invalid");
}
// Convert the user's key back to a byte array.
final byte[] keyBytes = HexEncoding.decode(userKey);
// Validate that the key is of expected length.
// Keys are currently 32 bytes, but were once 16 bytes during Android O development.
if (keyBytes.length != 16 && keyBytes.length != 32) {
throw new IllegalStateException("User key invalid");
}
final Mac m;
try {
m = Mac.getInstance("HmacSHA256");
m.init(new SecretKeySpec(keyBytes, m.getAlgorithm()));
} catch (NoSuchAlgorithmException e) {
throw new IllegalStateException("HmacSHA256 is not available", e);
} catch (InvalidKeyException e) {
throw new IllegalStateException("Key is corrupted", e);
}
// Mac each of the developer signatures.
for (int i = 0; i < callingPkg.signatures.length; i++) {
byte[] sig = callingPkg.signatures[i].toByteArray();
m.update(getLengthPrefix(sig), 0, 4);
m.update(sig);
}
// Convert result to a string for storage in settings table. Only want first 64 bits.
final String ssaid = HexEncoding.encodeToString(m.doFinal(), false /* upperCase */)
.substring(0, 16);
// Save the ssaid in the ssaid table.
final String uid = Integer.toString(callingPkg.applicationInfo.uid);
final SettingsState ssaidSettings = getSettingsLocked(SETTINGS_TYPE_SSAID, userId);
final boolean success = ssaidSettings.insertSettingLocked(uid, ssaid, null, true,
callingPkg.packageName);
if (!success) {
throw new IllegalStateException("Ssaid settings not accessible");
}
return getSettingLocked(SETTINGS_TYPE_SSAID, userId, uid);
}
public void syncSsaidTableOnStart() {
synchronized (mLock) {
// Verify that each user's packages and ssaid's are in sync.
for (UserInfo user : mUserManager.getUsers(true)) {
// Get all uids for the user's packages.
final List packages;
try {
packages = mPackageManager.getInstalledPackages(
PackageManager.MATCH_UNINSTALLED_PACKAGES,
user.id).getList();
} catch (RemoteException e) {
throw new IllegalStateException("Package manager not available");
}
final Set appUids = new HashSet<>();
for (PackageInfo info : packages) {
appUids.add(Integer.toString(info.applicationInfo.uid));
}
// Get all uids currently stored in the user's ssaid table.
final Set ssaidUids = new HashSet<>(
getSettingsNamesLocked(SETTINGS_TYPE_SSAID, user.id));
ssaidUids.remove(SSAID_USER_KEY);
// Perform a set difference for the appUids and ssaidUids.
ssaidUids.removeAll(appUids);
// If there are ssaidUids left over they need to be removed from the table.
final SettingsState ssaidSettings = getSettingsLocked(SETTINGS_TYPE_SSAID,
user.id);
for (String uid : ssaidUids) {
ssaidSettings.deleteSettingLocked(uid);
}
}
}
}
public List getSettingsNamesLocked(int type, int userId) {
final int key = makeKey(type, userId);
SettingsState settingsState = peekSettingsStateLocked(key);
if (settingsState == null) {
return new ArrayList<>();
}
return settingsState.getSettingNamesLocked();
}
public SparseBooleanArray getKnownUsersLocked() {
SparseBooleanArray users = new SparseBooleanArray();
for (int i = mSettingsStates.size()-1; i >= 0; i--) {
users.put(getUserIdFromKey(mSettingsStates.keyAt(i)), true);
}
return users;
}
@Nullable
public SettingsState getSettingsLocked(int type, int userId) {
final int key = makeKey(type, userId);
return peekSettingsStateLocked(key);
}
public boolean ensureSettingsForUserLocked(int userId) {
// First make sure this user actually exists.
if (mUserManager.getUserInfo(userId) == null) {
Slog.wtf(LOG_TAG, "Requested user " + userId + " does not exist");
return false;
}
// Migrate the setting for this user if needed.
migrateLegacySettingsForUserIfNeededLocked(userId);
// Ensure config settings loaded if owner.
if (userId == UserHandle.USER_SYSTEM) {
final int configKey
= makeKey(SETTINGS_TYPE_CONFIG, UserHandle.USER_SYSTEM);
ensureSettingsStateLocked(configKey);
}
// Ensure global settings loaded if owner.
if (userId == UserHandle.USER_SYSTEM) {
final int globalKey = makeKey(SETTINGS_TYPE_GLOBAL, UserHandle.USER_SYSTEM);
ensureSettingsStateLocked(globalKey);
}
// Ensure secure settings loaded.
final int secureKey = makeKey(SETTINGS_TYPE_SECURE, userId);
ensureSettingsStateLocked(secureKey);
// Make sure the secure settings have an Android id set.
SettingsState secureSettings = getSettingsLocked(SETTINGS_TYPE_SECURE, userId);
ensureSecureSettingAndroidIdSetLocked(secureSettings);
// Ensure system settings loaded.
final int systemKey = makeKey(SETTINGS_TYPE_SYSTEM, userId);
ensureSettingsStateLocked(systemKey);
// Ensure secure settings loaded.
final int ssaidKey = makeKey(SETTINGS_TYPE_SSAID, userId);
ensureSettingsStateLocked(ssaidKey);
// Upgrade the settings to the latest version.
UpgradeController upgrader = new UpgradeController(userId);
upgrader.upgradeIfNeededLocked();
return true;
}
private void ensureSettingsStateLocked(int key) {
if (mSettingsStates.get(key) == null) {
final int maxBytesPerPackage = getMaxBytesPerPackageForType(getTypeFromKey(key));
SettingsState settingsState = new SettingsState(getContext(), mLock,
getSettingsFile(key), key, maxBytesPerPackage, mHandlerThread.getLooper());
mSettingsStates.put(key, settingsState);
}
}
public void removeUserStateLocked(int userId, boolean permanently) {
// We always keep the global settings in memory.
// Nuke system settings.
final int systemKey = makeKey(SETTINGS_TYPE_SYSTEM, userId);
final SettingsState systemSettingsState = mSettingsStates.get(systemKey);
if (systemSettingsState != null) {
if (permanently) {
mSettingsStates.remove(systemKey);
systemSettingsState.destroyLocked(null);
} else {
systemSettingsState.destroyLocked(new Runnable() {
@Override
public void run() {
mSettingsStates.remove(systemKey);
}
});
}
}
// Nuke secure settings.
final int secureKey = makeKey(SETTINGS_TYPE_SECURE, userId);
final SettingsState secureSettingsState = mSettingsStates.get(secureKey);
if (secureSettingsState != null) {
if (permanently) {
mSettingsStates.remove(secureKey);
secureSettingsState.destroyLocked(null);
} else {
secureSettingsState.destroyLocked(new Runnable() {
@Override
public void run() {
mSettingsStates.remove(secureKey);
}
});
}
}
// Nuke ssaid settings.
final int ssaidKey = makeKey(SETTINGS_TYPE_SSAID, userId);
final SettingsState ssaidSettingsState = mSettingsStates.get(ssaidKey);
if (ssaidSettingsState != null) {
if (permanently) {
mSettingsStates.remove(ssaidKey);
ssaidSettingsState.destroyLocked(null);
} else {
ssaidSettingsState.destroyLocked(new Runnable() {
@Override
public void run() {
mSettingsStates.remove(ssaidKey);
}
});
}
}
// Nuke generation tracking data
mGenerationRegistry.onUserRemoved(userId);
}
public boolean insertSettingLocked(int type, int userId, String name, String value,
String tag, boolean makeDefault, String packageName, boolean forceNotify,
Set criticalSettings, boolean overrideableByRestore) {
return insertSettingLocked(type, userId, name, value, tag, makeDefault, false,
packageName, forceNotify, criticalSettings, overrideableByRestore);
}
public boolean insertSettingLocked(int type, int userId, String name, String value,
String tag, boolean makeDefault, boolean forceNonSystemPackage, String packageName,
boolean forceNotify, Set criticalSettings, boolean overrideableByRestore) {
if (overrideableByRestore != Settings.DEFAULT_OVERRIDEABLE_BY_RESTORE) {
getContext().enforceCallingOrSelfPermission(
Manifest.permission.MODIFY_SETTINGS_OVERRIDEABLE_BY_RESTORE,
"Caller is not allowed to modify settings overrideable by restore");
}
final int key = makeKey(type, userId);
boolean success = false;
SettingsState settingsState = peekSettingsStateLocked(key);
if (settingsState != null) {
success = settingsState.insertSettingLocked(name, value,
tag, makeDefault, forceNonSystemPackage, packageName, overrideableByRestore);
}
if (success && criticalSettings != null && criticalSettings.contains(name)) {
settingsState.persistSyncLocked();
}
if (forceNotify || success) {
notifyForSettingsChange(key, name);
}
return success;
}
/**
* Set Config Settings using consumed keyValues, returns true if the keyValues can be set,
* false otherwise.
*/
public boolean setConfigSettingsLocked(int key, String prefix,
Map keyValues, String packageName) {
SettingsState settingsState = peekSettingsStateLocked(key);
if (settingsState != null) {
if (settingsState.isNewConfigBannedLocked(prefix, keyValues)) {
return false;
}
settingsState.unbanAllConfigIfBannedConfigUpdatedLocked(prefix);
List changedSettings =
settingsState.setSettingsLocked(prefix, keyValues, packageName);
if (!changedSettings.isEmpty()) {
reportDeviceConfigUpdate(prefix);
notifyForConfigSettingsChangeLocked(key, prefix, changedSettings);
}
}
// keyValues aren't banned and can be set
return true;
}
public boolean deleteSettingLocked(int type, int userId, String name, boolean forceNotify,
Set criticalSettings) {
final int key = makeKey(type, userId);
boolean success = false;
SettingsState settingsState = peekSettingsStateLocked(key);
if (settingsState != null) {
success = settingsState.deleteSettingLocked(name);
}
if (success && criticalSettings != null && criticalSettings.contains(name)) {
settingsState.persistSyncLocked();
}
if (forceNotify || success) {
notifyForSettingsChange(key, name);
}
return success;
}
public boolean updateSettingLocked(int type, int userId, String name, String value,
String tag, boolean makeDefault, String packageName, boolean forceNotify,
Set criticalSettings) {
final int key = makeKey(type, userId);
boolean success = false;
SettingsState settingsState = peekSettingsStateLocked(key);
if (settingsState != null) {
success = settingsState.updateSettingLocked(name, value, tag,
makeDefault, packageName);
}
if (success && criticalSettings != null && criticalSettings.contains(name)) {
settingsState.persistSyncLocked();
}
if (forceNotify || success) {
notifyForSettingsChange(key, name);
}
return success;
}
public Setting getSettingLocked(int type, int userId, String name) {
final int key = makeKey(type, userId);
SettingsState settingsState = peekSettingsStateLocked(key);
if (settingsState == null) {
return null;
}
// getSettingLocked will return non-null result
return settingsState.getSettingLocked(name);
}
public void resetSettingsLocked(int type, int userId, String packageName, int mode,
String tag) {
resetSettingsLocked(type, userId, packageName, mode, tag, /*prefix=*/
null);
}
public void resetSettingsLocked(int type, int userId, String packageName, int mode,
String tag, @Nullable String prefix) {
final int key = makeKey(type, userId);
SettingsState settingsState = peekSettingsStateLocked(key);
if (settingsState == null) {
return;
}
banConfigurationIfNecessary(type, prefix, settingsState);
switch (mode) {
case Settings.RESET_MODE_PACKAGE_DEFAULTS: {
for (String name : settingsState.getSettingNamesLocked()) {
boolean someSettingChanged = false;
Setting setting = settingsState.getSettingLocked(name);
if (packageName.equals(setting.getPackageName())) {
if ((tag != null && !tag.equals(setting.getTag()))
|| (prefix != null && !setting.getName().startsWith(prefix))) {
continue;
}
if (settingsState.resetSettingLocked(name)) {
someSettingChanged = true;
notifyForSettingsChange(key, name);
}
}
if (someSettingChanged) {
settingsState.persistSyncLocked();
}
}
} break;
case Settings.RESET_MODE_UNTRUSTED_DEFAULTS: {
for (String name : settingsState.getSettingNamesLocked()) {
boolean someSettingChanged = false;
Setting setting = settingsState.getSettingLocked(name);
if (!SettingsState.isSystemPackage(getContext(),
setting.getPackageName(), INVALID_UID, userId)) {
if (prefix != null && !setting.getName().startsWith(prefix)) {
continue;
}
if (settingsState.resetSettingLocked(name)) {
someSettingChanged = true;
notifyForSettingsChange(key, name);
}
}
if (someSettingChanged) {
settingsState.persistSyncLocked();
}
}
} break;
case Settings.RESET_MODE_UNTRUSTED_CHANGES: {
for (String name : settingsState.getSettingNamesLocked()) {
boolean someSettingChanged = false;
Setting setting = settingsState.getSettingLocked(name);
if (!SettingsState.isSystemPackage(getContext(),
setting.getPackageName(), INVALID_UID, userId)) {
if (prefix != null && !setting.getName().startsWith(prefix)) {
continue;
}
if (setting.isDefaultFromSystem()) {
if (settingsState.resetSettingLocked(name)) {
someSettingChanged = true;
notifyForSettingsChange(key, name);
}
} else if (settingsState.deleteSettingLocked(name)) {
someSettingChanged = true;
notifyForSettingsChange(key, name);
}
}
if (someSettingChanged) {
settingsState.persistSyncLocked();
}
}
} break;
case Settings.RESET_MODE_TRUSTED_DEFAULTS: {
for (String name : settingsState.getSettingNamesLocked()) {
Setting setting = settingsState.getSettingLocked(name);
boolean someSettingChanged = false;
if (prefix != null && !setting.getName().startsWith(prefix)) {
continue;
}
if (setting.isDefaultFromSystem()) {
if (settingsState.resetSettingLocked(name)) {
someSettingChanged = true;
notifyForSettingsChange(key, name);
}
} else if (settingsState.deleteSettingLocked(name)) {
someSettingChanged = true;
notifyForSettingsChange(key, name);
}
if (someSettingChanged) {
settingsState.persistSyncLocked();
}
}
} break;
}
}
public void removeSettingsForPackageLocked(String packageName, int userId) {
// Global and secure settings are signature protected. Apps signed
// by the platform certificate are generally not uninstalled and
// the main exception is tests. We trust components signed
// by the platform certificate and do not do a clean up after them.
final int systemKey = makeKey(SETTINGS_TYPE_SYSTEM, userId);
SettingsState systemSettings = mSettingsStates.get(systemKey);
if (systemSettings != null) {
systemSettings.removeSettingsForPackageLocked(packageName);
}
}
public void onUidRemovedLocked(int uid) {
final SettingsState ssaidSettings = getSettingsLocked(SETTINGS_TYPE_SSAID,
UserHandle.getUserId(uid));
if (ssaidSettings != null) {
ssaidSettings.deleteSettingLocked(Integer.toString(uid));
}
}
@Nullable
private SettingsState peekSettingsStateLocked(int key) {
SettingsState settingsState = mSettingsStates.get(key);
if (settingsState != null) {
return settingsState;
}
if (!ensureSettingsForUserLocked(getUserIdFromKey(key))) {
return null;
}
return mSettingsStates.get(key);
}
private void migrateAllLegacySettingsIfNeeded() {
synchronized (mLock) {
final int key = makeKey(SETTINGS_TYPE_GLOBAL, UserHandle.USER_SYSTEM);
File globalFile = getSettingsFile(key);
if (SettingsState.stateFileExists(globalFile)) {
return;
}
mSettingsCreationBuildId = Build.ID;
final long identity = Binder.clearCallingIdentity();
try {
List users = mUserManager.getUsers(true);
final int userCount = users.size();
for (int i = 0; i < userCount; i++) {
final int userId = users.get(i).id;
DatabaseHelper dbHelper = new DatabaseHelper(getContext(), userId);
SQLiteDatabase database = dbHelper.getWritableDatabase();
migrateLegacySettingsForUserLocked(dbHelper, database, userId);
// Upgrade to the latest version.
UpgradeController upgrader = new UpgradeController(userId);
upgrader.upgradeIfNeededLocked();
// Drop from memory if not a running user.
if (!mUserManager.isUserRunning(new UserHandle(userId))) {
removeUserStateLocked(userId, false);
}
}
} finally {
Binder.restoreCallingIdentity(identity);
}
}
}
private void migrateLegacySettingsForUserIfNeededLocked(int userId) {
// Every user has secure settings and if no file we need to migrate.
final int secureKey = makeKey(SETTINGS_TYPE_SECURE, userId);
File secureFile = getSettingsFile(secureKey);
if (SettingsState.stateFileExists(secureFile)) {
return;
}
DatabaseHelper dbHelper = new DatabaseHelper(getContext(), userId);
SQLiteDatabase database = dbHelper.getWritableDatabase();
migrateLegacySettingsForUserLocked(dbHelper, database, userId);
}
private void migrateLegacySettingsForUserLocked(DatabaseHelper dbHelper,
SQLiteDatabase database, int userId) {
// Move over the system settings.
final int systemKey = makeKey(SETTINGS_TYPE_SYSTEM, userId);
ensureSettingsStateLocked(systemKey);
SettingsState systemSettings = mSettingsStates.get(systemKey);
migrateLegacySettingsLocked(systemSettings, database, TABLE_SYSTEM);
systemSettings.persistSyncLocked();
// Move over the secure settings.
// Do this after System settings, since this is the first thing we check when deciding
// to skip over migration from db to xml for a secondary user.
final int secureKey = makeKey(SETTINGS_TYPE_SECURE, userId);
ensureSettingsStateLocked(secureKey);
SettingsState secureSettings = mSettingsStates.get(secureKey);
migrateLegacySettingsLocked(secureSettings, database, TABLE_SECURE);
ensureSecureSettingAndroidIdSetLocked(secureSettings);
secureSettings.persistSyncLocked();
// Move over the global settings if owner.
// Do this last, since this is the first thing we check when deciding
// to skip over migration from db to xml for owner user.
if (userId == UserHandle.USER_SYSTEM) {
final int globalKey = makeKey(SETTINGS_TYPE_GLOBAL, userId);
ensureSettingsStateLocked(globalKey);
SettingsState globalSettings = mSettingsStates.get(globalKey);
migrateLegacySettingsLocked(globalSettings, database, TABLE_GLOBAL);
// If this was just created
if (mSettingsCreationBuildId != null) {
globalSettings.insertSettingLocked(Settings.Global.DATABASE_CREATION_BUILDID,
mSettingsCreationBuildId, null, true,
SettingsState.SYSTEM_PACKAGE_NAME);
}
globalSettings.persistSyncLocked();
}
// Drop the database as now all is moved and persisted.
if (DROP_DATABASE_ON_MIGRATION) {
dbHelper.dropDatabase();
} else {
dbHelper.backupDatabase();
}
}
private void migrateLegacySettingsLocked(SettingsState settingsState,
SQLiteDatabase database, String table) {
SQLiteQueryBuilder queryBuilder = new SQLiteQueryBuilder();
queryBuilder.setTables(table);
Cursor cursor = queryBuilder.query(database, LEGACY_SQL_COLUMNS,
null, null, null, null, null);
if (cursor == null) {
return;
}
try {
if (!cursor.moveToFirst()) {
return;
}
final int nameColumnIdx = cursor.getColumnIndex(Settings.NameValueTable.NAME);
final int valueColumnIdx = cursor.getColumnIndex(Settings.NameValueTable.VALUE);
settingsState.setVersionLocked(database.getVersion());
while (!cursor.isAfterLast()) {
String name = cursor.getString(nameColumnIdx);
String value = cursor.getString(valueColumnIdx);
settingsState.insertSettingLocked(name, value, null, true,
SettingsState.SYSTEM_PACKAGE_NAME);
cursor.moveToNext();
}
} finally {
cursor.close();
}
}
@GuardedBy("secureSettings.mLock")
private void ensureSecureSettingAndroidIdSetLocked(SettingsState secureSettings) {
Setting value = secureSettings.getSettingLocked(Settings.Secure.ANDROID_ID);
if (!value.isNull()) {
return;
}
final int userId = getUserIdFromKey(secureSettings.mKey);
final UserInfo user;
final long identity = Binder.clearCallingIdentity();
try {
user = mUserManager.getUserInfo(userId);
} finally {
Binder.restoreCallingIdentity(identity);
}
if (user == null) {
// Can happen due to races when deleting users - treat as benign.
return;
}
String androidId = Long.toHexString(new SecureRandom().nextLong());
secureSettings.insertSettingLocked(Settings.Secure.ANDROID_ID, androidId,
null, true, SettingsState.SYSTEM_PACKAGE_NAME);
Slog.d(LOG_TAG, "Generated and saved new ANDROID_ID [" + androidId
+ "] for user " + userId);
// Write a drop box entry if it's a restricted profile
if (user.isRestricted()) {
DropBoxManager dbm = (DropBoxManager) getContext().getSystemService(
Context.DROPBOX_SERVICE);
if (dbm != null && dbm.isTagEnabled(DROPBOX_TAG_USERLOG)) {
dbm.addText(DROPBOX_TAG_USERLOG, System.currentTimeMillis()
+ "," + DROPBOX_TAG_USERLOG + "," + androidId + "\n");
}
}
}
private void notifyForSettingsChange(int key, String name) {
// Increment the generation first, so observers always see the new value
mGenerationRegistry.incrementGeneration(key);
if (isGlobalSettingsKey(key) || isConfigSettingsKey(key)) {
final long token = Binder.clearCallingIdentity();
try {
if (Global.LOCATION_GLOBAL_KILL_SWITCH.equals(name)
&& isGlobalSettingsKey(key)) {
// When the global kill switch is updated, send the
// change notification for the location setting.
notifyLocationChangeForRunningUsers();
}
notifySettingChangeForRunningUsers(key, name);
} finally {
Binder.restoreCallingIdentity(token);
}
} else {
final int userId = getUserIdFromKey(key);
final Uri uri = getNotificationUriFor(key, name);
mHandler.obtainMessage(MyHandler.MSG_NOTIFY_URI_CHANGED,
userId, 0, uri).sendToTarget();
if (isSecureSettingsKey(key)) {
maybeNotifyProfiles(getTypeFromKey(key), userId, uri, name,
sSecureCloneToManagedSettings);
maybeNotifyProfiles(SETTINGS_TYPE_SYSTEM, userId, uri, name,
sSystemCloneFromParentOnDependency.values());
} else if (isSystemSettingsKey(key)) {
maybeNotifyProfiles(getTypeFromKey(key), userId, uri, name,
sSystemCloneToManagedSettings);
}
}
// Always notify that our data changed
mHandler.obtainMessage(MyHandler.MSG_NOTIFY_DATA_CHANGED).sendToTarget();
}
private void notifyForConfigSettingsChangeLocked(int key, String prefix,
List changedSettings) {
// Increment the generation first, so observers always see the new value
mGenerationRegistry.incrementGeneration(key);
StringBuilder stringBuilder = new StringBuilder(prefix);
for (int i = 0; i < changedSettings.size(); ++i) {
stringBuilder.append(changedSettings.get(i).split("/")[1]).append("/");
}
final long token = Binder.clearCallingIdentity();
try {
notifySettingChangeForRunningUsers(key, stringBuilder.toString());
} finally {
Binder.restoreCallingIdentity(token);
}
// Always notify that our data changed
mHandler.obtainMessage(MyHandler.MSG_NOTIFY_DATA_CHANGED).sendToTarget();
}
private void maybeNotifyProfiles(int type, int userId, Uri uri, String name,
Collection keysCloned) {
if (keysCloned.contains(name)) {
for (int profileId : mUserManager.getProfileIdsWithDisabled(userId)) {
// the notification for userId has already been sent.
if (profileId != userId) {
final int key = makeKey(type, profileId);
// Increment the generation first, so observers always see the new value
mGenerationRegistry.incrementGeneration(key);
mHandler.obtainMessage(MyHandler.MSG_NOTIFY_URI_CHANGED,
profileId, 0, uri).sendToTarget();
}
}
}
}
private void notifySettingChangeForRunningUsers(int key, String name) {
// Important: No need to update generation for each user as there
// is a singleton generation entry for the global settings which
// is already incremented be the caller.
final Uri uri = getNotificationUriFor(key, name);
final List users = mUserManager.getUsers(/*excludeDying*/ true);
for (int i = 0; i < users.size(); i++) {
final int userId = users.get(i).id;
if (mUserManager.isUserRunning(UserHandle.of(userId))) {
mHandler.obtainMessage(MyHandler.MSG_NOTIFY_URI_CHANGED,
userId, 0, uri).sendToTarget();
}
}
}
private void notifyLocationChangeForRunningUsers() {
final List users = mUserManager.getUsers(/*excludeDying=*/ true);
for (int i = 0; i < users.size(); i++) {
final int userId = users.get(i).id;
if (!mUserManager.isUserRunning(UserHandle.of(userId))) {
continue;
}
// Increment the generation first, so observers always see the new value
final int key = makeKey(SETTINGS_TYPE_SECURE, userId);
mGenerationRegistry.incrementGeneration(key);
final Uri uri = getNotificationUriFor(key, Secure.LOCATION_MODE);
mHandler.obtainMessage(MyHandler.MSG_NOTIFY_URI_CHANGED,
userId, 0, uri).sendToTarget();
}
}
private boolean isConfigSettingsKey(int key) {
return getTypeFromKey(key) == SETTINGS_TYPE_CONFIG;
}
private boolean isGlobalSettingsKey(int key) {
return getTypeFromKey(key) == SETTINGS_TYPE_GLOBAL;
}
private boolean isSystemSettingsKey(int key) {
return getTypeFromKey(key) == SETTINGS_TYPE_SYSTEM;
}
private boolean isSecureSettingsKey(int key) {
return getTypeFromKey(key) == SETTINGS_TYPE_SECURE;
}
private boolean isSsaidSettingsKey(int key) {
return getTypeFromKey(key) == SETTINGS_TYPE_SSAID;
}
private boolean shouldBan(int type) {
if (SETTINGS_TYPE_CONFIG != type) {
return false;
}
final int callingUid = Binder.getCallingUid();
final int appId = UserHandle.getAppId(callingUid);
// Only non-shell resets should result in namespace banning
return appId != SHELL_UID;
}
private void banConfigurationIfNecessary(int type, @Nullable String prefix,
SettingsState settingsState) {
// Banning should be performed only for Settings.Config and for non-shell reset calls
if (!shouldBan(type)) {
return;
}
if (prefix != null) {
settingsState.banConfigurationLocked(prefix, getAllConfigFlags(prefix));
} else {
Set configPrefixes = settingsState.getAllConfigPrefixesLocked();
for (String configPrefix : configPrefixes) {
settingsState.banConfigurationLocked(configPrefix,
getAllConfigFlags(configPrefix));
}
}
}
private File getSettingsFile(int key) {
if (isConfigSettingsKey(key)) {
final int userId = getUserIdFromKey(key);
return new File(Environment.getUserSystemDirectory(userId),
SETTINGS_FILE_CONFIG);
} else if (isGlobalSettingsKey(key)) {
final int userId = getUserIdFromKey(key);
return new File(Environment.getUserSystemDirectory(userId),
SETTINGS_FILE_GLOBAL);
} else if (isSystemSettingsKey(key)) {
final int userId = getUserIdFromKey(key);
return new File(Environment.getUserSystemDirectory(userId),
SETTINGS_FILE_SYSTEM);
} else if (isSecureSettingsKey(key)) {
final int userId = getUserIdFromKey(key);
return new File(Environment.getUserSystemDirectory(userId),
SETTINGS_FILE_SECURE);
} else if (isSsaidSettingsKey(key)) {
final int userId = getUserIdFromKey(key);
return new File(Environment.getUserSystemDirectory(userId),
SETTINGS_FILE_SSAID);
} else {
throw new IllegalArgumentException("Invalid settings key:" + key);
}
}
private Uri getNotificationUriFor(int key, String name) {
if (isConfigSettingsKey(key)) {
return (name != null) ? Uri.withAppendedPath(DeviceConfig.CONTENT_URI, name)
: DeviceConfig.CONTENT_URI;
} else if (isGlobalSettingsKey(key)) {
return (name != null) ? Uri.withAppendedPath(Settings.Global.CONTENT_URI, name)
: Settings.Global.CONTENT_URI;
} else if (isSecureSettingsKey(key)) {
return (name != null) ? Uri.withAppendedPath(Settings.Secure.CONTENT_URI, name)
: Settings.Secure.CONTENT_URI;
} else if (isSystemSettingsKey(key)) {
return (name != null) ? Uri.withAppendedPath(Settings.System.CONTENT_URI, name)
: Settings.System.CONTENT_URI;
} else {
throw new IllegalArgumentException("Invalid settings key:" + key);
}
}
private int getMaxBytesPerPackageForType(int type) {
switch (type) {
case SETTINGS_TYPE_CONFIG:
case SETTINGS_TYPE_GLOBAL:
case SETTINGS_TYPE_SECURE:
case SETTINGS_TYPE_SSAID: {
return SettingsState.MAX_BYTES_PER_APP_PACKAGE_UNLIMITED;
}
default: {
return SettingsState.MAX_BYTES_PER_APP_PACKAGE_LIMITED;
}
}
}
private final class MyHandler extends Handler {
private static final int MSG_NOTIFY_URI_CHANGED = 1;
private static final int MSG_NOTIFY_DATA_CHANGED = 2;
public MyHandler(Looper looper) {
super(looper);
}
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case MSG_NOTIFY_URI_CHANGED: {
final int userId = msg.arg1;
Uri uri = (Uri) msg.obj;
try {
getContext().getContentResolver().notifyChange(uri, null, true, userId);
} catch (SecurityException e) {
Slog.w(LOG_TAG, "Failed to notify for " + userId + ": " + uri, e);
}
if (DEBUG) {
Slog.v(LOG_TAG, "Notifying for " + userId + ": " + uri);
}
} break;
case MSG_NOTIFY_DATA_CHANGED: {
mBackupManager.dataChanged();
scheduleWriteFallbackFilesJob();
} break;
}
}
}
private final class UpgradeController {
private static final int SETTINGS_VERSION = 191;
private final int mUserId;
public UpgradeController(int userId) {
mUserId = userId;
}
public void upgradeIfNeededLocked() {
// The version of all settings for a user is the same (all users have secure).
SettingsState secureSettings = getSettingsLocked(
SETTINGS_TYPE_SECURE, mUserId);
// Try an update from the current state.
final int oldVersion = secureSettings.getVersionLocked();
final int newVersion = SETTINGS_VERSION;
// If up do date - done.
if (oldVersion == newVersion) {
return;
}
// Try to upgrade.
final int curVersion = onUpgradeLocked(mUserId, oldVersion, newVersion);
// If upgrade failed start from scratch and upgrade.
if (curVersion != newVersion) {
// Drop state we have for this user.
removeUserStateLocked(mUserId, true);
// Recreate the database.
DatabaseHelper dbHelper = new DatabaseHelper(getContext(), mUserId);
SQLiteDatabase database = dbHelper.getWritableDatabase();
dbHelper.recreateDatabase(database, newVersion, curVersion, oldVersion);
// Migrate the settings for this user.
migrateLegacySettingsForUserLocked(dbHelper, database, mUserId);
// Now upgrade should work fine.
onUpgradeLocked(mUserId, oldVersion, newVersion);
// Make a note what happened, so we don't wonder why data was lost
String reason = "Settings rebuilt! Current version: "
+ curVersion + " while expected: " + newVersion;
getGlobalSettingsLocked().insertSettingLocked(
Settings.Global.DATABASE_DOWNGRADE_REASON,
reason, null, true, SettingsState.SYSTEM_PACKAGE_NAME);
}
// Set the global settings version if owner.
if (mUserId == UserHandle.USER_SYSTEM) {
SettingsState globalSettings = getSettingsLocked(
SETTINGS_TYPE_GLOBAL, mUserId);
globalSettings.setVersionLocked(newVersion);
}
// Set the secure settings version.
secureSettings.setVersionLocked(newVersion);
// Set the system settings version.
SettingsState systemSettings = getSettingsLocked(
SETTINGS_TYPE_SYSTEM, mUserId);
systemSettings.setVersionLocked(newVersion);
}
private SettingsState getGlobalSettingsLocked() {
return getSettingsLocked(SETTINGS_TYPE_GLOBAL, UserHandle.USER_SYSTEM);
}
private SettingsState getSecureSettingsLocked(int userId) {
return getSettingsLocked(SETTINGS_TYPE_SECURE, userId);
}
private SettingsState getSsaidSettingsLocked(int userId) {
return getSettingsLocked(SETTINGS_TYPE_SSAID, userId);
}
private SettingsState getSystemSettingsLocked(int userId) {
return getSettingsLocked(SETTINGS_TYPE_SYSTEM, userId);
}
/**
* You must perform all necessary mutations to bring the settings
* for this user from the old to the new version. When you add a new
* upgrade step you *must* update SETTINGS_VERSION.
*
* All settings modifications should be made through
* {@link SettingsState#insertSettingOverrideableByRestoreLocked(String, String, String,
* boolean, String)} so that restore can override those values if needed.
*
* This is an example of moving a setting from secure to global.
*
* // v119: Example settings changes.
* if (currentVersion == 118) {
* if (userId == UserHandle.USER_OWNER) {
* // Remove from the secure settings.
* SettingsState secureSettings = getSecureSettingsLocked(userId);
* String name = "example_setting_to_move";
* String value = secureSettings.getSetting(name);
* secureSettings.deleteSetting(name);
*
* // Add to the global settings.
* SettingsState globalSettings = getGlobalSettingsLocked();
* globalSettings.insertSetting(name, value, SettingsState.SYSTEM_PACKAGE_NAME);
* }
*
* // Update the current version.
* currentVersion = 119;
* }
*/
private int onUpgradeLocked(int userId, int oldVersion, int newVersion) {
if (DEBUG) {
Slog.w(LOG_TAG, "Upgrading settings for user: " + userId + " from version: "
+ oldVersion + " to version: " + newVersion);
}
int currentVersion = oldVersion;
// v119: Reset zen + ringer mode.
if (currentVersion == 118) {
if (userId == UserHandle.USER_SYSTEM) {
final SettingsState globalSettings = getGlobalSettingsLocked();
globalSettings.updateSettingLocked(Settings.Global.ZEN_MODE,
Integer.toString(Settings.Global.ZEN_MODE_OFF), null,
true, SettingsState.SYSTEM_PACKAGE_NAME);
globalSettings.updateSettingLocked(Settings.Global.MODE_RINGER,
Integer.toString(AudioManager.RINGER_MODE_NORMAL), null,
true, SettingsState.SYSTEM_PACKAGE_NAME);
}
currentVersion = 119;
}
// v120: Add double tap to wake setting.
if (currentVersion == 119) {
SettingsState secureSettings = getSecureSettingsLocked(userId);
secureSettings.insertSettingOverrideableByRestoreLocked(
Settings.Secure.DOUBLE_TAP_TO_WAKE,
getContext().getResources().getBoolean(
R.bool.def_double_tap_to_wake) ? "1" : "0", null, true,
SettingsState.SYSTEM_PACKAGE_NAME);
currentVersion = 120;
}
if (currentVersion == 120) {
// Before 121, we used a different string encoding logic. We just bump the
// version here; SettingsState knows how to handle pre-version 120 files.
currentVersion = 121;
}
if (currentVersion == 121) {
// Version 122: allow OEMs to set a default payment component in resources.
// Note that we only write the default if no default has been set;
// if there is, we just leave the default at whatever it currently is.
final SettingsState secureSettings = getSecureSettingsLocked(userId);
String defaultComponent = (getContext().getResources().getString(
R.string.def_nfc_payment_component));
Setting currentSetting = secureSettings.getSettingLocked(
Settings.Secure.NFC_PAYMENT_DEFAULT_COMPONENT);
if (defaultComponent != null && !defaultComponent.isEmpty() &&
currentSetting.isNull()) {
secureSettings.insertSettingOverrideableByRestoreLocked(
Settings.Secure.NFC_PAYMENT_DEFAULT_COMPONENT,
defaultComponent, null, true, SettingsState.SYSTEM_PACKAGE_NAME);
}
currentVersion = 122;
}
if (currentVersion == 122) {
// Version 123: Adding a default value for the ability to add a user from
// the lock screen.
if (userId == UserHandle.USER_SYSTEM) {
final SettingsState globalSettings = getGlobalSettingsLocked();
Setting currentSetting = globalSettings.getSettingLocked(
Settings.Global.ADD_USERS_WHEN_LOCKED);
if (currentSetting.isNull()) {
globalSettings.insertSettingOverrideableByRestoreLocked(
Settings.Global.ADD_USERS_WHEN_LOCKED,
getContext().getResources().getBoolean(
R.bool.def_add_users_from_lockscreen) ? "1" : "0",
null, true, SettingsState.SYSTEM_PACKAGE_NAME);
}
}
currentVersion = 123;
}
if (currentVersion == 123) {
final SettingsState globalSettings = getGlobalSettingsLocked();
String defaultDisabledProfiles = (getContext().getResources().getString(
R.string.def_bluetooth_disabled_profiles));
globalSettings.insertSettingOverrideableByRestoreLocked(
Settings.Global.BLUETOOTH_DISABLED_PROFILES, defaultDisabledProfiles,
null, true, SettingsState.SYSTEM_PACKAGE_NAME);
currentVersion = 124;
}
if (currentVersion == 124) {
// Version 124: allow OEMs to set a default value for whether IME should be
// shown when a physical keyboard is connected.
final SettingsState secureSettings = getSecureSettingsLocked(userId);
Setting currentSetting = secureSettings.getSettingLocked(
Settings.Secure.SHOW_IME_WITH_HARD_KEYBOARD);
if (currentSetting.isNull()) {
secureSettings.insertSettingOverrideableByRestoreLocked(
Settings.Secure.SHOW_IME_WITH_HARD_KEYBOARD,
getContext().getResources().getBoolean(
R.bool.def_show_ime_with_hard_keyboard) ? "1" : "0",
null, true, SettingsState.SYSTEM_PACKAGE_NAME);
}
currentVersion = 125;
}
if (currentVersion == 125) {
// Version 125: Allow OEMs to set the default VR service.
final SettingsState secureSettings = getSecureSettingsLocked(userId);
Setting currentSetting = secureSettings.getSettingLocked(
Settings.Secure.ENABLED_VR_LISTENERS);
if (currentSetting.isNull()) {
ArraySet l =
SystemConfig.getInstance().getDefaultVrComponents();
if (l != null && !l.isEmpty()) {
StringBuilder b = new StringBuilder();
boolean start = true;
for (ComponentName c : l) {
if (!start) {
b.append(':');
}
b.append(c.flattenToString());
start = false;
}
secureSettings.insertSettingOverrideableByRestoreLocked(
Settings.Secure.ENABLED_VR_LISTENERS, b.toString(),
null, true, SettingsState.SYSTEM_PACKAGE_NAME);
}
}
currentVersion = 126;
}
if (currentVersion == 126) {
// Version 126: copy the primary values of LOCK_SCREEN_SHOW_NOTIFICATIONS and
// LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS into managed profile.
if (mUserManager.isManagedProfile(userId)) {
final SettingsState systemSecureSettings =
getSecureSettingsLocked(UserHandle.USER_SYSTEM);
final Setting showNotifications = systemSecureSettings.getSettingLocked(
Settings.Secure.LOCK_SCREEN_SHOW_NOTIFICATIONS);
if (!showNotifications.isNull()) {
final SettingsState secureSettings = getSecureSettingsLocked(userId);
secureSettings.insertSettingOverrideableByRestoreLocked(
Settings.Secure.LOCK_SCREEN_SHOW_NOTIFICATIONS,
showNotifications.getValue(), null, true,
SettingsState.SYSTEM_PACKAGE_NAME);
}
final Setting allowPrivate = systemSecureSettings.getSettingLocked(
Settings.Secure.LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS);
if (!allowPrivate.isNull()) {
final SettingsState secureSettings = getSecureSettingsLocked(userId);
secureSettings.insertSettingOverrideableByRestoreLocked(
Settings.Secure.LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS,
allowPrivate.getValue(), null, true,
SettingsState.SYSTEM_PACKAGE_NAME);
}
}
currentVersion = 127;
}
if (currentVersion == 127) {
// version 127 is no longer used.
currentVersion = 128;
}
if (currentVersion == 128) {
// Version 128: Removed
currentVersion = 129;
}
if (currentVersion == 129) {
// default longpress timeout changed from 500 to 400. If unchanged from the old
// default, update to the new default.
final SettingsState systemSecureSettings =
getSecureSettingsLocked(userId);
final String oldValue = systemSecureSettings.getSettingLocked(
Settings.Secure.LONG_PRESS_TIMEOUT).getValue();
if (TextUtils.equals("500", oldValue)) {
systemSecureSettings.insertSettingOverrideableByRestoreLocked(
Settings.Secure.LONG_PRESS_TIMEOUT,
String.valueOf(getContext().getResources().getInteger(
R.integer.def_long_press_timeout_millis)),
null, true, SettingsState.SYSTEM_PACKAGE_NAME);
}
currentVersion = 130;
}
if (currentVersion == 130) {
// Split Ambient settings
final SettingsState secureSettings = getSecureSettingsLocked(userId);
boolean dozeExplicitlyDisabled = "0".equals(secureSettings.
getSettingLocked(Settings.Secure.DOZE_ENABLED).getValue());
if (dozeExplicitlyDisabled) {
secureSettings.insertSettingOverrideableByRestoreLocked(
Settings.Secure.DOZE_PICK_UP_GESTURE, "0", null, true,
SettingsState.SYSTEM_PACKAGE_NAME);
secureSettings.insertSettingOverrideableByRestoreLocked(
Settings.Secure.DOZE_DOUBLE_TAP_GESTURE, "0", null, true,
SettingsState.SYSTEM_PACKAGE_NAME);
}
currentVersion = 131;
}
if (currentVersion == 131) {
// Initialize new multi-press timeout to default value
final SettingsState systemSecureSettings = getSecureSettingsLocked(userId);
final String oldValue = systemSecureSettings.getSettingLocked(
Settings.Secure.MULTI_PRESS_TIMEOUT).getValue();
if (TextUtils.equals(null, oldValue)) {
systemSecureSettings.insertSettingOverrideableByRestoreLocked(
Settings.Secure.MULTI_PRESS_TIMEOUT,
String.valueOf(getContext().getResources().getInteger(
R.integer.def_multi_press_timeout_millis)),
null, true, SettingsState.SYSTEM_PACKAGE_NAME);
}
currentVersion = 132;
}
if (currentVersion == 132) {
// Version 132: Allow managed profile to optionally use the parent's ringtones
final SettingsState systemSecureSettings = getSecureSettingsLocked(userId);
String defaultSyncParentSounds = (getContext().getResources()
.getBoolean(R.bool.def_sync_parent_sounds) ? "1" : "0");
systemSecureSettings.insertSettingOverrideableByRestoreLocked(
Settings.Secure.SYNC_PARENT_SOUNDS, defaultSyncParentSounds,
null, true, SettingsState.SYSTEM_PACKAGE_NAME);
currentVersion = 133;
}
if (currentVersion == 133) {
// Version 133: Add default end button behavior
final SettingsState systemSettings = getSystemSettingsLocked(userId);
if (systemSettings.getSettingLocked(Settings.System.END_BUTTON_BEHAVIOR)
.isNull()) {
String defaultEndButtonBehavior = Integer.toString(getContext()
.getResources().getInteger(R.integer.def_end_button_behavior));
systemSettings.insertSettingOverrideableByRestoreLocked(
Settings.System.END_BUTTON_BEHAVIOR, defaultEndButtonBehavior, null,
true, SettingsState.SYSTEM_PACKAGE_NAME);
}
currentVersion = 134;
}
if (currentVersion == 134) {
// Remove setting that specifies if magnification values should be preserved.
// This setting defaulted to true and never has a UI.
getSecureSettingsLocked(userId).deleteSettingLocked(
Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_AUTO_UPDATE);
currentVersion = 135;
}
if (currentVersion == 135) {
// Version 135 no longer used.
currentVersion = 136;
}
if (currentVersion == 136) {
// Version 136: Store legacy SSAID for all apps currently installed on the
// device as first step in migrating SSAID to be unique per application.
final boolean isUpgrade;
try {
isUpgrade = mPackageManager.isDeviceUpgrading();
} catch (RemoteException e) {
throw new IllegalStateException("Package manager not available");
}
// Only retain legacy ssaid if the device is performing an OTA. After wiping
// user data or first boot on a new device should use new ssaid generation.
if (isUpgrade) {
// Retrieve the legacy ssaid from the secure settings table.
final Setting legacySsaidSetting = getSettingLocked(SETTINGS_TYPE_SECURE,
userId, Settings.Secure.ANDROID_ID);
if (legacySsaidSetting == null || legacySsaidSetting.isNull()
|| legacySsaidSetting.getValue() == null) {
throw new IllegalStateException("Legacy ssaid not accessible");
}
final String legacySsaid = legacySsaidSetting.getValue();
// Fill each uid with the legacy ssaid to be backwards compatible.
final List packages;
try {
packages = mPackageManager.getInstalledPackages(
PackageManager.MATCH_UNINSTALLED_PACKAGES,
userId).getList();
} catch (RemoteException e) {
throw new IllegalStateException("Package manager not available");
}
final SettingsState ssaidSettings = getSsaidSettingsLocked(userId);
for (PackageInfo info : packages) {
// Check if the UID already has an entry in the table.
final String uid = Integer.toString(info.applicationInfo.uid);
final Setting ssaid = ssaidSettings.getSettingLocked(uid);
if (ssaid.isNull() || ssaid.getValue() == null) {
// Android Id doesn't exist for this package so create it.
ssaidSettings.insertSettingOverrideableByRestoreLocked(uid,
legacySsaid, null, true, info.packageName);
if (DEBUG) {
Slog.d(LOG_TAG, "Keep the legacy ssaid for uid=" + uid);
}
}
}
}
currentVersion = 137;
}
if (currentVersion == 137) {
// Version 138: Settings.Secure#INSTALL_NON_MARKET_APPS is deprecated and its
// default value set to 1. The user can no longer change the value of this
// setting through the UI.
final SettingsState secureSetting = getSecureSettingsLocked(userId);
if (!mUserManager.hasUserRestriction(
UserManager.DISALLOW_INSTALL_UNKNOWN_SOURCES, UserHandle.of(userId))
&& secureSetting.getSettingLocked(
Settings.Secure.INSTALL_NON_MARKET_APPS).getValue().equals("0")) {
secureSetting.insertSettingOverrideableByRestoreLocked(
Settings.Secure.INSTALL_NON_MARKET_APPS, "1", null, true,
SettingsState.SYSTEM_PACKAGE_NAME);
// For managed profiles with profile owners, DevicePolicyManagerService
// may want to set the user restriction in this case
secureSetting.insertSettingOverrideableByRestoreLocked(
Settings.Secure.UNKNOWN_SOURCES_DEFAULT_REVERSED, "1", null,
true, SettingsState.SYSTEM_PACKAGE_NAME);
}
currentVersion = 138;
}
if (currentVersion == 138) {
// Version 139: Removed.
currentVersion = 139;
}
if (currentVersion == 139) {
// Version 140: Settings.Secure#ACCESSIBILITY_SPEAK_PASSWORD is deprecated and
// the user can no longer change the value of this setting through the UI.
// Force to true.
final SettingsState secureSettings = getSecureSettingsLocked(userId);
secureSettings.updateSettingLocked(Settings.Secure.ACCESSIBILITY_SPEAK_PASSWORD,
"1", null, true, SettingsState.SYSTEM_PACKAGE_NAME);
currentVersion = 140;
}
if (currentVersion == 140) {
// Version 141: Removed
currentVersion = 141;
}
if (currentVersion == 141) {
// This implementation was incorrectly setting the current value of
// settings changed by non-system packages as the default which default
// is set by the system. We add a new upgrade step at the end to properly
// handle this case which would also fix incorrect changes made by the
// old implementation of this step.
currentVersion = 142;
}
if (currentVersion == 142) {
// Version 143: Set a default value for Wi-Fi wakeup feature.
if (userId == UserHandle.USER_SYSTEM) {
final SettingsState globalSettings = getGlobalSettingsLocked();
Setting currentSetting = globalSettings.getSettingLocked(
Settings.Global.WIFI_WAKEUP_ENABLED);
if (currentSetting.isNull()) {
globalSettings.insertSettingOverrideableByRestoreLocked(
Settings.Global.WIFI_WAKEUP_ENABLED,
getContext().getResources().getBoolean(
R.bool.def_wifi_wakeup_enabled) ? "1" : "0",
null, true, SettingsState.SYSTEM_PACKAGE_NAME);
}
}
currentVersion = 143;
}
if (currentVersion == 143) {
// Version 144: Set a default value for Autofill service.
final SettingsState secureSettings = getSecureSettingsLocked(userId);
final Setting currentSetting = secureSettings
.getSettingLocked(Settings.Secure.AUTOFILL_SERVICE);
if (currentSetting.isNull()) {
final String defaultValue = getContext().getResources().getString(
com.android.internal.R.string.config_defaultAutofillService);
if (defaultValue != null) {
Slog.d(LOG_TAG, "Setting [" + defaultValue + "] as Autofill Service "
+ "for user " + userId);
secureSettings.insertSettingOverrideableByRestoreLocked(
Settings.Secure.AUTOFILL_SERVICE, defaultValue, null, true,
SettingsState.SYSTEM_PACKAGE_NAME);
}
}
currentVersion = 144;
}
if (currentVersion == 144) {
// Version 145: Removed
currentVersion = 145;
}
if (currentVersion == 145) {
// Version 146: In step 142 we had a bug where incorrectly
// some settings were considered system set and as a result
// made the default and marked as the default being set by
// the system. Here reevaluate the default and default system
// set flags. This would both fix corruption by the old impl
// of step 142 and also properly handle devices which never
// run 142.
if (userId == UserHandle.USER_SYSTEM) {
SettingsState globalSettings = getGlobalSettingsLocked();
ensureLegacyDefaultValueAndSystemSetUpdatedLocked(globalSettings, userId);
globalSettings.persistSyncLocked();
}
SettingsState secureSettings = getSecureSettingsLocked(mUserId);
ensureLegacyDefaultValueAndSystemSetUpdatedLocked(secureSettings, userId);
secureSettings.persistSyncLocked();
SettingsState systemSettings = getSystemSettingsLocked(mUserId);
ensureLegacyDefaultValueAndSystemSetUpdatedLocked(systemSettings, userId);
systemSettings.persistSyncLocked();
currentVersion = 146;
}
if (currentVersion == 146) {
// Version 147: Removed. (This version previously allowed showing the
// "wifi_wakeup_available" setting).
// The setting that was added here is deleted in 153.
currentVersion = 147;
}
if (currentVersion == 147) {
// Version 148: Set the default value for DEFAULT_RESTRICT_BACKGROUND_DATA.
if (userId == UserHandle.USER_SYSTEM) {
final SettingsState globalSettings = getGlobalSettingsLocked();
final Setting currentSetting = globalSettings.getSettingLocked(
Global.DEFAULT_RESTRICT_BACKGROUND_DATA);
if (currentSetting.isNull()) {
globalSettings.insertSettingOverrideableByRestoreLocked(
Global.DEFAULT_RESTRICT_BACKGROUND_DATA,
getContext().getResources().getBoolean(
R.bool.def_restrict_background_data) ? "1" : "0",
null, true, SettingsState.SYSTEM_PACKAGE_NAME);
}
}
currentVersion = 148;
}
if (currentVersion == 148) {
// Version 149: Set the default value for BACKUP_MANAGER_CONSTANTS.
final SettingsState systemSecureSettings = getSecureSettingsLocked(userId);
final String oldValue = systemSecureSettings.getSettingLocked(
Settings.Secure.BACKUP_MANAGER_CONSTANTS).getValue();
if (TextUtils.equals(null, oldValue)) {
final String defaultValue = getContext().getResources().getString(
R.string.def_backup_manager_constants);
if (!TextUtils.isEmpty(defaultValue)) {
systemSecureSettings.insertSettingOverrideableByRestoreLocked(
Settings.Secure.BACKUP_MANAGER_CONSTANTS, defaultValue, null,
true, SettingsState.SYSTEM_PACKAGE_NAME);
}
}
currentVersion = 149;
}
if (currentVersion == 149) {
// Version 150: Set a default value for mobile data always on
final SettingsState globalSettings = getGlobalSettingsLocked();
final Setting currentSetting = globalSettings.getSettingLocked(
Settings.Global.MOBILE_DATA_ALWAYS_ON);
if (currentSetting.isNull()) {
globalSettings.insertSettingOverrideableByRestoreLocked(
Settings.Global.MOBILE_DATA_ALWAYS_ON,
getContext().getResources().getBoolean(
R.bool.def_mobile_data_always_on) ? "1" : "0",
null, true, SettingsState.SYSTEM_PACKAGE_NAME);
}
currentVersion = 150;
}
if (currentVersion == 150) {
// Version 151: Removed.
currentVersion = 151;
}
if (currentVersion == 151) {
// Version 152: Removed. (This version made the setting for wifi_wakeup enabled
// by default but it is now no longer configurable).
// The setting updated here is deleted in 153.
currentVersion = 152;
}
if (currentVersion == 152) {
getGlobalSettingsLocked().deleteSettingLocked("wifi_wakeup_available");
currentVersion = 153;
}
if (currentVersion == 153) {
// Version 154: Read notification badge configuration from config.
// If user has already set the value, don't do anything.
final SettingsState systemSecureSettings = getSecureSettingsLocked(userId);
final Setting showNotificationBadges = systemSecureSettings.getSettingLocked(
Settings.Secure.NOTIFICATION_BADGING);
if (showNotificationBadges.isNull()) {
final boolean defaultValue = getContext().getResources().getBoolean(
com.android.internal.R.bool.config_notificationBadging);
systemSecureSettings.insertSettingOverrideableByRestoreLocked(
Secure.NOTIFICATION_BADGING,
defaultValue ? "1" : "0",
null, true, SettingsState.SYSTEM_PACKAGE_NAME);
}
currentVersion = 154;
}
if (currentVersion == 154) {
// Version 155: Set the default value for BACKUP_LOCAL_TRANSPORT_PARAMETERS.
final SettingsState systemSecureSettings = getSecureSettingsLocked(userId);
final String oldValue = systemSecureSettings.getSettingLocked(
Settings.Secure.BACKUP_LOCAL_TRANSPORT_PARAMETERS).getValue();
if (TextUtils.equals(null, oldValue)) {
final String defaultValue = getContext().getResources().getString(
R.string.def_backup_local_transport_parameters);
if (!TextUtils.isEmpty(defaultValue)) {
systemSecureSettings.insertSettingOverrideableByRestoreLocked(
Settings.Secure.BACKUP_LOCAL_TRANSPORT_PARAMETERS, defaultValue,
null, true, SettingsState.SYSTEM_PACKAGE_NAME);
}
}
currentVersion = 155;
}
if (currentVersion == 155) {
// Version 156: migrated to version 184
currentVersion = 156;
}
if (currentVersion == 156) {
// Version 157: Set a default value for zen duration,
// in version 169, zen duration is moved to secure settings
final SettingsState globalSettings = getGlobalSettingsLocked();
final Setting currentSetting = globalSettings.getSettingLocked(
Global.ZEN_DURATION);
if (currentSetting.isNull()) {
String defaultZenDuration = Integer.toString(getContext()
.getResources().getInteger(R.integer.def_zen_duration));
globalSettings.insertSettingOverrideableByRestoreLocked(
Global.ZEN_DURATION, defaultZenDuration,
null, true, SettingsState.SYSTEM_PACKAGE_NAME);
}
currentVersion = 157;
}
if (currentVersion == 157) {
// Version 158: Set default value for BACKUP_AGENT_TIMEOUT_PARAMETERS.
final SettingsState globalSettings = getGlobalSettingsLocked();
final String oldValue = globalSettings.getSettingLocked(
Settings.Global.BACKUP_AGENT_TIMEOUT_PARAMETERS).getValue();
if (TextUtils.equals(null, oldValue)) {
final String defaultValue = getContext().getResources().getString(
R.string.def_backup_agent_timeout_parameters);
if (!TextUtils.isEmpty(defaultValue)) {
globalSettings.insertSettingOverrideableByRestoreLocked(
Settings.Global.BACKUP_AGENT_TIMEOUT_PARAMETERS, defaultValue,
null, true,
SettingsState.SYSTEM_PACKAGE_NAME);
}
}
currentVersion = 158;
}
if (currentVersion == 158) {
// Remove setting that specifies wifi bgscan throttling params
getGlobalSettingsLocked().deleteSettingLocked(
"wifi_scan_background_throttle_interval_ms");
getGlobalSettingsLocked().deleteSettingLocked(
"wifi_scan_background_throttle_package_whitelist");
currentVersion = 159;
}
if (currentVersion == 159) {
// Version 160: Hiding notifications from the lockscreen is only available as
// primary user option, profiles can only make them redacted. If a profile was
// configured to not show lockscreen notifications, ensure that at the very
// least these will be come hidden.
if (mUserManager.isManagedProfile(userId)) {
final SettingsState secureSettings = getSecureSettingsLocked(userId);
Setting showNotifications = secureSettings.getSettingLocked(
Settings.Secure.LOCK_SCREEN_SHOW_NOTIFICATIONS);
// The default value is "1", check if user has turned it off.
if ("0".equals(showNotifications.getValue())) {
secureSettings.insertSettingOverrideableByRestoreLocked(
Secure.LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS, "0",
null /* tag */, false /* makeDefault */,
SettingsState.SYSTEM_PACKAGE_NAME);
}
// The setting is no longer valid for managed profiles, it should be
// treated as if it was set to "1".
secureSettings.deleteSettingLocked(Secure.LOCK_SCREEN_SHOW_NOTIFICATIONS);
}
currentVersion = 160;
}
if (currentVersion == 160) {
// Version 161: Set the default value for
// MAX_SOUND_TRIGGER_DETECTION_SERVICE_OPS_PER_DAY and
// SOUND_TRIGGER_DETECTION_SERVICE_OP_TIMEOUT
final SettingsState globalSettings = getGlobalSettingsLocked();
String oldValue = globalSettings.getSettingLocked(
Global.MAX_SOUND_TRIGGER_DETECTION_SERVICE_OPS_PER_DAY).getValue();
if (TextUtils.equals(null, oldValue)) {
globalSettings.insertSettingOverrideableByRestoreLocked(
Settings.Global.MAX_SOUND_TRIGGER_DETECTION_SERVICE_OPS_PER_DAY,
Integer.toString(getContext().getResources().getInteger(
R.integer.def_max_sound_trigger_detection_service_ops_per_day)),
null, true, SettingsState.SYSTEM_PACKAGE_NAME);
}
oldValue = globalSettings.getSettingLocked(
Global.SOUND_TRIGGER_DETECTION_SERVICE_OP_TIMEOUT).getValue();
if (TextUtils.equals(null, oldValue)) {
globalSettings.insertSettingOverrideableByRestoreLocked(
Settings.Global.SOUND_TRIGGER_DETECTION_SERVICE_OP_TIMEOUT,
Integer.toString(getContext().getResources().getInteger(
R.integer.def_sound_trigger_detection_service_op_timeout)),
null, true, SettingsState.SYSTEM_PACKAGE_NAME);
}
currentVersion = 161;
}
if (currentVersion == 161) {
// Version 161: Add a gesture for silencing phones
final SettingsState secureSettings = getSecureSettingsLocked(userId);
final Setting currentSetting = secureSettings.getSettingLocked(
Secure.VOLUME_HUSH_GESTURE);
if (currentSetting.isNull()) {
secureSettings.insertSettingOverrideableByRestoreLocked(
Secure.VOLUME_HUSH_GESTURE,
Integer.toString(Secure.VOLUME_HUSH_VIBRATE),
null, true, SettingsState.SYSTEM_PACKAGE_NAME);
}
currentVersion = 162;
}
if (currentVersion == 162) {
// Version 162: REMOVED: Add a gesture for silencing phones
currentVersion = 163;
}
if (currentVersion == 163) {
// Version 163: Update default value of
// MAX_SOUND_TRIGGER_DETECTION_SERVICE_OPS_PER_DAY from old to new default
final SettingsState settings = getGlobalSettingsLocked();
final Setting currentSetting = settings.getSettingLocked(
Global.MAX_SOUND_TRIGGER_DETECTION_SERVICE_OPS_PER_DAY);
if (currentSetting.isDefaultFromSystem()) {
settings.insertSettingOverrideableByRestoreLocked(
Settings.Global.MAX_SOUND_TRIGGER_DETECTION_SERVICE_OPS_PER_DAY,
Integer.toString(getContext().getResources().getInteger(
R.integer
.def_max_sound_trigger_detection_service_ops_per_day)),
null, true, SettingsState.SYSTEM_PACKAGE_NAME);
}
currentVersion = 164;
}
if (currentVersion == 164) {
// Version 164: REMOVED: show zen upgrade notification
currentVersion = 165;
}
if (currentVersion == 165) {
// Version 165: MOVED: Show zen settings suggestion and zen updated settings
// moved to secure settings and are set in version 169
currentVersion = 166;
}
if (currentVersion == 166) {
// Version 166: add default values for hush gesture used and manual ringer
// toggle
final SettingsState secureSettings = getSecureSettingsLocked(userId);
Setting currentHushUsedSetting = secureSettings.getSettingLocked(
Secure.HUSH_GESTURE_USED);
if (currentHushUsedSetting.isNull()) {
secureSettings.insertSettingOverrideableByRestoreLocked(
Settings.Secure.HUSH_GESTURE_USED, "0", null, true,
SettingsState.SYSTEM_PACKAGE_NAME);
}
Setting currentRingerToggleCountSetting = secureSettings.getSettingLocked(
Secure.MANUAL_RINGER_TOGGLE_COUNT);
if (currentRingerToggleCountSetting.isNull()) {
secureSettings.insertSettingOverrideableByRestoreLocked(
Settings.Secure.MANUAL_RINGER_TOGGLE_COUNT, "0", null, true,
SettingsState.SYSTEM_PACKAGE_NAME);
}
currentVersion = 167;
}
if (currentVersion == 167) {
// Version 167: MOVED - Settings.Global.CHARGING_VIBRATION_ENABLED moved to
// Settings.Secure.CHARGING_VIBRATION_ENABLED, set in version 170
currentVersion = 168;
}
if (currentVersion == 168) {
// Version 168: by default, vibrate for phone calls
final SettingsState systemSettings = getSystemSettingsLocked(userId);
final Setting currentSetting = systemSettings.getSettingLocked(
Settings.System.VIBRATE_WHEN_RINGING);
if (currentSetting.isNull()) {
systemSettings.insertSettingOverrideableByRestoreLocked(
Settings.System.VIBRATE_WHEN_RINGING,
getContext().getResources().getBoolean(
R.bool.def_vibrate_when_ringing) ? "1" : "0",
null, true, SettingsState.SYSTEM_PACKAGE_NAME);
}
currentVersion = 169;
}
if (currentVersion == 169) {
// Version 169: Set the default value for Secure Settings ZEN_DURATION,
// SHOW_ZEN_SETTINGS_SUGGESTION, ZEN_SETTINGS_UPDATE and
// ZEN_SETTINGS_SUGGESTION_VIEWED
final SettingsState globalSettings = getGlobalSettingsLocked();
final Setting globalZenDuration = globalSettings.getSettingLocked(
Global.ZEN_DURATION);
final SettingsState secureSettings = getSecureSettingsLocked(userId);
final Setting secureZenDuration = secureSettings.getSettingLocked(
Secure.ZEN_DURATION);
// ZEN_DURATION
if (!globalZenDuration.isNull()) {
secureSettings.insertSettingOverrideableByRestoreLocked(
Secure.ZEN_DURATION, globalZenDuration.getValue(), null, false,
SettingsState.SYSTEM_PACKAGE_NAME);
// set global zen duration setting to null since it's deprecated
globalSettings.insertSettingOverrideableByRestoreLocked(
Global.ZEN_DURATION, null, null, true,
SettingsState.SYSTEM_PACKAGE_NAME);
} else if (secureZenDuration.isNull()) {
String defaultZenDuration = Integer.toString(getContext()
.getResources().getInteger(R.integer.def_zen_duration));
secureSettings.insertSettingOverrideableByRestoreLocked(
Secure.ZEN_DURATION, defaultZenDuration, null, true,
SettingsState.SYSTEM_PACKAGE_NAME);
}
// SHOW_ZEN_SETTINGS_SUGGESTION
final Setting currentShowZenSettingSuggestion = secureSettings.getSettingLocked(
Secure.SHOW_ZEN_SETTINGS_SUGGESTION);
if (currentShowZenSettingSuggestion.isNull()) {
secureSettings.insertSettingOverrideableByRestoreLocked(
Secure.SHOW_ZEN_SETTINGS_SUGGESTION, "1",
null, true, SettingsState.SYSTEM_PACKAGE_NAME);
}
// ZEN_SETTINGS_UPDATED
final Setting currentUpdatedSetting = secureSettings.getSettingLocked(
Secure.ZEN_SETTINGS_UPDATED);
if (currentUpdatedSetting.isNull()) {
secureSettings.insertSettingOverrideableByRestoreLocked(
Secure.ZEN_SETTINGS_UPDATED, "0",
null, true, SettingsState.SYSTEM_PACKAGE_NAME);
}
// ZEN_SETTINGS_SUGGESTION_VIEWED
final Setting currentSettingSuggestionViewed = secureSettings.getSettingLocked(
Secure.ZEN_SETTINGS_SUGGESTION_VIEWED);
if (currentSettingSuggestionViewed.isNull()) {
secureSettings.insertSettingOverrideableByRestoreLocked(
Secure.ZEN_SETTINGS_SUGGESTION_VIEWED, "0",
null, true, SettingsState.SYSTEM_PACKAGE_NAME);
}
currentVersion = 170;
}
if (currentVersion == 170) {
// Version 170: Set the default value for Secure Settings:
// CHARGING_SOUNDS_ENABLED and CHARGING_VIBRATION_ENABLED
final SettingsState globalSettings = getGlobalSettingsLocked();
final SettingsState secureSettings = getSecureSettingsLocked(userId);
// CHARGING_SOUNDS_ENABLED
final Setting globalChargingSoundEnabled = globalSettings.getSettingLocked(
Global.CHARGING_SOUNDS_ENABLED);
final Setting secureChargingSoundsEnabled = secureSettings.getSettingLocked(
Secure.CHARGING_SOUNDS_ENABLED);
if (!globalChargingSoundEnabled.isNull()) {
if (secureChargingSoundsEnabled.isNull()) {
secureSettings.insertSettingOverrideableByRestoreLocked(
Secure.CHARGING_SOUNDS_ENABLED,
globalChargingSoundEnabled.getValue(), null, false,
SettingsState.SYSTEM_PACKAGE_NAME);
}
// set global charging_sounds_enabled setting to null since it's deprecated
globalSettings.insertSettingOverrideableByRestoreLocked(
Global.CHARGING_SOUNDS_ENABLED, null, null, true,
SettingsState.SYSTEM_PACKAGE_NAME);
} else if (secureChargingSoundsEnabled.isNull()) {
String defChargingSoundsEnabled = getContext().getResources()
.getBoolean(R.bool.def_charging_sounds_enabled) ? "1" : "0";
secureSettings.insertSettingOverrideableByRestoreLocked(
Secure.CHARGING_SOUNDS_ENABLED, defChargingSoundsEnabled, null,
true, SettingsState.SYSTEM_PACKAGE_NAME);
}
// CHARGING_VIBRATION_ENABLED
final Setting secureChargingVibrationEnabled = secureSettings.getSettingLocked(
Secure.CHARGING_VIBRATION_ENABLED);
if (secureChargingVibrationEnabled.isNull()) {
String defChargingVibrationEnabled = getContext().getResources()
.getBoolean(R.bool.def_charging_vibration_enabled) ? "1" : "0";
secureSettings.insertSettingOverrideableByRestoreLocked(
Secure.CHARGING_VIBRATION_ENABLED, defChargingVibrationEnabled,
null, true, SettingsState.SYSTEM_PACKAGE_NAME);
}
currentVersion = 171;
}
if (currentVersion == 171) {
// Version 171: by default, add STREAM_VOICE_CALL to list of streams that can
// be muted.
final SettingsState systemSettings = getSystemSettingsLocked(userId);
final Setting currentSetting = systemSettings.getSettingLocked(
Settings.System.MUTE_STREAMS_AFFECTED);
if (!currentSetting.isNull()) {
try {
int currentSettingIntegerValue = Integer.parseInt(
currentSetting.getValue());
if ((currentSettingIntegerValue
& (1 << AudioManager.STREAM_VOICE_CALL)) == 0) {
systemSettings.insertSettingOverrideableByRestoreLocked(
Settings.System.MUTE_STREAMS_AFFECTED,
Integer.toString(
currentSettingIntegerValue
| (1 << AudioManager.STREAM_VOICE_CALL)),
null, true, SettingsState.SYSTEM_PACKAGE_NAME);
}
} catch (NumberFormatException e) {
// remove the setting in case it is not a valid integer
Slog.w("Failed to parse integer value of MUTE_STREAMS_AFFECTED"
+ "setting, removing setting", e);
systemSettings.deleteSettingLocked(
Settings.System.MUTE_STREAMS_AFFECTED);
}
}
currentVersion = 172;
}
if (currentVersion == 172) {
// Version 172: Set the default value for Secure Settings: LOCATION_MODE
final SettingsState secureSettings = getSecureSettingsLocked(userId);
final Setting locationMode = secureSettings.getSettingLocked(
Secure.LOCATION_MODE);
if (locationMode.isNull()) {
final Setting locationProvidersAllowed = secureSettings.getSettingLocked(
Secure.LOCATION_PROVIDERS_ALLOWED);
final int defLocationMode;
if (locationProvidersAllowed.isNull()) {
defLocationMode = getContext().getResources().getInteger(
R.integer.def_location_mode);
} else {
defLocationMode =
!TextUtils.isEmpty(locationProvidersAllowed.getValue())
? Secure.LOCATION_MODE_ON
: Secure.LOCATION_MODE_OFF;
}
secureSettings.insertSettingOverrideableByRestoreLocked(
Secure.LOCATION_MODE, Integer.toString(defLocationMode),
null, true, SettingsState.SYSTEM_PACKAGE_NAME);
}
currentVersion = 173;
}
if (currentVersion == 173) {
// Version 173: Set the default value for Secure Settings: NOTIFICATION_BUBBLES
// Removed. Moved NOTIFICATION_BUBBLES to Global Settings.
currentVersion = 174;
}
if (currentVersion == 174) {
// Version 174: Set the default value for Global Settings: APPLY_RAMPING_RINGER
final SettingsState globalSettings = getGlobalSettingsLocked();
Setting currentRampingRingerSetting = globalSettings.getSettingLocked(
Settings.Global.APPLY_RAMPING_RINGER);
if (currentRampingRingerSetting.isNull()) {
globalSettings.insertSettingOverrideableByRestoreLocked(
Settings.Global.APPLY_RAMPING_RINGER,
getContext().getResources().getBoolean(
R.bool.def_apply_ramping_ringer) ? "1" : "0", null,
true, SettingsState.SYSTEM_PACKAGE_NAME);
}
currentVersion = 175;
}
if (currentVersion == 175) {
// Version 175: Set the default value for System Settings:
// RING_VIBRATION_INTENSITY. If the notification vibration intensity has been
// set and ring vibration intensity hasn't, the ring vibration intensity should
// followed notification vibration intensity.
final SettingsState systemSettings = getSystemSettingsLocked(userId);
Setting notificationVibrationIntensity = systemSettings.getSettingLocked(
Settings.System.NOTIFICATION_VIBRATION_INTENSITY);
Setting ringVibrationIntensity = systemSettings.getSettingLocked(
Settings.System.RING_VIBRATION_INTENSITY);
if (!notificationVibrationIntensity.isNull()
&& ringVibrationIntensity.isNull()) {
systemSettings.insertSettingOverrideableByRestoreLocked(
Settings.System.RING_VIBRATION_INTENSITY,
notificationVibrationIntensity.getValue(),
null , true, SettingsState.SYSTEM_PACKAGE_NAME);
}
currentVersion = 176;
}
if (currentVersion == 176) {
// Version 176: Migrate the existing swipe up setting into the resource overlay
// for the navigation bar interaction mode. We do so only if the
// setting is set.
final SettingsState secureSettings = getSecureSettingsLocked(userId);
final Setting swipeUpSetting = secureSettings.getSettingLocked(
"swipe_up_to_switch_apps_enabled");
if (swipeUpSetting != null && !swipeUpSetting.isNull()
&& swipeUpSetting.getValue().equals("1")) {
final IOverlayManager overlayManager = IOverlayManager.Stub.asInterface(
ServiceManager.getService(Context.OVERLAY_SERVICE));
try {
overlayManager.setEnabledExclusiveInCategory(
NAV_BAR_MODE_2BUTTON_OVERLAY, UserHandle.USER_CURRENT);
} catch (SecurityException | IllegalStateException | RemoteException e) {
throw new IllegalStateException(
"Failed to set nav bar interaction mode overlay");
}
}
currentVersion = 177;
}
if (currentVersion == 177) {
// Version 177: Set the default value for Secure Settings: AWARE_ENABLED
final SettingsState secureSettings = getSecureSettingsLocked(userId);
final Setting awareEnabled = secureSettings.getSettingLocked(
Secure.AWARE_ENABLED);
if (awareEnabled.isNull()) {
final boolean defAwareEnabled = getContext().getResources().getBoolean(
R.bool.def_aware_enabled);
secureSettings.insertSettingOverrideableByRestoreLocked(
Secure.AWARE_ENABLED, defAwareEnabled ? "1" : "0",
null, true, SettingsState.SYSTEM_PACKAGE_NAME);
}
currentVersion = 178;
}
if (currentVersion == 178) {
// Version 178: Set the default value for Secure Settings:
// SKIP_GESTURE & SILENCE_GESTURE
final SettingsState secureSettings = getSecureSettingsLocked(userId);
final Setting skipGesture = secureSettings.getSettingLocked(
Secure.SKIP_GESTURE);
if (skipGesture.isNull()) {
final boolean defSkipGesture = getContext().getResources().getBoolean(
R.bool.def_skip_gesture);
secureSettings.insertSettingOverrideableByRestoreLocked(
Secure.SKIP_GESTURE, defSkipGesture ? "1" : "0",
null, true, SettingsState.SYSTEM_PACKAGE_NAME);
}
final Setting silenceGesture = secureSettings.getSettingLocked(
Secure.SILENCE_GESTURE);
if (silenceGesture.isNull()) {
final boolean defSilenceGesture = getContext().getResources().getBoolean(
R.bool.def_silence_gesture);
secureSettings.insertSettingOverrideableByRestoreLocked(
Secure.SILENCE_GESTURE, defSilenceGesture ? "1" : "0",
null, true, SettingsState.SYSTEM_PACKAGE_NAME);
}
currentVersion = 179;
}
if (currentVersion == 179) {
// Version 178: Reset the default for Secure Settings: NOTIFICATION_BUBBLES
// This is originally set in version 173, however, the default value changed
// so this step is to ensure the value is updated to the correct default.
// Removed. Moved NOTIFICATION_BUBBLES to Global Settings.
currentVersion = 180;
}
if (currentVersion == 180) {
// Version 180: Set the default value for Secure Settings: AWARE_LOCK_ENABLED
final SettingsState secureSettings = getSecureSettingsLocked(userId);
final Setting awareLockEnabled = secureSettings.getSettingLocked(
Secure.AWARE_LOCK_ENABLED);
if (awareLockEnabled.isNull()) {
final boolean defAwareLockEnabled = getContext().getResources().getBoolean(
R.bool.def_aware_lock_enabled);
secureSettings.insertSettingOverrideableByRestoreLocked(
Secure.AWARE_LOCK_ENABLED, defAwareLockEnabled ? "1" : "0",
null, true, SettingsState.SYSTEM_PACKAGE_NAME);
}
currentVersion = 181;
}
if (currentVersion == 181) {
// Version cd : by default, add STREAM_BLUETOOTH_SCO to list of streams that can
// be muted.
final SettingsState systemSettings = getSystemSettingsLocked(userId);
final Setting currentSetting = systemSettings.getSettingLocked(
Settings.System.MUTE_STREAMS_AFFECTED);
if (!currentSetting.isNull()) {
try {
int currentSettingIntegerValue = Integer.parseInt(
currentSetting.getValue());
if ((currentSettingIntegerValue
& (1 << AudioManager.STREAM_BLUETOOTH_SCO)) == 0) {
systemSettings.insertSettingOverrideableByRestoreLocked(
Settings.System.MUTE_STREAMS_AFFECTED,
Integer.toString(
currentSettingIntegerValue
| (1 << AudioManager.STREAM_BLUETOOTH_SCO)),
null, true, SettingsState.SYSTEM_PACKAGE_NAME);
}
} catch (NumberFormatException e) {
// remove the setting in case it is not a valid integer
Slog.w("Failed to parse integer value of MUTE_STREAMS_AFFECTED"
+ "setting, removing setting", e);
systemSettings.deleteSettingLocked(
Settings.System.MUTE_STREAMS_AFFECTED);
}
}
currentVersion = 182;
}
if (currentVersion == 182) {
// Remove secure bubble settings; it's in global now.
getSecureSettingsLocked(userId).deleteSettingLocked("notification_bubbles");
// Removed. Updated NOTIFICATION_BUBBLES to be true by default, see 184.
currentVersion = 183;
}
if (currentVersion == 183) {
// Version 183: Set default values for WIRELESS_CHARGING_STARTED_SOUND
// and CHARGING_STARTED_SOUND
final SettingsState globalSettings = getGlobalSettingsLocked();
final String oldValueWireless = globalSettings.getSettingLocked(
Global.WIRELESS_CHARGING_STARTED_SOUND).getValue();
final String oldValueWired = globalSettings.getSettingLocked(
Global.CHARGING_STARTED_SOUND).getValue();
final String defaultValueWireless = getContext().getResources().getString(
R.string.def_wireless_charging_started_sound);
final String defaultValueWired = getContext().getResources().getString(
R.string.def_charging_started_sound);
// wireless charging sound
if (oldValueWireless == null
|| TextUtils.equals(oldValueWireless, defaultValueWired)) {
if (!TextUtils.isEmpty(defaultValueWireless)) {
globalSettings.insertSettingOverrideableByRestoreLocked(
Global.WIRELESS_CHARGING_STARTED_SOUND, defaultValueWireless,
null /* tag */, true /* makeDefault */,
SettingsState.SYSTEM_PACKAGE_NAME);
} else if (!TextUtils.isEmpty(defaultValueWired)) {
// if the wireless sound is empty, use the wired charging sound
globalSettings.insertSettingOverrideableByRestoreLocked(
Global.WIRELESS_CHARGING_STARTED_SOUND, defaultValueWired,
null /* tag */, true /* makeDefault */,
SettingsState.SYSTEM_PACKAGE_NAME);
}
}
// wired charging sound
if (oldValueWired == null && !TextUtils.isEmpty(defaultValueWired)) {
globalSettings.insertSettingOverrideableByRestoreLocked(
Global.CHARGING_STARTED_SOUND, defaultValueWired,
null /* tag */, true /* makeDefault */,
SettingsState.SYSTEM_PACKAGE_NAME);
}
currentVersion = 184;
}
if (currentVersion == 184) {
// Version 184: Reset the default for Global Settings: NOTIFICATION_BUBBLES
// This is originally set in version 182, however, the default value changed
// so this step is to ensure the value is updated to the correct default.
getGlobalSettingsLocked().insertSettingOverrideableByRestoreLocked(
Global.NOTIFICATION_BUBBLES, getContext().getResources().getBoolean(
R.bool.def_notification_bubbles) ? "1" : "0", null /* tag */,
true /* makeDefault */, SettingsState.SYSTEM_PACKAGE_NAME);
currentVersion = 185;
}
if (currentVersion == 185) {
// Deprecate ACCESSIBILITY_DISPLAY_MAGNIFICATION_NAVBAR_ENABLED, and migrate it
// to ACCESSIBILITY_BUTTON_TARGETS.
final SettingsState secureSettings = getSecureSettingsLocked(userId);
final Setting magnifyNavbarEnabled = secureSettings.getSettingLocked(
Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_NAVBAR_ENABLED);
if ("1".equals(magnifyNavbarEnabled.getValue())) {
secureSettings.insertSettingLocked(
Secure.ACCESSIBILITY_BUTTON_TARGETS,
ACCESSIBILITY_SHORTCUT_TARGET_MAGNIFICATION_CONTROLLER,
null /* tag */, false /* makeDefault */,
SettingsState.SYSTEM_PACKAGE_NAME);
}
secureSettings.deleteSettingLocked(
Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_NAVBAR_ENABLED);
currentVersion = 186;
}
if (currentVersion == 186) {
// Remove unused wifi settings
getGlobalSettingsLocked().deleteSettingLocked(
"wifi_rtt_background_exec_gap_ms");
getGlobalSettingsLocked().deleteSettingLocked(
"network_recommendation_request_timeout_ms");
getGlobalSettingsLocked().deleteSettingLocked(
"wifi_suspend_optimizations_enabled");
getGlobalSettingsLocked().deleteSettingLocked(
"wifi_is_unusable_event_metrics_enabled");
getGlobalSettingsLocked().deleteSettingLocked(
"wifi_data_stall_min_tx_bad");
getGlobalSettingsLocked().deleteSettingLocked(
"wifi_data_stall_min_tx_success_without_rx");
getGlobalSettingsLocked().deleteSettingLocked(
"wifi_link_speed_metrics_enabled");
getGlobalSettingsLocked().deleteSettingLocked(
"wifi_pno_frequency_culling_enabled");
getGlobalSettingsLocked().deleteSettingLocked(
"wifi_pno_recency_sorting_enabled");
getGlobalSettingsLocked().deleteSettingLocked(
"wifi_link_probing_enabled");
getGlobalSettingsLocked().deleteSettingLocked(
"wifi_saved_state");
currentVersion = 187;
}
if (currentVersion == 187) {
// Migrate adaptive sleep setting from System to Secure.
if (userId == UserHandle.USER_OWNER) {
// Remove from the system settings.
SettingsState systemSettings = getSystemSettingsLocked(userId);
String name = Settings.System.ADAPTIVE_SLEEP;
Setting setting = systemSettings.getSettingLocked(name);
systemSettings.deleteSettingLocked(name);
// Add to the secure settings.
SettingsState secureSettings = getSecureSettingsLocked(userId);
secureSettings.insertSettingLocked(name, setting.getValue(), null /* tag */,
false /* makeDefault */, SettingsState.SYSTEM_PACKAGE_NAME);
}
currentVersion = 188;
}
if (currentVersion == 188) {
// Deprecate ACCESSIBILITY_SHORTCUT_ENABLED, and migrate it
// to ACCESSIBILITY_SHORTCUT_TARGET_SERVICE.
final SettingsState secureSettings = getSecureSettingsLocked(userId);
final Setting shortcutEnabled = secureSettings.getSettingLocked(
"accessibility_shortcut_enabled");
if ("0".equals(shortcutEnabled.getValue())) {
// Clear shortcut key targets list setting.
secureSettings.insertSettingLocked(
Secure.ACCESSIBILITY_SHORTCUT_TARGET_SERVICE,
"", null /* tag */, false /* makeDefault */,
SettingsState.SYSTEM_PACKAGE_NAME);
}
secureSettings.deleteSettingLocked("accessibility_shortcut_enabled");
currentVersion = 189;
}
if (currentVersion == 189) {
final SettingsState secureSettings = getSecureSettingsLocked(userId);
final Setting showNotifications = secureSettings.getSettingLocked(
Secure.LOCK_SCREEN_SHOW_NOTIFICATIONS);
final Setting allowPrivateNotifications = secureSettings.getSettingLocked(
Secure.LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS);
if ("1".equals(showNotifications.getValue())
&& "1".equals(allowPrivateNotifications.getValue())) {
secureSettings.insertSettingLocked(
Secure.POWER_MENU_LOCKED_SHOW_CONTENT,
"1", null /* tag */, false /* makeDefault */,
SettingsState.SYSTEM_PACKAGE_NAME);
} else if ("0".equals(showNotifications.getValue())
|| "0".equals(allowPrivateNotifications.getValue())) {
secureSettings.insertSettingLocked(
Secure.POWER_MENU_LOCKED_SHOW_CONTENT,
"0", null /* tag */, false /* makeDefault */,
SettingsState.SYSTEM_PACKAGE_NAME);
}
currentVersion = 190;
}
if (currentVersion == 190) {
// Version 190: get HDMI auto device off from overlay
final SettingsState globalSettings = getGlobalSettingsLocked();
final Setting currentSetting = globalSettings.getSettingLocked(
Global.HDMI_CONTROL_AUTO_DEVICE_OFF_ENABLED);
if (currentSetting.isNull()) {
globalSettings.insertSettingLocked(
Global.HDMI_CONTROL_AUTO_DEVICE_OFF_ENABLED,
getContext().getResources().getBoolean(
R.bool.def_hdmiControlAutoDeviceOff) ? "1" : "0",
null, true, SettingsState.SYSTEM_PACKAGE_NAME);
}
currentVersion = 191;
}
// vXXX: Add new settings above this point.
if (currentVersion != newVersion) {
Slog.wtf("SettingsProvider", "warning: upgrading settings database to version "
+ newVersion + " left it at "
+ currentVersion +
" instead; this is probably a bug. Did you update SETTINGS_VERSION?",
new Throwable());
if (DEBUG) {
throw new RuntimeException("db upgrade error");
}
}
// Return the current version.
return currentVersion;
}
}
private void ensureLegacyDefaultValueAndSystemSetUpdatedLocked(SettingsState settings,
int userId) {
List names = settings.getSettingNamesLocked();
final int nameCount = names.size();
for (int i = 0; i < nameCount; i++) {
String name = names.get(i);
Setting setting = settings.getSettingLocked(name);
// In the upgrade case we pretend the call is made from the app
// that made the last change to the setting to properly determine
// whether the call has been made by a system component.
int callingUid = -1;
try {
callingUid = mPackageManager.getPackageUid(setting.getPackageName(), 0, userId);
} catch (RemoteException e) {
/* ignore - handled below */
}
if (callingUid < 0) {
Slog.e(LOG_TAG, "Unknown package: " + setting.getPackageName());
continue;
}
try {
final boolean systemSet = SettingsState.isSystemPackage(getContext(),
setting.getPackageName(), callingUid, userId);
if (systemSet) {
settings.insertSettingOverrideableByRestoreLocked(name, setting.getValue(),
setting.getTag(), true, setting.getPackageName());
} else if (setting.getDefaultValue() != null && setting.isDefaultFromSystem()) {
// We had a bug where changes by non-system packages were marked
// as system made and as a result set as the default. Therefore, if
// the package changed the setting last is not a system one but the
// setting is marked as its default coming from the system we clear
// the default and clear the system set flag.
settings.resetSettingDefaultValueLocked(name);
}
} catch (IllegalStateException e) {
// If the package goes over its quota during the upgrade, don't
// crash but just log the error as the system does the upgrade.
Slog.e(LOG_TAG, "Error upgrading setting: " + setting.getName(), e);
}
}
}
}
}