mirror of
https://github.com/moparisthebest/k-9
synced 2024-08-13 17:03:48 -04:00
1276 lines
43 KiB
Java
1276 lines
43 KiB
Java
package com.android.email.activity;
|
|
|
|
import java.text.DateFormat;
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.Date;
|
|
|
|
import com.android.email.K9ListActivity;
|
|
|
|
import android.app.AlertDialog;
|
|
import android.app.Dialog;
|
|
import android.app.NotificationManager;
|
|
import android.content.Context;
|
|
import android.content.DialogInterface;
|
|
import android.content.Intent;
|
|
import android.net.Uri;
|
|
import android.os.Bundle;
|
|
import android.os.Handler;
|
|
import android.os.Process;
|
|
import android.util.Config;
|
|
import android.util.Log;
|
|
import android.view.ContextMenu;
|
|
import android.view.KeyEvent;
|
|
import android.view.LayoutInflater;
|
|
import android.view.Menu;
|
|
import android.view.MenuItem;
|
|
import android.view.View;
|
|
import android.view.ViewGroup;
|
|
import android.view.Window;
|
|
import android.widget.AdapterView.AdapterContextMenuInfo;
|
|
import android.widget.AdapterView.OnItemClickListener;
|
|
import android.view.ContextMenu.ContextMenuInfo;
|
|
import android.widget.BaseAdapter;
|
|
import android.widget.AdapterView;
|
|
import android.widget.ListView;
|
|
import android.widget.TextView;
|
|
import android.widget.Toast;
|
|
|
|
import com.android.email.Account;
|
|
import com.android.email.Email;
|
|
import com.android.email.MessagingController;
|
|
import com.android.email.MessagingListener;
|
|
import com.android.email.Preferences;
|
|
import com.android.email.R;
|
|
import com.android.email.MessagingController.SORT_TYPE;
|
|
import com.android.email.activity.FolderList.FolderInfoHolder;
|
|
import com.android.email.activity.MessageList.MessageInfoHolder;
|
|
import com.android.email.activity.setup.AccountSettings;
|
|
import com.android.email.activity.setup.FolderSettings;
|
|
import com.android.email.mail.Folder;
|
|
import com.android.email.mail.Message;
|
|
import com.android.email.mail.MessagingException;
|
|
import com.android.email.mail.Store;
|
|
import com.android.email.mail.store.LocalStore.LocalFolder;
|
|
|
|
import android.os.PowerManager;
|
|
import android.os.PowerManager.WakeLock;
|
|
import java.util.concurrent.LinkedBlockingQueue;
|
|
import java.util.concurrent.ThreadPoolExecutor;
|
|
import java.util.concurrent.TimeUnit;
|
|
|
|
/**
|
|
* FolderList is the primary user interface for the program. This
|
|
* Activity shows list of the Account's folders
|
|
*/
|
|
|
|
public class FolderList extends K9ListActivity {
|
|
|
|
private static final int DIALOG_MARK_ALL_AS_READ = 1;
|
|
|
|
private static final String EXTRA_ACCOUNT = "account";
|
|
|
|
private static final String EXTRA_INITIAL_FOLDER = "initialFolder";
|
|
|
|
private static final String STATE_CURRENT_FOLDER = "com.android.email.activity.folderlist_folder";
|
|
|
|
private static final String EXTRA_CLEAR_NOTIFICATION = "clearNotification";
|
|
|
|
private static final String EXTRA_STARTUP = "startup";
|
|
|
|
private static final boolean REFRESH_REMOTE = true;
|
|
|
|
private ListView mListView;
|
|
|
|
private FolderListAdapter mAdapter;
|
|
|
|
private LayoutInflater mInflater;
|
|
|
|
private Account mAccount;
|
|
|
|
private String mInitialFolder;
|
|
|
|
private boolean mRestoringState;
|
|
|
|
private boolean mRefreshRemote;
|
|
|
|
private FolderListHandler mHandler = new FolderListHandler();
|
|
|
|
private DateFormat dateFormat = null;
|
|
|
|
private DateFormat timeFormat = null;
|
|
|
|
private boolean sortAscending = true;
|
|
|
|
private boolean sortDateAscending = false;
|
|
|
|
private boolean mStartup = false;
|
|
|
|
|
|
private static final ThreadPoolExecutor threadPool = new ThreadPoolExecutor(1, 1, 120000L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue());
|
|
|
|
private DateFormat getDateFormat() {
|
|
if (dateFormat == null) {
|
|
String dateFormatS = android.provider.Settings.System.getString(getContentResolver(),
|
|
android.provider.Settings.System.DATE_FORMAT);
|
|
|
|
if (dateFormatS != null) {
|
|
dateFormat = new java.text.SimpleDateFormat(dateFormatS);
|
|
} else {
|
|
dateFormat = new java.text.SimpleDateFormat(Email.BACKUP_DATE_FORMAT);
|
|
}
|
|
}
|
|
|
|
return dateFormat;
|
|
}
|
|
|
|
private DateFormat getTimeFormat() {
|
|
|
|
if (timeFormat == null) {
|
|
String timeFormatS = android.provider.Settings.System.getString(getContentResolver(),
|
|
android.provider.Settings.System.TIME_12_24);
|
|
boolean b24 = !(timeFormatS == null || timeFormatS.equals("12"));
|
|
timeFormat = new java.text.SimpleDateFormat(b24 ? Email.TIME_FORMAT_24 : Email.TIME_FORMAT_12);
|
|
}
|
|
|
|
return timeFormat;
|
|
}
|
|
|
|
private void clearFormats() {
|
|
dateFormat = null;
|
|
timeFormat = null;
|
|
}
|
|
|
|
class FolderListHandler extends Handler {
|
|
|
|
private static final int MSG_PROGRESS = 2;
|
|
private static final int MSG_DATA_CHANGED = 3;
|
|
private static final int MSG_EXPAND_GROUP = 5;
|
|
private static final int MSG_FOLDER_LOADING = 7;
|
|
private static final int MSG_SYNC_MESSAGES = 13;
|
|
private static final int MSG_FOLDER_SYNCING = 18;
|
|
private static final int MSG_SENDING_OUTBOX = 19;
|
|
private static final int MSG_ACCOUNT_SIZE_CHANGED = 20;
|
|
private static final int MSG_WORKING_ACCOUNT = 21;
|
|
|
|
@Override
|
|
public void handleMessage(android.os.Message msg) {
|
|
switch (msg.what) {
|
|
case MSG_PROGRESS:
|
|
setProgressBarIndeterminateVisibility(msg.arg1 != 0);
|
|
break;
|
|
case MSG_DATA_CHANGED:
|
|
mAdapter.notifyDataSetChanged();
|
|
break;
|
|
case MSG_FOLDER_LOADING: {
|
|
FolderInfoHolder folder = mAdapter.getFolder((String) msg.obj);
|
|
|
|
if (folder != null) {
|
|
folder.loading = msg.arg1 != 0;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case MSG_ACCOUNT_SIZE_CHANGED: {
|
|
Long[] sizes = (Long[])msg.obj;
|
|
String toastText = getString(R.string.account_size_changed, mAccount.getDescription(), SizeFormatter.formatSize(getApplication(), sizes[0]), SizeFormatter.formatSize(getApplication(), sizes[1]));
|
|
|
|
Toast toast = Toast.makeText(getApplication(), toastText, Toast.LENGTH_LONG);
|
|
toast.show();
|
|
break;
|
|
}
|
|
|
|
case MSG_WORKING_ACCOUNT: {
|
|
int res = msg.arg1;
|
|
String toastText = getString(res, mAccount.getDescription());
|
|
|
|
Toast toast = Toast.makeText(getApplication(), toastText, Toast.LENGTH_SHORT);
|
|
toast.show();
|
|
break;
|
|
}
|
|
|
|
|
|
case MSG_FOLDER_SYNCING: {
|
|
String folderName = (String)((Object[]) msg.obj)[0];
|
|
String dispString;
|
|
dispString = mAccount.getDescription();
|
|
|
|
if (folderName != null) {
|
|
dispString += " (" + getString(R.string.status_loading) + folderName + ")";
|
|
}
|
|
|
|
setTitle(dispString);
|
|
|
|
break;
|
|
}
|
|
|
|
case MSG_SENDING_OUTBOX: {
|
|
boolean sending = (msg.arg1 != 0);
|
|
String dispString;
|
|
dispString = mAccount.getDescription();
|
|
|
|
if (sending) {
|
|
dispString += " (" + getString(R.string.status_sending) + ")";
|
|
}
|
|
|
|
setTitle(dispString);
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
super.handleMessage(msg);
|
|
}
|
|
}
|
|
|
|
public void synchronizeMessages(FolderInfoHolder folder, Message[] messages) {
|
|
android.os.Message msg = new android.os.Message();
|
|
msg.what = MSG_SYNC_MESSAGES;
|
|
msg.obj = new Object[] { folder, messages };
|
|
sendMessage(msg);
|
|
}
|
|
|
|
public void workingAccount(int res) {
|
|
android.os.Message msg = new android.os.Message();
|
|
msg.what = MSG_WORKING_ACCOUNT;
|
|
msg.arg1 = res;
|
|
sendMessage(msg);
|
|
}
|
|
|
|
public void accountSizeChanged(long oldSize, long newSize) {
|
|
android.os.Message msg = new android.os.Message();
|
|
msg.what = MSG_ACCOUNT_SIZE_CHANGED;
|
|
msg.obj = new Long[] { oldSize, newSize };
|
|
sendMessage(msg);
|
|
}
|
|
|
|
public void folderLoading(String folder, boolean loading) {
|
|
android.os.Message msg = new android.os.Message();
|
|
msg.what = MSG_FOLDER_LOADING;
|
|
msg.arg1 = loading ? 1 : 0;
|
|
msg.obj = folder;
|
|
sendMessage(msg);
|
|
}
|
|
|
|
public void progress(boolean progress) {
|
|
android.os.Message msg = new android.os.Message();
|
|
msg.what = MSG_PROGRESS;
|
|
msg.arg1 = progress ? 1 : 0;
|
|
sendMessage(msg);
|
|
}
|
|
|
|
public void dataChanged() {
|
|
sendEmptyMessage(MSG_DATA_CHANGED);
|
|
}
|
|
|
|
public void folderSyncing(String folder) {
|
|
android.os.Message msg = new android.os.Message();
|
|
msg.what = MSG_FOLDER_SYNCING;
|
|
msg.obj = new String[] { folder };
|
|
sendMessage(msg);
|
|
}
|
|
|
|
public void sendingOutbox(boolean sending) {
|
|
android.os.Message msg = new android.os.Message();
|
|
msg.what = MSG_SENDING_OUTBOX;
|
|
msg.arg1 = sending ? 1 : 0;
|
|
sendMessage(msg);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This class is responsible for reloading the list of local messages for a
|
|
* given folder, notifying the adapter that the message have been loaded and
|
|
* queueing up a remote update of the folder.
|
|
*/
|
|
|
|
class FolderUpdateWorker implements Runnable {
|
|
String mFolder;
|
|
FolderInfoHolder mHolder;
|
|
boolean mSynchronizeRemote;
|
|
|
|
/**
|
|
* Create a worker for the given folder and specifying whether the worker
|
|
* should synchronize the remote folder or just the local one.
|
|
*
|
|
* @param folder
|
|
* @param synchronizeRemote
|
|
*/
|
|
public FolderUpdateWorker(FolderInfoHolder folder, boolean synchronizeRemote) {
|
|
mFolder = folder.name;
|
|
mHolder = folder;
|
|
mSynchronizeRemote = synchronizeRemote;
|
|
}
|
|
|
|
public void run() {
|
|
// Lower our priority
|
|
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
|
|
PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
|
|
WakeLock wakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "Email - UpdateWorker");
|
|
wakeLock.setReferenceCounted(false);
|
|
wakeLock.acquire(Email.WAKE_LOCK_TIMEOUT);
|
|
// Synchronously load the list of local messages
|
|
|
|
try {
|
|
try {
|
|
Store localStore = Store.getInstance(mAccount.getLocalStoreUri(), getApplication());
|
|
LocalFolder localFolder = (LocalFolder) localStore.getFolder(mFolder);
|
|
|
|
if (localFolder.getMessageCount() == 0 && localFolder.getLastChecked() <= 0) {
|
|
mSynchronizeRemote = true;
|
|
}
|
|
} catch (MessagingException me) {
|
|
Log.e(Email.LOG_TAG, "Unable to get count of local messages for folder " + mFolder, me);
|
|
}
|
|
|
|
if (mSynchronizeRemote) {
|
|
// Tell the MessagingController to run a remote update of this folder
|
|
// at it's leisure
|
|
MessagingController.getInstance(getApplication()).synchronizeMailbox(mAccount, mFolder, mAdapter.mListener);
|
|
}
|
|
} finally {
|
|
wakeLock.release();
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
private static void actionHandleAccount(Context context, Account account, String initialFolder, boolean startup) {
|
|
Intent intent = new Intent(context, FolderList.class);
|
|
intent.putExtra(EXTRA_ACCOUNT, account);
|
|
intent.putExtra(EXTRA_STARTUP, startup);
|
|
|
|
if (initialFolder != null) {
|
|
intent.putExtra(EXTRA_INITIAL_FOLDER, initialFolder);
|
|
}
|
|
|
|
context.startActivity(intent);
|
|
}
|
|
|
|
public static void actionHandleAccount(Context context, Account account, String initialFolder) {
|
|
actionHandleAccount(context, account, initialFolder, false);
|
|
}
|
|
|
|
public static void actionHandleAccount(Context context, Account account, boolean startup) {
|
|
actionHandleAccount(context, account, null, startup);
|
|
}
|
|
|
|
public static Intent actionHandleAccountIntent(Context context, Account account, String initialFolder) {
|
|
Intent intent = new Intent(
|
|
Intent.ACTION_VIEW,
|
|
Uri.parse("email://accounts/" + account.getAccountNumber()),
|
|
context,
|
|
FolderList.class);
|
|
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
|
|
intent.putExtra(EXTRA_ACCOUNT, account);
|
|
intent.putExtra(EXTRA_CLEAR_NOTIFICATION, true);
|
|
|
|
if (initialFolder != null) {
|
|
intent.putExtra(EXTRA_INITIAL_FOLDER, initialFolder);
|
|
}
|
|
else {
|
|
intent.putExtra(EXTRA_STARTUP, true);
|
|
}
|
|
return intent;
|
|
}
|
|
|
|
public static Intent actionHandleAccountIntent(Context context, Account account) {
|
|
return actionHandleAccountIntent(context, account, null);
|
|
}
|
|
|
|
@Override
|
|
public void onCreate(Bundle savedInstanceState) {
|
|
super.onCreate(savedInstanceState);
|
|
String savedFolderName = null;
|
|
Intent intent = getIntent();
|
|
mAccount = (Account)intent.getSerializableExtra(EXTRA_ACCOUNT);
|
|
Log.v(Email.LOG_TAG, "savedInstanceState: " + (savedInstanceState==null));
|
|
if (savedInstanceState == null) {
|
|
mInitialFolder = intent.getStringExtra(EXTRA_INITIAL_FOLDER);
|
|
Log.v(Email.LOG_TAG, "EXTRA_INITIAL_FOLDER: " + mInitialFolder);
|
|
mStartup = (boolean) intent.getBooleanExtra(EXTRA_STARTUP, false);
|
|
Log.v(Email.LOG_TAG, "startup: " + mStartup);
|
|
if (mInitialFolder == null
|
|
&& mStartup) {
|
|
mInitialFolder = mAccount.getAutoExpandFolderName();
|
|
}
|
|
}
|
|
else {
|
|
mInitialFolder = null;
|
|
mStartup = false;
|
|
savedFolderName = savedInstanceState.getString(STATE_CURRENT_FOLDER);
|
|
}
|
|
|
|
Log.v(Email.LOG_TAG, "mInitialFolder: " + mInitialFolder);
|
|
if (mInitialFolder != null
|
|
&& !Email.FOLDER_NONE.equals(mInitialFolder)) {
|
|
onOpenFolder(mInitialFolder, true);
|
|
finish();
|
|
}
|
|
else {
|
|
requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);
|
|
|
|
final FolderList xxx = this;
|
|
|
|
mListView = getListView();
|
|
mListView.setScrollBarStyle(View.SCROLLBARS_OUTSIDE_INSET);
|
|
mListView.setLongClickable(true);
|
|
//mListView.setFastScrollEnabled(true); // XXX TODO - reenable when we switch to 1.5
|
|
mListView.setScrollingCacheEnabled(true);
|
|
mListView.setOnItemClickListener(new OnItemClickListener() {
|
|
public void onItemClick(AdapterView parent, View v, int itemPosition, long id) {
|
|
Log.v(Email.LOG_TAG,"We're clicking "+itemPosition+" -- "+id);
|
|
MessageList.actionHandleFolder(xxx, mAccount, ((FolderInfoHolder)mAdapter.getItem(id)).name, false);
|
|
}
|
|
});
|
|
registerForContextMenu(mListView);
|
|
|
|
/*
|
|
* We manually save and restore the list's state because our adapter is
|
|
* slow.
|
|
*/
|
|
mListView.setSaveEnabled(false);
|
|
|
|
mInflater = getLayoutInflater();
|
|
|
|
mAdapter = new FolderListAdapter();
|
|
|
|
final Object previousData = getLastNonConfigurationInstance();
|
|
|
|
if (previousData != null) {
|
|
//noinspection unchecked
|
|
mAdapter.mFolders = (ArrayList<FolderInfoHolder>) previousData;
|
|
}
|
|
|
|
setListAdapter(mAdapter);
|
|
|
|
if (savedInstanceState != null) {
|
|
mRestoringState = true;
|
|
//onRestoreListState(savedInstanceState);
|
|
mRestoringState = false;
|
|
}
|
|
|
|
setTitle(mAccount.getDescription());
|
|
|
|
if (savedFolderName != null)
|
|
{
|
|
mSelectedContextFolder = mAdapter.getFolder(savedFolderName);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override public Object onRetainNonConfigurationInstance() {
|
|
return mAdapter.mFolders;
|
|
}
|
|
|
|
@Override public void onPause() {
|
|
super.onPause();
|
|
MessagingController.getInstance(getApplication()).removeListener(mAdapter.mListener);
|
|
}
|
|
|
|
/**
|
|
* On resume we refresh the folder list (in the background) and we refresh the
|
|
* messages for any folder that is currently open. This guarantees that things
|
|
* like unread message count and read status are updated.
|
|
*/
|
|
@Override public void onResume() {
|
|
super.onResume();
|
|
clearFormats();
|
|
|
|
MessagingController.getInstance(getApplication()).addListener(mAdapter.mListener);
|
|
mAccount.refresh(Preferences.getPreferences(this));
|
|
markAllRefresh();
|
|
|
|
onRefresh( !REFRESH_REMOTE );
|
|
|
|
NotificationManager notifMgr = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
|
|
notifMgr.cancel(mAccount.getAccountNumber());
|
|
notifMgr.cancel(-1000 - mAccount.getAccountNumber());
|
|
|
|
}
|
|
|
|
@Override
|
|
public void onSaveInstanceState(Bundle outState) {
|
|
super.onSaveInstanceState(outState);
|
|
if (mSelectedContextFolder != null)
|
|
{
|
|
outState.putString(STATE_CURRENT_FOLDER, mSelectedContextFolder.name);
|
|
}
|
|
}
|
|
|
|
@Override public boolean onKeyDown(int keyCode, KeyEvent event) {
|
|
//Shortcuts that work no matter what is selected
|
|
|
|
switch (keyCode) {
|
|
case KeyEvent.KEYCODE_Q: {
|
|
onAccounts();
|
|
return true;
|
|
}
|
|
|
|
case KeyEvent.KEYCODE_S: {
|
|
onEditAccount();
|
|
return true;
|
|
}
|
|
|
|
case KeyEvent.KEYCODE_H: {
|
|
Toast toast = Toast.makeText(this, R.string.message_list_help_key, Toast.LENGTH_LONG);
|
|
toast.show();
|
|
return true;
|
|
}
|
|
}//switch
|
|
|
|
|
|
return super.onKeyDown(keyCode, event);
|
|
}//onKeyDown
|
|
|
|
private void onRefresh(final boolean forceRemote) {
|
|
if (forceRemote) {
|
|
mRefreshRemote = true;
|
|
}
|
|
|
|
new Thread() {
|
|
|
|
public void run() {
|
|
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
|
|
MessagingController.getInstance(getApplication()).listFolders(mAccount, forceRemote, mAdapter.mListener);
|
|
|
|
if (forceRemote) {
|
|
MessagingController.getInstance(getApplication()).sendPendingMessages(mAccount, null);
|
|
}
|
|
}
|
|
}
|
|
.start();
|
|
}
|
|
|
|
private void onEditAccount() {
|
|
AccountSettings.actionSettings(this, mAccount);
|
|
}
|
|
|
|
private void onEditFolder(Account account, String folderName) {
|
|
FolderSettings.actionSettings(this, account, folderName);
|
|
}
|
|
|
|
private void onAccounts() {
|
|
// If we're a child activity (say because Welcome dropped us straight to the message list
|
|
// we won't have a parent activity and we'll need to get back to it
|
|
if (mStartup
|
|
|| isTaskRoot()) {
|
|
Intent intent = new Intent(this, Accounts.class);
|
|
intent.putExtra(Accounts.EXTRA_STARTUP, false);
|
|
startActivity(intent);
|
|
}
|
|
finish();
|
|
}
|
|
|
|
private void markAllRefresh() {
|
|
mAdapter.mListener.accountReset(mAccount);
|
|
}
|
|
|
|
private void onEmptyTrash(final Account account) {
|
|
mHandler.dataChanged();
|
|
|
|
MessagingListener listener = new MessagingListener() {
|
|
@Override
|
|
public void controllerCommandCompleted(boolean moreToDo) {
|
|
Log.v(Email.LOG_TAG, "Empty Trash background task completed");
|
|
}
|
|
};
|
|
|
|
MessagingController.getInstance(getApplication()).emptyTrash(account, listener);
|
|
}
|
|
|
|
private void checkMail(final Account account) {
|
|
MessagingController.getInstance(getApplication()).checkMail(this, account, true, true, mAdapter.mListener);
|
|
}
|
|
|
|
@Override public boolean onOptionsItemSelected(MenuItem item) {
|
|
switch (item.getItemId()) {
|
|
case R.id.compose:
|
|
MessageCompose.actionCompose(this, mAccount);
|
|
|
|
return true;
|
|
|
|
case R.id.check_mail:
|
|
checkMail(mAccount);
|
|
|
|
return true;
|
|
|
|
case R.id.accounts:
|
|
onAccounts();
|
|
|
|
return true;
|
|
|
|
case R.id.list_folders:
|
|
onRefresh( REFRESH_REMOTE );
|
|
|
|
return true;
|
|
|
|
case R.id.account_settings:
|
|
onEditAccount();
|
|
|
|
return true;
|
|
|
|
case R.id.empty_trash:
|
|
onEmptyTrash(mAccount);
|
|
|
|
return true;
|
|
|
|
case R.id.compact:
|
|
onCompact(mAccount);
|
|
|
|
return true;
|
|
|
|
case R.id.clear:
|
|
onClear(mAccount);
|
|
|
|
return true;
|
|
|
|
default:
|
|
return super.onOptionsItemSelected(item);
|
|
}
|
|
}
|
|
|
|
private void onOpenFolder(String folder, boolean startup) {
|
|
MessageList.actionHandleFolder(this, mAccount, folder, startup);
|
|
}
|
|
|
|
private void onCompact(Account account) {
|
|
mHandler.workingAccount(R.string.compacting_account);
|
|
MessagingController.getInstance(getApplication()).compact(account, null);
|
|
}
|
|
|
|
private void onClear(Account account) {
|
|
mHandler.workingAccount(R.string.clearing_account);
|
|
MessagingController.getInstance(getApplication()).clear(account, null);
|
|
}
|
|
|
|
@Override public boolean onCreateOptionsMenu(Menu menu) {
|
|
super.onCreateOptionsMenu(menu);
|
|
getMenuInflater().inflate(R.menu.folder_list_option, menu);
|
|
return true;
|
|
}
|
|
|
|
@Override public boolean onContextItemSelected(MenuItem item) {
|
|
AdapterContextMenuInfo info = (AdapterContextMenuInfo) item .getMenuInfo();
|
|
FolderInfoHolder folder = (FolderInfoHolder) mAdapter.getItem(info.position);
|
|
|
|
switch (item.getItemId()) {
|
|
case R.id.open_folder:
|
|
onOpenFolder(folder.name, false);
|
|
break;
|
|
|
|
case R.id.mark_all_as_read:
|
|
onMarkAllAsRead(mAccount, folder.name);
|
|
break;
|
|
|
|
case R.id.send_messages:
|
|
Log.i(Email.LOG_TAG, "sending pending messages from " + folder.name);
|
|
|
|
MessagingController.getInstance(getApplication()).sendPendingMessages(mAccount, null);
|
|
|
|
break;
|
|
|
|
case R.id.check_mail:
|
|
Log.i(Email.LOG_TAG, "refresh folder " + folder.name);
|
|
|
|
threadPool.execute(new FolderUpdateWorker(folder, true));
|
|
|
|
break;
|
|
|
|
case R.id.folder_settings:
|
|
Log.i(Email.LOG_TAG, "edit folder settings for " + folder.name);
|
|
|
|
onEditFolder(mAccount, folder.name);
|
|
|
|
break;
|
|
|
|
case R.id.empty_trash:
|
|
Log.i(Email.LOG_TAG, "empty trash");
|
|
|
|
onEmptyTrash(mAccount);
|
|
|
|
break;
|
|
}
|
|
|
|
return super.onContextItemSelected(item);
|
|
}
|
|
|
|
private FolderInfoHolder mSelectedContextFolder = null;
|
|
|
|
|
|
private void onMarkAllAsRead(final Account account, final String folder) {
|
|
mSelectedContextFolder = mAdapter.getFolder(folder);
|
|
showDialog(DIALOG_MARK_ALL_AS_READ);
|
|
}
|
|
|
|
|
|
@Override
|
|
public Dialog onCreateDialog(int id) {
|
|
switch (id) {
|
|
case DIALOG_MARK_ALL_AS_READ:
|
|
return createMarkAllAsReadDialog();
|
|
}
|
|
|
|
return super.onCreateDialog(id);
|
|
}
|
|
|
|
public void onPrepareDialog(int id, Dialog dialog) {
|
|
switch (id) {
|
|
case DIALOG_MARK_ALL_AS_READ:
|
|
((AlertDialog)dialog).setMessage(getString(R.string.mark_all_as_read_dlg_instructions_fmt,
|
|
mSelectedContextFolder.displayName));
|
|
|
|
break;
|
|
|
|
default:
|
|
super.onPrepareDialog(id, dialog);
|
|
}
|
|
}
|
|
|
|
private Dialog createMarkAllAsReadDialog() {
|
|
return new AlertDialog.Builder(this)
|
|
.setTitle(R.string.mark_all_as_read_dlg_title)
|
|
.setMessage(getString(R.string.mark_all_as_read_dlg_instructions_fmt,
|
|
mSelectedContextFolder.displayName))
|
|
.setPositiveButton(R.string.okay_action, new DialogInterface.OnClickListener() {
|
|
public void onClick(DialogInterface dialog, int whichButton) {
|
|
dismissDialog(DIALOG_MARK_ALL_AS_READ);
|
|
|
|
try {
|
|
|
|
MessagingController.getInstance(getApplication()).markAllMessagesRead(mAccount, mSelectedContextFolder.name);
|
|
|
|
for (MessageInfoHolder holder : mSelectedContextFolder.messages) {
|
|
holder.read = true;
|
|
}
|
|
|
|
mSelectedContextFolder.unreadMessageCount = 0;
|
|
|
|
mHandler.dataChanged();
|
|
|
|
|
|
} catch (Exception e) {
|
|
// Ignore
|
|
}
|
|
}
|
|
})
|
|
|
|
.setNegativeButton(R.string.cancel_action, new DialogInterface.OnClickListener() {
|
|
public void onClick(DialogInterface dialog, int whichButton) {
|
|
dismissDialog(DIALOG_MARK_ALL_AS_READ);
|
|
}
|
|
})
|
|
|
|
.create();
|
|
}
|
|
|
|
|
|
@Override public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
|
|
super.onCreateContextMenu(menu, v, menuInfo);
|
|
AdapterContextMenuInfo info = (AdapterContextMenuInfo) menuInfo;
|
|
getMenuInflater().inflate(R.menu.folder_context, menu);
|
|
|
|
FolderInfoHolder folder = (FolderInfoHolder) mAdapter.getItem(info.position);
|
|
|
|
menu.setHeaderTitle((CharSequence) folder.displayName);
|
|
|
|
if (!folder.name.equals(mAccount.getTrashFolderName()))
|
|
menu.findItem(R.id.empty_trash).setVisible(false);
|
|
|
|
if (folder.outbox) {
|
|
menu.findItem(R.id.check_mail).setVisible(false);
|
|
} else {
|
|
menu.findItem(R.id.send_messages).setVisible(false);
|
|
}
|
|
|
|
menu.setHeaderTitle(folder.displayName);
|
|
}
|
|
|
|
private String truncateStatus(String mess) {
|
|
if (mess != null && mess.length() > 27) {
|
|
mess = mess.substring(0, 27);
|
|
}
|
|
|
|
return mess;
|
|
}
|
|
|
|
class FolderListAdapter extends BaseAdapter {
|
|
private ArrayList<FolderInfoHolder> mFolders = new ArrayList<FolderInfoHolder>();
|
|
|
|
public Object getItem(long position) {
|
|
return getItem((int)position);
|
|
}
|
|
|
|
public Object getItem(int position) {
|
|
return mFolders.get(position);
|
|
}
|
|
|
|
|
|
public long getItemId(int position) {
|
|
return position ;
|
|
}
|
|
|
|
public int getCount() {
|
|
return mFolders.size();
|
|
}
|
|
|
|
public boolean isEnabled(int item) {
|
|
return true;
|
|
}
|
|
|
|
public boolean areAllItemsEnabled() {
|
|
return true;
|
|
}
|
|
|
|
private MessagingListener mListener = new MessagingListener() {
|
|
|
|
@Override
|
|
public void listFoldersStarted(Account account) {
|
|
if (!account.equals(mAccount)) {
|
|
return;
|
|
}
|
|
|
|
mHandler.progress(true);
|
|
}
|
|
|
|
@Override
|
|
public void listFoldersFailed(Account account, String message) {
|
|
if (!account.equals(mAccount)) {
|
|
return;
|
|
}
|
|
|
|
mHandler.progress(false);
|
|
|
|
if (Config.LOGV) {
|
|
Log.v(Email.LOG_TAG, "listFoldersFailed " + message);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void listFoldersFinished(Account account) {
|
|
if (!account.equals(mAccount)) {
|
|
return;
|
|
}
|
|
|
|
mHandler.progress(false);
|
|
|
|
mHandler.dataChanged();
|
|
|
|
}
|
|
|
|
@Override
|
|
public void listFolders(Account account, Folder[] folders) {
|
|
if (!account.equals(mAccount)) {
|
|
return;
|
|
}
|
|
|
|
ArrayList<FolderInfoHolder> newFolders = new ArrayList<FolderInfoHolder>();
|
|
|
|
Account.FolderMode aMode = account.getFolderDisplayMode();
|
|
|
|
for (Folder folder : folders) {
|
|
try {
|
|
folder.refresh( Preferences.getPreferences(getApplication().getApplicationContext()) );
|
|
|
|
Folder.FolderClass fMode = folder.getDisplayClass();
|
|
|
|
if ((aMode == Account.FolderMode.FIRST_CLASS && fMode != Folder.FolderClass.FIRST_CLASS)
|
|
|| (aMode == Account.FolderMode.FIRST_AND_SECOND_CLASS &&
|
|
fMode != Folder.FolderClass.FIRST_CLASS &&
|
|
fMode != Folder.FolderClass.SECOND_CLASS)
|
|
|| (aMode == Account.FolderMode.NOT_SECOND_CLASS && fMode == Folder.FolderClass.SECOND_CLASS)) {
|
|
continue;
|
|
}
|
|
} catch (MessagingException me) {
|
|
Log.e(Email.LOG_TAG, "Couldn't get prefs to check for displayability of folder " + folder.getName(), me);
|
|
}
|
|
|
|
FolderInfoHolder holder = null;
|
|
|
|
int folderIndex = getFolderIndex(folder.getName());
|
|
if (folderIndex >= 0 ) {
|
|
holder = (FolderInfoHolder) getItem(folderIndex);
|
|
}
|
|
|
|
if (holder == null) {
|
|
holder = new FolderInfoHolder(folder);
|
|
} else {
|
|
holder.populate(folder);
|
|
|
|
}
|
|
|
|
newFolders.add(holder);
|
|
}
|
|
mFolders.clear();
|
|
|
|
mFolders.addAll(newFolders);
|
|
Collections.sort(mFolders);
|
|
mHandler.dataChanged();
|
|
mRefreshRemote = false;
|
|
}
|
|
|
|
|
|
@Override
|
|
public void accountReset(Account account) {
|
|
if (!account.equals(mAccount)) {
|
|
return;
|
|
}
|
|
|
|
for (FolderInfoHolder folder : mFolders) {
|
|
folder.needsRefresh = true;
|
|
}
|
|
}
|
|
|
|
public void synchronizeMailboxStarted(Account account, String folder) {
|
|
if (!account.equals(mAccount)) {
|
|
return;
|
|
}
|
|
|
|
mHandler.progress(true);
|
|
mHandler.folderLoading(folder, true);
|
|
mHandler.folderSyncing(folder);
|
|
}
|
|
|
|
@Override
|
|
public void synchronizeMailboxFinished(Account account, String folder, int totalMessagesInMailbox, int numNewMessages) {
|
|
if (!account.equals(mAccount)) {
|
|
return;
|
|
}
|
|
|
|
// There has to be a cheaper way to get at the localFolder object than this
|
|
try {
|
|
Folder localFolder = (Folder) Store.getInstance(account.getLocalStoreUri(), getApplication()).getFolder(folder);
|
|
getFolder(folder).populate(localFolder);
|
|
}
|
|
catch (MessagingException e) {
|
|
|
|
}
|
|
|
|
|
|
mHandler.progress(false);
|
|
mHandler.folderLoading(folder, false);
|
|
// mHandler.folderStatus(folder, null);
|
|
mHandler.folderSyncing(null);
|
|
|
|
onRefresh( ! REFRESH_REMOTE );
|
|
}
|
|
|
|
@Override
|
|
public void synchronizeMailboxFailed(Account account, String folder,
|
|
String message) {
|
|
if (!account.equals(mAccount)) {
|
|
return;
|
|
}
|
|
|
|
|
|
mHandler.progress(false);
|
|
|
|
mHandler.folderLoading(folder, false);
|
|
|
|
// String mess = truncateStatus(message);
|
|
|
|
// mHandler.folderStatus(folder, mess);
|
|
FolderInfoHolder holder = getFolder(folder);
|
|
|
|
if (holder != null) {
|
|
holder.lastChecked = 0;
|
|
}
|
|
|
|
mHandler.folderSyncing(null);
|
|
}
|
|
|
|
|
|
@Override
|
|
public void messageDeleted(Account account,
|
|
String folder, Message message) {
|
|
synchronizeMailboxRemovedMessage(account,
|
|
folder, message);
|
|
}
|
|
|
|
@Override
|
|
public void emptyTrashCompleted(Account account) {
|
|
if (!account.equals(mAccount)) {
|
|
return;
|
|
}
|
|
|
|
onRefresh( ! REFRESH_REMOTE);
|
|
}
|
|
|
|
@Override
|
|
public void folderStatusChanged(Account account, String folderName) {
|
|
if (!account.equals(mAccount)) {
|
|
return;
|
|
}
|
|
|
|
onRefresh( !REFRESH_REMOTE);
|
|
}
|
|
|
|
@Override
|
|
public void sendPendingMessagesCompleted(Account account) {
|
|
if (!account.equals(mAccount)) {
|
|
return;
|
|
}
|
|
|
|
mHandler.sendingOutbox(false);
|
|
|
|
onRefresh( !REFRESH_REMOTE);
|
|
}
|
|
|
|
@Override
|
|
public void sendPendingMessagesStarted(Account account) {
|
|
if (!account.equals(mAccount)) {
|
|
return;
|
|
}
|
|
|
|
mHandler.sendingOutbox(true);
|
|
}
|
|
|
|
@Override
|
|
public void sendPendingMessagesFailed(Account account) {
|
|
if (!account.equals(mAccount)) {
|
|
return;
|
|
}
|
|
|
|
mHandler.sendingOutbox(false);
|
|
}
|
|
|
|
public void accountSizeChanged(Account account, long oldSize, long newSize) {
|
|
if (!account.equals(mAccount)) {
|
|
return;
|
|
}
|
|
|
|
mHandler.accountSizeChanged(oldSize, newSize);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
public int getFolderIndex(String folder) {
|
|
FolderInfoHolder searchHolder = new FolderInfoHolder();
|
|
searchHolder.name = folder;
|
|
return mFolders.indexOf((Object) searchHolder);
|
|
}
|
|
|
|
public FolderInfoHolder getFolder(String folder) {
|
|
FolderInfoHolder holder = null;
|
|
|
|
int index = getFolderIndex(folder);
|
|
if(index >= 0 ){
|
|
holder = (FolderInfoHolder) getItem(index);
|
|
if (holder != null) {
|
|
return holder;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public View getView(int position, View convertView, ViewGroup parent) {
|
|
if (position <= getCount()) {
|
|
return getItemView(position, convertView, parent);
|
|
} else {
|
|
// XXX TODO - should catch an exception here
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public View getItemView(int itemPosition, View convertView, ViewGroup parent) {
|
|
FolderInfoHolder folder = (FolderInfoHolder) getItem(itemPosition);
|
|
View view;
|
|
if ((convertView != null) && (convertView.getId() == R.layout.folder_list_item)) {
|
|
view = convertView;
|
|
} else {
|
|
view = mInflater.inflate(R.layout.folder_list_item, parent, false);
|
|
view.setId(R.layout.folder_list_item);
|
|
}
|
|
|
|
|
|
FolderViewHolder holder = (FolderViewHolder) view.getTag();
|
|
|
|
if (holder == null) {
|
|
holder = new FolderViewHolder();
|
|
holder.folderName = (TextView) view.findViewById(R.id.folder_name);
|
|
holder.newMessageCount = (TextView) view.findViewById(R.id.folder_unread_message_count);
|
|
holder.folderStatus = (TextView) view.findViewById(R.id.folder_status);
|
|
holder.rawFolderName = folder.name;
|
|
|
|
view.setTag(holder);
|
|
}
|
|
|
|
if (folder == null) {
|
|
return view;
|
|
}
|
|
|
|
holder.folderName.setText(folder.displayName);
|
|
String statusText = "";
|
|
|
|
if (folder.loading) {
|
|
statusText = getString(R.string.status_loading);
|
|
} else if (folder.status != null) {
|
|
statusText = folder.status;
|
|
} else if (folder.lastChecked != 0) {
|
|
Date lastCheckedDate = new Date(folder.lastChecked);
|
|
|
|
statusText = (getDateFormat().format(lastCheckedDate) + " " + getTimeFormat()
|
|
.format(lastCheckedDate));
|
|
}
|
|
|
|
if (statusText != null) {
|
|
holder.folderStatus.setText(statusText);
|
|
holder.folderStatus.setVisibility(View.VISIBLE);
|
|
} else {
|
|
holder.folderStatus.setText(null);
|
|
holder.folderStatus.setVisibility(View.GONE);
|
|
}
|
|
|
|
if (folder.unreadMessageCount != 0) {
|
|
holder.newMessageCount.setText(Integer
|
|
.toString(folder.unreadMessageCount));
|
|
holder.newMessageCount.setVisibility(View.VISIBLE);
|
|
} else {
|
|
holder.newMessageCount.setVisibility(View.GONE);
|
|
}
|
|
|
|
return view;
|
|
}
|
|
|
|
public boolean hasStableIds() {
|
|
return false;
|
|
}
|
|
|
|
public boolean isItemSelectable(int position) {
|
|
return true;
|
|
}
|
|
|
|
}
|
|
|
|
public class FolderInfoHolder implements Comparable<FolderInfoHolder> {
|
|
public String name;
|
|
|
|
public String displayName;
|
|
|
|
public ArrayList<MessageInfoHolder> messages;
|
|
|
|
public long lastChecked;
|
|
|
|
public int unreadMessageCount;
|
|
|
|
public boolean loading;
|
|
|
|
public String status;
|
|
|
|
public boolean lastCheckFailed;
|
|
|
|
public boolean needsRefresh = false;
|
|
|
|
/**
|
|
* Outbox is handled differently from any other folder.
|
|
*/
|
|
public boolean outbox;
|
|
|
|
|
|
public boolean equals(Object o) {
|
|
if (this.name.equals(((FolderInfoHolder)o).name)) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public int compareTo(FolderInfoHolder o) {
|
|
String s1 = this.name;
|
|
String s2 = o.name;
|
|
|
|
if (Email.INBOX.equalsIgnoreCase(s1) && Email.INBOX.equalsIgnoreCase(s2)) {
|
|
return 0;
|
|
} else if (Email.INBOX.equalsIgnoreCase(s1)) {
|
|
return -1;
|
|
} else if (Email.INBOX.equalsIgnoreCase(s2)) {
|
|
return 1;
|
|
} else {
|
|
int ret = s1.compareToIgnoreCase(s2);
|
|
if (ret != 0) {
|
|
return ret;
|
|
}
|
|
else {
|
|
return s1.compareTo(s2);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// constructor for an empty object for comparisons
|
|
public FolderInfoHolder() {
|
|
}
|
|
|
|
public FolderInfoHolder(Folder folder) {
|
|
populate(folder);
|
|
}
|
|
public void populate (Folder folder) {
|
|
int unreadCount = 0;
|
|
|
|
try {
|
|
folder.open(Folder.OpenMode.READ_WRITE);
|
|
unreadCount = folder.getUnreadMessageCount();
|
|
} catch (MessagingException me) {
|
|
Log.e(Email.LOG_TAG, "Folder.getUnreadMessageCount() failed", me);
|
|
}
|
|
|
|
this.name = folder.getName();
|
|
|
|
if (this.name.equalsIgnoreCase(Email.INBOX)) {
|
|
this.displayName = getString(R.string.special_mailbox_name_inbox);
|
|
} else {
|
|
this.displayName = folder.getName();
|
|
}
|
|
|
|
if (this.name.equals(mAccount.getOutboxFolderName())) {
|
|
this.displayName = String.format( getString(R.string.special_mailbox_name_outbox_fmt), this.name);
|
|
this.outbox = true;
|
|
}
|
|
|
|
if (this.name.equals(mAccount.getDraftsFolderName())) {
|
|
this.displayName = String.format( getString(R.string.special_mailbox_name_drafts_fmt), this.name);
|
|
}
|
|
|
|
if (this.name.equals(mAccount.getTrashFolderName())) {
|
|
this.displayName = String.format( getString(R.string.special_mailbox_name_trash_fmt), this.name);
|
|
}
|
|
|
|
if (this.name.equals(mAccount.getSentFolderName())) {
|
|
this.displayName = String.format( getString(R.string.special_mailbox_name_sent_fmt), this.name);
|
|
}
|
|
|
|
if (this.messages == null) {
|
|
this.messages = new ArrayList<MessageInfoHolder>();
|
|
}
|
|
|
|
this.lastChecked = folder.getLastChecked();
|
|
|
|
String mess = truncateStatus(folder.getStatus());
|
|
|
|
this.status = mess;
|
|
|
|
this.unreadMessageCount = unreadCount;
|
|
|
|
try {
|
|
folder.close(false);
|
|
} catch (MessagingException me) {
|
|
Log.e(Email.LOG_TAG, "Folder.close() failed", me);
|
|
}
|
|
}
|
|
}
|
|
|
|
class FolderViewHolder {
|
|
public TextView folderName;
|
|
|
|
public TextView folderStatus;
|
|
|
|
public TextView newMessageCount;
|
|
|
|
public String rawFolderName;
|
|
}
|
|
|
|
}
|