[Bookmarks] Refactor search view to use SelectableListLayout paradigm

chrome/android/java/src/org/chromium/chrome/browser/bookmarks/BookmarkManager.java

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.chrome.browser.bookmarks;
 
 import android.app.Activity;
 import android.app.ActivityManager;
 import android.content.Context;
+import android.support.v4.view.GravityCompat;
 import android.support.v4.widget.DrawerLayout;
 import android.support.v7.widget.RecyclerView;
 import android.support.v7.widget.Toolbar;
 import android.text.TextUtils;
-import android.view.Gravity;
 import android.view.View;
 import android.view.ViewGroup;
-import android.widget.ViewSwitcher;
 
 import org.chromium.base.ApiCompatibilityUtils;
 import org.chromium.base.ContextUtils;
 import org.chromium.base.ObserverList;
 import org.chromium.base.metrics.RecordUserAction;
 import org.chromium.chrome.R;
 import org.chromium.chrome.browser.BasicNativePage;
 import org.chromium.chrome.browser.bookmarks.BookmarkBridge.BookmarkItem;
 import org.chromium.chrome.browser.bookmarks.BookmarkBridge.BookmarkModelObserver;
 import org.chromium.chrome.browser.favicon.LargeIconBridge;
 import org.chromium.chrome.browser.partnerbookmarks.PartnerBookmarksShim;
 import org.chromium.chrome.browser.profiles.Profile;
 import org.chromium.chrome.browser.snackbar.SnackbarManager.SnackbarManageable;
 import org.chromium.chrome.browser.widget.selection.SelectableListLayout;
+import org.chromium.chrome.browser.widget.selection.SelectableListToolbar.SearchDelegate;
 import org.chromium.chrome.browser.widget.selection.SelectionDelegate;
 import org.chromium.components.bookmarks.BookmarkId;
 
 import java.util.Stack;
 
 /**
  * The new bookmark manager that is planned to replace the existing bookmark manager. It holds all
  * views and shared logics between tablet and phone. For tablet/phone specific logics, see
  * {@link BookmarkActivity} (phone) and {@link BookmarkPage} (tablet).
  */
-public class BookmarkManager implements BookmarkDelegate {
+public class BookmarkManager implements BookmarkDelegate, SearchDelegate {
     private static final int FAVICON_MAX_CACHE_SIZE_BYTES = 10 * 1024 * 1024; // 10MB
 
+    /**
+     * This shared preference used to be used to save a list of recent searches. That feature
+     * has been removed, so this string is now used solely to clear the shared preference.
+     */
+    private static final String PREF_SEARCH_HISTORY = "bookmark_search_history";
+

[gone, 2017/03/23 00:56:36]

We should really have a central place for this.

[Theresa, 2017/03/23 15:49:38]

"bookmark_search_history" was previously in BookmarkSearchView which has been
deleted, so this string only appears in one place (here). Do you mean we should
have a common place for removing deprecated preferences?

[gone, 2017/03/23 17:12:03]

Yeah, common place for removing deprecated prefs.  I've seen the "distant
memory" string at least three times now.

     private Activity mActivity;
     private ViewGroup mMainView;
     private BookmarkModel mBookmarkModel;
     private BookmarkUndoController mUndoController;
     private final ObserverList<BookmarkUIObserver> mUIObservers =
             new ObserverList<BookmarkUIObserver>();
     private BasicNativePage mNativePage;
     private SelectableListLayout<BookmarkId> mSelectableListLayout;
     private RecyclerView mRecyclerView;
     private BookmarkItemsAdapter mAdapter;
     private BookmarkActionBar mToolbar;
-    private BookmarkSearchView mSearchView;
-    private ViewSwitcher mViewSwitcher;
     private DrawerLayout mDrawer;
     private BookmarkDrawerListView mDrawerListView;
     private SelectionDelegate<BookmarkId> mSelectionDelegate;
     private final Stack<BookmarkUIState> mStateStack = new Stack<>();
     private LargeIconBridge mLargeIconBridge;
     private String mInitialUrl;
     private boolean mIsDialogUi;
 
     private final BookmarkModelObserver mBookmarkModelObserver = new BookmarkModelObserver() {
 
@@ skipping 27 matching lines @@
             if (getCurrentState() == BookmarkUIState.STATE_FOLDER) {
                 setState(mStateStack.peek());
             }
             mSelectionDelegate.clearSelection();
         }
     };
 
     private final Runnable mModelLoadedRunnable = new Runnable() {
         @Override
         public void run() {
-            mSearchView.onBookmarkDelegateInitialized(BookmarkManager.this);
             mDrawerListView.onBookmarkDelegateInitialized(BookmarkManager.this);
             mAdapter.onBookmarkDelegateInitialized(BookmarkManager.this);
             mToolbar.onBookmarkDelegateInitialized(BookmarkManager.this);
             if (!TextUtils.isEmpty(mInitialUrl)) {
                 setState(BookmarkUIState.createStateFromUrl(mInitialUrl,
                         mBookmarkModel));
             }
         }
     };
 
@@ skipping 21 matching lines @@
         mDrawerListView = (BookmarkDrawerListView) mMainView.findViewById(
                 R.id.bookmark_drawer_list);
 
         @SuppressWarnings("unchecked")
         SelectableListLayout<BookmarkId> selectableList =
                 (SelectableListLayout<BookmarkId>) mMainView.findViewById(R.id.selectable_list);
         mSelectableListLayout = selectableList;
         mSelectableListLayout.initializeEmptyView(
                 ApiCompatibilityUtils.getDrawable(
                         mActivity.getResources(), R.drawable.bookmark_logo_large),
-                R.string.bookmarks_folder_empty,
-                0 /* Bookmarks search is not yet controlled by the SelectableListLayout. */);
+                R.string.bookmarks_folder_empty, R.string.bookmark_no_result);
 
         mAdapter = new BookmarkItemsAdapter(activity);
 
         mRecyclerView = mSelectableListLayout.initializeRecyclerView(mAdapter);
 
         mToolbar = (BookmarkActionBar) mSelectableListLayout.initializeToolbar(
                 R.layout.bookmark_action_bar, mSelectionDelegate, 0, mDrawer,
                 R.id.normal_menu_group, R.id.selection_mode_menu_group, null, true, null);
+        mToolbar.initializeSearchView(
+                this, R.string.bookmark_action_bar_search, R.id.search_menu_id);
 
-        mViewSwitcher = (ViewSwitcher) mMainView.findViewById(R.id.bookmark_view_switcher);
         mUndoController = new BookmarkUndoController(activity, mBookmarkModel,
                 ((SnackbarManageable) activity).getSnackbarManager());
-        mSearchView = (BookmarkSearchView) getView().findViewById(R.id.bookmark_search_view);
         mBookmarkModel.addObserver(mBookmarkModelObserver);
         initializeToLoadingState();
         mBookmarkModel.runAfterBookmarkModelLoaded(mModelLoadedRunnable);
 
         // Load partner bookmarks explicitly. We load partner bookmarks in the deferred startup
         // code, but that might be executed much later. Especially on L, showing loading
         // progress bar blocks that so it won't be loaded. http://crbug.com/429383
         PartnerBookmarksShim.kickOffReading(activity);
 
         mLargeIconBridge = new LargeIconBridge(Profile.getLastUsedProfile().getOriginalProfile());
         ActivityManager activityManager = ((ActivityManager) ContextUtils
                 .getApplicationContext().getSystemService(Context.ACTIVITY_SERVICE));
         int maxSize = Math.min(activityManager.getMemoryClass() / 4 * 1024 * 1024,
                 FAVICON_MAX_CACHE_SIZE_BYTES);
         mLargeIconBridge.createCache(maxSize);
 
         RecordUserAction.record("MobileBookmarkManagerOpen");
         if (!isDialogUi) {
             RecordUserAction.record("MobileBookmarkManagerPageOpen");
         }
+
+        // TODO(twellington): Remove this when Chrome version 59 is a distant memory and users
+        // are unlikely to have the old PREF_SEARCH_HISTORY in shared preferences.
+        ContextUtils.getAppSharedPreferences().edit().remove(PREF_SEARCH_HISTORY).apply();
     }
 
     /**
      * Destroys and cleans up itself. This must be called after done using this class.
      */
     public void destroy() {
         for (BookmarkUIObserver observer : mUIObservers) {
             observer.onDestroy();
         }
         assert mUIObservers.size() == 0;
 
         if (mUndoController != null) {
             mUndoController.destroy();
             mUndoController = null;
         }
         mBookmarkModel.removeObserver(mBookmarkModelObserver);
         mBookmarkModel.destroy();
         mBookmarkModel = null;
         mLargeIconBridge.destroy();
         mLargeIconBridge = null;
     }
 
     /**
      * Called when the user presses the back key. This is only going to be called on Phone.
      * @return True if manager handles this event, false if it decides to ignore.
      */
     public boolean onBackPressed() {
         if (doesDrawerExist()) {
-            if (mDrawer.isDrawerVisible(Gravity.START)) {
-                mDrawer.closeDrawer(Gravity.START);
+            if (mDrawer.isDrawerVisible(GravityCompat.START)) {
+                mDrawer.closeDrawer(GravityCompat.START);
                 return true;
             }
         }
 
         // TODO(twellington): replicate this behavior for other list UIs during unification.
         if (mSelectionDelegate.isSelectionEnabled()) {
             mSelectionDelegate.clearSelection();
             return true;
         }
 
@@ skipping 118 matching lines @@
 
     // BookmarkDelegate implementations.
 
     @Override
     public boolean isDialogUi() {
         return mIsDialogUi;
     }
 
     @Override
     public void openFolder(BookmarkId folder) {
-        closeSearchUI();
+        mToolbar.hideSearchView();
         setState(BookmarkUIState.createFolderState(folder, mBookmarkModel));
         mRecyclerView.scrollToPosition(0);
     }
 
     @Override
     public SelectionDelegate<BookmarkId> getSelectionDelegate() {
         return mSelectionDelegate;
     }
 
     @Override
     public void notifyStateChange(BookmarkUIObserver observer) {
         int state = getCurrentState();
         switch (state) {
             case BookmarkUIState.STATE_FOLDER:
                 observer.onFolderStateSet(mStateStack.peek().mFolder);
                 break;
             case BookmarkUIState.STATE_LOADING:
                 // In loading state, onBookmarkDelegateInitialized() is not called for all
                 // UIObservers, which means that there will be no observers at the time. Do nothing.
                 assert mUIObservers.isEmpty();
                 break;
+            case BookmarkUIState.STATE_SEARCHING:
+                observer.onSearchStateSet();
+                break;
             default:
                 assert false : "State not valid";
                 break;
         }
     }
 
     @Override
     public boolean doesDrawerExist() {
         return mDrawer != null;
     }
 
     @Override
     public void closeDrawer() {
         if (!doesDrawerExist()) return;
 
-        mDrawer.closeDrawer(Gravity.START);
+        mDrawer.closeDrawer(GravityCompat.START);
     }
 
     @Override
     public DrawerLayout getDrawerLayout() {
         return mDrawer;
     }
 
     @Override
     public void openBookmark(BookmarkId bookmark, int launchLocation) {
         mSelectionDelegate.clearSelection();
         if (BookmarkUtils.openBookmark(
                     mBookmarkModel, mActivity, bookmark, launchLocation)) {
             BookmarkUtils.finishActivityOnPhone(mActivity);
         }
     }
 
     @Override
     public void openSearchUI() {
-        // Give search view focus, because it needs to handle back key event.
-        mViewSwitcher.showNext();
+        mSelectableListLayout.onStartSearch();
+        mToolbar.showSearchView();
+        setState(BookmarkUIState.createSearchState());
     }
 
     @Override
     public void closeSearchUI() {
-        if (mSearchView.getVisibility() != View.VISIBLE) return;
-        mViewSwitcher.showPrevious();
+        mSelectableListLayout.onEndSearch();
+
+        // Pop the search state off the stack.
+        mStateStack.pop();
+
+        // Set the state back to the folder that was previously being viewed. Listeners, including
+        // the BookmarkItemsAdapter, will be notified of the change and the list of bookmarks will
+        // be updated.
+        setState(mStateStack.pop());
     }
 
     @Override
     public void addUIObserver(BookmarkUIObserver observer) {
         mUIObservers.addObserver(observer);
     }
 
     @Override
     public void removeUIObserver(BookmarkUIObserver observer) {
         mUIObservers.removeObserver(observer);
     }
 
     @Override
     public BookmarkModel getModel() {
         return mBookmarkModel;
     }
 
     @Override
     public int getCurrentState() {
         if (mStateStack.isEmpty()) return BookmarkUIState.STATE_LOADING;
         return mStateStack.peek().mState;
     }
 
     @Override
     public LargeIconBridge getLargeIconBridge() {
         return mLargeIconBridge;
     }
+
+    // SearchDelegate overrides
+
+    @Override
+    public void onSearchTextChanged(String query) {
+        mAdapter.search(query);
+    }
+
+    @Override
+    public void onEndSearch() {
+        closeSearchUI();
+    }
 }