The Android Open Source Project | 0c90888 | 2009-03-03 19:32:16 -0800 | [diff] [blame] | 1 | /* |
Dany Rybnikov | 535d4af | 2014-06-23 09:16:09 +0300 | [diff] [blame] | 2 | * Copyright (c) 2014, Linux Foundation. All rights reserved. |
The Android Open Source Project | 0c90888 | 2009-03-03 19:32:16 -0800 | [diff] [blame] | 3 | * Copyright (C) 2006 The Android Open Source Project |
| 4 | * |
| 5 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 6 | * you may not use this file except in compliance with the License. |
| 7 | * You may obtain a copy of the License at |
| 8 | * |
| 9 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 10 | * |
| 11 | * Unless required by applicable law or agreed to in writing, software |
| 12 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 14 | * See the License for the specific language governing permissions and |
| 15 | * limitations under the License. |
| 16 | */ |
| 17 | |
Bijan Amirzada | 41242f2 | 2014-03-21 12:12:18 -0700 | [diff] [blame] | 18 | package com.android.browser; |
The Android Open Source Project | 0c90888 | 2009-03-03 19:32:16 -0800 | [diff] [blame] | 19 | |
| 20 | import android.app.Activity; |
Jeff Hamilton | 64144e4 | 2010-08-18 16:31:59 -0500 | [diff] [blame] | 21 | import android.app.Fragment; |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 22 | import android.app.LoaderManager; |
Dianne Hackborn | eb07b17 | 2010-08-26 22:18:14 -0700 | [diff] [blame] | 23 | import android.content.ClipData; |
Michael Kolb | bef7a75 | 2010-08-25 17:11:35 -0700 | [diff] [blame] | 24 | import android.content.ClipboardManager; |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 25 | import android.content.ContentUris; |
Dianne Hackborn | 80f3262 | 2010-08-05 14:17:53 -0700 | [diff] [blame] | 26 | import android.content.Context; |
John Reck | 71efc2b | 2011-05-09 16:54:28 -0700 | [diff] [blame] | 27 | import android.content.CursorLoader; |
The Android Open Source Project | 0c90888 | 2009-03-03 19:32:16 -0800 | [diff] [blame] | 28 | import android.content.Intent; |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 29 | import android.content.Loader; |
John Reck | 4f61ee4 | 2011-08-22 16:31:14 -0700 | [diff] [blame] | 30 | import android.content.SharedPreferences; |
John Reck | b3417f0 | 2011-01-14 11:01:05 -0800 | [diff] [blame] | 31 | import android.content.res.Configuration; |
| 32 | import android.content.res.Resources; |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 33 | import android.database.Cursor; |
The Android Open Source Project | 0c90888 | 2009-03-03 19:32:16 -0800 | [diff] [blame] | 34 | import android.graphics.Bitmap; |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 35 | import android.graphics.BitmapFactory; |
John Reck | f94abcf | 2011-10-10 15:33:48 -0700 | [diff] [blame] | 36 | import android.graphics.BitmapFactory.Options; |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 37 | import android.net.Uri; |
John Reck | c849081 | 2010-11-22 14:15:36 -0800 | [diff] [blame] | 38 | import android.os.AsyncTask; |
The Android Open Source Project | 0c90888 | 2009-03-03 19:32:16 -0800 | [diff] [blame] | 39 | import android.os.Bundle; |
The Android Open Source Project | 0c90888 | 2009-03-03 19:32:16 -0800 | [diff] [blame] | 40 | import android.view.ContextMenu; |
Jeff Hamilton | db90aa8 | 2010-09-16 03:38:04 -0500 | [diff] [blame] | 41 | import android.view.ContextMenu.ContextMenuInfo; |
Jeff Hamilton | 64144e4 | 2010-08-18 16:31:59 -0500 | [diff] [blame] | 42 | import android.view.LayoutInflater; |
luxiaol | dbe4a62 | 2013-07-19 17:14:06 +0800 | [diff] [blame] | 43 | import android.view.Menu; |
The Android Open Source Project | 0c90888 | 2009-03-03 19:32:16 -0800 | [diff] [blame] | 44 | import android.view.MenuInflater; |
| 45 | import android.view.MenuItem; |
| 46 | import android.view.View; |
Jeff Hamilton | db90aa8 | 2010-09-16 03:38:04 -0500 | [diff] [blame] | 47 | import android.view.ViewGroup; |
John Reck | 71efc2b | 2011-05-09 16:54:28 -0700 | [diff] [blame] | 48 | import android.widget.ExpandableListView; |
| 49 | import android.widget.ExpandableListView.OnChildClickListener; |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 50 | import android.widget.Toast; |
The Android Open Source Project | 0c90888 | 2009-03-03 19:32:16 -0800 | [diff] [blame] | 51 | |
Bijan Amirzada | 41242f2 | 2014-03-21 12:12:18 -0700 | [diff] [blame] | 52 | import com.android.browser.R; |
| 53 | import com.android.browser.platformsupport.BrowserContract; |
| 54 | import com.android.browser.platformsupport.BrowserContract.Accounts; |
| 55 | import com.android.browser.provider.BrowserProvider2; |
| 56 | import com.android.browser.view.BookmarkExpandableView; |
| 57 | import com.android.browser.view.BookmarkExpandableView.BookmarkContextMenuInfo; |
Bijan Amirzada | 9b1e988 | 2014-02-26 17:15:46 -0800 | [diff] [blame] | 58 | |
| 59 | import java.util.HashMap; |
John Reck | e7c97de | 2011-05-27 14:42:43 -0700 | [diff] [blame] | 60 | |
John Reck | 4f61ee4 | 2011-08-22 16:31:14 -0700 | [diff] [blame] | 61 | import org.json.JSONException; |
| 62 | import org.json.JSONObject; |
| 63 | |
Dany Rybnikov | 535d4af | 2014-06-23 09:16:09 +0300 | [diff] [blame] | 64 | |
John Reck | 608baa7 | 2010-11-24 10:32:28 -0800 | [diff] [blame] | 65 | interface BookmarksPageCallbacks { |
| 66 | // Return true if handled |
| 67 | boolean onBookmarkSelected(Cursor c, boolean isFolder); |
| 68 | // Return true if handled |
John Reck | d3e4d5b | 2011-07-13 15:48:43 -0700 | [diff] [blame] | 69 | boolean onOpenInNewWindow(String... urls); |
John Reck | 608baa7 | 2010-11-24 10:32:28 -0800 | [diff] [blame] | 70 | } |
| 71 | |
The Android Open Source Project | 0c90888 | 2009-03-03 19:32:16 -0800 | [diff] [blame] | 72 | /** |
| 73 | * View showing the user's bookmarks in the browser. |
| 74 | */ |
Jeff Hamilton | 64144e4 | 2010-08-18 16:31:59 -0500 | [diff] [blame] | 75 | public class BrowserBookmarksPage extends Fragment implements View.OnCreateContextMenuListener, |
John Reck | 9db9529 | 2011-06-20 13:00:12 -0700 | [diff] [blame] | 76 | LoaderManager.LoaderCallbacks<Cursor>, BreadCrumbView.Controller, |
John Reck | d3e4d5b | 2011-07-13 15:48:43 -0700 | [diff] [blame] | 77 | OnChildClickListener { |
The Android Open Source Project | 0c90888 | 2009-03-03 19:32:16 -0800 | [diff] [blame] | 78 | |
John Reck | e7c97de | 2011-05-27 14:42:43 -0700 | [diff] [blame] | 79 | public static class ExtraDragState { |
| 80 | public int childPosition; |
| 81 | public int groupPosition; |
| 82 | } |
| 83 | |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 84 | static final String LOGTAG = "browser"; |
Nicolas Catania | 095292f | 2010-03-15 09:00:14 -0700 | [diff] [blame] | 85 | |
John Reck | 71efc2b | 2011-05-09 16:54:28 -0700 | [diff] [blame] | 86 | static final int LOADER_ACCOUNTS = 1; |
| 87 | static final int LOADER_BOOKMARKS = 100; |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 88 | |
Michael Kolb | 801ecb7 | 2010-08-25 12:57:38 -0700 | [diff] [blame] | 89 | static final String EXTRA_DISABLE_WINDOW = "disable_new_window"; |
John Reck | 4f61ee4 | 2011-08-22 16:31:14 -0700 | [diff] [blame] | 90 | static final String PREF_GROUP_STATE = "bbp_group_state"; |
Michael Kolb | 801ecb7 | 2010-08-25 12:57:38 -0700 | [diff] [blame] | 91 | |
John Reck | 71efc2b | 2011-05-09 16:54:28 -0700 | [diff] [blame] | 92 | static final String ACCOUNT_TYPE = "account_type"; |
| 93 | static final String ACCOUNT_NAME = "account_name"; |
| 94 | |
luxiaol | dbe4a62 | 2013-07-19 17:14:06 +0800 | [diff] [blame] | 95 | static final long DEFAULT_FOLDER_ID = -1; |
| 96 | |
John Reck | 608baa7 | 2010-11-24 10:32:28 -0800 | [diff] [blame] | 97 | BookmarksPageCallbacks mCallbacks; |
John Reck | 0ce8a94 | 2011-01-14 19:57:09 -0800 | [diff] [blame] | 98 | View mRoot; |
John Reck | 9db9529 | 2011-06-20 13:00:12 -0700 | [diff] [blame] | 99 | BookmarkExpandableView mGrid; |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 100 | boolean mDisableNewWindow; |
John Reck | 608baa7 | 2010-11-24 10:32:28 -0800 | [diff] [blame] | 101 | boolean mEnableContextMenu = true; |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 102 | View mEmptyView; |
John Reck | 608baa7 | 2010-11-24 10:32:28 -0800 | [diff] [blame] | 103 | View mHeader; |
John Reck | 71efc2b | 2011-05-09 16:54:28 -0700 | [diff] [blame] | 104 | HashMap<Integer, BrowserBookmarksAdapter> mBookmarkAdapters = new HashMap<Integer, BrowserBookmarksAdapter>(); |
John Reck | 4f61ee4 | 2011-08-22 16:31:14 -0700 | [diff] [blame] | 105 | JSONObject mState; |
luxiaol | dbe4a62 | 2013-07-19 17:14:06 +0800 | [diff] [blame] | 106 | long mCurrentFolderId = BrowserProvider2.FIXED_ID_ROOT; |
Michael Kolb | 370a4f3 | 2010-10-06 10:45:32 -0700 | [diff] [blame] | 107 | |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 108 | @Override |
| 109 | public Loader<Cursor> onCreateLoader(int id, Bundle args) { |
John Reck | 71efc2b | 2011-05-09 16:54:28 -0700 | [diff] [blame] | 110 | if (id == LOADER_ACCOUNTS) { |
| 111 | return new AccountsLoader(getActivity()); |
| 112 | } else if (id >= LOADER_BOOKMARKS) { |
| 113 | String accountType = args.getString(ACCOUNT_TYPE); |
| 114 | String accountName = args.getString(ACCOUNT_NAME); |
| 115 | BookmarksLoader bl = new BookmarksLoader(getActivity(), |
| 116 | accountType, accountName); |
| 117 | return bl; |
| 118 | } else { |
| 119 | throw new UnsupportedOperationException("Unknown loader id " + id); |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 120 | } |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 121 | } |
| 122 | |
| 123 | @Override |
Jeff Hamilton | db90aa8 | 2010-09-16 03:38:04 -0500 | [diff] [blame] | 124 | public void onLoadFinished(Loader<Cursor> loader, Cursor cursor) { |
John Reck | 71efc2b | 2011-05-09 16:54:28 -0700 | [diff] [blame] | 125 | if (loader.getId() == LOADER_ACCOUNTS) { |
| 126 | LoaderManager lm = getLoaderManager(); |
| 127 | int id = LOADER_BOOKMARKS; |
| 128 | while (cursor.moveToNext()) { |
| 129 | String accountName = cursor.getString(0); |
| 130 | String accountType = cursor.getString(1); |
| 131 | Bundle args = new Bundle(); |
| 132 | args.putString(ACCOUNT_NAME, accountName); |
| 133 | args.putString(ACCOUNT_TYPE, accountType); |
| 134 | BrowserBookmarksAdapter adapter = new BrowserBookmarksAdapter( |
John Reck | af991f9 | 2012-04-24 15:31:16 -0700 | [diff] [blame] | 135 | getActivity()); |
John Reck | 71efc2b | 2011-05-09 16:54:28 -0700 | [diff] [blame] | 136 | mBookmarkAdapters.put(id, adapter); |
John Reck | 4f61ee4 | 2011-08-22 16:31:14 -0700 | [diff] [blame] | 137 | boolean expand = true; |
| 138 | try { |
| 139 | expand = mState.getBoolean(accountName != null ? accountName |
| 140 | : BookmarkExpandableView.LOCAL_ACCOUNT_NAME); |
| 141 | } catch (JSONException e) {} // no state for accountName |
| 142 | mGrid.addAccount(accountName, adapter, expand); |
John Reck | 71efc2b | 2011-05-09 16:54:28 -0700 | [diff] [blame] | 143 | lm.restartLoader(id, args, this); |
| 144 | id++; |
Jeff Hamilton | db90aa8 | 2010-09-16 03:38:04 -0500 | [diff] [blame] | 145 | } |
John Reck | 71efc2b | 2011-05-09 16:54:28 -0700 | [diff] [blame] | 146 | // TODO: Figure out what a reload of these means |
| 147 | // Currently, a reload is triggered whenever bookmarks change |
| 148 | // This is less than ideal |
| 149 | // It also causes UI flickering as a new adapter is created |
| 150 | // instead of re-using an existing one when the account_name is the |
| 151 | // same. |
| 152 | // For now, this is a one-shot load |
| 153 | getLoaderManager().destroyLoader(LOADER_ACCOUNTS); |
| 154 | } else if (loader.getId() >= LOADER_BOOKMARKS) { |
| 155 | BrowserBookmarksAdapter adapter = mBookmarkAdapters.get(loader.getId()); |
| 156 | adapter.changeCursor(cursor); |
luxiaol | dbe4a62 | 2013-07-19 17:14:06 +0800 | [diff] [blame] | 157 | if (adapter.getCount() != 0) { |
| 158 | mCurrentFolderId = adapter.getItem(0).getLong(BookmarksLoader.COLUMN_INDEX_PARENT); |
| 159 | } |
Jeff Hamilton | db90aa8 | 2010-09-16 03:38:04 -0500 | [diff] [blame] | 160 | } |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 161 | } |
| 162 | |
John Reck | 522a438 | 2011-01-26 13:23:47 -0800 | [diff] [blame] | 163 | @Override |
Dianne Hackborn | 39772c8 | 2010-12-16 00:43:54 -0800 | [diff] [blame] | 164 | public void onLoaderReset(Loader<Cursor> loader) { |
John Reck | 3ad8d5c | 2012-04-23 14:50:09 -0700 | [diff] [blame] | 165 | if (loader.getId() >= LOADER_BOOKMARKS) { |
| 166 | BrowserBookmarksAdapter adapter = mBookmarkAdapters.get(loader.getId()); |
| 167 | adapter.changeCursor(null); |
| 168 | } |
Dianne Hackborn | 39772c8 | 2010-12-16 00:43:54 -0800 | [diff] [blame] | 169 | } |
| 170 | |
luxiaol | dbe4a62 | 2013-07-19 17:14:06 +0800 | [diff] [blame] | 171 | //add for carrier feature which adds new bookmark/folder function. |
| 172 | @Override |
| 173 | public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) { |
| 174 | super.onCreateOptionsMenu(menu, inflater); |
| 175 | inflater.inflate(R.menu.bookmark, menu); |
| 176 | } |
| 177 | |
| 178 | @Override |
| 179 | public boolean onOptionsItemSelected(MenuItem item) { |
| 180 | final Activity activity = getActivity(); |
| 181 | if (item.getItemId() == R.id.add_bookmark_menu_id) { |
| 182 | Intent intent = new Intent(activity, AddBookmarkPage.class); |
| 183 | intent.putExtra(BrowserContract.Bookmarks.URL, "http://"); |
| 184 | intent.putExtra(BrowserContract.Bookmarks.TITLE, ""); |
| 185 | intent.putExtra(BrowserContract.Bookmarks.PARENT, mCurrentFolderId); |
| 186 | activity.startActivity(intent); |
| 187 | } |
| 188 | if (item.getItemId() == R.id.new_bmfolder_menu_id) { |
| 189 | Intent intent = new Intent(activity, AddBookmarkFolder.class); |
| 190 | intent.putExtra(BrowserContract.Bookmarks.PARENT, mCurrentFolderId); |
| 191 | activity.startActivity(intent); |
| 192 | } |
| 193 | return super.onOptionsItemSelected(item); |
| 194 | } |
| 195 | |
The Android Open Source Project | 0c90888 | 2009-03-03 19:32:16 -0800 | [diff] [blame] | 196 | @Override |
| 197 | public boolean onContextItemSelected(MenuItem item) { |
John Reck | 54ed3aa | 2011-08-19 15:16:05 -0700 | [diff] [blame] | 198 | if (!(item.getMenuInfo() instanceof BookmarkContextMenuInfo)) { |
| 199 | return false; |
| 200 | } |
| 201 | BookmarkContextMenuInfo i = (BookmarkContextMenuInfo) item.getMenuInfo(); |
The Android Open Source Project | 0c90888 | 2009-03-03 19:32:16 -0800 | [diff] [blame] | 202 | // If we have no menu info, we can't tell which item was selected. |
| 203 | if (i == null) { |
Leon Scroggins | c8cae08 | 2010-11-03 18:51:46 -0400 | [diff] [blame] | 204 | return false; |
The Android Open Source Project | 0c90888 | 2009-03-03 19:32:16 -0800 | [diff] [blame] | 205 | } |
Nicolas Catania | 095292f | 2010-03-15 09:00:14 -0700 | [diff] [blame] | 206 | |
John Reck | e7c97de | 2011-05-27 14:42:43 -0700 | [diff] [blame] | 207 | if (handleContextItem(item.getItemId(), i.groupPosition, i.childPosition)) { |
| 208 | return true; |
| 209 | } |
| 210 | return super.onContextItemSelected(item); |
| 211 | } |
| 212 | |
| 213 | public boolean handleContextItem(int itemId, int groupPosition, |
| 214 | int childPosition) { |
| 215 | final Activity activity = getActivity(); |
| 216 | BrowserBookmarksAdapter adapter = getChildAdapter(groupPosition); |
| 217 | |
| 218 | switch (itemId) { |
The Android Open Source Project | 0c90888 | 2009-03-03 19:32:16 -0800 | [diff] [blame] | 219 | case R.id.open_context_menu_id: |
John Reck | e7c97de | 2011-05-27 14:42:43 -0700 | [diff] [blame] | 220 | loadUrl(adapter, childPosition); |
The Android Open Source Project | 0c90888 | 2009-03-03 19:32:16 -0800 | [diff] [blame] | 221 | break; |
| 222 | case R.id.edit_context_menu_id: |
John Reck | e7c97de | 2011-05-27 14:42:43 -0700 | [diff] [blame] | 223 | editBookmark(adapter, childPosition); |
The Android Open Source Project | 0c90888 | 2009-03-03 19:32:16 -0800 | [diff] [blame] | 224 | break; |
| 225 | case R.id.shortcut_context_menu_id: |
John Reck | e7c97de | 2011-05-27 14:42:43 -0700 | [diff] [blame] | 226 | Cursor c = adapter.getItem(childPosition); |
John Reck | 608baa7 | 2010-11-24 10:32:28 -0800 | [diff] [blame] | 227 | activity.sendBroadcast(createShortcutIntent(getActivity(), c)); |
The Android Open Source Project | 0c90888 | 2009-03-03 19:32:16 -0800 | [diff] [blame] | 228 | break; |
| 229 | case R.id.delete_context_menu_id: |
John Reck | e7c97de | 2011-05-27 14:42:43 -0700 | [diff] [blame] | 230 | displayRemoveBookmarkDialog(adapter, childPosition); |
The Android Open Source Project | 0c90888 | 2009-03-03 19:32:16 -0800 | [diff] [blame] | 231 | break; |
| 232 | case R.id.new_window_context_menu_id: |
John Reck | e7c97de | 2011-05-27 14:42:43 -0700 | [diff] [blame] | 233 | openInNewWindow(adapter, childPosition); |
The Android Open Source Project | 0c90888 | 2009-03-03 19:32:16 -0800 | [diff] [blame] | 234 | break; |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 235 | case R.id.share_link_context_menu_id: { |
John Reck | e7c97de | 2011-05-27 14:42:43 -0700 | [diff] [blame] | 236 | Cursor cursor = adapter.getItem(childPosition); |
Michael Kolb | 8233fac | 2010-10-26 16:08:53 -0700 | [diff] [blame] | 237 | Controller.sharePage(activity, |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 238 | cursor.getString(BookmarksLoader.COLUMN_INDEX_TITLE), |
| 239 | cursor.getString(BookmarksLoader.COLUMN_INDEX_URL), |
| 240 | getBitmap(cursor, BookmarksLoader.COLUMN_INDEX_FAVICON), |
| 241 | getBitmap(cursor, BookmarksLoader.COLUMN_INDEX_THUMBNAIL)); |
The Android Open Source Project | 0c90888 | 2009-03-03 19:32:16 -0800 | [diff] [blame] | 242 | break; |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 243 | } |
The Android Open Source Project | 0c90888 | 2009-03-03 19:32:16 -0800 | [diff] [blame] | 244 | case R.id.copy_url_context_menu_id: |
John Reck | e7c97de | 2011-05-27 14:42:43 -0700 | [diff] [blame] | 245 | copy(getUrl(adapter, childPosition)); |
Leon Scroggins | feb941d | 2009-05-28 17:27:38 -0400 | [diff] [blame] | 246 | break; |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 247 | case R.id.homepage_context_menu_id: { |
John Reck | e7c97de | 2011-05-27 14:42:43 -0700 | [diff] [blame] | 248 | BrowserSettings.getInstance().setHomePage(getUrl(adapter, childPosition)); |
Jeff Hamilton | 64144e4 | 2010-08-18 16:31:59 -0500 | [diff] [blame] | 249 | Toast.makeText(activity, R.string.homepage_set, Toast.LENGTH_LONG).show(); |
Leon Scroggins | feb941d | 2009-05-28 17:27:38 -0400 | [diff] [blame] | 250 | break; |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 251 | } |
Leon Scroggins | a5d669e | 2009-08-05 14:07:58 -0400 | [diff] [blame] | 252 | // Only for the Most visited page |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 253 | case R.id.save_to_bookmarks_menu_id: { |
John Reck | e7c97de | 2011-05-27 14:42:43 -0700 | [diff] [blame] | 254 | Cursor cursor = adapter.getItem(childPosition); |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 255 | String name = cursor.getString(BookmarksLoader.COLUMN_INDEX_TITLE); |
| 256 | String url = cursor.getString(BookmarksLoader.COLUMN_INDEX_URL); |
Leon Scroggins | a5d669e | 2009-08-05 14:07:58 -0400 | [diff] [blame] | 257 | // If the site is bookmarked, the item becomes remove from |
| 258 | // bookmarks. |
Jeff Hamilton | 64144e4 | 2010-08-18 16:31:59 -0500 | [diff] [blame] | 259 | Bookmarks.removeFromBookmarks(activity, activity.getContentResolver(), url, name); |
Leon Scroggins | a5d669e | 2009-08-05 14:07:58 -0400 | [diff] [blame] | 260 | break; |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 261 | } |
The Android Open Source Project | 0c90888 | 2009-03-03 19:32:16 -0800 | [diff] [blame] | 262 | default: |
John Reck | e7c97de | 2011-05-27 14:42:43 -0700 | [diff] [blame] | 263 | return false; |
The Android Open Source Project | 0c90888 | 2009-03-03 19:32:16 -0800 | [diff] [blame] | 264 | } |
| 265 | return true; |
| 266 | } |
| 267 | |
John Reck | 608baa7 | 2010-11-24 10:32:28 -0800 | [diff] [blame] | 268 | static Bitmap getBitmap(Cursor cursor, int columnIndex) { |
John Reck | f94abcf | 2011-10-10 15:33:48 -0700 | [diff] [blame] | 269 | return getBitmap(cursor, columnIndex, null); |
| 270 | } |
| 271 | |
| 272 | static ThreadLocal<Options> sOptions = new ThreadLocal<Options>() { |
| 273 | @Override |
| 274 | protected Options initialValue() { |
| 275 | return new Options(); |
| 276 | }; |
| 277 | }; |
| 278 | static Bitmap getBitmap(Cursor cursor, int columnIndex, Bitmap inBitmap) { |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 279 | byte[] data = cursor.getBlob(columnIndex); |
| 280 | if (data == null) { |
| 281 | return null; |
The Android Open Source Project | 0c90888 | 2009-03-03 19:32:16 -0800 | [diff] [blame] | 282 | } |
John Reck | f94abcf | 2011-10-10 15:33:48 -0700 | [diff] [blame] | 283 | Options opts = sOptions.get(); |
| 284 | opts.inBitmap = inBitmap; |
| 285 | opts.inSampleSize = 1; |
| 286 | opts.inScaled = false; |
| 287 | try { |
| 288 | return BitmapFactory.decodeByteArray(data, 0, data.length, opts); |
| 289 | } catch (IllegalArgumentException ex) { |
| 290 | // Failed to re-use bitmap, create a new one |
| 291 | return BitmapFactory.decodeByteArray(data, 0, data.length); |
| 292 | } |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 293 | } |
| 294 | |
John Reck | c849081 | 2010-11-22 14:15:36 -0800 | [diff] [blame] | 295 | private MenuItem.OnMenuItemClickListener mContextItemClickListener = |
| 296 | new MenuItem.OnMenuItemClickListener() { |
| 297 | @Override |
| 298 | public boolean onMenuItemClick(MenuItem item) { |
| 299 | return onContextItemSelected(item); |
| 300 | } |
| 301 | }; |
| 302 | |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 303 | @Override |
| 304 | public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) { |
John Reck | 71efc2b | 2011-05-09 16:54:28 -0700 | [diff] [blame] | 305 | BookmarkContextMenuInfo info = (BookmarkContextMenuInfo) menuInfo; |
| 306 | BrowserBookmarksAdapter adapter = getChildAdapter(info.groupPosition); |
| 307 | Cursor cursor = adapter.getItem(info.childPosition); |
John Reck | 1cebb44 | 2010-12-10 12:02:16 -0800 | [diff] [blame] | 308 | if (!canEdit(cursor)) { |
| 309 | return; |
| 310 | } |
Leon Scroggins | 5e8a40f | 2010-09-27 17:13:35 -0400 | [diff] [blame] | 311 | boolean isFolder |
| 312 | = cursor.getInt(BookmarksLoader.COLUMN_INDEX_IS_FOLDER) != 0; |
Michael Kolb | 801ecb7 | 2010-08-25 12:57:38 -0700 | [diff] [blame] | 313 | |
Jeff Hamilton | 64144e4 | 2010-08-18 16:31:59 -0500 | [diff] [blame] | 314 | final Activity activity = getActivity(); |
| 315 | MenuInflater inflater = activity.getMenuInflater(); |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 316 | inflater.inflate(R.menu.bookmarkscontext, menu); |
John Reck | c849081 | 2010-11-22 14:15:36 -0800 | [diff] [blame] | 317 | if (isFolder) { |
| 318 | menu.setGroupVisible(R.id.FOLDER_CONTEXT_MENU, true); |
| 319 | } else { |
| 320 | menu.setGroupVisible(R.id.BOOKMARK_CONTEXT_MENU, true); |
| 321 | if (mDisableNewWindow) { |
| 322 | menu.findItem(R.id.new_window_context_menu_id).setVisible(false); |
| 323 | } |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 324 | } |
John Reck | c849081 | 2010-11-22 14:15:36 -0800 | [diff] [blame] | 325 | BookmarkItem header = new BookmarkItem(activity); |
John Reck | 83c0151 | 2011-09-09 11:14:16 -0700 | [diff] [blame] | 326 | header.setEnableScrolling(true); |
John Reck | c849081 | 2010-11-22 14:15:36 -0800 | [diff] [blame] | 327 | populateBookmarkItem(cursor, header, isFolder); |
John Reck | c849081 | 2010-11-22 14:15:36 -0800 | [diff] [blame] | 328 | menu.setHeaderView(header); |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 329 | |
John Reck | c849081 | 2010-11-22 14:15:36 -0800 | [diff] [blame] | 330 | int count = menu.size(); |
| 331 | for (int i = 0; i < count; i++) { |
| 332 | menu.getItem(i).setOnMenuItemClickListener(mContextItemClickListener); |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 333 | } |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 334 | } |
| 335 | |
John Reck | 1cebb44 | 2010-12-10 12:02:16 -0800 | [diff] [blame] | 336 | boolean canEdit(Cursor c) { |
John Reck | d18ac4b | 2012-04-12 17:27:34 -0700 | [diff] [blame] | 337 | int type = c.getInt(BookmarksLoader.COLUMN_INDEX_TYPE); |
| 338 | return type == BrowserContract.Bookmarks.BOOKMARK_TYPE_BOOKMARK |
| 339 | || type == BrowserContract.Bookmarks.BOOKMARK_TYPE_FOLDER; |
John Reck | 1cebb44 | 2010-12-10 12:02:16 -0800 | [diff] [blame] | 340 | } |
| 341 | |
John Reck | c849081 | 2010-11-22 14:15:36 -0800 | [diff] [blame] | 342 | private void populateBookmarkItem(Cursor cursor, BookmarkItem item, boolean isFolder) { |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 343 | item.setName(cursor.getString(BookmarksLoader.COLUMN_INDEX_TITLE)); |
John Reck | c849081 | 2010-11-22 14:15:36 -0800 | [diff] [blame] | 344 | if (isFolder) { |
| 345 | item.setUrl(null); |
| 346 | Bitmap bitmap = |
Michael Kolb | 5a72f18 | 2011-01-13 20:35:06 -0800 | [diff] [blame] | 347 | BitmapFactory.decodeResource(getResources(), R.drawable.ic_folder_holo_dark); |
John Reck | c849081 | 2010-11-22 14:15:36 -0800 | [diff] [blame] | 348 | item.setFavicon(bitmap); |
John Reck | 60e3336 | 2010-12-02 17:52:38 -0800 | [diff] [blame] | 349 | new LookupBookmarkCount(getActivity(), item) |
| 350 | .execute(cursor.getLong(BookmarksLoader.COLUMN_INDEX_ID)); |
John Reck | c849081 | 2010-11-22 14:15:36 -0800 | [diff] [blame] | 351 | } else { |
| 352 | String url = cursor.getString(BookmarksLoader.COLUMN_INDEX_URL); |
| 353 | item.setUrl(url); |
| 354 | Bitmap bitmap = getBitmap(cursor, BookmarksLoader.COLUMN_INDEX_FAVICON); |
John Reck | c849081 | 2010-11-22 14:15:36 -0800 | [diff] [blame] | 355 | item.setFavicon(bitmap); |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 356 | } |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 357 | } |
The Android Open Source Project | 0c90888 | 2009-03-03 19:32:16 -0800 | [diff] [blame] | 358 | |
| 359 | /** |
| 360 | * Create a new BrowserBookmarksPage. |
Nicolas Catania | 095292f | 2010-03-15 09:00:14 -0700 | [diff] [blame] | 361 | */ |
The Android Open Source Project | 0c90888 | 2009-03-03 19:32:16 -0800 | [diff] [blame] | 362 | @Override |
Jeff Hamilton | 64144e4 | 2010-08-18 16:31:59 -0500 | [diff] [blame] | 363 | public void onCreate(Bundle icicle) { |
The Android Open Source Project | 0c90888 | 2009-03-03 19:32:16 -0800 | [diff] [blame] | 364 | super.onCreate(icicle); |
John Reck | 4f61ee4 | 2011-08-22 16:31:14 -0700 | [diff] [blame] | 365 | SharedPreferences prefs = BrowserSettings.getInstance().getPreferences(); |
| 366 | try { |
| 367 | mState = new JSONObject(prefs.getString(PREF_GROUP_STATE, "{}")); |
| 368 | } catch (JSONException e) { |
| 369 | // Parse failed, clear preference and start with empty state |
| 370 | prefs.edit().remove(PREF_GROUP_STATE).apply(); |
| 371 | mState = new JSONObject(); |
| 372 | } |
Jeff Hamilton | 64144e4 | 2010-08-18 16:31:59 -0500 | [diff] [blame] | 373 | Bundle args = getArguments(); |
Leon Scroggins | bc92285 | 2010-10-22 12:15:27 -0400 | [diff] [blame] | 374 | mDisableNewWindow = args == null ? false : args.getBoolean(EXTRA_DISABLE_WINDOW, false); |
John Reck | 8f295d1 | 2011-03-18 15:25:18 -0700 | [diff] [blame] | 375 | setHasOptionsMenu(true); |
John Reck | 2d963a2 | 2011-08-10 15:53:07 -0700 | [diff] [blame] | 376 | if (mCallbacks == null && getActivity() instanceof CombinedBookmarksCallbacks) { |
| 377 | mCallbacks = new CombinedBookmarksCallbackWrapper( |
| 378 | (CombinedBookmarksCallbacks) getActivity()); |
| 379 | } |
Jeff Hamilton | 64144e4 | 2010-08-18 16:31:59 -0500 | [diff] [blame] | 380 | } |
Leon Scroggins | d87f85e | 2009-08-18 14:13:31 -0400 | [diff] [blame] | 381 | |
John Reck | 4f61ee4 | 2011-08-22 16:31:14 -0700 | [diff] [blame] | 382 | @Override |
| 383 | public void onPause() { |
| 384 | super.onPause(); |
| 385 | try { |
| 386 | mState = mGrid.saveGroupState(); |
| 387 | // Save state |
| 388 | SharedPreferences prefs = BrowserSettings.getInstance().getPreferences(); |
| 389 | prefs.edit() |
| 390 | .putString(PREF_GROUP_STATE, mState.toString()) |
| 391 | .apply(); |
| 392 | } catch (JSONException e) { |
| 393 | // Not critical, ignore |
| 394 | } |
| 395 | } |
| 396 | |
John Reck | 2d963a2 | 2011-08-10 15:53:07 -0700 | [diff] [blame] | 397 | private static class CombinedBookmarksCallbackWrapper |
| 398 | implements BookmarksPageCallbacks { |
| 399 | |
| 400 | private CombinedBookmarksCallbacks mCombinedCallback; |
| 401 | |
| 402 | private CombinedBookmarksCallbackWrapper(CombinedBookmarksCallbacks cb) { |
| 403 | mCombinedCallback = cb; |
| 404 | } |
| 405 | |
| 406 | @Override |
| 407 | public boolean onOpenInNewWindow(String... urls) { |
| 408 | mCombinedCallback.openInNewTab(urls); |
| 409 | return true; |
| 410 | } |
| 411 | |
| 412 | @Override |
| 413 | public boolean onBookmarkSelected(Cursor c, boolean isFolder) { |
| 414 | if (isFolder) { |
| 415 | return false; |
| 416 | } |
| 417 | mCombinedCallback.openUrl(BrowserBookmarksPage.getUrl(c)); |
| 418 | return true; |
| 419 | } |
| 420 | }; |
| 421 | |
Jeff Hamilton | 64144e4 | 2010-08-18 16:31:59 -0500 | [diff] [blame] | 422 | @Override |
Jeff Hamilton | 64144e4 | 2010-08-18 16:31:59 -0500 | [diff] [blame] | 423 | public View onCreateView(LayoutInflater inflater, ViewGroup container, |
| 424 | Bundle savedInstanceState) { |
John Reck | 0ce8a94 | 2011-01-14 19:57:09 -0800 | [diff] [blame] | 425 | mRoot = inflater.inflate(R.layout.bookmarks, container, false); |
| 426 | mEmptyView = mRoot.findViewById(android.R.id.empty); |
Leon Scroggins | d87f85e | 2009-08-18 14:13:31 -0400 | [diff] [blame] | 427 | |
John Reck | 9db9529 | 2011-06-20 13:00:12 -0700 | [diff] [blame] | 428 | mGrid = (BookmarkExpandableView) mRoot.findViewById(R.id.grid); |
John Reck | 71efc2b | 2011-05-09 16:54:28 -0700 | [diff] [blame] | 429 | mGrid.setOnChildClickListener(this); |
| 430 | mGrid.setColumnWidthFromLayout(R.layout.bookmark_thumbnail); |
| 431 | mGrid.setBreadcrumbController(this); |
John Reck | 608baa7 | 2010-11-24 10:32:28 -0800 | [diff] [blame] | 432 | setEnableContextMenu(mEnableContextMenu); |
| 433 | |
Jeff Hamilton | db90aa8 | 2010-09-16 03:38:04 -0500 | [diff] [blame] | 434 | // Start the loaders |
| 435 | LoaderManager lm = getLoaderManager(); |
John Reck | 71efc2b | 2011-05-09 16:54:28 -0700 | [diff] [blame] | 436 | lm.restartLoader(LOADER_ACCOUNTS, null, this); |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 437 | |
John Reck | 0ce8a94 | 2011-01-14 19:57:09 -0800 | [diff] [blame] | 438 | return mRoot; |
Jeff Hamilton | 64144e4 | 2010-08-18 16:31:59 -0500 | [diff] [blame] | 439 | } |
Michael Kolb | 801ecb7 | 2010-08-25 12:57:38 -0700 | [diff] [blame] | 440 | |
John Reck | 608baa7 | 2010-11-24 10:32:28 -0800 | [diff] [blame] | 441 | @Override |
| 442 | public void onDestroyView() { |
| 443 | super.onDestroyView(); |
John Reck | 71efc2b | 2011-05-09 16:54:28 -0700 | [diff] [blame] | 444 | mGrid.setBreadcrumbController(null); |
John Reck | c3c46d7 | 2011-09-06 16:17:34 -0700 | [diff] [blame] | 445 | mGrid.clearAccounts(); |
John Reck | 71efc2b | 2011-05-09 16:54:28 -0700 | [diff] [blame] | 446 | LoaderManager lm = getLoaderManager(); |
| 447 | lm.destroyLoader(LOADER_ACCOUNTS); |
| 448 | for (int id : mBookmarkAdapters.keySet()) { |
Tarun Nainani | ebdf18e | 2014-07-09 19:35:30 -0700 | [diff] [blame] | 449 | mBookmarkAdapters.get(id).quitThread(); |
John Reck | 71efc2b | 2011-05-09 16:54:28 -0700 | [diff] [blame] | 450 | lm.destroyLoader(id); |
John Reck | 608baa7 | 2010-11-24 10:32:28 -0800 | [diff] [blame] | 451 | } |
John Reck | 71efc2b | 2011-05-09 16:54:28 -0700 | [diff] [blame] | 452 | mBookmarkAdapters.clear(); |
John Reck | 71efc2b | 2011-05-09 16:54:28 -0700 | [diff] [blame] | 453 | } |
| 454 | |
| 455 | private BrowserBookmarksAdapter getChildAdapter(int groupPosition) { |
John Reck | 9db9529 | 2011-06-20 13:00:12 -0700 | [diff] [blame] | 456 | return mGrid.getChildAdapter(groupPosition); |
John Reck | 71efc2b | 2011-05-09 16:54:28 -0700 | [diff] [blame] | 457 | } |
| 458 | |
| 459 | private BreadCrumbView getBreadCrumbs(int groupPosition) { |
John Reck | 9db9529 | 2011-06-20 13:00:12 -0700 | [diff] [blame] | 460 | return mGrid.getBreadCrumbs(groupPosition); |
Nicolas Catania | 095292f | 2010-03-15 09:00:14 -0700 | [diff] [blame] | 461 | } |
| 462 | |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 463 | @Override |
John Reck | 71efc2b | 2011-05-09 16:54:28 -0700 | [diff] [blame] | 464 | public boolean onChildClick(ExpandableListView parent, View v, |
| 465 | int groupPosition, int childPosition, long id) { |
| 466 | BrowserBookmarksAdapter adapter = getChildAdapter(groupPosition); |
| 467 | Cursor cursor = adapter.getItem(childPosition); |
John Reck | 608baa7 | 2010-11-24 10:32:28 -0800 | [diff] [blame] | 468 | boolean isFolder = cursor.getInt(BookmarksLoader.COLUMN_INDEX_IS_FOLDER) != 0; |
| 469 | if (mCallbacks != null && |
| 470 | mCallbacks.onBookmarkSelected(cursor, isFolder)) { |
John Reck | 71efc2b | 2011-05-09 16:54:28 -0700 | [diff] [blame] | 471 | return true; |
Ben Murdoch | 328ea87 | 2009-09-16 13:33:29 +0100 | [diff] [blame] | 472 | } |
| 473 | |
John Reck | 608baa7 | 2010-11-24 10:32:28 -0800 | [diff] [blame] | 474 | if (isFolder) { |
Michael Kolb | 370a4f3 | 2010-10-06 10:45:32 -0700 | [diff] [blame] | 475 | String title = cursor.getString(BookmarksLoader.COLUMN_INDEX_TITLE); |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 476 | Uri uri = ContentUris.withAppendedId( |
| 477 | BrowserContract.Bookmarks.CONTENT_URI_DEFAULT_FOLDER, id); |
John Reck | 71efc2b | 2011-05-09 16:54:28 -0700 | [diff] [blame] | 478 | BreadCrumbView crumbs = getBreadCrumbs(groupPosition); |
| 479 | if (crumbs != null) { |
Michael Kolb | 370a4f3 | 2010-10-06 10:45:32 -0700 | [diff] [blame] | 480 | // update crumbs |
John Reck | 71efc2b | 2011-05-09 16:54:28 -0700 | [diff] [blame] | 481 | crumbs.pushView(title, uri); |
John Reck | cece1fe | 2011-09-13 08:47:17 -0700 | [diff] [blame] | 482 | crumbs.setVisibility(View.VISIBLE); |
luxiaol | dbe4a62 | 2013-07-19 17:14:06 +0800 | [diff] [blame] | 483 | Object data = crumbs.getTopData(); |
| 484 | mCurrentFolderId = (data != null ? ContentUris.parseId((Uri) data) |
| 485 | : DEFAULT_FOLDER_ID); |
Michael Kolb | 370a4f3 | 2010-10-06 10:45:32 -0700 | [diff] [blame] | 486 | } |
John Reck | 71efc2b | 2011-05-09 16:54:28 -0700 | [diff] [blame] | 487 | loadFolder(groupPosition, uri); |
Leon Scroggins | a5d669e | 2009-08-05 14:07:58 -0400 | [diff] [blame] | 488 | } |
John Reck | 71efc2b | 2011-05-09 16:54:28 -0700 | [diff] [blame] | 489 | return true; |
The Android Open Source Project | 0c90888 | 2009-03-03 19:32:16 -0800 | [diff] [blame] | 490 | } |
| 491 | |
John Reck | 608baa7 | 2010-11-24 10:32:28 -0800 | [diff] [blame] | 492 | /* package */ static Intent createShortcutIntent(Context context, Cursor cursor) { |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 493 | String url = cursor.getString(BookmarksLoader.COLUMN_INDEX_URL); |
Michael Kolb | ccaa896 | 2010-10-20 17:03:10 -0700 | [diff] [blame] | 494 | String title = cursor.getString(BookmarksLoader.COLUMN_INDEX_TITLE); |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 495 | Bitmap touchIcon = getBitmap(cursor, BookmarksLoader.COLUMN_INDEX_TOUCH_ICON); |
| 496 | Bitmap favicon = getBitmap(cursor, BookmarksLoader.COLUMN_INDEX_FAVICON); |
John Reck | 608baa7 | 2010-11-24 10:32:28 -0800 | [diff] [blame] | 497 | return BookmarkUtils.createAddToHomeIntent(context, url, title, touchIcon, favicon); |
The Android Open Source Project | 0c90888 | 2009-03-03 19:32:16 -0800 | [diff] [blame] | 498 | } |
| 499 | |
John Reck | 71efc2b | 2011-05-09 16:54:28 -0700 | [diff] [blame] | 500 | private void loadUrl(BrowserBookmarksAdapter adapter, int position) { |
| 501 | if (mCallbacks != null && adapter != null) { |
| 502 | mCallbacks.onBookmarkSelected(adapter.getItem(position), false); |
John Reck | 608baa7 | 2010-11-24 10:32:28 -0800 | [diff] [blame] | 503 | } |
The Android Open Source Project | 0c90888 | 2009-03-03 19:32:16 -0800 | [diff] [blame] | 504 | } |
| 505 | |
John Reck | 71efc2b | 2011-05-09 16:54:28 -0700 | [diff] [blame] | 506 | private void openInNewWindow(BrowserBookmarksAdapter adapter, int position) { |
John Reck | 608baa7 | 2010-11-24 10:32:28 -0800 | [diff] [blame] | 507 | if (mCallbacks != null) { |
John Reck | 71efc2b | 2011-05-09 16:54:28 -0700 | [diff] [blame] | 508 | Cursor c = adapter.getItem(position); |
John Reck | 1b3c66e | 2011-01-11 13:20:32 -0800 | [diff] [blame] | 509 | boolean isFolder = c.getInt(BookmarksLoader.COLUMN_INDEX_IS_FOLDER) == 1; |
| 510 | if (isFolder) { |
| 511 | long id = c.getLong(BookmarksLoader.COLUMN_INDEX_ID); |
| 512 | new OpenAllInTabsTask(id).execute(); |
| 513 | } else { |
John Reck | d3e4d5b | 2011-07-13 15:48:43 -0700 | [diff] [blame] | 514 | mCallbacks.onOpenInNewWindow(BrowserBookmarksPage.getUrl(c)); |
John Reck | 1b3c66e | 2011-01-11 13:20:32 -0800 | [diff] [blame] | 515 | } |
John Reck | 608baa7 | 2010-11-24 10:32:28 -0800 | [diff] [blame] | 516 | } |
The Android Open Source Project | 0c90888 | 2009-03-03 19:32:16 -0800 | [diff] [blame] | 517 | } |
Nicolas Catania | 095292f | 2010-03-15 09:00:14 -0700 | [diff] [blame] | 518 | |
John Reck | 1b3c66e | 2011-01-11 13:20:32 -0800 | [diff] [blame] | 519 | class OpenAllInTabsTask extends AsyncTask<Void, Void, Cursor> { |
| 520 | long mFolderId; |
| 521 | public OpenAllInTabsTask(long id) { |
| 522 | mFolderId = id; |
| 523 | } |
| 524 | |
| 525 | @Override |
| 526 | protected Cursor doInBackground(Void... params) { |
| 527 | Context c = getActivity(); |
| 528 | if (c == null) return null; |
| 529 | return c.getContentResolver().query(BookmarkUtils.getBookmarksUri(c), |
| 530 | BookmarksLoader.PROJECTION, BrowserContract.Bookmarks.PARENT + "=?", |
| 531 | new String[] { Long.toString(mFolderId) }, null); |
| 532 | } |
| 533 | |
| 534 | @Override |
| 535 | protected void onPostExecute(Cursor result) { |
John Reck | d3e4d5b | 2011-07-13 15:48:43 -0700 | [diff] [blame] | 536 | if (mCallbacks != null && result.getCount() > 0) { |
| 537 | String[] urls = new String[result.getCount()]; |
| 538 | int i = 0; |
John Reck | 1b3c66e | 2011-01-11 13:20:32 -0800 | [diff] [blame] | 539 | while (result.moveToNext()) { |
John Reck | d3e4d5b | 2011-07-13 15:48:43 -0700 | [diff] [blame] | 540 | urls[i++] = BrowserBookmarksPage.getUrl(result); |
John Reck | 1b3c66e | 2011-01-11 13:20:32 -0800 | [diff] [blame] | 541 | } |
John Reck | d3e4d5b | 2011-07-13 15:48:43 -0700 | [diff] [blame] | 542 | mCallbacks.onOpenInNewWindow(urls); |
John Reck | 1b3c66e | 2011-01-11 13:20:32 -0800 | [diff] [blame] | 543 | } |
| 544 | } |
| 545 | |
| 546 | } |
| 547 | |
John Reck | 71efc2b | 2011-05-09 16:54:28 -0700 | [diff] [blame] | 548 | private void editBookmark(BrowserBookmarksAdapter adapter, int position) { |
Jeff Hamilton | 64144e4 | 2010-08-18 16:31:59 -0500 | [diff] [blame] | 549 | Intent intent = new Intent(getActivity(), AddBookmarkPage.class); |
John Reck | 71efc2b | 2011-05-09 16:54:28 -0700 | [diff] [blame] | 550 | Cursor cursor = adapter.getItem(position); |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 551 | Bundle item = new Bundle(); |
Michael Kolb | bef7a75 | 2010-08-25 17:11:35 -0700 | [diff] [blame] | 552 | item.putString(BrowserContract.Bookmarks.TITLE, |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 553 | cursor.getString(BookmarksLoader.COLUMN_INDEX_TITLE)); |
Michael Kolb | bef7a75 | 2010-08-25 17:11:35 -0700 | [diff] [blame] | 554 | item.putString(BrowserContract.Bookmarks.URL, |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 555 | cursor.getString(BookmarksLoader.COLUMN_INDEX_URL)); |
| 556 | byte[] data = cursor.getBlob(BookmarksLoader.COLUMN_INDEX_FAVICON); |
| 557 | if (data != null) { |
Michael Kolb | bef7a75 | 2010-08-25 17:11:35 -0700 | [diff] [blame] | 558 | item.putParcelable(BrowserContract.Bookmarks.FAVICON, |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 559 | BitmapFactory.decodeByteArray(data, 0, data.length)); |
| 560 | } |
John Reck | c849081 | 2010-11-22 14:15:36 -0800 | [diff] [blame] | 561 | item.putLong(BrowserContract.Bookmarks._ID, |
| 562 | cursor.getLong(BookmarksLoader.COLUMN_INDEX_ID)); |
Leon Scroggins III | 052ce66 | 2010-09-13 14:44:16 -0400 | [diff] [blame] | 563 | item.putLong(BrowserContract.Bookmarks.PARENT, |
| 564 | cursor.getLong(BookmarksLoader.COLUMN_INDEX_PARENT)); |
John Reck | c849081 | 2010-11-22 14:15:36 -0800 | [diff] [blame] | 565 | intent.putExtra(AddBookmarkPage.EXTRA_EDIT_BOOKMARK, item); |
| 566 | intent.putExtra(AddBookmarkPage.EXTRA_IS_FOLDER, |
| 567 | cursor.getInt(BookmarksLoader.COLUMN_INDEX_IS_FOLDER) == 1); |
| 568 | startActivity(intent); |
Jeff Hamilton | 8402962 | 2010-08-05 14:29:28 -0500 | [diff] [blame] | 569 | } |
| 570 | |
John Reck | 71efc2b | 2011-05-09 16:54:28 -0700 | [diff] [blame] | 571 | private void displayRemoveBookmarkDialog(BrowserBookmarksAdapter adapter, |
| 572 | int position) { |
The Android Open Source Project | 0c90888 | 2009-03-03 19:32:16 -0800 | [diff] [blame] | 573 | // Put up a dialog asking if the user really wants to |
| 574 | // delete the bookmark |
John Reck | 71efc2b | 2011-05-09 16:54:28 -0700 | [diff] [blame] | 575 | Cursor cursor = adapter.getItem(position); |
Leon Scroggins | 7563067 | 2011-01-13 17:56:15 -0500 | [diff] [blame] | 576 | long id = cursor.getLong(BookmarksLoader.COLUMN_INDEX_ID); |
| 577 | String title = cursor.getString(BookmarksLoader.COLUMN_INDEX_TITLE); |
Jeff Hamilton | 64144e4 | 2010-08-18 16:31:59 -0500 | [diff] [blame] | 578 | Context context = getActivity(); |
Leon Scroggins | 7563067 | 2011-01-13 17:56:15 -0500 | [diff] [blame] | 579 | BookmarkUtils.displayRemoveBookmarkDialog(id, title, context, null); |
The Android Open Source Project | 0c90888 | 2009-03-03 19:32:16 -0800 | [diff] [blame] | 580 | } |
| 581 | |
John Reck | 71efc2b | 2011-05-09 16:54:28 -0700 | [diff] [blame] | 582 | private String getUrl(BrowserBookmarksAdapter adapter, int position) { |
| 583 | return getUrl(adapter.getItem(position)); |
John Reck | 608baa7 | 2010-11-24 10:32:28 -0800 | [diff] [blame] | 584 | } |
| 585 | |
| 586 | /* package */ static String getUrl(Cursor c) { |
| 587 | return c.getString(BookmarksLoader.COLUMN_INDEX_URL); |
The Android Open Source Project | 0c90888 | 2009-03-03 19:32:16 -0800 | [diff] [blame] | 588 | } |
Michael Kolb | 801ecb7 | 2010-08-25 12:57:38 -0700 | [diff] [blame] | 589 | |
The Android Open Source Project | 0c90888 | 2009-03-03 19:32:16 -0800 | [diff] [blame] | 590 | private void copy(CharSequence text) { |
Jeff Hamilton | 64144e4 | 2010-08-18 16:31:59 -0500 | [diff] [blame] | 591 | ClipboardManager cm = (ClipboardManager) getActivity().getSystemService( |
| 592 | Context.CLIPBOARD_SERVICE); |
Dianne Hackborn | bf1d10a | 2011-01-17 12:29:51 -0800 | [diff] [blame] | 593 | cm.setPrimaryClip(ClipData.newRawUri(null, Uri.parse(text.toString()))); |
The Android Open Source Project | 0c90888 | 2009-03-03 19:32:16 -0800 | [diff] [blame] | 594 | } |
Michael Kolb | 370a4f3 | 2010-10-06 10:45:32 -0700 | [diff] [blame] | 595 | |
John Reck | b3417f0 | 2011-01-14 11:01:05 -0800 | [diff] [blame] | 596 | @Override |
John Reck | b3417f0 | 2011-01-14 11:01:05 -0800 | [diff] [blame] | 597 | public void onConfigurationChanged(Configuration newConfig) { |
| 598 | super.onConfigurationChanged(newConfig); |
| 599 | Resources res = getActivity().getResources(); |
John Reck | 71efc2b | 2011-05-09 16:54:28 -0700 | [diff] [blame] | 600 | mGrid.setColumnWidthFromLayout(R.layout.bookmark_thumbnail); |
John Reck | 0ce8a94 | 2011-01-14 19:57:09 -0800 | [diff] [blame] | 601 | int paddingTop = (int) res.getDimension(R.dimen.combo_paddingTop); |
John Reck | f3828cd | 2011-06-14 17:21:55 -0700 | [diff] [blame] | 602 | mRoot.setPadding(0, paddingTop, 0, 0); |
John Reck | 9fdd981 | 2011-05-17 14:16:38 -0700 | [diff] [blame] | 603 | getActivity().invalidateOptionsMenu(); |
John Reck | b3417f0 | 2011-01-14 11:01:05 -0800 | [diff] [blame] | 604 | } |
| 605 | |
John Reck | 608baa7 | 2010-11-24 10:32:28 -0800 | [diff] [blame] | 606 | /** |
| 607 | * BreadCrumb controller callback |
| 608 | */ |
| 609 | @Override |
John Reck | 71efc2b | 2011-05-09 16:54:28 -0700 | [diff] [blame] | 610 | public void onTop(BreadCrumbView view, int level, Object data) { |
| 611 | int groupPosition = (Integer) view.getTag(R.id.group_position); |
John Reck | 89f73c1 | 2010-12-01 10:10:14 -0800 | [diff] [blame] | 612 | Uri uri = (Uri) data; |
| 613 | if (uri == null) { |
| 614 | // top level |
| 615 | uri = BrowserContract.Bookmarks.CONTENT_URI_DEFAULT_FOLDER; |
| 616 | } |
John Reck | 71efc2b | 2011-05-09 16:54:28 -0700 | [diff] [blame] | 617 | loadFolder(groupPosition, uri); |
John Reck | cece1fe | 2011-09-13 08:47:17 -0700 | [diff] [blame] | 618 | if (level <= 1) { |
| 619 | view.setVisibility(View.GONE); |
| 620 | } else { |
| 621 | view.setVisibility(View.VISIBLE); |
| 622 | } |
John Reck | 89f73c1 | 2010-12-01 10:10:14 -0800 | [diff] [blame] | 623 | } |
| 624 | |
| 625 | /** |
| 626 | * @param uri |
| 627 | */ |
John Reck | 71efc2b | 2011-05-09 16:54:28 -0700 | [diff] [blame] | 628 | private void loadFolder(int groupPosition, Uri uri) { |
John Reck | 89f73c1 | 2010-12-01 10:10:14 -0800 | [diff] [blame] | 629 | LoaderManager manager = getLoaderManager(); |
John Reck | 71efc2b | 2011-05-09 16:54:28 -0700 | [diff] [blame] | 630 | // This assumes groups are ordered the same as loaders |
| 631 | BookmarksLoader loader = (BookmarksLoader) ((Loader<?>) |
| 632 | manager.getLoader(LOADER_BOOKMARKS + groupPosition)); |
John Reck | 89f73c1 | 2010-12-01 10:10:14 -0800 | [diff] [blame] | 633 | loader.setUri(uri); |
| 634 | loader.forceLoad(); |
John Reck | 608baa7 | 2010-11-24 10:32:28 -0800 | [diff] [blame] | 635 | } |
| 636 | |
John Reck | 608baa7 | 2010-11-24 10:32:28 -0800 | [diff] [blame] | 637 | public void setCallbackListener(BookmarksPageCallbacks callbackListener) { |
| 638 | mCallbacks = callbackListener; |
| 639 | } |
| 640 | |
| 641 | public void setEnableContextMenu(boolean enable) { |
| 642 | mEnableContextMenu = enable; |
| 643 | if (mGrid != null) { |
| 644 | if (mEnableContextMenu) { |
| 645 | registerForContextMenu(mGrid); |
| 646 | } else { |
| 647 | unregisterForContextMenu(mGrid); |
| 648 | mGrid.setLongClickable(false); |
| 649 | } |
| 650 | } |
John Reck | 608baa7 | 2010-11-24 10:32:28 -0800 | [diff] [blame] | 651 | } |
John Reck | c849081 | 2010-11-22 14:15:36 -0800 | [diff] [blame] | 652 | |
| 653 | private static class LookupBookmarkCount extends AsyncTask<Long, Void, Integer> { |
| 654 | Context mContext; |
| 655 | BookmarkItem mHeader; |
| 656 | |
| 657 | public LookupBookmarkCount(Context context, BookmarkItem header) { |
Ben Murdoch | 914c559 | 2011-08-01 13:58:47 +0100 | [diff] [blame] | 658 | mContext = context.getApplicationContext(); |
John Reck | c849081 | 2010-11-22 14:15:36 -0800 | [diff] [blame] | 659 | mHeader = header; |
| 660 | } |
| 661 | |
| 662 | @Override |
| 663 | protected Integer doInBackground(Long... params) { |
| 664 | if (params.length != 1) { |
| 665 | throw new IllegalArgumentException("Missing folder id!"); |
| 666 | } |
| 667 | Uri uri = BookmarkUtils.getBookmarksUri(mContext); |
| 668 | Cursor c = mContext.getContentResolver().query(uri, |
| 669 | null, BrowserContract.Bookmarks.PARENT + "=?", |
| 670 | new String[] {params[0].toString()}, null); |
| 671 | return c.getCount(); |
| 672 | } |
| 673 | |
| 674 | @Override |
| 675 | protected void onPostExecute(Integer result) { |
| 676 | if (result > 0) { |
| 677 | mHeader.setUrl(mContext.getString(R.string.contextheader_folder_bookmarkcount, |
| 678 | result)); |
| 679 | } else if (result == 0) { |
| 680 | mHeader.setUrl(mContext.getString(R.string.contextheader_folder_empty)); |
| 681 | } |
| 682 | } |
| 683 | } |
John Reck | 89f73c1 | 2010-12-01 10:10:14 -0800 | [diff] [blame] | 684 | |
John Reck | 71efc2b | 2011-05-09 16:54:28 -0700 | [diff] [blame] | 685 | static class AccountsLoader extends CursorLoader { |
John Reck | 89f73c1 | 2010-12-01 10:10:14 -0800 | [diff] [blame] | 686 | |
John Reck | 71efc2b | 2011-05-09 16:54:28 -0700 | [diff] [blame] | 687 | static String[] ACCOUNTS_PROJECTION = new String[] { |
| 688 | Accounts.ACCOUNT_NAME, |
| 689 | Accounts.ACCOUNT_TYPE |
| 690 | }; |
John Reck | 89f73c1 | 2010-12-01 10:10:14 -0800 | [diff] [blame] | 691 | |
John Reck | 71efc2b | 2011-05-09 16:54:28 -0700 | [diff] [blame] | 692 | public AccountsLoader(Context context) { |
John Reck | 1e9815d | 2011-08-08 17:45:05 -0700 | [diff] [blame] | 693 | super(context, Accounts.CONTENT_URI |
| 694 | .buildUpon() |
| 695 | .appendQueryParameter(BrowserProvider2.PARAM_ALLOW_EMPTY_ACCOUNTS, "false") |
| 696 | .build(), |
| 697 | ACCOUNTS_PROJECTION, null, null, null); |
John Reck | 89f73c1 | 2010-12-01 10:10:14 -0800 | [diff] [blame] | 698 | } |
John Reck | 522a438 | 2011-01-26 13:23:47 -0800 | [diff] [blame] | 699 | |
John Reck | 522a438 | 2011-01-26 13:23:47 -0800 | [diff] [blame] | 700 | } |
The Android Open Source Project | 0c90888 | 2009-03-03 19:32:16 -0800 | [diff] [blame] | 701 | } |