diff options
Diffstat (limited to 'src/src/com/android/browser/provider/BrowserProvider.java')
| -rw-r--r-- | src/src/com/android/browser/provider/BrowserProvider.java | 1040 |
1 files changed, 1040 insertions, 0 deletions
diff --git a/src/src/com/android/browser/provider/BrowserProvider.java b/src/src/com/android/browser/provider/BrowserProvider.java new file mode 100644 index 00000000..c86ae844 --- /dev/null +++ b/src/src/com/android/browser/provider/BrowserProvider.java @@ -0,0 +1,1040 @@ +/* + * Copyright (C) 2006 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.app.SearchManager; +import android.app.backup.BackupManager; +import android.content.ContentProvider; +import android.content.ContentResolver; +import android.content.ContentUris; +import android.content.ContentValues; +import android.content.Context; +import android.content.Intent; +import android.content.SharedPreferences; +import android.content.SharedPreferences.Editor; +import android.content.UriMatcher; +import android.content.res.Configuration; +import android.database.AbstractCursor; +import android.database.Cursor; +import android.database.DatabaseUtils; +import android.database.sqlite.SQLiteDatabase; +import android.database.sqlite.SQLiteOpenHelper; +import android.net.Uri; +import android.os.Process; +import android.preference.PreferenceManager; +import android.text.TextUtils; +import android.util.Log; +import android.util.Patterns; + +import com.android.browser.BrowserSettings; +import com.android.browser.R; +import com.android.browser.platformsupport.Browser; +import com.android.browser.platformsupport.Browser.BookmarkColumns; +import com.android.browser.search.SearchEngine; + +import java.io.File; +import java.io.FilenameFilter; +import java.util.Date; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + + +public class BrowserProvider extends ContentProvider { + + private SQLiteOpenHelper mOpenHelper; + private BackupManager mBackupManager; + static final String sDatabaseName = "browser.db"; + private static final String TAG = "BrowserProvider"; + private static final String ORDER_BY = "visits DESC, date DESC"; + + private static final String PICASA_URL = "http://picasaweb.google.com/m/" + + "viewer?source=androidclient"; + + static final String[] TABLE_NAMES = new String[] { + "bookmarks", "searches" + }; + private static final String[] SUGGEST_PROJECTION = new String[] { + "_id", "url", "title", "bookmark", "user_entered" + }; + private static final String SUGGEST_SELECTION = + "(url LIKE ? OR url LIKE ? OR url LIKE ? OR url LIKE ?" + + " OR title LIKE ?) AND (bookmark = 1 OR user_entered = 1)"; + private String[] SUGGEST_ARGS = new String[5]; + + // shared suggestion array index, make sure to match COLUMNS + private static final int SUGGEST_COLUMN_INTENT_ACTION_ID = 1; + private static final int SUGGEST_COLUMN_INTENT_DATA_ID = 2; + private static final int SUGGEST_COLUMN_TEXT_1_ID = 3; + private static final int SUGGEST_COLUMN_TEXT_2_ID = 4; + private static final int SUGGEST_COLUMN_TEXT_2_URL_ID = 5; + private static final int SUGGEST_COLUMN_ICON_1_ID = 6; + private static final int SUGGEST_COLUMN_ICON_2_ID = 7; + private static final int SUGGEST_COLUMN_QUERY_ID = 8; + private static final int SUGGEST_COLUMN_INTENT_EXTRA_DATA = 9; + + // how many suggestions will be shown in dropdown + // 0..SHORT: filled by browser db + private static final int MAX_SUGGEST_SHORT_SMALL = 3; + // SHORT..LONG: filled by search suggestions + private static final int MAX_SUGGEST_LONG_SMALL = 6; + + // large screen size shows more + private static final int MAX_SUGGEST_SHORT_LARGE = 6; + private static final int MAX_SUGGEST_LONG_LARGE = 9; + + + // shared suggestion columns + private static final String[] COLUMNS = new String[] { + "_id", + SearchManager.SUGGEST_COLUMN_INTENT_ACTION, + SearchManager.SUGGEST_COLUMN_INTENT_DATA, + SearchManager.SUGGEST_COLUMN_TEXT_1, + SearchManager.SUGGEST_COLUMN_TEXT_2, + SearchManager.SUGGEST_COLUMN_TEXT_2_URL, + SearchManager.SUGGEST_COLUMN_ICON_1, + SearchManager.SUGGEST_COLUMN_ICON_2, + SearchManager.SUGGEST_COLUMN_QUERY, + SearchManager.SUGGEST_COLUMN_INTENT_EXTRA_DATA}; + + + // make sure that these match the index of TABLE_NAMES + static final int URI_MATCH_BOOKMARKS = 0; + private static final int URI_MATCH_SEARCHES = 1; + // (id % 10) should match the table name index + private static final int URI_MATCH_BOOKMARKS_ID = 10; + private static final int URI_MATCH_SEARCHES_ID = 11; + // + private static final int URI_MATCH_SUGGEST = 20; + private static final int URI_MATCH_BOOKMARKS_SUGGEST = 21; + + private static final UriMatcher URI_MATCHER; + + static { + URI_MATCHER = new UriMatcher(UriMatcher.NO_MATCH); + URI_MATCHER.addURI("browser", TABLE_NAMES[URI_MATCH_BOOKMARKS], + URI_MATCH_BOOKMARKS); + URI_MATCHER.addURI("browser", TABLE_NAMES[URI_MATCH_BOOKMARKS] + "/#", + URI_MATCH_BOOKMARKS_ID); + URI_MATCHER.addURI("browser", TABLE_NAMES[URI_MATCH_SEARCHES], + URI_MATCH_SEARCHES); + URI_MATCHER.addURI("browser", TABLE_NAMES[URI_MATCH_SEARCHES] + "/#", + URI_MATCH_SEARCHES_ID); + URI_MATCHER.addURI("browser", SearchManager.SUGGEST_URI_PATH_QUERY, + URI_MATCH_SUGGEST); + URI_MATCHER.addURI("browser", + TABLE_NAMES[URI_MATCH_BOOKMARKS] + "/" + SearchManager.SUGGEST_URI_PATH_QUERY, + URI_MATCH_BOOKMARKS_SUGGEST); + } + + // 1 -> 2 add cache table + // 2 -> 3 update history table + // 3 -> 4 add passwords table + // 4 -> 5 add settings table + // 5 -> 6 ? + // 6 -> 7 ? + // 7 -> 8 drop proxy table + // 8 -> 9 drop settings table + // 9 -> 10 add form_urls and form_data + // 10 -> 11 add searches table + // 11 -> 12 modify cache table + // 12 -> 13 modify cache table + // 13 -> 14 correspond with Google Bookmarks schema + // 14 -> 15 move couple of tables to either browser private database or webview database + // 15 -> 17 Set it up for the SearchManager + // 17 -> 18 Added favicon in bookmarks table for Home shortcuts + // 18 -> 19 Remove labels table + // 19 -> 20 Added thumbnail + // 20 -> 21 Added touch_icon + // 21 -> 22 Remove "clientid" + // 22 -> 23 Added user_entered + // 23 -> 24 Url not allowed to be null anymore. + private static final int DATABASE_VERSION = 24; + + // Regular expression which matches http://, followed by some stuff, followed by + // optionally a trailing slash, all matched as separate groups. + private static final Pattern STRIP_URL_PATTERN = Pattern.compile("^(http://)(.*?)(/$)?"); + + private BrowserSettings mSettings; + + private int mMaxSuggestionShortSize; + private int mMaxSuggestionLongSize; + + public BrowserProvider() { + } + + // XXX: This is a major hack to remove our dependency on gsf constants and + // its content provider. http://b/issue?id=2425179 + public static String getClientId(ContentResolver cr) { + String ret = "android-google"; + Cursor legacyClientIdCursor = null; + Cursor searchClientIdCursor = null; + + // search_client_id includes search prefix, legacy client_id does not include prefix + try { + searchClientIdCursor = cr.query(Uri.parse("content://com.google.settings/partner"), + new String[] { "value" }, "name='search_client_id'", null, null); + if (searchClientIdCursor != null && searchClientIdCursor.moveToNext()) { + ret = searchClientIdCursor.getString(0); + } else { + legacyClientIdCursor = cr.query(Uri.parse("content://com.google.settings/partner"), + new String[] { "value" }, "name='client_id'", null, null); + if (legacyClientIdCursor != null && legacyClientIdCursor.moveToNext()) { + ret = "ms-" + legacyClientIdCursor.getString(0); + } + } + } catch (RuntimeException ex) { + // fall through to return the default + } finally { + if (legacyClientIdCursor != null) { + legacyClientIdCursor.close(); + } + if (searchClientIdCursor != null) { + searchClientIdCursor.close(); + } + } + return ret; + } + + private static CharSequence replaceSystemPropertyInString(Context context, CharSequence srcString) { + StringBuffer sb = new StringBuffer(); + int lastCharLoc = 0; + + final String client_id = getClientId(context.getContentResolver()); + + for (int i = 0; i < srcString.length(); ++i) { + char c = srcString.charAt(i); + if (c == '{') { + sb.append(srcString.subSequence(lastCharLoc, i)); + lastCharLoc = i; + inner: + for (int j = i; j < srcString.length(); ++j) { + char k = srcString.charAt(j); + if (k == '}') { + String propertyKeyValue = srcString.subSequence(i + 1, j).toString(); + if (propertyKeyValue.equals("CLIENT_ID")) { + sb.append(client_id); + } else { + sb.append("unknown"); + } + lastCharLoc = j + 1; + i = j; + break inner; + } + } + } + } + if (srcString.length() - lastCharLoc > 0) { + // Put on the tail, if there is one + sb.append(srcString.subSequence(lastCharLoc, srcString.length())); + } + return sb; + } + + static class DatabaseHelper extends SQLiteOpenHelper { + private Context mContext; + + public DatabaseHelper(Context context) { + super(context, sDatabaseName, null, DATABASE_VERSION); + mContext = context; + } + + @Override + public void onCreate(SQLiteDatabase db) { + db.execSQL("CREATE TABLE bookmarks (" + + "_id INTEGER PRIMARY KEY," + + "title TEXT," + + "url TEXT NOT NULL," + + "visits INTEGER," + + "date LONG," + + "created LONG," + + "description TEXT," + + "bookmark INTEGER," + + "favicon BLOB DEFAULT NULL," + + "thumbnail BLOB DEFAULT NULL," + + "touch_icon BLOB DEFAULT NULL," + + "user_entered INTEGER" + + ");"); + + final CharSequence[] bookmarks = mContext.getResources() + .getTextArray(R.array.bookmarks); + int size = bookmarks.length; + try { + for (int i = 0; i < size; i = i + 2) { + CharSequence bookmarkDestination = replaceSystemPropertyInString(mContext, bookmarks[i + 1]); + db.execSQL("INSERT INTO bookmarks (title, url, visits, " + + "date, created, bookmark)" + " VALUES('" + + bookmarks[i] + "', '" + bookmarkDestination + + "', 0, 0, 0, 1);"); + } + } catch (ArrayIndexOutOfBoundsException e) { + } + + db.execSQL("CREATE TABLE searches (" + + "_id INTEGER PRIMARY KEY," + + "search TEXT," + + "date LONG" + + ");"); + } + + @Override + public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { + Log.w(TAG, "Upgrading database from version " + oldVersion + " to " + + newVersion); + if (oldVersion == 18) { + db.execSQL("DROP TABLE IF EXISTS labels"); + } + if (oldVersion <= 19) { + db.execSQL("ALTER TABLE bookmarks ADD COLUMN thumbnail BLOB DEFAULT NULL;"); + } + if (oldVersion < 21) { + db.execSQL("ALTER TABLE bookmarks ADD COLUMN touch_icon BLOB DEFAULT NULL;"); + } + if (oldVersion < 22) { + db.execSQL("DELETE FROM bookmarks WHERE (bookmark = 0 AND url LIKE \"%.google.%client=ms-%\")"); + removeGears(); + } + if (oldVersion < 23) { + db.execSQL("ALTER TABLE bookmarks ADD COLUMN user_entered INTEGER;"); + } + if (oldVersion < 24) { + /* SQLite does not support ALTER COLUMN, hence the lengthy code. */ + db.execSQL("DELETE FROM bookmarks WHERE url IS NULL;"); + db.execSQL("ALTER TABLE bookmarks RENAME TO bookmarks_temp;"); + db.execSQL("CREATE TABLE bookmarks (" + + "_id INTEGER PRIMARY KEY," + + "title TEXT," + + "url TEXT NOT NULL," + + "visits INTEGER," + + "date LONG," + + "created LONG," + + "description TEXT," + + "bookmark INTEGER," + + "favicon BLOB DEFAULT NULL," + + "thumbnail BLOB DEFAULT NULL," + + "touch_icon BLOB DEFAULT NULL," + + "user_entered INTEGER" + + ");"); + db.execSQL("INSERT INTO bookmarks SELECT * FROM bookmarks_temp;"); + db.execSQL("DROP TABLE bookmarks_temp;"); + } else { + db.execSQL("DROP TABLE IF EXISTS bookmarks"); + db.execSQL("DROP TABLE IF EXISTS searches"); + onCreate(db); + } + } + + private void removeGears() { + new Thread() { + @Override + public void run() { + Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND); + String browserDataDirString = mContext.getApplicationInfo().dataDir; + final String appPluginsDirString = "app_plugins"; + final String gearsPrefix = "gears"; + File appPluginsDir = new File(browserDataDirString + File.separator + + appPluginsDirString); + if (!appPluginsDir.exists()) { + return; + } + // Delete the Gears plugin files + File[] gearsFiles = appPluginsDir.listFiles(new FilenameFilter() { + public boolean accept(File dir, String filename) { + return filename.startsWith(gearsPrefix); + } + }); + for (int i = 0; i < gearsFiles.length; ++i) { + if (gearsFiles[i].isDirectory()) { + deleteDirectory(gearsFiles[i]); + } else { + gearsFiles[i].delete(); + } + } + // Delete the Gears data files + File gearsDataDir = new File(browserDataDirString + File.separator + + gearsPrefix); + if (!gearsDataDir.exists()) { + return; + } + deleteDirectory(gearsDataDir); + } + + private void deleteDirectory(File currentDir) { + File[] files = currentDir.listFiles(); + for (int i = 0; i < files.length; ++i) { + if (files[i].isDirectory()) { + deleteDirectory(files[i]); + } + files[i].delete(); + } + currentDir.delete(); + } + }.start(); + } + } + + @Override + public boolean onCreate() { + final Context context = getContext(); + boolean xlargeScreenSize = (context.getResources().getConfiguration().screenLayout + & Configuration.SCREENLAYOUT_SIZE_MASK) + == Configuration.SCREENLAYOUT_SIZE_XLARGE; + boolean isPortrait = (context.getResources().getConfiguration().orientation + == Configuration.ORIENTATION_PORTRAIT); + + + if (xlargeScreenSize && isPortrait) { + mMaxSuggestionLongSize = MAX_SUGGEST_LONG_LARGE; + mMaxSuggestionShortSize = MAX_SUGGEST_SHORT_LARGE; + } else { + mMaxSuggestionLongSize = MAX_SUGGEST_LONG_SMALL; + mMaxSuggestionShortSize = MAX_SUGGEST_SHORT_SMALL; + } + mOpenHelper = new DatabaseHelper(context); + mBackupManager = new BackupManager(context); + // we added "picasa web album" into default bookmarks for version 19. + // To avoid erasing the bookmark table, we added it explicitly for + // version 18 and 19 as in the other cases, we will erase the table. + if (DATABASE_VERSION == 18 || DATABASE_VERSION == 19) { + SharedPreferences p = PreferenceManager + .getDefaultSharedPreferences(context); + boolean fix = p.getBoolean("fix_picasa", true); + if (fix) { + fixPicasaBookmark(); + Editor ed = p.edit(); + ed.putBoolean("fix_picasa", false); + ed.apply(); + } + } + mSettings = BrowserSettings.getInstance(); + return true; + } + + private void fixPicasaBookmark() { + SQLiteDatabase db = mOpenHelper.getWritableDatabase(); + Cursor cursor = db.rawQuery("SELECT _id FROM bookmarks WHERE " + + "bookmark = 1 AND url = ?", new String[] { PICASA_URL }); + try { + if (!cursor.moveToFirst()) { + // set "created" so that it will be on the top of the list + db.execSQL("INSERT INTO bookmarks (title, url, visits, " + + "date, created, bookmark)" + " VALUES('" + + getContext().getString(R.string.picasa) + "', '" + + PICASA_URL + "', 0, 0, " + new Date().getTime() + + ", 1);"); + } + } finally { + if (cursor != null) { + cursor.close(); + } + } + } + + /* + * Subclass AbstractCursor so we can combine multiple Cursors and add + * "Search the web". + * Here are the rules. + * 1. We only have MAX_SUGGESTION_LONG_ENTRIES in the list plus + * "Search the web"; + * 2. If bookmark/history entries has a match, "Search the web" shows up at + * the second place. Otherwise, "Search the web" shows up at the first + * place. + */ + private class MySuggestionCursor extends AbstractCursor { + private Cursor mHistoryCursor; + private Cursor mSuggestCursor; + private int mHistoryCount; + private int mSuggestionCount; + private boolean mIncludeWebSearch; + private String mString; + private int mSuggestText1Id; + private int mSuggestText2Id; + private int mSuggestText2UrlId; + private int mSuggestQueryId; + private int mSuggestIntentExtraDataId; + + public MySuggestionCursor(Cursor hc, Cursor sc, String string) { + mHistoryCursor = hc; + mSuggestCursor = sc; + mHistoryCount = hc != null ? hc.getCount() : 0; + mSuggestionCount = sc != null ? sc.getCount() : 0; + if (mSuggestionCount > (mMaxSuggestionLongSize - mHistoryCount)) { + mSuggestionCount = mMaxSuggestionLongSize - mHistoryCount; + } + mString = string; + mIncludeWebSearch = string.length() > 0; + + // Some web suggest providers only give suggestions and have no description string for + // items. The order of the result columns may be different as well. So retrieve the + // column indices for the fields we need now and check before using below. + if (mSuggestCursor == null) { + mSuggestText1Id = -1; + mSuggestText2Id = -1; + mSuggestText2UrlId = -1; + mSuggestQueryId = -1; + mSuggestIntentExtraDataId = -1; + } else { + mSuggestText1Id = mSuggestCursor.getColumnIndex( + SearchManager.SUGGEST_COLUMN_TEXT_1); + mSuggestText2Id = mSuggestCursor.getColumnIndex( + SearchManager.SUGGEST_COLUMN_TEXT_2); + mSuggestText2UrlId = mSuggestCursor.getColumnIndex( + SearchManager.SUGGEST_COLUMN_TEXT_2_URL); + mSuggestQueryId = mSuggestCursor.getColumnIndex( + SearchManager.SUGGEST_COLUMN_QUERY); + mSuggestIntentExtraDataId = mSuggestCursor.getColumnIndex( + SearchManager.SUGGEST_COLUMN_INTENT_EXTRA_DATA); + } + } + + @Override + public boolean onMove(int oldPosition, int newPosition) { + if (mHistoryCursor == null) { + return false; + } + if (mIncludeWebSearch) { + if (mHistoryCount == 0 && newPosition == 0) { + return true; + } else if (mHistoryCount > 0) { + if (newPosition == 0) { + mHistoryCursor.moveToPosition(0); + return true; + } else if (newPosition == 1) { + return true; + } + } + newPosition--; + } + if (mHistoryCount > newPosition) { + mHistoryCursor.moveToPosition(newPosition); + } else { + mSuggestCursor.moveToPosition(newPosition - mHistoryCount); + } + return true; + } + + @Override + public int getCount() { + if (mIncludeWebSearch) { + return mHistoryCount + mSuggestionCount + 1; + } else { + return mHistoryCount + mSuggestionCount; + } + } + + @Override + public String[] getColumnNames() { + return COLUMNS; + } + + @Override + public String getString(int columnIndex) { + if ((mPos != -1 && mHistoryCursor != null)) { + int type = -1; // 0: web search; 1: history; 2: suggestion + if (mIncludeWebSearch) { + if (mHistoryCount == 0 && mPos == 0) { + type = 0; + } else if (mHistoryCount > 0) { + if (mPos == 0) { + type = 1; + } else if (mPos == 1) { + type = 0; + } + } + if (type == -1) type = (mPos - 1) < mHistoryCount ? 1 : 2; + } else { + type = mPos < mHistoryCount ? 1 : 2; + } + + switch(columnIndex) { + case SUGGEST_COLUMN_INTENT_ACTION_ID: + if (type == 1) { + return Intent.ACTION_VIEW; + } else { + return Intent.ACTION_SEARCH; + } + + case SUGGEST_COLUMN_INTENT_DATA_ID: + if (type == 1) { + return mHistoryCursor.getString(1); + } else { + return null; + } + + case SUGGEST_COLUMN_TEXT_1_ID: + if (type == 0) { + return mString; + } else if (type == 1) { + return getHistoryTitle(); + } else { + if (mSuggestText1Id == -1) return null; + return mSuggestCursor.getString(mSuggestText1Id); + } + + case SUGGEST_COLUMN_TEXT_2_ID: + if (type == 0) { + return getContext().getString(R.string.search_the_web); + } else if (type == 1) { + return null; // Use TEXT_2_URL instead + } else { + if (mSuggestText2Id == -1) return null; + return mSuggestCursor.getString(mSuggestText2Id); + } + + case SUGGEST_COLUMN_TEXT_2_URL_ID: + if (type == 0) { + return null; + } else if (type == 1) { + return getHistoryUrl(); + } else { + if (mSuggestText2UrlId == -1) return null; + return mSuggestCursor.getString(mSuggestText2UrlId); + } + + case SUGGEST_COLUMN_ICON_1_ID: + if (type == 1) { + if (mHistoryCursor.getInt(3) == 1) { + return Integer.valueOf( + R.drawable.ic_suggest_bookmark_normal) + .toString(); + } else { + return Integer.valueOf( + R.drawable.ic_suggest_history_normal) + .toString(); + } + } else { + return Integer.valueOf( + R.drawable.ic_suggest_search_normal) + .toString(); + } + + case SUGGEST_COLUMN_ICON_2_ID: + return "0"; + + case SUGGEST_COLUMN_QUERY_ID: + if (type == 0) { + return mString; + } else if (type == 1) { + // Return the url in the intent query column. This is ignored + // within the browser because our searchable is set to + // android:searchMode="queryRewriteFromData", but it is used by + // global search for query rewriting. + return mHistoryCursor.getString(1); + } else { + if (mSuggestQueryId == -1) return null; + return mSuggestCursor.getString(mSuggestQueryId); + } + + case SUGGEST_COLUMN_INTENT_EXTRA_DATA: + if (type == 0) { + return null; + } else if (type == 1) { + return null; + } else { + if (mSuggestIntentExtraDataId == -1) return null; + return mSuggestCursor.getString(mSuggestIntentExtraDataId); + } + } + } + return null; + } + + @Override + public double getDouble(int column) { + throw new UnsupportedOperationException(); + } + + @Override + public float getFloat(int column) { + throw new UnsupportedOperationException(); + } + + @Override + public int getInt(int column) { + throw new UnsupportedOperationException(); + } + + @Override + public long getLong(int column) { + if ((mPos != -1) && column == 0) { + return mPos; // use row# as the _Id + } + throw new UnsupportedOperationException(); + } + + @Override + public short getShort(int column) { + throw new UnsupportedOperationException(); + } + + @Override + public boolean isNull(int column) { + throw new UnsupportedOperationException(); + } + + // TODO Temporary change, finalize after jq's changes go in + @Override + public void deactivate() { + if (mHistoryCursor != null) { + mHistoryCursor.deactivate(); + } + if (mSuggestCursor != null) { + mSuggestCursor.deactivate(); + } + super.deactivate(); + } + + @Override + public boolean requery() { + return (mHistoryCursor != null ? mHistoryCursor.requery() : false) | + (mSuggestCursor != null ? mSuggestCursor.requery() : false); + } + + // TODO Temporary change, finalize after jq's changes go in + @Override + public void close() { + super.close(); + if (mHistoryCursor != null) { + mHistoryCursor.close(); + mHistoryCursor = null; + } + if (mSuggestCursor != null) { + mSuggestCursor.close(); + mSuggestCursor = null; + } + } + + /** + * Provides the title (text line 1) for a browser suggestion, which should be the + * webpage title. If the webpage title is empty, returns the stripped url instead. + * + * @return the title string to use + */ + private String getHistoryTitle() { + String title = mHistoryCursor.getString(2 /* webpage title */); + if (TextUtils.isEmpty(title) || TextUtils.getTrimmedLength(title) == 0) { + title = stripUrl(mHistoryCursor.getString(1 /* url */)); + } + return title; + } + + /** + * Provides the subtitle (text line 2) for a browser suggestion, which should be the + * webpage url. If the webpage title is empty, then the url should go in the title + * instead, and the subtitle should be empty, so this would return null. + * + * @return the subtitle string to use, or null if none + */ + private String getHistoryUrl() { + String title = mHistoryCursor.getString(2 /* webpage title */); + if (TextUtils.isEmpty(title) || TextUtils.getTrimmedLength(title) == 0) { + return null; + } else { + return stripUrl(mHistoryCursor.getString(1 /* url */)); + } + } + + } + + @Override + public Cursor query(Uri url, String[] projectionIn, String selection, + String[] selectionArgs, String sortOrder) + throws IllegalStateException { + int match = URI_MATCHER.match(url); + if (match == -1) { + throw new IllegalArgumentException("Unknown URL"); + } + + if (match == URI_MATCH_SUGGEST || match == URI_MATCH_BOOKMARKS_SUGGEST) { + // Handle suggestions + return doSuggestQuery(selection, selectionArgs, match == URI_MATCH_BOOKMARKS_SUGGEST); + } + + String[] projection = null; + if (projectionIn != null && projectionIn.length > 0) { + projection = new String[projectionIn.length + 1]; + System.arraycopy(projectionIn, 0, projection, 0, projectionIn.length); + projection[projectionIn.length] = "_id AS _id"; + } + + String whereClause = null; + if (match == URI_MATCH_BOOKMARKS_ID || match == URI_MATCH_SEARCHES_ID) { + whereClause = "_id = " + url.getPathSegments().get(1); + } + + Cursor c = mOpenHelper.getReadableDatabase().query(TABLE_NAMES[match % 10], projection, + DatabaseUtils.concatenateWhere(whereClause, selection), selectionArgs, + null, null, sortOrder, null); + c.setNotificationUri(getContext().getContentResolver(), url); + return c; + } + + private Cursor doSuggestQuery(String selection, String[] selectionArgs, boolean bookmarksOnly) { + String suggestSelection; + String [] myArgs; + if (selectionArgs[0] == null || selectionArgs[0].equals("")) { + return new MySuggestionCursor(null, null, ""); + } else { + String like = selectionArgs[0] + "%"; + if (selectionArgs[0].startsWith("http") + || selectionArgs[0].startsWith("file")) { + myArgs = new String[1]; + myArgs[0] = like; + suggestSelection = selection; + } else { + SUGGEST_ARGS[0] = "http://" + like; + SUGGEST_ARGS[1] = "http://www." + like; + SUGGEST_ARGS[2] = "https://" + like; + SUGGEST_ARGS[3] = "https://www." + like; + // To match against titles. + SUGGEST_ARGS[4] = like; + myArgs = SUGGEST_ARGS; + suggestSelection = SUGGEST_SELECTION; + } + } + + Cursor c = mOpenHelper.getReadableDatabase().query(TABLE_NAMES[URI_MATCH_BOOKMARKS], + SUGGEST_PROJECTION, suggestSelection, myArgs, null, null, + ORDER_BY, Integer.toString(mMaxSuggestionLongSize)); + + if (bookmarksOnly || Patterns.WEB_URL.matcher(selectionArgs[0]).matches()) { + return new MySuggestionCursor(c, null, ""); + } else { + // get search suggestions if there is still space in the list + if (myArgs != null && myArgs.length > 1 + && c.getCount() < (MAX_SUGGEST_SHORT_SMALL - 1)) { + SearchEngine searchEngine = mSettings.getSearchEngine(); + if (searchEngine != null && searchEngine.supportsSuggestions()) { + Cursor sc = searchEngine.getSuggestions(getContext(), selectionArgs[0]); + return new MySuggestionCursor(c, sc, selectionArgs[0]); + } + } + return new MySuggestionCursor(c, null, selectionArgs[0]); + } + } + + @Override + public String getType(Uri url) { + int match = URI_MATCHER.match(url); + switch (match) { + case URI_MATCH_BOOKMARKS: + return "vnd.android.cursor.dir/bookmark"; + + case URI_MATCH_BOOKMARKS_ID: + return "vnd.android.cursor.item/bookmark"; + + case URI_MATCH_SEARCHES: + return "vnd.android.cursor.dir/searches"; + + case URI_MATCH_SEARCHES_ID: + return "vnd.android.cursor.item/searches"; + + case URI_MATCH_SUGGEST: + return SearchManager.SUGGEST_MIME_TYPE; + + default: + throw new IllegalArgumentException("Unknown URL"); + } + } + + @Override + public Uri insert(Uri url, ContentValues initialValues) { + boolean isBookmarkTable = false; + SQLiteDatabase db = mOpenHelper.getWritableDatabase(); + + int match = URI_MATCHER.match(url); + Uri uri = null; + switch (match) { + case URI_MATCH_BOOKMARKS: { + // Insert into the bookmarks table + long rowID = db.insert(TABLE_NAMES[URI_MATCH_BOOKMARKS], "url", + initialValues); + if (rowID > 0) { + uri = ContentUris.withAppendedId(Browser.BOOKMARKS_URI, + rowID); + } + isBookmarkTable = true; + break; + } + + case URI_MATCH_SEARCHES: { + // Insert into the searches table + long rowID = db.insert(TABLE_NAMES[URI_MATCH_SEARCHES], "url", + initialValues); + if (rowID > 0) { + uri = ContentUris.withAppendedId(Browser.SEARCHES_URI, + rowID); + } + break; + } + + default: + throw new IllegalArgumentException("Unknown URL"); + } + + if (uri == null) { + throw new IllegalArgumentException("Unknown URL"); + } + getContext().getContentResolver().notifyChange(uri, null); + + // Back up the new bookmark set if we just inserted one. + // A row created when bookmarks are added from scratch will have + // bookmark=1 in the initial value set. + if (isBookmarkTable + && initialValues.containsKey(BookmarkColumns.BOOKMARK) + && initialValues.getAsInteger(BookmarkColumns.BOOKMARK) != 0) { + mBackupManager.dataChanged(); + } + return uri; + } + + @Override + public int delete(Uri url, String where, String[] whereArgs) { + SQLiteDatabase db = mOpenHelper.getWritableDatabase(); + + int match = URI_MATCHER.match(url); + if (match == -1 || match == URI_MATCH_SUGGEST) { + throw new IllegalArgumentException("Unknown URL"); + } + + // need to know whether it's the bookmarks table for a couple of reasons + boolean isBookmarkTable = (match == URI_MATCH_BOOKMARKS_ID); + String id = null; + + if (isBookmarkTable || match == URI_MATCH_SEARCHES_ID) { + StringBuilder sb = new StringBuilder(); + if (where != null && where.length() > 0) { + sb.append("( "); + sb.append(where); + sb.append(" ) AND "); + } + id = url.getPathSegments().get(1); + sb.append("_id = "); + sb.append(id); + where = sb.toString(); + } + + ContentResolver cr = getContext().getContentResolver(); + + // we'lll need to back up the bookmark set if we are about to delete one + if (isBookmarkTable) { + Cursor cursor = cr.query(Browser.BOOKMARKS_URI, + new String[] { BookmarkColumns.BOOKMARK }, + "_id = " + id, null, null); + if (cursor.moveToNext()) { + if (cursor.getInt(0) != 0) { + // yep, this record is a bookmark + mBackupManager.dataChanged(); + } + } + cursor.close(); + } + + int count = db.delete(TABLE_NAMES[match % 10], where, whereArgs); + cr.notifyChange(url, null); + return count; + } + + @Override + public int update(Uri url, ContentValues values, String where, + String[] whereArgs) { + SQLiteDatabase db = mOpenHelper.getWritableDatabase(); + + int match = URI_MATCHER.match(url); + if (match == -1 || match == URI_MATCH_SUGGEST) { + throw new IllegalArgumentException("Unknown URL"); + } + + if (match == URI_MATCH_BOOKMARKS_ID || match == URI_MATCH_SEARCHES_ID) { + StringBuilder sb = new StringBuilder(); + if (where != null && where.length() > 0) { + sb.append("( "); + sb.append(where); + sb.append(" ) AND "); + } + String id = url.getPathSegments().get(1); + sb.append("_id = "); + sb.append(id); + where = sb.toString(); + } + + ContentResolver cr = getContext().getContentResolver(); + + // Not all bookmark-table updates should be backed up. Look to see + // whether we changed the title, url, or "is a bookmark" state, and + // request a backup if so. + if (match == URI_MATCH_BOOKMARKS_ID || match == URI_MATCH_BOOKMARKS) { + boolean changingBookmarks = false; + // Alterations to the bookmark field inherently change the bookmark + // set, so we don't need to query the record; we know a priori that + // we will need to back up this change. + if (values.containsKey(BookmarkColumns.BOOKMARK)) { + changingBookmarks = true; + } else if ((values.containsKey(BookmarkColumns.TITLE) + || values.containsKey(BookmarkColumns.URL)) + && values.containsKey(BookmarkColumns._ID)) { + // If a title or URL has been changed, check to see if it is to + // a bookmark. The ID should have been included in the update, + // so use it. + Cursor cursor = cr.query(Browser.BOOKMARKS_URI, + new String[] { BookmarkColumns.BOOKMARK }, + BookmarkColumns._ID + " = " + + values.getAsString(BookmarkColumns._ID), null, null); + if (cursor.moveToNext()) { + changingBookmarks = (cursor.getInt(0) != 0); + } + cursor.close(); + } + + // if this *is* a bookmark row we're altering, we need to back it up. + if (changingBookmarks) { + mBackupManager.dataChanged(); + } + } + + int ret = db.update(TABLE_NAMES[match % 10], values, where, whereArgs); + cr.notifyChange(url, null); + return ret; + } + + /** + * Strips the provided url of preceding "http://" and any trailing "/". Does not + * strip "https://". If the provided string cannot be stripped, the original string + * is returned. + * + * TODO: Put this in TextUtils to be used by other packages doing something similar. + * + * @param url a url to strip, like "http://www.google.com/" + * @return a stripped url like "www.google.com", or the original string if it could + * not be stripped + */ + private static String stripUrl(String url) { + if (url == null) return null; + Matcher m = STRIP_URL_PATTERN.matcher(url); + if (m.matches() && m.groupCount() == 3) { + return m.group(2); + } else { + return url; + } + } + + public static Cursor getBookmarksSuggestions(ContentResolver cr, String constraint) { + Uri uri = Uri.parse("content://browser/" + SearchManager.SUGGEST_URI_PATH_QUERY); + return cr.query(uri, SUGGEST_PROJECTION, SUGGEST_SELECTION, + new String[] { constraint }, ORDER_BY); + } + +} |