Merge "Negatively cache settings and proactively slurp settings into cache." into gingerbread

import java.security.SecureRandom;

import java.util.LinkedHashMap;

import java.util.Map;

import java.util.concurrent.atomic.AtomicBoolean;

import java.util.concurrent.atomic.AtomicInteger;

import android.app.backup.BackupManager;

import android.content.ContentProvider;

import android.media.RingtoneManager;

import android.net.Uri;

import android.os.Bundle;

import android.os.FileObserver;

import android.os.ParcelFileDescriptor;

import android.os.SystemProperties;

import android.provider.DrmStore;

    // Cache for settings, access-ordered for acting as LRU.

    // Guarded by themselves.

    private static final int MAX_CACHE_ENTRIES = 50;

    private static final SettingsCache sSystemCache = new SettingsCache();

    private static final SettingsCache sSecureCache = new SettingsCache();

    private static final int MAX_CACHE_ENTRIES = 200;

    private static final SettingsCache sSystemCache = new SettingsCache("system");

    private static final SettingsCache sSecureCache = new SettingsCache("secure");

    // The count of how many known (handled by SettingsProvider)

    // database mutations are currently being handled.  Used by

    // sFileObserver to not reload the database when it's ourselves

    // modifying it.

    private static final AtomicInteger sKnownMutationsInFlight = new AtomicInteger(0);

    // Over this size we don't reject loading or saving settings but

    // we do consider them broken/malicious and don't keep them in

    private static final Bundle NULL_SETTING = Bundle.forPair("value", null);

    // Used as a sentinel value in an instance equality test when we

    // want to cache the existence of a key, but not store its value.

    private static final Bundle TOO_LARGE_TO_CACHE_MARKER = Bundle.forPair("_dummy", null);

    protected DatabaseHelper mOpenHelper;

    private BackupManager mBackupManager;

        }

    }

    // FileObserver for external modifications to the database file.

    // Note that this is for platform developers only with

    // userdebug/eng builds who should be able to tinker with the

    // sqlite database out from under the SettingsProvider, which is

    // normally the exclusive owner of the database.  But we keep this

    // enabled all the time to minimize development-vs-user

    // differences in testing.

    private static SettingsFileObserver sObserverInstance;

    private class SettingsFileObserver extends FileObserver {

        private final AtomicBoolean mIsDirty = new AtomicBoolean(false);

        private final String mPath;

        public SettingsFileObserver(String path) {

            super(path, FileObserver.CLOSE_WRITE |

                  FileObserver.CREATE | FileObserver.DELETE |

                  FileObserver.MOVED_TO | FileObserver.MODIFY);

            mPath = path;

        }

        public void onEvent(int event, String path) {

            int modsInFlight = sKnownMutationsInFlight.get();

            if (modsInFlight > 0) {

                // our own modification.

                return;

            }

            Log.d(TAG, "external modification to " + mPath + "; event=" + event);

            if (!mIsDirty.compareAndSet(false, true)) {

                // already handled. (we get a few update events

                // during an sqlite write)

                return;

            }

            Log.d(TAG, "updating our caches for " + mPath);

            fullyPopulateCaches();

            mIsDirty.set(false);

        }

    }

    @Override

    public boolean onCreate() {

        mOpenHelper = new DatabaseHelper(getContext());

            return false;

        }

        // Watch for external modifications to the database file,

        // keeping our cache in sync.

        // It's kinda lame to call mOpenHelper.getReadableDatabase()

        // during onCreate(), but since ensureAndroidIdIsSet has

        // already done it above and initialized/upgraded the

        // database, might as well just use it...

        SQLiteDatabase db = mOpenHelper.getReadableDatabase();

        sObserverInstance = new SettingsFileObserver(db.getPath());

        sObserverInstance.startWatching();

        startAsyncCachePopulation();

        return true;

    }

    private void startAsyncCachePopulation() {

        new Thread("populate-settings-caches") {

            public void run() {

                fullyPopulateCaches();

            }

        }.start();

    }

    private void fullyPopulateCaches() {

        fullyPopulateCache("secure", sSecureCache);

        fullyPopulateCache("system", sSystemCache);

    }

    // Slurp all values (if sane in number & size) into cache.

    private void fullyPopulateCache(String table, SettingsCache cache) {

        SQLiteDatabase db = mOpenHelper.getReadableDatabase();

        Cursor c = db.query(

            table,

            new String[] { Settings.NameValueTable.NAME, Settings.NameValueTable.VALUE },

            null, null, null, null, null,

            "" + (MAX_CACHE_ENTRIES + 1) /* limit */);

        try {

            synchronized (cache) {

                cache.clear();

                cache.setFullyMatchesDisk(true);  // optimistic

                int rows = 0;

                while (c.moveToNext()) {

                    rows++;

                    String name = c.getString(0);

                    String value = c.getString(1);

                    cache.populate(name, value);

                }

                if (rows > MAX_CACHE_ENTRIES) {

                    // Somewhat redundant, as removeEldestEntry() will

                    // have already done this, but to be explicit:

                    cache.setFullyMatchesDisk(false);

                    Log.d(TAG, "row count exceeds max cache entries for table " + table);

                }

                Log.d(TAG, "cache for settings table '" + table + "' fullycached=" +

                      cache.fullyMatchesDisk());

            }

        } finally {

            c.close();

        }

    }

    private boolean ensureAndroidIdIsSet() {

        final Cursor c = query(Settings.Secure.CONTENT_URI,

                new String[] { Settings.NameValueTable.VALUE },

    private Bundle lookupValue(String table, SettingsCache cache, String key) {

        synchronized (cache) {

            if (cache.containsKey(key)) {

                return cache.get(key);

                Bundle value = cache.get(key);

                if (value != TOO_LARGE_TO_CACHE_MARKER) {

                    return value;

                }

                // else we fall through and read the value from disk

            } else if (cache.fullyMatchesDisk()) {

                // Fast path (very common).  Don't even try touch disk

                // if we know we've slurped it all in.  Trying to

                // touch the disk would mean waiting for yaffs2 to

                // give us access, which could takes hundreds of

                // milliseconds.  And we're very likely being called

                // from somebody's UI thread...

                return NULL_SETTING;

            }

        }

        checkWritePermissions(args);

        SettingsCache cache = SettingsCache.forTable(args.table);

        sKnownMutationsInFlight.incrementAndGet();

        SQLiteDatabase db = mOpenHelper.getWritableDatabase();

        db.beginTransaction();

        try {

            db.setTransactionSuccessful();

        } finally {

            db.endTransaction();

            sKnownMutationsInFlight.decrementAndGet();

        }

        sendNotify(uri);

            return Uri.withAppendedPath(url, name);

        }

        sKnownMutationsInFlight.incrementAndGet();

        SQLiteDatabase db = mOpenHelper.getWritableDatabase();

        final long rowId = db.insert(args.table, null, initialValues);

        sKnownMutationsInFlight.decrementAndGet();

        if (rowId <= 0) return null;

        SettingsCache.populate(cache, initialValues);  // before we notify

        }

        checkWritePermissions(args);

        sKnownMutationsInFlight.incrementAndGet();

        SQLiteDatabase db = mOpenHelper.getWritableDatabase();

        int count = db.delete(args.table, args.where, args.args);

        sKnownMutationsInFlight.decrementAndGet();

        if (count > 0) {

            SettingsCache.wipe(args.table);  // before we notify

            sendNotify(url);

        }

        startAsyncCachePopulation();

        if (LOCAL_LOGV) Log.v(TAG, args.table + ": " + count + " row(s) deleted");

        return count;

    }

        }

        checkWritePermissions(args);

        sKnownMutationsInFlight.incrementAndGet();

        SQLiteDatabase db = mOpenHelper.getWritableDatabase();

        sKnownMutationsInFlight.decrementAndGet();

        int count = db.update(args.table, initialValues, args.where, args.args);

        if (count > 0) {

            SettingsCache.wipe(args.table);  // before we notify

            sendNotify(url);

        }

        startAsyncCachePopulation();

        if (LOCAL_LOGV) Log.v(TAG, args.table + ": " + count + " row(s) <- " + initialValues);

        return count;

    }

     */

    private static final class SettingsCache extends LinkedHashMap<String, Bundle> {

        public SettingsCache() {

        private final String mCacheName;

        private boolean mCacheFullyMatchesDisk = false;  // has the whole database slurped.

        public SettingsCache(String name) {

            super(MAX_CACHE_ENTRIES, 0.75f /* load factor */, true /* access ordered */);

            mCacheName = name;

        }

        /**

         * Is the whole database table slurped into this cache?

         */

        public boolean fullyMatchesDisk() {

            synchronized (this) {

                return mCacheFullyMatchesDisk;

            }

        }

        public void setFullyMatchesDisk(boolean value) {

            synchronized (this) {

                mCacheFullyMatchesDisk = value;

            }

        }

        @Override

        protected boolean removeEldestEntry(Map.Entry eldest) {

            return size() > MAX_CACHE_ENTRIES;

            if (size() <= MAX_CACHE_ENTRIES) {

                return false;

            }

            synchronized (this) {

                mCacheFullyMatchesDisk = false;

            }

            return true;

        }

        /**

                return;

            }

            String value = contentValues.getAsString(Settings.NameValueTable.VALUE);

            synchronized (cache) {

            cache.populate(name, value);

        }

        public void populate(String name, String value) {

            synchronized (this) {

                if (value == null || value.length() <= MAX_CACHE_ENTRY_SIZE) {

                    cache.put(name, Bundle.forPair(Settings.NameValueTable.VALUE, value));

                    put(name, Bundle.forPair(Settings.NameValueTable.VALUE, value));

                } else {

                    cache.remove(name);

                    put(name, TOO_LARGE_TO_CACHE_MARKER);

                }

            }

        }

            }

            synchronized (cache) {

                cache.clear();

                cache.mCacheFullyMatchesDisk = true;

            }

        }