src/com/android/photos/data/MediaCacheDatabase.java - platform/packages/apps/Gallery2 - Git at Google

 /*
  * Copyright (C) 2013 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.photos.data;

 import android.content.ContentValues;
 import android.content.Context;
 import android.database.Cursor;
 import android.database.sqlite.SQLiteDatabase;
 import android.database.sqlite.SQLiteOpenHelper;
 import android.net.Uri;
 import android.provider.BaseColumns;

 import com.android.photos.data.MediaRetriever.MediaSize;

 import java.io.File;

 class MediaCacheDatabase extends SQLiteOpenHelper {
     public static final int DB_VERSION = 1;
     public static final String DB_NAME = "mediacache.db";

     /** Internal database table used for the media cache */
     public static final String TABLE = "media_cache";

     private static interface Columns extends BaseColumns {
         /** The Content URI of the original image. */
         public static final String URI = "uri";
         /** MediaSize.getValue() values. */
         public static final String MEDIA_SIZE = "media_size";
         /** The last time this image was queried. */
         public static final String LAST_ACCESS = "last_access";
         /** The image size in bytes. */
         public static final String SIZE_IN_BYTES = "size";
     }

     static interface Action {
         void execute(Uri uri, long id, MediaSize size, Object parameter);
     }

     private static final String[] PROJECTION_ID = {
         Columns._ID,
     };

     private static final String[] PROJECTION_CACHED = {
         Columns._ID, Columns.MEDIA_SIZE, Columns.SIZE_IN_BYTES,
     };

     private static final String[] PROJECTION_CACHE_SIZE = {
         "SUM(" + Columns.SIZE_IN_BYTES + ")"
     };

     private static final String[] PROJECTION_DELETE_OLD = {
         Columns._ID, Columns.URI, Columns.MEDIA_SIZE, Columns.SIZE_IN_BYTES, Columns.LAST_ACCESS,
     };

     public static final String CREATE_TABLE = "CREATE TABLE " + TABLE + "("
             + Columns._ID + " INTEGER PRIMARY KEY AUTOINCREMENT, "
             + Columns.URI + " TEXT NOT NULL,"
             + Columns.MEDIA_SIZE + " INTEGER NOT NULL,"
             + Columns.LAST_ACCESS + " INTEGER NOT NULL,"
             + Columns.SIZE_IN_BYTES + " INTEGER NOT NULL,"
             + "UNIQUE(" + Columns.URI + ", " + Columns.MEDIA_SIZE + "))";

     public static final String DROP_TABLE = "DROP TABLE IF EXISTS " + TABLE;

     public static final String WHERE_THUMBNAIL = Columns.MEDIA_SIZE + " = "
             + MediaSize.Thumbnail.getValue();

     public static final String WHERE_NOT_THUMBNAIL = Columns.MEDIA_SIZE + " <> "
             + MediaSize.Thumbnail.getValue();

     public static final String WHERE_CLEAR_CACHE = Columns.LAST_ACCESS + " <= ?";

     public static final String WHERE_CLEAR_CACHE_LARGE = WHERE_CLEAR_CACHE + " AND "
             + WHERE_NOT_THUMBNAIL;

     static class QueryCacheResults {
         public QueryCacheResults(long id, int sizeVal) {
             this.id = id;
             this.size = MediaSize.fromInteger(sizeVal);
         }
         public long id;
         public MediaSize size;
     }

     public MediaCacheDatabase(Context context) {
         super(context, DB_NAME, null, DB_VERSION);
     }

     @Override
     public void onCreate(SQLiteDatabase db) {
         db.execSQL(CREATE_TABLE);
     }

     @Override
     public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
         db.execSQL(DROP_TABLE);
         onCreate(db);
         MediaCache.getInstance().clearCacheDir();
     }

     public Long getCached(Uri uri, MediaSize size) {
         String where = Columns.URI + " = ? AND " + Columns.MEDIA_SIZE + " = ?";
         SQLiteDatabase db = getWritableDatabase();
         String[] whereArgs = {
                 uri.toString(), String.valueOf(size.getValue()),
         };
         Cursor cursor = db.query(TABLE, PROJECTION_ID, where, whereArgs, null, null, null);
         Long id = null;
         if (cursor.moveToNext()) {
             id = cursor.getLong(0);
         }
         cursor.close();
         if (id != null) {
             String[] updateArgs = {
                 id.toString()
             };
             ContentValues values = new ContentValues();
             values.put(Columns.LAST_ACCESS, System.currentTimeMillis());
             db.beginTransaction();
             try {
                 db.update(TABLE, values, Columns._ID + " = ?", updateArgs);
                 db.setTransactionSuccessful();
             } finally {
                 db.endTransaction();
             }
         }
         return id;
     }

     public MediaSize executeOnBestCached(Uri uri, MediaSize size, Action action) {
         String where = Columns.URI + " = ? AND " + Columns.MEDIA_SIZE + " < ?";
         String orderBy = Columns.MEDIA_SIZE + " DESC";
         SQLiteDatabase db = getReadableDatabase();
         String[] whereArgs = {
                 uri.toString(), String.valueOf(size.getValue()),
         };
         Cursor cursor = db.query(TABLE, PROJECTION_CACHED, where, whereArgs, null, null, orderBy);
         MediaSize bestSize = null;
         if (cursor.moveToNext()) {
             long id = cursor.getLong(0);
             bestSize = MediaSize.fromInteger(cursor.getInt(1));
             long fileSize = cursor.getLong(2);
             action.execute(uri, id, bestSize, fileSize);
         }
         cursor.close();
         return bestSize;
     }

     public long insert(Uri uri, MediaSize size, Action action, File tempFile) {
         SQLiteDatabase db = getWritableDatabase();
         db.beginTransaction();
         try {
             ContentValues values = new ContentValues();
             values.put(Columns.LAST_ACCESS, System.currentTimeMillis());
             values.put(Columns.MEDIA_SIZE, size.getValue());
             values.put(Columns.URI, uri.toString());
             values.put(Columns.SIZE_IN_BYTES, tempFile.length());
             long id = db.insert(TABLE, null, values);
             if (id != -1) {
                 action.execute(uri, id, size, tempFile);
                 db.setTransactionSuccessful();
             }
             return id;
         } finally {
             db.endTransaction();
         }
     }

     public void updateLength(long id, long fileSize) {
         ContentValues values = new ContentValues();
         values.put(Columns.SIZE_IN_BYTES, fileSize);
         String[] whereArgs = {
             String.valueOf(id)
         };
         SQLiteDatabase db = getWritableDatabase();
         db.beginTransaction();
         try {
             db.update(TABLE, values, Columns._ID + " = ?", whereArgs);
             db.setTransactionSuccessful();
         } finally {
             db.endTransaction();
         }
     }

     public void delete(Uri uri, MediaSize size, Action action) {
         String where = Columns.URI + " = ? AND " + Columns.MEDIA_SIZE + " = ?";
         String[] whereArgs = {
                 uri.toString(), String.valueOf(size.getValue()),
         };
         deleteRows(uri, where, whereArgs, action);
     }

     public void delete(Uri uri, Action action) {
         String where = Columns.URI + " = ?";
         String[] whereArgs = {
             uri.toString()
         };
         deleteRows(uri, where, whereArgs, action);
     }

     private void deleteRows(Uri uri, String where, String[] whereArgs, Action action) {
         SQLiteDatabase db = getWritableDatabase();
         // Make this an atomic operation
         db.beginTransaction();
         Cursor cursor = db.query(TABLE, PROJECTION_CACHED, where, whereArgs, null, null, null);
         while (cursor.moveToNext()) {
             long id = cursor.getLong(0);
             MediaSize size = MediaSize.fromInteger(cursor.getInt(1));
             long length = cursor.getLong(2);
             action.execute(uri, id, size, length);
         }
         cursor.close();
         try {
             db.delete(TABLE, where, whereArgs);
             db.setTransactionSuccessful();
         } finally {
             db.endTransaction();
         }
     }

     public void deleteOldCached(boolean includeThumbnails, long deleteSize, Action action) {
         String where = includeThumbnails ? null : WHERE_NOT_THUMBNAIL;
         long lastAccess = 0;
         SQLiteDatabase db = getWritableDatabase();
         db.beginTransaction();
         try {
             Cursor cursor = db.query(TABLE, PROJECTION_DELETE_OLD, where, null, null, null,
                     Columns.LAST_ACCESS);
             while (cursor.moveToNext()) {
                 long id = cursor.getLong(0);
                 String uri = cursor.getString(1);
                 MediaSize size = MediaSize.fromInteger(cursor.getInt(2));
                 long length = cursor.getLong(3);
                 long imageLastAccess = cursor.getLong(4);

                 if (imageLastAccess != lastAccess && deleteSize < 0) {
                     break; // We've deleted enough.
                 }
                 lastAccess = imageLastAccess;
                 action.execute(Uri.parse(uri), id, size, length);
                 deleteSize -= length;
             }
             cursor.close();
             String[] whereArgs = {
                 String.valueOf(lastAccess),
             };
             String whereDelete = includeThumbnails ? WHERE_CLEAR_CACHE : WHERE_CLEAR_CACHE_LARGE;
             db.delete(TABLE, whereDelete, whereArgs);
             db.setTransactionSuccessful();
         } finally {
             db.endTransaction();
         }
     }

     public long getCacheSize() {
         return getCacheSize(null);
     }

     public long getThumbnailCacheSize() {
         return getCacheSize(WHERE_THUMBNAIL);
     }

     private long getCacheSize(String where) {
         SQLiteDatabase db = getReadableDatabase();
         Cursor cursor = db.query(TABLE, PROJECTION_CACHE_SIZE, where, null, null, null, null);
         long size = -1;
         if (cursor.moveToNext()) {
             size = cursor.getLong(0);
         }
         cursor.close();
         return size;
     }
 }
	/*
	* Copyright (C) 2013 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.photos.data;

	import android.content.ContentValues;
	import android.content.Context;
	import android.database.Cursor;
	import android.database.sqlite.SQLiteDatabase;
	import android.database.sqlite.SQLiteOpenHelper;
	import android.net.Uri;
	import android.provider.BaseColumns;

	import com.android.photos.data.MediaRetriever.MediaSize;

	import java.io.File;

	class MediaCacheDatabase extends SQLiteOpenHelper {
	public static final int DB_VERSION = 1;
	public static final String DB_NAME = "mediacache.db";

	/** Internal database table used for the media cache */
	public static final String TABLE = "media_cache";

	private static interface Columns extends BaseColumns {
	/** The Content URI of the original image. */
	public static final String URI = "uri";
	/** MediaSize.getValue() values. */
	public static final String MEDIA_SIZE = "media_size";
	/** The last time this image was queried. */
	public static final String LAST_ACCESS = "last_access";
	/** The image size in bytes. */
	public static final String SIZE_IN_BYTES = "size";
	}

	static interface Action {
	void execute(Uri uri, long id, MediaSize size, Object parameter);
	}

	private static final String[] PROJECTION_ID = {
	Columns._ID,
	};

	private static final String[] PROJECTION_CACHED = {
	Columns._ID, Columns.MEDIA_SIZE, Columns.SIZE_IN_BYTES,
	};

	private static final String[] PROJECTION_CACHE_SIZE = {
	"SUM(" + Columns.SIZE_IN_BYTES + ")"
	};

	private static final String[] PROJECTION_DELETE_OLD = {
	Columns._ID, Columns.URI, Columns.MEDIA_SIZE, Columns.SIZE_IN_BYTES, Columns.LAST_ACCESS,
	};

	public static final String CREATE_TABLE = "CREATE TABLE " + TABLE + "("
	+ Columns._ID + " INTEGER PRIMARY KEY AUTOINCREMENT, "
	+ Columns.URI + " TEXT NOT NULL,"
	+ Columns.MEDIA_SIZE + " INTEGER NOT NULL,"
	+ Columns.LAST_ACCESS + " INTEGER NOT NULL,"
	+ Columns.SIZE_IN_BYTES + " INTEGER NOT NULL,"
	+ "UNIQUE(" + Columns.URI + ", " + Columns.MEDIA_SIZE + "))";

	public static final String DROP_TABLE = "DROP TABLE IF EXISTS " + TABLE;

	public static final String WHERE_THUMBNAIL = Columns.MEDIA_SIZE + " = "
	+ MediaSize.Thumbnail.getValue();

	public static final String WHERE_NOT_THUMBNAIL = Columns.MEDIA_SIZE + " <> "
	+ MediaSize.Thumbnail.getValue();

	public static final String WHERE_CLEAR_CACHE = Columns.LAST_ACCESS + " <= ?";

	public static final String WHERE_CLEAR_CACHE_LARGE = WHERE_CLEAR_CACHE + " AND "
	+ WHERE_NOT_THUMBNAIL;

	static class QueryCacheResults {
	public QueryCacheResults(long id, int sizeVal) {
	this.id = id;
	this.size = MediaSize.fromInteger(sizeVal);
	}
	public long id;
	public MediaSize size;
	}

	public MediaCacheDatabase(Context context) {
	super(context, DB_NAME, null, DB_VERSION);
	}

	@Override
	public void onCreate(SQLiteDatabase db) {
	db.execSQL(CREATE_TABLE);
	}

	@Override
	public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
	db.execSQL(DROP_TABLE);
	onCreate(db);
	MediaCache.getInstance().clearCacheDir();
	}

	public Long getCached(Uri uri, MediaSize size) {
	String where = Columns.URI + " = ? AND " + Columns.MEDIA_SIZE + " = ?";
	SQLiteDatabase db = getWritableDatabase();
	String[] whereArgs = {
	uri.toString(), String.valueOf(size.getValue()),
	};
	Cursor cursor = db.query(TABLE, PROJECTION_ID, where, whereArgs, null, null, null);
	Long id = null;
	if (cursor.moveToNext()) {
	id = cursor.getLong(0);
	}
	cursor.close();
	if (id != null) {
	String[] updateArgs = {
	id.toString()
	};
	ContentValues values = new ContentValues();
	values.put(Columns.LAST_ACCESS, System.currentTimeMillis());
	db.beginTransaction();
	try {
	db.update(TABLE, values, Columns._ID + " = ?", updateArgs);
	db.setTransactionSuccessful();
	} finally {
	db.endTransaction();
	}
	}
	return id;
	}

	public MediaSize executeOnBestCached(Uri uri, MediaSize size, Action action) {
	String where = Columns.URI + " = ? AND " + Columns.MEDIA_SIZE + " < ?";
	String orderBy = Columns.MEDIA_SIZE + " DESC";
	SQLiteDatabase db = getReadableDatabase();
	String[] whereArgs = {
	uri.toString(), String.valueOf(size.getValue()),
	};
	Cursor cursor = db.query(TABLE, PROJECTION_CACHED, where, whereArgs, null, null, orderBy);
	MediaSize bestSize = null;
	if (cursor.moveToNext()) {
	long id = cursor.getLong(0);
	bestSize = MediaSize.fromInteger(cursor.getInt(1));
	long fileSize = cursor.getLong(2);
	action.execute(uri, id, bestSize, fileSize);
	}
	cursor.close();
	return bestSize;
	}

	public long insert(Uri uri, MediaSize size, Action action, File tempFile) {
	SQLiteDatabase db = getWritableDatabase();
	db.beginTransaction();
	try {
	ContentValues values = new ContentValues();
	values.put(Columns.LAST_ACCESS, System.currentTimeMillis());
	values.put(Columns.MEDIA_SIZE, size.getValue());
	values.put(Columns.URI, uri.toString());
	values.put(Columns.SIZE_IN_BYTES, tempFile.length());
	long id = db.insert(TABLE, null, values);
	if (id != -1) {
	action.execute(uri, id, size, tempFile);
	db.setTransactionSuccessful();
	}
	return id;
	} finally {
	db.endTransaction();
	}
	}

	public void updateLength(long id, long fileSize) {
	ContentValues values = new ContentValues();
	values.put(Columns.SIZE_IN_BYTES, fileSize);
	String[] whereArgs = {
	String.valueOf(id)
	};
	SQLiteDatabase db = getWritableDatabase();
	db.beginTransaction();
	try {
	db.update(TABLE, values, Columns._ID + " = ?", whereArgs);
	db.setTransactionSuccessful();
	} finally {
	db.endTransaction();
	}
	}

	public void delete(Uri uri, MediaSize size, Action action) {
	String where = Columns.URI + " = ? AND " + Columns.MEDIA_SIZE + " = ?";
	String[] whereArgs = {
	uri.toString(), String.valueOf(size.getValue()),
	};
	deleteRows(uri, where, whereArgs, action);
	}

	public void delete(Uri uri, Action action) {
	String where = Columns.URI + " = ?";
	String[] whereArgs = {
	uri.toString()
	};
	deleteRows(uri, where, whereArgs, action);
	}

	private void deleteRows(Uri uri, String where, String[] whereArgs, Action action) {
	SQLiteDatabase db = getWritableDatabase();
	// Make this an atomic operation
	db.beginTransaction();
	Cursor cursor = db.query(TABLE, PROJECTION_CACHED, where, whereArgs, null, null, null);
	while (cursor.moveToNext()) {
	long id = cursor.getLong(0);
	MediaSize size = MediaSize.fromInteger(cursor.getInt(1));
	long length = cursor.getLong(2);
	action.execute(uri, id, size, length);
	}
	cursor.close();
	try {
	db.delete(TABLE, where, whereArgs);
	db.setTransactionSuccessful();
	} finally {
	db.endTransaction();
	}
	}

	public void deleteOldCached(boolean includeThumbnails, long deleteSize, Action action) {
	String where = includeThumbnails ? null : WHERE_NOT_THUMBNAIL;
	long lastAccess = 0;
	SQLiteDatabase db = getWritableDatabase();
	db.beginTransaction();
	try {
	Cursor cursor = db.query(TABLE, PROJECTION_DELETE_OLD, where, null, null, null,
	Columns.LAST_ACCESS);
	while (cursor.moveToNext()) {
	long id = cursor.getLong(0);
	String uri = cursor.getString(1);
	MediaSize size = MediaSize.fromInteger(cursor.getInt(2));
	long length = cursor.getLong(3);
	long imageLastAccess = cursor.getLong(4);

	if (imageLastAccess != lastAccess && deleteSize < 0) {
	break; // We've deleted enough.
	}
	lastAccess = imageLastAccess;
	action.execute(Uri.parse(uri), id, size, length);
	deleteSize -= length;
	}
	cursor.close();
	String[] whereArgs = {
	String.valueOf(lastAccess),
	};
	String whereDelete = includeThumbnails ? WHERE_CLEAR_CACHE : WHERE_CLEAR_CACHE_LARGE;
	db.delete(TABLE, whereDelete, whereArgs);
	db.setTransactionSuccessful();
	} finally {
	db.endTransaction();
	}
	}

	public long getCacheSize() {
	return getCacheSize(null);
	}

	public long getThumbnailCacheSize() {
	return getCacheSize(WHERE_THUMBNAIL);
	}

	private long getCacheSize(String where) {
	SQLiteDatabase db = getReadableDatabase();
	Cursor cursor = db.query(TABLE, PROJECTION_CACHE_SIZE, where, null, null, null, null);
	long size = -1;
	if (cursor.moveToNext()) {
	size = cursor.getLong(0);
	}
	cursor.close();
	return size;
	}
	}