Examples with Preferences com.fsck.k9.Preferences used on opensource projects

Example 31 with Preferences

use of com.fsck.k9.Preferences in project k-9 by k9mail.

the class NotificationActionService method startService.

@Override
public int startService(Intent intent, int startId) {
    Timber.i("NotificationActionService started with startId = %d", startId);
    String accountUuid = intent.getStringExtra(EXTRA_ACCOUNT_UUID);
    Preferences preferences = Preferences.getPreferences(this);
    Account account = preferences.getAccount(accountUuid);
    if (account == null) {
        Timber.w("Could not find account for notification action.");
        return START_NOT_STICKY;
    }
    MessagingController controller = MessagingController.getInstance(getApplication());
    String action = intent.getAction();
    if (ACTION_MARK_AS_READ.equals(action)) {
        markMessagesAsRead(intent, account, controller);
    } else if (ACTION_DELETE.equals(action)) {
        deleteMessages(intent, controller);
    } else if (ACTION_ARCHIVE.equals(action)) {
        archiveMessages(intent, account, controller);
    } else if (ACTION_SPAM.equals(action)) {
        markMessageAsSpam(intent, account, controller);
    } else if (ACTION_DISMISS.equals(action)) {
        Timber.i("Notification dismissed");
    }
    cancelNotifications(intent, account, controller);
    return START_NOT_STICKY;
}

Example 32 with Preferences

use of com.fsck.k9.Preferences in project k-9 by k9mail.

the class MigrationTest method getNewAccount.

private Account getNewAccount() {
    Preferences preferences = Preferences.getPreferences(RuntimeEnvironment.application);
    //FIXME: This is a hack to get Preferences into a state where it's safe to call newAccount()
    preferences.loadAccounts();
    return preferences.newAccount();
}

Example 33 with Preferences

use of com.fsck.k9.Preferences in project k-9 by k9mail.

the class AccountSettings method onCreate.

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    String accountUuid = getIntent().getStringExtra(EXTRA_ACCOUNT);
    mAccount = Preferences.getPreferences(this).getAccount(accountUuid);
    try {
        final Store store = mAccount.getRemoteStore();
        mIsMoveCapable = store.isMoveCapable();
        mIsPushCapable = store.isPushCapable();
        mIsExpungeCapable = store.isExpungeCapable();
        mIsSeenFlagSupported = store.isSeenFlagSupported();
    } catch (Exception e) {
        Timber.e(e, "Could not get remote store");
    }
    addPreferencesFromResource(R.xml.account_settings_preferences);
    mMainScreen = (PreferenceScreen) findPreference(PREFERENCE_SCREEN_MAIN);
    mAccountDescription = (EditTextPreference) findPreference(PREFERENCE_DESCRIPTION);
    mAccountDescription.setSummary(mAccount.getDescription());
    mAccountDescription.setText(mAccount.getDescription());
    mAccountDescription.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

        public boolean onPreferenceChange(Preference preference, Object newValue) {
            final String summary = newValue.toString();
            mAccountDescription.setSummary(summary);
            mAccountDescription.setText(summary);
            return false;
        }
    });
    mMarkMessageAsReadOnView = (CheckBoxPreference) findPreference(PREFERENCE_MARK_MESSAGE_AS_READ_ON_VIEW);
    mMarkMessageAsReadOnView.setChecked(mAccount.isMarkMessageAsReadOnView());
    mMessageFormat = (ListPreference) findPreference(PREFERENCE_MESSAGE_FORMAT);
    mMessageFormat.setValue(mAccount.getMessageFormat().name());
    mMessageFormat.setSummary(mMessageFormat.getEntry());
    mMessageFormat.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

        public boolean onPreferenceChange(Preference preference, Object newValue) {
            final String summary = newValue.toString();
            int index = mMessageFormat.findIndexOfValue(summary);
            mMessageFormat.setSummary(mMessageFormat.getEntries()[index]);
            mMessageFormat.setValue(summary);
            return false;
        }
    });
    mAlwaysShowCcBcc = (CheckBoxPreference) findPreference(PREFERENCE_ALWAYS_SHOW_CC_BCC);
    mAlwaysShowCcBcc.setChecked(mAccount.isAlwaysShowCcBcc());
    mMessageReadReceipt = (CheckBoxPreference) findPreference(PREFERENCE_MESSAGE_READ_RECEIPT);
    mMessageReadReceipt.setChecked(mAccount.isMessageReadReceiptAlways());
    mAccountQuotePrefix = (EditTextPreference) findPreference(PREFERENCE_QUOTE_PREFIX);
    mAccountQuotePrefix.setSummary(mAccount.getQuotePrefix());
    mAccountQuotePrefix.setText(mAccount.getQuotePrefix());
    mAccountQuotePrefix.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

        @Override
        public boolean onPreferenceChange(Preference preference, Object newValue) {
            final String value = newValue.toString();
            mAccountQuotePrefix.setSummary(value);
            mAccountQuotePrefix.setText(value);
            return false;
        }
    });
    mAccountDefaultQuotedTextShown = (CheckBoxPreference) findPreference(PREFERENCE_DEFAULT_QUOTED_TEXT_SHOWN);
    mAccountDefaultQuotedTextShown.setChecked(mAccount.isDefaultQuotedTextShown());
    mReplyAfterQuote = (CheckBoxPreference) findPreference(PREFERENCE_REPLY_AFTER_QUOTE);
    mReplyAfterQuote.setChecked(mAccount.isReplyAfterQuote());
    mStripSignature = (CheckBoxPreference) findPreference(PREFERENCE_STRIP_SIGNATURE);
    mStripSignature.setChecked(mAccount.isStripSignature());
    mComposingScreen = (PreferenceScreen) findPreference(PREFERENCE_SCREEN_COMPOSING);
    Preference.OnPreferenceChangeListener quoteStyleListener = new Preference.OnPreferenceChangeListener() {

        @Override
        public boolean onPreferenceChange(Preference preference, Object newValue) {
            final QuoteStyle style = QuoteStyle.valueOf(newValue.toString());
            int index = mQuoteStyle.findIndexOfValue(newValue.toString());
            mQuoteStyle.setSummary(mQuoteStyle.getEntries()[index]);
            if (style == QuoteStyle.PREFIX) {
                mComposingScreen.addPreference(mAccountQuotePrefix);
                mComposingScreen.addPreference(mReplyAfterQuote);
            } else if (style == QuoteStyle.HEADER) {
                mComposingScreen.removePreference(mAccountQuotePrefix);
                mComposingScreen.removePreference(mReplyAfterQuote);
            }
            return true;
        }
    };
    mQuoteStyle = (ListPreference) findPreference(PREFERENCE_QUOTE_STYLE);
    mQuoteStyle.setValue(mAccount.getQuoteStyle().name());
    mQuoteStyle.setSummary(mQuoteStyle.getEntry());
    mQuoteStyle.setOnPreferenceChangeListener(quoteStyleListener);
    // Call the onPreferenceChange() handler on startup to update the Preference dialogue based
    // upon the existing quote style setting.
    quoteStyleListener.onPreferenceChange(mQuoteStyle, mAccount.getQuoteStyle().name());
    mCheckFrequency = (ListPreference) findPreference(PREFERENCE_FREQUENCY);
    mCheckFrequency.setValue(String.valueOf(mAccount.getAutomaticCheckIntervalMinutes()));
    mCheckFrequency.setSummary(mCheckFrequency.getEntry());
    mCheckFrequency.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

        public boolean onPreferenceChange(Preference preference, Object newValue) {
            final String summary = newValue.toString();
            int index = mCheckFrequency.findIndexOfValue(summary);
            mCheckFrequency.setSummary(mCheckFrequency.getEntries()[index]);
            mCheckFrequency.setValue(summary);
            return false;
        }
    });
    mDisplayMode = (ListPreference) findPreference(PREFERENCE_DISPLAY_MODE);
    mDisplayMode.setValue(mAccount.getFolderDisplayMode().name());
    mDisplayMode.setSummary(mDisplayMode.getEntry());
    mDisplayMode.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

        public boolean onPreferenceChange(Preference preference, Object newValue) {
            final String summary = newValue.toString();
            int index = mDisplayMode.findIndexOfValue(summary);
            mDisplayMode.setSummary(mDisplayMode.getEntries()[index]);
            mDisplayMode.setValue(summary);
            return false;
        }
    });
    mSyncMode = (ListPreference) findPreference(PREFERENCE_SYNC_MODE);
    mSyncMode.setValue(mAccount.getFolderSyncMode().name());
    mSyncMode.setSummary(mSyncMode.getEntry());
    mSyncMode.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

        public boolean onPreferenceChange(Preference preference, Object newValue) {
            final String summary = newValue.toString();
            int index = mSyncMode.findIndexOfValue(summary);
            mSyncMode.setSummary(mSyncMode.getEntries()[index]);
            mSyncMode.setValue(summary);
            return false;
        }
    });
    mTargetMode = (ListPreference) findPreference(PREFERENCE_TARGET_MODE);
    mTargetMode.setValue(mAccount.getFolderTargetMode().name());
    mTargetMode.setSummary(mTargetMode.getEntry());
    mTargetMode.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

        public boolean onPreferenceChange(Preference preference, Object newValue) {
            final String summary = newValue.toString();
            int index = mTargetMode.findIndexOfValue(summary);
            mTargetMode.setSummary(mTargetMode.getEntries()[index]);
            mTargetMode.setValue(summary);
            return false;
        }
    });
    mDeletePolicy = (ListPreference) findPreference(PREFERENCE_DELETE_POLICY);
    if (!mIsSeenFlagSupported) {
        removeListEntry(mDeletePolicy, DeletePolicy.MARK_AS_READ.preferenceString());
    }
    mDeletePolicy.setValue(mAccount.getDeletePolicy().preferenceString());
    mDeletePolicy.setSummary(mDeletePolicy.getEntry());
    mDeletePolicy.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

        public boolean onPreferenceChange(Preference preference, Object newValue) {
            final String summary = newValue.toString();
            int index = mDeletePolicy.findIndexOfValue(summary);
            mDeletePolicy.setSummary(mDeletePolicy.getEntries()[index]);
            mDeletePolicy.setValue(summary);
            return false;
        }
    });
    mExpungePolicy = (ListPreference) findPreference(PREFERENCE_EXPUNGE_POLICY);
    if (mIsExpungeCapable) {
        mExpungePolicy.setValue(mAccount.getExpungePolicy().name());
        mExpungePolicy.setSummary(mExpungePolicy.getEntry());
        mExpungePolicy.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

            public boolean onPreferenceChange(Preference preference, Object newValue) {
                final String summary = newValue.toString();
                int index = mExpungePolicy.findIndexOfValue(summary);
                mExpungePolicy.setSummary(mExpungePolicy.getEntries()[index]);
                mExpungePolicy.setValue(summary);
                return false;
            }
        });
    } else {
        ((PreferenceScreen) findPreference(PREFERENCE_SCREEN_INCOMING)).removePreference(mExpungePolicy);
    }
    mSyncRemoteDeletions = (CheckBoxPreference) findPreference(PREFERENCE_SYNC_REMOTE_DELETIONS);
    mSyncRemoteDeletions.setChecked(mAccount.syncRemoteDeletions());
    mSearchableFolders = (ListPreference) findPreference(PREFERENCE_SEARCHABLE_FOLDERS);
    mSearchableFolders.setValue(mAccount.getSearchableFolders().name());
    mSearchableFolders.setSummary(mSearchableFolders.getEntry());
    mSearchableFolders.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

        public boolean onPreferenceChange(Preference preference, Object newValue) {
            final String summary = newValue.toString();
            int index = mSearchableFolders.findIndexOfValue(summary);
            mSearchableFolders.setSummary(mSearchableFolders.getEntries()[index]);
            mSearchableFolders.setValue(summary);
            return false;
        }
    });
    mDisplayCount = (ListPreference) findPreference(PREFERENCE_DISPLAY_COUNT);
    mDisplayCount.setValue(String.valueOf(mAccount.getDisplayCount()));
    mDisplayCount.setSummary(mDisplayCount.getEntry());
    mDisplayCount.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

        public boolean onPreferenceChange(Preference preference, Object newValue) {
            final String summary = newValue.toString();
            int index = mDisplayCount.findIndexOfValue(summary);
            mDisplayCount.setSummary(mDisplayCount.getEntries()[index]);
            mDisplayCount.setValue(summary);
            return false;
        }
    });
    mMessageAge = (ListPreference) findPreference(PREFERENCE_MESSAGE_AGE);
    if (!mAccount.isSearchByDateCapable()) {
        ((PreferenceScreen) findPreference(PREFERENCE_SCREEN_INCOMING)).removePreference(mMessageAge);
    } else {
        mMessageAge.setValue(String.valueOf(mAccount.getMaximumPolledMessageAge()));
        mMessageAge.setSummary(mMessageAge.getEntry());
        mMessageAge.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

            public boolean onPreferenceChange(Preference preference, Object newValue) {
                final String summary = newValue.toString();
                int index = mMessageAge.findIndexOfValue(summary);
                mMessageAge.setSummary(mMessageAge.getEntries()[index]);
                mMessageAge.setValue(summary);
                return false;
            }
        });
    }
    mMessageSize = (ListPreference) findPreference(PREFERENCE_MESSAGE_SIZE);
    mMessageSize.setValue(String.valueOf(mAccount.getMaximumAutoDownloadMessageSize()));
    mMessageSize.setSummary(mMessageSize.getEntry());
    mMessageSize.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

        public boolean onPreferenceChange(Preference preference, Object newValue) {
            final String summary = newValue.toString();
            int index = mMessageSize.findIndexOfValue(summary);
            mMessageSize.setSummary(mMessageSize.getEntries()[index]);
            mMessageSize.setValue(summary);
            return false;
        }
    });
    mAccountDefault = (CheckBoxPreference) findPreference(PREFERENCE_DEFAULT);
    mAccountDefault.setChecked(mAccount.equals(Preferences.getPreferences(this).getDefaultAccount()));
    mAccountShowPictures = (ListPreference) findPreference(PREFERENCE_SHOW_PICTURES);
    mAccountShowPictures.setValue("" + mAccount.getShowPictures());
    mAccountShowPictures.setSummary(mAccountShowPictures.getEntry());
    mAccountShowPictures.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

        public boolean onPreferenceChange(Preference preference, Object newValue) {
            final String summary = newValue.toString();
            int index = mAccountShowPictures.findIndexOfValue(summary);
            mAccountShowPictures.setSummary(mAccountShowPictures.getEntries()[index]);
            mAccountShowPictures.setValue(summary);
            return false;
        }
    });
    mLocalStorageProvider = (ListPreference) findPreference(PREFERENCE_LOCAL_STORAGE_PROVIDER);
    {
        final Map<String, String> providers;
        providers = StorageManager.getInstance(this).getAvailableProviders();
        int i = 0;
        final String[] providerLabels = new String[providers.size()];
        final String[] providerIds = new String[providers.size()];
        for (final Map.Entry<String, String> entry : providers.entrySet()) {
            providerIds[i] = entry.getKey();
            providerLabels[i] = entry.getValue();
            i++;
        }
        mLocalStorageProvider.setEntryValues(providerIds);
        mLocalStorageProvider.setEntries(providerLabels);
        mLocalStorageProvider.setValue(mAccount.getLocalStorageProviderId());
        mLocalStorageProvider.setSummary(providers.get(mAccount.getLocalStorageProviderId()));
        mLocalStorageProvider.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

            public boolean onPreferenceChange(Preference preference, Object newValue) {
                mLocalStorageProvider.setSummary(providers.get(newValue));
                return true;
            }
        });
    }
    // IMAP-specific preferences
    mSearchScreen = (PreferenceScreen) findPreference(PREFERENCE_SCREEN_SEARCH);
    mCloudSearchEnabled = (CheckBoxPreference) findPreference(PREFERENCE_CLOUD_SEARCH_ENABLED);
    mRemoteSearchNumResults = (ListPreference) findPreference(PREFERENCE_REMOTE_SEARCH_NUM_RESULTS);
    mRemoteSearchNumResults.setOnPreferenceChangeListener(new OnPreferenceChangeListener() {

        public boolean onPreferenceChange(Preference pref, Object newVal) {
            updateRemoteSearchLimit((String) newVal);
            return true;
        }
    });
    //mRemoteSearchFullText = (CheckBoxPreference) findPreference(PREFERENCE_REMOTE_SEARCH_FULL_TEXT);
    mPushPollOnConnect = (CheckBoxPreference) findPreference(PREFERENCE_PUSH_POLL_ON_CONNECT);
    mIdleRefreshPeriod = (ListPreference) findPreference(PREFERENCE_IDLE_REFRESH_PERIOD);
    mMaxPushFolders = (ListPreference) findPreference(PREFERENCE_MAX_PUSH_FOLDERS);
    if (mIsPushCapable) {
        mPushPollOnConnect.setChecked(mAccount.isPushPollOnConnect());
        mCloudSearchEnabled.setChecked(mAccount.allowRemoteSearch());
        String searchNumResults = Integer.toString(mAccount.getRemoteSearchNumResults());
        mRemoteSearchNumResults.setValue(searchNumResults);
        updateRemoteSearchLimit(searchNumResults);
        //mRemoteSearchFullText.setChecked(mAccount.isRemoteSearchFullText());
        mIdleRefreshPeriod.setValue(String.valueOf(mAccount.getIdleRefreshMinutes()));
        mIdleRefreshPeriod.setSummary(mIdleRefreshPeriod.getEntry());
        mIdleRefreshPeriod.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

            public boolean onPreferenceChange(Preference preference, Object newValue) {
                final String summary = newValue.toString();
                int index = mIdleRefreshPeriod.findIndexOfValue(summary);
                mIdleRefreshPeriod.setSummary(mIdleRefreshPeriod.getEntries()[index]);
                mIdleRefreshPeriod.setValue(summary);
                return false;
            }
        });
        mMaxPushFolders.setValue(String.valueOf(mAccount.getMaxPushFolders()));
        mMaxPushFolders.setSummary(mMaxPushFolders.getEntry());
        mMaxPushFolders.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

            public boolean onPreferenceChange(Preference preference, Object newValue) {
                final String summary = newValue.toString();
                int index = mMaxPushFolders.findIndexOfValue(summary);
                mMaxPushFolders.setSummary(mMaxPushFolders.getEntries()[index]);
                mMaxPushFolders.setValue(summary);
                return false;
            }
        });
        mPushMode = (ListPreference) findPreference(PREFERENCE_PUSH_MODE);
        mPushMode.setValue(mAccount.getFolderPushMode().name());
        mPushMode.setSummary(mPushMode.getEntry());
        mPushMode.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

            public boolean onPreferenceChange(Preference preference, Object newValue) {
                final String summary = newValue.toString();
                int index = mPushMode.findIndexOfValue(summary);
                mPushMode.setSummary(mPushMode.getEntries()[index]);
                mPushMode.setValue(summary);
                return false;
            }
        });
    } else {
        PreferenceScreen incomingPrefs = (PreferenceScreen) findPreference(PREFERENCE_SCREEN_INCOMING);
        incomingPrefs.removePreference((PreferenceScreen) findPreference(PREFERENCE_SCREEN_PUSH_ADVANCED));
        incomingPrefs.removePreference((ListPreference) findPreference(PREFERENCE_PUSH_MODE));
        mMainScreen.removePreference(mSearchScreen);
    }
    mAccountNotify = (CheckBoxPreference) findPreference(PREFERENCE_NOTIFY);
    mAccountNotify.setChecked(mAccount.isNotifyNewMail());
    mAccountNotifyNewMailMode = (ListPreference) findPreference(PREFERENCE_NOTIFY_NEW_MAIL_MODE);
    mAccountNotifyNewMailMode.setValue(mAccount.getFolderNotifyNewMailMode().name());
    mAccountNotifyNewMailMode.setSummary(mAccountNotifyNewMailMode.getEntry());
    mAccountNotifyNewMailMode.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

        public boolean onPreferenceChange(Preference preference, Object newValue) {
            final String summary = newValue.toString();
            int index = mAccountNotifyNewMailMode.findIndexOfValue(summary);
            mAccountNotifyNewMailMode.setSummary(mAccountNotifyNewMailMode.getEntries()[index]);
            mAccountNotifyNewMailMode.setValue(summary);
            return false;
        }
    });
    mAccountNotifySelf = (CheckBoxPreference) findPreference(PREFERENCE_NOTIFY_SELF);
    mAccountNotifySelf.setChecked(mAccount.isNotifySelfNewMail());
    mAccountNotifyContactsMailOnly = (CheckBoxPreference) findPreference(PREFERENCE_NOTIFY_CONTACTS_MAIL_ONLY);
    mAccountNotifyContactsMailOnly.setChecked(mAccount.isNotifyContactsMailOnly());
    mAccountNotifySync = (CheckBoxPreference) findPreference(PREFERENCE_NOTIFY_SYNC);
    mAccountNotifySync.setChecked(mAccount.isShowOngoing());
    mAccountRingtone = (RingtonePreference) findPreference(PREFERENCE_RINGTONE);
    // XXX: The following two lines act as a workaround for the RingtonePreference
    //      which does not let us set/get the value programmatically
    SharedPreferences prefs = mAccountRingtone.getPreferenceManager().getSharedPreferences();
    String currentRingtone = (!mAccount.getNotificationSetting().shouldRing() ? null : mAccount.getNotificationSetting().getRingtone());
    prefs.edit().putString(PREFERENCE_RINGTONE, currentRingtone).commit();
    mAccountVibrate = (CheckBoxPreference) findPreference(PREFERENCE_VIBRATE);
    mAccountVibrate.setChecked(mAccount.getNotificationSetting().shouldVibrate());
    mAccountVibratePattern = (ListPreference) findPreference(PREFERENCE_VIBRATE_PATTERN);
    mAccountVibratePattern.setValue(String.valueOf(mAccount.getNotificationSetting().getVibratePattern()));
    mAccountVibratePattern.setSummary(mAccountVibratePattern.getEntry());
    mAccountVibratePattern.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

        public boolean onPreferenceChange(Preference preference, Object newValue) {
            final String summary = newValue.toString();
            int index = mAccountVibratePattern.findIndexOfValue(summary);
            mAccountVibratePattern.setSummary(mAccountVibratePattern.getEntries()[index]);
            mAccountVibratePattern.setValue(summary);
            doVibrateTest(preference);
            return false;
        }
    });
    mAccountVibrateTimes = (ListPreference) findPreference(PREFERENCE_VIBRATE_TIMES);
    mAccountVibrateTimes.setValue(String.valueOf(mAccount.getNotificationSetting().getVibrateTimes()));
    mAccountVibrateTimes.setSummary(String.valueOf(mAccount.getNotificationSetting().getVibrateTimes()));
    mAccountVibrateTimes.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

        @Override
        public boolean onPreferenceChange(Preference preference, Object newValue) {
            final String value = newValue.toString();
            mAccountVibrateTimes.setSummary(value);
            mAccountVibrateTimes.setValue(value);
            doVibrateTest(preference);
            return false;
        }
    });
    mAccountLed = (CheckBoxPreference) findPreference(PREFERENCE_NOTIFICATION_LED);
    mAccountLed.setChecked(mAccount.getNotificationSetting().isLed());
    mNotificationOpensUnread = (CheckBoxPreference) findPreference(PREFERENCE_NOTIFICATION_OPENS_UNREAD);
    mNotificationOpensUnread.setChecked(mAccount.goToUnreadMessageSearch());
    new PopulateFolderPrefsTask().execute();
    mChipColor = findPreference(PREFERENCE_CHIP_COLOR);
    mChipColor.setOnPreferenceClickListener(new Preference.OnPreferenceClickListener() {

        public boolean onPreferenceClick(Preference preference) {
            onChooseChipColor();
            return false;
        }
    });
    mLedColor = findPreference(PREFERENCE_LED_COLOR);
    mLedColor.setOnPreferenceClickListener(new Preference.OnPreferenceClickListener() {

        public boolean onPreferenceClick(Preference preference) {
            onChooseLedColor();
            return false;
        }
    });
    findPreference(PREFERENCE_COMPOSITION).setOnPreferenceClickListener(new Preference.OnPreferenceClickListener() {

        public boolean onPreferenceClick(Preference preference) {
            onCompositionSettings();
            return true;
        }
    });
    findPreference(PREFERENCE_MANAGE_IDENTITIES).setOnPreferenceClickListener(new Preference.OnPreferenceClickListener() {

        public boolean onPreferenceClick(Preference preference) {
            onManageIdentities();
            return true;
        }
    });
    findPreference(PREFERENCE_INCOMING).setOnPreferenceClickListener(new Preference.OnPreferenceClickListener() {

        public boolean onPreferenceClick(Preference preference) {
            mIncomingChanged = true;
            onIncomingSettings();
            return true;
        }
    });
    findPreference(PREFERENCE_OUTGOING).setOnPreferenceClickListener(new Preference.OnPreferenceClickListener() {

        public boolean onPreferenceClick(Preference preference) {
            onOutgoingSettings();
            return true;
        }
    });
    mHasCrypto = K9.isOpenPgpProviderConfigured();
    PreferenceScreen cryptoMenu = (PreferenceScreen) findPreference(PREFERENCE_CRYPTO);
    if (mHasCrypto) {
        mCryptoKey = (OpenPgpKeyPreference) findPreference(PREFERENCE_CRYPTO_KEY);
        mCryptoKey.setValue(mAccount.getCryptoKey());
        mCryptoKey.setOpenPgpProvider(K9.getOpenPgpProvider());
        // TODO: other identities?
        mCryptoKey.setDefaultUserId(OpenPgpApiHelper.buildUserId(mAccount.getIdentity(0)));
        mCryptoKey.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

            public boolean onPreferenceChange(Preference preference, Object newValue) {
                long value = (Long) newValue;
                mCryptoKey.setValue(value);
                return false;
            }
        });
        cryptoMenu.setOnPreferenceClickListener(null);
    } else {
        cryptoMenu.setSummary(R.string.account_settings_no_openpgp_provider_configured);
        cryptoMenu.setOnPreferenceClickListener(new OnPreferenceClickListener() {

            @Override
            public boolean onPreferenceClick(Preference preference) {
                Dialog dialog = ((PreferenceScreen) preference).getDialog();
                if (dialog != null) {
                    dialog.dismiss();
                }
                Toast.makeText(AccountSettings.this, R.string.no_crypto_provider_see_global, Toast.LENGTH_SHORT).show();
                return true;
            }
        });
    }
}

Example 34 with Preferences

use of com.fsck.k9.Preferences in project k-9 by k9mail.

the class MessagingController method getSearchAccountStatsSynchronous.

public AccountStats getSearchAccountStatsSynchronous(final SearchAccount searchAccount, final MessagingListener listener) {
    Preferences preferences = Preferences.getPreferences(context);
    LocalSearch search = searchAccount.getRelatedSearch();
    // Collect accounts that belong to the search
    String[] accountUuids = search.getAccountUuids();
    List<Account> accounts;
    if (search.searchAllAccounts()) {
        accounts = preferences.getAccounts();
    } else {
        accounts = new ArrayList<>(accountUuids.length);
        for (int i = 0, len = accountUuids.length; i < len; i++) {
            String accountUuid = accountUuids[i];
            accounts.set(i, preferences.getAccount(accountUuid));
        }
    }
    ContentResolver cr = context.getContentResolver();
    int unreadMessageCount = 0;
    int flaggedMessageCount = 0;
    String[] projection = { StatsColumns.UNREAD_COUNT, StatsColumns.FLAGGED_COUNT };
    for (Account account : accounts) {
        StringBuilder query = new StringBuilder();
        List<String> queryArgs = new ArrayList<>();
        ConditionsTreeNode conditions = search.getConditions();
        SqlQueryBuilder.buildWhereClause(account, conditions, query, queryArgs);
        String selection = query.toString();
        String[] selectionArgs = queryArgs.toArray(new String[queryArgs.size()]);
        Uri uri = Uri.withAppendedPath(EmailProvider.CONTENT_URI, "account/" + account.getUuid() + "/stats");
        // Query content provider to get the account stats
        Cursor cursor = cr.query(uri, projection, selection, selectionArgs, null);
        try {
            if (cursor != null && cursor.moveToFirst()) {
                unreadMessageCount += cursor.getInt(0);
                flaggedMessageCount += cursor.getInt(1);
            }
        } finally {
            if (cursor != null) {
                cursor.close();
            }
        }
    }
    // Create AccountStats instance...
    AccountStats stats = new AccountStats();
    stats.unreadMessageCount = unreadMessageCount;
    stats.flaggedMessageCount = flaggedMessageCount;
    // ...and notify the listener
    if (listener != null) {
        listener.accountStatusChanged(searchAccount, stats);
    }
    return stats;
}

Example 35 with Preferences

use of com.fsck.k9.Preferences in project k-9 by k9mail.

the class MessageCompose method processDraftMessage.

private void processDraftMessage(MessageViewInfo messageViewInfo) {
    Message message = messageViewInfo.message;
    draftId = MessagingController.getInstance(getApplication()).getId(message);
    subjectView.setText(message.getSubject());
    recipientPresenter.initFromDraftMessage(message);
    // Read In-Reply-To header from draft
    final String[] inReplyTo = message.getHeader("In-Reply-To");
    if (inReplyTo.length >= 1) {
        repliedToMessageId = inReplyTo[0];
    }
    // Read References header from draft
    final String[] references = message.getHeader("References");
    if (references.length >= 1) {
        referencedMessageIds = references[0];
    }
    if (!relatedMessageProcessed) {
        attachmentPresenter.loadNonInlineAttachments(messageViewInfo);
    }
    // Decode the identity header when loading a draft.
    // See buildIdentityHeader(TextBody) for a detailed description of the composition of this blob.
    Map<IdentityField, String> k9identity = new HashMap<>();
    String[] identityHeaders = message.getHeader(K9.IDENTITY_HEADER);
    if (identityHeaders.length > 0 && identityHeaders[0] != null) {
        k9identity = IdentityHeaderParser.parse(identityHeaders[0]);
    }
    Identity newIdentity = new Identity();
    if (k9identity.containsKey(IdentityField.SIGNATURE)) {
        newIdentity.setSignatureUse(true);
        newIdentity.setSignature(k9identity.get(IdentityField.SIGNATURE));
        signatureChanged = true;
    } else {
        if (message instanceof LocalMessage) {
            newIdentity.setSignatureUse(((LocalMessage) message).getFolder().getSignatureUse());
        }
        newIdentity.setSignature(identity.getSignature());
    }
    if (k9identity.containsKey(IdentityField.NAME)) {
        newIdentity.setName(k9identity.get(IdentityField.NAME));
        identityChanged = true;
    } else {
        newIdentity.setName(identity.getName());
    }
    if (k9identity.containsKey(IdentityField.EMAIL)) {
        newIdentity.setEmail(k9identity.get(IdentityField.EMAIL));
        identityChanged = true;
    } else {
        newIdentity.setEmail(identity.getEmail());
    }
    if (k9identity.containsKey(IdentityField.ORIGINAL_MESSAGE)) {
        relatedMessageReference = null;
        String originalMessage = k9identity.get(IdentityField.ORIGINAL_MESSAGE);
        MessageReference messageReference = MessageReference.parse(originalMessage);
        if (messageReference != null) {
            // Check if this is a valid account in our database
            Preferences prefs = Preferences.getPreferences(getApplicationContext());
            Account account = prefs.getAccount(messageReference.getAccountUuid());
            if (account != null) {
                relatedMessageReference = messageReference;
            }
        }
    }
    identity = newIdentity;
    updateSignature();
    updateFrom();
    quotedMessagePresenter.processDraftMessage(messageViewInfo, k9identity);
}