src.android.widget.SearchView Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of android-all Show documentation
Show all versions of android-all Show documentation
A library jar that provides APIs for Applications written for the Google Android Platform.
/*
* Copyright (C) 2010 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.widget;
import static android.widget.SuggestionsAdapter.getColumnString;
import android.annotation.Nullable;
import android.app.PendingIntent;
import android.app.SearchManager;
import android.app.SearchableInfo;
import android.compat.annotation.UnsupportedAppUsage;
import android.content.ActivityNotFoundException;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.content.pm.ResolveInfo;
import android.content.res.Configuration;
import android.content.res.Resources;
import android.content.res.TypedArray;
import android.database.Cursor;
import android.graphics.Rect;
import android.graphics.drawable.Drawable;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.os.Parcel;
import android.os.Parcelable;
import android.speech.RecognizerIntent;
import android.text.Editable;
import android.text.InputType;
import android.text.Spannable;
import android.text.SpannableStringBuilder;
import android.text.TextUtils;
import android.text.TextWatcher;
import android.text.style.ImageSpan;
import android.util.AttributeSet;
import android.util.DisplayMetrics;
import android.util.Log;
import android.util.TypedValue;
import android.view.CollapsibleActionView;
import android.view.KeyEvent;
import android.view.LayoutInflater;
import android.view.MotionEvent;
import android.view.TouchDelegate;
import android.view.View;
import android.view.ViewConfiguration;
import android.view.inputmethod.EditorInfo;
import android.view.inputmethod.InputConnection;
import android.view.inputmethod.InputMethodManager;
import android.view.inspector.InspectableProperty;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.AdapterView.OnItemSelectedListener;
import android.widget.TextView.OnEditorActionListener;
import com.android.internal.R;
import java.util.WeakHashMap;
/**
* A widget that provides a user interface for the user to enter a search query and submit a request
* to a search provider. Shows a list of query suggestions or results, if available, and allows the
* user to pick a suggestion or result to launch into.
*
*
* When the SearchView is used in an ActionBar as an action view for a collapsible menu item, it
* needs to be set to iconified by default using {@link #setIconifiedByDefault(boolean)
* setIconifiedByDefault(true)}. This is the default, so nothing needs to be done.
*
*
* If you want the search field to always be visible, then call setIconifiedByDefault(false).
*
*
*
* Developer Guides
* For information about using {@code SearchView}, read the
* Search developer guide.
*
*
* @see android.view.MenuItem#SHOW_AS_ACTION_COLLAPSE_ACTION_VIEW
* @attr ref android.R.styleable#SearchView_iconifiedByDefault
* @attr ref android.R.styleable#SearchView_imeOptions
* @attr ref android.R.styleable#SearchView_inputType
* @attr ref android.R.styleable#SearchView_maxWidth
* @attr ref android.R.styleable#SearchView_queryHint
*/
public class SearchView extends LinearLayout implements CollapsibleActionView {
private static final boolean DBG = false;
private static final String LOG_TAG = "SearchView";
/**
* Private constant for removing the microphone in the keyboard.
*/
private static final String IME_OPTION_NO_MICROPHONE = "nm";
@UnsupportedAppUsage
private final SearchAutoComplete mSearchSrcTextView;
@UnsupportedAppUsage
private final View mSearchEditFrame;
@UnsupportedAppUsage
private final View mSearchPlate;
@UnsupportedAppUsage
private final View mSubmitArea;
@UnsupportedAppUsage
private final ImageView mSearchButton;
private final ImageView mGoButton;
@UnsupportedAppUsage
private final ImageView mCloseButton;
@UnsupportedAppUsage
private final ImageView mVoiceButton;
private final View mDropDownAnchor;
private UpdatableTouchDelegate mTouchDelegate;
private Rect mSearchSrcTextViewBounds = new Rect();
private Rect mSearchSrtTextViewBoundsExpanded = new Rect();
private int[] mTemp = new int[2];
private int[] mTemp2 = new int[2];
/** Icon optionally displayed when the SearchView is collapsed. */
private final ImageView mCollapsedIcon;
/** Drawable used as an EditText hint. */
@UnsupportedAppUsage
private final Drawable mSearchHintIcon;
// Resources used by SuggestionsAdapter to display suggestions.
private final int mSuggestionRowLayout;
private final int mSuggestionCommitIconResId;
// Intents used for voice searching.
private final Intent mVoiceWebSearchIntent;
private final Intent mVoiceAppSearchIntent;
private final CharSequence mDefaultQueryHint;
@UnsupportedAppUsage
private OnQueryTextListener mOnQueryChangeListener;
private OnCloseListener mOnCloseListener;
private OnFocusChangeListener mOnQueryTextFocusChangeListener;
private OnSuggestionListener mOnSuggestionListener;
private OnClickListener mOnSearchClickListener;
@UnsupportedAppUsage
private boolean mIconifiedByDefault;
@UnsupportedAppUsage
private boolean mIconified;
@UnsupportedAppUsage
private CursorAdapter mSuggestionsAdapter;
private boolean mSubmitButtonEnabled;
private CharSequence mQueryHint;
private boolean mQueryRefinement;
@UnsupportedAppUsage
private boolean mClearingFocus;
private int mMaxWidth;
@UnsupportedAppUsage
private boolean mVoiceButtonEnabled;
private CharSequence mOldQueryText;
@UnsupportedAppUsage
private CharSequence mUserQuery;
@UnsupportedAppUsage
private boolean mExpandedInActionView;
@UnsupportedAppUsage
private int mCollapsedImeOptions;
private SearchableInfo mSearchable;
private Bundle mAppSearchData;
private Runnable mUpdateDrawableStateRunnable = new Runnable() {
public void run() {
updateFocusedState();
}
};
private Runnable mReleaseCursorRunnable = new Runnable() {
public void run() {
if (mSuggestionsAdapter != null && mSuggestionsAdapter instanceof SuggestionsAdapter) {
mSuggestionsAdapter.changeCursor(null);
}
}
};
// A weak map of drawables we've gotten from other packages, so we don't load them
// more than once.
private final WeakHashMap mOutsideDrawablesCache =
new WeakHashMap();
/**
* Callbacks for changes to the query text.
*/
public interface OnQueryTextListener {
/**
* Called when the user submits the query. This could be due to a key press on the
* keyboard or due to pressing a submit button.
* The listener can override the standard behavior by returning true
* to indicate that it has handled the submit request. Otherwise return false to
* let the SearchView handle the submission by launching any associated intent.
*
* @param query the query text that is to be submitted
*
* @return true if the query has been handled by the listener, false to let the
* SearchView perform the default action.
*/
boolean onQueryTextSubmit(String query);
/**
* Called when the query text is changed by the user.
*
* @param newText the new content of the query text field.
*
* @return false if the SearchView should perform the default action of showing any
* suggestions if available, true if the action was handled by the listener.
*/
boolean onQueryTextChange(String newText);
}
public interface OnCloseListener {
/**
* The user is attempting to close the SearchView.
*
* @return true if the listener wants to override the default behavior of clearing the
* text field and dismissing it, false otherwise.
*/
boolean onClose();
}
/**
* Callback interface for selection events on suggestions. These callbacks
* are only relevant when a SearchableInfo has been specified by {@link #setSearchableInfo}.
*/
public interface OnSuggestionListener {
/**
* Called when a suggestion was selected by navigating to it.
* @param position the absolute position in the list of suggestions.
*
* @return true if the listener handles the event and wants to override the default
* behavior of possibly rewriting the query based on the selected item, false otherwise.
*/
boolean onSuggestionSelect(int position);
/**
* Called when a suggestion was clicked.
* @param position the absolute position of the clicked item in the list of suggestions.
*
* @return true if the listener handles the event and wants to override the default
* behavior of launching any intent or submitting a search query specified on that item.
* Return false otherwise.
*/
boolean onSuggestionClick(int position);
}
public SearchView(Context context) {
this(context, null);
}
public SearchView(Context context, AttributeSet attrs) {
this(context, attrs, R.attr.searchViewStyle);
}
public SearchView(Context context, AttributeSet attrs, int defStyleAttr) {
this(context, attrs, defStyleAttr, 0);
}
public SearchView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
super(context, attrs, defStyleAttr, defStyleRes);
final TypedArray a = context.obtainStyledAttributes(
attrs, R.styleable.SearchView, defStyleAttr, defStyleRes);
saveAttributeDataForStyleable(context, R.styleable.SearchView,
attrs, a, defStyleAttr, defStyleRes);
final LayoutInflater inflater = (LayoutInflater) context.getSystemService(
Context.LAYOUT_INFLATER_SERVICE);
final int layoutResId = a.getResourceId(
R.styleable.SearchView_layout, R.layout.search_view);
inflater.inflate(layoutResId, this, true);
mSearchSrcTextView = (SearchAutoComplete) findViewById(R.id.search_src_text);
mSearchSrcTextView.setSearchView(this);
mSearchEditFrame = findViewById(R.id.search_edit_frame);
mSearchPlate = findViewById(R.id.search_plate);
mSubmitArea = findViewById(R.id.submit_area);
mSearchButton = (ImageView) findViewById(R.id.search_button);
mGoButton = (ImageView) findViewById(R.id.search_go_btn);
mCloseButton = (ImageView) findViewById(R.id.search_close_btn);
mVoiceButton = (ImageView) findViewById(R.id.search_voice_btn);
mCollapsedIcon = (ImageView) findViewById(R.id.search_mag_icon);
// Set up icons and backgrounds.
mSearchPlate.setBackground(a.getDrawable(R.styleable.SearchView_queryBackground));
mSubmitArea.setBackground(a.getDrawable(R.styleable.SearchView_submitBackground));
mSearchButton.setImageDrawable(a.getDrawable(R.styleable.SearchView_searchIcon));
mGoButton.setImageDrawable(a.getDrawable(R.styleable.SearchView_goIcon));
mCloseButton.setImageDrawable(a.getDrawable(R.styleable.SearchView_closeIcon));
mVoiceButton.setImageDrawable(a.getDrawable(R.styleable.SearchView_voiceIcon));
mCollapsedIcon.setImageDrawable(a.getDrawable(R.styleable.SearchView_searchIcon));
// Prior to L MR1, the search hint icon defaulted to searchIcon. If the
// style does not have an explicit value set, fall back to that.
if (a.hasValueOrEmpty(R.styleable.SearchView_searchHintIcon)) {
mSearchHintIcon = a.getDrawable(R.styleable.SearchView_searchHintIcon);
} else {
mSearchHintIcon = a.getDrawable(R.styleable.SearchView_searchIcon);
}
// Extract dropdown layout resource IDs for later use.
mSuggestionRowLayout = a.getResourceId(R.styleable.SearchView_suggestionRowLayout,
R.layout.search_dropdown_item_icons_2line);
mSuggestionCommitIconResId = a.getResourceId(R.styleable.SearchView_commitIcon, 0);
mSearchButton.setOnClickListener(mOnClickListener);
mCloseButton.setOnClickListener(mOnClickListener);
mGoButton.setOnClickListener(mOnClickListener);
mVoiceButton.setOnClickListener(mOnClickListener);
mSearchSrcTextView.setOnClickListener(mOnClickListener);
mSearchSrcTextView.addTextChangedListener(mTextWatcher);
mSearchSrcTextView.setOnEditorActionListener(mOnEditorActionListener);
mSearchSrcTextView.setOnItemClickListener(mOnItemClickListener);
mSearchSrcTextView.setOnItemSelectedListener(mOnItemSelectedListener);
mSearchSrcTextView.setOnKeyListener(mTextKeyListener);
// Inform any listener of focus changes
mSearchSrcTextView.setOnFocusChangeListener(new OnFocusChangeListener() {
public void onFocusChange(View v, boolean hasFocus) {
if (mOnQueryTextFocusChangeListener != null) {
mOnQueryTextFocusChangeListener.onFocusChange(SearchView.this, hasFocus);
}
}
});
setIconifiedByDefault(a.getBoolean(R.styleable.SearchView_iconifiedByDefault, true));
final int maxWidth = a.getDimensionPixelSize(R.styleable.SearchView_maxWidth, -1);
if (maxWidth != -1) {
setMaxWidth(maxWidth);
}
mDefaultQueryHint = a.getText(R.styleable.SearchView_defaultQueryHint);
mQueryHint = a.getText(R.styleable.SearchView_queryHint);
final int imeOptions = a.getInt(R.styleable.SearchView_imeOptions, -1);
if (imeOptions != -1) {
setImeOptions(imeOptions);
}
final int inputType = a.getInt(R.styleable.SearchView_inputType, -1);
if (inputType != -1) {
setInputType(inputType);
}
if (getFocusable() == FOCUSABLE_AUTO) {
setFocusable(FOCUSABLE);
}
a.recycle();
// Save voice intent for later queries/launching
mVoiceWebSearchIntent = new Intent(RecognizerIntent.ACTION_WEB_SEARCH);
mVoiceWebSearchIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
mVoiceWebSearchIntent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL,
RecognizerIntent.LANGUAGE_MODEL_WEB_SEARCH);
mVoiceAppSearchIntent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);
mVoiceAppSearchIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
mDropDownAnchor = findViewById(mSearchSrcTextView.getDropDownAnchor());
if (mDropDownAnchor != null) {
mDropDownAnchor.addOnLayoutChangeListener(new OnLayoutChangeListener() {
@Override
public void onLayoutChange(View v, int left, int top, int right, int bottom,
int oldLeft, int oldTop, int oldRight, int oldBottom) {
adjustDropDownSizeAndPosition();
}
});
}
updateViewsVisibility(mIconifiedByDefault);
updateQueryHint();
}
int getSuggestionRowLayout() {
return mSuggestionRowLayout;
}
int getSuggestionCommitIconResId() {
return mSuggestionCommitIconResId;
}
/**
* Sets the SearchableInfo for this SearchView. Properties in the SearchableInfo are used
* to display labels, hints, suggestions, create intents for launching search results screens
* and controlling other affordances such as a voice button.
*
* @param searchable a SearchableInfo can be retrieved from the SearchManager, for a specific
* activity or a global search provider.
*/
public void setSearchableInfo(SearchableInfo searchable) {
mSearchable = searchable;
if (mSearchable != null) {
updateSearchAutoComplete();
updateQueryHint();
}
// Cache the voice search capability
mVoiceButtonEnabled = hasVoiceSearch();
if (mVoiceButtonEnabled) {
// Disable the microphone on the keyboard, as a mic is displayed near the text box
// TODO: use imeOptions to disable voice input when the new API will be available
mSearchSrcTextView.setPrivateImeOptions(IME_OPTION_NO_MICROPHONE);
}
updateViewsVisibility(isIconified());
}
/**
* Sets the APP_DATA for legacy SearchDialog use.
* @param appSearchData bundle provided by the app when launching the search dialog
* @hide
*/
public void setAppSearchData(Bundle appSearchData) {
mAppSearchData = appSearchData;
}
/**
* Sets the IME options on the query text field.
*
* @see TextView#setImeOptions(int)
* @param imeOptions the options to set on the query text field
*
* @attr ref android.R.styleable#SearchView_imeOptions
*/
public void setImeOptions(int imeOptions) {
mSearchSrcTextView.setImeOptions(imeOptions);
}
/**
* Returns the IME options set on the query text field.
* @return the ime options
* @see TextView#setImeOptions(int)
*
* @attr ref android.R.styleable#SearchView_imeOptions
*/
public int getImeOptions() {
return mSearchSrcTextView.getImeOptions();
}
/**
* Sets the input type on the query text field.
*
* @see TextView#setInputType(int)
* @param inputType the input type to set on the query text field
*
* @attr ref android.R.styleable#SearchView_inputType
*/
public void setInputType(int inputType) {
mSearchSrcTextView.setInputType(inputType);
}
/**
* Returns the input type set on the query text field.
* @return the input type
*
* @attr ref android.R.styleable#SearchView_inputType
*/
public int getInputType() {
return mSearchSrcTextView.getInputType();
}
/** @hide */
@Override
public boolean requestFocus(int direction, Rect previouslyFocusedRect) {
// Don't accept focus if in the middle of clearing focus
if (mClearingFocus) return false;
// Check if SearchView is focusable.
if (!isFocusable()) return false;
// If it is not iconified, then give the focus to the text field
if (!isIconified()) {
boolean result = mSearchSrcTextView.requestFocus(direction, previouslyFocusedRect);
if (result) {
updateViewsVisibility(false);
}
return result;
} else {
return super.requestFocus(direction, previouslyFocusedRect);
}
}
/** @hide */
@Override
public void clearFocus() {
mClearingFocus = true;
super.clearFocus();
mSearchSrcTextView.clearFocus();
mSearchSrcTextView.setImeVisibility(false);
mClearingFocus = false;
}
/**
* Sets a listener for user actions within the SearchView.
*
* @param listener the listener object that receives callbacks when the user performs
* actions in the SearchView such as clicking on buttons or typing a query.
*/
public void setOnQueryTextListener(OnQueryTextListener listener) {
mOnQueryChangeListener = listener;
}
/**
* Sets a listener to inform when the user closes the SearchView.
*
* @param listener the listener to call when the user closes the SearchView.
*/
public void setOnCloseListener(OnCloseListener listener) {
mOnCloseListener = listener;
}
/**
* Sets a listener to inform when the focus of the query text field changes.
*
* @param listener the listener to inform of focus changes.
*/
public void setOnQueryTextFocusChangeListener(OnFocusChangeListener listener) {
mOnQueryTextFocusChangeListener = listener;
}
/**
* Sets a listener to inform when a suggestion is focused or clicked.
*
* @param listener the listener to inform of suggestion selection events.
*/
public void setOnSuggestionListener(OnSuggestionListener listener) {
mOnSuggestionListener = listener;
}
/**
* Sets a listener to inform when the search button is pressed. This is only
* relevant when the text field is not visible by default. Calling {@link #setIconified
* setIconified(false)} can also cause this listener to be informed.
*
* @param listener the listener to inform when the search button is clicked or
* the text field is programmatically de-iconified.
*/
public void setOnSearchClickListener(OnClickListener listener) {
mOnSearchClickListener = listener;
}
/**
* Returns the query string currently in the text field.
*
* @return the query string
*/
@InspectableProperty(hasAttributeId = false)
public CharSequence getQuery() {
return mSearchSrcTextView.getText();
}
/**
* Sets a query string in the text field and optionally submits the query as well.
*
* @param query the query string. This replaces any query text already present in the
* text field.
* @param submit whether to submit the query right now or only update the contents of
* text field.
*/
public void setQuery(CharSequence query, boolean submit) {
mSearchSrcTextView.setText(query);
if (query != null) {
mSearchSrcTextView.setSelection(mSearchSrcTextView.length());
mUserQuery = query;
}
// If the query is not empty and submit is requested, submit the query
if (submit && !TextUtils.isEmpty(query)) {
onSubmitQuery();
}
}
/**
* Sets the hint text to display in the query text field. This overrides
* any hint specified in the {@link SearchableInfo}.
*
* This value may be specified as an empty string to prevent any query hint
* from being displayed.
*
* @param hint the hint text to display or {@code null} to clear
* @attr ref android.R.styleable#SearchView_queryHint
*/
public void setQueryHint(@Nullable CharSequence hint) {
mQueryHint = hint;
updateQueryHint();
}
/**
* Returns the hint text that will be displayed in the query text field.
*
* The displayed query hint is chosen in the following order:
*
* - Non-null value set with {@link #setQueryHint(CharSequence)}
*
- Value specified in XML using
* {@link android.R.styleable#SearchView_queryHint android:queryHint}
*
- Valid string resource ID exposed by the {@link SearchableInfo} via
* {@link SearchableInfo#getHintId()}
*
- Default hint provided by the theme against which the view was
* inflated
*
*
* @return the displayed query hint text, or {@code null} if none set
* @attr ref android.R.styleable#SearchView_queryHint
*/
@InspectableProperty
@Nullable
public CharSequence getQueryHint() {
final CharSequence hint;
if (mQueryHint != null) {
hint = mQueryHint;
} else if (mSearchable != null && mSearchable.getHintId() != 0) {
hint = getContext().getText(mSearchable.getHintId());
} else {
hint = mDefaultQueryHint;
}
return hint;
}
/**
* Sets the default or resting state of the search field. If true, a single search icon is
* shown by default and expands to show the text field and other buttons when pressed. Also,
* if the default state is iconified, then it collapses to that state when the close button
* is pressed. Changes to this property will take effect immediately.
*
* The default value is true.
*
* @param iconified whether the search field should be iconified by default
*
* @attr ref android.R.styleable#SearchView_iconifiedByDefault
*/
public void setIconifiedByDefault(boolean iconified) {
if (mIconifiedByDefault == iconified) return;
mIconifiedByDefault = iconified;
updateViewsVisibility(iconified);
updateQueryHint();
}
/**
* Returns the default iconified state of the search field.
* @return
*
* @deprecated use {@link #isIconifiedByDefault()}
* @attr ref android.R.styleable#SearchView_iconifiedByDefault
*/
@Deprecated
public boolean isIconfiedByDefault() {
return mIconifiedByDefault;
}
/**
* Returns the default iconified state of the search field.
*
* @attr ref android.R.styleable#SearchView_iconifiedByDefault
*/
@InspectableProperty
public boolean isIconifiedByDefault() {
return mIconifiedByDefault;
}
/**
* Iconifies or expands the SearchView. Any query text is cleared when iconified. This is
* a temporary state and does not override the default iconified state set by
* {@link #setIconifiedByDefault(boolean)}. If the default state is iconified, then
* a false here will only be valid until the user closes the field. And if the default
* state is expanded, then a true here will only clear the text field and not close it.
*
* @param iconify a true value will collapse the SearchView to an icon, while a false will
* expand it.
*/
public void setIconified(boolean iconify) {
if (iconify) {
onCloseClicked();
} else {
onSearchClicked();
}
}
/**
* Returns the current iconified state of the SearchView.
*
* @return true if the SearchView is currently iconified, false if the search field is
* fully visible.
*/
@InspectableProperty(hasAttributeId = false)
public boolean isIconified() {
return mIconified;
}
/**
* Enables showing a submit button when the query is non-empty. In cases where the SearchView
* is being used to filter the contents of the current activity and doesn't launch a separate
* results activity, then the submit button should be disabled.
*
* @param enabled true to show a submit button for submitting queries, false if a submit
* button is not required.
*/
public void setSubmitButtonEnabled(boolean enabled) {
mSubmitButtonEnabled = enabled;
updateViewsVisibility(isIconified());
}
/**
* Returns whether the submit button is enabled when necessary or never displayed.
*
* @return whether the submit button is enabled automatically when necessary
*/
public boolean isSubmitButtonEnabled() {
return mSubmitButtonEnabled;
}
/**
* Specifies if a query refinement button should be displayed alongside each suggestion
* or if it should depend on the flags set in the individual items retrieved from the
* suggestions provider. Clicking on the query refinement button will replace the text
* in the query text field with the text from the suggestion. This flag only takes effect
* if a SearchableInfo has been specified with {@link #setSearchableInfo(SearchableInfo)}
* and not when using a custom adapter.
*
* @param enable true if all items should have a query refinement button, false if only
* those items that have a query refinement flag set should have the button.
*
* @see SearchManager#SUGGEST_COLUMN_FLAGS
* @see SearchManager#FLAG_QUERY_REFINEMENT
*/
public void setQueryRefinementEnabled(boolean enable) {
mQueryRefinement = enable;
if (mSuggestionsAdapter instanceof SuggestionsAdapter) {
((SuggestionsAdapter) mSuggestionsAdapter).setQueryRefinement(
enable ? SuggestionsAdapter.REFINE_ALL : SuggestionsAdapter.REFINE_BY_ENTRY);
}
}
/**
* Returns whether query refinement is enabled for all items or only specific ones.
* @return true if enabled for all items, false otherwise.
*/
public boolean isQueryRefinementEnabled() {
return mQueryRefinement;
}
/**
* You can set a custom adapter if you wish. Otherwise the default adapter is used to
* display the suggestions from the suggestions provider associated with the SearchableInfo.
*
* @see #setSearchableInfo(SearchableInfo)
*/
public void setSuggestionsAdapter(CursorAdapter adapter) {
mSuggestionsAdapter = adapter;
mSearchSrcTextView.setAdapter(mSuggestionsAdapter);
}
/**
* Returns the adapter used for suggestions, if any.
* @return the suggestions adapter
*/
public CursorAdapter getSuggestionsAdapter() {
return mSuggestionsAdapter;
}
/**
* Makes the view at most this many pixels wide
*
* @attr ref android.R.styleable#SearchView_maxWidth
*/
public void setMaxWidth(int maxpixels) {
mMaxWidth = maxpixels;
requestLayout();
}
/**
* Gets the specified maximum width in pixels, if set. Returns zero if
* no maximum width was specified.
* @return the maximum width of the view
*
* @attr ref android.R.styleable#SearchView_maxWidth
*/
@InspectableProperty
public int getMaxWidth() {
return mMaxWidth;
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
// Let the standard measurements take effect in iconified state.
if (isIconified()) {
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
return;
}
int widthMode = MeasureSpec.getMode(widthMeasureSpec);
int width = MeasureSpec.getSize(widthMeasureSpec);
switch (widthMode) {
case MeasureSpec.AT_MOST:
// If there is an upper limit, don't exceed maximum width (explicit or implicit)
if (mMaxWidth > 0) {
width = Math.min(mMaxWidth, width);
} else {
width = Math.min(getPreferredWidth(), width);
}
break;
case MeasureSpec.EXACTLY:
// If an exact width is specified, still don't exceed any specified maximum width
if (mMaxWidth > 0) {
width = Math.min(mMaxWidth, width);
}
break;
case MeasureSpec.UNSPECIFIED:
// Use maximum width, if specified, else preferred width
width = mMaxWidth > 0 ? mMaxWidth : getPreferredWidth();
break;
}
widthMode = MeasureSpec.EXACTLY;
int heightMode = MeasureSpec.getMode(heightMeasureSpec);
int height = MeasureSpec.getSize(heightMeasureSpec);
switch (heightMode) {
case MeasureSpec.AT_MOST:
height = Math.min(getPreferredHeight(), height);
break;
case MeasureSpec.UNSPECIFIED:
height = getPreferredHeight();
break;
}
heightMode = MeasureSpec.EXACTLY;
super.onMeasure(MeasureSpec.makeMeasureSpec(width, widthMode),
MeasureSpec.makeMeasureSpec(height, heightMode));
}
@Override
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
super.onLayout(changed, left, top, right, bottom);
if (changed) {
// Expand mSearchSrcTextView touch target to be the height of the parent in order to
// allow it to be up to 48dp.
getChildBoundsWithinSearchView(mSearchSrcTextView, mSearchSrcTextViewBounds);
mSearchSrtTextViewBoundsExpanded.set(
mSearchSrcTextViewBounds.left, 0, mSearchSrcTextViewBounds.right, bottom - top);
if (mTouchDelegate == null) {
mTouchDelegate = new UpdatableTouchDelegate(mSearchSrtTextViewBoundsExpanded,
mSearchSrcTextViewBounds, mSearchSrcTextView);
setTouchDelegate(mTouchDelegate);
} else {
mTouchDelegate.setBounds(mSearchSrtTextViewBoundsExpanded, mSearchSrcTextViewBounds);
}
}
}
private void getChildBoundsWithinSearchView(View view, Rect rect) {
view.getLocationInWindow(mTemp);
getLocationInWindow(mTemp2);
final int top = mTemp[1] - mTemp2[1];
final int left = mTemp[0] - mTemp2[0];
rect.set(left , top, left + view.getWidth(), top + view.getHeight());
}
private int getPreferredWidth() {
return getContext().getResources()
.getDimensionPixelSize(R.dimen.search_view_preferred_width);
}
private int getPreferredHeight() {
return getContext().getResources()
.getDimensionPixelSize(R.dimen.search_view_preferred_height);
}
@UnsupportedAppUsage
private void updateViewsVisibility(final boolean collapsed) {
mIconified = collapsed;
// Visibility of views that are visible when collapsed
final int visCollapsed = collapsed ? VISIBLE : GONE;
// Is there text in the query
final boolean hasText = !TextUtils.isEmpty(mSearchSrcTextView.getText());
mSearchButton.setVisibility(visCollapsed);
updateSubmitButton(hasText);
mSearchEditFrame.setVisibility(collapsed ? GONE : VISIBLE);
final int iconVisibility;
if (mCollapsedIcon.getDrawable() == null || mIconifiedByDefault) {
iconVisibility = GONE;
} else {
iconVisibility = VISIBLE;
}
mCollapsedIcon.setVisibility(iconVisibility);
updateCloseButton();
updateVoiceButton(!hasText);
updateSubmitArea();
}
private boolean hasVoiceSearch() {
if (mSearchable != null && mSearchable.getVoiceSearchEnabled()) {
Intent testIntent = null;
if (mSearchable.getVoiceSearchLaunchWebSearch()) {
testIntent = mVoiceWebSearchIntent;
} else if (mSearchable.getVoiceSearchLaunchRecognizer()) {
testIntent = mVoiceAppSearchIntent;
}
if (testIntent != null) {
ResolveInfo ri = getContext().getPackageManager().resolveActivity(testIntent,
PackageManager.MATCH_DEFAULT_ONLY);
return ri != null;
}
}
return false;
}
private boolean isSubmitAreaEnabled() {
return (mSubmitButtonEnabled || mVoiceButtonEnabled) && !isIconified();
}
@UnsupportedAppUsage
private void updateSubmitButton(boolean hasText) {
int visibility = GONE;
if (mSubmitButtonEnabled && isSubmitAreaEnabled() && hasFocus()
&& (hasText || !mVoiceButtonEnabled)) {
visibility = VISIBLE;
}
mGoButton.setVisibility(visibility);
}
@UnsupportedAppUsage
private void updateSubmitArea() {
int visibility = GONE;
if (isSubmitAreaEnabled()
&& (mGoButton.getVisibility() == VISIBLE
|| mVoiceButton.getVisibility() == VISIBLE)) {
visibility = VISIBLE;
}
mSubmitArea.setVisibility(visibility);
}
private void updateCloseButton() {
final boolean hasText = !TextUtils.isEmpty(mSearchSrcTextView.getText());
// Should we show the close button? It is not shown if there's no focus,
// field is not iconified by default and there is no text in it.
final boolean showClose = hasText || (mIconifiedByDefault && !mExpandedInActionView);
mCloseButton.setVisibility(showClose ? VISIBLE : GONE);
final Drawable closeButtonImg = mCloseButton.getDrawable();
if (closeButtonImg != null){
closeButtonImg.setState(hasText ? ENABLED_STATE_SET : EMPTY_STATE_SET);
}
}
private void postUpdateFocusedState() {
post(mUpdateDrawableStateRunnable);
}
private void updateFocusedState() {
final boolean focused = mSearchSrcTextView.hasFocus();
final int[] stateSet = focused ? FOCUSED_STATE_SET : EMPTY_STATE_SET;
final Drawable searchPlateBg = mSearchPlate.getBackground();
if (searchPlateBg != null) {
searchPlateBg.setState(stateSet);
}
final Drawable submitAreaBg = mSubmitArea.getBackground();
if (submitAreaBg != null) {
submitAreaBg.setState(stateSet);
}
invalidate();
}
@Override
protected void onDetachedFromWindow() {
removeCallbacks(mUpdateDrawableStateRunnable);
post(mReleaseCursorRunnable);
super.onDetachedFromWindow();
}
/**
* Called by the SuggestionsAdapter
* @hide
*/
/* package */void onQueryRefine(CharSequence queryText) {
setQuery(queryText);
}
@UnsupportedAppUsage
private final OnClickListener mOnClickListener = new OnClickListener() {
public void onClick(View v) {
if (v == mSearchButton) {
onSearchClicked();
} else if (v == mCloseButton) {
onCloseClicked();
} else if (v == mGoButton) {
onSubmitQuery();
} else if (v == mVoiceButton) {
onVoiceClicked();
} else if (v == mSearchSrcTextView) {
forceSuggestionQuery();
}
}
};
/**
* Handles the key down event for dealing with action keys.
*
* @param keyCode This is the keycode of the typed key, and is the same value as
* found in the KeyEvent parameter.
* @param event The complete event record for the typed key
*
* @return true if the event was handled here, or false if not.
*/
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
if (mSearchable == null) {
return false;
}
// if it's an action specified by the searchable activity, launch the
// entered query with the action key
SearchableInfo.ActionKeyInfo actionKey = mSearchable.findActionKey(keyCode);
if ((actionKey != null) && (actionKey.getQueryActionMsg() != null)) {
launchQuerySearch(keyCode, actionKey.getQueryActionMsg(), mSearchSrcTextView.getText()
.toString());
return true;
}
return super.onKeyDown(keyCode, event);
}
/**
* React to the user typing "enter" or other hardwired keys while typing in
* the search box. This handles these special keys while the edit box has
* focus.
*/
View.OnKeyListener mTextKeyListener = new View.OnKeyListener() {
public boolean onKey(View v, int keyCode, KeyEvent event) {
// guard against possible race conditions
if (mSearchable == null) {
return false;
}
if (DBG) {
Log.d(LOG_TAG, "mTextListener.onKey(" + keyCode + "," + event + "), selection: "
+ mSearchSrcTextView.getListSelection());
}
// If a suggestion is selected, handle enter, search key, and action keys
// as presses on the selected suggestion
if (mSearchSrcTextView.isPopupShowing()
&& mSearchSrcTextView.getListSelection() != ListView.INVALID_POSITION) {
return onSuggestionsKey(v, keyCode, event);
}
// If there is text in the query box, handle enter, and action keys
// The search key is handled by the dialog's onKeyDown().
if (!mSearchSrcTextView.isEmpty() && event.hasNoModifiers()) {
if (event.getAction() == KeyEvent.ACTION_UP) {
if (keyCode == KeyEvent.KEYCODE_ENTER
|| keyCode == KeyEvent.KEYCODE_NUMPAD_ENTER) {
v.cancelLongPress();
// Launch as a regular search.
launchQuerySearch(KeyEvent.KEYCODE_UNKNOWN, null, mSearchSrcTextView.getText()
.toString());
return true;
}
}
if (event.getAction() == KeyEvent.ACTION_DOWN) {
SearchableInfo.ActionKeyInfo actionKey = mSearchable.findActionKey(keyCode);
if ((actionKey != null) && (actionKey.getQueryActionMsg() != null)) {
launchQuerySearch(keyCode, actionKey.getQueryActionMsg(), mSearchSrcTextView
.getText().toString());
return true;
}
}
}
return false;
}
};
/**
* React to the user typing while in the suggestions list. First, check for
* action keys. If not handled, try refocusing regular characters into the
* EditText.
*/
private boolean onSuggestionsKey(View v, int keyCode, KeyEvent event) {
// guard against possible race conditions (late arrival after dismiss)
if (mSearchable == null) {
return false;
}
if (mSuggestionsAdapter == null) {
return false;
}
if (event.getAction() == KeyEvent.ACTION_DOWN && event.hasNoModifiers()) {
// First, check for enter or search (both of which we'll treat as a
// "click")
if (keyCode == KeyEvent.KEYCODE_ENTER || keyCode == KeyEvent.KEYCODE_SEARCH
|| keyCode == KeyEvent.KEYCODE_TAB) {
int position = mSearchSrcTextView.getListSelection();
return onItemClicked(position, KeyEvent.KEYCODE_UNKNOWN, null);
}
// Next, check for left/right moves, which we use to "return" the
// user to the edit view
if (keyCode == KeyEvent.KEYCODE_DPAD_LEFT || keyCode == KeyEvent.KEYCODE_DPAD_RIGHT) {
// give "focus" to text editor, with cursor at the beginning if
// left key, at end if right key
// TODO: Reverse left/right for right-to-left languages, e.g.
// Arabic
int selPoint = (keyCode == KeyEvent.KEYCODE_DPAD_LEFT) ? 0 : mSearchSrcTextView
.length();
mSearchSrcTextView.setSelection(selPoint);
mSearchSrcTextView.setListSelection(0);
mSearchSrcTextView.clearListSelection();
mSearchSrcTextView.ensureImeVisible(true);
return true;
}
// Next, check for an "up and out" move
if (keyCode == KeyEvent.KEYCODE_DPAD_UP && 0 == mSearchSrcTextView.getListSelection()) {
// TODO: restoreUserQuery();
// let ACTV complete the move
return false;
}
// Next, check for an "action key"
SearchableInfo.ActionKeyInfo actionKey = mSearchable.findActionKey(keyCode);
if ((actionKey != null)
&& ((actionKey.getSuggestActionMsg() != null) || (actionKey
.getSuggestActionMsgColumn() != null))) {
// launch suggestion using action key column
int position = mSearchSrcTextView.getListSelection();
if (position != ListView.INVALID_POSITION) {
Cursor c = mSuggestionsAdapter.getCursor();
if (c.moveToPosition(position)) {
final String actionMsg = getActionKeyMessage(c, actionKey);
if (actionMsg != null && (actionMsg.length() > 0)) {
return onItemClicked(position, keyCode, actionMsg);
}
}
}
}
}
return false;
}
/**
* For a given suggestion and a given cursor row, get the action message. If
* not provided by the specific row/column, also check for a single
* definition (for the action key).
*
* @param c The cursor providing suggestions
* @param actionKey The actionkey record being examined
*
* @return Returns a string, or null if no action key message for this
* suggestion
*/
private static String getActionKeyMessage(Cursor c, SearchableInfo.ActionKeyInfo actionKey) {
String result = null;
// check first in the cursor data, for a suggestion-specific message
final String column = actionKey.getSuggestActionMsgColumn();
if (column != null) {
result = SuggestionsAdapter.getColumnString(c, column);
}
// If the cursor didn't give us a message, see if there's a single
// message defined
// for the actionkey (for all suggestions)
if (result == null) {
result = actionKey.getSuggestActionMsg();
}
return result;
}
private CharSequence getDecoratedHint(CharSequence hintText) {
// If the field is always expanded or we don't have a search hint icon,
// then don't add the search icon to the hint.
if (!mIconifiedByDefault || mSearchHintIcon == null) {
return hintText;
}
final int textSize = (int) (mSearchSrcTextView.getTextSize() * 1.25);
mSearchHintIcon.setBounds(0, 0, textSize, textSize);
final SpannableStringBuilder ssb = new SpannableStringBuilder(" ");
ssb.setSpan(new ImageSpan(mSearchHintIcon), 1, 2, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
ssb.append(hintText);
return ssb;
}
private void updateQueryHint() {
final CharSequence hint = getQueryHint();
mSearchSrcTextView.setHint(getDecoratedHint(hint == null ? "" : hint));
}
/**
* Updates the auto-complete text view.
*/
private void updateSearchAutoComplete() {
mSearchSrcTextView.setDropDownAnimationStyle(0); // no animation
mSearchSrcTextView.setThreshold(mSearchable.getSuggestThreshold());
mSearchSrcTextView.setImeOptions(mSearchable.getImeOptions());
int inputType = mSearchable.getInputType();
// We only touch this if the input type is set up for text (which it almost certainly
// should be, in the case of search!)
if ((inputType & InputType.TYPE_MASK_CLASS) == InputType.TYPE_CLASS_TEXT) {
// The existence of a suggestions authority is the proxy for "suggestions
// are available here"
inputType &= ~InputType.TYPE_TEXT_FLAG_AUTO_COMPLETE;
if (mSearchable.getSuggestAuthority() != null) {
inputType |= InputType.TYPE_TEXT_FLAG_AUTO_COMPLETE;
// TYPE_TEXT_FLAG_AUTO_COMPLETE means that the text editor is performing
// auto-completion based on its own semantics, which it will present to the user
// as they type. This generally means that the input method should not show its
// own candidates, and the spell checker should not be in action. The text editor
// supplies its candidates by calling InputMethodManager.displayCompletions(),
// which in turn will call InputMethodSession.displayCompletions().
inputType |= InputType.TYPE_TEXT_FLAG_NO_SUGGESTIONS;
}
}
mSearchSrcTextView.setInputType(inputType);
if (mSuggestionsAdapter != null) {
mSuggestionsAdapter.changeCursor(null);
}
// attach the suggestions adapter, if suggestions are available
// The existence of a suggestions authority is the proxy for "suggestions available here"
if (mSearchable.getSuggestAuthority() != null) {
mSuggestionsAdapter = new SuggestionsAdapter(getContext(),
this, mSearchable, mOutsideDrawablesCache);
mSearchSrcTextView.setAdapter(mSuggestionsAdapter);
((SuggestionsAdapter) mSuggestionsAdapter).setQueryRefinement(
mQueryRefinement ? SuggestionsAdapter.REFINE_ALL
: SuggestionsAdapter.REFINE_BY_ENTRY);
}
}
/**
* Update the visibility of the voice button. There are actually two voice search modes,
* either of which will activate the button.
* @param empty whether the search query text field is empty. If it is, then the other
* criteria apply to make the voice button visible.
*/
private void updateVoiceButton(boolean empty) {
int visibility = GONE;
if (mVoiceButtonEnabled && !isIconified() && empty) {
visibility = VISIBLE;
mGoButton.setVisibility(GONE);
}
mVoiceButton.setVisibility(visibility);
}
private final OnEditorActionListener mOnEditorActionListener = new OnEditorActionListener() {
/**
* Called when the input method default action key is pressed.
*/
public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
onSubmitQuery();
return true;
}
};
private void onTextChanged(CharSequence newText) {
CharSequence text = mSearchSrcTextView.getText();
mUserQuery = text;
boolean hasText = !TextUtils.isEmpty(text);
updateSubmitButton(hasText);
updateVoiceButton(!hasText);
updateCloseButton();
updateSubmitArea();
if (mOnQueryChangeListener != null && !TextUtils.equals(newText, mOldQueryText)) {
mOnQueryChangeListener.onQueryTextChange(newText.toString());
}
mOldQueryText = newText.toString();
}
private void onSubmitQuery() {
CharSequence query = mSearchSrcTextView.getText();
if (query != null && TextUtils.getTrimmedLength(query) > 0) {
if (mOnQueryChangeListener == null
|| !mOnQueryChangeListener.onQueryTextSubmit(query.toString())) {
if (mSearchable != null) {
launchQuerySearch(KeyEvent.KEYCODE_UNKNOWN, null, query.toString());
}
mSearchSrcTextView.setImeVisibility(false);
dismissSuggestions();
}
}
}
private void dismissSuggestions() {
mSearchSrcTextView.dismissDropDown();
}
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P, trackingBug = 115609023)
private void onCloseClicked() {
CharSequence text = mSearchSrcTextView.getText();
if (TextUtils.isEmpty(text)) {
if (mIconifiedByDefault) {
// If the app doesn't override the close behavior
if (mOnCloseListener == null || !mOnCloseListener.onClose()) {
// hide the keyboard and remove focus
clearFocus();
// collapse the search field
updateViewsVisibility(true);
}
}
} else {
mSearchSrcTextView.setText("");
mSearchSrcTextView.requestFocus();
mSearchSrcTextView.setImeVisibility(true);
}
}
private void onSearchClicked() {
updateViewsVisibility(false);
mSearchSrcTextView.requestFocus();
mSearchSrcTextView.setImeVisibility(true);
if (mOnSearchClickListener != null) {
mOnSearchClickListener.onClick(this);
}
}
private void onVoiceClicked() {
// guard against possible race conditions
if (mSearchable == null) {
return;
}
SearchableInfo searchable = mSearchable;
try {
if (searchable.getVoiceSearchLaunchWebSearch()) {
Intent webSearchIntent = createVoiceWebSearchIntent(mVoiceWebSearchIntent,
searchable);
getContext().startActivity(webSearchIntent);
} else if (searchable.getVoiceSearchLaunchRecognizer()) {
Intent appSearchIntent = createVoiceAppSearchIntent(mVoiceAppSearchIntent,
searchable);
getContext().startActivity(appSearchIntent);
}
} catch (ActivityNotFoundException e) {
// Should not happen, since we check the availability of
// voice search before showing the button. But just in case...
Log.w(LOG_TAG, "Could not find voice search activity");
}
}
void onTextFocusChanged() {
updateViewsVisibility(isIconified());
// Delayed update to make sure that the focus has settled down and window focus changes
// don't affect it. A synchronous update was not working.
postUpdateFocusedState();
if (mSearchSrcTextView.hasFocus()) {
forceSuggestionQuery();
}
}
@Override
public void onWindowFocusChanged(boolean hasWindowFocus) {
super.onWindowFocusChanged(hasWindowFocus);
postUpdateFocusedState();
}
/**
* {@inheritDoc}
*/
@Override
public void onActionViewCollapsed() {
setQuery("", false);
clearFocus();
updateViewsVisibility(true);
mSearchSrcTextView.setImeOptions(mCollapsedImeOptions);
mExpandedInActionView = false;
}
/**
* {@inheritDoc}
*/
@Override
public void onActionViewExpanded() {
if (mExpandedInActionView) return;
mExpandedInActionView = true;
mCollapsedImeOptions = mSearchSrcTextView.getImeOptions();
mSearchSrcTextView.setImeOptions(mCollapsedImeOptions | EditorInfo.IME_FLAG_NO_FULLSCREEN);
mSearchSrcTextView.setText("");
setIconified(false);
}
static class SavedState extends BaseSavedState {
boolean isIconified;
SavedState(Parcelable superState) {
super(superState);
}
public SavedState(Parcel source) {
super(source);
isIconified = (Boolean) source.readValue(null);
}
@Override
public void writeToParcel(Parcel dest, int flags) {
super.writeToParcel(dest, flags);
dest.writeValue(isIconified);
}
@Override
public String toString() {
return "SearchView.SavedState{"
+ Integer.toHexString(System.identityHashCode(this))
+ " isIconified=" + isIconified + "}";
}
public static final @android.annotation.NonNull Parcelable.Creator CREATOR =
new Parcelable.Creator() {
public SavedState createFromParcel(Parcel in) {
return new SavedState(in);
}
public SavedState[] newArray(int size) {
return new SavedState[size];
}
};
}
@Override
protected Parcelable onSaveInstanceState() {
Parcelable superState = super.onSaveInstanceState();
SavedState ss = new SavedState(superState);
ss.isIconified = isIconified();
return ss;
}
@Override
protected void onRestoreInstanceState(Parcelable state) {
SavedState ss = (SavedState) state;
super.onRestoreInstanceState(ss.getSuperState());
updateViewsVisibility(ss.isIconified);
requestLayout();
}
@Override
public CharSequence getAccessibilityClassName() {
return SearchView.class.getName();
}
private void adjustDropDownSizeAndPosition() {
if (mDropDownAnchor.getWidth() > 1) {
Resources res = getContext().getResources();
int anchorPadding = mSearchPlate.getPaddingLeft();
Rect dropDownPadding = new Rect();
final boolean isLayoutRtl = isLayoutRtl();
int iconOffset = mIconifiedByDefault
? res.getDimensionPixelSize(R.dimen.dropdownitem_icon_width)
+ res.getDimensionPixelSize(R.dimen.dropdownitem_text_padding_left)
: 0;
mSearchSrcTextView.getDropDownBackground().getPadding(dropDownPadding);
int offset;
if (isLayoutRtl) {
offset = - dropDownPadding.left;
} else {
offset = anchorPadding - (dropDownPadding.left + iconOffset);
}
mSearchSrcTextView.setDropDownHorizontalOffset(offset);
final int width = mDropDownAnchor.getWidth() + dropDownPadding.left
+ dropDownPadding.right + iconOffset - anchorPadding;
mSearchSrcTextView.setDropDownWidth(width);
}
}
private boolean onItemClicked(int position, int actionKey, String actionMsg) {
if (mOnSuggestionListener == null
|| !mOnSuggestionListener.onSuggestionClick(position)) {
launchSuggestion(position, KeyEvent.KEYCODE_UNKNOWN, null);
mSearchSrcTextView.setImeVisibility(false);
dismissSuggestions();
return true;
}
return false;
}
private boolean onItemSelected(int position) {
if (mOnSuggestionListener == null
|| !mOnSuggestionListener.onSuggestionSelect(position)) {
rewriteQueryFromSuggestion(position);
return true;
}
return false;
}
@UnsupportedAppUsage
private final OnItemClickListener mOnItemClickListener = new OnItemClickListener() {
/**
* Implements OnItemClickListener
*/
public void onItemClick(AdapterView parent, View view, int position, long id) {
if (DBG) Log.d(LOG_TAG, "onItemClick() position " + position);
onItemClicked(position, KeyEvent.KEYCODE_UNKNOWN, null);
}
};
private final OnItemSelectedListener mOnItemSelectedListener = new OnItemSelectedListener() {
/**
* Implements OnItemSelectedListener
*/
public void onItemSelected(AdapterView parent, View view, int position, long id) {
if (DBG) Log.d(LOG_TAG, "onItemSelected() position " + position);
SearchView.this.onItemSelected(position);
}
/**
* Implements OnItemSelectedListener
*/
public void onNothingSelected(AdapterView parent) {
if (DBG)
Log.d(LOG_TAG, "onNothingSelected()");
}
};
/**
* Query rewriting.
*/
private void rewriteQueryFromSuggestion(int position) {
CharSequence oldQuery = mSearchSrcTextView.getText();
Cursor c = mSuggestionsAdapter.getCursor();
if (c == null) {
return;
}
if (c.moveToPosition(position)) {
// Get the new query from the suggestion.
CharSequence newQuery = mSuggestionsAdapter.convertToString(c);
if (newQuery != null) {
// The suggestion rewrites the query.
// Update the text field, without getting new suggestions.
setQuery(newQuery);
} else {
// The suggestion does not rewrite the query, restore the user's query.
setQuery(oldQuery);
}
} else {
// We got a bad position, restore the user's query.
setQuery(oldQuery);
}
}
/**
* Launches an intent based on a suggestion.
*
* @param position The index of the suggestion to create the intent from.
* @param actionKey The key code of the action key that was pressed,
* or {@link KeyEvent#KEYCODE_UNKNOWN} if none.
* @param actionMsg The message for the action key that was pressed,
* or null if none.
* @return true if a successful launch, false if could not (e.g. bad position).
*/
private boolean launchSuggestion(int position, int actionKey, String actionMsg) {
Cursor c = mSuggestionsAdapter.getCursor();
if ((c != null) && c.moveToPosition(position)) {
Intent intent = createIntentFromSuggestion(c, actionKey, actionMsg);
// launch the intent
launchIntent(intent);
return true;
}
return false;
}
/**
* Launches an intent, including any special intent handling.
*/
private void launchIntent(Intent intent) {
if (intent == null) {
return;
}
try {
// If the intent was created from a suggestion, it will always have an explicit
// component here.
getContext().startActivity(intent);
} catch (RuntimeException ex) {
Log.e(LOG_TAG, "Failed launch activity: " + intent, ex);
}
}
/**
* Sets the text in the query box, without updating the suggestions.
*/
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P, trackingBug = 115609023)
private void setQuery(CharSequence query) {
mSearchSrcTextView.setText(query, true);
// Move the cursor to the end
mSearchSrcTextView.setSelection(TextUtils.isEmpty(query) ? 0 : query.length());
}
private void launchQuerySearch(int actionKey, String actionMsg, String query) {
String action = Intent.ACTION_SEARCH;
Intent intent = createIntent(action, null, null, query, actionKey, actionMsg);
getContext().startActivity(intent);
}
/**
* Constructs an intent from the given information and the search dialog state.
*
* @param action Intent action.
* @param data Intent data, or null.
* @param extraData Data for {@link SearchManager#EXTRA_DATA_KEY} or null.
* @param query Intent query, or null.
* @param actionKey The key code of the action key that was pressed,
* or {@link KeyEvent#KEYCODE_UNKNOWN} if none.
* @param actionMsg The message for the action key that was pressed,
* or null if none.
* @param mode The search mode, one of the acceptable values for
* {@link SearchManager#SEARCH_MODE}, or {@code null}.
* @return The intent.
*/
private Intent createIntent(String action, Uri data, String extraData, String query,
int actionKey, String actionMsg) {
// Now build the Intent
Intent intent = new Intent(action);
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
// We need CLEAR_TOP to avoid reusing an old task that has other activities
// on top of the one we want. We don't want to do this in in-app search though,
// as it can be destructive to the activity stack.
if (data != null) {
intent.setData(data);
}
intent.putExtra(SearchManager.USER_QUERY, mUserQuery);
if (query != null) {
intent.putExtra(SearchManager.QUERY, query);
}
if (extraData != null) {
intent.putExtra(SearchManager.EXTRA_DATA_KEY, extraData);
}
if (mAppSearchData != null) {
intent.putExtra(SearchManager.APP_DATA, mAppSearchData);
}
if (actionKey != KeyEvent.KEYCODE_UNKNOWN) {
intent.putExtra(SearchManager.ACTION_KEY, actionKey);
intent.putExtra(SearchManager.ACTION_MSG, actionMsg);
}
intent.setComponent(mSearchable.getSearchActivity());
return intent;
}
/**
* Create and return an Intent that can launch the voice search activity for web search.
*/
private Intent createVoiceWebSearchIntent(Intent baseIntent, SearchableInfo searchable) {
Intent voiceIntent = new Intent(baseIntent);
ComponentName searchActivity = searchable.getSearchActivity();
voiceIntent.putExtra(RecognizerIntent.EXTRA_CALLING_PACKAGE, searchActivity == null ? null
: searchActivity.flattenToShortString());
return voiceIntent;
}
/**
* Create and return an Intent that can launch the voice search activity, perform a specific
* voice transcription, and forward the results to the searchable activity.
*
* @param baseIntent The voice app search intent to start from
* @return A completely-configured intent ready to send to the voice search activity
*/
private Intent createVoiceAppSearchIntent(Intent baseIntent, SearchableInfo searchable) {
ComponentName searchActivity = searchable.getSearchActivity();
// create the necessary intent to set up a search-and-forward operation
// in the voice search system. We have to keep the bundle separate,
// because it becomes immutable once it enters the PendingIntent
Intent queryIntent = new Intent(Intent.ACTION_SEARCH);
queryIntent.setComponent(searchActivity);
PendingIntent pending = PendingIntent.getActivity(getContext(), 0, queryIntent,
PendingIntent.FLAG_ONE_SHOT | PendingIntent.FLAG_MUTABLE);
// Now set up the bundle that will be inserted into the pending intent
// when it's time to do the search. We always build it here (even if empty)
// because the voice search activity will always need to insert "QUERY" into
// it anyway.
Bundle queryExtras = new Bundle();
if (mAppSearchData != null) {
queryExtras.putParcelable(SearchManager.APP_DATA, mAppSearchData);
}
// Now build the intent to launch the voice search. Add all necessary
// extras to launch the voice recognizer, and then all the necessary extras
// to forward the results to the searchable activity
Intent voiceIntent = new Intent(baseIntent);
// Add all of the configuration options supplied by the searchable's metadata
String languageModel = RecognizerIntent.LANGUAGE_MODEL_FREE_FORM;
String prompt = null;
String language = null;
int maxResults = 1;
Resources resources = getResources();
if (searchable.getVoiceLanguageModeId() != 0) {
languageModel = resources.getString(searchable.getVoiceLanguageModeId());
}
if (searchable.getVoicePromptTextId() != 0) {
prompt = resources.getString(searchable.getVoicePromptTextId());
}
if (searchable.getVoiceLanguageId() != 0) {
language = resources.getString(searchable.getVoiceLanguageId());
}
if (searchable.getVoiceMaxResults() != 0) {
maxResults = searchable.getVoiceMaxResults();
}
voiceIntent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL, languageModel);
voiceIntent.putExtra(RecognizerIntent.EXTRA_PROMPT, prompt);
voiceIntent.putExtra(RecognizerIntent.EXTRA_LANGUAGE, language);
voiceIntent.putExtra(RecognizerIntent.EXTRA_MAX_RESULTS, maxResults);
voiceIntent.putExtra(RecognizerIntent.EXTRA_CALLING_PACKAGE, searchActivity == null ? null
: searchActivity.flattenToShortString());
// Add the values that configure forwarding the results
voiceIntent.putExtra(RecognizerIntent.EXTRA_RESULTS_PENDINGINTENT, pending);
voiceIntent.putExtra(RecognizerIntent.EXTRA_RESULTS_PENDINGINTENT_BUNDLE, queryExtras);
return voiceIntent;
}
/**
* When a particular suggestion has been selected, perform the various lookups required
* to use the suggestion. This includes checking the cursor for suggestion-specific data,
* and/or falling back to the XML for defaults; It also creates REST style Uri data when
* the suggestion includes a data id.
*
* @param c The suggestions cursor, moved to the row of the user's selection
* @param actionKey The key code of the action key that was pressed,
* or {@link KeyEvent#KEYCODE_UNKNOWN} if none.
* @param actionMsg The message for the action key that was pressed,
* or null if none.
* @return An intent for the suggestion at the cursor's position.
*/
private Intent createIntentFromSuggestion(Cursor c, int actionKey, String actionMsg) {
try {
// use specific action if supplied, or default action if supplied, or fixed default
String action = getColumnString(c, SearchManager.SUGGEST_COLUMN_INTENT_ACTION);
if (action == null) {
action = mSearchable.getSuggestIntentAction();
}
if (action == null) {
action = Intent.ACTION_SEARCH;
}
// use specific data if supplied, or default data if supplied
String data = getColumnString(c, SearchManager.SUGGEST_COLUMN_INTENT_DATA);
if (data == null) {
data = mSearchable.getSuggestIntentData();
}
// then, if an ID was provided, append it.
if (data != null) {
String id = getColumnString(c, SearchManager.SUGGEST_COLUMN_INTENT_DATA_ID);
if (id != null) {
data = data + "/" + Uri.encode(id);
}
}
Uri dataUri = (data == null) ? null : Uri.parse(data);
String query = getColumnString(c, SearchManager.SUGGEST_COLUMN_QUERY);
String extraData = getColumnString(c, SearchManager.SUGGEST_COLUMN_INTENT_EXTRA_DATA);
return createIntent(action, dataUri, extraData, query, actionKey, actionMsg);
} catch (RuntimeException e ) {
int rowNum;
try { // be really defensive now
rowNum = c.getPosition();
} catch (RuntimeException e2 ) {
rowNum = -1;
}
Log.w(LOG_TAG, "Search suggestions cursor at row " + rowNum +
" returned exception.", e);
return null;
}
}
private void forceSuggestionQuery() {
mSearchSrcTextView.doBeforeTextChanged();
mSearchSrcTextView.doAfterTextChanged();
}
static boolean isLandscapeMode(Context context) {
return context.getResources().getConfiguration().orientation
== Configuration.ORIENTATION_LANDSCAPE;
}
/**
* Callback to watch the text field for empty/non-empty
*/
private TextWatcher mTextWatcher = new TextWatcher() {
public void beforeTextChanged(CharSequence s, int start, int before, int after) { }
public void onTextChanged(CharSequence s, int start,
int before, int after) {
SearchView.this.onTextChanged(s);
}
public void afterTextChanged(Editable s) {
}
};
private static class UpdatableTouchDelegate extends TouchDelegate {
/**
* View that should receive forwarded touch events
*/
private final View mDelegateView;
/**
* Bounds in local coordinates of the containing view that should be mapped to the delegate
* view. This rect is used for initial hit testing.
*/
private final Rect mTargetBounds;
/**
* Bounds in local coordinates of the containing view that are actual bounds of the delegate
* view. This rect is used for event coordinate mapping.
*/
private final Rect mActualBounds;
/**
* mTargetBounds inflated to include some slop. This rect is to track whether the motion events
* should be considered to be be within the delegate view.
*/
private final Rect mSlopBounds;
private final int mSlop;
/**
* True if the delegate had been targeted on a down event (intersected mTargetBounds).
*/
private boolean mDelegateTargeted;
public UpdatableTouchDelegate(Rect targetBounds, Rect actualBounds, View delegateView) {
super(targetBounds, delegateView);
mSlop = ViewConfiguration.get(delegateView.getContext()).getScaledTouchSlop();
mTargetBounds = new Rect();
mSlopBounds = new Rect();
mActualBounds = new Rect();
setBounds(targetBounds, actualBounds);
mDelegateView = delegateView;
}
public void setBounds(Rect desiredBounds, Rect actualBounds) {
mTargetBounds.set(desiredBounds);
mSlopBounds.set(desiredBounds);
mSlopBounds.inset(-mSlop, -mSlop);
mActualBounds.set(actualBounds);
}
@Override
public boolean onTouchEvent(MotionEvent event) {
final int x = (int) event.getX();
final int y = (int) event.getY();
boolean sendToDelegate = false;
boolean hit = true;
boolean handled = false;
switch (event.getAction()) {
case MotionEvent.ACTION_DOWN:
if (mTargetBounds.contains(x, y)) {
mDelegateTargeted = true;
sendToDelegate = true;
}
break;
case MotionEvent.ACTION_UP:
case MotionEvent.ACTION_MOVE:
sendToDelegate = mDelegateTargeted;
if (sendToDelegate) {
if (!mSlopBounds.contains(x, y)) {
hit = false;
}
}
break;
case MotionEvent.ACTION_CANCEL:
sendToDelegate = mDelegateTargeted;
mDelegateTargeted = false;
break;
}
if (sendToDelegate) {
if (hit && !mActualBounds.contains(x, y)) {
// Offset event coordinates to be in the center of the target view since we
// are within the targetBounds, but not inside the actual bounds of
// mDelegateView
event.setLocation(mDelegateView.getWidth() / 2,
mDelegateView.getHeight() / 2);
} else {
// Offset event coordinates to the target view coordinates.
event.setLocation(x - mActualBounds.left, y - mActualBounds.top);
}
handled = mDelegateView.dispatchTouchEvent(event);
}
return handled;
}
}
/**
* Local subclass for AutoCompleteTextView.
* @hide
*/
public static class SearchAutoComplete extends AutoCompleteTextView {
private int mThreshold;
private SearchView mSearchView;
private boolean mHasPendingShowSoftInputRequest;
final Runnable mRunShowSoftInputIfNecessary = () -> showSoftInputIfNecessary();
public SearchAutoComplete(Context context) {
super(context);
mThreshold = getThreshold();
}
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
public SearchAutoComplete(Context context, AttributeSet attrs) {
super(context, attrs);
mThreshold = getThreshold();
}
public SearchAutoComplete(Context context, AttributeSet attrs, int defStyleAttrs) {
super(context, attrs, defStyleAttrs);
mThreshold = getThreshold();
}
public SearchAutoComplete(
Context context, AttributeSet attrs, int defStyleAttrs, int defStyleRes) {
super(context, attrs, defStyleAttrs, defStyleRes);
mThreshold = getThreshold();
}
@Override
protected void onFinishInflate() {
super.onFinishInflate();
DisplayMetrics metrics = getResources().getDisplayMetrics();
setMinWidth((int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,
getSearchViewTextMinWidthDp(), metrics));
}
void setSearchView(SearchView searchView) {
mSearchView = searchView;
}
@Override
public void setThreshold(int threshold) {
super.setThreshold(threshold);
mThreshold = threshold;
}
/**
* Returns true if the text field is empty, or contains only whitespace.
*/
private boolean isEmpty() {
return TextUtils.getTrimmedLength(getText()) == 0;
}
/**
* We override this method to avoid replacing the query box text when a
* suggestion is clicked.
*/
@Override
protected void replaceText(CharSequence text) {
}
/**
* We override this method to avoid an extra onItemClick being called on
* the drop-down's OnItemClickListener by
* {@link AutoCompleteTextView#onKeyUp(int, KeyEvent)} when an item is
* clicked with the trackball.
*/
@Override
public void performCompletion() {
}
/**
* We override this method to be sure and show the soft keyboard if
* appropriate when the TextView has focus.
*/
@Override
public void onWindowFocusChanged(boolean hasWindowFocus) {
super.onWindowFocusChanged(hasWindowFocus);
if (hasWindowFocus && mSearchView.hasFocus() && getVisibility() == VISIBLE) {
// Since InputMethodManager#onPostWindowFocus() will be called after this callback,
// it is a bit too early to call InputMethodManager#showSoftInput() here. We still
// need to wait until the system calls back onCreateInputConnection() to call
// InputMethodManager#showSoftInput().
mHasPendingShowSoftInputRequest = true;
// If in landscape mode, then make sure that the ime is in front of the dropdown.
if (isLandscapeMode(getContext())) {
ensureImeVisible(true);
}
}
}
@Override
protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) {
super.onFocusChanged(focused, direction, previouslyFocusedRect);
mSearchView.onTextFocusChanged();
}
/**
* We override this method so that we can allow a threshold of zero,
* which ACTV does not.
*/
@Override
public boolean enoughToFilter() {
return mThreshold <= 0 || super.enoughToFilter();
}
@Override
public boolean onKeyPreIme(int keyCode, KeyEvent event) {
final boolean consume = super.onKeyPreIme(keyCode, event);
if (consume && keyCode == KeyEvent.KEYCODE_BACK
&& event.getAction() == KeyEvent.ACTION_UP) {
// If AutoCompleteTextView closed its pop-up, it will return true, in which case
// we should also close the IME. Otherwise, the popup is already closed and we can
// leave the BACK event alone.
setImeVisibility(false);
}
return consume;
}
/**
* Get minimum width of the search view text entry area.
*/
private int getSearchViewTextMinWidthDp() {
final Configuration configuration = getResources().getConfiguration();
final int width = configuration.screenWidthDp;
final int height = configuration.screenHeightDp;
final int orientation = configuration.orientation;
if (width >= 960 && height >= 720
&& orientation == Configuration.ORIENTATION_LANDSCAPE) {
return 256;
} else if (width >= 600 || (width >= 640 && height >= 480)) {
return 192;
};
return 160;
}
/**
* We override {@link View#onCreateInputConnection(EditorInfo)} as a signal to schedule a
* pending {@link InputMethodManager#showSoftInput(View, int)} request (if any).
*/
@Override
public InputConnection onCreateInputConnection(EditorInfo editorInfo) {
final InputConnection ic = super.onCreateInputConnection(editorInfo);
if (mHasPendingShowSoftInputRequest) {
removeCallbacks(mRunShowSoftInputIfNecessary);
post(mRunShowSoftInputIfNecessary);
}
return ic;
}
@Override
public boolean checkInputConnectionProxy(View view) {
return view == mSearchView;
}
private void showSoftInputIfNecessary() {
if (mHasPendingShowSoftInputRequest) {
final InputMethodManager imm =
getContext().getSystemService(InputMethodManager.class);
imm.showSoftInput(this, 0);
mHasPendingShowSoftInputRequest = false;
}
}
private void setImeVisibility(final boolean visible) {
final InputMethodManager imm = getContext().getSystemService(InputMethodManager.class);
if (!visible) {
mHasPendingShowSoftInputRequest = false;
removeCallbacks(mRunShowSoftInputIfNecessary);
imm.hideSoftInputFromWindow(getWindowToken(), 0);
return;
}
if (imm.isActive(this)) {
// This means that SearchAutoComplete is already connected to the IME.
// InputMethodManager#showSoftInput() is guaranteed to pass client-side focus check.
mHasPendingShowSoftInputRequest = false;
removeCallbacks(mRunShowSoftInputIfNecessary);
imm.showSoftInput(this, 0);
return;
}
// Otherwise, InputMethodManager#showSoftInput() should be deferred after
// onCreateInputConnection().
mHasPendingShowSoftInputRequest = true;
}
}
}