android 联系人搜索

独立搜索代码

 

package com.android.search.test;

import android.app.Activity;
import android.content.ContentResolver;
import android.content.Context;
import android.content.Intent;
import android.content.UriMatcher;
import android.database.Cursor;
import android.database.MatrixCursor;
import android.net.Uri;
import android.os.Bundle;
import android.provider.ContactsContract;
import android.provider.ContactsContract.Contacts;
import android.text.Editable;
import android.text.TextUtils;
import android.text.TextWatcher;
import android.util.Log;
import android.view.KeyEvent;
import android.view.LayoutInflater;
import android.view.MotionEvent;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.View.OnFocusChangeListener;
import android.view.View.OnTouchListener;
import android.view.ViewGroup;
import android.view.inputmethod.EditorInfo;
import android.view.inputmethod.InputMethodManager;
import android.widget.AbsListView;
import android.widget.AbsListView.OnScrollListener;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.Button;
import android.widget.CursorAdapter;
import android.widget.EditText;
import android.widget.Filter;
import android.widget.ImageView;
import android.widget.ListView;
import android.widget.SectionIndexer;
import android.widget.TextView;

public class SearchTestActivity extends Activity implements OnClickListener, OnItemClickListener,
android.widget.AbsListView.OnScrollListener, TextWatcher, TextView.OnEditorActionListener,
OnFocusChangeListener, OnTouchListener{
    /** Called when the activity is first created. */
 private String TAG="=SearchTestActivity=";
 private static final int SUBACTIVITY_SEARCH = 4;
 private static final int SUBACTIVITY_FILTER = 5;

 static final String[] CONTACTS_SUMMARY_PROJECTION = new String[] {
   Contacts._ID, // 0
   "display_name", // 1
   "display_name",// "display_name_alt", // 2
   "display_name",// "sort_key", // 3
   Contacts.STARRED, // 4
   Contacts.TIMES_CONTACTED, // 5
   Contacts.CONTACT_PRESENCE, // 6
   Contacts.PHOTO_ID, // 7
   Contacts.LOOKUP_KEY, // 8
   "display_name",// "phonetic_name", // 9
   Contacts.HAS_PHONE_NUMBER, // 10
 };
 static final String[] CONTACTS_SUMMARY_PROJECTION_FROM_EMAIL = new String[] {
   Contacts._ID, // 0
   "display_name", // 1
   "display_name", // "display_name_alt", // 2
   "display_name",// "sort_key",// "sort_key", // 3
   Contacts.STARRED, // 4
   Contacts.TIMES_CONTACTED, // 5
   Contacts.CONTACT_PRESENCE, // 6
   Contacts.PHOTO_ID, // 7
   Contacts.LOOKUP_KEY, // 8
   "display_name",// "phonetic_name", // 9
 // email lookup doesn't included HAS_PHONE_NUMBER in projection
 };

 static final String[] CONTACTS_SUMMARY_FILTER_PROJECTION = new String[] {
   Contacts._ID, // 0
   "display_name", // 1
   "display_name",// "display_name_alt", // 2
   "display_name",// "sort_key",// "sort_key", // 3
   Contacts.STARRED, // 4
   Contacts.TIMES_CONTACTED, // 5
   Contacts.CONTACT_PRESENCE, // 6
   Contacts.PHOTO_ID, // 7
   Contacts.LOOKUP_KEY, // 8
   "display_name",// "phonetic_name", // 9
   Contacts.HAS_PHONE_NUMBER, // 10
   "display_name",// "snippet_mimetype", // 11
   "display_name",// "snippet_data1", // 12
   "display_name", // "snippet_data4", // 13
 };
 static final int SUMMARY_ID_COLUMN_INDEX = 0;
 static final int SUMMARY_DISPLAY_NAME_PRIMARY_COLUMN_INDEX = 1;
 static final int SUMMARY_DISPLAY_NAME_ALTERNATIVE_COLUMN_INDEX = 2;
 static final int SUMMARY_SORT_KEY_PRIMARY_COLUMN_INDEX = 3;
 static final int SUMMARY_STARRED_COLUMN_INDEX = 4;
 static final int SUMMARY_TIMES_CONTACTED_COLUMN_INDEX = 5;
 static final int SUMMARY_PRESENCE_STATUS_COLUMN_INDEX = 6;
 static final int SUMMARY_PHOTO_ID_COLUMN_INDEX = 7;
 static final int SUMMARY_LOOKUP_KEY_COLUMN_INDEX = 8;
 static final int SUMMARY_PHONETIC_NAME_COLUMN_INDEX = 9;
 static final int SUMMARY_HAS_PHONE_COLUMN_INDEX = 10;
 static final int SUMMARY_SNIPPET_MIMETYPE_COLUMN_INDEX = 11;
 static final int SUMMARY_SNIPPET_DATA1_COLUMN_INDEX = 12;
 static final int SUMMARY_SNIPPET_DATA4_COLUMN_INDEX = 13;

 private boolean mJustCreated;
 private boolean mDisplayOnlyPhones;

 private boolean mSearchMode;

 private boolean mSearchInitiated;

 private String mInitialFilter;

 private static final String CLAUSE_ONLY_VISIBLE = Contacts.IN_VISIBLE_GROUP+ "=1";
 private static final String CLAUSE_ONLY_PHONES = Contacts.HAS_PHONE_NUMBER+ "=1";

 // Uri matcher for contact id
 private static final int CONTACTS_ID = 1001;
 private static final UriMatcher sContactsIdMatcher;

 final String[] sLookupProjection = new String[] { Contacts.LOOKUP_KEY };

 static {
  sContactsIdMatcher = new UriMatcher(UriMatcher.NO_MATCH);
  sContactsIdMatcher.addURI(ContactsContract.AUTHORITY, "contacts/#",
    CONTACTS_ID);
 }
 
 private ListView mList;
 private SearchListAdapter mSearchListAdapter;
 private Button mBtn;
 private EditText mEdit;
 private void init(){
  mBtn=(Button) findViewById(R.id.btn);
  mList=(ListView) findViewById(R.id.list);
  mSearchListAdapter=new SearchListAdapter(SearchTestActivity.this);
  mList.setAdapter(mSearchListAdapter);
  mList.setOnFocusChangeListener(this);
  mList.setOnTouchListener(this);
  mList.setSaveEnabled(false);
  mBtn.setOnClickListener(new OnClickListener() {
   
   @Override
   public void onClick(View v) {
    onSearchRequested();
   }
  });
  mEdit=(EditText) findViewById(R.id.search_edit);
  mEdit.addTextChangedListener(this);
  mEdit.setOnEditorActionListener(this);
  mEdit.setText(mInitialFilter);
  mEdit.requestFocus();
 }
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        init();
    }
 
    void startQuery() {
        Log.i(TAG, "=====startQuery()==");
           // Set the proper empty string
           setEmptyText();
           mSearchListAdapter.setLoading(true);
           // When sort order and display order contradict each other, we want to
           // highlight the part of the name used for sorting.
           String[] projection = getProjectionForQuery();
           if (mSearchMode && TextUtils.isEmpty(getTextFilter())) {
            mSearchListAdapter.changeCursor(new MatrixCursor(projection));
               return;
           }

       }
    private void setEmptyText() {
        if ( mSearchMode) {
            return;
        }
    }

    private String getTextFilter() {
        if (mEdit != null) {
            return mEdit.getText().toString();
        }
        return null;
    }
    private void hideSoftKeyboard() {
        // Hide soft keyboard, if visible
        InputMethodManager inputMethodManager = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
        inputMethodManager.hideSoftInputFromWindow(mList.getWindowToken(), 0);
    }
    String[] getProjectionForQuery() {
        return CONTACTS_SUMMARY_FILTER_PROJECTION;
    }
    @Override
    public void startSearch(String initialQuery, boolean selectInitialQuery, Bundle appSearchData,
            boolean globalSearch) {
      Log.i(TAG, "===startSearch=globalSearch="+globalSearch);
        if (globalSearch) {
            super.startSearch(initialQuery, selectInitialQuery, appSearchData, globalSearch);
        } else {
            if (!mSearchMode) {
                /*if ((mMode & MODE_MASK_PICKER) != 0) {
                    ContactsSearchManager.startSearchForResult(this, initialQuery,
                            SUBACTIVITY_FILTER);
                } else {
                    ContactsSearchManager.startSearch(this, initialQuery);
                }*/
            }
        }
    }
   
    /**
     * Called from a background thread to do the filter and return the resulting cursor.
     *
     * @param filter the text that was entered to filter on
     * @return a cursor with the results of the filter
     */
    Cursor doFilter(String filter) {
     //Cursor cursor;
        String[] projection = getProjectionForQuery();
        if (mSearchMode && TextUtils.isEmpty(getTextFilter())) {
            return new MatrixCursor(projection);
        }

        final ContentResolver resolver = getContentResolver();
        Log.i(TAG, "====getContactFilterUri==="+getContactFilterUri(filter)+"==filter="+filter);
        return resolver.query(getContactFilterUri(filter), projection,
                getContactSelection(), null,null);
    }

    private String getContactSelection() {
        if (mDisplayOnlyPhones) {
            return CLAUSE_ONLY_VISIBLE + " AND " + CLAUSE_ONLY_PHONES;
        } else {
            return CLAUSE_ONLY_VISIBLE;
        }
    }

    private Uri getContactFilterUri(String filter) {
        Uri baseUri;
        if (!TextUtils.isEmpty(filter)) {
            baseUri = Uri.withAppendedPath(Contacts.CONTENT_FILTER_URI, Uri.encode(filter));
        } else {
            baseUri = Contacts.CONTENT_URI;
        }

        if (true) {
            return buildSectionIndexerUri(baseUri);
        } else {
            return baseUri;
        }
    }
    private static Uri buildSectionIndexerUri(Uri uri) {
     return uri.buildUpon().appendQueryParameter("address_book_index_extras", "true").build();
     //return null;
    }

    // TODO: fix PluralRules to handle zero correctly and use Resources.getQuantityText directly
    protected String getQuantityText(int count, int zeroResourceId, int pluralResourceId) {
        if (count == 0) {
            return getString(zeroResourceId);
        } else {
            String format = getResources().getQuantityText(pluralResourceId, count).toString();
            return String.format(format, count);
        }
    }
   
    Cursor getItemForView(View view) {
        ListView listView =mList;
        int index = listView.getPositionForView(view);
        if (index < 0) {
            return null;
        }
        return (Cursor) listView.getAdapter().getItem(index);
    }
    @Override
    protected void onRestart() {
        super.onRestart();
        if (TextUtils.isEmpty(getTextFilter())) {
            startQuery();
        } else {
            // Run the filtered query on the adapter
         mSearchListAdapter.onContentChanged();
        }
    }
  @Override
  protected void onDestroy() {

   super.onDestroy();

  }

  @Override
  protected void onPause() {

   super.onPause();
  }
  
  @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
     Log.i(TAG, "=====onActivityResult()==requestCode"+requestCode);
        switch (requestCode) {
            case SUBACTIVITY_FILTER:
            case SUBACTIVITY_SEARCH:
                // Pass through results of filter or search UI
                if (resultCode == RESULT_OK) {
                    setResult(RESULT_OK, data);
                    finish();
                }
                break;
        }
    }
    /**
     * Event handler for the use case where the user starts typing without
     * bringing up the search UI first.
     */
    public boolean onKey(View v, int keyCode, KeyEvent event) {
        if (!mSearchMode&& !mSearchInitiated) {
            int unicodeChar = event.getUnicodeChar();
            if (unicodeChar != 0) {
                mSearchInitiated = true;
                startSearch(new String(new int[]{unicodeChar}, 0, 1), false, null, false);
                return true;
            }
        }
        return false;
    }
   
    /**
     * Event handler for search UI.
     */
    public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
        if (actionId == EditorInfo.IME_ACTION_DONE) {
            hideSoftKeyboard();
            if (TextUtils.isEmpty(getTextFilter())) {
                finish();
            }
            return true;
        }
        return false;
    }
    /**
     * Dismisses the soft keyboard when the list takes focus.
     */
    public void onFocusChange(View view, boolean hasFocus) {
        if (view ==mList && hasFocus) {
            hideSoftKeyboard();
        }
    }

    /**
     * Dismisses the soft keyboard when the list takes focus.
     */
    public boolean onTouch(View view, MotionEvent event) {
        if (view == mList) {
            hideSoftKeyboard();
        }
        return false;
    }

    /**
     * Dismisses the search UI along with the keyboard if the filter text is empty.
     */
    public boolean onKeyPreIme(int keyCode, KeyEvent event) {
        if (mSearchMode && keyCode == KeyEvent.KEYCODE_BACK && TextUtils.isEmpty(getTextFilter())) {
            hideSoftKeyboard();
            onBackPressed();
            return true;
        }
        return false;
    }

  @Override
  protected void onResume() {
   super.onResume();

         // See if we were invoked with a filter
         if (mSearchMode) {
             mEdit.requestFocus();
         }
         if (mJustCreated) {
             startQuery();
         }
         mJustCreated = false;
         mSearchInitiated = false;
  }

    /**
     * Performs filtering of the list based on the search query entered in the
     * search text edit.
     */
    protected void onSearchTextChanged() {
      Log.i(TAG, "===onSearchTextChanged");
        // Set the proper empty string
        setEmptyText();

        Filter filter = mSearchListAdapter.getFilter();
        filter.filter(getTextFilter());
    }
 private final class SearchListAdapter extends CursorAdapter implements SectionIndexer, OnScrollListener{
  private LayoutInflater mLayoutInflater;
   private SectionIndexer mIndexer;
         private boolean mLoading = true;
         private int mFrequentSeparatorPos = ListView.INVALID_POSITION;
         private Cursor mSuggestionsCursor;
         private Cursor mCursor;
         private int mSuggestionsCursorCount;
         private Context mContext;

  public SearchListAdapter(Context context) {
   super(context, null,false);
   Log.i(TAG, "==SearchListAdapter=");
   mContext=context;
   mLayoutInflater = LayoutInflater.from(context);
  }

  public void setSuggestionsCursor(Cursor cursor) {
   if (cursor != null) {
    Log.i(TAG, "=cursor=" + cursor.getCount());
   }
   if (mSuggestionsCursor != null) {
    mSuggestionsCursor.close();
   }
   mSuggestionsCursor = cursor;
   mSuggestionsCursorCount = cursor == null ? 0 : cursor.getCount();
  }

  public void setLoading(boolean loading) {
   mLoading = loading;
  }

  @Override
  public boolean isEmpty() {
   Log.i(TAG, "==isEmpty=");
    if (mLoading) {
     return false;
    } else {
     return super.isEmpty();
    }
  }

  @Override
  public int getItemViewType(int position) {
   Log.i(TAG, "==getItemViewType=");
   if (getSeparatorId(position) != 0) {
    // We don't want the separator view to be recycled.
    return IGNORE_ITEM_VIEW_TYPE;
   }
   return super.getItemViewType(position);
  }

         private int getSeparatorId(int position) {
          Log.i(TAG, "==getSeparatorId=");
             int separatorId = 0;
             return separatorId;
         }
  @Override
  public void bindView(View view, Context context, Cursor cursor) {
   Log.i(TAG, "bindView=cursror="+cursor.getCount());
   TextView nameTextView = (TextView) view
     .findViewById(R.id.contact_name_tv);
   TextView phoTextView = (TextView) view
     .findViewById(R.id.contact_phone_tv);
   ImageView headImageView = (ImageView) view
     .findViewById(R.id.contact_imageview);
   if(cursor!=null&&cursor.getCount()>0){
    long contactId=cursor.getLong(SUMMARY_ID_COLUMN_INDEX);
    nameTextView.setText(contactId+"contactId");
    phoTextView.setText(cursor.getString(SUMMARY_LOOKUP_KEY_COLUMN_INDEX));
    
   }

  }
  @Override
  public View getView(int position, View convertView, ViewGroup parent) {
   Log.i(TAG, "==getView=");
   View v;
            if (convertView == null || convertView.getTag() == null) {
                v = newView(mContext,mCursor, parent);
            } else {
                v = convertView;
            }

            bindView(v, mContext,mCursor);
            return v;
  }
  @Override
  public View newView(Context context, Cursor cursor, ViewGroup parent) {
   Log.i(TAG, "==newView=");
   return mLayoutInflater.inflate(R.layout.search_item_layout, null);

  }

  @Override
  public void changeCursor(Cursor cursor) {
   if(cursor!=null){
          Log.i(TAG, "==changeCursor="+cursor.getCount());
          }
             if (cursor != null) {
                 setLoading(false);
             }

             // Get the split between starred and frequent items, if the mode is strequent
             mFrequentSeparatorPos = ListView.INVALID_POSITION;
             if (cursor != null && (cursor.getCount()) > 0) {
                 cursor.move(-1);
                 for (int i = 0; cursor.moveToNext(); i++) {
                     int starred = cursor.getInt(SUMMARY_STARRED_COLUMN_INDEX);
                     if (starred == 0) {
                         if (i > 0) {
                             // Only add the separator when there are starred items present
                             mFrequentSeparatorPos = i;
                         }
                         break;
                     }
                 }
             }

            /* if (cursor != null && mSearchResultsMode) {
                 TextView foundContactsText = (TextView)findViewById(R.id.search_results_found);
                 String text = getQuantityText(cursor.getCount(), R.string.listFoundAllContactsZero,
                         R.plurals.listFoundAllContacts);
                 foundContactsText.setText(text);
             }*/

             super.changeCursor(cursor);
             // Update the indexer for the fast scroll widget
             mCursor=cursor;
             updateIndexer(cursor);
             //this.notifyDataSetChanged();
  }
   private void updateIndexer(Cursor cursor) {
    Log.i(TAG, "==updateIndexer=");
             if (cursor == null) {
                 mIndexer = null;
                 return;
             }
         }

  @Override
  protected void onContentChanged() {
   super.onContentChanged();
   Log.i(TAG, "==onContentChanged=");
    CharSequence constraint = getTextFilter();
             if (!TextUtils.isEmpty(constraint)) {
                 // Reset the filter state then start an async filter operation
                 Filter filter = getFilter();
                 filter.filter(constraint);
             } else {
                 // Start an async query
                 startQuery();
             }
  }
  
  @Override
        public boolean areAllItemsEnabled() {
   Log.i(TAG, "==areAllItemsEnabled=");
            return false;
        }
  
  @Override
        public boolean isEnabled(int position) {
   Log.i(TAG, "==isEnabled=");
           
            return true;
        }
  @Override
  public Cursor runQueryOnBackgroundThread(CharSequence constraint) {
   Cursor cursor=doFilter(constraint.toString());
   Log.i(TAG,"=runQueryOnBackgroundThread==constraint="+constraint+"==curor="+cursor.getCount());
   return cursor;
  }
  
   @Override
         public int getCount() {
             int superCount = super.getCount();
            // Log.i(TAG, "===getCount"+superCount);
             if (mSuggestionsCursorCount != 0) {
                 // When showing suggestions, we have 2 additional list items: the "Suggestions"
                 // and "All contacts" headers.
                 return mSuggestionsCursorCount + superCount + 2;
             }
             else if (mFrequentSeparatorPos != ListView.INVALID_POSITION) {
                 // When showing strequent list, we have an additional list item - the separator.
                 return superCount + 1;
             } else {
                 return superCount;
             }
         }

         private int getRealPosition(int pos) {
           Log.i(TAG, "===getRealPosition");

              if (mSuggestionsCursorCount != 0) {
                 // When showing suggestions, we have 2 additional list items: the "Suggestions"
                 // and "All contacts" separators.
                 if (pos < mSuggestionsCursorCount + 2) {
                     // We are in the upper partition (Suggestions). Adjusting for the "Suggestions"
                     // separator.
                     return pos - 1;
                 } else {
                     // We are in the lower partition (All contacts). Adjusting for the size
                     // of the upper partition plus the two separators.
                     return pos - mSuggestionsCursorCount - 2;
                 }
             } else if (mFrequentSeparatorPos == ListView.INVALID_POSITION) {
                 // No separator, identity map
                 return pos;
             } else if (pos <= mFrequentSeparatorPos) {
                 // Before or at the separator, identity map
                 return pos;
             } else {
                 // After the separator, remove 1 from the pos to get the real underlying pos
                 return pos - 1;
             }
         }

         @Override
         public Object getItem(int pos) {
           Log.i(TAG, "===getItem");
             if (mSuggestionsCursorCount != 0 && pos <= mSuggestionsCursorCount) {
                 mSuggestionsCursor.moveToPosition(getRealPosition(pos));
                 return mSuggestionsCursor;
             } else if (isSearchAllContactsItemPosition(pos)){
                 return null;
             } else {
                 int realPosition = getRealPosition(pos);
                 if (realPosition < 0) {
                     return null;
                 }
                 return super.getItem(realPosition);
             }
         }
        
         private boolean isSearchAllContactsItemPosition(int position) {
          Log.i(TAG, "==isSearchAllContactsItemPosition=");
             return mSearchMode && position == getCount() - 1;
         }

         @Override
         public long getItemId(int pos) {
           Log.i(TAG, "===getItemId");
             if (mSuggestionsCursorCount != 0 && pos < mSuggestionsCursorCount + 2) {
                 if (mSuggestionsCursor.moveToPosition(pos - 1)) {
                     return mSuggestionsCursor.getLong(0);
                 } else {
                     return 0;
                 }
             }
             int realPosition = getRealPosition(pos);
             if (realPosition < 0) {
                 return 0;
             }
             return super.getItemId(realPosition);
         }

   public Object [] getSections() {
    Log.i(TAG, "==getSections=");
             if (mIndexer == null) {
                 return new String[] { " " };
             } else {
                 return mIndexer.getSections();
             }
         }

         public int getPositionForSection(int sectionIndex) {
           Log.i(TAG, "==getPositionForSection=");
             if (mIndexer == null) {
                 return -1;
             }

             return mIndexer.getPositionForSection(sectionIndex);
         }

         public int getSectionForPosition(int position) {
          Log.i(TAG, "==getSectionForPosition=");
             if (mIndexer == null) {
                 return -1;
             }

             return mIndexer.getSectionForPosition(position);
         }

   @Override
   public void onScrollStateChanged(AbsListView view, int scrollState) {
    // TODO Auto-generated method stub
    
   }

   @Override
   public void onScroll(AbsListView view, int firstVisibleItem,
     int visibleItemCount, int totalItemCount) {
    // TODO Auto-generated method stub
    
   }

 }
 @Override
 public void afterTextChanged(Editable arg0) {
    onSearchTextChanged();
  
 }

 @Override
 public void beforeTextChanged(CharSequence s, int start, int count,
   int after) {

 }

 @Override
 public void onTextChanged(CharSequence s, int start, int before, int count) {

 }
 @Override
 public void onScrollStateChanged(AbsListView view, int scrollState) {
  // TODO Auto-generated method stub
  
 }
 @Override
 public void onScroll(AbsListView view, int firstVisibleItem,
   int visibleItemCount, int totalItemCount) {
  // TODO Auto-generated method stub
  
 }
 @Override
 public void onItemClick(AdapterView<?> parent, View view, int position,
   long id) {
  // TODO Auto-generated method stub
  
 }
 @Override
 public void onClick(View v) {
  // TODO Auto-generated method stub
  
 }
}

 

 

 

 

总的说来，搜索界面是一个AutoCompleteTextView，他的数据是一个SuggestionsAdapter，每次输入内容后，更新AutoCompleteTextView中的mFilter, 然后在contacts中的peopleLookup表中查找，更新adapter，然后将结果显示给用户 

1，当我们点击联系人中menu->search后，调用了activity中的startSearch函数，该函数的几个参数值
得注意，因为指定了是否进行全局搜索、初始搜索的值

case MENU_SEARCH:

startSearch(null, false, null, false);

return true;

2，在SearchManager.java中实例化了一个SearchDialog的对象，然后调用show方法来创建一个搜索框（因为dialog控件是通过show来调用onCreate函数的）,在onCreate函数中对输入框注册了连个监听函数

mSearchTextField.addTextChangedListener(mTextWatcher);

mSearchTextField.setOnKeyListener(mTextKeyListener);

用来在输入框的内容发生改变后，更新mUserQuery，另外更新些其他信息，例如selection的start和end

3，在SearchDialog.java中，提供了一个很重要的Adatpter，它是继承SimpleCursorAdapter的，在show方法中，可以看到如下一段代码：

mSuggestionsAdapter = new SuggestionsAdapter(getContext(), mSearchable, mSearchTextField);

mSearchTextField.setAdapter(mSuggestionsAdapter);

mSuggestionsAdapter.setNonUserQuery(false);

mSearchTextField.setText(initialQuery);

可别小看了mSearchTextField.setText(initialQuery),由于我们没有指定初始查询值，可以在这段函数前面看到initialQuery被初始成了 “”.

4,由于AutoCompleteTextView注册了一个TextWatcher，因此在输入框在setText后，调用了sendAfterTextChanged->list.get(i).afterTextChanged(text)->AutoCompleteTextView.MyWatcher.afterTextChanged->doAfterTextChanged，在doAfterTextChanged函数中，调用了performFiltering（AutoCompleteTextView.java），该函数更新了mFliter中的filter:

mFilter.filter(text, this);//在该函数中创建一个查询线程，然后将句柄为FILTER_TOKEN的消息加入到该线程的消息队列中，方便在handleMessage时得知当前的消息，这个在后面可以看到

5，查询线程执行FILTER_TOKEN消息，在Filter.java中的handleMessage函数执行如下分支：

case FILTER_TOKEN:

..........

//执行了搜索

args.results = performFiltering(args.constraint);

............

............

//添加新的消息到消息队列

Message finishMessage = mThreadHandler.obtainMessage(FINISH_TOKEN);

mThreadHandler.sendMessageDelayed(finishMessage, 3000);

}

break;

6，在filter.java中再来看看performFiltering的实现

Cursor cursor = mClient.runQueryOnBackgroundThread(constraint);

由于此时的mClient就是SuggestionAdapter，所以runQueryOnBackgroundThread(constraint);在SuggestionAdapter中实现的，关键代码如下：

c = getSuggestions(mSearchable, query);

getSuggestions函数中可以看到它构建了uri,然后调用了ContentResolver中的query函数

进一步跟踪到AbstractSyncableContentProvider中query函数，发现它调用了queryInternal(url, projection, selection, selectionArgs, sortOrder);（在ContactsProvider中实现的)

7，查询完成后，ResultsHandler.handleMessage负责更新将CursorAdapter.java中的mCursor,同时调用notifyDataSetChanged();改变Adapter; 然后调用onFilterComplete更新数据显示

publishResults(args.constraint, args.results);

args.listener.onFilterComplete(count);//由AutoCompleteTextView.onFilterComplete更新数据

8,如果搜索不到，就会在CursorAdapter.changeCursor中调用notifyDataSetInvalidated();通知；

9，当在搜索框中输入了字符，调用AutoCompleteTextView中的doAfterChanged函数，从而执行上面4到8的步骤

备注：联系人中查询的uri是”content://contacts/search_suggest_query/输入的字符“，首先在peopleLookup表中查找到联系人的ID,然后到people, phones, contact_methods, organizations表中查找对应联系人的信息