public class AutoCompleteTextView extends EditText implements Filter.FilterListener

public static interface FilterListener {        /**         * <p>Notifies the end of a filtering operation.</p>         *         * @param count the number of values computed by the filter         */        public void onFilterComplete(int count);}

public AutoCompleteTextView(Context context, AttributeSet attrs, int defStyle) {        super(context, attrs, defStyle);        mPopup = new ListPopupWindow(context, attrs,                com.android.internal.R.attr.autoCompleteTextViewStyle);......                mThreshold = a.getInt(                R.styleable.AutoCompleteTextView_completionThreshold, 2);                // Get the anchor‘s id now, but the view won‘t be ready, so wait to actually get the        // view and store it in mDropDownAnchorView lazily in getDropDownAnchorView later.        // Defaults to NO_ID, in which case the getDropDownAnchorView method will simply return        // this TextView, as a default anchoring point.        mDropDownAnchorId = a.getResourceId(R.styleable.AutoCompleteTextView_dropDownAnchor,                View.NO_ID);.....        addTextChangedListener(new MyWatcher());            }

private class MyWatcher implements TextWatcher {        public void afterTextChanged(Editable s) {            doAfterTextChanged();        }        public void beforeTextChanged(CharSequence s, int start, int count, int after) {            doBeforeTextChanged();        }        public void onTextChanged(CharSequence s, int start, int before, int count) {        }    }

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);            }        }    }

protected void performFiltering(CharSequence text, int keyCode) {        mFilter.filter(text, this);    }

public <T extends ListAdapter & Filterable> void setAdapter(T adapter) {        if (mObserver == null) {            mObserver = new PopupDataSetObserver();        } 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 interface Filterable {    /**     * <p>Returns a filter that can be used to constrain data with a filtering     * pattern.</p>     *     * <p>This method is usually implemented by {@link android.widget.Adapter}     * classes.</p>     *     * @return a filter used to constrain data     */    Filter getFilter();}

public final void filter(CharSequence constraint, FilterListener listener) {        synchronized (mLock) {            if (mThreadHandler == null) {                HandlerThread thread = new HandlerThread(                        THREAD_NAME, android.os.Process.THREAD_PRIORITY_BACKGROUND);                thread.start();                mThreadHandler = new RequestHandler(thread.getLooper());            }            final long delay = (mDelayer == null) ? 0 : mDelayer.getPostingDelay(constraint);                        Message message = mThreadHandler.obtainMessage(FILTER_TOKEN);                RequestArguments args = new RequestArguments();            // make sure we use an immutable copy of the constraint, so that            // it doesn‘t change while the filter operation is in progress            args.constraint = constraint != null ? constraint.toString() : null;            args.listener = listener;            message.obj = args;                mThreadHandler.removeMessages(FILTER_TOKEN);            mThreadHandler.removeMessages(FINISH_TOKEN);            mThreadHandler.sendMessageDelayed(message, delay);        }    }

public void handleMessage(Message msg) {            int what = msg.what;            Message message;            switch (what) {                case FILTER_TOKEN:                    RequestArguments args = (RequestArguments) msg.obj;                    try {                        args.results = performFiltering(args.constraint);                    } catch (Exception e) {                        args.results = new FilterResults();                        Log.w(LOG_TAG, "An exception occured during performFiltering()!", e);                    } finally {                        message = mResultHandler.obtainMessage(what);                        message.obj = args;                        message.sendToTarget();                    }                    synchronized (mLock) {                        if (mThreadHandler != null) {                            Message finishMessage = mThreadHandler.obtainMessage(FINISH_TOKEN);                            mThreadHandler.sendMessageDelayed(finishMessage, 3000);                        }                    }                    break;                case FINISH_TOKEN:                    synchronized (mLock) {                        if (mThreadHandler != null) {                            mThreadHandler.getLooper().quit();                            mThreadHandler = null;                        }                    }                    break;            }        }

private class ResultsHandler extends Handler {        /**         * <p>Messages received from the request handler are processed in the         * UI thread. The processing involves calling         * {@link Filter#publishResults(CharSequence,         * android.widget.Filter.FilterResults)}         * to post the results back in the UI and then notifying the listener,         * if any.</p>          *         * @param msg the filtering results         */        @Override        public void handleMessage(Message msg) {            RequestArguments args = (RequestArguments) msg.obj;            publishResults(args.constraint, args.results);            if (args.listener != null) {                int count = args.results != null ? args.results.count : -1;                args.listener.onFilterComplete(count);            }        }    }

public class ArrayAdapter<T> extends BaseAdapter implements Filterable {    
　　public Filter getFilter() {        if (mFilter == null) {            mFilter = new ArrayFilter();        }        return mFilter;    }
    private class ArrayFilter extends Filter {        @Override        protected FilterResults performFiltering(CharSequence prefix)       {            FilterResults results = new FilterResults();            if (mOriginalValues == null) {                synchronized (mLock) {                    mOriginalValues = new ArrayList<T>(mObjects);                }            }            if (prefix == null || prefix.length() == 0) {                ArrayList<T> list;                synchronized (mLock) {                    list = new ArrayList<T>(mOriginalValues);                }                results.values = list;                results.count = list.size();            } else {                String prefixString = prefix.toString().toLowerCase();                ArrayList<T> values;                synchronized (mLock) {                    values = new ArrayList<T>(mOriginalValues);                }                final int count = values.size();                final ArrayList<T> newValues = new ArrayList<T>();                for (int i = 0; i < count; i++) {                    final T value =http://www.mamicode.com/ values.get(i);                    final String valueText = value.toString().toLowerCase();                    // First match against the whole, non-splitted value                    if (valueText.startsWith(prefixString)) {                        newValues.add(value);                    } else {                        final String[] words = valueText.split(" ");                        final int wordCount = words.length;                        // Start at index 0, in case valueText starts with space(s)                        for (int k = 0; k < wordCount; k++) {                            if (words[k].startsWith(prefixString)) {                                newValues.add(value);                                break;                            }                        }                    }                }                results.values = newValues;                results.count = newValues.size();            }            return results;        }        @Override        protected void publishResults(CharSequence constraint, FilterResults results) {            //noinspection unchecked            mObjects = (List<T>) results.values;            if (results.count > 0) {                notifyDataSetChanged();            } else {                notifyDataSetInvalidated();            }        }    }}