Java tutorial
/* * Copyright (C) 2011 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 com.chen.ex.chips; import android.accounts.Account; import android.content.ContentResolver; import android.content.Context; import android.content.pm.PackageManager; import android.content.pm.PackageManager.NameNotFoundException; import android.content.res.Resources; import android.database.Cursor; import android.graphics.Bitmap; import android.graphics.BitmapFactory; import android.net.Uri; import android.os.AsyncTask; import android.os.Handler; import android.os.Message; import android.provider.ContactsContract; import android.provider.ContactsContract.CommonDataKinds.Photo; import android.provider.ContactsContract.Directory; import android.support.v4.util.LruCache; import android.text.TextUtils; import android.text.util.Rfc822Token; import android.util.Log; import android.view.LayoutInflater; import android.view.View; import android.view.ViewGroup; import android.widget.AutoCompleteTextView; import android.widget.BaseAdapter; import android.widget.Filter; import android.widget.Filterable; import android.widget.ImageView; import android.widget.TextView; import com.chen.mail.R; import java.io.ByteArrayOutputStream; import java.io.InputStream; import java.io.IOException; import java.util.ArrayList; import java.util.HashSet; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.Set; /** * Adapter for showing a recipient list. */ public abstract class BaseRecipientAdapter extends BaseAdapter implements Filterable, AccountSpecifier { private static final String TAG = "BaseRecipientAdapter"; private static final boolean DEBUG = false; /** * The preferred number of results to be retrieved. This number may be * exceeded if there are several directories configured, because we will use * the same limit for all directories. */ private static final int DEFAULT_PREFERRED_MAX_RESULT_COUNT = 10; /** * The number of extra entries requested to allow for duplicates. Duplicates * are removed from the overall result. */ static final int ALLOWANCE_FOR_DUPLICATES = 5; // This is ContactsContract.PRIMARY_ACCOUNT_NAME. Available from ICS as hidden static final String PRIMARY_ACCOUNT_NAME = "name_for_primary_account"; // This is ContactsContract.PRIMARY_ACCOUNT_TYPE. Available from ICS as hidden static final String PRIMARY_ACCOUNT_TYPE = "type_for_primary_account"; /** The number of photos cached in this Adapter. */ private static final int PHOTO_CACHE_SIZE = 20; /** * The "Waiting for more contacts" message will be displayed if search is not complete * within this many milliseconds. */ private static final int MESSAGE_SEARCH_PENDING_DELAY = 1000; /** Used to prepare "Waiting for more contacts" message. */ private static final int MESSAGE_SEARCH_PENDING = 1; public static final int QUERY_TYPE_EMAIL = 0; public static final int QUERY_TYPE_PHONE = 1; private final Queries.Query mQuery; private final int mQueryType; /** * Model object for a {@link Directory} row. */ public final static class DirectorySearchParams { public long directoryId; public String directoryType; public String displayName; public String accountName; public String accountType; public CharSequence constraint; public DirectoryFilter filter; } private static class PhotoQuery { public static final String[] PROJECTION = { Photo.PHOTO }; public static final int PHOTO = 0; } protected static class DirectoryListQuery { public static final Uri URI = Uri.withAppendedPath(ContactsContract.AUTHORITY_URI, "directories"); public static final String[] PROJECTION = { Directory._ID, // 0 Directory.ACCOUNT_NAME, // 1 Directory.ACCOUNT_TYPE, // 2 Directory.DISPLAY_NAME, // 3 Directory.PACKAGE_NAME, // 4 Directory.TYPE_RESOURCE_ID, // 5 }; public static final int ID = 0; public static final int ACCOUNT_NAME = 1; public static final int ACCOUNT_TYPE = 2; public static final int DISPLAY_NAME = 3; public static final int PACKAGE_NAME = 4; public static final int TYPE_RESOURCE_ID = 5; } /** Used to temporarily hold results in Cursor objects. */ protected static class TemporaryEntry { public final String displayName; public final String destination; public final int destinationType; public final String destinationLabel; public final long contactId; public final long dataId; public final String thumbnailUriString; public final int displayNameSource; public TemporaryEntry(String displayName, String destination, int destinationType, String destinationLabel, long contactId, long dataId, String thumbnailUriString, int displayNameSource) { this.displayName = displayName; this.destination = destination; this.destinationType = destinationType; this.destinationLabel = destinationLabel; this.contactId = contactId; this.dataId = dataId; this.thumbnailUriString = thumbnailUriString; this.displayNameSource = displayNameSource; } public TemporaryEntry(Cursor cursor) { this.displayName = cursor.getString(Queries.Query.NAME); this.destination = cursor.getString(Queries.Query.DESTINATION); this.destinationType = cursor.getInt(Queries.Query.DESTINATION_TYPE); this.destinationLabel = cursor.getString(Queries.Query.DESTINATION_LABEL); this.contactId = cursor.getLong(Queries.Query.CONTACT_ID); this.dataId = cursor.getLong(Queries.Query.DATA_ID); this.thumbnailUriString = cursor.getString(Queries.Query.PHOTO_THUMBNAIL_URI); this.displayNameSource = cursor.getInt(Queries.Query.DISPLAY_NAME_SOURCE); } } /** * Used to pass results from {@link DefaultFilter#performFiltering(CharSequence)} to * {@link DefaultFilter#publishResults(CharSequence, Filter.FilterResults)} */ private static class DefaultFilterResult { public final List<RecipientEntry> entries; public final LinkedHashMap<Long, List<RecipientEntry>> entryMap; public final List<RecipientEntry> nonAggregatedEntries; public final Set<String> existingDestinations; public final List<DirectorySearchParams> paramsList; public DefaultFilterResult(List<RecipientEntry> entries, LinkedHashMap<Long, List<RecipientEntry>> entryMap, List<RecipientEntry> nonAggregatedEntries, Set<String> existingDestinations, List<DirectorySearchParams> paramsList) { this.entries = entries; this.entryMap = entryMap; this.nonAggregatedEntries = nonAggregatedEntries; this.existingDestinations = existingDestinations; this.paramsList = paramsList; } } /** * An asynchronous filter used for loading two data sets: email rows from the local * contact provider and the list of {@link Directory}'s. */ private final class DefaultFilter extends Filter { @Override protected FilterResults performFiltering(CharSequence constraint) { if (DEBUG) { Log.d(TAG, "start filtering. constraint: " + constraint + ", thread:" + Thread.currentThread()); } final FilterResults results = new FilterResults(); Cursor defaultDirectoryCursor = null; Cursor directoryCursor = null; if (TextUtils.isEmpty(constraint)) { clearTempEntries(); // Return empty results. return results; } try { defaultDirectoryCursor = doQuery(constraint, mPreferredMaxResultCount, null); if (defaultDirectoryCursor == null) { if (DEBUG) { Log.w(TAG, "null cursor returned for default Email filter query."); } } else { // These variables will become mEntries, mEntryMap, mNonAggregatedEntries, and // mExistingDestinations. Here we shouldn't use those member variables directly // since this method is run outside the UI thread. final LinkedHashMap<Long, List<RecipientEntry>> entryMap = new LinkedHashMap<Long, List<RecipientEntry>>(); final List<RecipientEntry> nonAggregatedEntries = new ArrayList<RecipientEntry>(); final Set<String> existingDestinations = new HashSet<String>(); while (defaultDirectoryCursor.moveToNext()) { // Note: At this point each entry doesn't contain any photo // (thus getPhotoBytes() returns null). putOneEntry(new TemporaryEntry(defaultDirectoryCursor), true, entryMap, nonAggregatedEntries, existingDestinations); } // We'll copy this result to mEntry in publicResults() (run in the UX thread). final List<RecipientEntry> entries = constructEntryList(entryMap, nonAggregatedEntries); // After having local results, check the size of results. If the results are // not enough, we search remote directories, which will take longer time. final int limit = mPreferredMaxResultCount - existingDestinations.size(); final List<DirectorySearchParams> paramsList; if (limit > 0) { if (DEBUG) { Log.d(TAG, "More entries should be needed (current: " + existingDestinations.size() + ", remaining limit: " + limit + ") "); } directoryCursor = mContentResolver.query(DirectoryListQuery.URI, DirectoryListQuery.PROJECTION, null, null, null); paramsList = setupOtherDirectories(mContext, directoryCursor, mAccount); } else { // We don't need to search other directories. paramsList = null; } results.values = new DefaultFilterResult(entries, entryMap, nonAggregatedEntries, existingDestinations, paramsList); results.count = 1; } } finally { if (defaultDirectoryCursor != null) { defaultDirectoryCursor.close(); } if (directoryCursor != null) { directoryCursor.close(); } } return results; } @Override protected void publishResults(final CharSequence constraint, FilterResults results) { // If a user types a string very quickly and database is slow, "constraint" refers to // an older text which shows inconsistent results for users obsolete (b/4998713). // TODO: Fix it. mCurrentConstraint = constraint; clearTempEntries(); if (results.values != null) { DefaultFilterResult defaultFilterResult = (DefaultFilterResult) results.values; mEntryMap = defaultFilterResult.entryMap; mNonAggregatedEntries = defaultFilterResult.nonAggregatedEntries; mExistingDestinations = defaultFilterResult.existingDestinations; // If there are no local results, in the new result set, cache off what had been // shown to the user for use until the first directory result is returned if (defaultFilterResult.entries.size() == 0 && defaultFilterResult.paramsList != null) { cacheCurrentEntries(); } updateEntries(defaultFilterResult.entries); // We need to search other remote directories, doing other Filter requests. if (defaultFilterResult.paramsList != null) { final int limit = mPreferredMaxResultCount - defaultFilterResult.existingDestinations.size(); startSearchOtherDirectories(constraint, defaultFilterResult.paramsList, limit); } } } @Override public CharSequence convertResultToString(Object resultValue) { final RecipientEntry entry = (RecipientEntry) resultValue; final String displayName = entry.getDisplayName(); final String emailAddress = entry.getDestination(); if (TextUtils.isEmpty(displayName) || TextUtils.equals(displayName, emailAddress)) { return emailAddress; } else { return new Rfc822Token(displayName, emailAddress, null).toString(); } } } /** * An asynchronous filter that performs search in a particular directory. */ protected class DirectoryFilter extends Filter { private final DirectorySearchParams mParams; private int mLimit; public DirectoryFilter(DirectorySearchParams params) { mParams = params; } public synchronized void setLimit(int limit) { this.mLimit = limit; } public synchronized int getLimit() { return this.mLimit; } @Override protected FilterResults performFiltering(CharSequence constraint) { if (DEBUG) { Log.d(TAG, "DirectoryFilter#performFiltering. directoryId: " + mParams.directoryId + ", constraint: " + constraint + ", thread: " + Thread.currentThread()); } final FilterResults results = new FilterResults(); results.values = null; results.count = 0; if (!TextUtils.isEmpty(constraint)) { final ArrayList<TemporaryEntry> tempEntries = new ArrayList<TemporaryEntry>(); Cursor cursor = null; try { // We don't want to pass this Cursor object to UI thread (b/5017608). // Assuming the result should contain fairly small results (at most ~10), // We just copy everything to local structure. cursor = doQuery(constraint, getLimit(), mParams.directoryId); if (cursor != null) { while (cursor.moveToNext()) { tempEntries.add(new TemporaryEntry(cursor)); } } } finally { if (cursor != null) { cursor.close(); } } if (!tempEntries.isEmpty()) { results.values = tempEntries; results.count = 1; } } if (DEBUG) { Log.v(TAG, "finished loading directory \"" + mParams.displayName + "\"" + " with query " + constraint); } return results; } @Override protected void publishResults(final CharSequence constraint, FilterResults results) { if (DEBUG) { Log.d(TAG, "DirectoryFilter#publishResult. constraint: " + constraint + ", mCurrentConstraint: " + mCurrentConstraint); } mDelayedMessageHandler.removeDelayedLoadMessage(); // Check if the received result matches the current constraint // If not - the user must have continued typing after the request was issued, which // means several member variables (like mRemainingDirectoryLoad) are already // overwritten so shouldn't be touched here anymore. if (TextUtils.equals(constraint, mCurrentConstraint)) { if (results.count > 0) { @SuppressWarnings("unchecked") final ArrayList<TemporaryEntry> tempEntries = (ArrayList<TemporaryEntry>) results.values; for (TemporaryEntry tempEntry : tempEntries) { putOneEntry(tempEntry, mParams.directoryId == Directory.DEFAULT, mEntryMap, mNonAggregatedEntries, mExistingDestinations); } } // If there are remaining directories, set up delayed message again. mRemainingDirectoryCount--; if (mRemainingDirectoryCount > 0) { if (DEBUG) { Log.d(TAG, "Resend delayed load message. Current mRemainingDirectoryLoad: " + mRemainingDirectoryCount); } mDelayedMessageHandler.sendDelayedLoadMessage(); } // If this directory result has some items, or there are no more directories that // we are waiting for, clear the temp results if (results.count > 0 || mRemainingDirectoryCount == 0) { // Clear the temp entries clearTempEntries(); } } // Show the list again without "waiting" message. updateEntries(constructEntryList(mEntryMap, mNonAggregatedEntries)); } } private final Context mContext; private final ContentResolver mContentResolver; private final LayoutInflater mInflater; private Account mAccount; private final int mPreferredMaxResultCount; private final Handler mHandler = new Handler(); /** * {@link #mEntries} is responsible for showing every result for this Adapter. To * construct it, we use {@link #mEntryMap}, {@link #mNonAggregatedEntries}, and * {@link #mExistingDestinations}. * * First, each destination (an email address or a phone number) with a valid contactId is * inserted into {@link #mEntryMap} and grouped by the contactId. Destinations without valid * contactId (possible if they aren't in local storage) are stored in * {@link #mNonAggregatedEntries}. * Duplicates are removed using {@link #mExistingDestinations}. * * After having all results from Cursor objects, all destinations in mEntryMap are copied to * {@link #mEntries}. If the number of destinations is not enough (i.e. less than * {@link #mPreferredMaxResultCount}), destinations in mNonAggregatedEntries are also used. * * These variables are only used in UI thread, thus should not be touched in * performFiltering() methods. */ private LinkedHashMap<Long, List<RecipientEntry>> mEntryMap; private List<RecipientEntry> mNonAggregatedEntries; private Set<String> mExistingDestinations; /** Note: use {@link #updateEntries(List)} to update this variable. */ private List<RecipientEntry> mEntries; private List<RecipientEntry> mTempEntries; /** The number of directories this adapter is waiting for results. */ private int mRemainingDirectoryCount; /** * Used to ignore asynchronous queries with a different constraint, which may happen when * users type characters quickly. */ private CharSequence mCurrentConstraint; private final LruCache<Uri, byte[]> mPhotoCacheMap; /** * Handler specific for maintaining "Waiting for more contacts" message, which will be shown * when: * - there are directories to be searched * - results from directories are slow to come */ private final class DelayedMessageHandler extends Handler { @Override public void handleMessage(Message msg) { if (mRemainingDirectoryCount > 0) { updateEntries(constructEntryList(mEntryMap, mNonAggregatedEntries)); } } public void sendDelayedLoadMessage() { sendMessageDelayed(obtainMessage(MESSAGE_SEARCH_PENDING, 0, 0, null), MESSAGE_SEARCH_PENDING_DELAY); } public void removeDelayedLoadMessage() { removeMessages(MESSAGE_SEARCH_PENDING); } } private final DelayedMessageHandler mDelayedMessageHandler = new DelayedMessageHandler(); private EntriesUpdatedObserver mEntriesUpdatedObserver; /** * Constructor for email queries. */ public BaseRecipientAdapter(Context context) { this(context, DEFAULT_PREFERRED_MAX_RESULT_COUNT, QUERY_TYPE_EMAIL); } public BaseRecipientAdapter(Context context, int preferredMaxResultCount) { this(context, preferredMaxResultCount, QUERY_TYPE_EMAIL); } public BaseRecipientAdapter(int queryMode, Context context) { this(context, DEFAULT_PREFERRED_MAX_RESULT_COUNT, queryMode); } public BaseRecipientAdapter(int queryMode, Context context, int preferredMaxResultCount) { this(context, preferredMaxResultCount, queryMode); } public BaseRecipientAdapter(Context context, int preferredMaxResultCount, int queryMode) { mContext = context; mContentResolver = context.getContentResolver(); mInflater = LayoutInflater.from(context); mPreferredMaxResultCount = preferredMaxResultCount; mPhotoCacheMap = new LruCache<Uri, byte[]>(PHOTO_CACHE_SIZE); mQueryType = queryMode; if (queryMode == QUERY_TYPE_EMAIL) { mQuery = Queries.EMAIL; } else if (queryMode == QUERY_TYPE_PHONE) { mQuery = Queries.PHONE; } else { mQuery = Queries.EMAIL; Log.e(TAG, "Unsupported query type: " + queryMode); } } public Context getContext() { return mContext; } public int getQueryType() { return mQueryType; } /** * Set the account when known. Causes the search to prioritize contacts from that account. */ @Override public void setAccount(Account account) { mAccount = account; } /** Will be called from {@link AutoCompleteTextView} to prepare auto-complete list. */ @Override public Filter getFilter() { return new DefaultFilter(); } /** * An extesion to {@link RecipientAlternatesAdapter#getMatchingRecipients} that allows * additional sources of contacts to be considered as matching recipients. * @param addresses A set of addresses to be matched * @return A list of matches or null if none found */ public Map<String, RecipientEntry> getMatchingRecipients(Set<String> addresses) { return null; } public static List<DirectorySearchParams> setupOtherDirectories(Context context, Cursor directoryCursor, Account account) { final PackageManager packageManager = context.getPackageManager(); final List<DirectorySearchParams> paramsList = new ArrayList<DirectorySearchParams>(); DirectorySearchParams preferredDirectory = null; while (directoryCursor.moveToNext()) { final long id = directoryCursor.getLong(DirectoryListQuery.ID); // Skip the local invisible directory, because the default directory already includes // all local results. if (id == Directory.LOCAL_INVISIBLE) { continue; } final DirectorySearchParams params = new DirectorySearchParams(); final String packageName = directoryCursor.getString(DirectoryListQuery.PACKAGE_NAME); final int resourceId = directoryCursor.getInt(DirectoryListQuery.TYPE_RESOURCE_ID); params.directoryId = id; params.displayName = directoryCursor.getString(DirectoryListQuery.DISPLAY_NAME); params.accountName = directoryCursor.getString(DirectoryListQuery.ACCOUNT_NAME); params.accountType = directoryCursor.getString(DirectoryListQuery.ACCOUNT_TYPE); if (packageName != null && resourceId != 0) { try { final Resources resources = packageManager.getResourcesForApplication(packageName); params.directoryType = resources.getString(resourceId); if (params.directoryType == null) { Log.e(TAG, "Cannot resolve directory name: " + resourceId + "@" + packageName); } } catch (NameNotFoundException e) { Log.e(TAG, "Cannot resolve directory name: " + resourceId + "@" + packageName, e); } } // If an account has been provided and we found a directory that // corresponds to that account, place that directory second, directly // underneath the local contacts. if (account != null && account.name.equals(params.accountName) && account.type.equals(params.accountType)) { preferredDirectory = params; } else { paramsList.add(params); } } if (preferredDirectory != null) { paramsList.add(1, preferredDirectory); } return paramsList; } /** * Starts search in other directories using {@link Filter}. Results will be handled in * {@link DirectoryFilter}. */ protected void startSearchOtherDirectories(CharSequence constraint, List<DirectorySearchParams> paramsList, int limit) { final int count = paramsList.size(); // Note: skipping the default partition (index 0), which has already been loaded for (int i = 1; i < count; i++) { final DirectorySearchParams params = paramsList.get(i); params.constraint = constraint; if (params.filter == null) { params.filter = new DirectoryFilter(params); } params.filter.setLimit(limit); params.filter.filter(constraint); } // Directory search started. We may show "waiting" message if directory results are slow // enough. mRemainingDirectoryCount = count - 1; mDelayedMessageHandler.sendDelayedLoadMessage(); } private static void putOneEntry(TemporaryEntry entry, boolean isAggregatedEntry, LinkedHashMap<Long, List<RecipientEntry>> entryMap, List<RecipientEntry> nonAggregatedEntries, Set<String> existingDestinations) { if (existingDestinations.contains(entry.destination)) { return; } existingDestinations.add(entry.destination); if (!isAggregatedEntry) { nonAggregatedEntries.add(RecipientEntry.constructTopLevelEntry(entry.displayName, entry.displayNameSource, entry.destination, entry.destinationType, entry.destinationLabel, entry.contactId, entry.dataId, entry.thumbnailUriString, true)); } else if (entryMap.containsKey(entry.contactId)) { // We already have a section for the person. final List<RecipientEntry> entryList = entryMap.get(entry.contactId); entryList.add(RecipientEntry.constructSecondLevelEntry(entry.displayName, entry.displayNameSource, entry.destination, entry.destinationType, entry.destinationLabel, entry.contactId, entry.dataId, entry.thumbnailUriString, true)); } else { final List<RecipientEntry> entryList = new ArrayList<RecipientEntry>(); entryList.add(RecipientEntry.constructTopLevelEntry(entry.displayName, entry.displayNameSource, entry.destination, entry.destinationType, entry.destinationLabel, entry.contactId, entry.dataId, entry.thumbnailUriString, true)); entryMap.put(entry.contactId, entryList); } } /** * Constructs an actual list for this Adapter using {@link #mEntryMap}. Also tries to * fetch a cached photo for each contact entry (other than separators), or request another * thread to get one from directories. */ private List<RecipientEntry> constructEntryList(LinkedHashMap<Long, List<RecipientEntry>> entryMap, List<RecipientEntry> nonAggregatedEntries) { final List<RecipientEntry> entries = new ArrayList<RecipientEntry>(); int validEntryCount = 0; for (Map.Entry<Long, List<RecipientEntry>> mapEntry : entryMap.entrySet()) { final List<RecipientEntry> entryList = mapEntry.getValue(); final int size = entryList.size(); for (int i = 0; i < size; i++) { RecipientEntry entry = entryList.get(i); entries.add(entry); tryFetchPhoto(entry); validEntryCount++; } if (validEntryCount > mPreferredMaxResultCount) { break; } } if (validEntryCount <= mPreferredMaxResultCount) { for (RecipientEntry entry : nonAggregatedEntries) { if (validEntryCount > mPreferredMaxResultCount) { break; } entries.add(entry); tryFetchPhoto(entry); validEntryCount++; } } return entries; } protected interface EntriesUpdatedObserver { public void onChanged(List<RecipientEntry> entries); } public void registerUpdateObserver(EntriesUpdatedObserver observer) { mEntriesUpdatedObserver = observer; } /** Resets {@link #mEntries} and notify the event to its parent ListView. */ private void updateEntries(List<RecipientEntry> newEntries) { mEntries = newEntries; mEntriesUpdatedObserver.onChanged(newEntries); notifyDataSetChanged(); } private void cacheCurrentEntries() { mTempEntries = mEntries; } private void clearTempEntries() { mTempEntries = null; } protected List<RecipientEntry> getEntries() { return mTempEntries != null ? mTempEntries : mEntries; } private void tryFetchPhoto(final RecipientEntry entry) { final Uri photoThumbnailUri = entry.getPhotoThumbnailUri(); if (photoThumbnailUri != null) { final byte[] photoBytes = mPhotoCacheMap.get(photoThumbnailUri); if (photoBytes != null) { entry.setPhotoBytes(photoBytes); // notifyDataSetChanged() should be called by a caller. } else { if (DEBUG) { Log.d(TAG, "No photo cache for " + entry.getDisplayName() + ". Fetch one asynchronously"); } fetchPhotoAsync(entry, photoThumbnailUri); } } } // For reading photos for directory contacts, this is the chunksize for // copying from the inputstream to the output stream. private static final int BUFFER_SIZE = 1024 * 16; private void fetchPhotoAsync(final RecipientEntry entry, final Uri photoThumbnailUri) { final AsyncTask<Void, Void, byte[]> photoLoadTask = new AsyncTask<Void, Void, byte[]>() { @Override protected byte[] doInBackground(Void... params) { // First try running a query. Images for local contacts are // loaded by sending a query to the ContactsProvider. final Cursor photoCursor = mContentResolver.query(photoThumbnailUri, PhotoQuery.PROJECTION, null, null, null); if (photoCursor != null) { try { if (photoCursor.moveToFirst()) { return photoCursor.getBlob(PhotoQuery.PHOTO); } } finally { photoCursor.close(); } } else { // If the query fails, try streaming the URI directly. // For remote directory images, this URI resolves to the // directory provider and the images are loaded by sending // an openFile call to the provider. try { InputStream is = mContentResolver.openInputStream(photoThumbnailUri); if (is != null) { byte[] buffer = new byte[BUFFER_SIZE]; ByteArrayOutputStream baos = new ByteArrayOutputStream(); try { int size; while ((size = is.read(buffer)) != -1) { baos.write(buffer, 0, size); } } finally { is.close(); } return baos.toByteArray(); } } catch (IOException ex) { // ignore } } return null; } @Override protected void onPostExecute(final byte[] photoBytes) { entry.setPhotoBytes(photoBytes); if (photoBytes != null) { mPhotoCacheMap.put(photoThumbnailUri, photoBytes); notifyDataSetChanged(); } } }; photoLoadTask.executeOnExecutor(AsyncTask.SERIAL_EXECUTOR); } protected void fetchPhoto(final RecipientEntry entry, final Uri photoThumbnailUri) { byte[] photoBytes = mPhotoCacheMap.get(photoThumbnailUri); if (photoBytes != null) { entry.setPhotoBytes(photoBytes); return; } final Cursor photoCursor = mContentResolver.query(photoThumbnailUri, PhotoQuery.PROJECTION, null, null, null); if (photoCursor != null) { try { if (photoCursor.moveToFirst()) { photoBytes = photoCursor.getBlob(PhotoQuery.PHOTO); entry.setPhotoBytes(photoBytes); mPhotoCacheMap.put(photoThumbnailUri, photoBytes); } } finally { photoCursor.close(); } } } private Cursor doQuery(CharSequence constraint, int limit, Long directoryId) { final Uri.Builder builder = mQuery.getContentFilterUri().buildUpon().appendPath(constraint.toString()) .appendQueryParameter(ContactsContract.LIMIT_PARAM_KEY, String.valueOf(limit + ALLOWANCE_FOR_DUPLICATES)); if (directoryId != null) { builder.appendQueryParameter(ContactsContract.DIRECTORY_PARAM_KEY, String.valueOf(directoryId)); } if (mAccount != null) { builder.appendQueryParameter(PRIMARY_ACCOUNT_NAME, mAccount.name); builder.appendQueryParameter(PRIMARY_ACCOUNT_TYPE, mAccount.type); } final long start = System.currentTimeMillis(); final Cursor cursor = mContentResolver.query(builder.build(), mQuery.getProjection(), null, null, null); final long end = System.currentTimeMillis(); if (DEBUG) { Log.d(TAG, "Time for autocomplete (query: " + constraint + ", directoryId: " + directoryId + ", num_of_results: " + (cursor != null ? cursor.getCount() : "null") + "): " + (end - start) + " ms"); } return cursor; } // TODO: This won't be used at all. We should find better way to quit the thread.. /*public void close() { mEntries = null; mPhotoCacheMap.evictAll(); if (!sPhotoHandlerThread.quit()) { Log.w(TAG, "Failed to quit photo handler thread, ignoring it."); } }*/ @Override public int getCount() { final List<RecipientEntry> entries = getEntries(); return entries != null ? entries.size() : 0; } @Override public Object getItem(int position) { return getEntries().get(position); } @Override public long getItemId(int position) { return position; } @Override public int getViewTypeCount() { return RecipientEntry.ENTRY_TYPE_SIZE; } @Override public int getItemViewType(int position) { return getEntries().get(position).getEntryType(); } @Override public boolean isEnabled(int position) { return getEntries().get(position).isSelectable(); } @Override public View getView(int position, View convertView, ViewGroup parent) { final RecipientEntry entry = getEntries().get(position); String displayName = entry.getDisplayName(); String destination = entry.getDestination(); if (TextUtils.isEmpty(displayName) || TextUtils.equals(displayName, destination)) { displayName = destination; // We only show the destination for secondary entries, so clear it // only for the first level. if (entry.isFirstLevel()) { destination = null; } } final View itemView = convertView != null ? convertView : mInflater.inflate(getItemLayout(), parent, false); final TextView displayNameView = (TextView) itemView.findViewById(getDisplayNameId()); final TextView destinationView = (TextView) itemView.findViewById(getDestinationId()); final TextView destinationTypeView = (TextView) itemView.findViewById(getDestinationTypeId()); final ImageView imageView = (ImageView) itemView.findViewById(getPhotoId()); displayNameView.setText(displayName); if (!TextUtils.isEmpty(destination)) { destinationView.setText(destination); } else { destinationView.setText(null); } if (destinationTypeView != null) { final CharSequence destinationType = mQuery .getTypeLabel(mContext.getResources(), entry.getDestinationType(), entry.getDestinationLabel()) .toString().toUpperCase(); destinationTypeView.setText(destinationType); } if (entry.isFirstLevel()) { displayNameView.setVisibility(View.VISIBLE); if (imageView != null) { imageView.setVisibility(View.VISIBLE); final byte[] photoBytes = entry.getPhotoBytes(); if (photoBytes != null) { final Bitmap photo = BitmapFactory.decodeByteArray(photoBytes, 0, photoBytes.length); imageView.setImageBitmap(photo); } else { imageView.setImageResource(getDefaultPhotoResource()); } } } else { displayNameView.setVisibility(View.GONE); if (imageView != null) { imageView.setVisibility(View.INVISIBLE); } } return itemView; } /** * Returns a layout id for each item inside auto-complete list. * * Each View must contain two TextViews (for display name and destination) and one ImageView * (for photo). Ids for those should be available via {@link #getDisplayNameId()}, * {@link #getDestinationId()}, and {@link #getPhotoId()}. */ protected int getItemLayout() { return R.layout.chips_recipient_dropdown_item; } /** * Returns a resource ID representing an image which should be shown when ther's no relevant * photo is available. */ protected int getDefaultPhotoResource() { return R.drawable.ic_contact_picture; } /** * Returns an id for TextView in an item View for showing a display name. By default * {@link android.R.id#title} is returned. */ protected int getDisplayNameId() { return android.R.id.title; } /** * Returns an id for TextView in an item View for showing a destination * (an email address or a phone number). * By default {@link android.R.id#text1} is returned. */ protected int getDestinationId() { return android.R.id.text1; } /** * Returns an id for TextView in an item View for showing the type of the destination. * By default {@link android.R.id#text2} is returned. */ protected int getDestinationTypeId() { return android.R.id.text2; } /** * Returns an id for ImageView in an item View for showing photo image for a person. In default * {@link android.R.id#icon} is returned. */ protected int getPhotoId() { return android.R.id.icon; } public Account getAccount() { return mAccount; } }