| /* |
| * 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 com.android.contacts.list; |
| |
| import com.android.common.widget.CompositeCursorAdapter.Partition; |
| import com.android.contacts.ContactListEmptyView; |
| import com.android.contacts.ContactPhotoManager; |
| import com.android.contacts.R; |
| import com.android.contacts.preference.ContactsPreferences; |
| import com.android.contacts.widget.ContextMenuAdapter; |
| |
| import android.accounts.Account; |
| import android.accounts.AccountManager; |
| import android.app.Activity; |
| import android.app.Fragment; |
| import android.app.LoaderManager; |
| import android.app.LoaderManager.LoaderCallbacks; |
| import android.content.ContentResolver; |
| import android.content.Context; |
| import android.content.CursorLoader; |
| import android.content.IContentService; |
| import android.content.Intent; |
| import android.content.Loader; |
| import android.database.Cursor; |
| import android.os.Bundle; |
| import android.os.Handler; |
| import android.os.Message; |
| import android.os.Parcelable; |
| import android.os.RemoteException; |
| import android.provider.ContactsContract; |
| import android.provider.ContactsContract.Directory; |
| import android.telephony.TelephonyManager; |
| import android.text.TextUtils; |
| import android.util.Log; |
| import android.view.LayoutInflater; |
| import android.view.MotionEvent; |
| import android.view.View; |
| import android.view.View.OnFocusChangeListener; |
| import android.view.View.OnTouchListener; |
| import android.view.ViewGroup; |
| 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.ListView; |
| import android.widget.TextView; |
| |
| /** |
| * Common base class for various contact-related list fragments. |
| */ |
| public abstract class ContactEntryListFragment<T extends ContactEntryListAdapter> |
| extends Fragment |
| implements OnItemClickListener, OnScrollListener, OnFocusChangeListener, OnTouchListener, |
| LoaderCallbacks<Cursor> { |
| private static final String TAG = "ContactEntryListFragment"; |
| |
| // TODO: Make this protected. This should not be used from the PeopleActivity but |
| // instead use the new startActivityWithResultFromFragment API |
| public static final int ACTIVITY_REQUEST_CODE_PICKER = 1; |
| |
| private static final String KEY_LIST_STATE = "liststate"; |
| private static final String KEY_SECTION_HEADER_DISPLAY_ENABLED = "sectionHeaderDisplayEnabled"; |
| private static final String KEY_PHOTO_LOADER_ENABLED = "photoLoaderEnabled"; |
| private static final String KEY_QUICK_CONTACT_ENABLED = "quickContactEnabled"; |
| private static final String KEY_INCLUDE_PROFILE = "includeProfile"; |
| private static final String KEY_SEARCH_MODE = "searchMode"; |
| private static final String KEY_VISIBLE_SCROLLBAR_ENABLED = "visibleScrollbarEnabled"; |
| private static final String KEY_SCROLLBAR_POSITION = "scrollbarPosition"; |
| private static final String KEY_QUERY_STRING = "queryString"; |
| private static final String KEY_DIRECTORY_SEARCH_MODE = "directorySearchMode"; |
| private static final String KEY_SELECTION_VISIBLE = "selectionVisible"; |
| private static final String KEY_REQUEST = "request"; |
| private static final String KEY_DARK_THEME = "darkTheme"; |
| private static final String KEY_LEGACY_COMPATIBILITY = "legacyCompatibility"; |
| private static final String KEY_DIRECTORY_RESULT_LIMIT = "directoryResultLimit"; |
| |
| private static final String DIRECTORY_ID_ARG_KEY = "directoryId"; |
| |
| private static final int DIRECTORY_LOADER_ID = -1; |
| |
| private static final int DIRECTORY_SEARCH_DELAY_MILLIS = 300; |
| private static final int DIRECTORY_SEARCH_MESSAGE = 1; |
| |
| private static final int DEFAULT_DIRECTORY_RESULT_LIMIT = 20; |
| |
| private boolean mSectionHeaderDisplayEnabled; |
| private boolean mPhotoLoaderEnabled; |
| private boolean mQuickContactEnabled = true; |
| private boolean mIncludeProfile; |
| private boolean mSearchMode; |
| private boolean mVisibleScrollbarEnabled; |
| private int mVerticalScrollbarPosition = View.SCROLLBAR_POSITION_RIGHT; |
| private String mQueryString; |
| private int mDirectorySearchMode = DirectoryListLoader.SEARCH_MODE_NONE; |
| private boolean mSelectionVisible; |
| private boolean mLegacyCompatibility; |
| |
| private boolean mEnabled = true; |
| |
| private T mAdapter; |
| private View mView; |
| private ListView mListView; |
| |
| /** |
| * Used for keeping track of the scroll state of the list. |
| */ |
| private Parcelable mListState; |
| |
| private int mDisplayOrder; |
| private int mSortOrder; |
| private int mDirectoryResultLimit = DEFAULT_DIRECTORY_RESULT_LIMIT; |
| |
| private ContextMenuAdapter mContextMenuAdapter; |
| private ContactPhotoManager mPhotoManager; |
| private ContactListEmptyView mEmptyView; |
| private ProviderStatusLoader mProviderStatusLoader; |
| private ContactsPreferences mContactsPrefs; |
| |
| private boolean mForceLoad; |
| |
| private boolean mDarkTheme; |
| |
| protected boolean mUserProfileExists; |
| |
| private static final int STATUS_NOT_LOADED = 0; |
| private static final int STATUS_LOADING = 1; |
| private static final int STATUS_LOADED = 2; |
| |
| private int mDirectoryListStatus = STATUS_NOT_LOADED; |
| |
| /** |
| * Indicates whether we are doing the initial complete load of data (false) or |
| * a refresh caused by a change notification (true) |
| */ |
| private boolean mLoadPriorityDirectoriesOnly; |
| |
| private Context mContext; |
| |
| private LoaderManager mLoaderManager; |
| |
| private Handler mDelayedDirectorySearchHandler = new Handler() { |
| @Override |
| public void handleMessage(Message msg) { |
| if (msg.what == DIRECTORY_SEARCH_MESSAGE) { |
| loadDirectoryPartition(msg.arg1, (DirectoryPartition) msg.obj); |
| } |
| } |
| }; |
| |
| protected abstract View inflateView(LayoutInflater inflater, ViewGroup container); |
| protected abstract T createListAdapter(); |
| |
| /** |
| * @param position Please note that the position is already adjusted for |
| * header views, so "0" means the first list item below header |
| * views. |
| */ |
| protected abstract void onItemClick(int position, long id); |
| |
| @Override |
| public void onAttach(Activity activity) { |
| super.onAttach(activity); |
| setContext(activity); |
| setLoaderManager(super.getLoaderManager()); |
| } |
| |
| /** |
| * Sets a context for the fragment in the unit test environment. |
| */ |
| public void setContext(Context context) { |
| mContext = context; |
| configurePhotoLoader(); |
| } |
| |
| public Context getContext() { |
| return mContext; |
| } |
| |
| public void setEnabled(boolean enabled) { |
| if (mEnabled != enabled) { |
| mEnabled = enabled; |
| if (mAdapter != null) { |
| if (mEnabled) { |
| reloadData(); |
| } else { |
| mAdapter.clearPartitions(); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Overrides a loader manager for use in unit tests. |
| */ |
| public void setLoaderManager(LoaderManager loaderManager) { |
| mLoaderManager = loaderManager; |
| } |
| |
| @Override |
| public LoaderManager getLoaderManager() { |
| return mLoaderManager; |
| } |
| |
| public T getAdapter() { |
| return mAdapter; |
| } |
| |
| @Override |
| public View getView() { |
| return mView; |
| } |
| |
| public ListView getListView() { |
| return mListView; |
| } |
| |
| public ContactListEmptyView getEmptyView() { |
| return mEmptyView; |
| } |
| |
| @Override |
| public void onSaveInstanceState(Bundle outState) { |
| super.onSaveInstanceState(outState); |
| outState.putBoolean(KEY_SECTION_HEADER_DISPLAY_ENABLED, mSectionHeaderDisplayEnabled); |
| outState.putBoolean(KEY_PHOTO_LOADER_ENABLED, mPhotoLoaderEnabled); |
| outState.putBoolean(KEY_QUICK_CONTACT_ENABLED, mQuickContactEnabled); |
| outState.putBoolean(KEY_INCLUDE_PROFILE, mIncludeProfile); |
| outState.putBoolean(KEY_SEARCH_MODE, mSearchMode); |
| outState.putBoolean(KEY_VISIBLE_SCROLLBAR_ENABLED, mVisibleScrollbarEnabled); |
| outState.putInt(KEY_SCROLLBAR_POSITION, mVerticalScrollbarPosition); |
| outState.putInt(KEY_DIRECTORY_SEARCH_MODE, mDirectorySearchMode); |
| outState.putBoolean(KEY_SELECTION_VISIBLE, mSelectionVisible); |
| outState.putBoolean(KEY_LEGACY_COMPATIBILITY, mLegacyCompatibility); |
| outState.putString(KEY_QUERY_STRING, mQueryString); |
| outState.putInt(KEY_DIRECTORY_RESULT_LIMIT, mDirectoryResultLimit); |
| outState.putBoolean(KEY_DARK_THEME, mDarkTheme); |
| |
| if (mListView != null) { |
| outState.putParcelable(KEY_LIST_STATE, mListView.onSaveInstanceState()); |
| } |
| } |
| |
| @Override |
| public void onCreate(Bundle savedState) { |
| super.onCreate(savedState); |
| mContactsPrefs = new ContactsPreferences(mContext); |
| restoreSavedState(savedState); |
| } |
| |
| public void restoreSavedState(Bundle savedState) { |
| if (savedState == null) { |
| return; |
| } |
| |
| mSectionHeaderDisplayEnabled = savedState.getBoolean(KEY_SECTION_HEADER_DISPLAY_ENABLED); |
| mPhotoLoaderEnabled = savedState.getBoolean(KEY_PHOTO_LOADER_ENABLED); |
| mQuickContactEnabled = savedState.getBoolean(KEY_QUICK_CONTACT_ENABLED); |
| mIncludeProfile = savedState.getBoolean(KEY_INCLUDE_PROFILE); |
| mSearchMode = savedState.getBoolean(KEY_SEARCH_MODE); |
| mVisibleScrollbarEnabled = savedState.getBoolean(KEY_VISIBLE_SCROLLBAR_ENABLED); |
| mVerticalScrollbarPosition = savedState.getInt(KEY_SCROLLBAR_POSITION); |
| mDirectorySearchMode = savedState.getInt(KEY_DIRECTORY_SEARCH_MODE); |
| mSelectionVisible = savedState.getBoolean(KEY_SELECTION_VISIBLE); |
| mLegacyCompatibility = savedState.getBoolean(KEY_LEGACY_COMPATIBILITY); |
| mQueryString = savedState.getString(KEY_QUERY_STRING); |
| mDirectoryResultLimit = savedState.getInt(KEY_DIRECTORY_RESULT_LIMIT); |
| mDarkTheme = savedState.getBoolean(KEY_DARK_THEME); |
| |
| // Retrieve list state. This will be applied in onLoadFinished |
| mListState = savedState.getParcelable(KEY_LIST_STATE); |
| } |
| |
| @Override |
| public void onStart() { |
| super.onStart(); |
| |
| mContactsPrefs.registerChangeListener(mPreferencesChangeListener); |
| |
| if (mProviderStatusLoader == null) { |
| mProviderStatusLoader = new ProviderStatusLoader(mContext); |
| } |
| |
| mForceLoad = loadPreferences(); |
| |
| mDirectoryListStatus = STATUS_NOT_LOADED; |
| mLoadPriorityDirectoriesOnly = true; |
| |
| startLoading(); |
| } |
| |
| protected void startLoading() { |
| if (mAdapter == null) { |
| // The method was called before the fragment was started |
| return; |
| } |
| |
| configureAdapter(); |
| int partitionCount = mAdapter.getPartitionCount(); |
| for (int i = 0; i < partitionCount; i++) { |
| Partition partition = mAdapter.getPartition(i); |
| if (partition instanceof DirectoryPartition) { |
| DirectoryPartition directoryPartition = (DirectoryPartition)partition; |
| if (directoryPartition.getStatus() == DirectoryPartition.STATUS_NOT_LOADED) { |
| if (directoryPartition.isPriorityDirectory() || !mLoadPriorityDirectoriesOnly) { |
| startLoadingDirectoryPartition(i); |
| } |
| } |
| } else { |
| getLoaderManager().initLoader(i, null, this); |
| } |
| } |
| |
| // Next time this method is called, we should start loading non-priority directories |
| mLoadPriorityDirectoriesOnly = false; |
| } |
| |
| @Override |
| public Loader<Cursor> onCreateLoader(int id, Bundle args) { |
| if (id == DIRECTORY_LOADER_ID) { |
| DirectoryListLoader loader = new DirectoryListLoader(mContext); |
| mAdapter.configureDirectoryLoader(loader); |
| return loader; |
| } else { |
| CursorLoader loader = createCursorLoader(); |
| long directoryId = args != null && args.containsKey(DIRECTORY_ID_ARG_KEY) |
| ? args.getLong(DIRECTORY_ID_ARG_KEY) |
| : Directory.DEFAULT; |
| mAdapter.configureLoader(loader, directoryId); |
| return loader; |
| } |
| } |
| |
| public CursorLoader createCursorLoader() { |
| return new CursorLoader(mContext, null, null, null, null, null); |
| } |
| |
| private void startLoadingDirectoryPartition(int partitionIndex) { |
| DirectoryPartition partition = (DirectoryPartition)mAdapter.getPartition(partitionIndex); |
| partition.setStatus(DirectoryPartition.STATUS_LOADING); |
| long directoryId = partition.getDirectoryId(); |
| if (mForceLoad) { |
| if (directoryId == Directory.DEFAULT) { |
| loadDirectoryPartition(partitionIndex, partition); |
| } else { |
| loadDirectoryPartitionDelayed(partitionIndex, partition); |
| } |
| } else { |
| Bundle args = new Bundle(); |
| args.putLong(DIRECTORY_ID_ARG_KEY, directoryId); |
| getLoaderManager().initLoader(partitionIndex, args, this); |
| } |
| } |
| |
| /** |
| * Queues up a delayed request to search the specified directory. Since |
| * directory search will likely introduce a lot of network traffic, we want |
| * to wait for a pause in the user's typing before sending a directory request. |
| */ |
| private void loadDirectoryPartitionDelayed(int partitionIndex, DirectoryPartition partition) { |
| mDelayedDirectorySearchHandler.removeMessages(DIRECTORY_SEARCH_MESSAGE, partition); |
| Message msg = mDelayedDirectorySearchHandler.obtainMessage( |
| DIRECTORY_SEARCH_MESSAGE, partitionIndex, 0, partition); |
| mDelayedDirectorySearchHandler.sendMessageDelayed(msg, DIRECTORY_SEARCH_DELAY_MILLIS); |
| } |
| |
| /** |
| * Loads the directory partition. |
| */ |
| protected void loadDirectoryPartition(int partitionIndex, DirectoryPartition partition) { |
| Bundle args = new Bundle(); |
| args.putLong(DIRECTORY_ID_ARG_KEY, partition.getDirectoryId()); |
| getLoaderManager().restartLoader(partitionIndex, args, this); |
| } |
| |
| /** |
| * Cancels all queued directory loading requests. |
| */ |
| private void removePendingDirectorySearchRequests() { |
| mDelayedDirectorySearchHandler.removeMessages(DIRECTORY_SEARCH_MESSAGE); |
| } |
| |
| @Override |
| public void onLoadFinished(Loader<Cursor> loader, Cursor data) { |
| if (!mEnabled) { |
| return; |
| } |
| |
| int loaderId = loader.getId(); |
| if (loaderId == DIRECTORY_LOADER_ID) { |
| mDirectoryListStatus = STATUS_LOADED; |
| mAdapter.changeDirectories(data); |
| startLoading(); |
| } else { |
| onPartitionLoaded(loaderId, data); |
| if (isSearchMode()) { |
| int directorySearchMode = getDirectorySearchMode(); |
| if (directorySearchMode != DirectoryListLoader.SEARCH_MODE_NONE) { |
| if (mDirectoryListStatus == STATUS_NOT_LOADED) { |
| mDirectoryListStatus = STATUS_LOADING; |
| getLoaderManager().initLoader(DIRECTORY_LOADER_ID, null, this); |
| } else { |
| startLoading(); |
| } |
| } |
| } else { |
| mDirectoryListStatus = STATUS_NOT_LOADED; |
| getLoaderManager().destroyLoader(DIRECTORY_LOADER_ID); |
| } |
| } |
| } |
| |
| public void onLoaderReset(Loader<Cursor> loader) { |
| } |
| |
| protected void onPartitionLoaded(int partitionIndex, Cursor data) { |
| if (partitionIndex >= mAdapter.getPartitionCount()) { |
| // When we get unsolicited data, ignore it. This could happen |
| // when we are switching from search mode to the default mode. |
| return; |
| } |
| |
| mAdapter.changeCursor(partitionIndex, data); |
| setProfileHeader(); |
| showCount(partitionIndex, data); |
| |
| if (!isLoading()) { |
| completeRestoreInstanceState(); |
| } |
| } |
| |
| public boolean isLoading() { |
| if (mAdapter != null && mAdapter.isLoading()) { |
| return true; |
| } |
| |
| if (isLoadingDirectoryList()) { |
| return true; |
| } |
| |
| return false; |
| } |
| |
| public boolean isLoadingDirectoryList() { |
| return isSearchMode() && getDirectorySearchMode() != DirectoryListLoader.SEARCH_MODE_NONE |
| && (mDirectoryListStatus == STATUS_NOT_LOADED |
| || mDirectoryListStatus == STATUS_LOADING); |
| } |
| |
| @Override |
| public void onStop() { |
| super.onStop(); |
| mContactsPrefs.unregisterChangeListener(); |
| mAdapter.clearPartitions(); |
| } |
| |
| protected void reloadData() { |
| removePendingDirectorySearchRequests(); |
| mAdapter.onDataReload(); |
| mLoadPriorityDirectoriesOnly = true; |
| mForceLoad = true; |
| startLoading(); |
| } |
| |
| /** |
| * Configures the empty view. It is called when we are about to populate |
| * the list with an empty cursor. |
| */ |
| protected void prepareEmptyView() { |
| } |
| |
| /** |
| * Shows the count of entries included in the list. The default |
| * implementation does nothing. |
| */ |
| protected void showCount(int partitionIndex, Cursor data) { |
| } |
| |
| /** |
| * Shows a view at the top of the list with a pseudo local profile prompting the user to add |
| * a local profile. Default implementation does nothing. |
| */ |
| protected void setProfileHeader() { |
| mUserProfileExists = false; |
| } |
| |
| /** |
| * Provides logic that dismisses this fragment. The default implementation |
| * does nothing. |
| */ |
| protected void finish() { |
| } |
| |
| public void setSectionHeaderDisplayEnabled(boolean flag) { |
| if (mSectionHeaderDisplayEnabled != flag) { |
| mSectionHeaderDisplayEnabled = flag; |
| if (mAdapter != null) { |
| mAdapter.setSectionHeaderDisplayEnabled(flag); |
| } |
| configureVerticalScrollbar(); |
| } |
| } |
| |
| public boolean isSectionHeaderDisplayEnabled() { |
| return mSectionHeaderDisplayEnabled; |
| } |
| |
| public void setVisibleScrollbarEnabled(boolean flag) { |
| if (mVisibleScrollbarEnabled != flag) { |
| mVisibleScrollbarEnabled = flag; |
| configureVerticalScrollbar(); |
| } |
| } |
| |
| public boolean isVisibleScrollbarEnabled() { |
| return mVisibleScrollbarEnabled; |
| } |
| |
| public void setVerticalScrollbarPosition(int position) { |
| if (mVerticalScrollbarPosition != position) { |
| mVerticalScrollbarPosition = position; |
| configureVerticalScrollbar(); |
| } |
| } |
| |
| private void configureVerticalScrollbar() { |
| boolean hasScrollbar = isVisibleScrollbarEnabled() && isSectionHeaderDisplayEnabled(); |
| |
| if (mListView != null) { |
| mListView.setFastScrollEnabled(hasScrollbar); |
| mListView.setFastScrollAlwaysVisible(hasScrollbar); |
| mListView.setVerticalScrollbarPosition(mVerticalScrollbarPosition); |
| mListView.setScrollBarStyle(ListView.SCROLLBARS_OUTSIDE_OVERLAY); |
| int leftPadding = 0; |
| int rightPadding = 0; |
| if (mVerticalScrollbarPosition == View.SCROLLBAR_POSITION_LEFT) { |
| leftPadding = mContext.getResources().getDimensionPixelOffset( |
| R.dimen.list_visible_scrollbar_padding); |
| } else { |
| rightPadding = mContext.getResources().getDimensionPixelOffset( |
| R.dimen.list_visible_scrollbar_padding); |
| } |
| mListView.setPadding(leftPadding, mListView.getPaddingTop(), |
| rightPadding, mListView.getPaddingBottom()); |
| } |
| } |
| |
| public void setPhotoLoaderEnabled(boolean flag) { |
| mPhotoLoaderEnabled = flag; |
| configurePhotoLoader(); |
| } |
| |
| public boolean isPhotoLoaderEnabled() { |
| return mPhotoLoaderEnabled; |
| } |
| |
| /** |
| * Returns true if the list is supposed to visually highlight the selected item. |
| */ |
| public boolean isSelectionVisible() { |
| return mSelectionVisible; |
| } |
| |
| public void setSelectionVisible(boolean flag) { |
| this.mSelectionVisible = flag; |
| } |
| |
| public void setQuickContactEnabled(boolean flag) { |
| this.mQuickContactEnabled = flag; |
| } |
| |
| public void setIncludeProfile(boolean flag) { |
| mIncludeProfile = flag; |
| if(mAdapter != null) { |
| mAdapter.setIncludeProfile(flag); |
| } |
| } |
| |
| /** |
| * Enter/exit search mode. By design, a fragment enters search mode only when it has a |
| * non-empty query text, so the mode must be tightly related to the current query. |
| * For this reason this method must only be called by {@link #setQueryString}. |
| * |
| * Also note this method doesn't call {@link #reloadData()}; {@link #setQueryString} does it. |
| */ |
| protected void setSearchMode(boolean flag) { |
| if (mSearchMode != flag) { |
| mSearchMode = flag; |
| setSectionHeaderDisplayEnabled(!mSearchMode); |
| |
| if (!flag) { |
| mDirectoryListStatus = STATUS_NOT_LOADED; |
| getLoaderManager().destroyLoader(DIRECTORY_LOADER_ID); |
| } |
| |
| if (mAdapter != null) { |
| mAdapter.setPinnedPartitionHeadersEnabled(flag); |
| mAdapter.setSearchMode(flag); |
| |
| mAdapter.clearPartitions(); |
| if (!flag) { |
| // If we are switching from search to regular display, |
| // remove all directory partitions (except the default one). |
| int count = mAdapter.getPartitionCount(); |
| for (int i = count; --i >= 1;) { |
| mAdapter.removePartition(i); |
| } |
| } |
| mAdapter.configureDefaultPartition(false, flag); |
| } |
| |
| if (mListView != null) { |
| mListView.setFastScrollEnabled(!flag); |
| } |
| } |
| } |
| |
| public final boolean isSearchMode() { |
| return mSearchMode; |
| } |
| |
| public final String getQueryString() { |
| return mQueryString; |
| } |
| |
| public void setQueryString(String queryString, boolean delaySelection) { |
| // Normalize the empty query. |
| if (TextUtils.isEmpty(queryString)) queryString = null; |
| |
| if (!TextUtils.equals(mQueryString, queryString)) { |
| mQueryString = queryString; |
| setSearchMode(!TextUtils.isEmpty(mQueryString)); |
| |
| if (mAdapter != null) { |
| mAdapter.setQueryString(queryString); |
| reloadData(); |
| } |
| } |
| } |
| |
| public int getDirectorySearchMode() { |
| return mDirectorySearchMode; |
| } |
| |
| public void setDirectorySearchMode(int mode) { |
| mDirectorySearchMode = mode; |
| } |
| |
| public boolean isLegacyCompatibilityMode() { |
| return mLegacyCompatibility; |
| } |
| |
| public void setLegacyCompatibilityMode(boolean flag) { |
| mLegacyCompatibility = flag; |
| } |
| |
| protected int getContactNameDisplayOrder() { |
| return mDisplayOrder; |
| } |
| |
| protected void setContactNameDisplayOrder(int displayOrder) { |
| mDisplayOrder = displayOrder; |
| if (mAdapter != null) { |
| mAdapter.setContactNameDisplayOrder(displayOrder); |
| } |
| } |
| |
| public int getSortOrder() { |
| return mSortOrder; |
| } |
| |
| public void setSortOrder(int sortOrder) { |
| mSortOrder = sortOrder; |
| if (mAdapter != null) { |
| mAdapter.setSortOrder(sortOrder); |
| } |
| } |
| |
| public void setDirectoryResultLimit(int limit) { |
| mDirectoryResultLimit = limit; |
| } |
| |
| public void setContextMenuAdapter(ContextMenuAdapter adapter) { |
| mContextMenuAdapter = adapter; |
| if (mListView != null) { |
| mListView.setOnCreateContextMenuListener(adapter); |
| } |
| } |
| |
| public ContextMenuAdapter getContextMenuAdapter() { |
| return mContextMenuAdapter; |
| } |
| |
| protected boolean loadPreferences() { |
| boolean changed = false; |
| if (getContactNameDisplayOrder() != mContactsPrefs.getDisplayOrder()) { |
| setContactNameDisplayOrder(mContactsPrefs.getDisplayOrder()); |
| changed = true; |
| } |
| |
| if (getSortOrder() != mContactsPrefs.getSortOrder()) { |
| setSortOrder(mContactsPrefs.getSortOrder()); |
| changed = true; |
| } |
| |
| return changed; |
| } |
| |
| @Override |
| public View onCreateView(LayoutInflater inflater, ViewGroup container, |
| Bundle savedInstanceState) { |
| onCreateView(inflater, container); |
| |
| mAdapter = createListAdapter(); |
| |
| boolean searchMode = isSearchMode(); |
| mAdapter.setSearchMode(searchMode); |
| mAdapter.configureDefaultPartition(false, searchMode); |
| mAdapter.setPhotoLoader(mPhotoManager); |
| mListView.setAdapter(mAdapter); |
| |
| if (!isSearchMode()) { |
| mListView.setFocusableInTouchMode(true); |
| mListView.requestFocus(); |
| } |
| |
| return mView; |
| } |
| |
| protected void onCreateView(LayoutInflater inflater, ViewGroup container) { |
| mView = inflateView(inflater, container); |
| |
| mListView = (ListView)mView.findViewById(android.R.id.list); |
| if (mListView == null) { |
| throw new RuntimeException( |
| "Your content must have a ListView whose id attribute is " + |
| "'android.R.id.list'"); |
| } |
| |
| View emptyView = mView.findViewById(com.android.internal.R.id.empty); |
| if (emptyView != null) { |
| mListView.setEmptyView(emptyView); |
| if (emptyView instanceof ContactListEmptyView) { |
| mEmptyView = (ContactListEmptyView)emptyView; |
| } |
| } |
| |
| mListView.setOnItemClickListener(this); |
| mListView.setOnFocusChangeListener(this); |
| mListView.setOnTouchListener(this); |
| mListView.setFastScrollEnabled(!isSearchMode()); |
| |
| // Tell list view to not show dividers. We'll do it ourself so that we can *not* show |
| // them when an A-Z headers is visible. |
| mListView.setDividerHeight(0); |
| |
| // We manually save/restore the listview state |
| mListView.setSaveEnabled(false); |
| |
| if (mContextMenuAdapter != null) { |
| mListView.setOnCreateContextMenuListener(mContextMenuAdapter); |
| } |
| |
| configureVerticalScrollbar(); |
| configurePhotoLoader(); |
| } |
| |
| protected void configurePhotoLoader() { |
| if (isPhotoLoaderEnabled() && mContext != null) { |
| if (mPhotoManager == null) { |
| mPhotoManager = ContactPhotoManager.getInstance(mContext); |
| } |
| if (mListView != null) { |
| mListView.setOnScrollListener(this); |
| } |
| if (mAdapter != null) { |
| mAdapter.setPhotoLoader(mPhotoManager); |
| } |
| } |
| } |
| |
| protected void configureAdapter() { |
| if (mAdapter == null) { |
| return; |
| } |
| |
| mAdapter.setQuickContactEnabled(mQuickContactEnabled); |
| mAdapter.setIncludeProfile(mIncludeProfile); |
| mAdapter.setQueryString(mQueryString); |
| mAdapter.setDirectorySearchMode(mDirectorySearchMode); |
| mAdapter.setPinnedPartitionHeadersEnabled(mSearchMode); |
| mAdapter.setContactNameDisplayOrder(mDisplayOrder); |
| mAdapter.setSortOrder(mSortOrder); |
| mAdapter.setSectionHeaderDisplayEnabled(mSectionHeaderDisplayEnabled); |
| mAdapter.setSelectionVisible(mSelectionVisible); |
| mAdapter.setDirectoryResultLimit(mDirectoryResultLimit); |
| mAdapter.setDarkTheme(mDarkTheme); |
| } |
| |
| @Override |
| public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, |
| int totalItemCount) { |
| } |
| |
| @Override |
| public void onScrollStateChanged(AbsListView view, int scrollState) { |
| if (scrollState == OnScrollListener.SCROLL_STATE_FLING) { |
| mPhotoManager.pause(); |
| } else if (isPhotoLoaderEnabled()) { |
| mPhotoManager.resume(); |
| } |
| } |
| |
| @Override |
| public void onItemClick(AdapterView<?> parent, View view, int position, long id) { |
| hideSoftKeyboard(); |
| |
| int adjPosition = position - mListView.getHeaderViewsCount(); |
| if (adjPosition >= 0) { |
| onItemClick(adjPosition, id); |
| } |
| } |
| |
| private void hideSoftKeyboard() { |
| // Hide soft keyboard, if visible |
| InputMethodManager inputMethodManager = (InputMethodManager) |
| mContext.getSystemService(Context.INPUT_METHOD_SERVICE); |
| inputMethodManager.hideSoftInputFromWindow(mListView.getWindowToken(), 0); |
| } |
| |
| /** |
| * Dismisses the soft keyboard when the list takes focus. |
| */ |
| @Override |
| public void onFocusChange(View view, boolean hasFocus) { |
| if (view == mListView && hasFocus) { |
| hideSoftKeyboard(); |
| } |
| } |
| |
| /** |
| * Dismisses the soft keyboard when the list is touched. |
| */ |
| @Override |
| public boolean onTouch(View view, MotionEvent event) { |
| if (view == mListView) { |
| hideSoftKeyboard(); |
| } |
| return false; |
| } |
| |
| @Override |
| public void onPause() { |
| super.onPause(); |
| removePendingDirectorySearchRequests(); |
| } |
| |
| /** |
| * Dismisses the search UI along with the keyboard if the filter text is empty. |
| */ |
| public void onClose() { |
| hideSoftKeyboard(); |
| finish(); |
| } |
| |
| /** |
| * Restore the list state after the adapter is populated. |
| */ |
| protected void completeRestoreInstanceState() { |
| if (mListState != null) { |
| mListView.onRestoreInstanceState(mListState); |
| mListState = null; |
| } |
| } |
| |
| protected void setEmptyText(int resourceId) { |
| TextView empty = (TextView) getEmptyView().findViewById(R.id.emptyText); |
| empty.setText(mContext.getText(resourceId)); |
| empty.setVisibility(View.VISIBLE); |
| } |
| |
| // TODO redesign into an async task or loader |
| protected boolean isSyncActive() { |
| Account[] accounts = AccountManager.get(mContext).getAccounts(); |
| if (accounts != null && accounts.length > 0) { |
| IContentService contentService = ContentResolver.getContentService(); |
| for (Account account : accounts) { |
| try { |
| if (contentService.isSyncActive(account, ContactsContract.AUTHORITY)) { |
| return true; |
| } |
| } catch (RemoteException e) { |
| Log.e(TAG, "Could not get the sync status"); |
| } |
| } |
| } |
| return false; |
| } |
| |
| protected boolean hasIccCard() { |
| TelephonyManager telephonyManager = |
| (TelephonyManager)mContext.getSystemService(Context.TELEPHONY_SERVICE); |
| return telephonyManager.hasIccCard(); |
| } |
| |
| public void setDarkTheme(boolean value) { |
| mDarkTheme = value; |
| if (mAdapter != null) mAdapter.setDarkTheme(value); |
| } |
| |
| /** |
| * Processes a result returned by the contact picker. |
| */ |
| public void onPickerResult(Intent data) { |
| throw new UnsupportedOperationException("Picker result handler is not implemented."); |
| } |
| |
| private ContactsPreferences.ChangeListener mPreferencesChangeListener = |
| new ContactsPreferences.ChangeListener() { |
| @Override |
| public void onChange() { |
| loadPreferences(); |
| reloadData(); |
| } |
| }; |
| } |
