| /* |
| * 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; |
| |
| import com.android.browser.addbookmark.FolderSpinner; |
| import com.android.browser.addbookmark.FolderSpinnerAdapter; |
| |
| import android.app.Activity; |
| import android.app.LoaderManager; |
| import android.app.LoaderManager.LoaderCallbacks; |
| import android.content.AsyncTaskLoader; |
| import android.content.ContentResolver; |
| import android.content.ContentUris; |
| import android.content.ContentValues; |
| import android.content.Context; |
| import android.content.CursorLoader; |
| import android.content.Loader; |
| import android.content.res.Resources; |
| import android.database.Cursor; |
| import android.graphics.Bitmap; |
| import android.graphics.drawable.Drawable; |
| import android.net.ParseException; |
| import android.net.Uri; |
| import android.net.WebAddress; |
| import android.os.AsyncTask; |
| import android.os.Bundle; |
| import android.os.Handler; |
| import android.os.Message; |
| import android.provider.BrowserContract; |
| import android.provider.BrowserContract.Accounts; |
| import android.text.TextUtils; |
| import android.util.AttributeSet; |
| import android.view.KeyEvent; |
| import android.view.LayoutInflater; |
| import android.view.View; |
| import android.view.ViewGroup; |
| import android.view.Window; |
| import android.view.WindowManager; |
| import android.view.inputmethod.EditorInfo; |
| import android.view.inputmethod.InputMethodManager; |
| import android.widget.AdapterView; |
| import android.widget.AdapterView.OnItemSelectedListener; |
| import android.widget.ArrayAdapter; |
| import android.widget.CursorAdapter; |
| import android.widget.EditText; |
| import android.widget.ListView; |
| import android.widget.Spinner; |
| import android.widget.TextView; |
| import android.widget.Toast; |
| |
| import java.net.URI; |
| import java.net.URISyntaxException; |
| |
| public class AddBookmarkPage extends Activity |
| implements View.OnClickListener, TextView.OnEditorActionListener, |
| AdapterView.OnItemClickListener, LoaderManager.LoaderCallbacks<Cursor>, |
| BreadCrumbView.Controller, FolderSpinner.OnSetSelectionListener, |
| OnItemSelectedListener { |
| |
| public static final long DEFAULT_FOLDER_ID = -1; |
| public static final String TOUCH_ICON_URL = "touch_icon_url"; |
| // Place on an edited bookmark to remove the saved thumbnail |
| public static final String REMOVE_THUMBNAIL = "remove_thumbnail"; |
| public static final String USER_AGENT = "user_agent"; |
| public static final String CHECK_FOR_DUPE = "check_for_dupe"; |
| |
| /* package */ static final String EXTRA_EDIT_BOOKMARK = "bookmark"; |
| /* package */ static final String EXTRA_IS_FOLDER = "is_folder"; |
| |
| private static final int MAX_CRUMBS_SHOWN = 2; |
| |
| private final String LOGTAG = "Bookmarks"; |
| |
| // IDs for the CursorLoaders that are used. |
| private final int LOADER_ID_ACCOUNTS = 0; |
| private final int LOADER_ID_FOLDER_CONTENTS = 1; |
| private final int LOADER_ID_EDIT_INFO = 2; |
| |
| private EditText mTitle; |
| private EditText mAddress; |
| private TextView mButton; |
| private View mCancelButton; |
| private boolean mEditingExisting; |
| private boolean mEditingFolder; |
| private Bundle mMap; |
| private String mTouchIconUrl; |
| private String mOriginalUrl; |
| private FolderSpinner mFolder; |
| private View mDefaultView; |
| private View mFolderSelector; |
| private EditText mFolderNamer; |
| private View mFolderCancel; |
| private boolean mIsFolderNamerShowing; |
| private View mFolderNamerHolder; |
| private View mAddNewFolder; |
| private View mAddSeparator; |
| private long mCurrentFolder; |
| private FolderAdapter mAdapter; |
| private BreadCrumbView mCrumbs; |
| private TextView mFakeTitle; |
| private View mCrumbHolder; |
| private CustomListView mListView; |
| private boolean mSaveToHomeScreen; |
| private long mRootFolder; |
| private TextView mTopLevelLabel; |
| private Drawable mHeaderIcon; |
| private View mRemoveLink; |
| private View mFakeTitleHolder; |
| private FolderSpinnerAdapter mFolderAdapter; |
| private Spinner mAccountSpinner; |
| private ArrayAdapter<BookmarkAccount> mAccountAdapter; |
| |
| private static class Folder { |
| String Name; |
| long Id; |
| Folder(String name, long id) { |
| Name = name; |
| Id = id; |
| } |
| } |
| |
| // Message IDs |
| private static final int SAVE_BOOKMARK = 100; |
| private static final int TOUCH_ICON_DOWNLOADED = 101; |
| private static final int BOOKMARK_DELETED = 102; |
| |
| private Handler mHandler; |
| |
| private InputMethodManager getInputMethodManager() { |
| return (InputMethodManager) getSystemService(INPUT_METHOD_SERVICE); |
| } |
| |
| private Uri getUriForFolder(long folder) { |
| BookmarkAccount account = |
| (BookmarkAccount) mAccountSpinner.getSelectedItem(); |
| if (folder == mRootFolder && account != null) { |
| return BookmarksLoader.addAccount( |
| BrowserContract.Bookmarks.CONTENT_URI_DEFAULT_FOLDER, |
| account.accountType, account.accountName); |
| } |
| return BrowserContract.Bookmarks.buildFolderUri(folder); |
| } |
| |
| @Override |
| public void onTop(BreadCrumbView view, int level, Object data) { |
| if (null == data) return; |
| Folder folderData = (Folder) data; |
| long folder = folderData.Id; |
| LoaderManager manager = getLoaderManager(); |
| CursorLoader loader = (CursorLoader) ((Loader<?>) manager.getLoader( |
| LOADER_ID_FOLDER_CONTENTS)); |
| loader.setUri(getUriForFolder(folder)); |
| loader.forceLoad(); |
| if (mIsFolderNamerShowing) { |
| completeOrCancelFolderNaming(true); |
| } |
| setShowBookmarkIcon(level == 1); |
| } |
| |
| /** |
| * Show or hide the icon for bookmarks next to "Bookmarks" in the crumb view. |
| * @param show True if the icon should visible, false otherwise. |
| */ |
| private void setShowBookmarkIcon(boolean show) { |
| Drawable drawable = show ? mHeaderIcon: null; |
| mTopLevelLabel.setCompoundDrawablesWithIntrinsicBounds(drawable, null, null, null); |
| } |
| |
| @Override |
| public boolean onEditorAction(TextView v, int actionId, KeyEvent event) { |
| if (v == mFolderNamer) { |
| if (v.getText().length() > 0) { |
| if (actionId == EditorInfo.IME_NULL) { |
| // Only want to do this once. |
| if (event.getAction() == KeyEvent.ACTION_UP) { |
| completeOrCancelFolderNaming(false); |
| } |
| } |
| } |
| // Steal the key press; otherwise a newline will be added |
| return true; |
| } |
| return false; |
| } |
| |
| private void switchToDefaultView(boolean changedFolder) { |
| mFolderSelector.setVisibility(View.GONE); |
| mDefaultView.setVisibility(View.VISIBLE); |
| mCrumbHolder.setVisibility(View.GONE); |
| mFakeTitleHolder.setVisibility(View.VISIBLE); |
| if (changedFolder) { |
| Object data = mCrumbs.getTopData(); |
| if (data != null) { |
| Folder folder = (Folder) data; |
| mCurrentFolder = folder.Id; |
| if (mCurrentFolder == mRootFolder) { |
| // The Spinner changed to show "Other folder ..." Change |
| // it back to "Bookmarks", which is position 0 if we are |
| // editing a folder, 1 otherwise. |
| mFolder.setSelectionIgnoringSelectionChange(mEditingFolder ? 0 : 1); |
| } else { |
| mFolderAdapter.setOtherFolderDisplayText(folder.Name); |
| } |
| } |
| } else { |
| // The user canceled selecting a folder. Revert back to the earlier |
| // selection. |
| if (mSaveToHomeScreen) { |
| mFolder.setSelectionIgnoringSelectionChange(0); |
| } else { |
| if (mCurrentFolder == mRootFolder) { |
| mFolder.setSelectionIgnoringSelectionChange(mEditingFolder ? 0 : 1); |
| } else { |
| Object data = mCrumbs.getTopData(); |
| if (data != null && ((Folder) data).Id == mCurrentFolder) { |
| // We are showing the correct folder hierarchy. The |
| // folder selector will say "Other folder..." Change it |
| // to say the name of the folder once again. |
| mFolderAdapter.setOtherFolderDisplayText(((Folder) data).Name); |
| } else { |
| // We are not showing the correct folder hierarchy. |
| // Clear the Crumbs and find the proper folder |
| setupTopCrumb(); |
| LoaderManager manager = getLoaderManager(); |
| manager.restartLoader(LOADER_ID_FOLDER_CONTENTS, null, this); |
| |
| } |
| } |
| } |
| } |
| } |
| |
| @Override |
| public void onClick(View v) { |
| if (v == mButton) { |
| if (mFolderSelector.getVisibility() == View.VISIBLE) { |
| // We are showing the folder selector. |
| if (mIsFolderNamerShowing) { |
| completeOrCancelFolderNaming(false); |
| } else { |
| // User has selected a folder. Go back to the opening page |
| mSaveToHomeScreen = false; |
| switchToDefaultView(true); |
| } |
| } else if (save()) { |
| finish(); |
| } |
| } else if (v == mCancelButton) { |
| if (mIsFolderNamerShowing) { |
| completeOrCancelFolderNaming(true); |
| } else if (mFolderSelector.getVisibility() == View.VISIBLE) { |
| switchToDefaultView(false); |
| } else { |
| finish(); |
| } |
| } else if (v == mFolderCancel) { |
| completeOrCancelFolderNaming(true); |
| } else if (v == mAddNewFolder) { |
| setShowFolderNamer(true); |
| mFolderNamer.setText(R.string.new_folder); |
| mFolderNamer.requestFocus(); |
| mAddNewFolder.setVisibility(View.GONE); |
| mAddSeparator.setVisibility(View.GONE); |
| InputMethodManager imm = getInputMethodManager(); |
| // Set the InputMethodManager to focus on the ListView so that it |
| // can transfer the focus to mFolderNamer. |
| imm.focusIn(mListView); |
| imm.showSoftInput(mFolderNamer, InputMethodManager.SHOW_IMPLICIT); |
| } else if (v == mRemoveLink) { |
| if (!mEditingExisting) { |
| throw new AssertionError("Remove button should not be shown for" |
| + " new bookmarks"); |
| } |
| long id = mMap.getLong(BrowserContract.Bookmarks._ID); |
| createHandler(); |
| Message msg = Message.obtain(mHandler, BOOKMARK_DELETED); |
| BookmarkUtils.displayRemoveBookmarkDialog(id, |
| mTitle.getText().toString(), this, msg); |
| } |
| } |
| |
| // FolderSpinner.OnSetSelectionListener |
| |
| @Override |
| public void onSetSelection(long id) { |
| int intId = (int) id; |
| switch (intId) { |
| case FolderSpinnerAdapter.ROOT_FOLDER: |
| mCurrentFolder = mRootFolder; |
| mSaveToHomeScreen = false; |
| break; |
| case FolderSpinnerAdapter.HOME_SCREEN: |
| // Create a short cut to the home screen |
| mSaveToHomeScreen = true; |
| break; |
| case FolderSpinnerAdapter.OTHER_FOLDER: |
| switchToFolderSelector(); |
| break; |
| case FolderSpinnerAdapter.RECENT_FOLDER: |
| mCurrentFolder = mFolderAdapter.recentFolderId(); |
| mSaveToHomeScreen = false; |
| // In case the user decides to select OTHER_FOLDER |
| // and choose a different one, so that we will start from |
| // the correct place. |
| LoaderManager manager = getLoaderManager(); |
| manager.restartLoader(LOADER_ID_FOLDER_CONTENTS, null, this); |
| break; |
| default: |
| break; |
| } |
| } |
| |
| /** |
| * Finish naming a folder, and close the IME |
| * @param cancel If true, the new folder is not created. If false, the new |
| * folder is created and the user is taken inside it. |
| */ |
| private void completeOrCancelFolderNaming(boolean cancel) { |
| if (!cancel && !TextUtils.isEmpty(mFolderNamer.getText())) { |
| String name = mFolderNamer.getText().toString(); |
| long id = addFolderToCurrent(mFolderNamer.getText().toString()); |
| descendInto(name, id); |
| } |
| setShowFolderNamer(false); |
| mAddNewFolder.setVisibility(View.VISIBLE); |
| mAddSeparator.setVisibility(View.VISIBLE); |
| getInputMethodManager().hideSoftInputFromWindow( |
| mListView.getWindowToken(), 0); |
| } |
| |
| private long addFolderToCurrent(String name) { |
| // Add the folder to the database |
| ContentValues values = new ContentValues(); |
| values.put(BrowserContract.Bookmarks.TITLE, |
| name); |
| values.put(BrowserContract.Bookmarks.IS_FOLDER, 1); |
| long currentFolder; |
| Object data = mCrumbs.getTopData(); |
| if (data != null) { |
| currentFolder = ((Folder) data).Id; |
| } else { |
| currentFolder = mRootFolder; |
| } |
| values.put(BrowserContract.Bookmarks.PARENT, currentFolder); |
| Uri uri = getContentResolver().insert( |
| BrowserContract.Bookmarks.CONTENT_URI, values); |
| if (uri != null) { |
| return ContentUris.parseId(uri); |
| } else { |
| return -1; |
| } |
| } |
| |
| private void switchToFolderSelector() { |
| // Set the list to the top in case it is scrolled. |
| mListView.setSelection(0); |
| mDefaultView.setVisibility(View.GONE); |
| mFolderSelector.setVisibility(View.VISIBLE); |
| mCrumbHolder.setVisibility(View.VISIBLE); |
| mFakeTitleHolder.setVisibility(View.GONE); |
| mAddNewFolder.setVisibility(View.VISIBLE); |
| mAddSeparator.setVisibility(View.VISIBLE); |
| getInputMethodManager().hideSoftInputFromWindow( |
| mListView.getWindowToken(), 0); |
| } |
| |
| private void descendInto(String foldername, long id) { |
| if (id != DEFAULT_FOLDER_ID) { |
| mCrumbs.pushView(foldername, new Folder(foldername, id)); |
| mCrumbs.notifyController(); |
| } |
| } |
| |
| private LoaderCallbacks<EditBookmarkInfo> mEditInfoLoaderCallbacks = |
| new LoaderCallbacks<EditBookmarkInfo>() { |
| |
| @Override |
| public void onLoaderReset(Loader<EditBookmarkInfo> loader) { |
| // Don't care |
| } |
| |
| @Override |
| public void onLoadFinished(Loader<EditBookmarkInfo> loader, |
| EditBookmarkInfo info) { |
| boolean setAccount = false; |
| if (info.id != -1) { |
| mEditingExisting = true; |
| showRemoveButton(); |
| mFakeTitle.setText(R.string.edit_bookmark); |
| mTitle.setText(info.title); |
| mFolderAdapter.setOtherFolderDisplayText(info.parentTitle); |
| mMap.putLong(BrowserContract.Bookmarks._ID, info.id); |
| setAccount = true; |
| setAccount(info.accountName, info.accountType); |
| mCurrentFolder = info.parentId; |
| onCurrentFolderFound(); |
| } |
| // TODO: Detect if lastUsedId is a subfolder of info.id in the |
| // editing folder case. For now, just don't show the last used |
| // folder at all to prevent any chance of the user adding a parent |
| // folder to a child folder |
| if (info.lastUsedId != -1 && info.lastUsedId != info.id |
| && !mEditingFolder) { |
| if (setAccount && info.lastUsedId != mRootFolder |
| && TextUtils.equals(info.lastUsedAccountName, info.accountName) |
| && TextUtils.equals(info.lastUsedAccountType, info.accountType)) { |
| mFolderAdapter.addRecentFolder(info.lastUsedId, info.lastUsedTitle); |
| } else if (!setAccount) { |
| setAccount = true; |
| setAccount(info.lastUsedAccountName, info.lastUsedAccountType); |
| if (info.lastUsedId != mRootFolder) { |
| mFolderAdapter.addRecentFolder(info.lastUsedId, |
| info.lastUsedTitle); |
| } |
| } |
| } |
| if (!setAccount) { |
| mAccountSpinner.setSelection(0); |
| } |
| } |
| |
| @Override |
| public Loader<EditBookmarkInfo> onCreateLoader(int id, Bundle args) { |
| return new EditBookmarkInfoLoader(AddBookmarkPage.this, mMap); |
| } |
| }; |
| |
| void setAccount(String accountName, String accountType) { |
| for (int i = 0; i < mAccountAdapter.getCount(); i++) { |
| BookmarkAccount account = mAccountAdapter.getItem(i); |
| if (TextUtils.equals(account.accountName, accountName) |
| && TextUtils.equals(account.accountType, accountType)) { |
| mAccountSpinner.setSelection(i); |
| onRootFolderFound(account.rootFolderId); |
| return; |
| } |
| } |
| } |
| |
| @Override |
| public Loader<Cursor> onCreateLoader(int id, Bundle args) { |
| String[] projection; |
| switch (id) { |
| case LOADER_ID_ACCOUNTS: |
| return new AccountsLoader(this); |
| case LOADER_ID_FOLDER_CONTENTS: |
| projection = new String[] { |
| BrowserContract.Bookmarks._ID, |
| BrowserContract.Bookmarks.TITLE, |
| BrowserContract.Bookmarks.IS_FOLDER |
| }; |
| String where = BrowserContract.Bookmarks.IS_FOLDER + " != 0"; |
| String whereArgs[] = null; |
| if (mEditingFolder) { |
| where += " AND " + BrowserContract.Bookmarks._ID + " != ?"; |
| whereArgs = new String[] { Long.toString(mMap.getLong( |
| BrowserContract.Bookmarks._ID)) }; |
| } |
| long currentFolder; |
| Object data = mCrumbs.getTopData(); |
| if (data != null) { |
| currentFolder = ((Folder) data).Id; |
| } else { |
| currentFolder = mRootFolder; |
| } |
| return new CursorLoader(this, |
| getUriForFolder(currentFolder), |
| projection, |
| where, |
| whereArgs, |
| BrowserContract.Bookmarks._ID + " ASC"); |
| default: |
| throw new AssertionError("Asking for nonexistant loader!"); |
| } |
| } |
| |
| @Override |
| public void onLoadFinished(Loader<Cursor> loader, Cursor cursor) { |
| switch (loader.getId()) { |
| case LOADER_ID_ACCOUNTS: |
| mAccountAdapter.clear(); |
| while (cursor.moveToNext()) { |
| mAccountAdapter.add(new BookmarkAccount(this, cursor)); |
| } |
| getLoaderManager().destroyLoader(LOADER_ID_ACCOUNTS); |
| getLoaderManager().restartLoader(LOADER_ID_EDIT_INFO, null, |
| mEditInfoLoaderCallbacks); |
| break; |
| case LOADER_ID_FOLDER_CONTENTS: |
| mAdapter.changeCursor(cursor); |
| break; |
| } |
| } |
| |
| public void onLoaderReset(Loader<Cursor> loader) { |
| switch (loader.getId()) { |
| case LOADER_ID_FOLDER_CONTENTS: |
| mAdapter.changeCursor(null); |
| break; |
| } |
| } |
| |
| /** |
| * Move cursor to the position that has folderToFind as its "_id". |
| * @param cursor Cursor containing folders in the bookmarks database |
| * @param folderToFind "_id" of the folder to move to. |
| * @param idIndex Index in cursor of "_id" |
| * @throws AssertionError if cursor is empty or there is no row with folderToFind |
| * as its "_id". |
| */ |
| void moveCursorToFolder(Cursor cursor, long folderToFind, int idIndex) |
| throws AssertionError { |
| if (!cursor.moveToFirst()) { |
| throw new AssertionError("No folders in the database!"); |
| } |
| long folder; |
| do { |
| folder = cursor.getLong(idIndex); |
| } while (folder != folderToFind && cursor.moveToNext()); |
| if (cursor.isAfterLast()) { |
| throw new AssertionError("Folder(id=" + folderToFind |
| + ") holding this bookmark does not exist!"); |
| } |
| } |
| |
| @Override |
| public void onItemClick(AdapterView<?> parent, View view, int position, |
| long id) { |
| TextView tv = (TextView) view.findViewById(android.R.id.text1); |
| // Switch to the folder that was clicked on. |
| descendInto(tv.getText().toString(), id); |
| } |
| |
| private void setShowFolderNamer(boolean show) { |
| if (show != mIsFolderNamerShowing) { |
| mIsFolderNamerShowing = show; |
| if (show) { |
| // Set the selection to the folder namer so it will be in |
| // view. |
| mListView.addFooterView(mFolderNamerHolder); |
| } else { |
| mListView.removeFooterView(mFolderNamerHolder); |
| } |
| // Refresh the list. |
| mListView.setAdapter(mAdapter); |
| if (show) { |
| mListView.setSelection(mListView.getCount() - 1); |
| } |
| } |
| } |
| |
| /** |
| * Shows a list of names of folders. |
| */ |
| private class FolderAdapter extends CursorAdapter { |
| public FolderAdapter(Context context) { |
| super(context, null); |
| } |
| |
| @Override |
| public void bindView(View view, Context context, Cursor cursor) { |
| ((TextView) view.findViewById(android.R.id.text1)).setText( |
| cursor.getString(cursor.getColumnIndexOrThrow( |
| BrowserContract.Bookmarks.TITLE))); |
| } |
| |
| @Override |
| public View newView(Context context, Cursor cursor, ViewGroup parent) { |
| View view = LayoutInflater.from(context).inflate( |
| R.layout.folder_list_item, null); |
| view.setBackgroundDrawable(context.getResources(). |
| getDrawable(android.R.drawable.list_selector_background)); |
| return view; |
| } |
| |
| @Override |
| public boolean isEmpty() { |
| // Do not show the empty view if the user is creating a new folder. |
| return super.isEmpty() && !mIsFolderNamerShowing; |
| } |
| } |
| |
| @Override |
| protected void onCreate(Bundle icicle) { |
| super.onCreate(icicle); |
| requestWindowFeature(Window.FEATURE_NO_TITLE); |
| |
| mMap = getIntent().getExtras(); |
| |
| setContentView(R.layout.browser_add_bookmark); |
| |
| Window window = getWindow(); |
| |
| String title = null; |
| String url = null; |
| |
| mFakeTitle = (TextView) findViewById(R.id.fake_title); |
| |
| if (mMap != null) { |
| Bundle b = mMap.getBundle(EXTRA_EDIT_BOOKMARK); |
| if (b != null) { |
| mEditingFolder = mMap.getBoolean(EXTRA_IS_FOLDER, false); |
| mMap = b; |
| mEditingExisting = true; |
| mFakeTitle.setText(R.string.edit_bookmark); |
| if (mEditingFolder) { |
| findViewById(R.id.row_address).setVisibility(View.GONE); |
| } else { |
| showRemoveButton(); |
| } |
| } else { |
| int gravity = mMap.getInt("gravity", -1); |
| if (gravity != -1) { |
| WindowManager.LayoutParams l = window.getAttributes(); |
| l.gravity = gravity; |
| window.setAttributes(l); |
| } |
| } |
| title = mMap.getString(BrowserContract.Bookmarks.TITLE); |
| url = mOriginalUrl = mMap.getString(BrowserContract.Bookmarks.URL); |
| mTouchIconUrl = mMap.getString(TOUCH_ICON_URL); |
| mCurrentFolder = mMap.getLong(BrowserContract.Bookmarks.PARENT, DEFAULT_FOLDER_ID); |
| } |
| |
| mTitle = (EditText) findViewById(R.id.title); |
| mTitle.setText(title); |
| |
| mAddress = (EditText) findViewById(R.id.address); |
| mAddress.setText(url); |
| |
| mButton = (TextView) findViewById(R.id.OK); |
| mButton.setOnClickListener(this); |
| |
| mCancelButton = findViewById(R.id.cancel); |
| mCancelButton.setOnClickListener(this); |
| |
| mFolder = (FolderSpinner) findViewById(R.id.folder); |
| mFolderAdapter = new FolderSpinnerAdapter(this, !mEditingFolder); |
| mFolder.setAdapter(mFolderAdapter); |
| mFolder.setOnSetSelectionListener(this); |
| |
| mDefaultView = findViewById(R.id.default_view); |
| mFolderSelector = findViewById(R.id.folder_selector); |
| |
| mFolderNamerHolder = getLayoutInflater().inflate(R.layout.new_folder_layout, null); |
| mFolderNamer = (EditText) mFolderNamerHolder.findViewById(R.id.folder_namer); |
| mFolderNamer.setOnEditorActionListener(this); |
| mFolderCancel = mFolderNamerHolder.findViewById(R.id.close); |
| mFolderCancel.setOnClickListener(this); |
| |
| mAddNewFolder = findViewById(R.id.add_new_folder); |
| mAddNewFolder.setOnClickListener(this); |
| mAddSeparator = findViewById(R.id.add_divider); |
| |
| mCrumbs = (BreadCrumbView) findViewById(R.id.crumbs); |
| mCrumbs.setUseBackButton(true); |
| mCrumbs.setController(this); |
| mHeaderIcon = getResources().getDrawable(R.drawable.ic_folder_holo_dark); |
| mCrumbHolder = findViewById(R.id.crumb_holder); |
| mCrumbs.setMaxVisible(MAX_CRUMBS_SHOWN); |
| |
| mAdapter = new FolderAdapter(this); |
| mListView = (CustomListView) findViewById(R.id.list); |
| View empty = findViewById(R.id.empty); |
| mListView.setEmptyView(empty); |
| mListView.setAdapter(mAdapter); |
| mListView.setOnItemClickListener(this); |
| mListView.addEditText(mFolderNamer); |
| |
| mAccountAdapter = new ArrayAdapter<BookmarkAccount>(this, |
| android.R.layout.simple_spinner_item); |
| mAccountAdapter.setDropDownViewResource( |
| android.R.layout.simple_spinner_dropdown_item); |
| mAccountSpinner = (Spinner) findViewById(R.id.accounts); |
| mAccountSpinner.setAdapter(mAccountAdapter); |
| mAccountSpinner.setOnItemSelectedListener(this); |
| |
| |
| mFakeTitleHolder = findViewById(R.id.title_holder); |
| |
| if (!window.getDecorView().isInTouchMode()) { |
| mButton.requestFocus(); |
| } |
| |
| getLoaderManager().restartLoader(LOADER_ID_ACCOUNTS, null, this); |
| } |
| |
| private void showRemoveButton() { |
| findViewById(R.id.remove_divider).setVisibility(View.VISIBLE); |
| mRemoveLink = findViewById(R.id.remove); |
| mRemoveLink.setVisibility(View.VISIBLE); |
| mRemoveLink.setOnClickListener(this); |
| } |
| |
| // Called once we have determined which folder is the root folder |
| private void onRootFolderFound(long root) { |
| mRootFolder = root; |
| mCurrentFolder = mRootFolder; |
| setupTopCrumb(); |
| onCurrentFolderFound(); |
| } |
| |
| private void setupTopCrumb() { |
| mCrumbs.clear(); |
| String name = getString(R.string.bookmarks); |
| mTopLevelLabel = (TextView) mCrumbs.pushView(name, false, |
| new Folder(name, mRootFolder)); |
| // To better match the other folders. |
| mTopLevelLabel.setCompoundDrawablePadding(6); |
| } |
| |
| private void onCurrentFolderFound() { |
| LoaderManager manager = getLoaderManager(); |
| if (mCurrentFolder != mRootFolder) { |
| // Since we're not in the root folder, change the selection to other |
| // folder now. The text will get changed once we select the correct |
| // folder. |
| mFolder.setSelectionIgnoringSelectionChange(mEditingFolder ? 1 : 2); |
| } else { |
| setShowBookmarkIcon(true); |
| if (!mEditingFolder) { |
| // Initially the "Bookmarks" folder should be showing, rather than |
| // the home screen. In the editing folder case, home screen is not |
| // an option, so "Bookmarks" folder is already at the top. |
| mFolder.setSelectionIgnoringSelectionChange(FolderSpinnerAdapter.ROOT_FOLDER); |
| } |
| } |
| // Find the contents of the current folder |
| manager.restartLoader(LOADER_ID_FOLDER_CONTENTS, null, this); |
| } |
| |
| /** |
| * Runnable to save a bookmark, so it can be performed in its own thread. |
| */ |
| private class SaveBookmarkRunnable implements Runnable { |
| // FIXME: This should be an async task. |
| private Message mMessage; |
| private Context mContext; |
| public SaveBookmarkRunnable(Context ctx, Message msg) { |
| mContext = ctx.getApplicationContext(); |
| mMessage = msg; |
| } |
| public void run() { |
| // Unbundle bookmark data. |
| Bundle bundle = mMessage.getData(); |
| String title = bundle.getString(BrowserContract.Bookmarks.TITLE); |
| String url = bundle.getString(BrowserContract.Bookmarks.URL); |
| boolean invalidateThumbnail = bundle.getBoolean(REMOVE_THUMBNAIL); |
| Bitmap thumbnail = invalidateThumbnail ? null |
| : (Bitmap) bundle.getParcelable(BrowserContract.Bookmarks.THUMBNAIL); |
| String touchIconUrl = bundle.getString(TOUCH_ICON_URL); |
| |
| // Save to the bookmarks DB. |
| try { |
| final ContentResolver cr = getContentResolver(); |
| Bookmarks.addBookmark(AddBookmarkPage.this, false, url, |
| title, thumbnail, mCurrentFolder); |
| if (touchIconUrl != null) { |
| new DownloadTouchIcon(mContext, cr, url).execute(mTouchIconUrl); |
| } |
| mMessage.arg1 = 1; |
| } catch (IllegalStateException e) { |
| mMessage.arg1 = 0; |
| } |
| mMessage.sendToTarget(); |
| } |
| } |
| |
| private static class UpdateBookmarkTask extends AsyncTask<ContentValues, Void, Void> { |
| Context mContext; |
| Long mId; |
| |
| public UpdateBookmarkTask(Context context, long id) { |
| mContext = context.getApplicationContext(); |
| mId = id; |
| } |
| |
| @Override |
| protected Void doInBackground(ContentValues... params) { |
| if (params.length != 1) { |
| throw new IllegalArgumentException("No ContentValues provided!"); |
| } |
| Uri uri = ContentUris.withAppendedId(BookmarkUtils.getBookmarksUri(mContext), mId); |
| mContext.getContentResolver().update( |
| uri, |
| params[0], null, null); |
| return null; |
| } |
| } |
| |
| private void createHandler() { |
| if (mHandler == null) { |
| mHandler = new Handler() { |
| @Override |
| public void handleMessage(Message msg) { |
| switch (msg.what) { |
| case SAVE_BOOKMARK: |
| if (1 == msg.arg1) { |
| Toast.makeText(AddBookmarkPage.this, R.string.bookmark_saved, |
| Toast.LENGTH_LONG).show(); |
| } else { |
| Toast.makeText(AddBookmarkPage.this, R.string.bookmark_not_saved, |
| Toast.LENGTH_LONG).show(); |
| } |
| break; |
| case TOUCH_ICON_DOWNLOADED: |
| Bundle b = msg.getData(); |
| sendBroadcast(BookmarkUtils.createAddToHomeIntent( |
| AddBookmarkPage.this, |
| b.getString(BrowserContract.Bookmarks.URL), |
| b.getString(BrowserContract.Bookmarks.TITLE), |
| (Bitmap) b.getParcelable(BrowserContract.Bookmarks.TOUCH_ICON), |
| (Bitmap) b.getParcelable(BrowserContract.Bookmarks.FAVICON))); |
| break; |
| case BOOKMARK_DELETED: |
| finish(); |
| break; |
| } |
| } |
| }; |
| } |
| } |
| |
| /** |
| * Parse the data entered in the dialog and post a message to update the bookmarks database. |
| */ |
| boolean save() { |
| createHandler(); |
| |
| String title = mTitle.getText().toString().trim(); |
| String unfilteredUrl; |
| unfilteredUrl = UrlUtils.fixUrl(mAddress.getText().toString()); |
| |
| boolean emptyTitle = title.length() == 0; |
| boolean emptyUrl = unfilteredUrl.trim().length() == 0; |
| Resources r = getResources(); |
| if (emptyTitle || (emptyUrl && !mEditingFolder)) { |
| if (emptyTitle) { |
| mTitle.setError(r.getText(R.string.bookmark_needs_title)); |
| } |
| if (emptyUrl) { |
| mAddress.setError(r.getText(R.string.bookmark_needs_url)); |
| } |
| return false; |
| |
| } |
| String url = unfilteredUrl.trim(); |
| if (!mEditingFolder) { |
| try { |
| // We allow bookmarks with a javascript: scheme, but these will in most cases |
| // fail URI parsing, so don't try it if that's the kind of bookmark we have. |
| |
| if (!url.toLowerCase().startsWith("javascript:")) { |
| URI uriObj = new URI(url); |
| String scheme = uriObj.getScheme(); |
| if (!Bookmarks.urlHasAcceptableScheme(url)) { |
| // If the scheme was non-null, let the user know that we |
| // can't save their bookmark. If it was null, we'll assume |
| // they meant http when we parse it in the WebAddress class. |
| if (scheme != null) { |
| mAddress.setError(r.getText(R.string.bookmark_cannot_save_url)); |
| return false; |
| } |
| WebAddress address; |
| try { |
| address = new WebAddress(unfilteredUrl); |
| } catch (ParseException e) { |
| throw new URISyntaxException("", ""); |
| } |
| if (address.getHost().length() == 0) { |
| throw new URISyntaxException("", ""); |
| } |
| url = address.toString(); |
| } |
| } |
| } catch (URISyntaxException e) { |
| mAddress.setError(r.getText(R.string.bookmark_url_not_valid)); |
| return false; |
| } |
| } |
| |
| if (mSaveToHomeScreen) { |
| mEditingExisting = false; |
| } |
| |
| boolean urlUnmodified = url.equals(mOriginalUrl); |
| |
| if (mEditingExisting) { |
| Long id = mMap.getLong(BrowserContract.Bookmarks._ID); |
| ContentValues values = new ContentValues(); |
| values.put(BrowserContract.Bookmarks.TITLE, title); |
| values.put(BrowserContract.Bookmarks.PARENT, mCurrentFolder); |
| if (!mEditingFolder) { |
| values.put(BrowserContract.Bookmarks.URL, url); |
| if (!urlUnmodified) { |
| values.putNull(BrowserContract.Bookmarks.THUMBNAIL); |
| } |
| } |
| if (values.size() > 0) { |
| new UpdateBookmarkTask(getApplicationContext(), id).execute(values); |
| } |
| setResult(RESULT_OK); |
| } else { |
| Bitmap thumbnail; |
| Bitmap favicon; |
| if (urlUnmodified) { |
| thumbnail = (Bitmap) mMap.getParcelable( |
| BrowserContract.Bookmarks.THUMBNAIL); |
| favicon = (Bitmap) mMap.getParcelable( |
| BrowserContract.Bookmarks.FAVICON); |
| } else { |
| thumbnail = null; |
| favicon = null; |
| } |
| |
| Bundle bundle = new Bundle(); |
| bundle.putString(BrowserContract.Bookmarks.TITLE, title); |
| bundle.putString(BrowserContract.Bookmarks.URL, url); |
| bundle.putParcelable(BrowserContract.Bookmarks.FAVICON, favicon); |
| |
| if (mSaveToHomeScreen) { |
| if (mTouchIconUrl != null && urlUnmodified) { |
| Message msg = Message.obtain(mHandler, |
| TOUCH_ICON_DOWNLOADED); |
| msg.setData(bundle); |
| DownloadTouchIcon icon = new DownloadTouchIcon(this, msg, |
| mMap.getString(USER_AGENT)); |
| icon.execute(mTouchIconUrl); |
| } else { |
| sendBroadcast(BookmarkUtils.createAddToHomeIntent(this, url, |
| title, null /*touchIcon*/, favicon)); |
| } |
| } else { |
| bundle.putParcelable(BrowserContract.Bookmarks.THUMBNAIL, thumbnail); |
| bundle.putBoolean(REMOVE_THUMBNAIL, !urlUnmodified); |
| bundle.putString(TOUCH_ICON_URL, mTouchIconUrl); |
| // Post a message to write to the DB. |
| Message msg = Message.obtain(mHandler, SAVE_BOOKMARK); |
| msg.setData(bundle); |
| // Start a new thread so as to not slow down the UI |
| Thread t = new Thread(new SaveBookmarkRunnable(getApplicationContext(), msg)); |
| t.start(); |
| } |
| setResult(RESULT_OK); |
| LogTag.logBookmarkAdded(url, "bookmarkview"); |
| } |
| return true; |
| } |
| |
| @Override |
| public void onItemSelected(AdapterView<?> parent, View view, int position, |
| long id) { |
| if (mAccountSpinner == parent) { |
| long root = mAccountAdapter.getItem(position).rootFolderId; |
| if (root != mRootFolder) { |
| onRootFolderFound(root); |
| mFolderAdapter.clearRecentFolder(); |
| } |
| } |
| } |
| |
| @Override |
| public void onNothingSelected(AdapterView<?> parent) { |
| // Don't care |
| } |
| |
| /* |
| * Class used as a proxy for the InputMethodManager to get to mFolderNamer |
| */ |
| public static class CustomListView extends ListView { |
| private EditText mEditText; |
| |
| public void addEditText(EditText editText) { |
| mEditText = editText; |
| } |
| |
| public CustomListView(Context context) { |
| super(context); |
| } |
| |
| public CustomListView(Context context, AttributeSet attrs) { |
| super(context, attrs); |
| } |
| |
| public CustomListView(Context context, AttributeSet attrs, int defStyle) { |
| super(context, attrs, defStyle); |
| } |
| |
| @Override |
| public boolean checkInputConnectionProxy(View view) { |
| return view == mEditText; |
| } |
| } |
| |
| static class AccountsLoader extends CursorLoader { |
| |
| static final String[] PROJECTION = new String[] { |
| Accounts.ACCOUNT_NAME, |
| Accounts.ACCOUNT_TYPE, |
| Accounts.ROOT_ID, |
| }; |
| |
| static final int COLUMN_INDEX_ACCOUNT_NAME = 0; |
| static final int COLUMN_INDEX_ACCOUNT_TYPE = 1; |
| static final int COLUMN_INDEX_ROOT_ID = 2; |
| |
| public AccountsLoader(Context context) { |
| super(context, Accounts.CONTENT_URI, PROJECTION, null, null, null); |
| } |
| |
| } |
| |
| public static class BookmarkAccount { |
| |
| private String mLabel; |
| String accountName, accountType; |
| public long rootFolderId; |
| |
| public BookmarkAccount(Context context, Cursor cursor) { |
| accountName = cursor.getString( |
| AccountsLoader.COLUMN_INDEX_ACCOUNT_NAME); |
| accountType = cursor.getString( |
| AccountsLoader.COLUMN_INDEX_ACCOUNT_TYPE); |
| rootFolderId = cursor.getLong( |
| AccountsLoader.COLUMN_INDEX_ROOT_ID); |
| mLabel = accountName; |
| if (TextUtils.isEmpty(mLabel)) { |
| mLabel = context.getString(R.string.local_bookmarks); |
| } |
| } |
| |
| @Override |
| public String toString() { |
| return mLabel; |
| } |
| } |
| |
| static class EditBookmarkInfo { |
| long id = -1; |
| long parentId = -1; |
| String parentTitle; |
| String title; |
| String accountName; |
| String accountType; |
| |
| long lastUsedId = -1; |
| String lastUsedTitle; |
| String lastUsedAccountName; |
| String lastUsedAccountType; |
| } |
| |
| static class EditBookmarkInfoLoader extends AsyncTaskLoader<EditBookmarkInfo> { |
| |
| private Context mContext; |
| private Bundle mMap; |
| |
| public EditBookmarkInfoLoader(Context context, Bundle bundle) { |
| super(context); |
| mContext = context.getApplicationContext(); |
| mMap = bundle; |
| } |
| |
| @Override |
| public EditBookmarkInfo loadInBackground() { |
| final ContentResolver cr = mContext.getContentResolver(); |
| EditBookmarkInfo info = new EditBookmarkInfo(); |
| Cursor c = null; |
| |
| try { |
| // First, let's lookup the bookmark (check for dupes, get needed info) |
| String url = mMap.getString(BrowserContract.Bookmarks.URL); |
| info.id = mMap.getLong(BrowserContract.Bookmarks._ID, -1); |
| boolean checkForDupe = mMap.getBoolean(CHECK_FOR_DUPE); |
| if (checkForDupe && info.id == -1 && !TextUtils.isEmpty(url)) { |
| c = cr.query(BrowserContract.Bookmarks.CONTENT_URI, |
| new String[] { BrowserContract.Bookmarks._ID}, |
| BrowserContract.Bookmarks.URL + "=?", |
| new String[] { url }, null); |
| if (c.getCount() == 1 && c.moveToFirst()) { |
| info.id = c.getLong(0); |
| } |
| c.close(); |
| } |
| if (info.id != -1) { |
| c = cr.query(ContentUris.withAppendedId( |
| BrowserContract.Bookmarks.CONTENT_URI, info.id), |
| new String[] { |
| BrowserContract.Bookmarks.PARENT, |
| BrowserContract.Bookmarks.ACCOUNT_NAME, |
| BrowserContract.Bookmarks.ACCOUNT_TYPE, |
| BrowserContract.Bookmarks.TITLE}, |
| null, null, null); |
| if (c.moveToFirst()) { |
| info.parentId = c.getLong(0); |
| info.accountName = c.getString(1); |
| info.accountType = c.getString(2); |
| info.title = c.getString(3); |
| } |
| c.close(); |
| c = cr.query(ContentUris.withAppendedId( |
| BrowserContract.Bookmarks.CONTENT_URI, info.parentId), |
| new String[] { |
| BrowserContract.Bookmarks.TITLE,}, |
| null, null, null); |
| if (c.moveToFirst()) { |
| info.parentTitle = c.getString(0); |
| } |
| c.close(); |
| } |
| |
| // Figure out the last used folder/account |
| c = cr.query(BrowserContract.Bookmarks.CONTENT_URI, |
| new String[] { |
| BrowserContract.Bookmarks.PARENT, |
| }, null, null, |
| BrowserContract.Bookmarks.DATE_MODIFIED + " DESC LIMIT 1"); |
| if (c.moveToFirst()) { |
| long parent = c.getLong(0); |
| c.close(); |
| c = cr.query(BrowserContract.Bookmarks.CONTENT_URI, |
| new String[] { |
| BrowserContract.Bookmarks.TITLE, |
| BrowserContract.Bookmarks.ACCOUNT_NAME, |
| BrowserContract.Bookmarks.ACCOUNT_TYPE}, |
| BrowserContract.Bookmarks._ID + "=?", new String[] { |
| Long.toString(parent)}, null); |
| if (c.moveToFirst()) { |
| info.lastUsedId = parent; |
| info.lastUsedTitle = c.getString(0); |
| info.lastUsedAccountName = c.getString(1); |
| info.lastUsedAccountType = c.getString(2); |
| } |
| c.close(); |
| } |
| } finally { |
| if (c != null) { |
| c.close(); |
| } |
| } |
| |
| return info; |
| } |
| |
| @Override |
| protected void onStartLoading() { |
| forceLoad(); |
| } |
| |
| } |
| |
| } |
