src/com/android/browser/InstantSearchEngine.java - android_packages_apps_Gello - Gitiles

 /*
  * Copyright (C) 2011 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package com.android.browser;

 import com.android.browser.Controller;
 import com.android.browser.R;
 import com.android.browser.UI.DropdownChangeListener;
 import com.android.browser.provider.BrowserProvider;
 import com.android.browser.search.SearchEngine;

 import android.app.SearchManager;
 import android.content.Context;
 import android.database.AbstractCursor;
 import android.database.Cursor;
 import android.net.Uri;
 import android.os.Bundle;
 import android.text.TextUtils;
 import android.util.Log;
 import android.util.LruCache;
 import android.webkit.SearchBox;
 import android.webkit.WebView;

 import java.util.Collections;
 import java.util.List;

 public class InstantSearchEngine implements SearchEngine, DropdownChangeListener {
     private static final String TAG = "Browser.InstantSearchEngine";
     private static final boolean DBG = false;

     private Controller mController;
     private SearchBox mSearchBox;
     private final BrowserSearchboxListener mListener = new BrowserSearchboxListener();
     private int mHeight;

     private String mInstantBaseUrl;
     private final Context mContext;
     // Used for startSearch( ) calls if for some reason instant
     // is off, or no searchbox is present.
     private final SearchEngine mWrapped;

     public InstantSearchEngine(Context context, SearchEngine wrapped) {
         mContext = context;
         mWrapped = wrapped;
     }

     public void setController(Controller controller) {
         mController = controller;
     }

     @Override
     public String getName() {
         return SearchEngine.GOOGLE;
     }

     @Override
     public CharSequence getLabel() {
         return mContext.getResources().getString(R.string.instant_search_label);
     }

     @Override
     public void startSearch(Context context, String query, Bundle appData, String extraData) {
         if (DBG) Log.d(TAG, "startSearch(" + query + ")");

         switchSearchboxIfNeeded();

         // If for some reason we are in a bad state, ensure that the
         // user gets default search results at the very least.
         if (mSearchBox == null || !isInstantPage()) {
             mWrapped.startSearch(context, query, appData, extraData);
             return;
         }

         mSearchBox.setQuery(query);
         mSearchBox.setVerbatim(true);
         mSearchBox.onsubmit();
     }

     private final class BrowserSearchboxListener implements SearchBox.SearchBoxListener {
         /*
          * The maximum number of out of order suggestions we accept
          * before giving up the wait.
          */
         private static final int MAX_OUT_OF_ORDER = 5;

         /*
          * We wait for suggestions in increments of 600ms. This is primarily to
          * guard against suggestions arriving out of order.
          */
         private static final int WAIT_INCREMENT_MS = 600;

         /*
          * A cache of suggestions received, keyed by the queries they were
          * received for.
          */
         private final LruCache<String, List<String>> mSuggestions =
                 new LruCache<String, List<String>>(20);

         /*
          * The last set of suggestions received. We use this reduce UI flicker
          * in case there is a delay in recieving suggestions.
          */
         private List<String> mLatestSuggestion = Collections.emptyList();

         @Override
         public synchronized void onSuggestionsReceived(String query, List<String> suggestions) {
             if (DBG) Log.d(TAG, "onSuggestionsReceived(" + query + ")");

             if (!TextUtils.isEmpty(query)) {
                 mSuggestions.put(query, suggestions);
                 mLatestSuggestion = suggestions;
             }

             notifyAll();
         }

         public synchronized List<String> tryWaitForSuggestions(String query) {
             if (DBG) Log.d(TAG, "tryWait(" + query + ")");

             int numWaitReturns = 0;

             // This slightly unusual waiting construct is used to safeguard
             // to some extent against suggestions arriving out of order. We
             // wait for upto 5 notifyAll( ) calls to check if we received
             // suggestions for a given query.
             while (mSuggestions.get(query) == null)  {
                 try {
                     wait(WAIT_INCREMENT_MS);
                     ++numWaitReturns;
                     if (numWaitReturns > MAX_OUT_OF_ORDER) {
                         // We've waited too long for suggestions to be returned.
                         // return the last available suggestion.
                         break;
                     }
                 } catch (InterruptedException e) {
                     return Collections.emptyList();
                 }
             }

             List<String> suggestions = mSuggestions.get(query);
             if (suggestions == null) {
                 return mLatestSuggestion;
             }

             return suggestions;
         }

         public synchronized void clear() {
             mSuggestions.evictAll();
         }
     }

     private WebView getCurrentWebview() {
         if (mController != null) {
             return mController.getTabControl().getCurrentTopWebView();
         }

         return null;
     }

     /**
      * Attaches the searchbox to the right browser page, i.e, the currently
      * visible tab.
      */
     private void switchSearchboxIfNeeded() {
         final WebView current = getCurrentWebview();
         if (current == null) {
             return;
         }

         final SearchBox searchBox = current.getSearchBox();
         if (searchBox != mSearchBox) {
             if (mSearchBox != null) {
                 mSearchBox.removeSearchBoxListener(mListener);
                 mListener.clear();
             }
             mSearchBox = searchBox;
             if (mSearchBox != null) {
                 mSearchBox.addSearchBoxListener(mListener);
             }
         }
     }

     private boolean isInstantPage() {
         final WebView current = getCurrentWebview();
         if (current == null) {
             return false;
         }

         final String currentUrl = current.getUrl();

         if (currentUrl != null) {
             Uri uri = Uri.parse(currentUrl);
             final String host = uri.getHost();
             final String path = uri.getPath();

             // Is there a utility class that does this ?
             if (path != null && host != null) {
                 return host.startsWith("www.google.") &&
                         (path.startsWith("/search") || path.startsWith("/webhp"));
             }
             return false;
         }

         return false;
     }

     private void loadInstantPage() {
         mController.getActivity().runOnUiThread(new Runnable() {
             @Override
             public void run() {
                 final WebView current = getCurrentWebview();
                 if (current != null) {
                     current.loadUrl(getInstantBaseUrl());
                 }
             }
         });
     }

     /**
      * Queries for a given search term and returns a cursor containing
      * suggestions ordered by best match.
      */
     @Override
     public Cursor getSuggestions(Context context, String query) {
         if (DBG) Log.d(TAG, "getSuggestions(" + query + ")");
         if (query == null) {
             return null;
         }

         if (!isInstantPage()) {
             loadInstantPage();
         }

         switchSearchboxIfNeeded();

         mController.registerDropdownChangeListener(this);

         if (mSearchBox == null) {
             return mWrapped.getSuggestions(context, query);
         }

         mSearchBox.setDimensions(0, 0, 0, mHeight);
         mSearchBox.onresize();

         if (TextUtils.isEmpty(query)) {
             // To force the SRP to render an empty (no results) page.
             mSearchBox.setVerbatim(true);
         } else {
             mSearchBox.setVerbatim(false);
         }
         mSearchBox.setQuery(query);
         mSearchBox.onchange();

         // Don't bother waiting for suggestions for an empty query. We still
         // set the query so that the SRP clears itself.
         if (TextUtils.isEmpty(query)) {
             return new SuggestionsCursor(Collections.<String>emptyList());
         } else {
             return new SuggestionsCursor(mListener.tryWaitForSuggestions(query));
         }
     }

     @Override
     public boolean supportsSuggestions() {
         return true;
     }

     @Override
     public void close() {
         if (mController != null) {
             mController.registerDropdownChangeListener(null);
         }
         if (mSearchBox != null) {
             mSearchBox.removeSearchBoxListener(mListener);
         }
         mListener.clear();
         mWrapped.close();
     }

     @Override
     public boolean supportsVoiceSearch() {
         return false;
     }

     @Override
     public String toString() {
         return "InstantSearchEngine {" + hashCode() + "}";
     }

     @Override
     public boolean wantsEmptyQuery() {
         return true;
     }

     private int rescaleHeight(int height) {
         final WebView current = getCurrentWebview();
         if (current == null) {
             return 0;
         }

         final float scale = current.getScale();
         if (scale != 0) {
             return (int) (height / scale);
         }

         return height;
     }

     @Override
     public void onNewDropdownDimensions(int height) {
         final int rescaledHeight = rescaleHeight(height);

         if (rescaledHeight != mHeight) {
             mHeight = rescaledHeight;
             if (mSearchBox != null) {
                 mSearchBox.setDimensions(0, 0, 0, rescaledHeight);
                 mSearchBox.onresize();
             }
         }
     }

     private String getInstantBaseUrl() {
         if (mInstantBaseUrl == null) {
             String url = mContext.getResources().getString(R.string.instant_base);
             if (url.indexOf("{CID}") != -1) {
                 url = url.replace("{CID}",
                         BrowserProvider.getClientId(mContext.getContentResolver()));
             }
             mInstantBaseUrl = url;
         }

         return mInstantBaseUrl;
     }

     // Indices of the columns in the below arrays.
     private static final int COLUMN_INDEX_ID = 0;
     private static final int COLUMN_INDEX_QUERY = 1;
     private static final int COLUMN_INDEX_ICON = 2;
     private static final int COLUMN_INDEX_TEXT_1 = 3;

     private static final String[] COLUMNS_WITHOUT_DESCRIPTION = new String[] {
         "_id",
         SearchManager.SUGGEST_COLUMN_QUERY,
         SearchManager.SUGGEST_COLUMN_ICON_1,
         SearchManager.SUGGEST_COLUMN_TEXT_1,
     };

     private static class SuggestionsCursor extends AbstractCursor {
         private final List<String> mSuggestions;

         public SuggestionsCursor(List<String> suggestions) {
             mSuggestions = suggestions;
         }

         @Override
         public int getCount() {
             return mSuggestions.size();
         }

         @Override
         public String[] getColumnNames() {
             return COLUMNS_WITHOUT_DESCRIPTION;
         }

         private String format(String suggestion) {
             if (TextUtils.isEmpty(suggestion)) {
                 return "";
             }
             return suggestion;
         }

         @Override
         public String getString(int column) {
             if (mPos >= 0 && mPos < mSuggestions.size()) {
               if ((column == COLUMN_INDEX_QUERY) || (column == COLUMN_INDEX_TEXT_1)) {
                   return format(mSuggestions.get(mPos));
               } else if (column == COLUMN_INDEX_ICON) {
                   return String.valueOf(R.drawable.magnifying_glass);
               }
             }
             return null;
         }

         @Override
         public double getDouble(int column) {
             throw new UnsupportedOperationException();
         }

         @Override
         public float getFloat(int column) {
             throw new UnsupportedOperationException();
         }

         @Override
         public int getInt(int column) {
             if (column == COLUMN_INDEX_ID) {
                 return mPos;
             }
             throw new UnsupportedOperationException();
         }

         @Override
         public long getLong(int column) {
             throw new UnsupportedOperationException();
         }

         @Override
         public short getShort(int column) {
           throw new UnsupportedOperationException();
         }

         @Override
         public boolean isNull(int column) {
             throw new UnsupportedOperationException();
         }
     }
 }
	/*
	* Copyright (C) 2011 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package com.android.browser;

	import com.android.browser.Controller;
	import com.android.browser.R;
	import com.android.browser.UI.DropdownChangeListener;
	import com.android.browser.provider.BrowserProvider;
	import com.android.browser.search.SearchEngine;

	import android.app.SearchManager;
	import android.content.Context;
	import android.database.AbstractCursor;
	import android.database.Cursor;
	import android.net.Uri;
	import android.os.Bundle;
	import android.text.TextUtils;
	import android.util.Log;
	import android.util.LruCache;
	import android.webkit.SearchBox;
	import android.webkit.WebView;

	import java.util.Collections;
	import java.util.List;

	public class InstantSearchEngine implements SearchEngine, DropdownChangeListener {
	private static final String TAG = "Browser.InstantSearchEngine";
	private static final boolean DBG = false;

	private Controller mController;
	private SearchBox mSearchBox;
	private final BrowserSearchboxListener mListener = new BrowserSearchboxListener();
	private int mHeight;

	private String mInstantBaseUrl;
	private final Context mContext;
	// Used for startSearch( ) calls if for some reason instant
	// is off, or no searchbox is present.
	private final SearchEngine mWrapped;

	public InstantSearchEngine(Context context, SearchEngine wrapped) {
	mContext = context;
	mWrapped = wrapped;
	}

	public void setController(Controller controller) {
	mController = controller;
	}

	@Override
	public String getName() {
	return SearchEngine.GOOGLE;
	}

	@Override
	public CharSequence getLabel() {
	return mContext.getResources().getString(R.string.instant_search_label);
	}

	@Override
	public void startSearch(Context context, String query, Bundle appData, String extraData) {
	if (DBG) Log.d(TAG, "startSearch(" + query + ")");

	switchSearchboxIfNeeded();

	// If for some reason we are in a bad state, ensure that the
	// user gets default search results at the very least.
	if (mSearchBox == null \|\| !isInstantPage()) {
	mWrapped.startSearch(context, query, appData, extraData);
	return;
	}

	mSearchBox.setQuery(query);
	mSearchBox.setVerbatim(true);
	mSearchBox.onsubmit();
	}

	private final class BrowserSearchboxListener implements SearchBox.SearchBoxListener {
	/*
	* The maximum number of out of order suggestions we accept
	* before giving up the wait.
	*/
	private static final int MAX_OUT_OF_ORDER = 5;

	/*
	* We wait for suggestions in increments of 600ms. This is primarily to
	* guard against suggestions arriving out of order.
	*/
	private static final int WAIT_INCREMENT_MS = 600;

	/*
	* A cache of suggestions received, keyed by the queries they were
	* received for.
	*/
	private final LruCache<String, List<String>> mSuggestions =
	new LruCache<String, List<String>>(20);

	/*
	* The last set of suggestions received. We use this reduce UI flicker
	* in case there is a delay in recieving suggestions.
	*/
	private List<String> mLatestSuggestion = Collections.emptyList();

	@Override
	public synchronized void onSuggestionsReceived(String query, List<String> suggestions) {
	if (DBG) Log.d(TAG, "onSuggestionsReceived(" + query + ")");

	if (!TextUtils.isEmpty(query)) {
	mSuggestions.put(query, suggestions);
	mLatestSuggestion = suggestions;
	}

	notifyAll();
	}

	public synchronized List<String> tryWaitForSuggestions(String query) {
	if (DBG) Log.d(TAG, "tryWait(" + query + ")");

	int numWaitReturns = 0;

	// This slightly unusual waiting construct is used to safeguard
	// to some extent against suggestions arriving out of order. We
	// wait for upto 5 notifyAll( ) calls to check if we received
	// suggestions for a given query.
	while (mSuggestions.get(query) == null) {
	try {
	wait(WAIT_INCREMENT_MS);
	++numWaitReturns;
	if (numWaitReturns > MAX_OUT_OF_ORDER) {
	// We've waited too long for suggestions to be returned.
	// return the last available suggestion.
	break;
	}
	} catch (InterruptedException e) {
	return Collections.emptyList();
	}
	}

	List<String> suggestions = mSuggestions.get(query);
	if (suggestions == null) {
	return mLatestSuggestion;
	}

	return suggestions;
	}

	public synchronized void clear() {
	mSuggestions.evictAll();
	}
	}

	private WebView getCurrentWebview() {
	if (mController != null) {
	return mController.getTabControl().getCurrentTopWebView();
	}

	return null;
	}

	/**
	* Attaches the searchbox to the right browser page, i.e, the currently
	* visible tab.
	*/
	private void switchSearchboxIfNeeded() {
	final WebView current = getCurrentWebview();
	if (current == null) {
	return;
	}

	final SearchBox searchBox = current.getSearchBox();
	if (searchBox != mSearchBox) {
	if (mSearchBox != null) {
	mSearchBox.removeSearchBoxListener(mListener);
	mListener.clear();
	}
	mSearchBox = searchBox;
	if (mSearchBox != null) {
	mSearchBox.addSearchBoxListener(mListener);
	}
	}
	}

	private boolean isInstantPage() {
	final WebView current = getCurrentWebview();
	if (current == null) {
	return false;
	}

	final String currentUrl = current.getUrl();

	if (currentUrl != null) {
	Uri uri = Uri.parse(currentUrl);
	final String host = uri.getHost();
	final String path = uri.getPath();

	// Is there a utility class that does this ?
	if (path != null && host != null) {
	return host.startsWith("www.google.") &&
	(path.startsWith("/search") \|\| path.startsWith("/webhp"));
	}
	return false;
	}

	return false;
	}

	private void loadInstantPage() {
	mController.getActivity().runOnUiThread(new Runnable() {
	@Override
	public void run() {
	final WebView current = getCurrentWebview();
	if (current != null) {
	current.loadUrl(getInstantBaseUrl());
	}
	}
	});
	}

	/**
	* Queries for a given search term and returns a cursor containing
	* suggestions ordered by best match.
	*/
	@Override
	public Cursor getSuggestions(Context context, String query) {
	if (DBG) Log.d(TAG, "getSuggestions(" + query + ")");
	if (query == null) {
	return null;
	}

	if (!isInstantPage()) {
	loadInstantPage();
	}

	switchSearchboxIfNeeded();

	mController.registerDropdownChangeListener(this);

	if (mSearchBox == null) {
	return mWrapped.getSuggestions(context, query);
	}

	mSearchBox.setDimensions(0, 0, 0, mHeight);
	mSearchBox.onresize();

	if (TextUtils.isEmpty(query)) {
	// To force the SRP to render an empty (no results) page.
	mSearchBox.setVerbatim(true);
	} else {
	mSearchBox.setVerbatim(false);
	}
	mSearchBox.setQuery(query);
	mSearchBox.onchange();

	// Don't bother waiting for suggestions for an empty query. We still
	// set the query so that the SRP clears itself.
	if (TextUtils.isEmpty(query)) {
	return new SuggestionsCursor(Collections.<String>emptyList());
	} else {
	return new SuggestionsCursor(mListener.tryWaitForSuggestions(query));
	}
	}

	@Override
	public boolean supportsSuggestions() {
	return true;
	}

	@Override
	public void close() {
	if (mController != null) {
	mController.registerDropdownChangeListener(null);
	}
	if (mSearchBox != null) {
	mSearchBox.removeSearchBoxListener(mListener);
	}
	mListener.clear();
	mWrapped.close();
	}

	@Override
	public boolean supportsVoiceSearch() {
	return false;
	}

	@Override
	public String toString() {
	return "InstantSearchEngine {" + hashCode() + "}";
	}

	@Override
	public boolean wantsEmptyQuery() {
	return true;
	}

	private int rescaleHeight(int height) {
	final WebView current = getCurrentWebview();
	if (current == null) {
	return 0;
	}

	final float scale = current.getScale();
	if (scale != 0) {
	return (int) (height / scale);
	}

	return height;
	}

	@Override
	public void onNewDropdownDimensions(int height) {
	final int rescaledHeight = rescaleHeight(height);

	if (rescaledHeight != mHeight) {
	mHeight = rescaledHeight;
	if (mSearchBox != null) {
	mSearchBox.setDimensions(0, 0, 0, rescaledHeight);
	mSearchBox.onresize();
	}
	}
	}

	private String getInstantBaseUrl() {
	if (mInstantBaseUrl == null) {
	String url = mContext.getResources().getString(R.string.instant_base);
	if (url.indexOf("{CID}") != -1) {
	url = url.replace("{CID}",
	BrowserProvider.getClientId(mContext.getContentResolver()));
	}
	mInstantBaseUrl = url;
	}

	return mInstantBaseUrl;
	}

	// Indices of the columns in the below arrays.
	private static final int COLUMN_INDEX_ID = 0;
	private static final int COLUMN_INDEX_QUERY = 1;
	private static final int COLUMN_INDEX_ICON = 2;
	private static final int COLUMN_INDEX_TEXT_1 = 3;

	private static final String[] COLUMNS_WITHOUT_DESCRIPTION = new String[] {
	"_id",
	SearchManager.SUGGEST_COLUMN_QUERY,
	SearchManager.SUGGEST_COLUMN_ICON_1,
	SearchManager.SUGGEST_COLUMN_TEXT_1,
	};

	private static class SuggestionsCursor extends AbstractCursor {
	private final List<String> mSuggestions;

	public SuggestionsCursor(List<String> suggestions) {
	mSuggestions = suggestions;
	}

	@Override
	public int getCount() {
	return mSuggestions.size();
	}

	@Override
	public String[] getColumnNames() {
	return COLUMNS_WITHOUT_DESCRIPTION;
	}

	private String format(String suggestion) {
	if (TextUtils.isEmpty(suggestion)) {
	return "";
	}
	return suggestion;
	}

	@Override
	public String getString(int column) {
	if (mPos >= 0 && mPos < mSuggestions.size()) {
	if ((column == COLUMN_INDEX_QUERY) \|\| (column == COLUMN_INDEX_TEXT_1)) {
	return format(mSuggestions.get(mPos));
	} else if (column == COLUMN_INDEX_ICON) {
	return String.valueOf(R.drawable.magnifying_glass);
	}
	}
	return null;
	}

	@Override
	public double getDouble(int column) {
	throw new UnsupportedOperationException();
	}

	@Override
	public float getFloat(int column) {
	throw new UnsupportedOperationException();
	}

	@Override
	public int getInt(int column) {
	if (column == COLUMN_INDEX_ID) {
	return mPos;
	}
	throw new UnsupportedOperationException();
	}

	@Override
	public long getLong(int column) {
	throw new UnsupportedOperationException();
	}

	@Override
	public short getShort(int column) {
	throw new UnsupportedOperationException();
	}

	@Override
	public boolean isNull(int column) {
	throw new UnsupportedOperationException();
	}
	}
	}