content: /*
   * 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.annotation.UnsupportedAppUsage;
  import android.app.PendingIntent;
  import android.app.SearchManager;
  import android.app.SearchableInfo;
  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.
   *
   * <p>
   * 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.
   * </p>
   * <p>
   * If you want the search field to always be visible, then call setIconifiedByDefault(false).
   * </p>
   *
   * <div class="special reference">
   * <h3>Developer Guides</h3>
   * <p>For information about using {@code SearchView}, read the
   * <a href="{@docRoot}guide/topics/search/index.html">Search</a> developer guide.</p>
   * </div>
   *
   * @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<String, Drawable.ConstantState> mOutsideDrawablesCache =
              new WeakHashMap<String, Drawable.ConstantState>();
  
      /**
       * 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}.
       * <p>
       * 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.
       * <p>
       * The displayed query hint is chosen in the following order:
       * <ol>
       * <li>Non-null value set with {@link #setQueryHint(CharSequence)}
       * <li>Value specified in XML using
       *     {@link android.R.styleable#SearchView_queryHint android:queryHint}
       * <li>Valid string resource ID exposed by the {@link SearchableInfo} via
       *     {@link SearchableInfo#getHintId()}
       * <li>Default hint provided by the theme against which the view was
       *     inflated
       * </ol>
       *
       * @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.
       *
       * <p>The default value is true.</p>
       *
       * @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) {
                          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<SavedState> CREATOR =
                  new Parcelable.Creator<SavedState>() {
                      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 <code>null</code> 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 <code>null</code>.
       * @param extraData Data for {@link SearchManager#EXTRA_DATA_KEY} or <code>null</code>.
       * @param query Intent query, or <code>null</code>.
       * @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 <code>null</code> 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);
  
          // 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 <code>null</code> 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 paranoid 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
          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;
          }
      }
  }
  