/* * Copyright (C) 2015 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.android.providers.settings; import android.os.Handler; import android.os.Message; import android.os.SystemClock; import android.provider.Settings; import android.text.TextUtils; import android.util.ArrayMap; import android.util.AtomicFile; import android.util.Base64; import android.util.Slog; import android.util.Xml; import com.android.internal.annotations.GuardedBy; import com.android.internal.os.BackgroundThread; import libcore.io.IoUtils; import libcore.util.Objects; import org.xmlpull.v1.XmlPullParser; import org.xmlpull.v1.XmlPullParserException; import org.xmlpull.v1.XmlSerializer; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.nio.charset.StandardCharsets; import java.util.ArrayList; import java.util.List; /** * This class contains the state for one type of settings. It is responsible * for saving the state asynchronously to an XML file after a mutation and * loading the from an XML file on construction. * <p> * This class uses the same lock as the settings provider to ensure that * multiple changes made by the settings provider, e,g, upgrade, bulk insert, * etc, are atomically persisted since the asynchronous persistence is using * the same lock to grab the current state to write to disk. * </p> */ final class SettingsState { private static final boolean DEBUG = false; private static final boolean DEBUG_PERSISTENCE = false; private static final String LOG_TAG = "SettingsState"; static final int SETTINGS_VERSOIN_NEW_ENCODING = 121; private static final long WRITE_SETTINGS_DELAY_MILLIS = 200; private static final long MAX_WRITE_SETTINGS_DELAY_MILLIS = 2000; public static final int MAX_BYTES_PER_APP_PACKAGE_UNLIMITED = -1; public static final int MAX_BYTES_PER_APP_PACKAGE_LIMITED = 20000; public static final String SYSTEM_PACKAGE_NAME = "android"; public static final int VERSION_UNDEFINED = -1; private static final String TAG_SETTINGS = "settings"; private static final String TAG_SETTING = "setting"; private static final String ATTR_PACKAGE = "package"; private static final String ATTR_VERSION = "version"; private static final String ATTR_ID = "id"; private static final String ATTR_NAME = "name"; /** Non-binary value will be written in this attribute. */ private static final String ATTR_VALUE = "value"; /** * KXmlSerializer won't like some characters. We encode such characters in base64 and * store in this attribute. * NOTE: A null value will have NEITHER ATTR_VALUE nor ATTR_VALUE_BASE64. */ private static final String ATTR_VALUE_BASE64 = "valueBase64"; // This was used in version 120 and before. private static final String NULL_VALUE_OLD_STYLE = "null"; private final Object mLock; private final Handler mHandler = new MyHandler(); @GuardedBy("mLock") private final ArrayMap<String, Setting> mSettings = new ArrayMap<>(); @GuardedBy("mLock") private final ArrayMap<String, Integer> mPackageToMemoryUsage; @GuardedBy("mLock") private final int mMaxBytesPerAppPackage; @GuardedBy("mLock") private final File mStatePersistFile; public final int mKey; @GuardedBy("mLock") private int mVersion = VERSION_UNDEFINED; @GuardedBy("mLock") private long mLastNotWrittenMutationTimeMillis; @GuardedBy("mLock") private boolean mDirty; @GuardedBy("mLock") private boolean mWriteScheduled; @GuardedBy("mLock") private long mNextId; public SettingsState(Object lock, File file, int key, int maxBytesPerAppPackage) { // It is important that we use the same lock as the settings provider // to ensure multiple mutations on this state are atomicaly persisted // as the async persistence should be blocked while we make changes. mLock = lock; mStatePersistFile = file; mKey = key; if (maxBytesPerAppPackage == MAX_BYTES_PER_APP_PACKAGE_LIMITED) { mMaxBytesPerAppPackage = maxBytesPerAppPackage; mPackageToMemoryUsage = new ArrayMap<>(); } else { mMaxBytesPerAppPackage = maxBytesPerAppPackage; mPackageToMemoryUsage = null; } synchronized (mLock) { readStateSyncLocked(); } } // The settings provider must hold its lock when calling here. public int getVersionLocked() { return mVersion; } // The settings provider must hold its lock when calling here. public void setVersionLocked(int version) { if (version == mVersion) { return; } mVersion = version; scheduleWriteIfNeededLocked(); } // The settings provider must hold its lock when calling here. public void onPackageRemovedLocked(String packageName) { boolean removedSomething = false; final int settingCount = mSettings.size(); for (int i = settingCount - 1; i >= 0; i--) { String name = mSettings.keyAt(i); // Settings defined by us are never dropped. if (Settings.System.PUBLIC_SETTINGS.contains(name) || Settings.System.PRIVATE_SETTINGS.contains(name)) { continue; } Setting setting = mSettings.valueAt(i); if (packageName.equals(setting.packageName)) { mSettings.removeAt(i); removedSomething = true; } } if (removedSomething) { scheduleWriteIfNeededLocked(); } } // The settings provider must hold its lock when calling here. public List<String> getSettingNamesLocked() { ArrayList<String> names = new ArrayList<>(); final int settingsCount = mSettings.size(); for (int i = 0; i < settingsCount; i++) { String name = mSettings.keyAt(i); names.add(name); } return names; } // The settings provider must hold its lock when calling here. public Setting getSettingLocked(String name) { if (TextUtils.isEmpty(name)) { return null; } return mSettings.get(name); } // The settings provider must hold its lock when calling here. public boolean updateSettingLocked(String name, String value, String packageName) { if (!hasSettingLocked(name)) { return false; } return insertSettingLocked(name, value, packageName); } // The settings provider must hold its lock when calling here. public boolean insertSettingLocked(String name, String value, String packageName) { if (TextUtils.isEmpty(name)) { return false; } Setting oldState = mSettings.get(name); String oldValue = (oldState != null) ? oldState.value : null; if (oldState != null) { if (!oldState.update(value, packageName)) { return false; } } else { Setting state = new Setting(name, value, packageName); mSettings.put(name, state); } updateMemoryUsagePerPackageLocked(packageName, oldValue, value); scheduleWriteIfNeededLocked(); return true; } // The settings provider must hold its lock when calling here. public void persistSyncLocked() { mHandler.removeMessages(MyHandler.MSG_PERSIST_SETTINGS); doWriteState(); } // The settings provider must hold its lock when calling here. public boolean deleteSettingLocked(String name) { if (TextUtils.isEmpty(name) || !hasSettingLocked(name)) { return false; } Setting oldState = mSettings.remove(name); updateMemoryUsagePerPackageLocked(oldState.packageName, oldState.value, null); scheduleWriteIfNeededLocked(); return true; } // The settings provider must hold its lock when calling here. public void destroyLocked(Runnable callback) { mHandler.removeMessages(MyHandler.MSG_PERSIST_SETTINGS); if (callback != null) { if (mDirty) { // Do it without a delay. mHandler.obtainMessage(MyHandler.MSG_PERSIST_SETTINGS, callback).sendToTarget(); return; } callback.run(); } } private void updateMemoryUsagePerPackageLocked(String packageName, String oldValue, String newValue) { if (mMaxBytesPerAppPackage == MAX_BYTES_PER_APP_PACKAGE_UNLIMITED) { return; } if (SYSTEM_PACKAGE_NAME.equals(packageName)) { return; } final int oldValueSize = (oldValue != null) ? oldValue.length() : 0; final int newValueSize = (newValue != null) ? newValue.length() : 0; final int deltaSize = newValueSize - oldValueSize; Integer currentSize = mPackageToMemoryUsage.get(packageName); final int newSize = Math.max((currentSize != null) ? currentSize + deltaSize : deltaSize, 0); if (newSize > mMaxBytesPerAppPackage) { throw new IllegalStateException("You are adding too many system settings. " + "You should stop using system settings for app specific data" + " package: " + packageName); } if (DEBUG) { Slog.i(LOG_TAG, "Settings for package: " + packageName + " size: " + newSize + " bytes."); } mPackageToMemoryUsage.put(packageName, newSize); } private boolean hasSettingLocked(String name) { return mSettings.indexOfKey(name) >= 0; } private void scheduleWriteIfNeededLocked() { // If dirty then we have a write already scheduled. if (!mDirty) { mDirty = true; writeStateAsyncLocked(); } } private void writeStateAsyncLocked() { final long currentTimeMillis = SystemClock.uptimeMillis(); if (mWriteScheduled) { mHandler.removeMessages(MyHandler.MSG_PERSIST_SETTINGS); // If enough time passed, write without holding off anymore. final long timeSinceLastNotWrittenMutationMillis = currentTimeMillis - mLastNotWrittenMutationTimeMillis; if (timeSinceLastNotWrittenMutationMillis >= MAX_WRITE_SETTINGS_DELAY_MILLIS) { mHandler.obtainMessage(MyHandler.MSG_PERSIST_SETTINGS).sendToTarget(); return; } // Hold off a bit more as settings are frequently changing. final long maxDelayMillis = Math.max(mLastNotWrittenMutationTimeMillis + MAX_WRITE_SETTINGS_DELAY_MILLIS - currentTimeMillis, 0); final long writeDelayMillis = Math.min(WRITE_SETTINGS_DELAY_MILLIS, maxDelayMillis); Message message = mHandler.obtainMessage(MyHandler.MSG_PERSIST_SETTINGS); mHandler.sendMessageDelayed(message, writeDelayMillis); } else { mLastNotWrittenMutationTimeMillis = currentTimeMillis; Message message = mHandler.obtainMessage(MyHandler.MSG_PERSIST_SETTINGS); mHandler.sendMessageDelayed(message, WRITE_SETTINGS_DELAY_MILLIS); mWriteScheduled = true; } } private void doWriteState() { if (DEBUG_PERSISTENCE) { Slog.i(LOG_TAG, "[PERSIST START]"); } AtomicFile destination = new AtomicFile(mStatePersistFile); final int version; final ArrayMap<String, Setting> settings; synchronized (mLock) { version = mVersion; settings = new ArrayMap<>(mSettings); mDirty = false; mWriteScheduled = false; } FileOutputStream out = null; try { out = destination.startWrite(); XmlSerializer serializer = Xml.newSerializer(); serializer.setOutput(out, StandardCharsets.UTF_8.name()); serializer.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true); serializer.startDocument(null, true); serializer.startTag(null, TAG_SETTINGS); serializer.attribute(null, ATTR_VERSION, String.valueOf(version)); final int settingCount = settings.size(); for (int i = 0; i < settingCount; i++) { Setting setting = settings.valueAt(i); writeSingleSetting(mVersion, serializer, setting.getId(), setting.getName(), setting.getValue(), setting.getPackageName()); if (DEBUG_PERSISTENCE) { Slog.i(LOG_TAG, "[PERSISTED]" + setting.getName() + "=" + setting.getValue()); } } serializer.endTag(null, TAG_SETTINGS); serializer.endDocument(); destination.finishWrite(out); if (DEBUG_PERSISTENCE) { Slog.i(LOG_TAG, "[PERSIST END]"); } // Any error while writing is fatal. } catch (Throwable t) { Slog.wtf(LOG_TAG, "Failed to write settings, restoring backup", t); destination.failWrite(out); throw new IllegalStateException("Failed to write settings, restoring backup", t); } finally { IoUtils.closeQuietly(out); } } static void writeSingleSetting(int version, XmlSerializer serializer, String id, String name, String value, String packageName) throws IOException { if (id == null || isBinary(id) || name == null || isBinary(name) || packageName == null || isBinary(packageName)) { // This shouldn't happen. return; } serializer.startTag(null, TAG_SETTING); serializer.attribute(null, ATTR_ID, id); serializer.attribute(null, ATTR_NAME, name); setValueAttribute(version, serializer, value); serializer.attribute(null, ATTR_PACKAGE, packageName); serializer.endTag(null, TAG_SETTING); } static void setValueAttribute(int version, XmlSerializer serializer, String value) throws IOException { if (version >= SETTINGS_VERSOIN_NEW_ENCODING) { if (value == null) { // Null value -> No ATTR_VALUE nor ATTR_VALUE_BASE64. } else if (isBinary(value)) { serializer.attribute(null, ATTR_VALUE_BASE64, base64Encode(value)); } else { serializer.attribute(null, ATTR_VALUE, value); } } else { // Old encoding. if (value == null) { serializer.attribute(null, ATTR_VALUE, NULL_VALUE_OLD_STYLE); } else { serializer.attribute(null, ATTR_VALUE, value); } } } private String getValueAttribute(XmlPullParser parser) { if (mVersion >= SETTINGS_VERSOIN_NEW_ENCODING) { final String value = parser.getAttributeValue(null, ATTR_VALUE); if (value != null) { return value; } final String base64 = parser.getAttributeValue(null, ATTR_VALUE_BASE64); if (base64 != null) { return base64Decode(base64); } // null has neither ATTR_VALUE nor ATTR_VALUE_BASE64. return null; } else { // Old encoding. final String stored = parser.getAttributeValue(null, ATTR_VALUE); if (NULL_VALUE_OLD_STYLE.equals(stored)) { return null; } else { return stored; } } } private void readStateSyncLocked() { FileInputStream in; if (!mStatePersistFile.exists()) { return; } try { in = new AtomicFile(mStatePersistFile).openRead(); } catch (FileNotFoundException fnfe) { Slog.i(LOG_TAG, "No settings state"); return; } try { XmlPullParser parser = Xml.newPullParser(); parser.setInput(in, StandardCharsets.UTF_8.name()); parseStateLocked(parser); } catch (XmlPullParserException | IOException e) { throw new IllegalStateException("Failed parsing settings file: " + mStatePersistFile , e); } finally { IoUtils.closeQuietly(in); } } private void parseStateLocked(XmlPullParser parser) throws IOException, XmlPullParserException { final int outerDepth = parser.getDepth(); int type; while ((type = parser.next()) != XmlPullParser.END_DOCUMENT && (type != XmlPullParser.END_TAG || parser.getDepth() > outerDepth)) { if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) { continue; } String tagName = parser.getName(); if (tagName.equals(TAG_SETTINGS)) { parseSettingsLocked(parser); } } } private void parseSettingsLocked(XmlPullParser parser) throws IOException, XmlPullParserException { mVersion = Integer.parseInt(parser.getAttributeValue(null, ATTR_VERSION)); final int outerDepth = parser.getDepth(); int type; while ((type = parser.next()) != XmlPullParser.END_DOCUMENT && (type != XmlPullParser.END_TAG || parser.getDepth() > outerDepth)) { if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) { continue; } String tagName = parser.getName(); if (tagName.equals(TAG_SETTING)) { String id = parser.getAttributeValue(null, ATTR_ID); String name = parser.getAttributeValue(null, ATTR_NAME); String value = getValueAttribute(parser); String packageName = parser.getAttributeValue(null, ATTR_PACKAGE); mSettings.put(name, new Setting(name, value, packageName, id)); if (DEBUG_PERSISTENCE) { Slog.i(LOG_TAG, "[RESTORED] " + name + "=" + value); } } } } private final class MyHandler extends Handler { public static final int MSG_PERSIST_SETTINGS = 1; public MyHandler() { super(BackgroundThread.getHandler().getLooper()); } @Override public void handleMessage(Message message) { switch (message.what) { case MSG_PERSIST_SETTINGS: { Runnable callback = (Runnable) message.obj; doWriteState(); if (callback != null) { callback.run(); } } break; } } } public final class Setting { private String name; private String value; private String packageName; private String id; public Setting(String name, String value, String packageName) { init(name, value, packageName, String.valueOf(mNextId++)); } public Setting(String name, String value, String packageName, String id) { mNextId = Math.max(mNextId, Long.valueOf(id) + 1); init(name, value, packageName, id); } private void init(String name, String value, String packageName, String id) { this.name = name; this.value = value; this.packageName = packageName; this.id = id; } public String getName() { return name; } public String getValue() { return value; } public String getPackageName() { return packageName; } public String getId() { return id; } public boolean update(String value, String packageName) { if (Objects.equal(value, this.value)) { return false; } this.value = value; this.packageName = packageName; this.id = String.valueOf(mNextId++); return true; } } /** * @return TRUE if a string is considered "binary" from KXML's point of view. NOTE DO NOT * pass null. */ public static boolean isBinary(String s) { if (s == null) { throw new NullPointerException(); } // See KXmlSerializer.writeEscaped for (int i = 0; i < s.length(); i++) { char c = s.charAt(i); boolean allowedInXml = (c >= 0x20 && c <= 0xd7ff) || (c >= 0xe000 && c <= 0xfffd); if (!allowedInXml) { return true; } } return false; } private static String base64Encode(String s) { return Base64.encodeToString(toBytes(s), Base64.NO_WRAP); } private static String base64Decode(String s) { return fromBytes(Base64.decode(s, Base64.DEFAULT)); } // Note the followings are basically just UTF-16 encode/decode. But we want to preserve // contents as-is, even if it contains broken surrogate pairs, we do it by ourselves, // since I don't know how Charset would treat them. private static byte[] toBytes(String s) { final byte[] result = new byte[s.length() * 2]; int resultIndex = 0; for (int i = 0; i < s.length(); ++i) { char ch = s.charAt(i); result[resultIndex++] = (byte) (ch >> 8); result[resultIndex++] = (byte) ch; } return result; } private static String fromBytes(byte[] bytes) { final StringBuffer sb = new StringBuffer(bytes.length / 2); final int last = bytes.length - 1; for (int i = 0; i < last; i += 2) { final char ch = (char) ((bytes[i] & 0xff) << 8 | (bytes[i + 1] & 0xff)); sb.append(ch); } return sb.toString(); } }