/*
* 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 java.util.Collection;
import java.util.HashSet;
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.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.app.ActionBar;
import android.app.AlertDialog;
import android.app.ListActivity;
import android.app.SearchManager;
import android.app.SearchManager.OnDismissListener;
import android.app.SearchableInfo;
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.Gravity;
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.SearchView;
import android.widget.TextView;
/**
* This activity provides a list view of existing conversations.
*/
public class ConversationList extends ListActivity implements DraftCache.OnDraftChangedListener {
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 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 MenuItem mSearchItem;
private SearchView mSearchView;
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());
// Tell the list view which view to display when the list is empty
View emptyView = findViewById(R.id.empty);
listView.setEmptyView(emptyView);
initListAdapter();
setupActionBar();
mTitle = getString(R.string.app_label);
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.setDisplayOptions(ActionBar.DISPLAY_SHOW_CUSTOM,
ActionBar.DISPLAY_SHOW_CUSTOM);
actionBar.setCustomView(v,
new ActionBar.LayoutParams(ActionBar.LayoutParams.WRAP_CONTENT,
ActionBar.LayoutParams.WRAP_CONTENT,
Gravity.CENTER_VERTICAL | Gravity.RIGHT));
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);
}
}
SearchView.OnQueryTextListener mQueryTextListener = new SearchView.OnQueryTextListener() {
public boolean onQueryTextSubmit(String query) {
Intent intent = new Intent();
intent.setClass(ConversationList.this, SearchActivity.class);
intent.putExtra(SearchManager.QUERY, query);
startActivity(intent);
mSearchItem.collapseActionView();
return true;
}
public boolean onQueryTextChange(String newText) {
return false;
}
};
@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.conversation_list_menu, menu);
mSearchItem = menu.findItem(R.id.search);
mSearchView = (SearchView) mSearchItem.getActionView();
mSearchView.setOnQueryTextListener(mQueryTextListener);
mSearchView.setQueryHint(getString(R.string.search_hint));
mSearchView.setIconifiedByDefault(true);
SearchManager searchManager = (SearchManager) getSystemService(Context.SEARCH_SERVICE);
if (searchManager != null) {
SearchableInfo info = searchManager.getSearchableInfo(this.getComponentName());
mSearchView.setSearchableInfo(info);
}
return true;
}
@Override
public boolean onPrepareOptionsMenu(Menu menu) {
MenuItem item = menu.findItem(R.id.action_delete_all);
if (item != null) {
item.setVisible(mListAdapter.getCount() > 0);
}
if (!LogTag.DEBUG_DUMP) {
item = menu.findItem(R.id.action_debug_dump);
if (item != null) {
item.setVisible(false);
}
}
return true;
}
@Override
public boolean onSearchRequested() {
mSearchItem.expandActionView();
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch(item.getItemId()) {
case R.id.action_compose_new:
createNewMessage();
break;
case R.id.action_delete_all:
// The invalid threadId of -1 means all threads here.
confirmDeleteThread(-1L, mQueryHandler);
break;
case R.id.action_settings:
Intent intent = new Intent(this, MessagingPreferenceActivity.class);
startActivityIfNeeded(intent, -1);
break;
case R.id.action_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<Long> threadIds = null;
if (threadId != -1) {
threadIds = new ArrayList<Long>();
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(Collection<Long> 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,
Collection<Long> 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)
.setIconAttribute(android.R.attr.alertDialogIcon)
.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 Collection<Long> mThreadIds;
private final AsyncQueryHandler mHandler;
private final Context mContext;
private boolean mDeleteLockedMessages;
public DeleteThreadListener(Collection<Long> 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 Runnable mDeleteObsoleteThreadsRunnable = new Runnable() {
public void run() {
if (Log.isLoggable(LogTag.APP, Log.VERBOSE)) {
LogTag.debug("mDeleteObsoleteThreadsRunnable getSavingDraft(): " +
DraftCache.getInstance().getSavingDraft());
}
if (DraftCache.getInstance().getSavingDraft()) {
// We're still saving a draft. Try again in a second. We don't want to delete
// any threads out from under the draft.
mHandler.postDelayed(mDeleteObsoleteThreadsRunnable, 1000);
} else {
Conversation.asyncDeleteObsoleteThreads(mQueryHandler,
DELETE_OBSOLETE_THREADS_TOKEN);
}
}
};
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. We only call
// this on the first query (because of mNeedToMarkAsSeen).
mHandler.post(mDeleteObsoleteThreadsRunnable);
}
break;
case UNREAD_THREADS_QUERY_TOKEN:
int count = cursor.getCount();
mUnreadConvCount.setText(count > 0 ? Integer.toString(count) : null);
break;
case HAVE_LOCKED_MESSAGES_TOKEN:
Collection<Long> threadIds = (Collection<Long>)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:
// Rebuild the contacts cache now that a thread and its associated unique
// recipients have been deleted.
Contact.init(ConversationList.this);
// 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;
private HashSet<Long> mSelectedThreadIds;
public boolean onCreateActionMode(ActionMode mode, Menu menu) {
MenuInflater inflater = getMenuInflater();
mSelectedThreadIds = new HashSet<Long>();
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:
if (mSelectedThreadIds.size() > 0) {
confirmDeleteThreads(mSelectedThreadIds, mQueryHandler);
}
mode.finish();
break;
default:
break;
}
return true;
}
public void onDestroyActionMode(ActionMode mode) {
ConversationListAdapter adapter = (ConversationListAdapter)getListView().getAdapter();
adapter.uncheckAll();
mSelectedThreadIds = null;
}
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);
long threadId = conv.getThreadId();
if (checked) {
mSelectedThreadIds.add(threadId);
} else {
mSelectedThreadIds.remove(threadId);
}
}
}
private void log(String format, Object... args) {
String s = String.format(format, args);
Log.d(TAG, "[" + Thread.currentThread().getId() + "] " + s);
}
}