mirror of
https://github.com/moparisthebest/k-9
synced 2024-12-02 14:02:17 -05:00
5d1e42c453
The commit that introduced those notifications also introduced a rather ... interesting design pattern: The CertificateValidationException notified the user of its pure existance - it's no longer a 'message' only, but defines policy. As this is more than unusual, replace this pattern by the MessagingController treating CertificateValidationException specially when accessing remote folders. Also make clear which account failed when constructing the notification.
1328 lines
48 KiB
Java
1328 lines
48 KiB
Java
|
|
package com.fsck.k9;
|
|
|
|
import java.io.File;
|
|
import java.lang.reflect.Method;
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.concurrent.BlockingQueue;
|
|
import java.util.concurrent.SynchronousQueue;
|
|
|
|
import android.app.Application;
|
|
import android.content.ComponentName;
|
|
import android.content.Context;
|
|
import android.content.Intent;
|
|
import android.content.IntentFilter;
|
|
import android.content.SharedPreferences;
|
|
import android.content.SharedPreferences.Editor;
|
|
import android.content.pm.PackageInfo;
|
|
import android.content.pm.PackageManager;
|
|
import android.content.pm.PackageManager.NameNotFoundException;
|
|
import android.net.Uri;
|
|
import android.os.Debug;
|
|
import android.os.Environment;
|
|
import android.os.Handler;
|
|
import android.os.Looper;
|
|
import android.text.format.Time;
|
|
import android.util.Log;
|
|
|
|
import com.fsck.k9.Account.SortType;
|
|
import com.fsck.k9.activity.MessageCompose;
|
|
import com.fsck.k9.activity.UpgradeDatabases;
|
|
import com.fsck.k9.controller.MessagingController;
|
|
import com.fsck.k9.controller.MessagingListener;
|
|
import com.fsck.k9.mail.Address;
|
|
import com.fsck.k9.mail.Message;
|
|
import com.fsck.k9.mail.MessagingException;
|
|
import com.fsck.k9.mail.internet.BinaryTempFileBody;
|
|
import com.fsck.k9.mail.store.LocalStore;
|
|
import com.fsck.k9.provider.UnreadWidgetProvider;
|
|
import com.fsck.k9.service.BootReceiver;
|
|
import com.fsck.k9.service.MailService;
|
|
import com.fsck.k9.service.ShutdownReceiver;
|
|
import com.fsck.k9.service.StorageGoneReceiver;
|
|
|
|
public class K9 extends Application {
|
|
public static final int THEME_LIGHT = 0;
|
|
public static final int THEME_DARK = 1;
|
|
|
|
/**
|
|
* Components that are interested in knowing when the K9 instance is
|
|
* available and ready (Android invokes Application.onCreate() after other
|
|
* components') should implement this interface and register using
|
|
* {@link K9#registerApplicationAware(ApplicationAware)}.
|
|
*/
|
|
public static interface ApplicationAware {
|
|
/**
|
|
* Called when the Application instance is available and ready.
|
|
*
|
|
* @param application
|
|
* The application instance. Never <code>null</code>.
|
|
* @throws Exception
|
|
*/
|
|
void initializeComponent(K9 application);
|
|
}
|
|
|
|
public static Application app = null;
|
|
public static File tempDirectory;
|
|
public static final String LOG_TAG = "k9";
|
|
|
|
/**
|
|
* Name of the {@link SharedPreferences} file used to store the last known version of the
|
|
* accounts' databases.
|
|
*
|
|
* <p>
|
|
* See {@link UpgradeDatabases} for a detailed explanation of the database upgrade process.
|
|
* </p>
|
|
*/
|
|
private static final String DATABASE_VERSION_CACHE = "database_version_cache";
|
|
|
|
/**
|
|
* Key used to store the last known database version of the accounts' databases.
|
|
*
|
|
* @see #DATABASE_VERSION_CACHE
|
|
*/
|
|
private static final String KEY_LAST_ACCOUNT_DATABASE_VERSION = "last_account_database_version";
|
|
|
|
/**
|
|
* Components that are interested in knowing when the K9 instance is
|
|
* available and ready.
|
|
*
|
|
* @see ApplicationAware
|
|
*/
|
|
private static List<ApplicationAware> observers = new ArrayList<ApplicationAware>();
|
|
|
|
public enum BACKGROUND_OPS {
|
|
WHEN_CHECKED, ALWAYS, NEVER, WHEN_CHECKED_AUTO_SYNC
|
|
}
|
|
|
|
private static String language = "";
|
|
private static int theme = THEME_LIGHT;
|
|
private static int messageViewTheme = THEME_LIGHT;
|
|
|
|
private static final FontSizes fontSizes = new FontSizes();
|
|
|
|
private static BACKGROUND_OPS backgroundOps = BACKGROUND_OPS.WHEN_CHECKED;
|
|
/**
|
|
* Some log messages can be sent to a file, so that the logs
|
|
* can be read using unprivileged access (eg. Terminal Emulator)
|
|
* on the phone, without adb. Set to null to disable
|
|
*/
|
|
public static final String logFile = null;
|
|
//public static final String logFile = Environment.getExternalStorageDirectory() + "/k9mail/debug.log";
|
|
|
|
/**
|
|
* If this is enabled, various development settings will be enabled
|
|
* It should NEVER be on for Market builds
|
|
* Right now, it just governs strictmode
|
|
**/
|
|
public static boolean DEVELOPER_MODE = true;
|
|
|
|
|
|
/**
|
|
* If this is enabled there will be additional logging information sent to
|
|
* Log.d, including protocol dumps.
|
|
* Controlled by Preferences at run-time
|
|
*/
|
|
public static boolean DEBUG = false;
|
|
|
|
/**
|
|
* Should K-9 log the conversation it has over the wire with
|
|
* SMTP servers?
|
|
*/
|
|
|
|
public static boolean DEBUG_PROTOCOL_SMTP = true;
|
|
|
|
/**
|
|
* Should K-9 log the conversation it has over the wire with
|
|
* IMAP servers?
|
|
*/
|
|
|
|
public static boolean DEBUG_PROTOCOL_IMAP = true;
|
|
|
|
|
|
/**
|
|
* Should K-9 log the conversation it has over the wire with
|
|
* POP3 servers?
|
|
*/
|
|
|
|
public static boolean DEBUG_PROTOCOL_POP3 = true;
|
|
|
|
/**
|
|
* Should K-9 log the conversation it has over the wire with
|
|
* WebDAV servers?
|
|
*/
|
|
|
|
public static boolean DEBUG_PROTOCOL_WEBDAV = true;
|
|
|
|
|
|
|
|
/**
|
|
* If this is enabled than logging that normally hides sensitive information
|
|
* like passwords will show that information.
|
|
*/
|
|
public static boolean DEBUG_SENSITIVE = false;
|
|
|
|
/**
|
|
* Can create messages containing stack traces that can be forwarded
|
|
* to the development team.
|
|
*/
|
|
public static boolean ENABLE_ERROR_FOLDER = true;
|
|
public static String ERROR_FOLDER_NAME = "K9mail-errors";
|
|
|
|
/**
|
|
* A reference to the {@link SharedPreferences} used for caching the last known database
|
|
* version.
|
|
*
|
|
* @see #checkCachedDatabaseVersion()
|
|
* @see #setDatabasesUpToDate(boolean)
|
|
*/
|
|
private static SharedPreferences sDatabaseVersionCache;
|
|
|
|
|
|
private static boolean mAnimations = true;
|
|
|
|
private static boolean mConfirmDelete = false;
|
|
private static boolean mConfirmDeleteStarred = false;
|
|
private static boolean mConfirmSpam = false;
|
|
private static boolean mConfirmDeleteFromNotification = true;
|
|
|
|
private static NotificationHideSubject sNotificationHideSubject = NotificationHideSubject.NEVER;
|
|
|
|
/**
|
|
* Controls when to hide the subject in the notification area.
|
|
*/
|
|
public enum NotificationHideSubject {
|
|
ALWAYS,
|
|
WHEN_LOCKED,
|
|
NEVER
|
|
}
|
|
|
|
private static NotificationQuickDelete sNotificationQuickDelete = NotificationQuickDelete.NEVER;
|
|
|
|
/**
|
|
* Controls behaviour of delete button in notifications.
|
|
*/
|
|
public enum NotificationQuickDelete {
|
|
ALWAYS,
|
|
FOR_SINGLE_MSG,
|
|
NEVER
|
|
}
|
|
|
|
/**
|
|
* Controls when to use the message list split view.
|
|
*/
|
|
public enum SplitViewMode {
|
|
ALWAYS,
|
|
NEVER,
|
|
WHEN_IN_LANDSCAPE
|
|
}
|
|
|
|
private static boolean mMessageListCheckboxes = false;
|
|
private static int mMessageListPreviewLines = 2;
|
|
|
|
private static boolean mShowCorrespondentNames = true;
|
|
private static boolean mMessageListSenderAboveSubject = false;
|
|
private static boolean mShowContactName = false;
|
|
private static boolean mChangeContactNameColor = false;
|
|
private static int mContactNameColor = 0xff00008f;
|
|
private static boolean mMessageViewFixedWidthFont = false;
|
|
private static boolean mMessageViewReturnToList = false;
|
|
private static boolean mMessageViewShowNext = false;
|
|
|
|
private static boolean mGesturesEnabled = true;
|
|
private static boolean mUseVolumeKeysForNavigation = false;
|
|
private static boolean mUseVolumeKeysForListNavigation = false;
|
|
private static boolean mStartIntegratedInbox = false;
|
|
private static boolean mMeasureAccounts = true;
|
|
private static boolean mCountSearchMessages = true;
|
|
private static boolean mHideSpecialAccounts = false;
|
|
private static boolean mMobileOptimizedLayout = false;
|
|
private static boolean mQuietTimeEnabled = false;
|
|
private static String mQuietTimeStarts = null;
|
|
private static String mQuietTimeEnds = null;
|
|
private static String mAttachmentDefaultPath = "";
|
|
private static boolean mWrapFolderNames = false;
|
|
|
|
private static boolean mBatchButtonsMarkRead = true;
|
|
private static boolean mBatchButtonsDelete = true;
|
|
private static boolean mBatchButtonsArchive = false;
|
|
private static boolean mBatchButtonsMove = false;
|
|
private static boolean mBatchButtonsFlag = true;
|
|
private static boolean mBatchButtonsUnselect = true;
|
|
|
|
private static boolean useGalleryBugWorkaround = false;
|
|
private static boolean galleryBuggy;
|
|
|
|
private static SortType mSortType;
|
|
private static HashMap<SortType, Boolean> mSortAscending = new HashMap<SortType, Boolean>();
|
|
|
|
private static boolean sUseBackgroundAsUnreadIndicator = true;
|
|
private static boolean sThreadedViewEnabled = true;
|
|
private static SplitViewMode sSplitViewMode = SplitViewMode.NEVER;
|
|
|
|
/**
|
|
* @see #areDatabasesUpToDate()
|
|
*/
|
|
private static boolean sDatabasesUpToDate = false;
|
|
|
|
|
|
/**
|
|
* The MIME type(s) of attachments we're willing to view.
|
|
*/
|
|
public static final String[] ACCEPTABLE_ATTACHMENT_VIEW_TYPES = new String[] {
|
|
"*/*",
|
|
};
|
|
|
|
/**
|
|
* The MIME type(s) of attachments we're not willing to view.
|
|
*/
|
|
public static final String[] UNACCEPTABLE_ATTACHMENT_VIEW_TYPES = new String[] {
|
|
};
|
|
|
|
/**
|
|
* The MIME type(s) of attachments we're willing to download to SD.
|
|
*/
|
|
public static final String[] ACCEPTABLE_ATTACHMENT_DOWNLOAD_TYPES = new String[] {
|
|
"*/*",
|
|
};
|
|
|
|
/**
|
|
* The MIME type(s) of attachments we're not willing to download to SD.
|
|
*/
|
|
public static final String[] UNACCEPTABLE_ATTACHMENT_DOWNLOAD_TYPES = new String[] {
|
|
};
|
|
|
|
/**
|
|
* For use when displaying that no folder is selected
|
|
*/
|
|
public static final String FOLDER_NONE = "-NONE-";
|
|
|
|
public static final String LOCAL_UID_PREFIX = "K9LOCAL:";
|
|
|
|
public static final String REMOTE_UID_PREFIX = "K9REMOTE:";
|
|
|
|
public static final String IDENTITY_HEADER = "X-K9mail-Identity";
|
|
|
|
/**
|
|
* Specifies how many messages will be shown in a folder by default. This number is set
|
|
* on each new folder and can be incremented with "Load more messages..." by the
|
|
* VISIBLE_LIMIT_INCREMENT
|
|
*/
|
|
public static int DEFAULT_VISIBLE_LIMIT = 25;
|
|
|
|
/**
|
|
* The maximum size of an attachment we're willing to download (either View or Save)
|
|
* Attachments that are base64 encoded (most) will be about 1.375x their actual size
|
|
* so we should probably factor that in. A 5MB attachment will generally be around
|
|
* 6.8MB downloaded but only 5MB saved.
|
|
*/
|
|
public static final int MAX_ATTACHMENT_DOWNLOAD_SIZE = (128 * 1024 * 1024);
|
|
|
|
|
|
/* How many times should K-9 try to deliver a message before giving up
|
|
* until the app is killed and restarted
|
|
*/
|
|
|
|
public static int MAX_SEND_ATTEMPTS = 5;
|
|
|
|
/**
|
|
* Max time (in millis) the wake lock will be held for when background sync is happening
|
|
*/
|
|
public static final int WAKE_LOCK_TIMEOUT = 600000;
|
|
|
|
public static final int MANUAL_WAKE_LOCK_TIMEOUT = 120000;
|
|
|
|
public static final int PUSH_WAKE_LOCK_TIMEOUT = 60000;
|
|
|
|
public static final int MAIL_SERVICE_WAKE_LOCK_TIMEOUT = 60000;
|
|
|
|
public static final int BOOT_RECEIVER_WAKE_LOCK_TIMEOUT = 60000;
|
|
|
|
/**
|
|
* Time the LED is on/off when blinking on new email notification
|
|
*/
|
|
public static final int NOTIFICATION_LED_ON_TIME = 500;
|
|
public static final int NOTIFICATION_LED_OFF_TIME = 2000;
|
|
|
|
public static final boolean NOTIFICATION_LED_WHILE_SYNCING = false;
|
|
public static final int NOTIFICATION_LED_FAST_ON_TIME = 100;
|
|
public static final int NOTIFICATION_LED_FAST_OFF_TIME = 100;
|
|
|
|
|
|
public static final int NOTIFICATION_LED_BLINK_SLOW = 0;
|
|
public static final int NOTIFICATION_LED_BLINK_FAST = 1;
|
|
|
|
|
|
|
|
public static final int NOTIFICATION_LED_FAILURE_COLOR = 0xffff0000;
|
|
|
|
// Must not conflict with an account number
|
|
public static final int FETCHING_EMAIL_NOTIFICATION = -5000;
|
|
public static final int SEND_FAILED_NOTIFICATION = -1500;
|
|
public static final int CERTIFICATE_EXCEPTION_NOTIFICATION_INCOMING = -2000;
|
|
public static final int CERTIFICATE_EXCEPTION_NOTIFICATION_OUTGOING = -2500;
|
|
public static final int CONNECTIVITY_ID = -3;
|
|
|
|
|
|
public static class Intents {
|
|
|
|
public static class EmailReceived {
|
|
public static final String ACTION_EMAIL_RECEIVED = "com.fsck.k9.intent.action.EMAIL_RECEIVED";
|
|
public static final String ACTION_EMAIL_DELETED = "com.fsck.k9.intent.action.EMAIL_DELETED";
|
|
public static final String ACTION_REFRESH_OBSERVER = "com.fsck.k9.intent.action.REFRESH_OBSERVER";
|
|
public static final String EXTRA_ACCOUNT = "com.fsck.k9.intent.extra.ACCOUNT";
|
|
public static final String EXTRA_FOLDER = "com.fsck.k9.intent.extra.FOLDER";
|
|
public static final String EXTRA_SENT_DATE = "com.fsck.k9.intent.extra.SENT_DATE";
|
|
public static final String EXTRA_FROM = "com.fsck.k9.intent.extra.FROM";
|
|
public static final String EXTRA_TO = "com.fsck.k9.intent.extra.TO";
|
|
public static final String EXTRA_CC = "com.fsck.k9.intent.extra.CC";
|
|
public static final String EXTRA_BCC = "com.fsck.k9.intent.extra.BCC";
|
|
public static final String EXTRA_SUBJECT = "com.fsck.k9.intent.extra.SUBJECT";
|
|
public static final String EXTRA_FROM_SELF = "com.fsck.k9.intent.extra.FROM_SELF";
|
|
}
|
|
|
|
public static class Share {
|
|
/*
|
|
* We don't want to use EmailReceived.EXTRA_FROM ("com.fsck.k9.intent.extra.FROM")
|
|
* because of different semantics (String array vs. string with comma separated
|
|
* email addresses)
|
|
*/
|
|
public static final String EXTRA_FROM = "com.fsck.k9.intent.extra.SENDER";
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Called throughout the application when the number of accounts has changed. This method
|
|
* enables or disables the Compose activity, the boot receiver and the service based on
|
|
* whether any accounts are configured.
|
|
*/
|
|
public static void setServicesEnabled(Context context) {
|
|
int acctLength = Preferences.getPreferences(context).getAvailableAccounts().size();
|
|
|
|
setServicesEnabled(context, acctLength > 0, null);
|
|
|
|
}
|
|
|
|
private static void setServicesEnabled(Context context, boolean enabled, Integer wakeLockId) {
|
|
|
|
PackageManager pm = context.getPackageManager();
|
|
|
|
if (!enabled && pm.getComponentEnabledSetting(new ComponentName(context, MailService.class)) ==
|
|
PackageManager.COMPONENT_ENABLED_STATE_ENABLED) {
|
|
/*
|
|
* If no accounts now exist but the service is still enabled we're about to disable it
|
|
* so we'll reschedule to kill off any existing alarms.
|
|
*/
|
|
MailService.actionReset(context, wakeLockId);
|
|
}
|
|
Class<?>[] classes = { MessageCompose.class, BootReceiver.class, MailService.class };
|
|
|
|
for (Class<?> clazz : classes) {
|
|
|
|
boolean alreadyEnabled = pm.getComponentEnabledSetting(new ComponentName(context, clazz)) ==
|
|
PackageManager.COMPONENT_ENABLED_STATE_ENABLED;
|
|
|
|
if (enabled != alreadyEnabled) {
|
|
pm.setComponentEnabledSetting(
|
|
new ComponentName(context, clazz),
|
|
enabled ? PackageManager.COMPONENT_ENABLED_STATE_ENABLED :
|
|
PackageManager.COMPONENT_ENABLED_STATE_DISABLED,
|
|
PackageManager.DONT_KILL_APP);
|
|
}
|
|
}
|
|
|
|
if (enabled && pm.getComponentEnabledSetting(new ComponentName(context, MailService.class)) ==
|
|
PackageManager.COMPONENT_ENABLED_STATE_ENABLED) {
|
|
/*
|
|
* And now if accounts do exist then we've just enabled the service and we want to
|
|
* schedule alarms for the new accounts.
|
|
*/
|
|
MailService.actionReset(context, wakeLockId);
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Register BroadcastReceivers programmaticaly because doing it from manifest
|
|
* would make K-9 auto-start. We don't want auto-start because the initialization
|
|
* sequence isn't safe while some events occur (SD card unmount).
|
|
*/
|
|
protected void registerReceivers() {
|
|
final StorageGoneReceiver receiver = new StorageGoneReceiver();
|
|
final IntentFilter filter = new IntentFilter();
|
|
filter.addAction(Intent.ACTION_MEDIA_EJECT);
|
|
filter.addAction(Intent.ACTION_MEDIA_UNMOUNTED);
|
|
filter.addDataScheme("file");
|
|
|
|
final BlockingQueue<Handler> queue = new SynchronousQueue<Handler>();
|
|
|
|
// starting a new thread to handle unmount events
|
|
new Thread(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
Looper.prepare();
|
|
try {
|
|
queue.put(new Handler());
|
|
} catch (InterruptedException e) {
|
|
Log.e(K9.LOG_TAG, "", e);
|
|
}
|
|
Looper.loop();
|
|
}
|
|
|
|
}, "Unmount-thread").start();
|
|
|
|
try {
|
|
final Handler storageGoneHandler = queue.take();
|
|
registerReceiver(receiver, filter, null, storageGoneHandler);
|
|
Log.i(K9.LOG_TAG, "Registered: unmount receiver");
|
|
} catch (InterruptedException e) {
|
|
Log.e(K9.LOG_TAG, "Unable to register unmount receiver", e);
|
|
}
|
|
|
|
registerReceiver(new ShutdownReceiver(), new IntentFilter(Intent.ACTION_SHUTDOWN));
|
|
Log.i(K9.LOG_TAG, "Registered: shutdown receiver");
|
|
}
|
|
|
|
public static void save(SharedPreferences.Editor editor) {
|
|
editor.putBoolean("enableDebugLogging", K9.DEBUG);
|
|
editor.putBoolean("enableSensitiveLogging", K9.DEBUG_SENSITIVE);
|
|
editor.putString("backgroundOperations", K9.backgroundOps.toString());
|
|
editor.putBoolean("animations", mAnimations);
|
|
editor.putBoolean("gesturesEnabled", mGesturesEnabled);
|
|
editor.putBoolean("useVolumeKeysForNavigation", mUseVolumeKeysForNavigation);
|
|
editor.putBoolean("useVolumeKeysForListNavigation", mUseVolumeKeysForListNavigation);
|
|
editor.putBoolean("mobileOptimizedLayout", mMobileOptimizedLayout);
|
|
editor.putBoolean("quietTimeEnabled", mQuietTimeEnabled);
|
|
editor.putString("quietTimeStarts", mQuietTimeStarts);
|
|
editor.putString("quietTimeEnds", mQuietTimeEnds);
|
|
|
|
editor.putBoolean("startIntegratedInbox", mStartIntegratedInbox);
|
|
editor.putBoolean("measureAccounts", mMeasureAccounts);
|
|
editor.putBoolean("countSearchMessages", mCountSearchMessages);
|
|
editor.putBoolean("messageListSenderAboveSubject", mMessageListSenderAboveSubject);
|
|
editor.putBoolean("hideSpecialAccounts", mHideSpecialAccounts);
|
|
editor.putInt("messageListPreviewLines", mMessageListPreviewLines);
|
|
editor.putBoolean("messageListCheckboxes", mMessageListCheckboxes);
|
|
editor.putBoolean("showCorrespondentNames", mShowCorrespondentNames);
|
|
editor.putBoolean("showContactName", mShowContactName);
|
|
editor.putBoolean("changeRegisteredNameColor", mChangeContactNameColor);
|
|
editor.putInt("registeredNameColor", mContactNameColor);
|
|
editor.putBoolean("messageViewFixedWidthFont", mMessageViewFixedWidthFont);
|
|
editor.putBoolean("messageViewReturnToList", mMessageViewReturnToList);
|
|
editor.putBoolean("messageViewShowNext", mMessageViewShowNext);
|
|
editor.putBoolean("wrapFolderNames", mWrapFolderNames);
|
|
|
|
editor.putBoolean("batchButtonsMarkRead", mBatchButtonsMarkRead);
|
|
editor.putBoolean("batchButtonsDelete", mBatchButtonsDelete);
|
|
editor.putBoolean("batchButtonsArchive", mBatchButtonsArchive);
|
|
editor.putBoolean("batchButtonsMove", mBatchButtonsMove);
|
|
editor.putBoolean("batchButtonsFlag", mBatchButtonsFlag);
|
|
editor.putBoolean("batchButtonsUnselect", mBatchButtonsUnselect);
|
|
|
|
editor.putString("language", language);
|
|
editor.putInt("theme", theme);
|
|
editor.putInt("messageViewTheme", messageViewTheme);
|
|
editor.putBoolean("useGalleryBugWorkaround", useGalleryBugWorkaround);
|
|
|
|
editor.putBoolean("confirmDelete", mConfirmDelete);
|
|
editor.putBoolean("confirmDeleteStarred", mConfirmDeleteStarred);
|
|
editor.putBoolean("confirmSpam", mConfirmSpam);
|
|
editor.putBoolean("confirmDeleteFromNotification", mConfirmDeleteFromNotification);
|
|
|
|
editor.putString("sortTypeEnum", mSortType.name());
|
|
editor.putBoolean("sortAscending", mSortAscending.get(mSortType));
|
|
|
|
editor.putString("notificationHideSubject", sNotificationHideSubject.toString());
|
|
editor.putString("notificationQuickDelete", sNotificationQuickDelete.toString());
|
|
|
|
editor.putString("attachmentdefaultpath", mAttachmentDefaultPath);
|
|
editor.putBoolean("useBackgroundAsUnreadIndicator", sUseBackgroundAsUnreadIndicator);
|
|
editor.putBoolean("threadedView", sThreadedViewEnabled);
|
|
editor.putString("splitViewMode", sSplitViewMode.name());
|
|
fontSizes.save(editor);
|
|
}
|
|
|
|
@Override
|
|
public void onCreate() {
|
|
maybeSetupStrictMode();
|
|
super.onCreate();
|
|
app = this;
|
|
|
|
galleryBuggy = checkForBuggyGallery();
|
|
|
|
checkCachedDatabaseVersion();
|
|
|
|
Preferences prefs = Preferences.getPreferences(this);
|
|
loadPrefs(prefs);
|
|
|
|
/*
|
|
* We have to give MimeMessage a temp directory because File.createTempFile(String, String)
|
|
* doesn't work in Android and MimeMessage does not have access to a Context.
|
|
*/
|
|
BinaryTempFileBody.setTempDirectory(getCacheDir());
|
|
|
|
/*
|
|
* Enable background sync of messages
|
|
*/
|
|
|
|
setServicesEnabled(this);
|
|
registerReceivers();
|
|
|
|
MessagingController.getInstance(this).addListener(new MessagingListener() {
|
|
private void broadcastIntent(String action, Account account, String folder, Message message) {
|
|
try {
|
|
Uri uri = Uri.parse("email://messages/" + account.getAccountNumber() + "/" + Uri.encode(folder) + "/" + Uri.encode(message.getUid()));
|
|
Intent intent = new Intent(action, uri);
|
|
intent.putExtra(K9.Intents.EmailReceived.EXTRA_ACCOUNT, account.getDescription());
|
|
intent.putExtra(K9.Intents.EmailReceived.EXTRA_FOLDER, folder);
|
|
intent.putExtra(K9.Intents.EmailReceived.EXTRA_SENT_DATE, message.getSentDate());
|
|
intent.putExtra(K9.Intents.EmailReceived.EXTRA_FROM, Address.toString(message.getFrom()));
|
|
intent.putExtra(K9.Intents.EmailReceived.EXTRA_TO, Address.toString(message.getRecipients(Message.RecipientType.TO)));
|
|
intent.putExtra(K9.Intents.EmailReceived.EXTRA_CC, Address.toString(message.getRecipients(Message.RecipientType.CC)));
|
|
intent.putExtra(K9.Intents.EmailReceived.EXTRA_BCC, Address.toString(message.getRecipients(Message.RecipientType.BCC)));
|
|
intent.putExtra(K9.Intents.EmailReceived.EXTRA_SUBJECT, message.getSubject());
|
|
intent.putExtra(K9.Intents.EmailReceived.EXTRA_FROM_SELF, account.isAnIdentity(message.getFrom()));
|
|
K9.this.sendBroadcast(intent);
|
|
if (K9.DEBUG)
|
|
Log.d(K9.LOG_TAG, "Broadcasted: action=" + action
|
|
+ " account=" + account.getDescription()
|
|
+ " folder=" + folder
|
|
+ " message uid=" + message.getUid()
|
|
);
|
|
|
|
} catch (MessagingException e) {
|
|
Log.w(K9.LOG_TAG, "Error: action=" + action
|
|
+ " account=" + account.getDescription()
|
|
+ " folder=" + folder
|
|
+ " message uid=" + message.getUid()
|
|
);
|
|
}
|
|
}
|
|
|
|
private void updateUnreadWidget() {
|
|
try {
|
|
UnreadWidgetProvider.updateUnreadCount(K9.this);
|
|
} catch (Exception e) {
|
|
if (K9.DEBUG) {
|
|
Log.e(LOG_TAG, "Error while updating unread widget(s)", e);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void synchronizeMailboxRemovedMessage(Account account, String folder, Message message) {
|
|
broadcastIntent(K9.Intents.EmailReceived.ACTION_EMAIL_DELETED, account, folder, message);
|
|
updateUnreadWidget();
|
|
}
|
|
|
|
@Override
|
|
public void messageDeleted(Account account, String folder, Message message) {
|
|
broadcastIntent(K9.Intents.EmailReceived.ACTION_EMAIL_DELETED, account, folder, message);
|
|
updateUnreadWidget();
|
|
}
|
|
|
|
@Override
|
|
public void synchronizeMailboxNewMessage(Account account, String folder, Message message) {
|
|
broadcastIntent(K9.Intents.EmailReceived.ACTION_EMAIL_RECEIVED, account, folder, message);
|
|
updateUnreadWidget();
|
|
}
|
|
|
|
@Override
|
|
public void folderStatusChanged(Account account, String folderName,
|
|
int unreadMessageCount) {
|
|
|
|
updateUnreadWidget();
|
|
|
|
// let observers know a change occurred
|
|
Intent intent = new Intent(K9.Intents.EmailReceived.ACTION_REFRESH_OBSERVER, null);
|
|
intent.putExtra(K9.Intents.EmailReceived.EXTRA_ACCOUNT, account.getDescription());
|
|
intent.putExtra(K9.Intents.EmailReceived.EXTRA_FOLDER, folderName);
|
|
K9.this.sendBroadcast(intent);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
notifyObservers();
|
|
}
|
|
|
|
/**
|
|
* Loads the last known database version of the accounts' databases from a
|
|
* {@link SharedPreference}.
|
|
*
|
|
* <p>
|
|
* If the stored version matches {@link LocalStore#DB_VERSION} we know that the databases are
|
|
* up to date.<br>
|
|
* Using {@code SharedPreferences} should be a lot faster than opening all SQLite databases to
|
|
* get the current database version.
|
|
* </p><p>
|
|
* See {@link UpgradeDatabases} for a detailed explanation of the database upgrade process.
|
|
* </p>
|
|
*
|
|
* @see #areDatabasesUpToDate()
|
|
*/
|
|
public void checkCachedDatabaseVersion() {
|
|
sDatabaseVersionCache = getSharedPreferences(DATABASE_VERSION_CACHE, MODE_PRIVATE);
|
|
|
|
int cachedVersion = sDatabaseVersionCache.getInt(KEY_LAST_ACCOUNT_DATABASE_VERSION, 0);
|
|
|
|
if (cachedVersion >= LocalStore.DB_VERSION) {
|
|
K9.setDatabasesUpToDate(false);
|
|
}
|
|
}
|
|
|
|
public static void loadPrefs(Preferences prefs) {
|
|
SharedPreferences sprefs = prefs.getPreferences();
|
|
DEBUG = sprefs.getBoolean("enableDebugLogging", false);
|
|
if (!DEBUG && Debug.isDebuggerConnected()) {
|
|
// If the debugger is attached, we're probably (surprise surprise) debugging something.
|
|
DEBUG = true;
|
|
Log.i(K9.LOG_TAG, "Debugger attached; enabling debug logging.");
|
|
}
|
|
DEBUG_SENSITIVE = sprefs.getBoolean("enableSensitiveLogging", false);
|
|
mAnimations = sprefs.getBoolean("animations", true);
|
|
mGesturesEnabled = sprefs.getBoolean("gesturesEnabled", false);
|
|
mUseVolumeKeysForNavigation = sprefs.getBoolean("useVolumeKeysForNavigation", false);
|
|
mUseVolumeKeysForListNavigation = sprefs.getBoolean("useVolumeKeysForListNavigation", false);
|
|
mStartIntegratedInbox = sprefs.getBoolean("startIntegratedInbox", false);
|
|
mMeasureAccounts = sprefs.getBoolean("measureAccounts", true);
|
|
mCountSearchMessages = sprefs.getBoolean("countSearchMessages", true);
|
|
mHideSpecialAccounts = sprefs.getBoolean("hideSpecialAccounts", false);
|
|
mMessageListSenderAboveSubject = sprefs.getBoolean("messageListSenderAboveSubject", false);
|
|
mMessageListCheckboxes = sprefs.getBoolean("messageListCheckboxes", false);
|
|
mMessageListPreviewLines = sprefs.getInt("messageListPreviewLines", 2);
|
|
|
|
mMobileOptimizedLayout = sprefs.getBoolean("mobileOptimizedLayout", false);
|
|
|
|
mQuietTimeEnabled = sprefs.getBoolean("quietTimeEnabled", false);
|
|
mQuietTimeStarts = sprefs.getString("quietTimeStarts", "21:00");
|
|
mQuietTimeEnds = sprefs.getString("quietTimeEnds", "7:00");
|
|
|
|
mShowCorrespondentNames = sprefs.getBoolean("showCorrespondentNames", true);
|
|
mShowContactName = sprefs.getBoolean("showContactName", false);
|
|
mChangeContactNameColor = sprefs.getBoolean("changeRegisteredNameColor", false);
|
|
mContactNameColor = sprefs.getInt("registeredNameColor", 0xff00008f);
|
|
mMessageViewFixedWidthFont = sprefs.getBoolean("messageViewFixedWidthFont", false);
|
|
mMessageViewReturnToList = sprefs.getBoolean("messageViewReturnToList", false);
|
|
mMessageViewShowNext = sprefs.getBoolean("messageViewShowNext", false);
|
|
mWrapFolderNames = sprefs.getBoolean("wrapFolderNames", false);
|
|
|
|
mBatchButtonsMarkRead = sprefs.getBoolean("batchButtonsMarkRead", true);
|
|
mBatchButtonsDelete = sprefs.getBoolean("batchButtonsDelete", true);
|
|
mBatchButtonsArchive = sprefs.getBoolean("batchButtonsArchive", true);
|
|
mBatchButtonsMove = sprefs.getBoolean("batchButtonsMove", true);
|
|
mBatchButtonsFlag = sprefs.getBoolean("batchButtonsFlag", true);
|
|
mBatchButtonsUnselect = sprefs.getBoolean("batchButtonsUnselect", true);
|
|
|
|
useGalleryBugWorkaround = sprefs.getBoolean("useGalleryBugWorkaround", K9.isGalleryBuggy());
|
|
|
|
mConfirmDelete = sprefs.getBoolean("confirmDelete", false);
|
|
mConfirmDeleteStarred = sprefs.getBoolean("confirmDeleteStarred", false);
|
|
mConfirmSpam = sprefs.getBoolean("confirmSpam", false);
|
|
mConfirmDeleteFromNotification = sprefs.getBoolean("confirmDeleteFromNotification", true);
|
|
|
|
try {
|
|
String value = sprefs.getString("sortTypeEnum", Account.DEFAULT_SORT_TYPE.name());
|
|
mSortType = SortType.valueOf(value);
|
|
} catch (Exception e) {
|
|
mSortType = Account.DEFAULT_SORT_TYPE;
|
|
}
|
|
|
|
boolean sortAscending = sprefs.getBoolean("sortAscending", Account.DEFAULT_SORT_ASCENDING);
|
|
mSortAscending.put(mSortType, sortAscending);
|
|
|
|
String notificationHideSubject = sprefs.getString("notificationHideSubject", null);
|
|
if (notificationHideSubject == null) {
|
|
// If the "notificationHideSubject" setting couldn't be found, the app was probably
|
|
// updated. Look for the old "keyguardPrivacy" setting and map it to the new enum.
|
|
sNotificationHideSubject = (sprefs.getBoolean("keyguardPrivacy", false)) ?
|
|
NotificationHideSubject.WHEN_LOCKED : NotificationHideSubject.NEVER;
|
|
} else {
|
|
sNotificationHideSubject = NotificationHideSubject.valueOf(notificationHideSubject);
|
|
}
|
|
|
|
String notificationQuickDelete = sprefs.getString("notificationQuickDelete", null);
|
|
if (notificationQuickDelete != null) {
|
|
sNotificationQuickDelete = NotificationQuickDelete.valueOf(notificationQuickDelete);
|
|
}
|
|
|
|
String splitViewMode = sprefs.getString("splitViewMode", null);
|
|
if (splitViewMode != null) {
|
|
sSplitViewMode = SplitViewMode.valueOf(splitViewMode);
|
|
}
|
|
|
|
mAttachmentDefaultPath = sprefs.getString("attachmentdefaultpath", Environment.getExternalStorageDirectory().toString());
|
|
sUseBackgroundAsUnreadIndicator = sprefs.getBoolean("useBackgroundAsUnreadIndicator", true);
|
|
sThreadedViewEnabled = sprefs.getBoolean("threadedView", true);
|
|
fontSizes.load(sprefs);
|
|
|
|
try {
|
|
setBackgroundOps(BACKGROUND_OPS.valueOf(sprefs.getString("backgroundOperations", "WHEN_CHECKED")));
|
|
} catch (Exception e) {
|
|
setBackgroundOps(BACKGROUND_OPS.WHEN_CHECKED);
|
|
}
|
|
|
|
K9.setK9Language(sprefs.getString("language", ""));
|
|
|
|
int theme = sprefs.getInt("theme", THEME_LIGHT);
|
|
|
|
// We used to save the resource ID of the theme. So convert that to the new format if
|
|
// necessary.
|
|
if (theme == THEME_DARK || theme == android.R.style.Theme) {
|
|
theme = THEME_DARK;
|
|
} else {
|
|
theme = THEME_LIGHT;
|
|
}
|
|
K9.setK9Theme(theme);
|
|
|
|
K9.setK9MessageViewTheme(sprefs.getInt("messageViewTheme", THEME_LIGHT));
|
|
}
|
|
|
|
private void maybeSetupStrictMode() {
|
|
if (!K9.DEVELOPER_MODE)
|
|
return;
|
|
|
|
try {
|
|
Class<?> strictMode = Class.forName("android.os.StrictMode");
|
|
Method enableDefaults = strictMode.getMethod("enableDefaults");
|
|
enableDefaults.invoke(strictMode);
|
|
}
|
|
|
|
catch (Exception e) {
|
|
// Discard , as it means we're not running on a device with strict mode
|
|
Log.v(K9.LOG_TAG, "Failed to turn on strict mode", e);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
* since Android invokes Application.onCreate() only after invoking all
|
|
* other components' onCreate(), here is a way to notify interested
|
|
* component that the application is available and ready
|
|
*/
|
|
protected void notifyObservers() {
|
|
for (final ApplicationAware aware : observers) {
|
|
if (K9.DEBUG) {
|
|
Log.v(K9.LOG_TAG, "Initializing observer: " + aware);
|
|
}
|
|
try {
|
|
aware.initializeComponent(this);
|
|
} catch (Exception e) {
|
|
Log.w(K9.LOG_TAG, "Failure when notifying " + aware, e);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Register a component to be notified when the {@link K9} instance is ready.
|
|
*
|
|
* @param component
|
|
* Never <code>null</code>.
|
|
*/
|
|
public static void registerApplicationAware(final ApplicationAware component) {
|
|
if (!observers.contains(component)) {
|
|
observers.add(component);
|
|
}
|
|
}
|
|
|
|
public static String getK9Language() {
|
|
return language;
|
|
}
|
|
|
|
public static void setK9Language(String nlanguage) {
|
|
language = nlanguage;
|
|
}
|
|
|
|
public static int getK9ThemeResourceId(int theme) {
|
|
return (theme == THEME_LIGHT) ? R.style.Theme_K9_Light : R.style.Theme_K9_Dark;
|
|
}
|
|
|
|
public static int getK9ThemeResourceId() {
|
|
return getK9ThemeResourceId(theme);
|
|
}
|
|
|
|
public static int getK9MessageViewTheme() {
|
|
return messageViewTheme;
|
|
}
|
|
|
|
public static int getK9Theme() {
|
|
return theme;
|
|
}
|
|
|
|
public static void setK9Theme(int ntheme) {
|
|
theme = ntheme;
|
|
}
|
|
|
|
public static void setK9MessageViewTheme(int nMessageViewTheme) {
|
|
messageViewTheme = nMessageViewTheme;
|
|
}
|
|
|
|
public static BACKGROUND_OPS getBackgroundOps() {
|
|
return backgroundOps;
|
|
}
|
|
|
|
public static boolean setBackgroundOps(BACKGROUND_OPS backgroundOps) {
|
|
BACKGROUND_OPS oldBackgroundOps = K9.backgroundOps;
|
|
K9.backgroundOps = backgroundOps;
|
|
return backgroundOps != oldBackgroundOps;
|
|
}
|
|
|
|
public static boolean setBackgroundOps(String nbackgroundOps) {
|
|
return setBackgroundOps(BACKGROUND_OPS.valueOf(nbackgroundOps));
|
|
}
|
|
|
|
public static boolean gesturesEnabled() {
|
|
return mGesturesEnabled;
|
|
}
|
|
|
|
public static void setGesturesEnabled(boolean gestures) {
|
|
mGesturesEnabled = gestures;
|
|
}
|
|
|
|
public static boolean useVolumeKeysForNavigationEnabled() {
|
|
return mUseVolumeKeysForNavigation;
|
|
}
|
|
|
|
public static void setUseVolumeKeysForNavigation(boolean volume) {
|
|
mUseVolumeKeysForNavigation = volume;
|
|
}
|
|
|
|
public static boolean useVolumeKeysForListNavigationEnabled() {
|
|
return mUseVolumeKeysForListNavigation;
|
|
}
|
|
|
|
public static void setUseVolumeKeysForListNavigation(boolean enabled) {
|
|
mUseVolumeKeysForListNavigation = enabled;
|
|
}
|
|
|
|
public static boolean mobileOptimizedLayout() {
|
|
return mMobileOptimizedLayout;
|
|
}
|
|
|
|
public static void setMobileOptimizedLayout(boolean mobileOptimizedLayout) {
|
|
mMobileOptimizedLayout = mobileOptimizedLayout;
|
|
}
|
|
|
|
public static boolean getQuietTimeEnabled() {
|
|
return mQuietTimeEnabled;
|
|
}
|
|
|
|
public static void setQuietTimeEnabled(boolean quietTimeEnabled) {
|
|
mQuietTimeEnabled = quietTimeEnabled;
|
|
}
|
|
|
|
public static String getQuietTimeStarts() {
|
|
return mQuietTimeStarts;
|
|
}
|
|
|
|
public static void setQuietTimeStarts(String quietTimeStarts) {
|
|
mQuietTimeStarts = quietTimeStarts;
|
|
}
|
|
|
|
public static String getQuietTimeEnds() {
|
|
return mQuietTimeEnds;
|
|
}
|
|
|
|
public static void setQuietTimeEnds(String quietTimeEnds) {
|
|
mQuietTimeEnds = quietTimeEnds;
|
|
}
|
|
|
|
|
|
public static boolean isQuietTime() {
|
|
if (!mQuietTimeEnabled) {
|
|
return false;
|
|
}
|
|
|
|
Time time = new Time();
|
|
time.setToNow();
|
|
Integer startHour = Integer.parseInt(mQuietTimeStarts.split(":")[0]);
|
|
Integer startMinute = Integer.parseInt(mQuietTimeStarts.split(":")[1]);
|
|
Integer endHour = Integer.parseInt(mQuietTimeEnds.split(":")[0]);
|
|
Integer endMinute = Integer.parseInt(mQuietTimeEnds.split(":")[1]);
|
|
|
|
Integer now = (time.hour * 60) + time.minute;
|
|
Integer quietStarts = startHour * 60 + startMinute;
|
|
Integer quietEnds = endHour * 60 + endMinute;
|
|
|
|
// If start and end times are the same, we're never quiet
|
|
if (quietStarts.equals(quietEnds)) {
|
|
return false;
|
|
}
|
|
|
|
|
|
// 21:00 - 05:00 means we want to be quiet if it's after 9 or before 5
|
|
if (quietStarts > quietEnds) {
|
|
// if it's 22:00 or 03:00 but not 8:00
|
|
if (now >= quietStarts || now <= quietEnds) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// 01:00 - 05:00
|
|
else {
|
|
|
|
// if it' 2:00 or 4:00 but not 8:00 or 0:00
|
|
if (now >= quietStarts && now <= quietEnds) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
public static boolean startIntegratedInbox() {
|
|
return mStartIntegratedInbox;
|
|
}
|
|
|
|
public static void setStartIntegratedInbox(boolean startIntegratedInbox) {
|
|
mStartIntegratedInbox = startIntegratedInbox;
|
|
}
|
|
|
|
public static boolean showAnimations() {
|
|
return mAnimations;
|
|
}
|
|
|
|
public static void setAnimations(boolean animations) {
|
|
mAnimations = animations;
|
|
}
|
|
|
|
public static int messageListPreviewLines() {
|
|
return mMessageListPreviewLines;
|
|
}
|
|
|
|
public static void setMessageListPreviewLines(int lines) {
|
|
mMessageListPreviewLines = lines;
|
|
}
|
|
|
|
|
|
public static boolean messageListCheckboxes() {
|
|
return mMessageListCheckboxes;
|
|
}
|
|
|
|
public static void setMessageListCheckboxes(boolean checkboxes) {
|
|
mMessageListCheckboxes = checkboxes;
|
|
}
|
|
|
|
public static boolean showCorrespondentNames() {
|
|
return mShowCorrespondentNames;
|
|
}
|
|
|
|
public static boolean messageListSenderAboveSubject() {
|
|
return mMessageListSenderAboveSubject;
|
|
}
|
|
|
|
public static void setMessageListSenderAboveSubject(boolean sender) {
|
|
mMessageListSenderAboveSubject = sender;
|
|
}
|
|
public static void setShowCorrespondentNames(boolean showCorrespondentNames) {
|
|
mShowCorrespondentNames = showCorrespondentNames;
|
|
}
|
|
|
|
public static boolean showContactName() {
|
|
return mShowContactName;
|
|
}
|
|
|
|
public static void setShowContactName(boolean showContactName) {
|
|
mShowContactName = showContactName;
|
|
}
|
|
|
|
public static boolean changeContactNameColor() {
|
|
return mChangeContactNameColor;
|
|
}
|
|
|
|
public static void setChangeContactNameColor(boolean changeContactNameColor) {
|
|
mChangeContactNameColor = changeContactNameColor;
|
|
}
|
|
|
|
public static int getContactNameColor() {
|
|
return mContactNameColor;
|
|
}
|
|
|
|
public static void setContactNameColor(int contactNameColor) {
|
|
mContactNameColor = contactNameColor;
|
|
}
|
|
|
|
public static boolean messageViewFixedWidthFont() {
|
|
return mMessageViewFixedWidthFont;
|
|
}
|
|
|
|
public static void setMessageViewFixedWidthFont(boolean fixed) {
|
|
mMessageViewFixedWidthFont = fixed;
|
|
}
|
|
|
|
public static boolean messageViewReturnToList() {
|
|
return mMessageViewReturnToList;
|
|
}
|
|
|
|
public static void setMessageViewReturnToList(boolean messageViewReturnToList) {
|
|
mMessageViewReturnToList = messageViewReturnToList;
|
|
}
|
|
|
|
public static boolean messageViewShowNext() {
|
|
return mMessageViewShowNext;
|
|
}
|
|
|
|
public static void setMessageViewShowNext(boolean messageViewShowNext) {
|
|
mMessageViewShowNext = messageViewShowNext;
|
|
}
|
|
|
|
public static Method getMethod(Class<?> classObject, String methodName) {
|
|
try {
|
|
return classObject.getMethod(methodName, boolean.class);
|
|
} catch (NoSuchMethodException e) {
|
|
Log.i(K9.LOG_TAG, "Can't get method " +
|
|
classObject.toString() + "." + methodName);
|
|
} catch (Exception e) {
|
|
Log.e(K9.LOG_TAG, "Error while using reflection to get method " +
|
|
classObject.toString() + "." + methodName, e);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static FontSizes getFontSizes() {
|
|
return fontSizes;
|
|
}
|
|
|
|
public static boolean measureAccounts() {
|
|
return mMeasureAccounts;
|
|
}
|
|
|
|
public static void setMeasureAccounts(boolean measureAccounts) {
|
|
mMeasureAccounts = measureAccounts;
|
|
}
|
|
|
|
public static boolean countSearchMessages() {
|
|
return mCountSearchMessages;
|
|
}
|
|
|
|
public static void setCountSearchMessages(boolean countSearchMessages) {
|
|
mCountSearchMessages = countSearchMessages;
|
|
}
|
|
|
|
public static boolean isHideSpecialAccounts() {
|
|
return mHideSpecialAccounts;
|
|
}
|
|
|
|
public static void setHideSpecialAccounts(boolean hideSpecialAccounts) {
|
|
mHideSpecialAccounts = hideSpecialAccounts;
|
|
}
|
|
|
|
public static boolean useGalleryBugWorkaround() {
|
|
return useGalleryBugWorkaround;
|
|
}
|
|
|
|
public static void setUseGalleryBugWorkaround(boolean useGalleryBugWorkaround) {
|
|
K9.useGalleryBugWorkaround = useGalleryBugWorkaround;
|
|
}
|
|
|
|
public static boolean isGalleryBuggy() {
|
|
return galleryBuggy;
|
|
}
|
|
|
|
public static boolean confirmDelete() {
|
|
return mConfirmDelete;
|
|
}
|
|
|
|
public static void setConfirmDelete(final boolean confirm) {
|
|
mConfirmDelete = confirm;
|
|
}
|
|
|
|
public static boolean confirmDeleteStarred() {
|
|
return mConfirmDeleteStarred;
|
|
}
|
|
|
|
public static void setConfirmDeleteStarred(final boolean confirm) {
|
|
mConfirmDeleteStarred = confirm;
|
|
}
|
|
|
|
public static boolean confirmSpam() {
|
|
return mConfirmSpam;
|
|
}
|
|
|
|
public static void setConfirmSpam(final boolean confirm) {
|
|
mConfirmSpam = confirm;
|
|
}
|
|
|
|
public static boolean confirmDeleteFromNotification() {
|
|
return mConfirmDeleteFromNotification;
|
|
}
|
|
|
|
public static void setConfirmDeleteFromNotification(final boolean confirm) {
|
|
mConfirmDeleteFromNotification = confirm;
|
|
}
|
|
|
|
public static NotificationHideSubject getNotificationHideSubject() {
|
|
return sNotificationHideSubject;
|
|
}
|
|
|
|
public static void setNotificationHideSubject(final NotificationHideSubject mode) {
|
|
sNotificationHideSubject = mode;
|
|
}
|
|
|
|
public static NotificationQuickDelete getNotificationQuickDeleteBehaviour() {
|
|
return sNotificationQuickDelete;
|
|
}
|
|
|
|
public static void setNotificationQuickDeleteBehaviour(final NotificationQuickDelete mode) {
|
|
sNotificationQuickDelete = mode;
|
|
}
|
|
|
|
public static boolean batchButtonsMarkRead() {
|
|
return mBatchButtonsMarkRead;
|
|
}
|
|
public static void setBatchButtonsMarkRead(final boolean state) {
|
|
mBatchButtonsMarkRead = state;
|
|
}
|
|
|
|
public static boolean batchButtonsDelete() {
|
|
return mBatchButtonsDelete;
|
|
}
|
|
public static void setBatchButtonsDelete(final boolean state) {
|
|
mBatchButtonsDelete = state;
|
|
}
|
|
|
|
public static boolean batchButtonsArchive() {
|
|
return mBatchButtonsArchive;
|
|
}
|
|
public static void setBatchButtonsArchive(final boolean state) {
|
|
mBatchButtonsArchive = state;
|
|
}
|
|
|
|
public static boolean batchButtonsMove() {
|
|
return mBatchButtonsMove;
|
|
}
|
|
public static void setBatchButtonsMove(final boolean state) {
|
|
mBatchButtonsMove = state;
|
|
}
|
|
|
|
public static boolean batchButtonsFlag() {
|
|
return mBatchButtonsFlag;
|
|
}
|
|
public static void setBatchButtonsFlag(final boolean state) {
|
|
mBatchButtonsFlag = state;
|
|
}
|
|
|
|
public static boolean batchButtonsUnselect() {
|
|
return mBatchButtonsUnselect;
|
|
}
|
|
public static void setBatchButtonsUnselect(final boolean state) {
|
|
mBatchButtonsUnselect = state;
|
|
}
|
|
|
|
/**
|
|
* Check if this system contains a buggy Gallery 3D package.
|
|
*
|
|
* We have to work around the fact that those Gallery versions won't show
|
|
* any images or videos when the pick intent is used with a MIME type other
|
|
* than image/* or video/*. See issue 1186.
|
|
*
|
|
* @return true, if a buggy Gallery 3D package was found. False, otherwise.
|
|
*/
|
|
private boolean checkForBuggyGallery() {
|
|
try {
|
|
PackageInfo pi = getPackageManager().getPackageInfo("com.cooliris.media", 0);
|
|
|
|
return (pi.versionCode == 30682);
|
|
} catch (NameNotFoundException e) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public static boolean wrapFolderNames() {
|
|
return mWrapFolderNames;
|
|
}
|
|
public static void setWrapFolderNames(final boolean state) {
|
|
mWrapFolderNames = state;
|
|
}
|
|
|
|
public static String getAttachmentDefaultPath() {
|
|
return mAttachmentDefaultPath;
|
|
}
|
|
|
|
public static void setAttachmentDefaultPath(String attachmentDefaultPath) {
|
|
K9.mAttachmentDefaultPath = attachmentDefaultPath;
|
|
}
|
|
|
|
public static synchronized SortType getSortType() {
|
|
return mSortType;
|
|
}
|
|
|
|
public static synchronized void setSortType(SortType sortType) {
|
|
mSortType = sortType;
|
|
}
|
|
|
|
public static synchronized boolean isSortAscending(SortType sortType) {
|
|
if (mSortAscending.get(sortType) == null) {
|
|
mSortAscending.put(sortType, sortType.isDefaultAscending());
|
|
}
|
|
return mSortAscending.get(sortType);
|
|
}
|
|
|
|
public static synchronized void setSortAscending(SortType sortType, boolean sortAscending) {
|
|
mSortAscending.put(sortType, sortAscending);
|
|
}
|
|
|
|
public static synchronized boolean useBackgroundAsUnreadIndicator() {
|
|
return sUseBackgroundAsUnreadIndicator;
|
|
}
|
|
|
|
public static synchronized void setUseBackgroundAsUnreadIndicator(boolean enabled) {
|
|
sUseBackgroundAsUnreadIndicator = enabled;
|
|
}
|
|
|
|
public static synchronized boolean isThreadedViewEnabled() {
|
|
return sThreadedViewEnabled;
|
|
}
|
|
|
|
public static synchronized void setThreadedViewEnabled(boolean enable) {
|
|
sThreadedViewEnabled = enable;
|
|
}
|
|
|
|
public static synchronized SplitViewMode getSplitViewMode() {
|
|
return sSplitViewMode;
|
|
}
|
|
|
|
public static synchronized void setSplitViewMode(SplitViewMode mode) {
|
|
sSplitViewMode = mode;
|
|
}
|
|
|
|
/**
|
|
* Check if we already know whether all databases are using the current database schema.
|
|
*
|
|
* <p>
|
|
* This method is only used for optimizations. If it returns {@code true} we can be certain that
|
|
* getting a {@link LocalStore} instance won't trigger a schema upgrade.
|
|
* </p>
|
|
*
|
|
* @return {@code true}, if we know that all databases are using the current database schema.
|
|
* {@code false}, otherwise.
|
|
*/
|
|
public static synchronized boolean areDatabasesUpToDate() {
|
|
return sDatabasesUpToDate;
|
|
}
|
|
|
|
/**
|
|
* Remember that all account databases are using the most recent database schema.
|
|
*
|
|
* @param save
|
|
* Whether or not to write the current database version to the
|
|
* {@code SharedPreferences} {@link #DATABASE_VERSION_CACHE}.
|
|
*
|
|
* @see #areDatabasesUpToDate()
|
|
*/
|
|
public static synchronized void setDatabasesUpToDate(boolean save) {
|
|
sDatabasesUpToDate = true;
|
|
|
|
if (save) {
|
|
Editor editor = sDatabaseVersionCache.edit();
|
|
editor.putInt(KEY_LAST_ACCOUNT_DATABASE_VERSION, LocalStore.DB_VERSION);
|
|
editor.commit();
|
|
}
|
|
}
|
|
}
|