/* * Copyright (C) 2008 Esmertec AG. * Copyright (C) 2008 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.mms.ui; import java.util.ArrayList; import com.android.mms.LogTag; import com.android.mms.R; import com.android.mms.data.Contact; import com.android.mms.data.ContactList; import com.android.mms.data.Conversation; import com.android.mms.data.RecipientIdCache; import com.android.mms.transaction.MessagingNotification; import com.android.mms.transaction.SmsRejectedReceiver; import com.android.mms.util.DraftCache; import com.android.mms.util.Recycler; import com.google.android.mms.pdu.PduHeaders; import android.database.sqlite.SqliteWrapper; import android.animation.LayoutTransition; import android.app.ActionBar; import android.app.AlertDialog; import android.app.ListActivity; import android.app.SearchManager; import android.app.SearchManager.OnDismissListener; import android.content.AsyncQueryHandler; import android.content.ContentResolver; import android.content.Context; import android.content.DialogInterface; import android.content.Intent; import android.content.SharedPreferences; import android.content.DialogInterface.OnClickListener; import android.content.res.Configuration; import android.database.Cursor; import android.database.sqlite.SQLiteException; import android.os.Bundle; import android.os.Handler; import android.preference.PreferenceManager; import android.provider.ContactsContract; import android.provider.ContactsContract.Contacts; import android.provider.Telephony.Mms; import android.provider.Telephony.Threads; import android.util.Log; import android.util.SparseBooleanArray; import android.view.ActionMode; import android.view.ContextMenu; import android.view.KeyEvent; import android.view.LayoutInflater; import android.view.Menu; import android.view.MenuInflater; import android.view.MenuItem; import android.view.View; import android.view.ViewGroup; import android.view.Window; import android.view.ContextMenu.ContextMenuInfo; import android.view.View.OnCreateContextMenuListener; import android.view.View.OnKeyListener; import android.widget.AdapterView; import android.widget.CheckBox; import android.widget.ListView; import android.widget.TextView; /** * This activity provides a list view of existing conversations. */ public class ConversationList extends ListActivity implements DraftCache.OnDraftChangedListener, OnDismissListener { private static final String TAG = "ConversationList"; private static final boolean DEBUG = false; private static final boolean LOCAL_LOGV = DEBUG; private static final int THREAD_LIST_QUERY_TOKEN = 1701; private static final int UNREAD_THREADS_QUERY_TOKEN = 1702; public static final int DELETE_CONVERSATION_TOKEN = 1801; public static final int HAVE_LOCKED_MESSAGES_TOKEN = 1802; private static final int DELETE_OBSOLETE_THREADS_TOKEN = 1803; // IDs of the main menu items. public static final int MENU_COMPOSE_NEW = 0; public static final int MENU_SEARCH = 1; public static final int MENU_DELETE_ALL = 3; public static final int MENU_PREFERENCES = 4; public static final int MENU_DEBUG_DUMP = 5; // IDs of the context menu items for the list of conversations. public static final int MENU_DELETE = 0; public static final int MENU_VIEW = 1; public static final int MENU_VIEW_CONTACT = 2; public static final int MENU_ADD_TO_CONTACTS = 3; private ThreadListQueryHandler mQueryHandler; private ConversationListAdapter mListAdapter; private CharSequence mTitle; private SharedPreferences mPrefs; private Handler mHandler; private boolean mNeedToMarkAsSeen; private TextView mUnreadConvCount; private Menu mMenu; private SearchManager mSearchManager; static private final String CHECKED_MESSAGE_LIMITS = "checked_message_limits"; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS); setContentView(R.layout.conversation_list_screen); mQueryHandler = new ThreadListQueryHandler(getContentResolver()); ListView listView = getListView(); listView.setOnCreateContextMenuListener(mConvListOnCreateContextMenuListener); listView.setOnKeyListener(mThreadListKeyListener); listView.setChoiceMode(ListView.CHOICE_MODE_MULTIPLE_MODAL); listView.setMultiChoiceModeListener(new ModeCallback()); initListAdapter(); setupActionBar(); mTitle = getString(R.string.app_label); mSearchManager = (SearchManager)getSystemService(Context.SEARCH_SERVICE); mHandler = new Handler(); mPrefs = PreferenceManager.getDefaultSharedPreferences(this); boolean checkedMessageLimits = mPrefs.getBoolean(CHECKED_MESSAGE_LIMITS, false); if (DEBUG) Log.v(TAG, "checkedMessageLimits: " + checkedMessageLimits); if (!checkedMessageLimits || DEBUG) { runOneTimeStorageLimitCheckForLegacyMessages(); } } private void setupActionBar() { ActionBar actionBar = getActionBar(); ViewGroup v = (ViewGroup)LayoutInflater.from(this) .inflate(R.layout.conversation_list_actionbar, null); actionBar.setCustomView(v, new ActionBar.LayoutParams( ActionBar.LayoutParams.MATCH_PARENT, ActionBar.LayoutParams.MATCH_PARENT)); actionBar.setDisplayOptions(ActionBar.DISPLAY_SHOW_CUSTOM, ActionBar.DISPLAY_SHOW_CUSTOM); // This results in a fade out -> fade in when switching the action bar between // showing the account spinner and the search box. v.setLayoutTransition(new LayoutTransition()); mUnreadConvCount = (TextView)v.findViewById(R.id.unread_conv_count); } private final ConversationListAdapter.OnContentChangedListener mContentChangedListener = new ConversationListAdapter.OnContentChangedListener() { public void onContentChanged(ConversationListAdapter adapter) { startAsyncQuery(); } }; private void initListAdapter() { mListAdapter = new ConversationListAdapter(this, null); mListAdapter.setOnContentChangedListener(mContentChangedListener); setListAdapter(mListAdapter); getListView().setRecyclerListener(mListAdapter); } /** * Checks to see if the number of MMS and SMS messages are under the limits for the * recycler. If so, it will automatically turn on the recycler setting. If not, it * will prompt the user with a message and point them to the setting to manually * turn on the recycler. */ public synchronized void runOneTimeStorageLimitCheckForLegacyMessages() { if (Recycler.isAutoDeleteEnabled(this)) { if (DEBUG) Log.v(TAG, "recycler is already turned on"); // The recycler is already turned on. We don't need to check anything or warn // the user, just remember that we've made the check. markCheckedMessageLimit(); return; } new Thread(new Runnable() { public void run() { if (Recycler.checkForThreadsOverLimit(ConversationList.this)) { if (DEBUG) Log.v(TAG, "checkForThreadsOverLimit TRUE"); // Dang, one or more of the threads are over the limit. Show an activity // that'll encourage the user to manually turn on the setting. Delay showing // this activity until a couple of seconds after the conversation list appears. mHandler.postDelayed(new Runnable() { public void run() { Intent intent = new Intent(ConversationList.this, WarnOfStorageLimitsActivity.class); startActivity(intent); } }, 2000); } else { if (DEBUG) Log.v(TAG, "checkForThreadsOverLimit silently turning on recycler"); // No threads were over the limit. Turn on the recycler by default. runOnUiThread(new Runnable() { public void run() { SharedPreferences.Editor editor = mPrefs.edit(); editor.putBoolean(MessagingPreferenceActivity.AUTO_DELETE, true); editor.apply(); } }); } // Remember that we don't have to do the check anymore when starting MMS. runOnUiThread(new Runnable() { public void run() { markCheckedMessageLimit(); } }); } }).start(); } /** * Mark in preferences that we've checked the user's message limits. Once checked, we'll * never check them again, unless the user wipe-data or resets the device. */ private void markCheckedMessageLimit() { if (DEBUG) Log.v(TAG, "markCheckedMessageLimit"); SharedPreferences.Editor editor = mPrefs.edit(); editor.putBoolean(CHECKED_MESSAGE_LIMITS, true); editor.apply(); } @Override protected void onNewIntent(Intent intent) { // Handle intents that occur after the activity has already been created. startAsyncQuery(); } @Override protected void onStart() { super.onStart(); MessagingNotification.cancelNotification(getApplicationContext(), SmsRejectedReceiver.SMS_REJECTED_NOTIFICATION_ID); DraftCache.getInstance().addOnDraftChangedListener(this); mNeedToMarkAsSeen = true; startAsyncQuery(); // We used to refresh the DraftCache here, but // refreshing the DraftCache each time we go to the ConversationList seems overly // aggressive. We already update the DraftCache when leaving CMA in onStop() and // onNewIntent(), and when we delete threads or delete all in CMA or this activity. // I hope we don't have to do such a heavy operation each time we enter here. // we invalidate the contact cache here because we want to get updated presence // and any contact changes. We don't invalidate the cache by observing presence and contact // changes (since that's too untargeted), so as a tradeoff we do it here. // If we're in the middle of the app initialization where we're loading the conversation // threads, don't invalidate the cache because we're in the process of building it. // TODO: think of a better way to invalidate cache more surgically or based on actual // TODO: changes we care about if (!Conversation.loadingThreads()) { Contact.invalidateCache(); } } @Override protected void onStop() { super.onStop(); DraftCache.getInstance().removeOnDraftChangedListener(this); // Simply setting the choice mode causes the previous choice mode to finish and we exit // multi-select mode (if we're in it) and remove all the selections. getListView().setChoiceMode(ListView.CHOICE_MODE_MULTIPLE_MODAL); mListAdapter.changeCursor(null); } public void onDraftChanged(final long threadId, final boolean hasDraft) { // Run notifyDataSetChanged() on the main thread. mQueryHandler.post(new Runnable() { public void run() { if (Log.isLoggable(LogTag.APP, Log.VERBOSE)) { log("onDraftChanged: threadId=" + threadId + ", hasDraft=" + hasDraft); } mListAdapter.notifyDataSetChanged(); } }); } private void startAsyncQuery() { try { setTitle(getString(R.string.refreshing)); setProgressBarIndeterminateVisibility(true); Conversation.startQueryForAll(mQueryHandler, THREAD_LIST_QUERY_TOKEN); Conversation.startQuery(mQueryHandler, UNREAD_THREADS_QUERY_TOKEN, Threads.READ + "=0"); } catch (SQLiteException e) { SqliteWrapper.checkSQLiteException(this, e); } } @Override public boolean onCreateOptionsMenu(Menu menu) { // It looks dangerous to hold onto the menu, but Activity's docs say: // "You can safely hold on to menu (and any items created // from it), making modifications to it as desired, until the next // time onCreateOptionsMenu() is called." mMenu = menu; return super.onCreateOptionsMenu(menu); } @Override public boolean onPrepareOptionsMenu(Menu menu) { menu.clear(); menu.add(0, MENU_COMPOSE_NEW, 0, R.string.menu_compose_new) .setIcon(com.android.internal.R.drawable.ic_menu_compose) .setTitle(R.string.new_message) .setShowAsAction(MenuItem.SHOW_AS_ACTION_ALWAYS | MenuItem.SHOW_AS_ACTION_WITH_TEXT); if (mListAdapter.getCount() > 0) { menu.add(0, MENU_DELETE_ALL, 0, R.string.menu_delete_all).setIcon( android.R.drawable.ic_menu_delete); } menu.add(0, MENU_SEARCH, 0, android.R.string.search_go) .setIcon(android.R.drawable.ic_menu_search) .setAlphabeticShortcut(android.app.SearchManager.MENU_KEY) .setTitle(R.string.menu_search) .setShowAsAction(MenuItem.SHOW_AS_ACTION_ALWAYS | MenuItem.SHOW_AS_ACTION_WITH_TEXT); menu.add(0, MENU_PREFERENCES, 0, R.string.menu_preferences).setIcon( android.R.drawable.ic_menu_preferences); if (LogTag.DEBUG_DUMP) { menu.add(0, MENU_DEBUG_DUMP, 0, R.string.menu_debug_dump); } return true; } @Override public boolean onSearchRequested() { if (mMenu != null) { mMenu.removeItem(MENU_SEARCH); mSearchManager.setOnDismissListener(this); } startSearch(null, false, null /*appData*/, false); return true; } @Override public boolean onOptionsItemSelected(MenuItem item) { switch(item.getItemId()) { case MENU_COMPOSE_NEW: createNewMessage(); break; case MENU_SEARCH: onSearchRequested(); break; case MENU_DELETE_ALL: // The invalid threadId of -1 means all threads here. confirmDeleteThread(-1L, mQueryHandler); break; case MENU_PREFERENCES: Intent intent = new Intent(this, MessagingPreferenceActivity.class); startActivityIfNeeded(intent, -1); break; case MENU_DEBUG_DUMP: LogTag.dumpInternalTables(this); break; default: return true; } return false; } @Override protected void onListItemClick(ListView l, View v, int position, long id) { // Note: don't read the thread id data from the ConversationListItem view passed in. // It's unreliable to read the cached data stored in the view because the ListItem // can be recycled, and the same view could be assigned to a different position // if you click the list item fast enough. Instead, get the cursor at the position // clicked and load the data from the cursor. // (ConversationListAdapter extends CursorAdapter, so getItemAtPosition() should // return the cursor object, which is moved to the position passed in) Cursor cursor = (Cursor) getListView().getItemAtPosition(position); Conversation conv = Conversation.from(this, cursor); long tid = conv.getThreadId(); if (LogTag.VERBOSE) { Log.d(TAG, "onListItemClick: pos=" + position + ", view=" + v + ", tid=" + tid); } openThread(tid); } private void createNewMessage() { startActivity(ComposeMessageActivity.createIntent(this, 0)); } private void openThread(long threadId) { startActivity(ComposeMessageActivity.createIntent(this, threadId)); } public static Intent createAddContactIntent(String address) { // address must be a single recipient Intent intent = new Intent(Intent.ACTION_INSERT_OR_EDIT); intent.setType(Contacts.CONTENT_ITEM_TYPE); if (Mms.isEmailAddress(address)) { intent.putExtra(ContactsContract.Intents.Insert.EMAIL, address); } else { intent.putExtra(ContactsContract.Intents.Insert.PHONE, address); intent.putExtra(ContactsContract.Intents.Insert.PHONE_TYPE, ContactsContract.CommonDataKinds.Phone.TYPE_MOBILE); } intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET); return intent; } private final OnCreateContextMenuListener mConvListOnCreateContextMenuListener = new OnCreateContextMenuListener() { public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) { Cursor cursor = mListAdapter.getCursor(); if (cursor == null || cursor.getPosition() < 0) { return; } Conversation conv = Conversation.from(ConversationList.this, cursor); ContactList recipients = conv.getRecipients(); menu.setHeaderTitle(recipients.formatNames(",")); AdapterView.AdapterContextMenuInfo info = (AdapterView.AdapterContextMenuInfo) menuInfo; menu.add(0, MENU_VIEW, 0, R.string.menu_view); // Only show if there's a single recipient if (recipients.size() == 1) { // do we have this recipient in contacts? if (recipients.get(0).existsInDatabase()) { menu.add(0, MENU_VIEW_CONTACT, 0, R.string.menu_view_contact); } else { menu.add(0, MENU_ADD_TO_CONTACTS, 0, R.string.menu_add_to_contacts); } } menu.add(0, MENU_DELETE, 0, R.string.menu_delete); } }; @Override public boolean onContextItemSelected(MenuItem item) { Cursor cursor = mListAdapter.getCursor(); if (cursor != null && cursor.getPosition() >= 0) { Conversation conv = Conversation.from(ConversationList.this, cursor); long threadId = conv.getThreadId(); switch (item.getItemId()) { case MENU_DELETE: { confirmDeleteThread(threadId, mQueryHandler); break; } case MENU_VIEW: { openThread(threadId); break; } case MENU_VIEW_CONTACT: { Contact contact = conv.getRecipients().get(0); Intent intent = new Intent(Intent.ACTION_VIEW, contact.getUri()); intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET); startActivity(intent); break; } case MENU_ADD_TO_CONTACTS: { String address = conv.getRecipients().get(0).getNumber(); startActivity(createAddContactIntent(address)); break; } default: break; } } return super.onContextItemSelected(item); } @Override public void onConfigurationChanged(Configuration newConfig) { // We override this method to avoid restarting the entire // activity when the keyboard is opened (declared in // AndroidManifest.xml). Because the only translatable text // in this activity is "New Message", which has the full width // of phone to work with, localization shouldn't be a problem: // no abbreviated alternate words should be needed even in // 'wide' languages like German or Russian. super.onConfigurationChanged(newConfig); if (DEBUG) Log.v(TAG, "onConfigurationChanged: " + newConfig); } /** * Start the process of putting up a dialog to confirm deleting a thread, * but first start a background query to see if any of the threads or thread * contain locked messages so we'll know how detailed of a UI to display. * @param threadId id of the thread to delete or -1 for all threads * @param handler query handler to do the background locked query */ public static void confirmDeleteThread(long threadId, AsyncQueryHandler handler) { ArrayList threadIds = null; if (threadId != -1) { threadIds = new ArrayList(); threadIds.add(threadId); } confirmDeleteThreads(threadIds, handler); } /** * Start the process of putting up a dialog to confirm deleting threads, * but first start a background query to see if any of the threads * contain locked messages so we'll know how detailed of a UI to display. * @param threadIds list of threadIds to delete or null for all threads * @param handler query handler to do the background locked query */ public static void confirmDeleteThreads(ArrayList threadIds, AsyncQueryHandler handler) { Conversation.startQueryHaveLockedMessages(handler, threadIds, HAVE_LOCKED_MESSAGES_TOKEN); } /** * Build and show the proper delete thread dialog. The UI is slightly different * depending on whether there are locked messages in the thread(s) and whether we're * deleting single/multiple threads or all threads. * @param listener gets called when the delete button is pressed * @param deleteAll whether to show a single thread or all threads UI * @param hasLockedMessages whether the thread(s) contain locked messages * @param context used to load the various UI elements */ public static void confirmDeleteThreadDialog(final DeleteThreadListener listener, ArrayList threadIds, boolean hasLockedMessages, Context context) { View contents = View.inflate(context, R.layout.delete_thread_dialog_view, null); TextView msg = (TextView)contents.findViewById(R.id.message); if (threadIds == null) { msg.setText(R.string.confirm_delete_all_conversations); } else { // Show the number of threads getting deleted in the confirmation dialog. int cnt = threadIds.size(); msg.setText(context.getResources().getQuantityString( R.plurals.confirm_delete_conversation, cnt, cnt)); } final CheckBox checkbox = (CheckBox)contents.findViewById(R.id.delete_locked); if (!hasLockedMessages) { checkbox.setVisibility(View.GONE); } else { listener.setDeleteLockedMessage(checkbox.isChecked()); checkbox.setOnClickListener(new View.OnClickListener() { public void onClick(View v) { listener.setDeleteLockedMessage(checkbox.isChecked()); } }); } AlertDialog.Builder builder = new AlertDialog.Builder(context); builder.setTitle(R.string.confirm_dialog_title) .setIcon(android.R.drawable.ic_dialog_alert) .setCancelable(true) .setPositiveButton(R.string.delete, listener) .setNegativeButton(R.string.no, null) .setView(contents) .show(); } private final OnKeyListener mThreadListKeyListener = new OnKeyListener() { public boolean onKey(View v, int keyCode, KeyEvent event) { if (event.getAction() == KeyEvent.ACTION_DOWN) { switch (keyCode) { case KeyEvent.KEYCODE_DEL: { long id = getListView().getSelectedItemId(); if (id > 0) { confirmDeleteThread(id, mQueryHandler); } return true; } } } return false; } }; public static class DeleteThreadListener implements OnClickListener { private final ArrayList mThreadIds; private final AsyncQueryHandler mHandler; private final Context mContext; private boolean mDeleteLockedMessages; public DeleteThreadListener(ArrayList threadIds, AsyncQueryHandler handler, Context context) { mThreadIds = threadIds; mHandler = handler; mContext = context; } public void setDeleteLockedMessage(boolean deleteLockedMessages) { mDeleteLockedMessages = deleteLockedMessages; } public void onClick(DialogInterface dialog, final int whichButton) { MessageUtils.handleReadReport(mContext, mThreadIds, PduHeaders.READ_STATUS__DELETED_WITHOUT_BEING_READ, new Runnable() { public void run() { int token = DELETE_CONVERSATION_TOKEN; if (mThreadIds == null) { Conversation.startDeleteAll(mHandler, token, mDeleteLockedMessages); DraftCache.getInstance().refresh(); } else { for (long threadId : mThreadIds) { Conversation.startDelete(mHandler, token, mDeleteLockedMessages, threadId); DraftCache.getInstance().setDraftState(threadId, false); } } } }); dialog.dismiss(); } } private final class ThreadListQueryHandler extends AsyncQueryHandler { public ThreadListQueryHandler(ContentResolver contentResolver) { super(contentResolver); } @Override protected void onQueryComplete(int token, Object cookie, Cursor cursor) { switch (token) { case THREAD_LIST_QUERY_TOKEN: mListAdapter.changeCursor(cursor); setTitle(mTitle); setProgressBarIndeterminateVisibility(false); if (mNeedToMarkAsSeen) { mNeedToMarkAsSeen = false; Conversation.markAllConversationsAsSeen(getApplicationContext()); // Delete any obsolete threads. Obsolete threads are threads that aren't // referenced by at least one message in the pdu or sms tables. Conversation.asyncDeleteObsoleteThreads(mQueryHandler, DELETE_OBSOLETE_THREADS_TOKEN); } break; case UNREAD_THREADS_QUERY_TOKEN: int count = cursor.getCount(); mUnreadConvCount.setText(count > 0 ? Integer.toString(count) : null); break; case HAVE_LOCKED_MESSAGES_TOKEN: ArrayList threadIds = (ArrayList)cookie; confirmDeleteThreadDialog(new DeleteThreadListener(threadIds, mQueryHandler, ConversationList.this), threadIds, cursor != null && cursor.getCount() > 0, ConversationList.this); break; default: Log.e(TAG, "onQueryComplete called with unknown token " + token); } } @Override protected void onDeleteComplete(int token, Object cookie, int result) { switch (token) { case DELETE_CONVERSATION_TOKEN: // Make sure the conversation cache reflects the threads in the DB. Conversation.init(ConversationList.this); // Update the notification for new messages since they // may be deleted. MessagingNotification.nonBlockingUpdateNewMessageIndicator(ConversationList.this, false, false); // Update the notification for failed messages since they // may be deleted. MessagingNotification.updateSendFailedNotification(ConversationList.this); // Make sure the list reflects the delete startAsyncQuery(); break; case DELETE_OBSOLETE_THREADS_TOKEN: // Nothing to do here. break; } } } private class ModeCallback implements ListView.MultiChoiceModeListener { private View mMultiSelectActionBarView; private TextView mSelectedConvCount; public boolean onCreateActionMode(ActionMode mode, Menu menu) { MenuInflater inflater = getMenuInflater(); inflater.inflate(R.menu.conversation_multi_select_menu, menu); if (mMultiSelectActionBarView == null) { mMultiSelectActionBarView = (ViewGroup)LayoutInflater.from(ConversationList.this) .inflate(R.layout.conversation_list_multi_select_actionbar, null); mSelectedConvCount = (TextView)mMultiSelectActionBarView.findViewById(R.id.selected_conv_count); } mode.setCustomView(mMultiSelectActionBarView); ((TextView)mMultiSelectActionBarView.findViewById(R.id.title)) .setText(R.string.select_conversations); return true; } public boolean onPrepareActionMode(ActionMode mode, Menu menu) { if (mMultiSelectActionBarView == null) { ViewGroup v = (ViewGroup)LayoutInflater.from(ConversationList.this) .inflate(R.layout.conversation_list_multi_select_actionbar, null); mode.setCustomView(v); mSelectedConvCount = (TextView)v.findViewById(R.id.selected_conv_count); } return true; } public boolean onActionItemClicked(ActionMode mode, MenuItem item) { switch (item.getItemId()) { case R.id.delete: ListView listView = getListView(); int numSelected = listView.getCheckedItemCount(); if (numSelected > 0) { ArrayList threadIds = new ArrayList(); int numConvs = mAdapter.getCount(); SparseBooleanArray selectedItems = listView.getCheckedItemPositions(); for (int i = 0; i < numConvs; i++) { if (selectedItems.get(i)) { Cursor cursor = (Cursor) getListView().getItemAtPosition(i); Conversation conv = Conversation.from(ConversationList.this, cursor); threadIds.add(conv.getThreadId()); } } confirmDeleteThreads(threadIds, mQueryHandler); } mode.finish(); break; default: break; } return true; } public void onDestroyActionMode(ActionMode mode) { ConversationListAdapter adapter = (ConversationListAdapter)getListView().getAdapter(); adapter.uncheckAll(); } public void onItemCheckedStateChanged(ActionMode mode, int position, long id, boolean checked) { ListView listView = getListView(); final int checkedCount = listView.getCheckedItemCount(); mSelectedConvCount.setText(Integer.toString(checkedCount)); Cursor cursor = (Cursor)listView.getItemAtPosition(position); Conversation conv = Conversation.from(ConversationList.this, cursor); conv.setIsChecked(checked); } } private void log(String format, Object... args) { String s = String.format(format, args); Log.d(TAG, "[" + Thread.currentThread().getId() + "] " + s); } // Called when search is dismissed public void onDismiss() { mSearchManager.setOnDismissListener(null); // put back the search menu we removed when starting search if (mMenu != null) { onPrepareOptionsMenu(mMenu); } } }