core/java/android/server/search/SearchDialogWrapper.java - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2007 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 android.server.search;

 import android.app.ISearchManagerCallback;
 import android.app.SearchDialog;
 import android.app.SearchManager;
 import android.content.BroadcastReceiver;
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.DialogInterface;
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.os.Bundle;
 import android.os.DeadObjectException;
 import android.os.Handler;
 import android.os.HandlerThread;
 import android.os.Looper;
 import android.os.Message;
 import android.os.RemoteException;
 import android.os.SystemProperties;
 import android.text.TextUtils;
 import android.util.Log;

 /**
  * Runs an instance of {@link SearchDialog} on its own thread.
  */
 class SearchDialogWrapper
 implements DialogInterface.OnCancelListener, DialogInterface.OnDismissListener {

     private static final String TAG = "SearchManagerService";
     private static final boolean DBG = false;

     private static final String SEARCH_UI_THREAD_NAME = "SearchDialog";
     private static final int SEARCH_UI_THREAD_PRIORITY =
         android.os.Process.THREAD_PRIORITY_DEFAULT;

     // Takes no arguments
     private static final int MSG_INIT = 0;
     // Takes these arguments:
     // arg1: selectInitialQuery, 0 = false, 1 = true
     // arg2: globalSearch, 0 = false, 1 = true
     // obj: searchManagerCallback
     // data[KEY_INITIAL_QUERY]: initial query
     // data[KEY_LAUNCH_ACTIVITY]: launch activity
     // data[KEY_APP_SEARCH_DATA]: app search data
     // data[KEY_TRIGGER]: 0 = false, 1 = true
     private static final int MSG_START_SEARCH = 1;
     // Takes no arguments
     private static final int MSG_STOP_SEARCH = 2;
     // arg1 is activity id
     private static final int MSG_ACTIVITY_RESUMING = 3;
     // obj is the reason
     private static final int MSG_CLOSING_SYSTEM_DIALOGS = 4;

     private static final String KEY_INITIAL_QUERY = "q";
     private static final String KEY_LAUNCH_ACTIVITY = "a";
     private static final String KEY_APP_SEARCH_DATA = "d";
     private static final String KEY_IDENT = "i";
     private static final String KEY_TRIGGER = "t";

     // Context used for getting search UI resources
     private final Context mContext;

     // Handles messages on the search UI thread.
     private final SearchDialogHandler mSearchUiThread;

     // The search UI
     SearchDialog mSearchDialog;

     // If the search UI is visible, this is the callback for the client that showed it.
     ISearchManagerCallback mCallback = null;

     // Identity of last activity that started search.
     private int mStartedIdent = 0;

     // Identity of currently resumed activity.
     private int mResumedIdent = 0;

     // True if we have registered our receivers.
     private boolean mReceiverRegistered;

     private volatile boolean mVisible = false;

     /**
      * Creates a new search dialog wrapper and a search UI thread. The search dialog itself will
      * be created some asynchronously on the search UI thread.
      *
      * @param context Context used for getting search UI resources.
      */
     public SearchDialogWrapper(Context context) {
         mContext = context;

         // Create the search UI thread
         HandlerThread t = new HandlerThread(SEARCH_UI_THREAD_NAME, SEARCH_UI_THREAD_PRIORITY);
         t.start();
         mSearchUiThread = new SearchDialogHandler(t.getLooper());

         // Create search UI on the search UI thread
         mSearchUiThread.sendEmptyMessage(MSG_INIT);
     }

     public boolean isVisible() {
         return mVisible;
     }

     /**
      * Initializes the search UI.
      * Must be called from the search UI thread.
      */
     private void init() {
         mSearchDialog = new SearchDialog(mContext);
         mSearchDialog.setOnCancelListener(this);
         mSearchDialog.setOnDismissListener(this);
     }

     private void registerBroadcastReceiver() {
         if (!mReceiverRegistered) {
             IntentFilter filter = new IntentFilter(
                     Intent.ACTION_CONFIGURATION_CHANGED);
             mContext.registerReceiver(mBroadcastReceiver, filter, null,
                     mSearchUiThread);
             mReceiverRegistered = true;
         }
     }

     private void unregisterBroadcastReceiver() {
         if (mReceiverRegistered) {
             mContext.unregisterReceiver(mBroadcastReceiver);
             mReceiverRegistered = false;
         }
     }

     /**
      * Closes the search dialog when requested by the system (e.g. when a phone call comes in).
      */
     private BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() {
         @Override
         public void onReceive(Context context, Intent intent) {
             String action = intent.getAction();
             if (Intent.ACTION_CONFIGURATION_CHANGED.equals(action)) {
                 if (DBG) debug(Intent.ACTION_CONFIGURATION_CHANGED);
                 performOnConfigurationChanged();
             }
         }
     };

     //
     // External API
     //

     /**
      * Launches the search UI.
      * Can be called from any thread.
      *
      * @see SearchManager#startSearch(String, boolean, ComponentName, Bundle, boolean)
      */
     public void startSearch(final String initialQuery,
             final boolean selectInitialQuery,
             final ComponentName launchActivity,
             final Bundle appSearchData,
             final boolean globalSearch,
             final ISearchManagerCallback searchManagerCallback,
             int ident,
             boolean trigger) {
         if (DBG) debug("startSearch()");
         Message msg = Message.obtain();
         msg.what = MSG_START_SEARCH;
         msg.arg1 = selectInitialQuery ? 1 : 0;
         msg.arg2 = globalSearch ? 1 : 0;
         msg.obj = searchManagerCallback;
         Bundle msgData = msg.getData();
         msgData.putString(KEY_INITIAL_QUERY, initialQuery);
         msgData.putParcelable(KEY_LAUNCH_ACTIVITY, launchActivity);
         msgData.putBundle(KEY_APP_SEARCH_DATA, appSearchData);
         msgData.putInt(KEY_IDENT, ident);
         msgData.putInt(KEY_TRIGGER, trigger ? 1 : 0);
         mSearchUiThread.sendMessage(msg);
         // be a little more eager in setting this so isVisible will return the correct value if
         // called immediately after startSearch
         mVisible = true;
     }

     /**
      * Cancels the search dialog.
      * Can be called from any thread.
      */
     public void stopSearch() {
         if (DBG) debug("stopSearch()");
         mSearchUiThread.sendEmptyMessage(MSG_STOP_SEARCH);
         // be a little more eager in setting this so isVisible will return the correct value if
         // called immediately after stopSearch
         mVisible = false;
     }

     /**
      * Updates the currently resumed activity.
      * Can be called from any thread.
      */
     public void activityResuming(int ident) {
         if (DBG) debug("activityResuming(ident=" + ident + ")");
         Message msg = Message.obtain();
         msg.what = MSG_ACTIVITY_RESUMING;
         msg.arg1 = ident;
         mSearchUiThread.sendMessage(msg);
     }

     /**
      * Handles closing of system windows/dialogs
      * Can be called from any thread.
      */
     public void closingSystemDialogs(String reason) {
         if (DBG) debug("closingSystemDialogs(reason=" + reason + ")");
         Message msg = Message.obtain();
         msg.what = MSG_CLOSING_SYSTEM_DIALOGS;
         msg.obj = reason;
         mSearchUiThread.sendMessage(msg);
     }

     //
     // Implementation methods that run on the search UI thread
     //

     private class SearchDialogHandler extends Handler {

         public SearchDialogHandler(Looper looper) {
             super(looper);
         }

         @Override
         public void handleMessage(Message msg) {
             switch (msg.what) {
                 case MSG_INIT:
                     init();
                     break;
                 case MSG_START_SEARCH:
                     handleStartSearchMessage(msg);
                     break;
                 case MSG_STOP_SEARCH:
                     performStopSearch();
                     break;
                 case MSG_ACTIVITY_RESUMING:
                     performActivityResuming(msg.arg1);
                     break;
                 case MSG_CLOSING_SYSTEM_DIALOGS:
                     performClosingSystemDialogs((String)msg.obj);
                     break;
             }
         }

         private void handleStartSearchMessage(Message msg) {
             Bundle msgData = msg.getData();
             String initialQuery = msgData.getString(KEY_INITIAL_QUERY);
             boolean selectInitialQuery = msg.arg1 != 0;
             ComponentName launchActivity =
                     (ComponentName) msgData.getParcelable(KEY_LAUNCH_ACTIVITY);
             Bundle appSearchData = msgData.getBundle(KEY_APP_SEARCH_DATA);
             boolean globalSearch = msg.arg2 != 0;
             ISearchManagerCallback searchManagerCallback = (ISearchManagerCallback) msg.obj;
             int ident = msgData.getInt(KEY_IDENT);
             boolean trigger = msgData.getInt(KEY_TRIGGER) != 0;
             performStartSearch(initialQuery, selectInitialQuery, launchActivity,
                     appSearchData, globalSearch, searchManagerCallback, ident, trigger);
         }

     }

     /**
      * Actually launches the search UI.
      * This must be called on the search UI thread.
      */
     void performStartSearch(String initialQuery,
             boolean selectInitialQuery,
             ComponentName launchActivity,
             Bundle appSearchData,
             boolean globalSearch,
             ISearchManagerCallback searchManagerCallback,
             int ident,
             boolean trigger) {
         if (DBG) debug("performStartSearch()");

         registerBroadcastReceiver();
         mCallback = searchManagerCallback;

         // clean up any hidden dialog that we were waiting to resume
         if (mStartedIdent != 0) {
             mSearchDialog.dismiss();
         }

         mStartedIdent = ident;
         if (DBG) Log.v(TAG, "******************* DIALOG: start");

         mSearchDialog.show(initialQuery, selectInitialQuery, launchActivity, appSearchData,
                 globalSearch);
         mVisible = true;
         if (trigger) {
             mSearchDialog.launchQuerySearch();
         }
     }

     /**
      * Actually cancels the search UI.
      * This must be called on the search UI thread.
      */
     void performStopSearch() {
         if (DBG) debug("performStopSearch()");
         if (DBG) Log.v(TAG, "******************* DIALOG: cancel");
         mSearchDialog.cancel();
         mVisible = false;
         mStartedIdent = 0;
     }

     /**
      * Updates the resumed activity
      * This must be called on the search UI thread.
      */
     void performActivityResuming(int ident) {
         if (DBG) debug("performResumingActivity(): mStartedIdent="
                 + mStartedIdent + ", resuming: " + ident);
         this.mResumedIdent = ident;
         if (mStartedIdent != 0) {
             if (mStartedIdent == mResumedIdent) {
                 // we are resuming into the activity where we previously hid the dialog, bring it
                 // back
                 if (DBG) Log.v(TAG, "******************* DIALOG: show");
                 mSearchDialog.show();
                 mVisible = true;
             } else {
                 // resuming into some other activity; hide ourselves in case we ever come back
                 // so we can show ourselves quickly again
                 if (DBG) Log.v(TAG, "******************* DIALOG: hide");
                 mSearchDialog.hide();
                 mVisible = false;
             }
         }
     }

     /**
      * Updates due to system dialogs being closed
      * This must be called on the search UI thread.
      */
     void performClosingSystemDialogs(String reason) {
         if (DBG) debug("performClosingSystemDialogs(): mStartedIdent="
                 + mStartedIdent + ", reason: " + reason);
         if (!"search".equals(reason)) {
             if (DBG) debug(Intent.ACTION_CLOSE_SYSTEM_DIALOGS);
             performStopSearch();
         }
     }

     /**
      * Must be called from the search UI thread.
      */
     void performOnConfigurationChanged() {
         if (DBG) debug("performOnConfigurationChanged()");
         mSearchDialog.onConfigurationChanged();
     }

     /**
      * Called by {@link SearchDialog} when it goes away.
      */
     public void onDismiss(DialogInterface dialog) {
         if (DBG) debug("onDismiss()");
         mStartedIdent = 0;
         mVisible = false;
         callOnDismiss();

         // we don't need the callback anymore, release it
         mCallback = null;
         unregisterBroadcastReceiver();
     }


     /**
      * Called by {@link SearchDialog} when the user or activity cancels search.
      * Whenever this method is called, {@link #onDismiss} is always called afterwards.
      */
     public void onCancel(DialogInterface dialog) {
         if (DBG) debug("onCancel()");
         callOnCancel();
     }

     private void callOnDismiss() {
         if (mCallback == null) return;
         try {
             // should be safe to do on the search UI thread, since it's a oneway interface
             mCallback.onDismiss();
         } catch (DeadObjectException ex) {
             // The process that hosted the callback has died, do nothing
         } catch (RemoteException ex) {
             Log.e(TAG, "onDismiss() failed: " + ex);
         }
     }

     private void callOnCancel() {
         if (mCallback != null) {
             try {
                 // should be safe to do on the search UI thread, since it's a oneway interface
                 mCallback.onCancel();
             } catch (DeadObjectException ex) {
                 // The process that hosted the callback has died, do nothing
             } catch (RemoteException ex) {
                 Log.e(TAG, "onCancel() failed: " + ex);
             }
         }
     }

     private static void debug(String msg) {
         Thread thread = Thread.currentThread();
         Log.d(TAG, msg + " (" + thread.getName() + "-" + thread.getId() + ")");
     }
 }
	/*
	* Copyright (C) 2007 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 android.server.search;

	import android.app.ISearchManagerCallback;
	import android.app.SearchDialog;
	import android.app.SearchManager;
	import android.content.BroadcastReceiver;
	import android.content.ComponentName;
	import android.content.Context;
	import android.content.DialogInterface;
	import android.content.Intent;
	import android.content.IntentFilter;
	import android.os.Bundle;
	import android.os.DeadObjectException;
	import android.os.Handler;
	import android.os.HandlerThread;
	import android.os.Looper;
	import android.os.Message;
	import android.os.RemoteException;
	import android.os.SystemProperties;
	import android.text.TextUtils;
	import android.util.Log;

	/**
	* Runs an instance of {@link SearchDialog} on its own thread.
	*/
	class SearchDialogWrapper
	implements DialogInterface.OnCancelListener, DialogInterface.OnDismissListener {

	private static final String TAG = "SearchManagerService";
	private static final boolean DBG = false;

	private static final String SEARCH_UI_THREAD_NAME = "SearchDialog";
	private static final int SEARCH_UI_THREAD_PRIORITY =
	android.os.Process.THREAD_PRIORITY_DEFAULT;

	// Takes no arguments
	private static final int MSG_INIT = 0;
	// Takes these arguments:
	// arg1: selectInitialQuery, 0 = false, 1 = true
	// arg2: globalSearch, 0 = false, 1 = true
	// obj: searchManagerCallback
	// data[KEY_INITIAL_QUERY]: initial query
	// data[KEY_LAUNCH_ACTIVITY]: launch activity
	// data[KEY_APP_SEARCH_DATA]: app search data
	// data[KEY_TRIGGER]: 0 = false, 1 = true
	private static final int MSG_START_SEARCH = 1;
	// Takes no arguments
	private static final int MSG_STOP_SEARCH = 2;
	// arg1 is activity id
	private static final int MSG_ACTIVITY_RESUMING = 3;
	// obj is the reason
	private static final int MSG_CLOSING_SYSTEM_DIALOGS = 4;

	private static final String KEY_INITIAL_QUERY = "q";
	private static final String KEY_LAUNCH_ACTIVITY = "a";
	private static final String KEY_APP_SEARCH_DATA = "d";
	private static final String KEY_IDENT = "i";
	private static final String KEY_TRIGGER = "t";

	// Context used for getting search UI resources
	private final Context mContext;

	// Handles messages on the search UI thread.
	private final SearchDialogHandler mSearchUiThread;

	// The search UI
	SearchDialog mSearchDialog;

	// If the search UI is visible, this is the callback for the client that showed it.
	ISearchManagerCallback mCallback = null;

	// Identity of last activity that started search.
	private int mStartedIdent = 0;

	// Identity of currently resumed activity.
	private int mResumedIdent = 0;

	// True if we have registered our receivers.
	private boolean mReceiverRegistered;

	private volatile boolean mVisible = false;

	/**
	* Creates a new search dialog wrapper and a search UI thread. The search dialog itself will
	* be created some asynchronously on the search UI thread.
	*
	* @param context Context used for getting search UI resources.
	*/
	public SearchDialogWrapper(Context context) {
	mContext = context;

	// Create the search UI thread
	HandlerThread t = new HandlerThread(SEARCH_UI_THREAD_NAME, SEARCH_UI_THREAD_PRIORITY);
	t.start();
	mSearchUiThread = new SearchDialogHandler(t.getLooper());

	// Create search UI on the search UI thread
	mSearchUiThread.sendEmptyMessage(MSG_INIT);
	}

	public boolean isVisible() {
	return mVisible;
	}

	/**
	* Initializes the search UI.
	* Must be called from the search UI thread.
	*/
	private void init() {
	mSearchDialog = new SearchDialog(mContext);
	mSearchDialog.setOnCancelListener(this);
	mSearchDialog.setOnDismissListener(this);
	}

	private void registerBroadcastReceiver() {
	if (!mReceiverRegistered) {
	IntentFilter filter = new IntentFilter(
	Intent.ACTION_CONFIGURATION_CHANGED);
	mContext.registerReceiver(mBroadcastReceiver, filter, null,
	mSearchUiThread);
	mReceiverRegistered = true;
	}
	}

	private void unregisterBroadcastReceiver() {
	if (mReceiverRegistered) {
	mContext.unregisterReceiver(mBroadcastReceiver);
	mReceiverRegistered = false;
	}
	}

	/**
	* Closes the search dialog when requested by the system (e.g. when a phone call comes in).
	*/
	private BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() {
	@Override
	public void onReceive(Context context, Intent intent) {
	String action = intent.getAction();
	if (Intent.ACTION_CONFIGURATION_CHANGED.equals(action)) {
	if (DBG) debug(Intent.ACTION_CONFIGURATION_CHANGED);
	performOnConfigurationChanged();
	}
	}
	};

	//
	// External API
	//

	/**
	* Launches the search UI.
	* Can be called from any thread.
	*
	* @see SearchManager#startSearch(String, boolean, ComponentName, Bundle, boolean)
	*/
	public void startSearch(final String initialQuery,
	final boolean selectInitialQuery,
	final ComponentName launchActivity,
	final Bundle appSearchData,
	final boolean globalSearch,
	final ISearchManagerCallback searchManagerCallback,
	int ident,
	boolean trigger) {
	if (DBG) debug("startSearch()");
	Message msg = Message.obtain();
	msg.what = MSG_START_SEARCH;
	msg.arg1 = selectInitialQuery ? 1 : 0;
	msg.arg2 = globalSearch ? 1 : 0;
	msg.obj = searchManagerCallback;
	Bundle msgData = msg.getData();
	msgData.putString(KEY_INITIAL_QUERY, initialQuery);
	msgData.putParcelable(KEY_LAUNCH_ACTIVITY, launchActivity);
	msgData.putBundle(KEY_APP_SEARCH_DATA, appSearchData);
	msgData.putInt(KEY_IDENT, ident);
	msgData.putInt(KEY_TRIGGER, trigger ? 1 : 0);
	mSearchUiThread.sendMessage(msg);
	// be a little more eager in setting this so isVisible will return the correct value if
	// called immediately after startSearch
	mVisible = true;
	}

	/**
	* Cancels the search dialog.
	* Can be called from any thread.
	*/
	public void stopSearch() {
	if (DBG) debug("stopSearch()");
	mSearchUiThread.sendEmptyMessage(MSG_STOP_SEARCH);
	// be a little more eager in setting this so isVisible will return the correct value if
	// called immediately after stopSearch
	mVisible = false;
	}

	/**
	* Updates the currently resumed activity.
	* Can be called from any thread.
	*/
	public void activityResuming(int ident) {
	if (DBG) debug("activityResuming(ident=" + ident + ")");
	Message msg = Message.obtain();
	msg.what = MSG_ACTIVITY_RESUMING;
	msg.arg1 = ident;
	mSearchUiThread.sendMessage(msg);
	}

	/**
	* Handles closing of system windows/dialogs
	* Can be called from any thread.
	*/
	public void closingSystemDialogs(String reason) {
	if (DBG) debug("closingSystemDialogs(reason=" + reason + ")");
	Message msg = Message.obtain();
	msg.what = MSG_CLOSING_SYSTEM_DIALOGS;
	msg.obj = reason;
	mSearchUiThread.sendMessage(msg);
	}

	//
	// Implementation methods that run on the search UI thread
	//

	private class SearchDialogHandler extends Handler {

	public SearchDialogHandler(Looper looper) {
	super(looper);
	}

	@Override
	public void handleMessage(Message msg) {
	switch (msg.what) {
	case MSG_INIT:
	init();
	break;
	case MSG_START_SEARCH:
	handleStartSearchMessage(msg);
	break;
	case MSG_STOP_SEARCH:
	performStopSearch();
	break;
	case MSG_ACTIVITY_RESUMING:
	performActivityResuming(msg.arg1);
	break;
	case MSG_CLOSING_SYSTEM_DIALOGS:
	performClosingSystemDialogs((String)msg.obj);
	break;
	}
	}

	private void handleStartSearchMessage(Message msg) {
	Bundle msgData = msg.getData();
	String initialQuery = msgData.getString(KEY_INITIAL_QUERY);
	boolean selectInitialQuery = msg.arg1 != 0;
	ComponentName launchActivity =
	(ComponentName) msgData.getParcelable(KEY_LAUNCH_ACTIVITY);
	Bundle appSearchData = msgData.getBundle(KEY_APP_SEARCH_DATA);
	boolean globalSearch = msg.arg2 != 0;
	ISearchManagerCallback searchManagerCallback = (ISearchManagerCallback) msg.obj;
	int ident = msgData.getInt(KEY_IDENT);
	boolean trigger = msgData.getInt(KEY_TRIGGER) != 0;
	performStartSearch(initialQuery, selectInitialQuery, launchActivity,
	appSearchData, globalSearch, searchManagerCallback, ident, trigger);
	}

	}

	/**
	* Actually launches the search UI.
	* This must be called on the search UI thread.
	*/
	void performStartSearch(String initialQuery,
	boolean selectInitialQuery,
	ComponentName launchActivity,
	Bundle appSearchData,
	boolean globalSearch,
	ISearchManagerCallback searchManagerCallback,
	int ident,
	boolean trigger) {
	if (DBG) debug("performStartSearch()");

	registerBroadcastReceiver();
	mCallback = searchManagerCallback;

	// clean up any hidden dialog that we were waiting to resume
	if (mStartedIdent != 0) {
	mSearchDialog.dismiss();
	}

	mStartedIdent = ident;
	if (DBG) Log.v(TAG, "******************* DIALOG: start");

	mSearchDialog.show(initialQuery, selectInitialQuery, launchActivity, appSearchData,
	globalSearch);
	mVisible = true;
	if (trigger) {
	mSearchDialog.launchQuerySearch();
	}
	}

	/**
	* Actually cancels the search UI.
	* This must be called on the search UI thread.
	*/
	void performStopSearch() {
	if (DBG) debug("performStopSearch()");
	if (DBG) Log.v(TAG, "******************* DIALOG: cancel");
	mSearchDialog.cancel();
	mVisible = false;
	mStartedIdent = 0;
	}

	/**
	* Updates the resumed activity
	* This must be called on the search UI thread.
	*/
	void performActivityResuming(int ident) {
	if (DBG) debug("performResumingActivity(): mStartedIdent="
	+ mStartedIdent + ", resuming: " + ident);
	this.mResumedIdent = ident;
	if (mStartedIdent != 0) {
	if (mStartedIdent == mResumedIdent) {
	// we are resuming into the activity where we previously hid the dialog, bring it
	// back
	if (DBG) Log.v(TAG, "******************* DIALOG: show");
	mSearchDialog.show();
	mVisible = true;
	} else {
	// resuming into some other activity; hide ourselves in case we ever come back
	// so we can show ourselves quickly again
	if (DBG) Log.v(TAG, "******************* DIALOG: hide");
	mSearchDialog.hide();
	mVisible = false;
	}
	}
	}

	/**
	* Updates due to system dialogs being closed
	* This must be called on the search UI thread.
	*/
	void performClosingSystemDialogs(String reason) {
	if (DBG) debug("performClosingSystemDialogs(): mStartedIdent="
	+ mStartedIdent + ", reason: " + reason);
	if (!"search".equals(reason)) {
	if (DBG) debug(Intent.ACTION_CLOSE_SYSTEM_DIALOGS);
	performStopSearch();
	}
	}

	/**
	* Must be called from the search UI thread.
	*/
	void performOnConfigurationChanged() {
	if (DBG) debug("performOnConfigurationChanged()");
	mSearchDialog.onConfigurationChanged();
	}

	/**
	* Called by {@link SearchDialog} when it goes away.
	*/
	public void onDismiss(DialogInterface dialog) {
	if (DBG) debug("onDismiss()");
	mStartedIdent = 0;
	mVisible = false;
	callOnDismiss();

	// we don't need the callback anymore, release it
	mCallback = null;
	unregisterBroadcastReceiver();
	}


	/**
	* Called by {@link SearchDialog} when the user or activity cancels search.
	* Whenever this method is called, {@link #onDismiss} is always called afterwards.
	*/
	public void onCancel(DialogInterface dialog) {
	if (DBG) debug("onCancel()");
	callOnCancel();
	}

	private void callOnDismiss() {
	if (mCallback == null) return;
	try {
	// should be safe to do on the search UI thread, since it's a oneway interface
	mCallback.onDismiss();
	} catch (DeadObjectException ex) {
	// The process that hosted the callback has died, do nothing
	} catch (RemoteException ex) {
	Log.e(TAG, "onDismiss() failed: " + ex);
	}
	}

	private void callOnCancel() {
	if (mCallback != null) {
	try {
	// should be safe to do on the search UI thread, since it's a oneway interface
	mCallback.onCancel();
	} catch (DeadObjectException ex) {
	// The process that hosted the callback has died, do nothing
	} catch (RemoteException ex) {
	Log.e(TAG, "onCancel() failed: " + ex);
	}
	}
	}

	private static void debug(String msg) {
	Thread thread = Thread.currentThread();
	Log.d(TAG, msg + " (" + thread.getName() + "-" + thread.getId() + ")");
	}
	}