src/com/android/providers/calendar/CalendarCache.java

/*
 * Copyright (C) 2010 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.calendar;

import android.content.ContentValues;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import android.util.Log;
import com.google.common.annotations.VisibleForTesting;

import java.util.TimeZone;

/**
 * Class for managing a persistent Cache of (key, value) pairs. The persistent storage used is
 * a SQLite database.
 */
public class CalendarCache {
    private static final String TAG = "CalendarCache";

    public static final String DATABASE_NAME = "CalendarCache";

    public static final String KEY_TIMEZONE_DATABASE_VERSION = "timezoneDatabaseVersion";
    public static final String DEFAULT_TIMEZONE_DATABASE_VERSION = "2009s";

    public static final String KEY_TIMEZONE_TYPE = "timezoneType";
    public static final String TIMEZONE_TYPE_AUTO = "auto";
    public static final String TIMEZONE_TYPE_HOME = "home";

    public static final String KEY_TIMEZONE_INSTANCES = "timezoneInstances";
    public static final String KEY_TIMEZONE_INSTANCES_PREVIOUS = "timezoneInstancesPrevious";

    public static final String COLUMN_NAME_ID = "_id";
    public static final String COLUMN_NAME_KEY = "key";
    public static final String COLUMN_NAME_VALUE = "value";

    private static final String[] sProjection = {
        COLUMN_NAME_KEY,
        COLUMN_NAME_VALUE
    };

    private static final int COLUMN_INDEX_KEY = 0;
    private static final int COLUMN_INDEX_VALUE = 1;

    private final SQLiteOpenHelper mOpenHelper;

    /**
     * This exception is thrown when the cache encounter a null key or a null database reference
     */
    public static class CacheException extends Exception {
        public CacheException() {
        }

        public CacheException(String detailMessage) {
            super(detailMessage);
        }
    }

    public CalendarCache(SQLiteOpenHelper openHelper) {
        mOpenHelper = openHelper;
    }

    public void writeTimezoneDatabaseVersion(String timezoneDatabaseVersion) throws CacheException {
        writeData(KEY_TIMEZONE_DATABASE_VERSION, timezoneDatabaseVersion);
    }

    public String readTimezoneDatabaseVersion() {
        try {
            return readData(KEY_TIMEZONE_DATABASE_VERSION);
        } catch (CacheException e) {
            Log.e(TAG, "Could not read timezone database version from CalendarCache");
        }
        return null;
    }

    @VisibleForTesting
    public void writeTimezoneType(String timezoneType) throws CacheException {
        writeData(KEY_TIMEZONE_TYPE, timezoneType);
    }

    public String readTimezoneType() {
        try {
            return readData(KEY_TIMEZONE_TYPE);
        } catch (CacheException e) {
            Log.e(TAG, "Cannot read timezone type from CalendarCache - using AUTO as default", e);
        }
        return TIMEZONE_TYPE_AUTO;
    }

    public void writeTimezoneInstances(String timezone) {
        try {
            writeData(KEY_TIMEZONE_INSTANCES, timezone);
        } catch (CacheException e) {
            Log.e(TAG, "Cannot write instances timezone to CalendarCache");
        }
    }

    public String readTimezoneInstances() {
        try {
            return readData(KEY_TIMEZONE_INSTANCES);
        } catch (CacheException e) {
            String localTimezone = TimeZone.getDefault().getID();
            Log.e(TAG, "Cannot read instances timezone from CalendarCache - using device one: " +
                    localTimezone, e);
            return localTimezone;
        }
    }

    public void writeTimezoneInstancesPrevious(String timezone) {
        try {
            writeData(KEY_TIMEZONE_INSTANCES_PREVIOUS, timezone);
        } catch (CacheException e) {
            Log.e(TAG, "Cannot write previous instance timezone to CalendarCache");
        }
    }

    public String readTimezoneInstancesPrevious() {
        try {
            return readData(KEY_TIMEZONE_INSTANCES_PREVIOUS);
        } catch (CacheException e) {
            Log.e(TAG, "Cannot read previous instances timezone from CalendarCache", e);
        }
        return null;
    }

    /**
     * Write a (key, value) pair in the Cache.
     *
     * @param key the key (must not be null)
     * @param value the value (can be null)
     * @throws CacheException when key is null
     */
    public void writeData(String key, String value) throws CacheException {
        SQLiteDatabase db = mOpenHelper.getReadableDatabase();
        db.beginTransaction();
        try {
            writeDataLocked(db, key, value);
            db.setTransactionSuccessful();
            if (Log.isLoggable(TAG, Log.VERBOSE)) {
                Log.i(TAG, "Wrote (key, value) = [ " + key + ", " + value + "] ");
            }
        } finally {
            db.endTransaction();
        }
    }

    /**
     * Write a (key, value) pair in the database used by the cache. This method should be called in
     * a transaction.
     *
     * @param db the database (must not be null)
     * @param key the key (must not be null)
     * @param value the value
     * @throws CacheException when key or database are null
     */
    protected void writeDataLocked(SQLiteDatabase db, String key, String value)
            throws CacheException {
        if (null == db) {
            throw new CacheException("Database cannot be null");
        }
        if (null == key) {
            throw new CacheException("Cannot use null key for write");
        }

        /*
         * Storing the hash code of a String into the _id column carries a (very) small risk
         * of weird behavior, because we're using it as a unique key, but hash codes aren't
         * guaranteed to be unique.  CalendarCache has a small set of keys that are known
         * ahead of time, so we should be okay.
         */
        ContentValues values = new ContentValues();
        values.put(COLUMN_NAME_ID, key.hashCode());
        values.put(COLUMN_NAME_KEY, key);
        values.put(COLUMN_NAME_VALUE, value);

        db.replace(DATABASE_NAME, null /* null column hack */, values);
    }

    /**
     * Read a value from the database used by the cache and depending on a key.
     *
     * @param key the key from which we want the value (must not be null)
     * @return the value that was found for the key. Can be null if no key has been found
     * @throws CacheException when key is null
     */
    public String readData(String key) throws CacheException {
        SQLiteDatabase db = mOpenHelper.getReadableDatabase();
        return readDataLocked(db, key);
    }

    /**
     * Read a value from the database used by the cache and depending on a key. The database should
     * be "readable" at minimum
     *
     * @param db the database (must not be null)
     * @param key the key from which we want the value (must not be null)
     * @return the value that was found for the key. Can be null if no value has been found for the
     * key.
     * @throws CacheException when key or database are null
     */
    protected String readDataLocked(SQLiteDatabase db, String key) throws CacheException {
        if (null == db) {
            throw new CacheException("Database cannot be null");
        }
        if (null == key) {
            throw new CacheException("Cannot use null key for read");
        }

        String rowValue = null;

        Cursor cursor = db.query(DATABASE_NAME, sProjection,
                COLUMN_NAME_KEY + "=?", new String[] { key }, null, null, null);
        try {
            if (cursor.moveToNext()) {
                rowValue = cursor.getString(COLUMN_INDEX_VALUE);
            }
            else {
                if (Log.isLoggable(TAG, Log.VERBOSE)) {
                    Log.i(TAG, "Could not find key = [ " + key + " ]");
                }
            }
        } finally {
            cursor.close();
            cursor = null;
        }
        return rowValue;
    }
}