Examples with CheckBoxPreference android.support.v7.preference.CheckBoxPreference used on opensource projects

Example 16 with CheckBoxPreference

use of android.support.v7.preference.CheckBoxPreference in project Pix-Art-Messenger by kriztan.

the class SettingsActivity method onStart.

@Override
public void onStart() {
    super.onStart();
    PreferenceManager.getDefaultSharedPreferences(this).registerOnSharedPreferenceChangeListener(this);
    multiAccountPreference = mSettingsFragment.findPreference("enable_multi_accounts");
    if (multiAccountPreference != null) {
        isMultiAccountChecked = ((CheckBoxPreference) multiAccountPreference).isChecked();
    }
    if (Config.FORCE_ORBOT) {
        PreferenceCategory connectionOptions = (PreferenceCategory) mSettingsFragment.findPreference("connection_options");
        PreferenceScreen expert = (PreferenceScreen) mSettingsFragment.findPreference("expert");
        if (connectionOptions != null) {
            expert.removePreference(connectionOptions);
        }
    }
    PreferenceScreen mainPreferenceScreen = (PreferenceScreen) mSettingsFragment.findPreference("main_screen");
    // this feature is only available on Huawei Android 6.
    PreferenceScreen huaweiPreferenceScreen = (PreferenceScreen) mSettingsFragment.findPreference("huawei");
    if (huaweiPreferenceScreen != null) {
        Intent intent = huaweiPreferenceScreen.getIntent();
        // remove when Api version is above M (Version 6.0) or if the intent is not callable
        if (Build.VERSION.SDK_INT > Build.VERSION_CODES.M || !isCallable(intent)) {
            PreferenceCategory generalCategory = (PreferenceCategory) mSettingsFragment.findPreference("general");
            generalCategory.removePreference(huaweiPreferenceScreen);
            if (generalCategory.getPreferenceCount() == 0) {
                if (mainPreferenceScreen != null) {
                    mainPreferenceScreen.removePreference(generalCategory);
                }
            }
        }
    }
    ListPreference automaticMessageDeletionList = (ListPreference) mSettingsFragment.findPreference(AUTOMATIC_MESSAGE_DELETION);
    if (automaticMessageDeletionList != null) {
        final int[] choices = getResources().getIntArray(R.array.automatic_message_deletion_values);
        CharSequence[] entries = new CharSequence[choices.length];
        CharSequence[] entryValues = new CharSequence[choices.length];
        for (int i = 0; i < choices.length; ++i) {
            Log.d(Config.LOGTAG, "resolving choice " + choices[i]);
            entryValues[i] = String.valueOf(choices[i]);
            if (choices[i] == 0) {
                entries[i] = getString(R.string.never);
            } else {
                entries[i] = TimeframeUtils.resolve(this, 1000L * choices[i]);
            }
        }
        automaticMessageDeletionList.setEntries(entries);
        automaticMessageDeletionList.setEntryValues(entryValues);
    }
    final Preference removeCertsPreference = mSettingsFragment.findPreference("remove_trusted_certificates");
    if (removeCertsPreference != null) {
        removeCertsPreference.setOnPreferenceClickListener(preference -> {
            final MemorizingTrustManager mtm = xmppConnectionService.getMemorizingTrustManager();
            final ArrayList<String> aliases = Collections.list(mtm.getCertificates());
            if (aliases.size() == 0) {
                displayToast(getString(R.string.toast_no_trusted_certs));
                return true;
            }
            final ArrayList selectedItems = new ArrayList<>();
            final AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(SettingsActivity.this);
            dialogBuilder.setTitle(getResources().getString(R.string.dialog_manage_certs_title));
            dialogBuilder.setMultiChoiceItems(aliases.toArray(new CharSequence[aliases.size()]), null, (dialog, indexSelected, isChecked) -> {
                if (isChecked) {
                    selectedItems.add(indexSelected);
                } else if (selectedItems.contains(indexSelected)) {
                    selectedItems.remove(Integer.valueOf(indexSelected));
                }
                if (selectedItems.size() > 0)
                    ((AlertDialog) dialog).getButton(DialogInterface.BUTTON_POSITIVE).setEnabled(true);
                else {
                    ((AlertDialog) dialog).getButton(DialogInterface.BUTTON_POSITIVE).setEnabled(false);
                }
            });
            dialogBuilder.setPositiveButton(getResources().getString(R.string.dialog_manage_certs_positivebutton), (dialog, which) -> {
                int count = selectedItems.size();
                if (count > 0) {
                    for (int i = 0; i < count; i++) {
                        try {
                            Integer item = Integer.valueOf(selectedItems.get(i).toString());
                            String alias = aliases.get(item);
                            mtm.deleteCertificate(alias);
                        } catch (KeyStoreException e) {
                            e.printStackTrace();
                            displayToast("Error: " + e.getLocalizedMessage());
                        }
                    }
                    if (xmppConnectionServiceBound) {
                        reconnectAccounts();
                    }
                    displayToast(getResources().getQuantityString(R.plurals.toast_delete_certificates, count, count));
                }
            });
            dialogBuilder.setNegativeButton(getResources().getString(R.string.dialog_manage_certs_negativebutton), null);
            AlertDialog removeCertsDialog = dialogBuilder.create();
            removeCertsDialog.show();
            removeCertsDialog.getButton(AlertDialog.BUTTON_POSITIVE).setEnabled(false);
            return true;
        });
    }
    final Preference exportLogsPreference = mSettingsFragment.findPreference("export_logs");
    if (exportLogsPreference != null) {
        exportLogsPreference.setOnPreferenceClickListener(preference -> {
            if (hasStoragePermission(REQUEST_WRITE_LOGS)) {
                startExport();
            }
            return true;
        });
    }
    if (Config.ONLY_INTERNAL_STORAGE) {
        final Preference cleanCachePreference = mSettingsFragment.findPreference("clean_cache");
        if (cleanCachePreference != null) {
            cleanCachePreference.setOnPreferenceClickListener(preference -> cleanCache());
        }
        final Preference cleanPrivateStoragePreference = mSettingsFragment.findPreference("clean_private_storage");
        if (cleanPrivateStoragePreference != null) {
            cleanPrivateStoragePreference.setOnPreferenceClickListener(preference -> cleanPrivateStorage());
        }
    }
    final Preference deleteOmemoPreference = mSettingsFragment.findPreference("delete_omemo_identities");
    if (deleteOmemoPreference != null) {
        deleteOmemoPreference.setOnPreferenceClickListener(preference -> deleteOmemoIdentities());
    }
    final Preference enableMultiAccountsPreference = mSettingsFragment.findPreference("enable_multi_accounts");
    if (enableMultiAccountsPreference != null) {
        Log.d(Config.LOGTAG, "Multi account checkbox checked: " + isMultiAccountChecked);
        if (isMultiAccountChecked) {
            enableMultiAccountsPreference.setEnabled(false);
        /*
            if (xmppConnectionServiceBound) { // todo doesn't work --> it seems the service is never bound
                final List<Account> accounts = xmppConnectionService.getAccounts();
                Log.d(Config.LOGTAG, "Disabled multi account: Number of accounts " + accounts.size());
                if (accounts.size() > 1) {
                    Log.d(Config.LOGTAG, "Disabled multi account not possible because you have more than one account");
                    enableMultiAccountsPreference.setEnabled(false);
                } else {
                    Log.d(Config.LOGTAG, "Disabled multi account possible because you have one account");
                    enableMultiAccountsPreference.setEnabled(true);
                }
            } else {
                enableMultiAccountsPreference.setEnabled(false);
            }
            */
        } else {
            enableMultiAccountsPreference.setEnabled(true);
            enableMultiAccountsPreference.setOnPreferenceClickListener(preference -> {
                enableMultiAccounts();
                return true;
            });
        }
    }
}

Example 17 with CheckBoxPreference

use of android.support.v7.preference.CheckBoxPreference in project Pix-Art-Messenger by kriztan.

the class SettingsActivity method enterPasswordDialog.

public void enterPasswordDialog() {
    LayoutInflater li = LayoutInflater.from(this);
    View promptsView = li.inflate(R.layout.password, null);
    final Preference preference = mSettingsFragment.findPreference("enable_multi_accounts");
    final AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(this);
    alertDialogBuilder.setView(promptsView);
    final EditText password = promptsView.findViewById(R.id.password);
    final EditText confirm_password = promptsView.findViewById(R.id.confirm_password);
    confirm_password.setVisibility(View.VISIBLE);
    alertDialogBuilder.setTitle(R.string.enter_password);
    alertDialogBuilder.setMessage(R.string.enter_password);
    alertDialogBuilder.setCancelable(false).setPositiveButton(R.string.ok, (dialog, id) -> {
        final String pw1 = password.getText().toString();
        final String pw2 = confirm_password.getText().toString();
        if (!pw1.equals(pw2)) {
            ((CheckBoxPreference) preference).setChecked(false);
            AlertDialog.Builder builder = new AlertDialog.Builder(this);
            builder.setTitle(R.string.error);
            builder.setMessage(R.string.passwords_do_not_match);
            builder.setNegativeButton(R.string.cancel, null);
            builder.setPositiveButton(R.string.try_again, (dialog12, id12) -> enterPasswordDialog());
            builder.create().show();
        } else if (pw1.trim().isEmpty()) {
            ((CheckBoxPreference) preference).setChecked(false);
            AlertDialog.Builder builder = new AlertDialog.Builder(this);
            builder.setTitle(R.string.error);
            builder.setMessage(R.string.password_should_not_be_empty);
            builder.setNegativeButton(R.string.cancel, null);
            builder.setPositiveButton(R.string.try_again, (dialog1, id1) -> enterPasswordDialog());
            builder.create().show();
        } else {
            ((CheckBoxPreference) preference).setChecked(true);
            SharedPreferences multiaccount_prefs = getApplicationContext().getSharedPreferences(USE_MULTI_ACCOUNTS, Context.MODE_PRIVATE);
            SharedPreferences.Editor editor = multiaccount_prefs.edit();
            editor.putString("BackupPW", pw1);
            editor.commit();
        }
    }).setNegativeButton(R.string.cancel, null);
    alertDialogBuilder.create().show();
}

Example 18 with CheckBoxPreference

use of android.support.v7.preference.CheckBoxPreference in project android by owncloud.

the class Preferences method onCreate.

@SuppressWarnings("deprecation")
@Override
public void onCreate(Bundle savedInstanceState) {
    getDelegate().installViewFactory();
    getDelegate().onCreate(savedInstanceState);
    super.onCreate(savedInstanceState);
    addPreferencesFromResource(R.xml.preferences);
    ActionBar actionBar = getSupportActionBar();
    actionBar.setDisplayHomeAsUpEnabled(true);
    actionBar.setTitle(R.string.actionbar_settings);
    // For adding content description tag to a title field in the action bar
    int actionBarTitleId = getResources().getIdentifier("action_bar_title", "id", "android");
    View actionBarTitleView = getWindow().getDecorView().findViewById(actionBarTitleId);
    if (actionBarTitleView != null) {
        // it's null in Android 2.x
        getWindow().getDecorView().findViewById(actionBarTitleId).setContentDescription(getString(R.string.actionbar_settings));
    }
    // Load package info
    String temp;
    try {
        PackageInfo pkg = getPackageManager().getPackageInfo(getPackageName(), 0);
        temp = pkg.versionName;
    } catch (NameNotFoundException e) {
        temp = "";
        Log_OC.e(TAG, "Error while showing about dialog", e);
    }
    final String appVersion = temp;
    // Register context menu for list of preferences.
    registerForContextMenu(getListView());
    pCode = (CheckBoxPreference) findPreference(PassCodeActivity.PREFERENCE_SET_PASSCODE);
    if (pCode != null) {
        pCode.setOnPreferenceChangeListener(new OnPreferenceChangeListener() {

            @Override
            public boolean onPreferenceChange(Preference preference, Object newValue) {
                Intent i = new Intent(getApplicationContext(), PassCodeActivity.class);
                Boolean incoming = (Boolean) newValue;
                i.setAction(incoming ? PassCodeActivity.ACTION_REQUEST_WITH_RESULT : PassCodeActivity.ACTION_CHECK_WITH_RESULT);
                startActivityForResult(i, incoming ? ACTION_REQUEST_PASSCODE : ACTION_CONFIRM_PASSCODE);
                // Don't update just yet, we will decide on it in onActivityResult
                return false;
            }
        });
    }
    PreferenceCategory preferenceCategory = (PreferenceCategory) findPreference("more");
    boolean helpEnabled = getResources().getBoolean(R.bool.help_enabled);
    Preference pHelp = findPreference("help");
    if (pHelp != null) {
        if (helpEnabled) {
            pHelp.setOnPreferenceClickListener(new OnPreferenceClickListener() {

                @Override
                public boolean onPreferenceClick(Preference preference) {
                    String helpWeb = (String) getText(R.string.url_help);
                    if (helpWeb != null && helpWeb.length() > 0) {
                        Uri uriUrl = Uri.parse(helpWeb);
                        Intent intent = new Intent(Intent.ACTION_VIEW, uriUrl);
                        startActivity(intent);
                    }
                    return true;
                }
            });
        } else {
            preferenceCategory.removePreference(pHelp);
        }
    }
    boolean recommendEnabled = getResources().getBoolean(R.bool.recommend_enabled);
    Preference pRecommend = findPreference("recommend");
    if (pRecommend != null) {
        if (recommendEnabled) {
            pRecommend.setOnPreferenceClickListener(new OnPreferenceClickListener() {

                @Override
                public boolean onPreferenceClick(Preference preference) {
                    Intent intent = new Intent(Intent.ACTION_SENDTO);
                    intent.setType("text/plain");
                    intent.setData(Uri.parse(getString(R.string.mail_recommend)));
                    intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                    String appName = getString(R.string.app_name);
                    String downloadUrl = getString(R.string.url_app_download);
                    String recommendSubject = String.format(getString(R.string.recommend_subject), appName);
                    String recommendText = String.format(getString(R.string.recommend_text), appName, downloadUrl);
                    intent.putExtra(Intent.EXTRA_SUBJECT, recommendSubject);
                    intent.putExtra(Intent.EXTRA_TEXT, recommendText);
                    startActivity(intent);
                    return (true);
                }
            });
        } else {
            preferenceCategory.removePreference(pRecommend);
        }
    }
    boolean feedbackEnabled = getResources().getBoolean(R.bool.feedback_enabled);
    Preference pFeedback = findPreference("feedback");
    if (pFeedback != null) {
        if (feedbackEnabled) {
            pFeedback.setOnPreferenceClickListener(new OnPreferenceClickListener() {

                @Override
                public boolean onPreferenceClick(Preference preference) {
                    String feedbackMail = (String) getText(R.string.mail_feedback);
                    String feedback = (String) getText(R.string.prefs_feedback) + " - android v" + appVersion;
                    Intent intent = new Intent(Intent.ACTION_SENDTO);
                    intent.setType("text/plain");
                    intent.putExtra(Intent.EXTRA_SUBJECT, feedback);
                    intent.setData(Uri.parse(feedbackMail));
                    intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                    startActivity(intent);
                    return true;
                }
            });
        } else {
            preferenceCategory.removePreference(pFeedback);
        }
    }
    boolean privacyPolicyEnabled = getResources().getBoolean(R.bool.privacy_policy_enabled);
    Preference pPrivacyPolicy = findPreference("privacyPolicy");
    if (pPrivacyPolicy != null) {
        if (privacyPolicyEnabled) {
            pPrivacyPolicy.setOnPreferenceClickListener(new OnPreferenceClickListener() {

                @Override
                public boolean onPreferenceClick(Preference preference) {
                    Intent privacyPolicyIntent = new Intent(getApplicationContext(), PrivacyPolicyActivity.class);
                    startActivity(privacyPolicyIntent);
                    return true;
                }
            });
        } else {
            preferenceCategory.removePreference(pPrivacyPolicy);
        }
    }
    boolean loggerEnabled = getResources().getBoolean(R.bool.logger_enabled) || BuildConfig.DEBUG;
    Preference pLogger = findPreference("logger");
    if (pLogger != null) {
        if (loggerEnabled) {
            pLogger.setOnPreferenceClickListener(new OnPreferenceClickListener() {

                @Override
                public boolean onPreferenceClick(Preference preference) {
                    Intent loggerIntent = new Intent(getApplicationContext(), LogHistoryActivity.class);
                    startActivity(loggerIntent);
                    return true;
                }
            });
        } else {
            preferenceCategory.removePreference(pLogger);
        }
    }
    boolean imprintEnabled = getResources().getBoolean(R.bool.imprint_enabled);
    Preference pImprint = findPreference("imprint");
    if (pImprint != null) {
        if (imprintEnabled) {
            pImprint.setOnPreferenceClickListener(new OnPreferenceClickListener() {

                @Override
                public boolean onPreferenceClick(Preference preference) {
                    String imprintWeb = (String) getText(R.string.url_imprint);
                    if (imprintWeb != null && imprintWeb.length() > 0) {
                        Uri uriUrl = Uri.parse(imprintWeb);
                        Intent intent = new Intent(Intent.ACTION_VIEW, uriUrl);
                        startActivity(intent);
                    }
                    //ImprintDialog.newInstance(true).show(preference.get, "IMPRINT_DIALOG");
                    return true;
                }
            });
        } else {
            preferenceCategory.removePreference(pImprint);
        }
    }
    mPrefInstantUploadPath = findPreference("instant_upload_path");
    if (mPrefInstantUploadPath != null) {
        mPrefInstantUploadPath.setOnPreferenceClickListener(new OnPreferenceClickListener() {

            @Override
            public boolean onPreferenceClick(Preference preference) {
                if (!mUploadPath.endsWith(OCFile.PATH_SEPARATOR)) {
                    mUploadPath += OCFile.PATH_SEPARATOR;
                }
                Intent intent = new Intent(Preferences.this, UploadPathActivity.class);
                intent.putExtra(UploadPathActivity.KEY_INSTANT_UPLOAD_PATH, mUploadPath);
                startActivityForResult(intent, ACTION_SELECT_UPLOAD_PATH);
                return true;
            }
        });
    }
    mPrefInstantUploadCategory = (PreferenceCategory) findPreference("instant_uploading_category");
    mPrefInstantUploadWiFi = findPreference("instant_upload_on_wifi");
    mPrefInstantUpload = findPreference("instant_uploading");
    toggleInstantPictureOptions(((CheckBoxPreference) mPrefInstantUpload).isChecked());
    mPrefInstantUpload.setOnPreferenceChangeListener(new OnPreferenceChangeListener() {

        @Override
        public boolean onPreferenceChange(Preference preference, Object newValue) {
            boolean enableInstantPicture = (Boolean) newValue;
            toggleInstantPictureOptions(enableInstantPicture);
            toggleInstantUploadCommonOptions(((CheckBoxPreference) mPrefInstantVideoUpload).isChecked(), enableInstantPicture);
            return true;
        }
    });
    mPrefInstantVideoUploadPath = findPreference("instant_video_upload_path");
    if (mPrefInstantVideoUploadPath != null) {
        mPrefInstantVideoUploadPath.setOnPreferenceClickListener(new OnPreferenceClickListener() {

            @Override
            public boolean onPreferenceClick(Preference preference) {
                if (!mUploadVideoPath.endsWith(OCFile.PATH_SEPARATOR)) {
                    mUploadVideoPath += OCFile.PATH_SEPARATOR;
                }
                Intent intent = new Intent(Preferences.this, UploadPathActivity.class);
                intent.putExtra(UploadPathActivity.KEY_INSTANT_UPLOAD_PATH, mUploadVideoPath);
                startActivityForResult(intent, ACTION_SELECT_UPLOAD_VIDEO_PATH);
                return true;
            }
        });
    }
    mPrefInstantVideoUploadWiFi = findPreference("instant_video_upload_on_wifi");
    mPrefInstantVideoUpload = findPreference("instant_video_uploading");
    toggleInstantVideoOptions(((CheckBoxPreference) mPrefInstantVideoUpload).isChecked());
    mPrefInstantVideoUpload.setOnPreferenceChangeListener(new OnPreferenceChangeListener() {

        @Override
        public boolean onPreferenceChange(Preference preference, Object newValue) {
            toggleInstantVideoOptions((Boolean) newValue);
            toggleInstantUploadCommonOptions((Boolean) newValue, ((CheckBoxPreference) mPrefInstantUpload).isChecked());
            return true;
        }
    });
    mPrefInstantUploadSourcePath = findPreference("instant_upload_source_path");
    if (mPrefInstantUploadSourcePath != null) {
        mPrefInstantUploadSourcePath.setOnPreferenceClickListener(new OnPreferenceClickListener() {

            @Override
            public boolean onPreferenceClick(Preference preference) {
                if (!mSourcePath.endsWith(File.separator)) {
                    mSourcePath += File.separator;
                }
                LocalFolderPickerActivity.startLocalFolderPickerActivityForResult(Preferences.this, mSourcePath, ACTION_SELECT_SOURCE_PATH);
                return true;
            }
        });
    } else {
        Log_OC.e(TAG, "Lost preference instant_upload_source_path");
    }
    mPrefInstantUploadBehaviour = findPreference("prefs_instant_behaviour");
    toggleInstantUploadCommonOptions(((CheckBoxPreference) mPrefInstantVideoUpload).isChecked(), ((CheckBoxPreference) mPrefInstantUpload).isChecked());
    /* About App */
    pAboutApp = (Preference) findPreference("about_app");
    if (pAboutApp != null) {
        pAboutApp.setTitle(String.format(getString(R.string.about_android), getString(R.string.app_name)));
        pAboutApp.setSummary(String.format(getString(R.string.about_version), appVersion));
    }
    loadInstantUploadPath();
    loadInstantUploadVideoPath();
    loadInstantUploadSourcePath();
}

Example 19 with CheckBoxPreference

use of android.support.v7.preference.CheckBoxPreference in project Resurrection_packages_apps_Settings by ResurrectionRemix.

the class KeyboardLayoutPickerFragment method onPreferenceTreeClick.

@Override
public boolean onPreferenceTreeClick(Preference preference) {
    if (preference instanceof CheckBoxPreference) {
        CheckBoxPreference checkboxPref = (CheckBoxPreference) preference;
        KeyboardLayout layout = mPreferenceMap.get(checkboxPref);
        if (layout != null) {
            boolean checked = checkboxPref.isChecked();
            if (checked) {
                mIm.addKeyboardLayoutForInputDevice(mInputDeviceIdentifier, layout.getDescriptor());
            } else {
                mIm.removeKeyboardLayoutForInputDevice(mInputDeviceIdentifier, layout.getDescriptor());
            }
            return true;
        }
    }
    return super.onPreferenceTreeClick(preference);
}

Example 20 with CheckBoxPreference

use of android.support.v7.preference.CheckBoxPreference in project frostwire by frostwire.

the class OtherFragment method setupPermanentStatusNotificationOption.

private void setupPermanentStatusNotificationOption() {
    CheckBoxPreference cb = findPreference(Constants.PREF_KEY_GUI_ENABLE_PERMANENT_STATUS_NOTIFICATION);
    if (cb != null) {
        cb.setOnPreferenceChangeListener((preference, newValue) -> {
            final boolean notificationEnabled = (boolean) newValue;
            if (!notificationEnabled) {
                Context ctx = getActivity();
                NotificationManager notificationService = (NotificationManager) ctx.getSystemService(Context.NOTIFICATION_SERVICE);
                if (notificationService != null) {
                    try {
                        notificationService.cancel(EngineService.FROSTWIRE_STATUS_NOTIFICATION);
                    } catch (Throwable t) {
                    // possible java.lang.SecurityException
                    }
                }
            }
            return true;
        });
    }
}