Move Snapshots to own DB on sdcard

 Bug: 4982126

Change-Id: Ib66b2880d163de4feb4d880e1d01996301bbea08

2 files changed, 262 insertions, 67 deletions

diff --git a/src/com/android/browser/provider/BrowserProvider2.java b/src/com/android/browser/provider/BrowserProvider2.java
index 32fa172..b974c0e 100644
--- a/src/com/android/browser/provider/BrowserProvider2.java
+++ b/src/com/android/browser/provider/BrowserProvider2.java
@@ -68,19 +68,6 @@ import java.util.HashMap;
 
 public class BrowserProvider2 extends SQLiteContentProvider {
 
-    public static interface Snapshots {
-
-        public static final Uri CONTENT_URI = Uri.withAppendedPath(
-                BrowserContract.AUTHORITY_URI, "snapshots");
-        public static final String _ID = "_id";
-        public static final String VIEWSTATE = "view_state";
-        public static final String BACKGROUND = "background";
-        public static final String TITLE = History.TITLE;
-        public static final String URL = History.URL;
-        public static final String FAVICON = History.FAVICON;
-        public static final String THUMBNAIL = History.THUMBNAIL;
-    }
-
     public static final String PARAM_GROUP_BY = "groupBy";
 
     public static final String LEGACY_AUTHORITY = "browser";
@@ -152,9 +139,6 @@ public class BrowserProvider2 extends SQLiteContentProvider {
     static final int LEGACY = 9000;
     static final int LEGACY_ID = 9001;
 
-    static final int SNAPSHOTS = 10000;
-    static final int SNAPSHOTS_ID = 10001;
-
     public static final long FIXED_ID_ROOT = 1;
 
     // Default sort order for unsync'd bookmarks
@@ -216,9 +200,6 @@ public class BrowserProvider2 extends SQLiteContentProvider {
                 "bookmarks/" + SearchManager.SUGGEST_URI_PATH_QUERY,
                 BOOKMARKS_SUGGESTIONS);
 
-        matcher.addURI(authority, "snapshots", SNAPSHOTS);
-        matcher.addURI(authority, "snapshots/#", SNAPSHOTS_ID);
-
         // Projection maps
         HashMap<String, String> map;
 
@@ -352,7 +333,7 @@ public class BrowserProvider2 extends SQLiteContentProvider {
 
     final class DatabaseHelper extends SQLiteOpenHelper {
         static final String DATABASE_NAME = "browser2.db";
-        static final int DATABASE_VERSION = 29;
+        static final int DATABASE_VERSION = 30;
         public DatabaseHelper(Context context) {
             super(context, DATABASE_NAME, null, DATABASE_VERSION);
         }
@@ -423,8 +404,6 @@ public class BrowserProvider2 extends SQLiteContentProvider {
             }
 
             enableSync(db);
-
-            createSnapshots(db);
         }
 
         void enableSync(SQLiteDatabase db) {
@@ -521,8 +500,9 @@ public class BrowserProvider2 extends SQLiteContentProvider {
 
         @Override
         public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
-            if (oldVersion < 29) {
-                createSnapshots(db);
+            if (oldVersion < 30) {
+                db.execSQL("DROP VIEW IF EXISTS " + VIEW_SNAPSHOTS_COMBINED);
+                db.execSQL("DROP TABLE IF EXISTS " + TABLE_SNAPSHOTS);
             }
             if (oldVersion < 28) {
                 enableSync(db);
@@ -544,23 +524,6 @@ public class BrowserProvider2 extends SQLiteContentProvider {
             }
         }
 
-        void createSnapshots(SQLiteDatabase db) {
-            db.execSQL("DROP TABLE IF EXISTS " + TABLE_SNAPSHOTS);
-            db.execSQL("CREATE TABLE " + TABLE_SNAPSHOTS + " (" +
-                    Snapshots._ID + " INTEGER PRIMARY KEY AUTOINCREMENT," +
-                    Snapshots.URL + " TEXT NOT NULL," +
-                    Snapshots.TITLE + " TEXT," +
-                    Snapshots.BACKGROUND + " INTEGER," +
-                    Snapshots.VIEWSTATE + " BLOB NOT NULL" +
-                    ");");
-            db.execSQL("CREATE VIEW IF NOT EXISTS " + VIEW_SNAPSHOTS_COMBINED +
-                    " AS SELECT * FROM " + TABLE_SNAPSHOTS +
-                    " LEFT OUTER JOIN " + TABLE_IMAGES +
-                    " ON " + TABLE_SNAPSHOTS + "." + Snapshots.URL +
-                    " = images.url_key");
-        }
-
-        @Override
         public void onOpen(SQLiteDatabase db) {
             db.enableWriteAheadLogging();
             mSyncHelper.onDatabaseOpened(db);
@@ -1011,17 +974,6 @@ public class BrowserProvider2 extends SQLiteContentProvider {
                 break;
             }
 
-            case SNAPSHOTS_ID: {
-                selection = DatabaseUtils.concatenateWhere(selection, "_id=?");
-                selectionArgs = DatabaseUtils.appendSelectionArgs(selectionArgs,
-                        new String[] { Long.toString(ContentUris.parseId(uri)) });
-                // fall through
-            }
-            case SNAPSHOTS: {
-                qb.setTables(VIEW_SNAPSHOTS_COMBINED);
-                break;
-            }
-
             default: {
                 throw new UnsupportedOperationException("Unknown URL " + uri.toString());
             }
@@ -1221,16 +1173,6 @@ public class BrowserProvider2 extends SQLiteContentProvider {
                 }
                 break;
             }
-            case SNAPSHOTS_ID: {
-                selection = DatabaseUtils.concatenateWhere(selection, TABLE_SNAPSHOTS + "._id=?");
-                selectionArgs = DatabaseUtils.appendSelectionArgs(selectionArgs,
-                        new String[] { Long.toString(ContentUris.parseId(uri)) });
-                // fall through
-            }
-            case SNAPSHOTS: {
-                deleted = db.delete(TABLE_SNAPSHOTS, selection, selectionArgs);
-                break;
-            }
             default: {
                 throw new UnsupportedOperationException("Unknown delete URI " + uri);
             }
@@ -1368,11 +1310,6 @@ public class BrowserProvider2 extends SQLiteContentProvider {
                 break;
             }
 
-            case SNAPSHOTS: {
-                id = db.insertOrThrow(TABLE_SNAPSHOTS, Snapshots.TITLE, values);
-                break;
-            }
-
             default: {
                 throw new UnsupportedOperationException("Unknown insert URI " + uri);
             }
diff --git a/src/com/android/browser/provider/SnapshotProvider.java b/src/com/android/browser/provider/SnapshotProvider.java
new file mode 100644
index 0000000..49557f7
--- /dev/null
+++ b/src/com/android/browser/provider/SnapshotProvider.java
@@ -0,0 +1,258 @@
+/*
+ * Copyright (C) 2011 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.browser.provider;
+
+import android.content.BroadcastReceiver;
+import android.content.ContentProvider;
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.UriMatcher;
+import android.database.Cursor;
+import android.database.DatabaseUtils;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteOpenHelper;
+import android.database.sqlite.SQLiteQueryBuilder;
+import android.net.Uri;
+import android.os.Environment;
+import android.provider.BrowserContract;
+
+import java.io.File;
+
+/**
+ * This provider is expected to be potentially flaky. It uses a database
+ * stored on external storage, which could be yanked unexpectedly.
+ */
+public class SnapshotProvider extends ContentProvider {
+
+    public static interface Snapshots {
+
+        public static final Uri CONTENT_URI = Uri.withAppendedPath(
+                SnapshotProvider.AUTHORITY_URI, "snapshots");
+        public static final String _ID = "_id";
+        public static final String VIEWSTATE = "view_state";
+        public static final String BACKGROUND = "background";
+        public static final String TITLE = "title";
+        public static final String URL = "url";
+        public static final String FAVICON = "favicon";
+        public static final String THUMBNAIL = "thumbnail";
+        public static final String DATE_CREATED = "date_created";
+    }
+
+    public static final String AUTHORITY = "com.android.browser.snapshots";
+    public static final Uri AUTHORITY_URI = Uri.parse("content://" + AUTHORITY);
+
+    static final String TABLE_SNAPSHOTS = "snapshots";
+    static final int SNAPSHOTS = 10;
+    static final int SNAPSHOTS_ID = 11;
+    static final UriMatcher URI_MATCHER = new UriMatcher(UriMatcher.NO_MATCH);
+
+    SnapshotDatabaseHelper mOpenHelper;
+
+    static {
+        URI_MATCHER.addURI(AUTHORITY, "snapshots", SNAPSHOTS);
+        URI_MATCHER.addURI(AUTHORITY, "snapshots/#", SNAPSHOTS_ID);
+    }
+
+    final static class SnapshotDatabaseHelper extends SQLiteOpenHelper {
+
+        static final String DATABASE_NAME = "snapshots.db";
+        static final int DATABASE_VERSION = 1;
+
+        public SnapshotDatabaseHelper(Context context) {
+            super(context, getFullDatabaseName(context), null, DATABASE_VERSION);
+        }
+
+        static String getFullDatabaseName(Context context) {
+            File dir = context.getExternalFilesDir(null);
+            return new File(dir, DATABASE_NAME).getAbsolutePath();
+        }
+
+        @Override
+        public void onCreate(SQLiteDatabase db) {
+            db.execSQL("CREATE TABLE " + TABLE_SNAPSHOTS + "(" +
+                    Snapshots._ID + " INTEGER PRIMARY KEY AUTOINCREMENT," +
+                    Snapshots.TITLE + " TEXT," +
+                    Snapshots.URL + " TEXT NOT NULL," +
+                    Snapshots.DATE_CREATED + " INTEGER," +
+                    Snapshots.FAVICON + " BLOB," +
+                    Snapshots.THUMBNAIL + " BLOB," +
+                    Snapshots.BACKGROUND + " INTEGER," +
+                    Snapshots.VIEWSTATE + " BLOB NOT NULL" +
+                    ");");
+        }
+
+        @Override
+        public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
+            // Not needed yet
+        }
+
+    }
+
+    @Override
+    public boolean onCreate() {
+        mOpenHelper = new SnapshotDatabaseHelper(getContext());
+        IntentFilter filter = new IntentFilter(Intent.ACTION_MEDIA_EJECT);
+        filter.addAction(Intent.ACTION_MEDIA_UNMOUNTED);
+        getContext().registerReceiver(mExternalStorageReceiver, filter);
+        return true;
+    }
+
+    final BroadcastReceiver mExternalStorageReceiver = new BroadcastReceiver() {
+
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            try {
+                mOpenHelper.close();
+            } catch (Throwable t) {
+                // We failed to close the open helper, which most likely means
+                // another thread is busy attempting to open the database
+                // or use the database. Let that thread try to gracefully
+                // deal with the error
+            }
+        }
+    };
+
+    SQLiteDatabase getWritableDatabase() {
+        String state = Environment.getExternalStorageState();
+        if (Environment.MEDIA_MOUNTED.equals(state)) {
+            try {
+                return mOpenHelper.getWritableDatabase();
+            } catch (Throwable t) {
+                return null;
+            }
+        }
+        return null;
+    }
+
+    SQLiteDatabase getReadableDatabase() {
+        String state = Environment.getExternalStorageState();
+        if (Environment.MEDIA_MOUNTED.equals(state)
+                || Environment.MEDIA_MOUNTED_READ_ONLY.equals(state)) {
+            try {
+                return mOpenHelper.getReadableDatabase();
+            } catch (Throwable t) {
+                return null;
+            }
+        }
+        return null;
+    }
+
+    @Override
+    public Cursor query(Uri uri, String[] projection, String selection,
+            String[] selectionArgs, String sortOrder) {
+        SQLiteDatabase db = getReadableDatabase();
+        if (db == null) {
+            return null;
+        }
+        final int match = URI_MATCHER.match(uri);
+        SQLiteQueryBuilder qb = new SQLiteQueryBuilder();
+        String limit = uri.getQueryParameter(BrowserContract.PARAM_LIMIT);
+        switch (match) {
+        case SNAPSHOTS_ID:
+            selection = DatabaseUtils.concatenateWhere(selection, "_id=?");
+            selectionArgs = DatabaseUtils.appendSelectionArgs(selectionArgs,
+                    new String[] { Long.toString(ContentUris.parseId(uri)) });
+            // fall through
+        case SNAPSHOTS:
+            qb.setTables(TABLE_SNAPSHOTS);
+            break;
+
+        default:
+            throw new UnsupportedOperationException("Unknown URL " + uri.toString());
+        }
+        try {
+            Cursor cursor = qb.query(db, projection, selection, selectionArgs,
+                    null, null, sortOrder, limit);
+            cursor.setNotificationUri(getContext().getContentResolver(),
+                    AUTHORITY_URI);
+            return cursor;
+        } catch (Throwable t) {
+            return null;
+        }
+    }
+
+    @Override
+    public String getType(Uri uri) {
+        return null;
+    }
+
+    @Override
+    public Uri insert(Uri uri, ContentValues values) {
+        SQLiteDatabase db = getWritableDatabase();
+        if (db == null) {
+            return null;
+        }
+        int match = URI_MATCHER.match(uri);
+        long id = -1;
+        switch (match) {
+        case SNAPSHOTS:
+            try {
+                id = db.insert(TABLE_SNAPSHOTS, Snapshots.TITLE, values);
+            } catch (Throwable t) {
+                id = -1;
+            }
+            break;
+        default:
+            throw new UnsupportedOperationException("Unknown insert URI " + uri);
+        }
+        if (id < 0) {
+            return null;
+        }
+        Uri inserted = ContentUris.withAppendedId(uri, id);
+        getContext().getContentResolver().notifyChange(inserted, null, false);
+        return inserted;
+    }
+
+    @Override
+    public int delete(Uri uri, String selection, String[] selectionArgs) {
+        SQLiteDatabase db = getWritableDatabase();
+        if (db == null) {
+            return 0;
+        }
+        int match = URI_MATCHER.match(uri);
+        int deleted = 0;
+        switch (match) {
+        case SNAPSHOTS_ID: {
+            selection = DatabaseUtils.concatenateWhere(selection, TABLE_SNAPSHOTS + "._id=?");
+            selectionArgs = DatabaseUtils.appendSelectionArgs(selectionArgs,
+                    new String[] { Long.toString(ContentUris.parseId(uri)) });
+            // fall through
+        }
+        case SNAPSHOTS:
+            try {
+                deleted = db.delete(TABLE_SNAPSHOTS, selection, selectionArgs);
+            } catch (Throwable t) {
+            }
+            break;
+        default:
+            throw new UnsupportedOperationException("Unknown delete URI " + uri);
+        }
+        if (deleted > 0) {
+            getContext().getContentResolver().notifyChange(uri, null, false);
+        }
+        return deleted;
+    }
+
+    @Override
+    public int update(Uri uri, ContentValues values, String selection,
+            String[] selectionArgs) {
+        throw new UnsupportedOperationException("not implemented");
+    }
+
+}