| Methods Summary |
|---|
| private void | buildImeCompletions()
final ListAdapter adapter = mAdapter;
if (adapter != null) {
InputMethodManager imm = InputMethodManager.peekInstance();
if (imm != null) {
final int count = Math.min(adapter.getCount(), 20);
CompletionInfo[] completions = new CompletionInfo[count];
int realCount = 0;
for (int i = 0; i < count; i++) {
if (adapter.isEnabled(i)) {
Object item = adapter.getItem(i);
long id = adapter.getItemId(i);
completions[realCount] = new CompletionInfo(id, realCount,
convertSelectionToString(item));
realCount++;
}
}
if (realCount != count) {
CompletionInfo[] tmp = new CompletionInfo[realCount];
System.arraycopy(completions, 0, tmp, 0, realCount);
completions = tmp;
}
imm.displayCompletions(this, completions);
}
}
|
| public void | clearListSelection()Clear the list selection. This may only be temporary, as user input will often bring
it back.
mPopup.clearListSelection();
|
| protected java.lang.CharSequence | convertSelectionToString(java.lang.Object selectedItem)Converts the selected item from the drop down list into a sequence
of character that can be used in the edit box.
return mFilter.convertResultToString(selectedItem);
|
| public void | dismissDropDown()Closes the drop down if present on screen.
InputMethodManager imm = InputMethodManager.peekInstance();
if (imm != null) {
imm.displayCompletions(this, null);
}
mPopup.dismiss();
mPopupCanBeUpdated = false;
|
| void | doAfterTextChanged()
if (mBlockCompletion) return;
// if the list was open before the keystroke, but closed afterwards,
// then something in the keystroke processing (an input filter perhaps)
// called performCompletion() and we shouldn't do any more processing.
if (DEBUG) Log.v(TAG, "after text changed: openBefore=" + mOpenBefore
+ " open=" + isPopupShowing());
if (mOpenBefore && !isPopupShowing()) {
return;
}
// the drop down is shown only when a minimum number of characters
// was typed in the text view
if (enoughToFilter()) {
if (mFilter != null) {
mPopupCanBeUpdated = true;
performFiltering(getText(), mLastKeyCode);
}
} else {
// drop down is automatically dismissed when enough characters
// are deleted from the text view
if (!mPopup.isDropDownAlwaysVisible()) {
dismissDropDown();
}
if (mFilter != null) {
mFilter.filter(null);
}
}
|
| void | doBeforeTextChanged()
if (mBlockCompletion) return;
// when text is changed, inserted or deleted, we attempt to show
// the drop down
mOpenBefore = isPopupShowing();
if (DEBUG) Log.v(TAG, "before text changed: open=" + mOpenBefore);
|
| public boolean | enoughToFilter()Returns true if the amount of text in the field meets
or exceeds the {@link #getThreshold} requirement. You can override
this to impose a different standard for when filtering will be
triggered.
if (DEBUG) Log.v(TAG, "Enough to filter: len=" + getText().length()
+ " threshold=" + mThreshold);
return getText().length() >= mThreshold;
|
| public void | ensureImeVisible(boolean visible)Ensures that the drop down is not obscuring the IME.
mPopup.setInputMethodMode(visible
? ListPopupWindow.INPUT_METHOD_NEEDED : ListPopupWindow.INPUT_METHOD_NOT_NEEDED);
if (mPopup.isDropDownAlwaysVisible() || (mFilter != null && enoughToFilter())) {
showDropDown();
}
|
| public ListAdapter | getAdapter()Returns a filterable list adapter used for auto completion.
return mAdapter;
|
| public java.lang.CharSequence | getCompletionHint()Gets the optional hint text displayed at the bottom of the the matching list.
return mHintText;
|
| public int | getDropDownAnchor()Returns the id for the view that the auto-complete drop down list is anchored to.
return mDropDownAnchorId;
|
| public int | getDropDownAnimationStyle()Returns the animation style that is used when the drop-down list appears and disappears
return mPopup.getAnimationStyle();
|
| public android.graphics.drawable.Drawable | getDropDownBackground()Gets the background of the auto-complete drop-down list.
return mPopup.getBackground();
|
| public int | getDropDownHeight()Returns the current height for the auto-complete drop down list. This can
be a fixed height, or {@link ViewGroup.LayoutParams#MATCH_PARENT} to fill
the screen, or {@link ViewGroup.LayoutParams#WRAP_CONTENT} to fit the height
of the drop down's content.
return mPopup.getHeight();
|
| public int | getDropDownHorizontalOffset()Gets the horizontal offset used for the auto-complete drop-down list.
return mPopup.getHorizontalOffset();
|
| public int | getDropDownVerticalOffset()Gets the vertical offset used for the auto-complete drop-down list.
return mPopup.getVerticalOffset();
|
| public int | getDropDownWidth()Returns the current width for the auto-complete drop down list. This can
be a fixed width, or {@link ViewGroup.LayoutParams#MATCH_PARENT} to fill the screen, or
{@link ViewGroup.LayoutParams#WRAP_CONTENT} to fit the width of its anchor view.
return mPopup.getWidth();
|
| protected Filter | getFilter()Returns the Filter obtained from {@link Filterable#getFilter},
or null if {@link #setAdapter} was not called with
a Filterable.
return mFilter;
|
| public AdapterView.OnItemClickListener | getItemClickListener()Returns the listener that is notified whenever the user clicks an item
in the drop down list.
return mItemClickListener;
|
| public AdapterView.OnItemSelectedListener | getItemSelectedListener()Returns the listener that is notified whenever the user selects an
item in the drop down list.
return mItemSelectedListener;
|
| public int | getListSelection()Get the position of the dropdown view selection, if there is one. Returns
{@link ListView#INVALID_POSITION ListView.INVALID_POSITION} if there is no dropdown or if
there is no selection.
return mPopup.getSelectedItemPosition();
|
| public AdapterView.OnItemClickListener | getOnItemClickListener()Returns the listener that is notified whenever the user clicks an item
in the drop down list.
return mItemClickListener;
|
| public AdapterView.OnItemSelectedListener | getOnItemSelectedListener()Returns the listener that is notified whenever the user selects an
item in the drop down list.
return mItemSelectedListener;
|
| public int | getThreshold()Returns the number of characters the user must type before the drop
down list is shown.
return mThreshold;
|
| public android.widget.AutoCompleteTextView$Validator | getValidator()Returns the Validator set with {@link #setValidator},
or null if it was not set.
return mValidator;
|
| public boolean | isDropDownAlwaysVisible()
return mPopup.isDropDownAlwaysVisible();
|
| public boolean | isDropDownDismissedOnCompletion()Checks whether the drop-down is dismissed when a suggestion is clicked.
return mDropDownDismissedOnCompletion;
|
| public boolean | isInputMethodNotNeeded()
return mPopup.getInputMethodMode() == ListPopupWindow.INPUT_METHOD_NOT_NEEDED;
|
| public boolean | isPerformingCompletion()Identifies whether the view is currently performing a text completion, so subclasses
can decide whether to respond to text changed events.
return mBlockCompletion;
|
| public boolean | isPopupShowing()Indicates whether the popup menu is showing.
return mPopup.isShowing();
|
| protected void | onAttachedToWindow()
super.onAttachedToWindow();
|
| private void | onClickImpl()Private hook into the on click event, dispatched from {@link PassThroughClickListener}
// If the dropdown is showing, bring the keyboard to the front
// when the user touches the text field.
if (isPopupShowing()) {
ensureImeVisible(true);
}
|
| public void | onCommitCompletion(android.view.inputmethod.CompletionInfo completion)
if (isPopupShowing()) {
mPopup.performItemClick(completion.getPosition());
}
|
| protected void | onDetachedFromWindow()
dismissDropDown();
super.onDetachedFromWindow();
|
| protected void | onDisplayHint(int hint)
super.onDisplayHint(hint);
switch (hint) {
case INVISIBLE:
if (!mPopup.isDropDownAlwaysVisible()) {
dismissDropDown();
}
break;
}
|
| public void | onFilterComplete(int count){@inheritDoc}
updateDropDownForFilter(count);
|
| protected void | onFocusChanged(boolean focused, int direction, android.graphics.Rect previouslyFocusedRect)
super.onFocusChanged(focused, direction, previouslyFocusedRect);
if (mTemporaryDetach) {
// If we are temporarily in the detach state, then do nothing.
return;
}
// Perform validation if the view is losing focus.
if (!focused) {
performValidation();
}
if (!focused && !mPopup.isDropDownAlwaysVisible()) {
dismissDropDown();
}
|
| public boolean | onKeyDown(int keyCode, android.view.KeyEvent event)
if (mPopup.onKeyDown(keyCode, event)) {
return true;
}
if (!isPopupShowing()) {
switch(keyCode) {
case KeyEvent.KEYCODE_DPAD_DOWN:
if (event.hasNoModifiers()) {
performValidation();
}
}
}
if (isPopupShowing() && keyCode == KeyEvent.KEYCODE_TAB && event.hasNoModifiers()) {
return true;
}
mLastKeyCode = keyCode;
boolean handled = super.onKeyDown(keyCode, event);
mLastKeyCode = KeyEvent.KEYCODE_UNKNOWN;
if (handled && isPopupShowing()) {
clearListSelection();
}
return handled;
|
| public boolean | onKeyPreIme(int keyCode, android.view.KeyEvent event)
if (keyCode == KeyEvent.KEYCODE_BACK && isPopupShowing()
&& !mPopup.isDropDownAlwaysVisible()) {
// special case for the back key, we do not even try to send it
// to the drop down list but instead, consume it immediately
if (event.getAction() == KeyEvent.ACTION_DOWN && event.getRepeatCount() == 0) {
KeyEvent.DispatcherState state = getKeyDispatcherState();
if (state != null) {
state.startTracking(event, this);
}
return true;
} else if (event.getAction() == KeyEvent.ACTION_UP) {
KeyEvent.DispatcherState state = getKeyDispatcherState();
if (state != null) {
state.handleUpEvent(event);
}
if (event.isTracking() && !event.isCanceled()) {
dismissDropDown();
return true;
}
}
}
return super.onKeyPreIme(keyCode, event);
|
| public boolean | onKeyUp(int keyCode, android.view.KeyEvent event)
boolean consumed = mPopup.onKeyUp(keyCode, event);
if (consumed) {
switch (keyCode) {
// if the list accepts the key events and the key event
// was a click, the text view gets the selected item
// from the drop down as its content
case KeyEvent.KEYCODE_ENTER:
case KeyEvent.KEYCODE_DPAD_CENTER:
case KeyEvent.KEYCODE_TAB:
if (event.hasNoModifiers()) {
performCompletion();
}
return true;
}
}
if (isPopupShowing() && keyCode == KeyEvent.KEYCODE_TAB && event.hasNoModifiers()) {
performCompletion();
return true;
}
return super.onKeyUp(keyCode, event);
|
| public void | onWindowFocusChanged(boolean hasWindowFocus)
super.onWindowFocusChanged(hasWindowFocus);
if (!hasWindowFocus && !mPopup.isDropDownAlwaysVisible()) {
dismissDropDown();
}
|
| public void | performCompletion()Performs the text completion by converting the selected item from
the drop down list into a string, replacing the text box's content with
this string and finally dismissing the drop down menu.
performCompletion(null, -1, -1);
|
| private void | performCompletion(android.view.View selectedView, int position, long id)
if (isPopupShowing()) {
Object selectedItem;
if (position < 0) {
selectedItem = mPopup.getSelectedItem();
} else {
selectedItem = mAdapter.getItem(position);
}
if (selectedItem == null) {
Log.w(TAG, "performCompletion: no selected item");
return;
}
mBlockCompletion = true;
replaceText(convertSelectionToString(selectedItem));
mBlockCompletion = false;
if (mItemClickListener != null) {
final ListPopupWindow list = mPopup;
if (selectedView == null || position < 0) {
selectedView = list.getSelectedView();
position = list.getSelectedItemPosition();
id = list.getSelectedItemId();
}
mItemClickListener.onItemClick(list.getListView(), selectedView, position, id);
}
}
if (mDropDownDismissedOnCompletion && !mPopup.isDropDownAlwaysVisible()) {
dismissDropDown();
}
|
| protected void | performFiltering(java.lang.CharSequence text, int keyCode)Starts filtering the content of the drop down list. The filtering
pattern is the content of the edit box. Subclasses should override this
method to filter with a different pattern, for instance a substring of
text.
mFilter.filter(text, this);
|
| public void | performValidation()If a validator was set on this view and the current string is not valid,
ask the validator to fix it.
if (mValidator == null) return;
CharSequence text = getText();
if (!TextUtils.isEmpty(text) && !mValidator.isValid(text)) {
setText(mValidator.fixText(text));
}
|
| protected void | replaceText(java.lang.CharSequence text)Performs the text completion by replacing the current text by the
selected item. Subclasses should override this method to avoid replacing
the whole content of the edit box.
clearComposingText();
setText(text);
// make sure we keep the caret at the end of the text view
Editable spannable = getText();
Selection.setSelection(spannable, spannable.length());
|
| public void | setAdapter(T adapter)Changes the list of data used for auto completion. The provided list
must be a filterable list adapter.
The caller is still responsible for managing any resources used by the adapter.
Notably, when the AutoCompleteTextView is closed or released, the adapter is not notified.
A common case is the use of {@link android.widget.CursorAdapter}, which
contains a {@link android.database.Cursor} that must be closed. This can be done
automatically (see
{@link android.app.Activity#startManagingCursor(android.database.Cursor)
startManagingCursor()}),
or by manually closing the cursor when the AutoCompleteTextView is dismissed.
if (mObserver == null) {
mObserver = new PopupDataSetObserver(this);
} else if (mAdapter != null) {
mAdapter.unregisterDataSetObserver(mObserver);
}
mAdapter = adapter;
if (mAdapter != null) {
//noinspection unchecked
mFilter = ((Filterable) mAdapter).getFilter();
adapter.registerDataSetObserver(mObserver);
} else {
mFilter = null;
}
mPopup.setAdapter(mAdapter);
|
| public void | setCompletionHint(java.lang.CharSequence hint)Sets the optional hint text that is displayed at the bottom of the
the matching list. This can be used as a cue to the user on how to
best use the list, or to provide extra information.
mHintText = hint;
if (hint != null) {
if (mHintView == null) {
final TextView hintView = (TextView) LayoutInflater.from(getContext()).inflate(
mHintResource, null).findViewById(com.android.internal.R.id.text1);
hintView.setText(mHintText);
mHintView = hintView;
mPopup.setPromptView(hintView);
} else {
mHintView.setText(hint);
}
} else {
mPopup.setPromptView(null);
mHintView = null;
}
|
| public void | setDropDownAlwaysVisible(boolean dropDownAlwaysVisible)Sets whether the drop-down should remain visible as long as there is there is
{@link #enoughToFilter()}. This is useful if an unknown number of results are expected
to show up in the adapter sometime in the future.
The drop-down will occupy the entire screen below {@link #getDropDownAnchor} regardless
of the size or content of the list. {@link #getDropDownBackground()} will fill any space
that is not used by the list.
mPopup.setDropDownAlwaysVisible(dropDownAlwaysVisible);
|
| public void | setDropDownAnchor(int id)Sets the view to which the auto-complete drop down list should anchor. The view
corresponding to this id will not be loaded until the next time it is needed to avoid
loading a view which is not yet instantiated.
mDropDownAnchorId = id;
mPopup.setAnchorView(null);
|
| public void | setDropDownAnimationStyle(int animationStyle)Sets the animation style of the auto-complete drop-down list.
If the drop-down is showing, calling this method will take effect only
the next time the drop-down is shown.
mPopup.setAnimationStyle(animationStyle);
|
| public void | setDropDownBackgroundDrawable(android.graphics.drawable.Drawable d)Sets the background of the auto-complete drop-down list.
mPopup.setBackgroundDrawable(d);
|
| public void | setDropDownBackgroundResource(int id)Sets the background of the auto-complete drop-down list.
mPopup.setBackgroundDrawable(getContext().getDrawable(id));
|
| public void | setDropDownDismissedOnCompletion(boolean dropDownDismissedOnCompletion)Sets whether the drop-down is dismissed when a suggestion is clicked. This is
true by default.
mDropDownDismissedOnCompletion = dropDownDismissedOnCompletion;
|
| public void | setDropDownHeight(int height)Sets the current height for the auto-complete drop down list. This can
be a fixed height, or {@link ViewGroup.LayoutParams#MATCH_PARENT} to fill
the screen, or {@link ViewGroup.LayoutParams#WRAP_CONTENT} to fit the height
of the drop down's content.
mPopup.setHeight(height);
|
| public void | setDropDownHorizontalOffset(int offset)Sets the horizontal offset used for the auto-complete drop-down list.
mPopup.setHorizontalOffset(offset);
|
| public void | setDropDownVerticalOffset(int offset)Sets the vertical offset used for the auto-complete drop-down list.
mPopup.setVerticalOffset(offset);
|
| public void | setDropDownWidth(int width)Sets the current width for the auto-complete drop down list. This can
be a fixed width, or {@link ViewGroup.LayoutParams#MATCH_PARENT} to fill the screen, or
{@link ViewGroup.LayoutParams#WRAP_CONTENT} to fit the width of its anchor view.
mPopup.setWidth(width);
|
| public void | setForceIgnoreOutsideTouch(boolean forceIgnoreOutsideTouch)Forces outside touches to be ignored. Normally if {@link #isDropDownAlwaysVisible()} is
false, we allow outside touch to dismiss the dropdown. If this is set to true, then we
ignore outside touch even when the drop down is not set to always visible.
mPopup.setForceIgnoreOutsideTouch(forceIgnoreOutsideTouch);
|
| protected boolean | setFrame(int l, int t, int r, int b)
boolean result = super.setFrame(l, t, r, b);
if (isPopupShowing()) {
showDropDown();
}
return result;
|
| public void | setListSelection(int position)Set the position of the dropdown view selection.
mPopup.setSelection(position);
|
| public void | setOnClickListener(OnClickListener listener)
mPassThroughClickListener.mWrapped = listener;
|
| public void | setOnDismissListener(android.widget.AutoCompleteTextView$OnDismissListener dismissListener)Set a listener that will be invoked whenever the AutoCompleteTextView's
list of completions is dismissed.
PopupWindow.OnDismissListener wrappedListener = null;
if (dismissListener != null) {
wrappedListener = new PopupWindow.OnDismissListener() {
@Override public void onDismiss() {
dismissListener.onDismiss();
}
};
}
mPopup.setOnDismissListener(wrappedListener);
|
| public void | setOnItemClickListener(AdapterView.OnItemClickListener l)Sets the listener that will be notified when the user clicks an item
in the drop down list.
mItemClickListener = l;
|
| public void | setOnItemSelectedListener(AdapterView.OnItemSelectedListener l)Sets the listener that will be notified when the user selects an item
in the drop down list.
mItemSelectedListener = l;
|
| public void | setText(java.lang.CharSequence text, boolean filter)Like {@link #setText(CharSequence)}, except that it can disable filtering.
if (filter) {
setText(text);
} else {
mBlockCompletion = true;
setText(text);
mBlockCompletion = false;
}
|
| public void | setThreshold(int threshold)Specifies the minimum number of characters the user has to type in the
edit box before the drop down list is shown.
When threshold is less than or equals 0, a threshold of
1 is applied.
if (threshold <= 0) {
threshold = 1;
}
mThreshold = threshold;
|
| public void | setValidator(android.widget.AutoCompleteTextView$Validator validator)Sets the validator used to perform text validation.
mValidator = validator;
|
| public void | showDropDown()Displays the drop down on screen.
buildImeCompletions();
if (mPopup.getAnchorView() == null) {
if (mDropDownAnchorId != View.NO_ID) {
mPopup.setAnchorView(getRootView().findViewById(mDropDownAnchorId));
} else {
mPopup.setAnchorView(this);
}
}
if (!isPopupShowing()) {
// Make sure the list does not obscure the IME when shown for the first time.
mPopup.setInputMethodMode(ListPopupWindow.INPUT_METHOD_NEEDED);
mPopup.setListItemExpandMax(EXPAND_MAX);
}
mPopup.show();
mPopup.getListView().setOverScrollMode(View.OVER_SCROLL_ALWAYS);
|
| public void | showDropDownAfterLayout()Issues a runnable to show the dropdown as soon as possible.
mPopup.postShow();
|
| private void | updateDropDownForFilter(int count)
// Not attached to window, don't update drop-down
if (getWindowVisibility() == View.GONE) return;
/*
* This checks enoughToFilter() again because filtering requests
* are asynchronous, so the result may come back after enough text
* has since been deleted to make it no longer appropriate
* to filter.
*/
final boolean dropDownAlwaysVisible = mPopup.isDropDownAlwaysVisible();
final boolean enoughToFilter = enoughToFilter();
if ((count > 0 || dropDownAlwaysVisible) && enoughToFilter) {
if (hasFocus() && hasWindowFocus() && mPopupCanBeUpdated) {
showDropDown();
}
} else if (!dropDownAlwaysVisible && isPopupShowing()) {
dismissDropDown();
// When the filter text is changed, the first update from the adapter may show an empty
// count (when the query is being performed on the network). Future updates when some
// content has been retrieved should still be able to update the list.
mPopupCanBeUpdated = true;
}
|
