android.preference.ListPreference

Here are the examples of the java api android.preference.ListPreference taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

160 Examples 7

19 Source : SettingActivity.java
with Apache License 2.0
from zom

public clreplaced SettingActivity extends PreferenceActivity {

    private static final String TAG = "SettingActivity";

    private static final int CHOOSE_RINGTONE = 5;

    private PackageManager pm;

    private String currentLanguage;

    ListPreference mPanicTriggerApp;

    Preference mPanicConfig;

    ListPreference mLanguage;

    // CheckBoxPreference mDeleteUnsecuredMedia;
    CheckBoxPreference mEnableNotification;

    CheckBoxPreference mNotificationVibrate;

    CheckBoxPreference mNotificationSound;

    CheckBoxPreference mAllowScreenshot;

    // EditTextPreference mHeartbeatInterval;
    Preference mNotificationRingtone;

    private void setInitialValues() {
        // mDeleteUnsecuredMedia.setChecked(Preferences.getDeleteInsecureMedia());
        mEnableNotification.setChecked(Preferences.isNotificationEnabled());
        mNotificationVibrate.setChecked(Preferences.getNotificationVibrate());
        mNotificationSound.setChecked(Preferences.getNotificationSound());
        // mHeartbeatInterval.setText(String.valueOf(Preferences.getHeartbeatInterval()));
        ArrayList<CharSequence> entries = new ArrayList<CharSequence>();
        ArrayList<CharSequence> entryValues = new ArrayList<CharSequence>();
        entries.add(0, getString(R.string.panic_app_none));
        entries.add(1, getString(R.string.panic_app_default));
        entryValues.add(0, Panic.PACKAGE_NAME_NONE);
        entryValues.add(1, Panic.PACKAGE_NAME_DEFAULT);
        for (ResolveInfo resolveInfo : PanicResponder.resolveTriggerApps(pm)) {
            if (resolveInfo.activityInfo == null)
                continue;
            entries.add(resolveInfo.activityInfo.loadLabel(pm));
            entryValues.add(resolveInfo.activityInfo.packageName);
        }
        mPanicTriggerApp.setEntries(entries.toArray(new CharSequence[entries.size()]));
        mPanicTriggerApp.setEntryValues(entryValues.toArray(new CharSequence[entryValues.size()]));
        PanicResponder.configTriggerAppListPreference(mPanicTriggerApp, R.string.panic_trigger_app_summary, R.string.panic_app_none_summary);
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        addPreferencesFromResource(R.xml.preferences);
        pm = getPackageManager();
        mAllowScreenshot = (CheckBoxPreference) findPreference("prefBlockScreenshots");
        mPanicTriggerApp = (ListPreference) findPreference("pref_panic_trigger_app");
        mPanicConfig = (Preference) findPreference("pref_panic_config");
        mLanguage = (ListPreference) findPreference("pref_language");
        // mDeleteUnsecuredMedia = (CheckBoxPreference) findPreference("pref_delete_unsecured_media");
        mEnableNotification = (CheckBoxPreference) findPreference("pref_enable_notification");
        mNotificationVibrate = (CheckBoxPreference) findPreference("pref_notification_vibrate");
        mNotificationSound = (CheckBoxPreference) findPreference("pref_notification_sound");
        mNotificationRingtone = findPreference("pref_notification_ringtone");
        Languages languages = Languages.get(this);
        currentLanguage = getResources().getConfiguration().locale.getLanguage();
        mLanguage.setDefaultValue(currentLanguage);
        mLanguage.setEntries(languages.getAllNames());
        mLanguage.setEntryValues(languages.getSupportedLocales());
        mLanguage.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

            @Override
            public boolean onPreferenceChange(Preference preference, Object newValue) {
                String language = (String) newValue;
                ImApp.resetLanguage(SettingActivity.this, language);
                setResult(RESULT_OK);
                return true;
            }
        });
        mAllowScreenshot.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

            @Override
            public boolean onPreferenceChange(Preference preference, Object o) {
                setResult(RESULT_OK);
                return true;
            }
        });
        mPanicTriggerApp.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

            @Override
            public boolean onPreferenceChange(Preference preference, Object newValue) {
                String packageName = (String) newValue;
                PanicResponder.setTriggerPackageName(SettingActivity.this, packageName);
                PanicResponder.configTriggerAppListPreference(mPanicTriggerApp, R.string.panic_trigger_app_summary, R.string.panic_app_none_summary);
                return true;
            }
        });
        mPanicConfig.setOnPreferenceClickListener(new OnPreferenceClickListener() {

            @Override
            public boolean onPreferenceClick(Preference preference) {
                Intent intent = new Intent(SettingActivity.this, PanicSetupActivity.clreplaced);
                startActivity(intent);
                return true;
            }
        });
        findPreference("pref_color_reset").setOnPreferenceClickListener(new OnPreferenceClickListener() {

            @Override
            public boolean onPreferenceClick(Preference preference) {
                SharedPreferences settings = PreferenceManager.getDefaultSharedPreferences(SettingActivity.this);
                SharedPreferences.Editor pEdit = settings.edit();
                pEdit.remove("themeColorBg");
                pEdit.remove("themeColorText");
                pEdit.remove("themeColor");
                pEdit.commit();
                setResult(RESULT_OK);
                finish();
                return true;
            }
        });
        mNotificationRingtone.setOnPreferenceClickListener(new OnPreferenceClickListener() {

            @Override
            public boolean onPreferenceClick(Preference arg0) {
                Intent intent = new Intent(RingtoneManager.ACTION_RINGTONE_PICKER);
                intent.putExtra(RingtoneManager.EXTRA_RINGTONE_TYPE, RingtoneManager.TYPE_NOTIFICATION);
                intent.putExtra(RingtoneManager.EXTRA_RINGTONE_replacedLE, getString(R.string.notification_ringtone_replacedle));
                intent.putExtra(RingtoneManager.EXTRA_RINGTONE_EXISTING_URI, Preferences.getNotificationRingtoneUri());
                startActivityForResult(intent, CHOOSE_RINGTONE);
                return true;
            }
        });
    /**
     *        findPreference("pref_clear_data").setOnPreferenceClickListener(new OnPreferenceClickListener() {
     *            @Override
     *            public boolean onPreferenceClick(Preference preference) {
     *
     *                try {
     *                    SecureMediaStore.deleteLargerThan(5000000);
     *                } catch (IOException e) {
     *                    e.printStackTrace();
     *                }
     *
     *                return true;
     *            }
     *        });*
     */
    // mHeartbeatInterval = (EditTextPreference) findPreference("pref_heartbeat_interval");
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        if (resultCode == Activity.RESULT_OK && requestCode == CHOOSE_RINGTONE) {
            Uri uri = data.getParcelableExtra(RingtoneManager.EXTRA_RINGTONE_PICKED_URI);
            Preferences.setNotificationRingtone(uri);
        }
        super.onActivityResult(requestCode, resultCode, data);
    }

    @Override
    protected void onResume() {
        super.onResume();
        setInitialValues();
    }
}

19 Source : Theme.java
with GNU General Public License v2.0
from yeriomin

public clreplaced Theme extends Abstract {

    private ListPreference themePreference;

    public Theme(PreferenceActivity activity) {
        super(activity);
    }

    public void setThemePreference(ListPreference themePreference) {
        this.themePreference = themePreference;
    }

    @Override
    public void draw() {
        Preference.OnPreferenceChangeListener listener = new Preference.OnPreferenceChangeListener() {

            @Override
            public boolean onPreferenceChange(Preference preference, final Object newValue) {
                preference.setSummary(activity.getString(getThemeSummaryStringId((String) newValue)));
                return true;
            }
        };
        listener.onPreferenceChange(themePreference, themePreference.getValue());
        themePreference.setOnPreferenceChangeListener(listener);
    }

    private int getThemeSummaryStringId(String theme) {
        if (null == theme) {
            return R.string.pref_ui_theme_none;
        }
        int summaryId;
        switch(theme) {
            case PreferenceUtil.THEME_LIGHT:
                summaryId = R.string.pref_ui_theme_light;
                break;
            case PreferenceUtil.THEME_DARK:
                summaryId = R.string.pref_ui_theme_dark;
                break;
            case PreferenceUtil.THEME_BLACK:
                summaryId = R.string.pref_ui_theme_black;
                break;
            case PreferenceUtil.THEME_NONE:
            default:
                summaryId = R.string.pref_ui_theme_none;
                break;
        }
        return summaryId;
    }
}

19 Source : Theme.java
with GNU General Public License v2.0
from yeriomin

public void setThemePreference(ListPreference themePreference) {
    this.themePreference = themePreference;
}

19 Source : List.java
with GNU General Public License v2.0
from yeriomin

public abstract clreplaced List extends Abstract {

    protected ListPreference listPreference;

    protected Map<String, String> keyValueMap;

    abstract protected Map<String, String> getKeyValueMap();

    abstract protected OnListPreferenceChangeListener getOnListPreferenceChangeListener();

    public List(PreferenceActivity activity) {
        super(activity);
    }

    public void setListPreference(ListPreference listPreference) {
        this.listPreference = listPreference;
    }

    @Override
    public void draw() {
        new ListValuesTask(this, listPreference).execute();
    }

    static clreplaced ListValuesTask extends AsyncTask<Void, Void, Void> {

        private List list;

        private ListPreference listPreference;

        public ListValuesTask(List list, ListPreference listPreference) {
            this.list = list;
            this.listPreference = listPreference;
        }

        @Override
        protected void onPreExecute() {
            listPreference.setEntries(new String[0]);
            listPreference.setEntryValues(new String[0]);
        }

        @Override
        protected void onPostExecute(Void aVoid) {
            int count = list.keyValueMap.size();
            listPreference.setEntries(list.keyValueMap.values().toArray(new CharSequence[count]));
            listPreference.setEntryValues(list.keyValueMap.keySet().toArray(new CharSequence[count]));
            OnListPreferenceChangeListener listener = list.getOnListPreferenceChangeListener();
            listener.setKeyValueMap(list.keyValueMap);
            listPreference.setOnPreferenceChangeListener(listener);
            listener.setSummary(listPreference, listPreference.getValue());
        }

        @Override
        protected Void doInBackground(Void... voids) {
            list.keyValueMap = list.getKeyValueMap();
            return null;
        }
    }
}

19 Source : List.java
with GNU General Public License v2.0
from yeriomin

public void setListPreference(ListPreference listPreference) {
    this.listPreference = listPreference;
}

19 Source : InstallationMethod.java
with GNU General Public License v2.0
from yeriomin

public clreplaced InstallationMethod extends Abstract {

    private ListPreference installationMethod;

    public InstallationMethod(PreferenceActivity activity) {
        super(activity);
    }

    public void setInstallationMethodPreference(ListPreference installationMethod) {
        this.installationMethod = installationMethod;
    }

    @Override
    public void draw() {
        Preference.OnPreferenceChangeListener listener = new OnInstallationMethodChangeListener(activity);
        listener.onPreferenceChange(installationMethod, installationMethod.getValue());
        installationMethod.setOnPreferenceChangeListener(listener);
    }
}

19 Source : InstallationMethod.java
with GNU General Public License v2.0
from yeriomin

public void setInstallationMethodPreference(ListPreference installationMethod) {
    this.installationMethod = installationMethod;
}

19 Source : CheckUpdates.java
with GNU General Public License v2.0
from yeriomin

public clreplaced CheckUpdates extends Abstract {

    private ListPreference checkForUpdates;

    private CheckBoxPreference alsoInstall;

    private CheckBoxPreference alsoDownload;

    public CheckUpdates(PreferenceActivity activity) {
        super(activity);
    }

    public void setCheckForUpdates(ListPreference checkForUpdates) {
        this.checkForUpdates = checkForUpdates;
    }

    public void setAlsoInstall(CheckBoxPreference alsoInstall) {
        this.alsoInstall = alsoInstall;
    }

    public void setAlsoDownload(CheckBoxPreference alsoDownload) {
        this.alsoDownload = alsoDownload;
    }

    @Override
    public void draw() {
        checkForUpdates.setSummary(activity.getString(getUpdateSummaryStringId(checkForUpdates.getValue())));
        checkForUpdates.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

            @Override
            public boolean onPreferenceChange(Preference preference, Object newValue) {
                int interval = Util.parseInt((String) newValue, 0);
                UpdateChecker.enable(activity, interval);
                preference.setSummary(activity.getString(getUpdateSummaryStringId((String) newValue)));
                alsoDownload.setEnabled(interval > 0);
                alsoInstall.setEnabled(interval > 0);
                return true;
            }
        });
        checkForUpdates.getOnPreferenceChangeListener().onPreferenceChange(checkForUpdates, checkForUpdates.getValue());
        alsoInstall.setOnPreferenceChangeListener(new AlsoInstallOnPreferenceChangeListener());
    }

    private int getUpdateSummaryStringId(String intervalString) {
        int summaryId;
        final int hour = 1000 * 60 * 60;
        final int day = hour * 24;
        final int week = day * 7;
        int interval = Util.parseInt(intervalString, 0);
        switch(interval) {
            case hour:
                summaryId = R.string.pref_background_update_interval_hourly;
                break;
            case day:
                summaryId = R.string.pref_background_update_interval_daily;
                break;
            case week:
                summaryId = R.string.pref_background_update_interval_weekly;
                break;
            case 0:
                summaryId = R.string.pref_background_update_interval_never;
                break;
            default:
            case -1:
                summaryId = R.string.pref_background_update_interval_manually;
                break;
        }
        return summaryId;
    }

    private clreplaced AlsoInstallOnPreferenceChangeListener implements Preference.OnPreferenceChangeListener {

        @Override
        public boolean onPreferenceChange(Preference preference, Object newValue) {
            if ((Boolean) newValue) {
                if (isPrivileged()) {
                    return true;
                } else {
                    new CheckSuTask(activity).execute();
                }
            }
            return true;
        }

        private boolean isPrivileged() {
            return activity.getPackageManager().checkPermission(Manifest.permission.INSTALL_PACKAGES, BuildConfig.APPLICATION_ID) == PackageManager.PERMISSION_GRANTED;
        }
    }
}

19 Source : CheckUpdates.java
with GNU General Public License v2.0
from yeriomin

public void setCheckForUpdates(ListPreference checkForUpdates) {
    this.checkForUpdates = checkForUpdates;
}

19 Source : Blacklist.java
with GNU General Public License v2.0
from yeriomin

public clreplaced Blacklist extends Abstract {

    private ListPreference blackOrWhite;

    private MultiSelectListPreference appList;

    private CheckBoxPreference autoWhitelist;

    public Blacklist(PreferenceActivity activity) {
        super(activity);
    }

    public void setBlackOrWhite(ListPreference blackOrWhite) {
        this.blackOrWhite = blackOrWhite;
    }

    public void setAppList(MultiSelectListPreference appList) {
        this.appList = appList;
    }

    public void setAutoWhitelist(CheckBoxPreference autoWhitelist) {
        this.autoWhitelist = autoWhitelist;
    }

    @Override
    public void draw() {
        AppListTask task = new AppListTask(appList);
        task.setIncludeSystemApps(true);
        task.execute();
        Preference.OnPreferenceChangeListener listener = new BlackListOnPreferenceChangeListener(appList, autoWhitelist);
        blackOrWhite.setOnPreferenceChangeListener(listener);
        listener.onPreferenceChange(blackOrWhite, blackOrWhite.getValue());
    }

    static clreplaced BlackListOnPreferenceChangeListener implements Preference.OnPreferenceChangeListener {

        private MultiSelectListPreference appList;

        private CheckBoxPreference autoWhitelist;

        public BlackListOnPreferenceChangeListener(MultiSelectListPreference appList, CheckBoxPreference autoWhitelist) {
            this.appList = appList;
            this.autoWhitelist = autoWhitelist;
        }

        @Override
        public boolean onPreferenceChange(Preference preference, Object newValue) {
            String value = (String) newValue;
            boolean isBlackList = null != value && value.equals(PreferenceUtil.LIST_BLACK);
            appList.setreplacedle(appList.getContext().getString(isBlackList ? R.string.pref_update_list_black : R.string.pref_update_list_white));
            appList.setDialogreplacedle(appList.getreplacedle());
            preference.setSummary(appList.getContext().getString(isBlackList ? R.string.pref_update_list_white_or_black_black : R.string.pref_update_list_white_or_black_white));
            autoWhitelist.setEnabled(!isBlackList);
            return true;
        }
    }

    static clreplaced AppListTask extends InstalledAppsTask {

        private MultiSelectListPreference appList;

        private Map<String, String> appNames;

        public AppListTask(MultiSelectListPreference appList) {
            this.appList = appList;
            setContext(appList.getContext());
        }

        @Override
        protected void onPreExecute() {
            appList.setEntries(new String[0]);
            appList.setEntryValues(new String[0]);
        }

        @Override
        protected void onPostExecute(Map<String, App> installedApps) {
            int count = appNames.size();
            appList.setEntries(appNames.values().toArray(new String[count]));
            appList.setEntryValues(appNames.keySet().toArray(new String[count]));
        }

        @Override
        protected Map<String, App> doInBackground(String... strings) {
            Map<String, App> installedApps = super.doInBackground(strings);
            Map<String, String> appNames = new HashMap<>();
            for (String packageName : installedApps.keySet()) {
                appNames.put(packageName, installedApps.get(packageName).getDisplayName());
            }
            this.appNames = Util.sort(appNames);
            return installedApps;
        }
    }
}

19 Source : Blacklist.java
with GNU General Public License v2.0
from yeriomin

public void setBlackOrWhite(ListPreference blackOrWhite) {
    this.blackOrWhite = blackOrWhite;
}

19 Source : DevelopmentSettingsActivity.java
with Apache License 2.0
from XuDaojie

/**
 * Created by xdj on 2017/3/4.
 */
public clreplaced DevelopmentSettingsActivity extends AppCompatPreferenceActivity {

    private static final String TAG = DevelopmentSettingsActivity.clreplaced.getSimpleName();

    private boolean mRootPermission = false;

    private Handler mRootHandler = new Handler() {

        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            mDebugLayoutPref.setEnabled(mRootPermission);
            mDebugHwOverdrawPref.setEnabled(mRootPermission);
            mDebugHwOverdraw.setEnabled(mRootPermission);
        }
    };

    private SwitchPreference mDebugLayoutPref;

    private ListPreference mDebugHwOverdrawPref;

    private ListPreference mDebugHwOverdraw;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        getSupportActionBar().setDisplayHomeAsUpEnabled(true);
        // addPreferencesFromResource(R.xml.pref_developerment_settings);
        addPreferencesFromResource(R.xml.pref_developerment_settings);
        mDebugLayoutPref = (SwitchPreference) findPreference("debug_layout");
        // DevelopmentSettings.DEBUG_HW_OVERDRAW_KEY 调试GPU过度绘制
        mDebugHwOverdrawPref = (ListPreference) findPreference("debug_hw_overdraw");
        // DevelopmentSettings.TRACK_FRAME_TIME_KEY GPU呈现模式分析
        mDebugHwOverdraw = (ListPreference) findPreference("track_frame_time");
    }

    @Override
    protected void onResume() {
        super.onResume();
        checkRootPermission();
        updateAllOptions();
        findPreference("development_options").setOnPreferenceClickListener(new Preference.OnPreferenceClickListener() {

            @Override
            public boolean onPreferenceClick(Preference preference) {
                Intent i = new Intent(Settings.ACTION_APPLICATION_DEVELOPMENT_SETTINGS);
                startActivity(i);
                return true;
            }
        });
        findPreference("about").setOnPreferenceClickListener(new Preference.OnPreferenceClickListener() {

            @Override
            public boolean onPreferenceClick(Preference preference) {
                Intent i = new Intent(Intent.ACTION_VIEW);
                i.setData(Uri.parse("https://github.com/XuDaojie/DeveloperSettings"));
                i.createChooser(i, null);
                startActivity(i);
                return true;
            }
        });
    }

    private void checkRootPermission() {
        new Thread() {

            @Override
            public void run() {
                super.run();
                // 耗时操作
                mRootPermission = ShellUtils.checkRootPermission();
                mRootHandler.sendEmptyMessage(0);
            }
        }.start();
    }

    private void updateAllOptions() {
        updateShowTouchesOptions();
        updatePointerLocationOptions();
        updateDebugLayoutOptions();
        updateDebugHwOverdraw();
        updateTrackFrameTime();
    }

    private void updateShowTouchesOptions() {
        final SwitchPreference showTouchesPref = (SwitchPreference) findPreference("show_touches");
        int enable = 0;
        try {
            enable = Settings.System.getInt(getContentResolver(), Constants.SETTINGS_SYSTEM_SHOW_TOUCHES);
        } catch (Settings.SettingNotFoundException e) {
            e.printStackTrace();
        }
        showTouchesPref.setChecked(enable == 1);
        showTouchesPref.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

            @Override
            public boolean onPreferenceChange(Preference preference, Object newValue) {
                Settings.System.putInt(getContentResolver(), Constants.SETTINGS_SYSTEM_SHOW_TOUCHES, newValue == Boolean.TRUE ? 1 : 0);
                return true;
            }
        });
    }

    private void updatePointerLocationOptions() {
        final SwitchPreference pointerLocationPref = (SwitchPreference) findPreference("pointer_location");
        int enable = 0;
        try {
            enable = Settings.System.getInt(getContentResolver(), Constants.SETTINGS_SYSTEM_POINTER_LOCATION);
        } catch (Settings.SettingNotFoundException e) {
            e.printStackTrace();
        }
        pointerLocationPref.setChecked(enable == 1);
        pointerLocationPref.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

            @Override
            public boolean onPreferenceChange(Preference preference, Object newValue) {
                Settings.System.putInt(getContentResolver(), Constants.SETTINGS_SYSTEM_POINTER_LOCATION, newValue == Boolean.TRUE ? 1 : 0);
                return true;
            }
        });
    }

    private void updateDebugLayoutOptions() {
        mDebugLayoutPref.setChecked(SystemProperties.getBoolean(Constants.VIEW_DEBUG_LAYOUT_PROPERTY));
        mDebugLayoutPref.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

            @Override
            public boolean onPreferenceChange(Preference preference, Object newValue) {
                // setprop debug.layout true
                String command = String.format("setprop %s %s", Constants.VIEW_DEBUG_LAYOUT_PROPERTY, newValue == Boolean.TRUE ? "true" : "false");
                ShellUtils.execCommand(command, true);
                new SystemPropPoker().execute();
                return true;
            }
        });
    }

    private void updateDebugHwOverdraw() {
        final CharSequence[] entries = mDebugHwOverdrawPref.getEntries();
        String value = SystemProperties.get(Constants.THREADED_RENDERER_DEBUG_OVERDRAW_PROPERTY);
        int idxOfValue = mDebugHwOverdrawPref.findIndexOfValue(value);
        if (idxOfValue != -1) {
            mDebugHwOverdrawPref.setValueIndex(idxOfValue);
            mDebugHwOverdrawPref.setSummary(entries[idxOfValue]);
        }
        mDebugHwOverdrawPref.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

            @Override
            public boolean onPreferenceChange(Preference preference, Object newValue) {
                // ThreadedRenderer.DEBUG_OVERDRAW_PROPERTY
                String command = String.format("setprop %s %s", Constants.THREADED_RENDERER_DEBUG_OVERDRAW_PROPERTY, newValue.toString());
                ShellUtils.execCommand(command, true);
                new SystemPropPoker().execute();
                int indexOfValue = mDebugHwOverdrawPref.findIndexOfValue(newValue.toString());
                preference.setSummary(entries[indexOfValue]);
                return true;
            }
        });
    }

    private void updateTrackFrameTime() {
        final CharSequence[] entries = mDebugHwOverdraw.getEntries();
        String value = SystemProperties.get(Constants.THREADED_RENDERER_PROFILE_PROPERTY);
        int idxOfValue = mDebugHwOverdraw.findIndexOfValue(value);
        if (idxOfValue != -1) {
            mDebugHwOverdraw.setValueIndex(idxOfValue);
            mDebugHwOverdraw.setSummary(entries[idxOfValue]);
        }
        mDebugHwOverdraw.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

            @Override
            public boolean onPreferenceChange(Preference preference, Object newValue) {
                // ThreadedRenderer.PROFILE_PROPERTY
                String command = String.format("setprop %s %s", Constants.THREADED_RENDERER_PROFILE_PROPERTY, newValue.toString());
                ShellUtils.execCommand(command, true);
                new SystemPropPoker().execute();
                ListPreference listPreference = (ListPreference) preference;
                CharSequence[] entries = listPreference.getEntries();
                int indexOfValue = listPreference.findIndexOfValue(newValue.toString());
                preference.setSummary(entries[indexOfValue]);
                return true;
            }
        });
    }

    public static clreplaced SystemPropPoker extends AsyncTask<Void, Void, Void> {

        // IBinder.SYSPROPS_TRANSACTION
        private static final int SYSPROPS_TRANSACTION = ('_' << 24) | ('S' << 16) | ('P' << 8) | 'R';

        @Override
        protected Void doInBackground(Void... params) {
            // String[] services = ServiceManager.listServices();
            Method serviceManagerListServicesMethod = null;
            Method serviceManagerCheckServiceMethod = null;
            try {
                final Clreplaced serviceManagerClreplaced = Clreplaced.forName("android.os.ServiceManager");
                serviceManagerListServicesMethod = serviceManagerClreplaced.getMethod("listServices");
                serviceManagerCheckServiceMethod = serviceManagerClreplaced.getMethod("checkService", String.clreplaced);
            } catch (ClreplacedNotFoundException e) {
                e.printStackTrace();
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            }
            try {
                String[] services = (String[]) serviceManagerListServicesMethod.invoke(null);
                for (String service : services) {
                    // IBinder obj = ServiceManager.checkService(service);
                    IBinder obj = (IBinder) serviceManagerCheckServiceMethod.invoke(null, service);
                    if (obj != null) {
                        Parcel data = Parcel.obtain();
                        try {
                            obj.transact(SYSPROPS_TRANSACTION, data, null, 0);
                        } catch (RemoteException e) {
                        } catch (Exception e) {
                            Log.i(TAG, "Someone wrote a bad service '" + service + "' that doesn't like to be poked: " + e);
                        }
                        data.recycle();
                    }
                }
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
            return null;
        }
    }
}

19 Source : SettingsFragment.java
with Apache License 2.0
from xietiantian

/**
 * A simple {@link Fragment} subclreplaced.
 * Activities that contain this fragment must implement the
 * {@link SettingsFragment.OnFragmentInteractionListener} interface
 * to handle interaction events.
 * Use the {@link SettingsFragment#newInstance} factory method to
 * create an instance of this fragment.
 */
public clreplaced SettingsFragment extends PreferenceFragment {

    private OnFragmentInteractionListener mListener;

    private ListPreference dirList;

    private ListPreference cleanList;

    public SettingsFragment() {
    // Required empty public constructor
    }

    /**
     * Use this factory method to create a new instance of
     * this fragment using the provided parameters.
     *
     * @return A new instance of fragment SettingsFragment.
     */
    // TODO: Rename and change types and number of parameters
    public static SettingsFragment newInstance() {
        SettingsFragment fragment = new SettingsFragment();
        return fragment;
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        addPreferencesFromResource(R.xml.preferences);
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        View view = super.onCreateView(inflater, container, savedInstanceState);
        Context context = getActivity();
        dirList = (ListPreference) findPreference("FilesDirectoryNew");
        List<String> list = new ArrayList<String>();
        String folderName = context.getString(R.string.folder_name);
        if (context instanceof SettingsActivity) {
            if (((SettingsActivity) context).permissionWriteExternal) {
                // 加入扩展卡存储目录(卸载后不会删除,需要权限)
                String externalDirPath = new StringBuilder(Environment.getExternalStorageDirectory().getAbsolutePath()).append("/").append(folderName).append("/").toString();
                File externalDir = new File(externalDirPath);
                if (externalDir.exists() || externalDir.mkdir()) {
                    list.add(externalDirPath);
                }
            }
        }
        // 加入扩展卡存储目录(卸载后会删除,KITKAT后的版本不需要权限)
        File[] externalFilesDirs = new ContextCompat().getExternalFilesDirs(context, null);
        for (File file : externalFilesDirs) {
            list.add(file.getAbsolutePath());
        }
        // 加入手机内存存储目录(卸载后会删除,不需要权限)
        File filesDir = context.getFilesDir();
        list.add(filesDir.getAbsolutePath());
        String[] entriesArray = new String[list.size()];
        list.toArray(entriesArray);
        dirList.setEntries(entriesArray);
        dirList.setEntryValues(entriesArray);
        dirList.setDefaultValue(entriesArray[0]);
        if (dirList.getEntry() == null) {
            // 首次打开时value值为“1”不是合法路径,先用getEntry判断一下
            // value值不是entryValueArray中的值,将value重新设为默认值
            dirList.setValue(entriesArray[0]);
        }
        String dirString = dirList.getValue();
        dirList.setSummary(dirString);
        if (mListener != null) {
            mListener.onStorgeLocationInit(dirString);
        }
        dirList.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

            @Override
            public boolean onPreferenceChange(Preference preference, Object newValue) {
                dirList.setSummary((String) newValue);
                if (mListener != null) {
                    mListener.onStorgeLocationChanged((String) newValue);
                }
                return true;
            }
        });
        cleanList = (ListPreference) findPreference("OlderThan");
        cleanList.setSummary(cleanList.getEntry());
        cleanList.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

            @Override
            public boolean onPreferenceChange(Preference preference, Object newValue) {
                cleanList.setValue((String) newValue);
                cleanList.setSummary(cleanList.getEntry());
                // 因为已经setValue所以返回false
                return false;
            }
        });
        return view;
    }

    @Override
    public void onAttach(Context context) {
        super.onAttach(context);
        if (context instanceof OnFragmentInteractionListener) {
            mListener = (OnFragmentInteractionListener) context;
        } else {
            throw new RuntimeException(context.toString() + " must implement OnFragmentInteractionListener");
        }
    }

    // SDK API<23时,onAttach(Context)不执行,需要使用onAttach(Activity)。
    // Fragment自身的Bug,v4的Fragment没有此问题
    @Override
    public void onAttach(Activity activity) {
        super.onAttach(activity);
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
            if (activity instanceof OnFragmentInteractionListener) {
                mListener = (OnFragmentInteractionListener) activity;
            } else {
                throw new RuntimeException(activity.toString() + " must implement OnFragmentInteractionListener");
            }
        }
    }

    @Override
    public void onDetach() {
        super.onDetach();
        mListener = null;
    }

    /**
     * This interface must be implemented by activities that contain this
     * fragment to allow an interaction in this fragment to be communicated
     * to the activity and potentially other fragments contained in that
     * activity.
     * <p/>
     * See the Android Training lesson <a href=
     * "http://developer.android.com/training/basics/fragments/communicating.html"
     * >Communicating with Other Fragments</a> for more information.
     */
    public interface OnFragmentInteractionListener {

        // TODO: Update argument type and name
        void onStorgeLocationChanged(String path);

        void onStorgeLocationInit(String path);
    }
}

19 Source : SettingsPreferenceFragment.java
with GNU Affero General Public License v3.0
from vijai1996

/**
 * <p>
 *     This fragment handles various settings of the recorder.
 * </p>
 *
 * @author Vijai Chandra Prasad .R
 * @see android.content.SharedPreferences.OnSharedPreferenceChangeListener
 * @see PermissionResultListener
 * @see OnDirectorySelectedListerner
 * @see com.orpheusdroid.screenrecorder.MainActivity.replacedyticsSettingsListerner
 */
public clreplaced SettingsPreferenceFragment extends PreferenceFragment implements SharedPreferences.OnSharedPreferenceChangeListener, PermissionResultListener, OnDirectorySelectedListerner, MainActivity.replacedyticsSettingsListerner {

    /**
     * SharedPreferences object to read the persisted settings
     */
    SharedPreferences prefs;

    /**
     * ListPreference to choose the recording resolution
     */
    private ListPreference res;

    /**
     * CheckBoxPreference to manage audio recording via mic setting
     */
    private CheckBoxPreference recaudio;

    /**
     * CheckBoxPreference to manage onscreen floating control setting
     */
    private CheckBoxPreference floatingControl;

    /**
     * CheckBoxPreference to manage crash reporting via countly setting
     */
    private CheckBoxPreference crashReporting;

    /**
     * CheckBoxPreference to manage full replacedytics via countly setting
     */
    private CheckBoxPreference usageStats;

    /**
     * FolderChooser object to choose the directory where the video has to be saved to.
     */
    private FolderChooser dirChooser;

    /**
     * MainActivity object
     */
    private MainActivity activity;

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
    }

    /**
     * Initialize various listeners and settings preferences.
     *
     * @param savedInstanceState default savedInstance bundle sent by Android runtime
     */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        addPreferencesFromResource(R.xml.settings);
        // init permission listener callback
        setPermissionListener();
        setreplacedyticsPermissionListerner();
        // Get Default save location from shared preference
        String defaultSaveLoc = (new File(Environment.getExternalStorageDirectory() + File.separator + Const.APPDIR)).getPath();
        // Get instances of all preferences
        prefs = getPreferenceScreen().getSharedPreferences();
        res = (ListPreference) findPreference(getString(R.string.res_key));
        ListPreference fps = (ListPreference) findPreference(getString(R.string.fps_key));
        ListPreference bitrate = (ListPreference) findPreference(getString(R.string.bitrate_key));
        recaudio = (CheckBoxPreference) findPreference(getString(R.string.audiorec_key));
        ListPreference filenameFormat = (ListPreference) findPreference(getString(R.string.filename_key));
        EditTextPreference filenamePrefix = (EditTextPreference) findPreference(getString(R.string.fileprefix_key));
        dirChooser = (FolderChooser) findPreference(getString(R.string.savelocation_key));
        floatingControl = (CheckBoxPreference) findPreference(getString(R.string.preference_floating_control_key));
        CheckBoxPreference touchPointer = (CheckBoxPreference) findPreference("touch_pointer");
        crashReporting = (CheckBoxPreference) findPreference(getString(R.string.preference_crash_reporting_key));
        usageStats = (CheckBoxPreference) findPreference(getString(R.string.preference_anonymous_statistics_key));
        // Set previously chosen directory as initial directory
        dirChooser.setCurrentDir(getValue(getString(R.string.savelocation_key), defaultSaveLoc));
        ListPreference theme = (ListPreference) findPreference(getString(R.string.preference_theme_key));
        theme.setSummary(theme.getEntry());
        // Set the summary of preferences dynamically with user choice or default if no user choice is made
        updateScreenAspectRatio();
        updateResolution(res);
        fps.setSummary(getValue(getString(R.string.fps_key), "30"));
        float bps = bitsToMb(Integer.parseInt(getValue(getString(R.string.bitrate_key), "7130317")));
        bitrate.setSummary(bps + " Mbps");
        dirChooser.setSummary(getValue(getString(R.string.savelocation_key), defaultSaveLoc));
        filenameFormat.setSummary(getFileSaveFormat());
        filenamePrefix.setSummary(getValue(getString(R.string.fileprefix_key), "recording"));
        // If record audio checkbox is checked, check for record audio permission
        if (recaudio.isChecked())
            requestAudioPermission();
        // If floating controls is checked, check for system windows permission
        if (floatingControl.isChecked())
            requestSystemWindowsPermission();
        if (touchPointer.isChecked()) {
            if (!hasPluginInstalled())
                touchPointer.setChecked(false);
        }
        // set callback for directory change
        dirChooser.setOnDirectoryClickedListerner(this);
    }

    /**
     * Updates the summary of resolution settings preference
     *
     * @param pref object of the resolution ListPreference
     */
    private void updateResolution(ListPreference pref) {
        pref.setSummary(getValue(getString(R.string.res_key), getNativeRes()));
    }

    /**
     * Method to get the device's native resolution
     *
     * @return device resolution
     */
    private String getNativeRes() {
        DisplayMetrics metrics = getRealDisplayMetrics();
        return getScreenWidth(metrics) + "x" + getScreenHeight(metrics);
    }

    /**
     * Updates the available resolution based on aspect ratio
     */
    private void updateScreenAspectRatio() {
        Const.ASPECT_RATIO aspect_ratio = getAspectRatio();
        Log.d(Const.TAG, "Aspect ratio: " + aspect_ratio);
        CharSequence[] entriesValues = getResolutionEntriesValues(aspect_ratio);
        res.setEntries(entriesValues);
        res.setEntryValues(entriesValues);
    }

    /**
     * Get resolutions based on the device's aspect ratio
     *
     * @param aspectRatio {@link com.orpheusdroid.screenrecorder.Const.ASPECT_RATIO} of the device
     * @return entries for the resolution
     */
    private CharSequence[] getResolutionEntriesValues(Const.ASPECT_RATIO aspectRatio) {
        ArrayList<String> entries;
        switch(aspectRatio) {
            case AR16_9:
                entries = buildEntries(R.array.resolutionsArray_16_9);
                break;
            case AR18_9:
                entries = buildEntries(R.array.resolutionValues_18_9);
                break;
            default:
                entries = buildEntries(R.array.resolutionsArray_16_9);
                break;
        }
        String[] entriesArray = new String[entries.size()];
        return entries.toArray(entriesArray);
    }

    /**
     * Build resolutions from the arrays.
     *
     * @param resID resource ID for the resolution array
     * @return ArrayList of available resolutions
     */
    private ArrayList<String> buildEntries(int resID) {
        DisplayMetrics metrics = getRealDisplayMetrics();
        int width = getScreenWidth(metrics);
        int height = getScreenHeight(metrics);
        String nativeRes = width + "x" + height;
        ArrayList<String> entries = new ArrayList<>(Arrays.asList(getResources().getStringArray(resID)));
        Iterator<String> entriesIterator = entries.iterator();
        while (entriesIterator.hasNext()) {
            String entry = entriesIterator.next();
            String[] widthHeight = entry.split("x");
            if (width < Integer.parseInt(widthHeight[0]) || height < Integer.parseInt(widthHeight[1])) {
                entriesIterator.remove();
            }
        }
        if (!entries.contains(nativeRes))
            entries.add(nativeRes);
        return entries;
    }

    /**
     * Returns object of DisplayMetrics
     *
     * @return DisplayMetrics
     */
    private DisplayMetrics getRealDisplayMetrics() {
        DisplayMetrics metrics = new DisplayMetrics();
        WindowManager window = (WindowManager) getActivity().getSystemService(Context.WINDOW_SERVICE);
        window.getDefaultDisplay().getRealMetrics(metrics);
        return metrics;
    }

    /**
     * Get width of screen in pixels
     *
     * @return screen width
     */
    private int getScreenWidth(DisplayMetrics metrics) {
        return metrics.widthPixels;
    }

    /**
     * Get height of screen in pixels
     *
     * @return Screen height
     */
    private int getScreenHeight(DisplayMetrics metrics) {
        return metrics.heightPixels;
    }

    /**
     * Get aspect ratio of the screen
     */
    private Const.ASPECT_RATIO getAspectRatio() {
        float screen_width = getScreenWidth(getRealDisplayMetrics());
        float screen_height = getScreenHeight(getRealDisplayMetrics());
        float aspectRatio;
        if (screen_width > screen_height) {
            aspectRatio = screen_width / screen_height;
        } else {
            aspectRatio = screen_height / screen_width;
        }
        return Const.ASPECT_RATIO.valueOf(aspectRatio);
    }

    /**
     * Set permission listener in the {@link MainActivity} to handle permission results
     */
    private void setPermissionListener() {
        if (getActivity() != null && getActivity() instanceof MainActivity) {
            activity = (MainActivity) getActivity();
            activity.setPermissionResultListener(this);
        }
    }

    /**
     * Set replacedytics permission listener in {@link MainActivity} to listen to replacedytics permission changes
     */
    private void setreplacedyticsPermissionListerner() {
        if (getActivity() != null && getActivity() instanceof MainActivity) {
            activity = (MainActivity) getActivity();
            activity.setreplacedyticsSettingsListerner(this);
        }
    }

    /**
     * Get the persisted value for the preference from default sharedPreference
     *
     * @param key String represnting the sharedpreference key to fetch
     * @param defVal String Default value if the preference does not exist
     * @return String the persisted preference value or default if not found
     */
    private String getValue(String key, String defVal) {
        return prefs.getString(key, defVal);
    }

    /**
     * Method to convert bits per second to MB/s
     *
     * @param bps float bitsPerSecond
     * @return float
     */
    private float bitsToMb(float bps) {
        return bps / (1024 * 1024);
    }

    // Register for OnSharedPreferenceChangeListener when the fragment resumes
    @Override
    public void onResume() {
        super.onResume();
        getPreferenceScreen().getSharedPreferences().registerOnSharedPreferenceChangeListener(this);
    }

    // Unregister for OnSharedPreferenceChangeListener when the fragment pauses
    @Override
    public void onPause() {
        super.onPause();
        getPreferenceScreen().getSharedPreferences().unregisterOnSharedPreferenceChangeListener(this);
    }

    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
    }

    // When user changes preferences, update the summary accordingly
    @Override
    public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String s) {
        Preference pref = findPreference(s);
        if (pref == null)
            return;
        switch(pref.getreplacedleRes()) {
            case R.string.preference_resolution_replacedle:
                updateResolution((ListPreference) pref);
                break;
            case R.string.preference_fps_replacedle:
                String fps = String.valueOf(getValue(getString(R.string.fps_key), "30"));
                pref.setSummary(fps);
                break;
            case R.string.preference_bit_replacedle:
                float bps = bitsToMb(Integer.parseInt(getValue(getString(R.string.bitrate_key), "7130317")));
                pref.setSummary(bps + " Mbps");
                break;
            case R.string.preference_filename_format_replacedle:
                pref.setSummary(getFileSaveFormat());
                break;
            case R.string.preference_audio_record_replacedle:
                requestAudioPermission();
                break;
            case R.string.preference_filename_prefix_replacedle:
                EditTextPreference etp = (EditTextPreference) pref;
                etp.setSummary(etp.getText());
                ListPreference filename = (ListPreference) findPreference(getString(R.string.filename_key));
                filename.setSummary(getFileSaveFormat());
                break;
            case R.string.preference_floating_control_replacedle:
                requestSystemWindowsPermission();
                break;
            case R.string.preference_show_touch_replacedle:
                CheckBoxPreference showTouchCB = (CheckBoxPreference) pref;
                if (showTouchCB.isChecked() && !hasPluginInstalled()) {
                    showTouchCB.setChecked(false);
                    showDownloadAlert();
                }
                break;
            case R.string.preference_crash_reporting_replacedle:
                CheckBoxPreference crashReporting = (CheckBoxPreference) pref;
                CheckBoxPreference anonymousStats = (CheckBoxPreference) findPreference(getString(R.string.preference_anonymous_statistics_key));
                if (!crashReporting.isChecked())
                    anonymousStats.setChecked(false);
                startreplacedytics();
                break;
            case R.string.preference_anonymous_statistics_replacedle:
                startreplacedytics();
                break;
            case R.string.preference_theme_replacedle:
                activity.recreate();
                break;
        }
    }

    /**
     * show an alert to download the plugin when the plugin is not found
     */
    private void showDownloadAlert() {
        new AlertDialog.Builder(getActivity()).setreplacedle(R.string.alert_plugin_not_found_replacedle).setMessage(R.string.alert_plugin_not_found_message).setPositiveButton(android.R.string.yes, new DialogInterface.OnClickListener() {

            @Override
            public void onClick(DialogInterface dialogInterface, int i) {
                try {
                    getActivity().startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse("market://details?id=com.orpheusdroid.screencamplugin")));
                } catch (android.content.ActivityNotFoundException e) {
                    // if there is no Google Play on device
                    getActivity().startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse("https://play.google.com/store/apps/details?id=com.orpheusdroid.screencamplugin")));
                }
            }
        }).setNeutralButton(android.R.string.no, new DialogInterface.OnClickListener() {

            @Override
            public void onClick(DialogInterface dialogInterface, int i) {
            }
        }).create().show();
    }

    /**
     * Check if "show touches" plugin is installed.
     *
     * @return boolean
     */
    private boolean hasPluginInstalled() {
        PackageManager pm = getActivity().getPackageManager();
        try {
            pm.getPackageInfo("com.orpheusdroid.screencamplugin", PackageManager.GET_META_DATA);
        } catch (PackageManager.NameNotFoundException e) {
            Log.d(Const.TAG, "Plugin not installed");
            return false;
        }
        return true;
    }

    /**
     * Method to concat file prefix with dateTime format
     */
    public String getFileSaveFormat() {
        String filename = prefs.getString(getString(R.string.filename_key), "yyyyMMdd_hhmmss");
        String prefix = prefs.getString(getString(R.string.fileprefix_key), "recording");
        return prefix + "_" + filename;
    }

    /**
     * Method to request android permission to record audio
     */
    public void requestAudioPermission() {
        if (activity != null) {
            activity.requestPermissionAudio();
        }
    }

    /**
     * Method to request android system windows permission to show floating controls
     * <p>
     *     Shown only on devices above api 23 (Marshmallow)
     * </p>
     */
    private void requestSystemWindowsPermission() {
        if (activity != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            activity.requestSystemWindowsPermission();
        } else {
            Log.d(Const.TAG, "API is < 23");
        }
    }

    /**
     * Show snackbar with permission Intent when the user rejects write storage permission
     */
    private void showSnackbar() {
        Snackbar.make(getActivity().findViewById(R.id.fab), R.string.snackbar_storage_permission_message, Snackbar.LENGTH_INDEFINITE).setAction(R.string.snackbar_storage_permission_action_enable, new View.OnClickListener() {

            @Override
            public void onClick(View v) {
                if (activity != null) {
                    activity.requestPermissionStorage();
                }
            }
        }).show();
    }

    /**
     * Show a dialog when the permission to storage is denied by the user during startup
     */
    private void showPermissionDeniedDialog() {
        new AlertDialog.Builder(activity).setreplacedle(R.string.alert_permission_denied_replacedle).setMessage(R.string.alert_permission_denied_message).setPositiveButton(android.R.string.yes, new DialogInterface.OnClickListener() {

            @Override
            public void onClick(DialogInterface dialogInterface, int i) {
                if (activity != null) {
                    activity.requestPermissionStorage();
                }
            }
        }).setNegativeButton(android.R.string.no, new DialogInterface.OnClickListener() {

            @Override
            public void onClick(DialogInterface dialogInterface, int i) {
                showSnackbar();
            }
        }).setIconAttribute(android.R.attr.alertDialogIcon).setCancelable(false).create().show();
    }

    // Permission result callback to process the result of Marshmallow style permission request
    @Override
    public void onPermissionResult(int requestCode, String[] permissions, int[] grantResults) {
        switch(requestCode) {
            case Const.EXTDIR_REQUEST_CODE:
                if ((grantResults.length > 0) && (grantResults[0] == PackageManager.PERMISSION_DENIED)) {
                    Log.d(Const.TAG, "Storage permission denied. Requesting again");
                    dirChooser.setEnabled(false);
                    showPermissionDeniedDialog();
                } else if ((grantResults.length > 0) && (grantResults[0] == PackageManager.PERMISSION_GRANTED)) {
                    dirChooser.setEnabled(true);
                }
                return;
            case Const.AUDIO_REQUEST_CODE:
                if ((grantResults.length > 0) && (grantResults[0] == PackageManager.PERMISSION_GRANTED)) {
                    Log.d(Const.TAG, "Record audio permission granted.");
                    recaudio.setChecked(true);
                } else {
                    Log.d(Const.TAG, "Record audio permission denied");
                    recaudio.setChecked(false);
                }
                return;
            case Const.SYSTEM_WINDOWS_CODE:
                if ((grantResults.length > 0) && (grantResults[0] == PackageManager.PERMISSION_GRANTED)) {
                    Log.d(Const.TAG, "System Windows permission granted");
                    floatingControl.setChecked(true);
                } else {
                    Log.d(Const.TAG, "System Windows permission denied");
                    floatingControl.setChecked(false);
                }
            default:
                Log.d(Const.TAG, "Unknown permission request with request code: " + requestCode);
        }
    }

    @Override
    public void onDirectorySelected() {
        Log.d(Const.TAG, "In settings fragment");
        if (getActivity() != null && getActivity() instanceof MainActivity) {
            ((MainActivity) getActivity()).onDirectoryChanged();
        }
    }

    @Override
    public void updatereplacedyticsSettings(Const.replacedytics replacedytics) {
        switch(replacedytics) {
            case CRASHREPORTING:
                crashReporting.setChecked(true);
                break;
            case USAGESTATS:
                usageStats.setChecked(true);
                break;
        }
    }

    /**
     * Start replacedytics service with user chosen config
     */
    private void startreplacedytics() {
        if (getActivity() != null && getActivity() instanceof MainActivity) {
            ((MainActivity) getActivity()).setupreplacedytics();
        }
    }
}

19 Source : VoipMS.java
with GNU General Public License v3.0
from treasure-lau

public clreplaced VoipMS extends SimpleImplementation {

    @Override
    protected String getDefaultName() {
        return "VoIP.ms";
    }

    ListPreference sipServer;

    static SortedMap<String, String> providers = new TreeMap<String, String>() {

        private static final long serialVersionUID = -2561302247222706262L;

        {
            put("Atlanta, GA", "atlanta.voip.ms");
            put("Atlanta 2, GA", "atlanta2.voip.ms");
            put("Chicago, IL", "chicago.voip.ms");
            put("Chicago 2, IL", "chicago2.voip.ms");
            put("Chicago 3, IL", "chicago3.voip.ms");
            put("Chicago 4, IL", "chicago4.voip.ms");
            put("Dallas, TX", "dallas.voip.ms");
            put("Denver, Colorado", "denver.voip.ms");
            put("Denver 2, Colorado", "denver2.voip.ms");
            put("Houston, TX", "houston.voip.ms");
            put("Los Angeles, CA", "losangeles.voip.ms");
            put("Los Angeles 2, CA", "losangeles2.voip.ms");
            put("New York, NY", "newyork.voip.ms");
            put("New York 2, NY", "newyork2.voip.ms");
            put("New York 3, NY", "newyork3.voip.ms");
            put("New York 4, NY", "newyork4.voip.ms");
            put("Seattle, WA", "seattle.voip.ms");
            put("Seattle 2, WA", "seattle2.voip.ms");
            put("Seattle 3, WA", "seattle3.voip.ms");
            put("Tampa, FL", "tampa.voip.ms");
            put("Montreal,QC", "montreal.voip.ms");
            put("Montreal 2,QC", "montreal2.voip.ms");
            put("Montreal 3,QC", "montreal3.voip.ms");
            put("Montreal 4,QC", "montreal4.voip.ms");
            put("Toronto, ON", "toronto.voip.ms");
            put("Toronto 2, ON", "toronto2.voip.ms");
            put("Toronto 3, ON", "toronto3.voip.ms");
            put("Toronto 4, ON", "toronto4.voip.ms");
            put("Washington, DC", "washington.voip.ms");
            put("Washington 2, DC", "washington2.voip.ms");
            put("London, UK", "london.voip.ms");
            put("Vancouver", "vancouver.voip.ms");
            put("Vancouver 2", "vancouver2.voip.ms");
        }
    };

    private static final String PROVIDER_LIST_KEY = "provider_list";

    @Override
    public void fillLayout(final SipProfile account) {
        super.fillLayout(account);
        boolean recycle = true;
        sipServer = (ListPreference) findPreference(PROVIDER_LIST_KEY);
        if (sipServer == null) {
            sipServer = new ListPreference(parent);
            sipServer.setKey(PROVIDER_LIST_KEY);
            recycle = false;
        }
        CharSequence[] e = new CharSequence[providers.size()];
        CharSequence[] v = new CharSequence[providers.size()];
        int i = 0;
        for (String pv : providers.keySet()) {
            e[i] = pv;
            v[i] = providers.get(pv);
            i++;
        }
        sipServer.setEntries(e);
        sipServer.setEntryValues(v);
        sipServer.setDialogreplacedle(R.string.w_common_server);
        sipServer.setreplacedle(R.string.w_common_server);
        sipServer.setDefaultValue("atlanta.voip.ms");
        if (!recycle) {
            addPreference(sipServer);
        }
        String domain = account.reg_uri;
        if (domain != null) {
            for (CharSequence state : v) {
                String currentComp = "sip:" + state;
                if (currentComp.equalsIgnoreCase(domain)) {
                    sipServer.setValue(state.toString());
                    break;
                }
            }
        }
    }

    protected String getDomain() {
        String provider = sipServer.getValue();
        if (provider != null) {
            return provider;
        }
        return "";
    }

    @Override
    public void updateDescriptions() {
        super.updateDescriptions();
        setStringFieldSummary(PROVIDER_LIST_KEY);
    }

    @Override
    public String getDefaultFieldSummary(String fieldName) {
        if (fieldName == PROVIDER_LIST_KEY) {
            if (sipServer != null) {
                return sipServer.getEntry().toString();
            }
        }
        return super.getDefaultFieldSummary(fieldName);
    }

    /* (non-Javadoc)
	 * @see com.csipsimple.wizards.impl.SimpleImplementation#buildAccount(com.csipsimple.api.SipProfile)
	 */
    @Override
    public SipProfile buildAccount(SipProfile account) {
        SipProfile acc = super.buildAccount(account);
        acc.vm_nbr = "*97";
        return acc;
    }
}

19 Source : Vitelity.java
with GNU General Public License v3.0
from treasure-lau

public clreplaced Vitelity extends SimpleImplementation {

    @Override
    protected String getDefaultName() {
        return "Vitelity";
    }

    ListPreference sipServer;

    static SortedMap<String, String> providers = new TreeMap<String, String>() {

        private static final long serialVersionUID = -2561302247222706262L;

        {
            put("sip1", "sip1.vitelity.net");
            put("sip2", "sip2.vitelity.net");
            put("sip3", "sip3.vitelity.net");
            put("sip4", "sip4.vitelity.net");
            put("sip5", "sip5.vitelity.net");
            put("sip6", "sip6.vitelity.net");
            put("sip7", "sip7.vitelity.net");
            put("sip8", "sip8.vitelity.net");
            put("sip9", "sip9.vitelity.net");
        }
    };

    private static final String PROVIDER_LIST_KEY = "provider_list";

    @Override
    public void fillLayout(final SipProfile account) {
        super.fillLayout(account);
        boolean recycle = true;
        sipServer = (ListPreference) findPreference(PROVIDER_LIST_KEY);
        if (sipServer == null) {
            sipServer = new ListPreference(parent);
            sipServer.setKey(PROVIDER_LIST_KEY);
            recycle = false;
        }
        CharSequence[] e = new CharSequence[providers.size()];
        CharSequence[] v = new CharSequence[providers.size()];
        int i = 0;
        for (String pv : providers.keySet()) {
            e[i] = pv;
            v[i] = providers.get(pv);
            i++;
        }
        sipServer.setEntries(e);
        sipServer.setEntryValues(v);
        sipServer.setDialogreplacedle(R.string.w_common_server);
        sipServer.setreplacedle(R.string.w_common_server);
        sipServer.setDefaultValue("sip1.vitelity.net");
        if (!recycle) {
            addPreference(sipServer);
        }
        String domain = account.reg_uri;
        if (domain != null) {
            for (CharSequence state : v) {
                String currentComp = "sip:" + state;
                if (currentComp.equalsIgnoreCase(domain)) {
                    sipServer.setValue(state.toString());
                    break;
                }
            }
        }
    }

    protected String getDomain() {
        String provider = sipServer.getValue();
        if (provider != null) {
            return provider;
        }
        return "";
    }

    @Override
    public void updateDescriptions() {
        super.updateDescriptions();
        setStringFieldSummary(PROVIDER_LIST_KEY);
    }

    @Override
    public String getDefaultFieldSummary(String fieldName) {
        if (fieldName == PROVIDER_LIST_KEY) {
            if (sipServer != null) {
                return sipServer.getEntry().toString();
            }
        }
        return super.getDefaultFieldSummary(fieldName);
    }

    @Override
    public List<Filter> getDefaultFilters(SipProfile acc) {
        // For US and Canada resident, auto add 10 digits => prefix with 1 rewriting rule
        String country = Locale.getDefault().getCountry();
        if (Locale.CANADA.getCountry().equals(country) || Locale.US.getCountry().equals(country)) {
            ArrayList<Filter> filters = new ArrayList<Filter>();
            Filter f = new Filter();
            f.account = (int) acc.id;
            f.action = Filter.ACTION_REPLACE;
            f.matchPattern = "^(\\d{10})$";
            f.replacePattern = "1$0";
            f.matchType = Filter.MATCHER_HAS_N_DIGIT;
            filters.add(f);
            return filters;
        }
        return null;
    }
}

19 Source : SuperCel.java
with GNU General Public License v3.0
from treasure-lau

public clreplaced SuperCel extends SimpleImplementation {

    ListPreference sipServer;

    static SortedMap<String, String> providers = new TreeMap<String, String>() {

        /**
         */
        private static final long serialVersionUID = 2291298928765427732L;

        {
            put("SuperCel", "67.222.131.147");
            put("SuperCel-2", "sip2.supersip.tk");
            put("SuperCel-3", "sip3.supersip.tk");
            put("SuperCel-4", "sip4.supersip.tk");
        }
    };

    private static final String PROVIDER_LIST_KEY = "provider_list";

    @Override
    protected String getDomain() {
        String provider = sipServer.getValue();
        if (provider != null) {
            return provider;
        }
        return "67.222.131.147";
    }

    /* (non-Javadoc)
	 * @see com.csipsimple.wizards.impl.SimpleImplementation#fillLayout(com.csipsimple.api.SipProfile)
	 */
    @Override
    public void fillLayout(SipProfile account) {
        super.fillLayout(account);
        boolean recycle = true;
        sipServer = (ListPreference) findPreference(PROVIDER_LIST_KEY);
        if (sipServer == null) {
            sipServer = new ListPreference(parent);
            sipServer.setKey(PROVIDER_LIST_KEY);
            recycle = false;
        }
        CharSequence[] e = new CharSequence[providers.size()];
        CharSequence[] v = new CharSequence[providers.size()];
        int i = 0;
        for (String pv : providers.keySet()) {
            e[i] = pv;
            v[i] = providers.get(pv);
            i++;
        }
        sipServer.setEntries(e);
        sipServer.setEntryValues(v);
        sipServer.setDialogreplacedle(R.string.w_common_server);
        sipServer.setreplacedle(R.string.w_common_server);
        sipServer.setDefaultValue("67.222.131.147");
        if (!recycle) {
            addPreference(sipServer);
        }
        String domain = account.reg_uri;
        if (domain != null) {
            for (CharSequence state : v) {
                String currentComp = "sip:" + state;
                if (currentComp.equalsIgnoreCase(domain)) {
                    sipServer.setValue(state.toString());
                    break;
                }
            }
        }
    }

    @Override
    protected String getDefaultName() {
        return "SuperCel";
    }

    @Override
    public void updateDescriptions() {
        super.updateDescriptions();
        setStringFieldSummary(PROVIDER_LIST_KEY);
    }

    @Override
    public String getDefaultFieldSummary(String fieldName) {
        if (fieldName == PROVIDER_LIST_KEY) {
            if (sipServer != null) {
                return sipServer.getEntry().toString();
            }
        }
        return super.getDefaultFieldSummary(fieldName);
    }
}

19 Source : SipCel.java
with GNU General Public License v3.0
from treasure-lau

public clreplaced SipCel extends SimpleImplementation {

    private static final String KEY_SERVER_PORT = "server_port";

    private ListPreference accountPort;

    private boolean accountPortAdded = false;

    @Override
    protected String getDomain() {
        return "sip.sipcel.mobi";
    }

    @Override
    protected String getDefaultName() {
        return "SipCel";
    }

    /* (non-Javadoc)
	 * @see com.csipsimple.wizards.impl.SimpleImplementation#updateDescriptions()
	 */
    @Override
    public void updateDescriptions() {
        super.updateDescriptions();
        setListFieldSummary(KEY_SERVER_PORT);
        if (accountUseTcp.isChecked()) {
            if (accountPortAdded) {
                hidePreference(null, KEY_SERVER_PORT);
                accountPortAdded = false;
            }
        } else {
            if (!accountPortAdded) {
                addPreference(accountPort);
                accountPortAdded = true;
            }
        }
    }

    /* (non-Javadoc)
	 * @see com.csipsimple.wizards.impl.SimpleImplementation#fillLayout(com.csipsimple.api.SipProfile)
	 */
    @Override
    public void fillLayout(SipProfile account) {
        super.fillLayout(account);
        CharSequence[] ports = new CharSequence[] { "5060", "443" };
        boolean recycle = true;
        accountPort = (ListPreference) findPreference(KEY_SERVER_PORT);
        if (accountPort == null) {
            recycle = false;
            accountPort = new ListPreference(parent);
            accountPort.setreplacedle("Server port");
            accountPort.setSummary("Connect to port 443 instead of 5060");
        }
        accountPort.setEntries(ports);
        accountPort.setEntryValues(ports);
        accountPort.setKey(KEY_SERVER_PORT);
        accountPort.setDefaultValue("5060");
        if (account.proxies != null) {
            for (String proxy : account.proxies) {
                if (proxy.endsWith(":443")) {
                    accountPort.setValue("443");
                }
            }
        }
        if (!recycle && account.transport != SipProfile.TRANSPORT_TCP) {
            addPreference(accountPort);
            accountPortAdded = true;
        }
    }

    @Override
    protected boolean canTcp() {
        return true;
    }

    @Override
    public boolean needRestart() {
        return true;
    }

    @Override
    public SipProfile buildAccount(SipProfile account) {
        SipProfile acc = super.buildAccount(account);
        String remoteServerUri = getDomain();
        String proxyPort = "";
        if (acc.transport == SipProfile.TRANSPORT_UDP) {
            proxyPort = ":" + accountPort.getValue();
        }
        acc.proxies = new String[] { "sip:" + remoteServerUri + proxyPort };
        acc.publish_enabled = 1;
        acc.sip_stun_use = 1;
        acc.media_stun_use = 1;
        return acc;
    }

    @Override
    public void setDefaultParams(PreferencesWrapper prefs) {
        super.setDefaultParams(prefs);
        prefs.setPreferenceBooleanValue(SipConfigManager.ECHO_CANCELLATION, true);
        prefs.setPreferenceBooleanValue(SipConfigManager.USE_COMPACT_FORM, true);
        prefs.setPreferenceBooleanValue(SipConfigManager.SUPPORT_MULTIPLE_CALLS, true);
        prefs.setPreferenceBooleanValue(SipConfigManager.ENABLE_QOS, true);
        prefs.setPreferenceStringValue(SipConfigManager.SND_CLOCK_RATE, "8000");
        prefs.setPreferenceStringValue(SipConfigManager.DTMF_MODE, Integer.toString(SipConfigManager.DTMF_MODE_AUTO));
        prefs.setPreferenceStringValue(SipConfigManager.KEEP_ALIVE_INTERVAL_MOBILE, "800");
        prefs.setPreferenceStringValue(SipConfigManager.KEEP_ALIVE_INTERVAL_WIFI, "1200");
        prefs.setPreferenceStringValue(SipConfigManager.TCP_KEEP_ALIVE_INTERVAL_MOBILE, "800");
        prefs.setPreferenceStringValue(SipConfigManager.TCP_KEEP_ALIVE_INTERVAL_WIFI, "1200");
        // For Wifi: Speex 32Khz, speex 16, g729, gsm.
        prefs.setCodecPriority("G729/8000/1", SipConfigManager.CODEC_WB, "242");
        prefs.setCodecPriority("PCMU/8000/1", SipConfigManager.CODEC_WB, "100");
        prefs.setCodecPriority("PCMA/8000/1", SipConfigManager.CODEC_WB, "0");
        prefs.setCodecPriority("G722/16000/1", SipConfigManager.CODEC_WB, "0");
        prefs.setCodecPriority("iLBC/8000/1", SipConfigManager.CODEC_WB, "0");
        prefs.setCodecPriority("speex/8000/1", SipConfigManager.CODEC_WB, "0");
        prefs.setCodecPriority("speex/16000/1", SipConfigManager.CODEC_WB, "243");
        prefs.setCodecPriority("speex/32000/1", SipConfigManager.CODEC_WB, "244");
        prefs.setCodecPriority("GSM/8000/1", SipConfigManager.CODEC_WB, "241");
        // For 3G: G729, GSM 8Khz, Ilbc 8Khz, speex 8Khz.
        prefs.setCodecPriority("G729/8000/1", SipConfigManager.CODEC_NB, "244");
        prefs.setCodecPriority("PCMU/8000/1", SipConfigManager.CODEC_NB, "100");
        prefs.setCodecPriority("PCMA/8000/1", SipConfigManager.CODEC_NB, "0");
        prefs.setCodecPriority("G722/16000/1", SipConfigManager.CODEC_NB, "0");
        prefs.setCodecPriority("iLBC/8000/1", SipConfigManager.CODEC_NB, "242");
        prefs.setCodecPriority("speex/8000/1", SipConfigManager.CODEC_NB, "241");
        prefs.setCodecPriority("speex/16000/1", SipConfigManager.CODEC_NB, "0");
        prefs.setCodecPriority("speex/32000/1", SipConfigManager.CODEC_NB, "0");
        prefs.setCodecPriority("GSM/8000/1", SipConfigManager.CODEC_NB, "243");
    }

    @Override
    public List<Filter> getDefaultFilters(SipProfile acc) {
        ArrayList<Filter> filters = new ArrayList<Filter>();
        Filter f = new Filter();
        f.account = (int) acc.id;
        f.action = Filter.ACTION_REPLACE;
        f.matchPattern = "^" + Pattern.quote("+") + "(.*)$";
        f.replacePattern = "00$1";
        f.matchType = Filter.MATCHER_STARTS;
        filters.add(f);
        f = new Filter();
        f.account = (int) acc.id;
        f.action = Filter.ACTION_REPLACE;
        f.matchPattern = "^" + Pattern.quote("011") + "(.*)$";
        f.replacePattern = "00$1";
        f.matchType = Filter.MATCHER_STARTS;
        filters.add(f);
        return filters;
    }
}

19 Source : Ovh.java
with GNU General Public License v3.0
from treasure-lau

public clreplaced Ovh extends SimpleImplementation {

    @Override
    protected String getDefaultName() {
        return "Ovh";
    }

    ListPreference sipServer;

    static SortedMap<String, String> providers = new TreeMap<String, String>() {

        private static final long serialVersionUID = 1511610509440960269L;

        {
            put("sip.ovh.fr", "sip.ovh.fr");
            put("sip.ovh.co.uk", "sip.ovh.co.uk");
            put("sip.ovh.de", "sip.ovh.de");
            put("sip.ovh.be", "sip.ovh.be");
            put("sip.ovh.es", "sip.ovh.es");
            put("sip.ovh.ch", "sip.ovh.ch");
            put("sip.ovh.net", "sip.ovh.net");
        }
    };

    private static final String PROVIDER_LIST_KEY = "provider_list";

    protected String getDomain() {
        String provider = sipServer.getValue();
        if (provider != null) {
            return provider;
        }
        return "";
    }

    // Customization
    @Override
    public void fillLayout(final SipProfile account) {
        super.fillLayout(account);
        accountUsername.setreplacedle(R.string.w_common_phone_number);
        accountUsername.setDialogreplacedle(R.string.w_common_phone_number);
        accountUsername.getEditText().setInputType(InputType.TYPE_CLreplaced_PHONE);
        // Server selection
        boolean recycle = true;
        sipServer = (ListPreference) findPreference(PROVIDER_LIST_KEY);
        if (sipServer == null) {
            sipServer = new ListPreference(parent);
            sipServer.setKey(PROVIDER_LIST_KEY);
            recycle = false;
        }
        CharSequence[] e = new CharSequence[providers.size()];
        CharSequence[] v = new CharSequence[providers.size()];
        int i = 0;
        for (String pv : providers.keySet()) {
            e[i] = pv;
            v[i] = providers.get(pv);
            i++;
        }
        sipServer.setEntries(e);
        sipServer.setEntryValues(v);
        sipServer.setDialogreplacedle(R.string.w_common_server);
        sipServer.setreplacedle(R.string.w_common_server);
        sipServer.setDefaultValue("sip.ovh.fr");
        if (!recycle) {
            addPreference(sipServer);
        }
        String domain = account.reg_uri;
        if (domain != null) {
            for (CharSequence state : v) {
                String currentComp = "sip:" + state;
                if (currentComp.equalsIgnoreCase(domain)) {
                    sipServer.setValue(state.toString());
                    break;
                }
            }
        }
    }

    @Override
    public SipProfile buildAccount(SipProfile account) {
        SipProfile acc = super.buildAccount(account);
        acc.vm_nbr = "123";
        return acc;
    }

    @Override
    public void updateDescriptions() {
        super.updateDescriptions();
        setStringFieldSummary(PROVIDER_LIST_KEY);
    }

    @Override
    public String getDefaultFieldSummary(String fieldName) {
        if (fieldName.equals(USER_NAME)) {
            return parent.getString(R.string.w_ovh_phone_number_desc);
        } else if (fieldName == PROVIDER_LIST_KEY) {
            if (sipServer != null) {
                return sipServer.getEntry().toString();
            }
        }
        return super.getDefaultFieldSummary(fieldName);
    }
}

19 Source : NeofonTpPl.java
with GNU General Public License v3.0
from treasure-lau

public clreplaced NeofonTpPl extends SimpleImplementation {

    private static final String PROVIDER_EXTRA_LETTER_KEY = "extra_letter";

    private ListPreference extensionLetter;

    @Override
    protected String getDomain() {
        return "neofon.tp.pl";
    }

    @Override
    protected String getDefaultName() {
        return "Neofon.tp.pl";
    }

    // Customization
    @Override
    public void fillLayout(final SipProfile account) {
        super.fillLayout(account);
        accountUsername.setreplacedle(R.string.w_common_phone_number);
        accountUsername.setDialogreplacedle(R.string.w_common_phone_number);
        accountUsername.getEditText().setInputType(InputType.TYPE_CLreplaced_PHONE);
        boolean recycle = true;
        extensionLetter = (ListPreference) findPreference(PROVIDER_EXTRA_LETTER_KEY);
        if (extensionLetter == null) {
            extensionLetter = new ListPreference(parent);
            extensionLetter.setKey(PROVIDER_EXTRA_LETTER_KEY);
            recycle = false;
        }
        CharSequence[] e = new CharSequence[] { "", "b", "c", "d" };
        extensionLetter.setEntries(e);
        extensionLetter.setEntryValues(e);
        extensionLetter.setDialogreplacedle(R.string.user_prefix);
        extensionLetter.setreplacedle(R.string.user_prefix);
        extensionLetter.setDefaultValue("b");
        if (!recycle) {
            addPreference(extensionLetter);
        }
        String username = account.username;
        if (!TextUtils.isEmpty(username)) {
            if (username.endsWith("b@" + getDomain())) {
                extensionLetter.setValue("b");
            } else if (username.endsWith("c@" + getDomain())) {
                extensionLetter.setValue("c");
            } else if (username.endsWith("d@" + getDomain())) {
                extensionLetter.setValue("d");
            } else {
                extensionLetter.setValue("");
            }
        }
    }

    /* (non-Javadoc)
	 * @see com.csipsimple.wizards.impl.SimpleImplementation#buildAccount(com.csipsimple.api.SipProfile)
	 */
    @Override
    public SipProfile buildAccount(SipProfile account) {
        SipProfile acc = super.buildAccount(account);
        acc.username = getText(accountUsername).trim() + extensionLetter.getValue() + "@" + getDomain();
        return acc;
    }
}

19 Source : LolaWireless.java
with GNU General Public License v3.0
from treasure-lau

public clreplaced LolaWireless extends SimpleImplementation {

    @Override
    protected String getDefaultName() {
        return "Lola Wireless";
    }

    ListPreference sipServer;

    static SortedMap<String, String> providers = new TreeMap<String, String>() {

        private static final long serialVersionUID = 1511610509440960269L;

        {
            put("voice01", "voice01.lolawireless.com");
            put("voice02", "voice02.lolawireless.com");
            put("voice03", "voice03.lolawireless.com");
            put("voice04 (port 80)", "voice04.lolawireless.com:80");
            put("voice05 (port 80)", "voice05.lolawireless.com:80");
        }
    };

    private static final String PROVIDER_LIST_KEY = "provider_list";

    protected String getDomain() {
        String provider = sipServer.getValue();
        if (provider != null) {
            return provider;
        }
        return "";
    }

    // Customization
    @Override
    public void fillLayout(final SipProfile account) {
        super.fillLayout(account);
        // Server selection
        boolean recycle = true;
        sipServer = (ListPreference) findPreference(PROVIDER_LIST_KEY);
        if (sipServer == null) {
            sipServer = new ListPreference(parent);
            sipServer.setKey(PROVIDER_LIST_KEY);
            recycle = false;
        }
        CharSequence[] e = new CharSequence[providers.size()];
        CharSequence[] v = new CharSequence[providers.size()];
        int i = 0;
        for (String pv : providers.keySet()) {
            e[i] = pv;
            v[i] = providers.get(pv);
            i++;
        }
        sipServer.setEntries(e);
        sipServer.setEntryValues(v);
        sipServer.setDialogreplacedle(R.string.w_common_server);
        sipServer.setreplacedle(R.string.w_common_server);
        sipServer.setDefaultValue("sip.ovh.fr");
        if (!recycle) {
            addPreference(sipServer);
        }
        String domain = account.reg_uri;
        if (domain != null) {
            for (CharSequence state : v) {
                String currentComp = "sip:" + state;
                if (currentComp.equalsIgnoreCase(domain)) {
                    sipServer.setValue(state.toString());
                    break;
                }
            }
        }
    }

    @Override
    public void updateDescriptions() {
        super.updateDescriptions();
        setStringFieldSummary(PROVIDER_LIST_KEY);
    }

    @Override
    public String getDefaultFieldSummary(String fieldName) {
        if (fieldName.equals(USER_NAME)) {
            return parent.getString(R.string.w_ovh_phone_number_desc);
        } else if (fieldName == PROVIDER_LIST_KEY) {
            if (sipServer != null) {
                return sipServer.getEntry().toString();
            }
        }
        return super.getDefaultFieldSummary(fieldName);
    }
}

19 Source : Local.java
with GNU General Public License v3.0
from treasure-lau

private static int getIntValue(ListPreference pref, int defaultValue) {
    try {
        return Integer.parseInt(pref.getValue());
    } catch (NumberFormatException e) {
        Log.e(THIS_FILE, "List item is not a number");
    }
    return defaultValue;
}

19 Source : IiNet.java
with GNU General Public License v3.0
from treasure-lau

public clreplaced IiNet extends SimpleImplementation {

    ListPreference accountState;

    @Override
    public void fillLayout(final SipProfile account) {
        super.fillLayout(account);
        CharSequence[] states = new CharSequence[] { "act", "nsw", "nt", "qld", "sa", "tas", "vic", "wa" };
        accountState = new ListPreference(parent);
        accountState.setEntries(states);
        accountState.setEntryValues(states);
        accountState.setKey("state");
        accountState.setDialogreplacedle(R.string.w_iinet_state);
        accountState.setreplacedle(R.string.w_iinet_state);
        accountState.setSummary(R.string.w_iinet_state_desc);
        accountState.setDefaultValue("act");
        addPreference(accountState);
        String domain = account.reg_uri;
        if (domain != null) {
            for (CharSequence state : states) {
                String currentComp = "sip:sip." + state + ".iinet.net.au";
                if (currentComp.equalsIgnoreCase(domain)) {
                    accountState.setValue(state.toString());
                    break;
                }
            }
        }
        accountUsername.setreplacedle(R.string.w_iinet_username);
        accountUsername.setDialogreplacedle(R.string.w_iinet_username);
        accountPreplacedword.setreplacedle(R.string.w_iinet_preplacedword);
        accountPreplacedword.setDialogreplacedle(R.string.w_iinet_preplacedword);
    }

    @Override
    public SipProfile buildAccount(SipProfile account) {
        account = super.buildAccount(account);
        String regUri = "sip:sip." + accountState.getValue() + ".iinet.net.au";
        account.reg_uri = regUri;
        account.proxies = new String[] { regUri };
        account.mwi_enabled = false;
        return account;
    }

    @Override
    public String getDefaultFieldSummary(String fieldName) {
        if (fieldName.equals(USER_NAME)) {
            return parent.getString(R.string.w_iinet_username_desc);
        } else if (fieldName.equals(PreplacedWORD)) {
            return parent.getString(R.string.w_iinet_preplacedword_desc);
        }
        return super.getDefaultFieldSummary(fieldName);
    }

    @Override
    protected String getDomain() {
        return "iinetphone.iinet.net.au";
    }

    @Override
    protected String getDefaultName() {
        return "iinet";
    }

    @Override
    public void setDefaultParams(PreferencesWrapper prefs) {
        super.setDefaultParams(prefs);
        // Add stun server
        prefs.setPreferenceBooleanValue(SipConfigManager.ENABLE_STUN, true);
        prefs.setPreferenceBooleanValue(SipConfigManager.ENABLE_DNS_SRV, true);
    }

    @Override
    public boolean needRestart() {
        return true;
    }
}

19 Source : Conexion.java
with GNU General Public License v3.0
from treasure-lau

public clreplaced Conexion extends AuthorizationImplementation {

    @Override
    protected String getDefaultName() {
        return "Conexion";
    }

    ListPreference sipServer;

    static SortedMap<String, String> providers = new TreeMap<String, String>() {

        private static final long serialVersionUID = -2561302247222706262L;

        {
            put("sip.asu.conexion.com.py", "sip.asu.conexion.com.py");
            put("sip.sao.conexion.com.br", "sip.sao.conexion.com.br");
        }
    };

    private static final String PROVIDER_LIST_KEY = "provider_list";

    @Override
    public void fillLayout(final SipProfile account) {
        super.fillLayout(account);
        boolean recycle = true;
        sipServer = (ListPreference) findPreference(PROVIDER_LIST_KEY);
        if (sipServer == null) {
            sipServer = new ListPreference(parent);
            sipServer.setKey(PROVIDER_LIST_KEY);
            recycle = false;
        }
        CharSequence[] e = new CharSequence[providers.size()];
        CharSequence[] v = new CharSequence[providers.size()];
        int i = 0;
        for (String pv : providers.keySet()) {
            e[i] = pv;
            v[i] = providers.get(pv);
            i++;
        }
        sipServer.setEntries(e);
        sipServer.setEntryValues(v);
        sipServer.setDialogreplacedle(R.string.w_common_server);
        sipServer.setreplacedle(R.string.w_common_server);
        sipServer.setDefaultValue("sip.asu.conexion.com.py");
        if (!recycle) {
            addPreference(sipServer);
        }
        String domain = account.reg_uri;
        if (domain != null) {
            for (CharSequence state : v) {
                String currentComp = "sip:" + state;
                if (currentComp.equalsIgnoreCase(domain)) {
                    sipServer.setValue(state.toString());
                    break;
                }
            }
        }
        hidePreference(null, SERVER);
    }

    /* (non-Javadoc)
	 * @see com.csipsimple.wizards.impl.AuthorizationImplementation#canSave()
	 */
    @Override
    public boolean canSave() {
        boolean isValid = true;
        isValid &= checkField(accountDisplayName, isEmpty(accountDisplayName));
        isValid &= checkField(accountUsername, isEmpty(accountUsername));
        isValid &= checkField(accountAuthorization, isEmpty(accountAuthorization));
        isValid &= checkField(accountPreplacedword, isEmpty(accountPreplacedword));
        return isValid;
    }

    protected String getDomain() {
        String provider = sipServer.getValue();
        if (provider != null) {
            return provider;
        }
        return "";
    }

    @Override
    public void updateDescriptions() {
        super.updateDescriptions();
        setStringFieldSummary(PROVIDER_LIST_KEY);
    }

    @Override
    public String getDefaultFieldSummary(String fieldName) {
        if (fieldName == PROVIDER_LIST_KEY) {
            if (sipServer != null) {
                return sipServer.getEntry().toString();
            }
        }
        return super.getDefaultFieldSummary(fieldName);
    }
}

19 Source : CommPeak.java
with GNU General Public License v3.0
from treasure-lau

public clreplaced CommPeak extends SimpleImplementation {

    @Override
    protected String getDefaultName() {
        return "CommPeak";
    }

    ListPreference sipServer;

    static SortedMap<String, String> providers = new TreeMap<String, String>() {

        private static final long serialVersionUID = 5937536588407734205L;

        {
            put("sip.commpeak.com", "sip.commpeak.com");
            put("US Virginia", "useast.sip.commpeak.com");
            put("US Oregon", "uswest.sip.commpeak.com");
            put("EU Ireland", "ireland.sip.commpeak.com");
            put("S. America Brazil", "brazil.sip.commpeak.com");
            put("Asia Singapore", "singapore.sip.commpeak.com");
            put("Asia Tokyo", "tokyo.sip.commpeak.com");
        }
    };

    private static final String PROVIDER_LIST_KEY = "provider_list";

    @Override
    public void fillLayout(final SipProfile account) {
        super.fillLayout(account);
        boolean recycle = true;
        sipServer = (ListPreference) findPreference(PROVIDER_LIST_KEY);
        if (sipServer == null) {
            sipServer = new ListPreference(parent);
            sipServer.setKey(PROVIDER_LIST_KEY);
            recycle = false;
        }
        CharSequence[] e = new CharSequence[providers.size()];
        CharSequence[] v = new CharSequence[providers.size()];
        int i = 0;
        for (String pv : providers.keySet()) {
            e[i] = pv;
            v[i] = providers.get(pv);
            i++;
        }
        sipServer.setEntries(e);
        sipServer.setEntryValues(v);
        sipServer.setDialogreplacedle(R.string.w_common_server);
        sipServer.setreplacedle(R.string.w_common_server);
        sipServer.setDefaultValue("sip.commpeak.com");
        if (!recycle) {
            addPreference(sipServer);
        }
        String domain = account.reg_uri;
        if (domain != null) {
            for (CharSequence state : v) {
                String currentComp = "sip:" + state;
                if (currentComp.equalsIgnoreCase(domain)) {
                    sipServer.setValue(state.toString());
                    break;
                }
            }
        }
    }

    protected String getDomain() {
        String provider = sipServer.getValue();
        if (provider != null) {
            return provider;
        }
        return "";
    }

    @Override
    public void updateDescriptions() {
        super.updateDescriptions();
        setStringFieldSummary(PROVIDER_LIST_KEY);
    }

    @Override
    public String getDefaultFieldSummary(String fieldName) {
        if (fieldName == PROVIDER_LIST_KEY) {
            if (sipServer != null) {
                return sipServer.getEntry().toString();
            }
        }
        return super.getDefaultFieldSummary(fieldName);
    }

    @Override
    public void setDefaultParams(PreferencesWrapper prefs) {
        super.setDefaultParams(prefs);
        // Prefer silk, g729 (not possible due to license, and keep g711
        // fallback)
        prefs.setCodecPriority("PCMU/8000/1", SipConfigManager.CODEC_WB, "245");
        prefs.setCodecPriority("PCMA/8000/1", SipConfigManager.CODEC_WB, "0");
        prefs.setCodecPriority("G722/16000/1", SipConfigManager.CODEC_WB, "0");
        prefs.setCodecPriority("iLBC/8000/1", SipConfigManager.CODEC_WB, "0");
        prefs.setCodecPriority("speex/8000/1", SipConfigManager.CODEC_WB, "0");
        prefs.setCodecPriority("speex/16000/1", SipConfigManager.CODEC_WB, "0");
        prefs.setCodecPriority("speex/32000/1", SipConfigManager.CODEC_WB, "0");
        prefs.setCodecPriority("GSM/8000/1", SipConfigManager.CODEC_WB, "0");
        prefs.setCodecPriority("SILK/8000/1", SipConfigManager.CODEC_WB, "0");
        prefs.setCodecPriority("SILK/12000/1", SipConfigManager.CODEC_WB, "0");
        prefs.setCodecPriority("SILK/16000/1", SipConfigManager.CODEC_WB, "0");
        prefs.setCodecPriority("SILK/24000/1", SipConfigManager.CODEC_WB, "0");
        // Prefer silk, g729 (not possible due to license, and keep g711
        // fallback)
        prefs.setCodecPriority("PCMU/8000/1", SipConfigManager.CODEC_NB, "245");
        prefs.setCodecPriority("PCMA/8000/1", SipConfigManager.CODEC_NB, "0");
        prefs.setCodecPriority("G722/16000/1", SipConfigManager.CODEC_NB, "0");
        prefs.setCodecPriority("iLBC/8000/1", SipConfigManager.CODEC_NB, "0");
        prefs.setCodecPriority("speex/8000/1", SipConfigManager.CODEC_NB, "0");
        prefs.setCodecPriority("speex/16000/1", SipConfigManager.CODEC_NB, "0");
        prefs.setCodecPriority("speex/32000/1", SipConfigManager.CODEC_NB, "0");
        prefs.setCodecPriority("GSM/8000/1", SipConfigManager.CODEC_NB, "0");
        prefs.setCodecPriority("SILK/8000/1", SipConfigManager.CODEC_NB, "0");
        prefs.setCodecPriority("SILK/12000/1", SipConfigManager.CODEC_NB, "0");
        prefs.setCodecPriority("SILK/16000/1", SipConfigManager.CODEC_NB, "0");
        prefs.setCodecPriority("SILK/24000/1", SipConfigManager.CODEC_NB, "0");
    }

    @Override
    public boolean needRestart() {
        return true;
    }
}

19 Source : BelCentrale.java
with GNU General Public License v3.0
from treasure-lau

public clreplaced BelCentrale extends SimpleImplementation {

    ListPreference accountState;

    private static String STATE_KEY = "state";

    @Override
    protected String getDomain() {
        String prefix = "login";
        if (accountState != null && !TextUtils.isEmpty(accountState.getValue())) {
            prefix = accountState.getValue();
        }
        return prefix + ".belcentrale.nl";
    }

    @Override
    protected String getDefaultName() {
        return "Belcentrale";
    }

    @Override
    public void fillLayout(SipProfile account) {
        super.fillLayout(account);
        CharSequence[] states = new CharSequence[] { "login", "pbx2", "pbx3", "pbx4", "pbx6", "pbx7", "pbx8", "pbx9", "pbx10", "pbx11", "pbx12", "pbx13", "pbx15" };
        boolean recycle = true;
        accountState = (ListPreference) findPreference(STATE_KEY);
        if (accountState == null) {
            accountState = new ListPreference(parent);
            accountState.setKey(STATE_KEY);
            recycle = false;
        }
        accountState.setEntries(states);
        accountState.setEntryValues(states);
        accountState.setDialogreplacedle(R.string.w_common_server);
        accountState.setreplacedle(R.string.w_common_server);
        accountState.setSummary(R.string.w_common_server_desc);
        accountState.setDefaultValue("login");
        if (!recycle) {
            addPreference(accountState);
        }
        String domain = account.reg_uri;
        if (domain != null) {
            for (CharSequence state : states) {
                String currentComp = "sip:" + state + ".belcentrale.nl";
                if (domain.startsWith(currentComp)) {
                    accountState.setValue(state.toString());
                    break;
                }
            }
        }
        accountUsername.getEditText().setInputType(InputType.TYPE_CLreplaced_PHONE);
    }

    public void updateDescriptions() {
        super.updateDescriptions();
        setStringFieldSummary(STATE_KEY);
    }

    @Override
    public SipProfile buildAccount(SipProfile account) {
        SipProfile acc = super.buildAccount(account);
        acc.reg_timeout = 60;
        acc.vm_nbr = "*95";
        return acc;
    }
}

19 Source : Ajtel.java
with GNU General Public License v3.0
from treasure-lau

public clreplaced Ajtel extends SimpleImplementation {

    @Override
    protected String getDefaultName() {
        return "Ajtel.net";
    }

    ListPreference sipServer;

    static SortedMap<String, String> providers = new TreeMap<String, String>() {

        private static final long serialVersionUID = -5453430983196197273L;

        {
            put("sip.ajtel.net", "sip.ajtel.net");
            put("mercurio.ajtel.net", "mercurio.ajtel.net");
            put("vpbx2.ajtel.net", "vpbx2.ajtel.net");
            put("serpiente.ajtel.net", "serpiente.ajtel.net");
            put("andromeda.ajtel.net", "andromeda.ajtel.net");
            put("escorpion.ajtel.net", "escorpion.ajtel.net");
            put("gateway.ajtel.net", "gateway.ajtel.net");
        }
    };

    private static final String PROVIDER_LIST_KEY = "provider_list";

    @Override
    public void fillLayout(final SipProfile account) {
        super.fillLayout(account);
        boolean recycle = true;
        sipServer = (ListPreference) findPreference(PROVIDER_LIST_KEY);
        if (sipServer == null) {
            sipServer = new ListPreference(parent);
            sipServer.setKey(PROVIDER_LIST_KEY);
            recycle = false;
        }
        CharSequence[] e = new CharSequence[providers.size()];
        CharSequence[] v = new CharSequence[providers.size()];
        int i = 0;
        for (String pv : providers.keySet()) {
            e[i] = pv;
            v[i] = providers.get(pv);
            i++;
        }
        sipServer.setEntries(e);
        sipServer.setEntryValues(v);
        sipServer.setDialogreplacedle(R.string.w_common_server);
        sipServer.setreplacedle(R.string.w_common_server);
        sipServer.setDefaultValue("sip.ajtel.net");
        if (!recycle) {
            addPreference(sipServer);
        }
        String domain = account.reg_uri;
        if (domain != null) {
            for (CharSequence state : v) {
                String currentComp = "sip:" + state;
                if (currentComp.equalsIgnoreCase(domain)) {
                    sipServer.setValue(state.toString());
                    break;
                }
            }
        }
    }

    protected String getDomain() {
        String provider = sipServer.getValue();
        if (provider != null) {
            return provider;
        }
        return "";
    }

    @Override
    public void updateDescriptions() {
        super.updateDescriptions();
        setStringFieldSummary(PROVIDER_LIST_KEY);
    }

    @Override
    public String getDefaultFieldSummary(String fieldName) {
        if (fieldName == PROVIDER_LIST_KEY) {
            if (sipServer != null) {
                return sipServer.getEntry().toString();
            }
        }
        return super.getDefaultFieldSummary(fieldName);
    }
}

19 Source : SettingsFragment.java
with GNU General Public License v3.0
from skyguy126

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    getPreferenceManager().setSharedPreferencesMode(Context.MODE_WORLD_READABLE);
    getPreferenceManager().setSharedPreferencesName(Shared.PREFS_FILE_NAME);
    addPreferencesFromResource(R.xml.prefs);
    this.prefs = getActivity().getSharedPreferences(Shared.PREFS_FILE_NAME, MODE_WORLD_READABLE);
    CheckBoxPreference showLauncherIconCheckbox = (CheckBoxPreference) findPreference(Shared.PREFS_LAUNCHER_ICON_KEY);
    showLauncherIconCheckbox.setOnPreferenceClickListener(new Preference.OnPreferenceClickListener() {

        @Override
        public boolean onPreferenceClick(Preference preference) {
            CheckBoxPreference checkBoxPreference = (CheckBoxPreference) preference;
            ComponentName alias = new ComponentName(getActivity(), Shared.PACKAGE_NAME + ".MainActivity-Alias");
            if (checkBoxPreference.isChecked()) {
                getActivity().getPackageManager().setComponentEnabledSetting(alias, PackageManager.COMPONENT_ENABLED_STATE_ENABLED, PackageManager.DONT_KILL_APP);
            } else {
                getActivity().getPackageManager().setComponentEnabledSetting(alias, PackageManager.COMPONENT_ENABLED_STATE_DISABLED, PackageManager.DONT_KILL_APP);
            }
            return true;
        }
    });
    ListPreference saveLocationSpinner = (ListPreference) findPreference(Shared.PREFS_SPINNER_KEY);
    saveLocationSpinner.setSummary(Shared.getSpinnerDescription(Integer.valueOf(saveLocationSpinner.getValue())));
    saveLocationSpinner.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

        @Override
        public boolean onPreferenceChange(Preference preference, Object newValue) {
            ListPreference listPreference = (ListPreference) preference;
            Integer value = Integer.valueOf((String) newValue);
            if (value == 3) {
                AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
                builder.setreplacedle("Save Directory");
                final EditText input = new EditText(getActivity());
                input.setInputType(InputType.TYPE_TEXT_VARIATION_URI);
                input.setText(prefs.getString(Shared.PREFS_SAVE_PATH_KEY, Shared.CUSTOM_PATH_DEFAULT));
                builder.setView(input);
                builder.setPositiveButton("OK", new DialogInterface.OnClickListener() {

                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                        SharedPreferences.Editor prefsEditor = prefs.edit();
                        prefsEditor.putString(Shared.PREFS_SAVE_PATH_KEY, input.getText().toString());
                        prefsEditor.apply();
                    }
                });
                builder.show();
            }
            listPreference.setSummary(Shared.getSpinnerDescription(value));
            SharedPreferences.Editor prefsEditor = prefs.edit();
            prefsEditor.putString(Shared.PREFS_SPINNER_KEY, value.toString());
            prefsEditor.apply();
            return true;
        }
    });
    Preference sourceButton = findPreference("source_button");
    sourceButton.setOnPreferenceClickListener(new Preference.OnPreferenceClickListener() {

        @Override
        public boolean onPreferenceClick(Preference preference) {
            Shared.openWebsite(getActivity(), Shared.SOURCE_LINK);
            return true;
        }
    });
}

19 Source : DuckDuckGoSettings.java
with MIT License
from SDRausty

public clreplaced DuckDuckGoSettings extends PreferenceActivity implements OnSharedPreferenceChangeListener {

    private static final String HELP_KEY = "help";

    private static final String SEARCH_KEY = "search";

    private static final String BANG_1_KEY = "bang_1_preference";

    private static final String BANG_2_KEY = "bang_2_preference";

    private static final String BANG_3_KEY = "bang_3_preference";

    private static final String BANG_4_KEY = "bang_4_preference";

    ListPreference bang1 = null;

    ListPreference bang2 = null;

    ListPreference bang3 = null;

    ListPreference bang4 = null;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        addPreferencesFromResource(R.xml.preferences);
        Preference search = findPreference(SEARCH_KEY);
        Preference help = findPreference(HELP_KEY);
        initializeLists();
        getPreferenceScreen().getSharedPreferences().registerOnSharedPreferenceChangeListener(this);
        search.setOnPreferenceClickListener(new OnPreferenceClickListener() {

            public boolean onPreferenceClick(Preference preference) {
                DuckDuckGoSettings.this.onSearchRequested();
                return true;
            }
        });
        help.setIntent(new Intent(this, Help.clreplaced));
    }

    public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
        updateLists();
    }

    private void initializeLists() {
        bang1 = (ListPreference) findPreference(BANG_1_KEY);
        bang2 = (ListPreference) findPreference(BANG_2_KEY);
        bang3 = (ListPreference) findPreference(BANG_3_KEY);
        bang4 = (ListPreference) findPreference(BANG_4_KEY);
        updateLists();
    }

    private void updateLists() {
        bang1.setSummary(bang1.getEntry());
        bang2.setSummary(bang2.getEntry());
        bang3.setSummary(bang3.getEntry());
        bang4.setSummary(bang4.getEntry());
    }
}

19 Source : LatinIMESettings.java
with GNU General Public License v3.0
from PhilippC

public clreplaced LatinIMESettings extends PreferenceActivity implements SharedPreferences.OnSharedPreferenceChangeListener, DialogInterface.OnDismissListener {

    private static final String QUICK_FIXES_KEY = "quick_fixes";

    private static final String PREDICTION_SETTINGS_KEY = "prediction_settings";

    /* package */
    static final String PREF_SETTINGS_KEY = "settings_key";

    private static final String TAG = "LatinIMESettings";

    private CheckBoxPreference mQuickFixes;

    private ListPreference mSettingsKeyPreference;

    private boolean mOkClicked = false;

    @Override
    protected void onCreate(Bundle icicle) {
        SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
        Design.updateTheme(this, prefs);
        super.onCreate(icicle);
        addPreferencesFromResource(R.xml.prefs);
        mQuickFixes = (CheckBoxPreference) findPreference(QUICK_FIXES_KEY);
        mSettingsKeyPreference = (ListPreference) findPreference(PREF_SETTINGS_KEY);
        prefs.registerOnSharedPreferenceChangeListener(this);
    }

    @Override
    protected void onResume() {
        super.onResume();
        int autoTextSize = AutoText.getSize(getListView());
        if (autoTextSize < 1) {
            ((PreferenceGroup) findPreference(PREDICTION_SETTINGS_KEY)).removePreference(mQuickFixes);
        }
    }

    @Override
    protected void onDestroy() {
        getPreferenceManager().getSharedPreferences().unregisterOnSharedPreferenceChangeListener(this);
        super.onDestroy();
    }

    public void onSharedPreferenceChanged(SharedPreferences prefs, String key) {
        (new BackupManager(this)).dataChanged();
    }

    @Override
    protected Dialog onCreateDialog(int id) {
        switch(id) {
            default:
                Log.e(TAG, "unknown dialog " + id);
                return null;
        }
    }

    public void onDismiss(DialogInterface dialog) {
    }
}

19 Source : SettingsActivity.java
with MIT License
from pcgpcgpcg

private void updateSummaryList(SharedPreferences sharedPreferences, String key) {
    ListPreference updatedPref = (ListPreference) settingsFragment.findPreference(key);
    updatedPref.setSummary(updatedPref.getEntry());
}

19 Source : PluggableCalibration.java
with GNU General Public License v3.0
from NightscoutFoundation

// populate a ListPreference with plugin choices
public static void setListPreferenceData(ListPreference p) {
    final Type[] types = Type.values();
    final CharSequence[] entries = new CharSequence[types.length];
    final CharSequence[] entryValues = new CharSequence[types.length];
    for (int i = 0; i < types.length; i++) {
        // Not sure exactly of what the overhead of this will be
        // perhaps we should save it to a cache...
        final CalibrationAbstract plugin = getCalibrationPlugin(types[i]);
        entries[i] = (plugin != null) ? plugin.getNiceNameAndDescription() : "None";
        entryValues[i] = types[i].toString();
    }
    p.setEntries(entries);
    p.setEntryValues(entryValues);
}

19 Source : AVChatSettingsFragment.java
with MIT License
from netease-im

@Override
public boolean onPreferenceChange(Preference preference, Object newValue) {
    String stringValue = newValue.toString();
    if (preference instanceof ListPreference) {
        ListPreference listPreference = (ListPreference) preference;
        int prefIndex = listPreference.findIndexOfValue(stringValue);
        if (prefIndex >= 0) {
            preference.setSummary(listPreference.getEntries()[prefIndex]);
        }
    } else {
        preference.setSummary(stringValue);
    }
    return true;
}

19 Source : SettingFragment.java
with Apache License 2.0
from li-yu

/**
 * Created by liyu on 2016/11/18.
 */
public clreplaced SettingFragment extends PreferenceFragment implements Preference.OnPreferenceClickListener, Preference.OnPreferenceChangeListener {

    private ListPreference weatherShareType;

    private ListPreference busRefreshFreq;

    private Preference cleanCache;

    private Preference theme;

    private Preference moduleManage;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        addPreferencesFromResource(R.xml.setting);
        weatherShareType = (ListPreference) findPreference(SettingsUtil.WEATHER_SHARE_TYPE);
        busRefreshFreq = (ListPreference) findPreference(SettingsUtil.BUS_REFRESH_FREQ);
        cleanCache = findPreference(SettingsUtil.CLEAR_CACHE);
        theme = findPreference(SettingsUtil.THEME);
        moduleManage = findPreference("module_manage");
        weatherShareType.setSummary(weatherShareType.getValue());
        busRefreshFreq.setSummary(String.format("%s 秒,长按『刷新』按钮即可开启自动模式。", busRefreshFreq.getValue()));
        String[] colorNames = getActivity().getResources().getStringArray(R.array.color_name);
        int currentThemeIndex = SettingsUtil.getTheme();
        if (currentThemeIndex >= colorNames.length) {
            theme.setSummary("自定义色");
        } else {
            theme.setSummary(colorNames[currentThemeIndex]);
        }
        weatherShareType.setOnPreferenceChangeListener(this);
        busRefreshFreq.setOnPreferenceChangeListener(this);
        cleanCache.setOnPreferenceClickListener(this);
        theme.setOnPreferenceClickListener(this);
        moduleManage.setOnPreferenceClickListener(this);
        String[] cachePaths = new String[] { FileUtil.getInternalCacheDir(App.getContext()), FileUtil.getExternalCacheDir(App.getContext()) };
        Observable.just(cachePaths).map(new Func1<String[], String>() {

            @Override
            public String call(String[] strings) {
                return FileSizeUtil.getAutoFileOrFilesSize(strings);
            }
        }).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).subscribe(new SimpleSubscriber<String>() {

            @Override
            public void onNext(String s) {
                cleanCache.setSummary(s);
            }
        });
    }

    @Override
    public boolean onPreferenceChange(Preference preference, Object o) {
        if (preference == weatherShareType) {
            weatherShareType.setSummary((String) o);
            SettingsUtil.setWeatherShareType((String) o);
        } else if (preference == busRefreshFreq) {
            busRefreshFreq.setSummary(String.format("%s 秒,长按『刷新』按钮即可开启自动模式。", (String) o));
            SettingsUtil.setBusRefreshFreq(Integer.parseInt((String) o));
        }
        return true;
    }

    @Override
    public boolean onPreferenceClick(Preference preference) {
        if (preference == cleanCache) {
            Observable.just(FileUtil.delete(FileUtil.getInternalCacheDir(App.getContext()))).map(new Func1<Boolean, Boolean>() {

                @Override
                public Boolean call(Boolean result) {
                    return result && FileUtil.delete(FileUtil.getExternalCacheDir(App.getContext()));
                }
            }).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).subscribe(new SimpleSubscriber<Boolean>() {

                @Override
                public void onNext(Boolean aBoolean) {
                    cleanCache.setSummary(FileSizeUtil.getAutoFileOrFilesSize(FileUtil.getInternalCacheDir(App.getContext()), FileUtil.getExternalCacheDir(App.getContext())));
                    Snackbar.make(getView(), "缓存已清除 (*^__^*)", Snackbar.LENGTH_SHORT).show();
                }
            });
        } else if (preference == theme) {
            new ColorChooserDialog.Builder((SettingActivity) getActivity(), R.string.theme).customColors(R.array.colors, null).doneButton(R.string.done).cancelButton(R.string.cancel).allowUserColorInput(false).allowUserColorInputAlpha(false).show(((SettingActivity) getActivity()).getSupportFragmentManager());
        } else if (preference == moduleManage) {
            getActivity().startActivity(new Intent(getActivity(), ModuleManageActivity.clreplaced));
        }
        return true;
    }
}

19 Source : SettingsActivity.java
with MIT License
from JZ-Darkal

/**
 * A {@link PreferenceActivity} that presents a set of application settings. On
 * handset devices, settings are presented as a single list. On tablets,
 * settings are split by category, with category headers shown to the left of
 * the list of settings.
 * <p/>
 * See <a href="http://developer.android.com/design/patterns/settings.html">
 * Android Design: Settings</a> for design guidelines and the <a
 * href="http://developer.android.com/guide/topics/ui/settings.html">Settings
 * API Guide</a> for more information on developing a Settings UI.
 */
public clreplaced SettingsActivity extends AppCompatPreferenceActivity implements Preference.OnPreferenceChangeListener {

    // 创建一个ListPreference对象
    ListPreference lp;

    Preference hostPreference;

    /**
     * Helper method to determine if the device has an extra-large screen. For
     * example, 10" tablets are extra-large.
     */
    private static boolean isXLargeTablet(Context context) {
        return (context.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) >= Configuration.SCREENLAYOUT_SIZE_XLARGE;
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setupActionBar();
        addPreferencesFromResource(R.xml.pref_data_sync);
        lp = (ListPreference) findPreference("select_ua");
        // 设置获取ListPreference中发生的变化
        lp.setOnPreferenceChangeListener(this);
        lp.setSummary(lp.getEntry());
        findPreference("system_host").setOnPreferenceChangeListener(this);
        findPreference("enable_filter").setOnPreferenceChangeListener(this);
        findPreference("install_cert").setOnPreferenceClickListener(new Preference.OnPreferenceClickListener() {

            @Override
            public boolean onPreferenceClick(Preference preference) {
                changeSystemProxy();
                return false;
            }
        });
        findPreference("system_proxy").setOnPreferenceClickListener(new Preference.OnPreferenceClickListener() {

            @Override
            public boolean onPreferenceClick(Preference preference) {
                startActivity(new Intent(Settings.ACTION_WIFI_SETTINGS));
                return false;
            }
        });
        findPreference("app_version").setSummary(DeviceUtils.getVersion(this));
        findPreference("app_version").setOnPreferenceClickListener(new Preference.OnPreferenceClickListener() {

            @Override
            public boolean onPreferenceClick(Preference preference) {
                try {
                    Beta.checkUpgrade();
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return false;
            }
        });
        hostPreference = findPreference("app_host");
        hostPreference.setSummary(getHost());
    }

    /**
     * Set up the {@link android.app.ActionBar}, if the API is available.
     */
    private void setupActionBar() {
        ActionBar actionBar = getSupportActionBar();
        if (actionBar != null) {
            // Show the Up button in the action bar.
            actionBar.setDisplayHomeAsUpEnabled(true);
        }
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean onIsMultiPane() {
        return isXLargeTablet(this);
    }

    // 让所选择的项显示出来,获取变化并显示出来
    @Override
    public boolean onPreferenceChange(Preference preference, Object newValue) {
        if (preference instanceof ListPreference) {
            // 把preference这个Preference强制转化为ListPreference类型
            ListPreference listPreference = (ListPreference) preference;
            // 获取ListPreference中的实体内容
            CharSequence[] entries = listPreference.getEntries();
            // 获取ListPreference中的实体内容的下标值
            int index = listPreference.findIndexOfValue((String) newValue);
            // 把listPreference中的摘要显示为当前ListPreference的实体内容中选择的那个项目
            listPreference.setSummary(entries[index]);
        }
        // 设置hosts
        if (preference.getKey().equals("system_host")) {
            DeviceUtils.changeHost(((SysApplication) getApplication()).proxy, newValue.toString());
            hostPreference.setSummary(getHost());
        }
        // 重启抓包进程
        if (preference.getKey().equals("enable_filter")) {
            Toast.makeText(this, "重启程序后生效", Toast.LENGTH_SHORT).show();
        // ((SysApplication)getApplication()).stopProxy();
        // ((SysApplication)getApplication()).startProxy();
        // Toast.makeText(this, "抓包进程重启完成", Toast.LENGTH_SHORT).show();
        }
        return true;
    }

    public void installCert() {
        final String CERTIFICATE_RESOURCE = Environment.getExternalStorageDirectory() + "/har/littleproxy-mitm.pem";
        Toast.makeText(this, "必须安装证书才可实现HTTPS抓包", Toast.LENGTH_LONG).show();
        Runnable runnable = new Runnable() {

            @Override
            public void run() {
                try {
                    byte[] keychainBytes;
                    FileInputStream is = null;
                    try {
                        is = new FileInputStream(CERTIFICATE_RESOURCE);
                        keychainBytes = new byte[is.available()];
                        is.read(keychainBytes);
                    } finally {
                        IOUtils.closeQuietly(is);
                    }
                    Intent intent = KeyChain.createInstallIntent();
                    intent.putExtra(KeyChain.EXTRA_CERTIFICATE, keychainBytes);
                    intent.putExtra(KeyChain.EXTRA_NAME, "NetworkDiagnosis CA Certificate");
                    startActivityForResult(intent, 3);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        };
        FileUtil.checkPermission(this, runnable);
    }

    private LoadingDialog loadingDialog;

    public void showLoading(final String text) {
        runOnUiThread(new Runnable() {

            @Override
            public void run() {
                try {
                    if (loadingDialog == null) {
                        loadingDialog = new LoadingDialog(SettingsActivity.this, text);
                    }
                    loadingDialog.show();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

    public void dismissLoading() {
        runOnUiThread(new Runnable() {

            @Override
            public void run() {
                if (loadingDialog != null) {
                    loadingDialog.dismiss();
                    loadingDialog = null;
                }
            }
        });
    }

    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        if (requestCode == 3) {
            if (resultCode == Activity.RESULT_OK) {
                SharedPreferenceUtils.putBoolean(this, "isInstallNewCert", true);
                Toast.makeText(this, "安装成功", Toast.LENGTH_LONG).show();
            } else {
                Toast.makeText(this, "安装失败", Toast.LENGTH_LONG).show();
            }
        }
    }

    public void changeSystemProxy() {
        installCert();
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        if (item.gereplacedemId() == android.R.id.home) {
            finish();
            return true;
        }
        return super.onOptionsItemSelected(item);
    }

    @Override
    protected void onPause() {
        super.onPause();
    }

    public String getHost() {
        String result = "";
        BrowserMobProxy browserMobProxy = ((SysApplication) getApplication()).proxy;
        AdvancedHostResolver advancedHostResolver = browserMobProxy.getHostNameResolver();
        for (String key : advancedHostResolver.getHostRemappings().keySet()) {
            result += key + " " + advancedHostResolver.getHostRemappings().get(key) + "\n";
        }
        return result.length() > 1 ? result.substring(0, result.length() - 1) : "无";
    }
}

19 Source : UserPreferences.java
with MIT License
from jrvansuita

public clreplaced UserPreferences extends PreferenceActivity implements OnSharedPreferenceChangeListener, OnPreferenceClickListener {

    private ListPreference listOrdenationCheckedStyle;

    private ListPreference listOrdenationAlphabeticalStyle;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        getFistPrefs();
        getActionBar().setDisplayHomeAsUpEnabled(true);
        super.onCreate(savedInstanceState);
        addPreferencesFromResource(R.layout.activity_user_preferences);
        listOrdenationCheckedStyle = (ListPreference) findPreference(getString(R.string.user_preference_ordenation_checked_list));
        listOrdenationAlphabeticalStyle = (ListPreference) findPreference(getString(R.string.user_preference_ordenation_alphabetical_list));
        ((Preference) findPreference(getString(R.string.user_preference_about_app))).setOnPreferenceClickListener(this);
    }

    private void getFistPrefs() {
        SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
        Editor editor = prefs.edit();
        editor.putBoolean(getString(R.string.user_preference_show_check_box), prefs.getBoolean(getString(R.string.user_preference_show_check_box), true));
        editor.putBoolean(getString(R.string.user_preference_show_quanreplacedy), prefs.getBoolean(getString(R.string.user_preference_show_quanreplacedy), true));
        editor.putBoolean(getString(R.string.user_preference_show_unit_value), prefs.getBoolean(getString(R.string.user_preference_show_unit_value), true));
        editor.commit();
    }

    @Override
    protected void onResume() {
        super.onResume();
        getPreferenceScreen().getSharedPreferences().registerOnSharedPreferenceChangeListener(this);
        setSummaries();
    }

    @Override
    protected void onPause() {
        super.onPause();
        // Unregister the listener whenever a key changes
        getPreferenceScreen().getSharedPreferences().unregisterOnSharedPreferenceChangeListener(this);
    }

    @Override
    public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
        setSummaries();
    }

    private void setSummaries() {
        listOrdenationAlphabeticalStyle.setSummary(getString(R.string.default_option) + " " + listOrdenationAlphabeticalStyle.getEntry().toString());
        listOrdenationCheckedStyle.setSummary(getString(R.string.default_option) + " " + listOrdenationCheckedStyle.getEntry().toString());
    }

    public static boolean getShowCheckBox(Context context) {
        SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
        return prefs.getBoolean(context.getString(R.string.user_preference_show_check_box), true);
    }

    public static boolean getShowQuanreplacedy(Context context) {
        SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
        return prefs.getBoolean(context.getString(R.string.user_preference_show_quanreplacedy), true);
    }

    public static boolean getShowUnitValue(Context context) {
        SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
        return prefs.getBoolean(context.getString(R.string.user_preference_show_unit_value), true);
    }

    public static String gereplacedemListCheckedOrdenation(Context context) {
        SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
        return prefs.getString(context.getString(R.string.user_preference_ordenation_checked_list), "");
    }

    public static String gereplacedemListAlphabeticalOrdenation(Context context) {
        SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
        return prefs.getString(context.getString(R.string.user_preference_ordenation_alphabetical_list), "");
    }

    @Override
    public boolean onPreferenceClick(Preference preference) {
        try {
            if (preference.getKey().equals(getString(R.string.user_preference_about_app))) {
                new CustomDialogAboutApp(preference.getContext()).show();
            }
        } catch (NameNotFoundException e) {
            Toast.makeText(preference.getContext(), e.getMessage(), Toast.LENGTH_LONG).show();
            e.printStackTrace();
        }
        return false;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        finish();
        return true;
    }
}

19 Source : SettingsFragment.java
with Apache License 2.0
from iwo

public clreplaced SettingsFragment extends PreferenceFragment implements Preference.OnPreferenceChangeListener, Preference.OnPreferenceClickListener, AudioDriver.OnInstallListener, SharedPreferences.OnSharedPreferenceChangeListener {

    public static final String KEY_COPYRIGHTS_STATEMENT = "copyrights_statement";

    public static final String KEY_DONATE = "donate";

    public static final String KEY_NO_ROOT_MODE = "no_root_mode";

    public static final String KEY_VIDEO = "video";

    public static final String KEY_VIDEO_CONFIG = "video_config";

    public static final String KEY_VIDEO_ENCODER = "video_encoder";

    public static final String KEY_RESOLUTION = "resolution";

    public static final String KEY_ORIENTATION = "orientation";

    public static final String KEY_TIME_LAPSE = "time_lapse";

    public static final String KEY_TRANSFORMATION = "transformation";

    public static final String KEY_VIDEO_BITRATE = "video_bitrate";

    public static final String KEY_FRAME_RATE = "frame_rate";

    public static final String KEY_VERTICAL_FRAMES = "vertical_frames";

    public static final String KEY_AUDIO = "audio";

    public static final String KEY_AUDIO_SOURCE = "audio_source";

    public static final String KEY_SAMPLING_RATE = "sampling_rate";

    public static final String KEY_STEREO = "stereo";

    public static final String KEY_MIC_GAIN = "mic_gain";

    public static final String KEY_OTHER = "other";

    public static final String KEY_SHOW_CAMERA = "show_camera";

    public static final String KEY_CAMERA_ALPHA = "camera_alpha";

    public static final String KEY_HIDE_ICON = "hide_icon";

    public static final String KEY_SHOW_TOUCHES = "show_touches";

    public static final String KEY_DOreplacedENT_DIR = "doreplacedent_dir";

    public static final String KEY_OUTPUT_DIR = "output_dir";

    public static final String KEY_STOP_ON_SCREEN_OFF = "stop_on_screen_off";

    public static final String KEY_COLOR_FIX = "color_fix";

    public static final String KEY_GUSHER = "gusher";

    public static final String KEY_MP4FIX = "mp4fix";

    private static final int SELECT_OUTPUT_DIR = 1;

    private static final int SELECT_DOreplacedENT_DIR = 2;

    private static final String TAG = "scr_SettingsFragment";

    private Preference donatePreference;

    private Preference noRootModePreference;

    private PreferenceCategory videoCategory;

    private ListPreference videoConfigPreference;

    private ListPreference videoEncoderPreference;

    private ListPreference resolutionPreference;

    private ListPreference orientationPreference;

    private ListPreference timeLapsePreference;

    private ListPreference transformationPreference;

    private ListPreference videoBitratePreference;

    private ListPreference frameRatePreference;

    private CheckBoxPreference verticalFramesPreference;

    private PreferenceCategory audioCategory;

    private ListPreference audioSourcePreference;

    private ListPreference samplingRatePreference;

    private CheckBoxPreference stereoPreference;

    private SliderPreference micGainPreference;

    private PreferenceCategory otherCategory;

    private SliderPreference cameraAlphaPreference;

    private CheckBoxPreference showCameraPreference;

    private CheckBoxPreference hideIconPreference;

    private CheckBoxPreference showTouchesPreference;

    private Preference doreplacedentDirPreference;

    private Preference outputDirPreference;

    private CheckBoxPreference stopOnScreenOffPreference;

    private CheckBoxPreference colorFixPreference;

    private Preference gusherPreference;

    private Preference mp4fixPreference;

    private Settings settings;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // Load the preferences from an XML resource
        addPreferencesFromResource(R.xml.settings);
        String copyrightsStatement = getString(R.string.copyrights_statement, getString(R.string.app_name));
        findPreference(KEY_COPYRIGHTS_STATEMENT).setSummary(copyrightsStatement);
        settings = Settings.getInstance();
        settings.registerOnSharedPreferenceChangeListener(this);
        donatePreference = findPreference(KEY_DONATE);
        donatePreference.setOnPreferenceClickListener(this);
        noRootModePreference = findPreference(KEY_NO_ROOT_MODE);
        noRootModePreference.setOnPreferenceClickListener(this);
        videoCategory = (PreferenceCategory) findPreference(KEY_VIDEO);
        videoConfigPreference = (ListPreference) findPreference(KEY_VIDEO_CONFIG);
        videoConfigPreference.setOnPreferenceChangeListener(this);
        String replacedle = getString(R.string.settings_video_config, Build.MODEL);
        videoConfigPreference.setreplacedle(replacedle);
        videoConfigPreference.setDialogreplacedle(replacedle);
        videoEncoderPreference = (ListPreference) findPreference(KEY_VIDEO_ENCODER);
        videoEncoderPreference.setOnPreferenceChangeListener(this);
        resolutionPreference = (ListPreference) findPreference(KEY_RESOLUTION);
        resolutionPreference.setOnPreferenceChangeListener(this);
        orientationPreference = (ListPreference) findPreference(KEY_ORIENTATION);
        orientationPreference.setOnPreferenceChangeListener(this);
        timeLapsePreference = (ListPreference) findPreference(KEY_TIME_LAPSE);
        timeLapsePreference.setOnPreferenceChangeListener(this);
        transformationPreference = (ListPreference) findPreference(KEY_TRANSFORMATION);
        transformationPreference.setOnPreferenceChangeListener(this);
        videoBitratePreference = (ListPreference) findPreference(KEY_VIDEO_BITRATE);
        videoBitratePreference.setOnPreferenceChangeListener(this);
        frameRatePreference = (ListPreference) findPreference(KEY_FRAME_RATE);
        frameRatePreference.setOnPreferenceChangeListener(this);
        verticalFramesPreference = (CheckBoxPreference) findPreference(KEY_VERTICAL_FRAMES);
        verticalFramesPreference.setOnPreferenceChangeListener(this);
        audioCategory = (PreferenceCategory) findPreference(KEY_AUDIO);
        audioSourcePreference = (ListPreference) findPreference(KEY_AUDIO_SOURCE);
        audioSourcePreference.setOnPreferenceChangeListener(this);
        samplingRatePreference = (ListPreference) findPreference(KEY_SAMPLING_RATE);
        samplingRatePreference.setOnPreferenceChangeListener(this);
        stereoPreference = (CheckBoxPreference) findPreference(KEY_STEREO);
        stereoPreference.setOnPreferenceChangeListener(this);
        micGainPreference = (SliderPreference) findPreference(KEY_MIC_GAIN);
        micGainPreference.setOnPreferenceChangeListener(this);
        otherCategory = (PreferenceCategory) findPreference(KEY_OTHER);
        showCameraPreference = (CheckBoxPreference) findPreference(KEY_SHOW_CAMERA);
        showCameraPreference.setOnPreferenceChangeListener(this);
        cameraAlphaPreference = (SliderPreference) findPreference(KEY_CAMERA_ALPHA);
        cameraAlphaPreference.setOnPreferenceChangeListener(this);
        hideIconPreference = (CheckBoxPreference) findPreference(KEY_HIDE_ICON);
        hideIconPreference.setOnPreferenceChangeListener(this);
        showTouchesPreference = (CheckBoxPreference) findPreference(KEY_SHOW_TOUCHES);
        showTouchesPreference.setOnPreferenceChangeListener(this);
        doreplacedentDirPreference = findPreference(KEY_DOreplacedENT_DIR);
        doreplacedentDirPreference.setOnPreferenceClickListener(this);
        outputDirPreference = findPreference(KEY_OUTPUT_DIR);
        outputDirPreference.setOnPreferenceClickListener(this);
        stopOnScreenOffPreference = (CheckBoxPreference) findPreference(KEY_STOP_ON_SCREEN_OFF);
        stopOnScreenOffPreference.setOnPreferenceChangeListener(this);
        colorFixPreference = (CheckBoxPreference) findPreference(KEY_COLOR_FIX);
        colorFixPreference.setOnPreferenceChangeListener(this);
        gusherPreference = findPreference(KEY_GUSHER);
        gusherPreference.setOnPreferenceClickListener(this);
        mp4fixPreference = findPreference(KEY_MP4FIX);
        mp4fixPreference.setOnPreferenceClickListener(this);
        settings.getAudioDriver().addInstallListener(this);
        updateEntries();
        updateValues();
    }

    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        Context context = getActivity();
        addRemovePreference(Utils.hasFrontFacingCamera(context), KEY_SHOW_CAMERA, showCameraPreference, otherCategory);
        addRemovePreference(Utils.hasFrontFacingCamera(context), KEY_CAMERA_ALPHA, cameraAlphaPreference, otherCategory);
    }

    protected void updateValues() {
        updateSelectedVideoConfig();
        videoConfigPreference.setEnabled(settings.isRootEnabled() && settings.getDeviceProfile() != null && settings.getDeviceProfile().getVideoConfigs().size() > 0);
        videoEncoderPreference.setValue(String.valueOf(settings.getVideoEncoder()));
        videoEncoderPreference.setSummary(formatVideoEncoderSummary(settings.getVideoEncoder()));
        resolutionPreference.setValue(formatResolutionEntryValue(settings.getResolution()));
        resolutionPreference.setSummary(formatResolutionEntry(settings.getResolution()));
        orientationPreference.setValue(settings.getOrientation().name());
        orientationPreference.setSummary(formatOrientationSummary(settings.getOrientation()));
        orientationPreference.setEnabled(settings.isNoRootVideoEncoder());
        timeLapsePreference.setValue(String.valueOf(settings.getTimeLapse()));
        timeLapsePreference.setSummary(formatTimeLapseSummary(settings.getTimeLapse()));
        transformationPreference.setValue(settings.getTransformation().name());
        transformationPreference.setSummary(formatTransformationSummary(settings.getTransformation()));
        transformationPreference.setEnabled(!settings.isNoRootVideoEncoder() && settings.getVideoEncoder() >= 0);
        videoBitratePreference.setValue(settings.getVideoBitrate().name());
        videoBitratePreference.setSummary(formatVideoBitrateSummary(settings.getVideoBitrate()));
        frameRatePreference.setValue(String.valueOf(settings.getFrameRate()));
        frameRatePreference.setSummary(formatFrameRateSummary(settings.getFrameRate()));
        frameRatePreference.setEnabled(!settings.isNoRootVideoEncoder());
        verticalFramesPreference.setChecked(settings.getVerticalFrames());
        verticalFramesPreference.setEnabled(!settings.isNoRootVideoEncoder());
        audioSourcePreference.setValue(settings.getAudioSource().name());
        audioSourcePreference.setSummary(formatAudioSourceSummary(settings.getAudioSource(), settings.getTimeLapse() != 1));
        audioSourcePreference.setEnabled(settings.getTimeLapse() == 1);
        samplingRatePreference.setValue(settings.getSamplingRate().name());
        samplingRatePreference.setSummary(formatSamplingRateSummary());
        samplingRatePreference.setEnabled(settings.getTimeLapse() == 1 && !settings.getAudioSource().equals(AudioSource.MUTE));
        stereoPreference.setChecked(settings.getStereo());
        stereoPreference.setEnabled(settings.getTimeLapse() == 1 && !settings.getAudioSource().equals(AudioSource.MUTE));
        micGainPreference.setValue(gainToIndex(settings.getMicGain()));
        micGainPreference.setSummary(formatMicGain());
        micGainPreference.setEnabled(settings.getTimeLapse() == 1 && settings.getAudioSource() == AudioSource.MIX);
        hideIconPreference.setChecked(settings.getHideIcon());
        showTouchesPreference.setChecked(settings.getShowTouches());
        showCameraPreference.setChecked(settings.getShowCamera());
        cameraAlphaPreference.setValue((int) (settings.getCameraAlpha() * 100));
        cameraAlphaPreference.setSummary(formatCameraAlphaSummary());
        doreplacedentDirPreference.setSummary(settings.getDoreplacedentDirName());
        outputDirPreference.setSummary(settings.getOutputDir().getAbsolutePath());
        stopOnScreenOffPreference.setChecked(settings.getStopOnScreenOff());
        colorFixPreference.setChecked(settings.getColorFix());
        colorFixPreference.setEnabled(!settings.isNoRootVideoEncoder());
    }

    private String formatOrientationSummary(Orientation orientation) {
        if (!settings.isNoRootVideoEncoder()) {
            return getString(R.string.settings_no_root_only);
        }
        switch(orientation) {
            case AUTO:
                return getString(R.string.settings_orientation_auto);
            case LANDSCAPE:
                return getString(R.string.settings_orientation_landscape);
            case PORTRAIT:
                return getString(R.string.settings_orientation_portrait);
        }
        return "";
    }

    private String formatTimeLapseSummary(int timeLapse) {
        if (timeLapse == 1) {
            return getString(R.string.settings_time_lapse_summary_no_time_lapse);
        }
        return getString(R.string.settings_time_lapse_summary, timeLapse);
    }

    private void updateSelectedVideoConfig() {
        if (settings.getDeviceProfile() != null && settings.getDeviceProfile().getVideoConfigs().size() > 0) {
            videoConfigPreference.setValue(getSelectedVideoConfigIndex());
        }
    }

    private String getSelectedVideoConfigIndex() {
        List<VideoConfig> configs = settings.getDeviceProfile().getVideoConfigs();
        for (int i = 0; i < configs.size(); i++) {
            VideoConfig config = configs.get(i);
            if (config.getVideoEncoder() == settings.getVideoEncoder() && config.getResolution() == settings.getResolution() && config.getTransformation() == settings.getTransformation() && config.getVideoBitrate() == settings.getVideoBitrate())
                return String.valueOf(i);
        }
        return null;
    }

    protected void updateEntries() {
        addRemovePreference(settings.isRootFlavor() && !settings.isRootEnabled(), KEY_NO_ROOT_MODE, noRootModePreference, getPreferenceScreen());
        if (addRemovePreference(settings.isRootFlavor(), KEY_VIDEO_CONFIG, videoConfigPreference, videoCategory)) {
            if (settings.getDeviceProfile() != null && settings.getDeviceProfile().getVideoConfigs().size() > 0) {
                videoConfigPreference.setEntries(getVideoConfigEntries());
                videoConfigPreference.setEntryValues(getVideoConfigEntryValues());
                videoConfigPreference.setEnabled(true);
                videoConfigPreference.setSummary(R.string.settings_video_config_summary);
            } else {
                videoConfigPreference.setEnabled(false);
                if (settings.getDeviceProfile() == null) {
                    videoConfigPreference.setSummary(R.string.settings_video_config_summary_no_data);
                } else {
                    videoConfigPreference.setSummary(R.string.settings_video_config_summary_not_available);
                }
            }
        }
        List<Integer> videoEncoders = getVideoEncoders();
        if (addRemovePreference(videoEncoders.size() > 1, KEY_VIDEO_ENCODER, videoEncoderPreference, videoCategory)) {
            videoEncoderPreference.setEntryValues(getVideoEncoderEntryValues(videoEncoders));
            videoEncoderPreference.setEntries(getVideoEncoderEntries(videoEncoders));
        }
        resolutionPreference.setEntryValues(getResolutionEntryValues());
        resolutionPreference.setEntries(getResolutionEntries());
        boolean softwareEncoderOnly = videoEncoders.size() == 1 && videoEncoders.get(0) == -2;
        List<Transformation> transformations = getTransformations();
        if (addRemovePreference(settings.isRootFlavor() && transformations.size() > 1 && !softwareEncoderOnly, KEY_TRANSFORMATION, transformationPreference, videoCategory)) {
            transformationPreference.setEntryValues(getTransformationEntryValues(transformations));
            transformationPreference.setEntries(getTransformationEntries(transformations));
        }
        if (addRemovePreference(!settings.isRootFlavor() || settings.getShowAdvanced(), KEY_VIDEO_BITRATE, videoBitratePreference, videoCategory)) {
            ArrayList<VideoBitrate> videoBitrates = getVideoBitrates();
            videoBitratePreference.setEntryValues(getVideoBitrateEntryValues(videoBitrates));
            videoBitratePreference.setEntries(getVideoBitrateEntries(videoBitrates));
        }
        if (addRemovePreference(settings.getShowAdvanced(), KEY_FRAME_RATE, frameRatePreference, videoCategory)) {
            if (Build.VERSION.SDK_INT < 18 || (settings.getDeviceProfile() != null && !settings.getDeviceProfile().isHighEndDevice())) {
                frameRatePreference.setEntryValues(R.array.frame_rate_values_lo_end);
            } else {
                frameRatePreference.setEntryValues(R.array.frame_rate_values);
            }
            frameRatePreference.setEntries(getFrameRateEntries(frameRatePreference.getEntryValues()));
        }
        addRemovePreference(settings.getShowAdvanced(), KEY_VERTICAL_FRAMES, verticalFramesPreference, videoCategory);
        CharSequence[] mainEntries = getResources().getStringArray(settings.isRootEnabled() ? R.array.audio_source_entries : R.array.audio_source_entries_no_root);
        CharSequence[] entries = new CharSequence[mainEntries.length];
        CharSequence[] entryValues = getResources().getStringArray(settings.isRootEnabled() ? R.array.audio_source_values : R.array.audio_source_values_no_root);
        for (int i = 0; i < mainEntries.length; i++) {
            AudioSource audioSource = AudioSource.valueOf(entryValues[i].toString());
            if (audioSource.getRequiresDriver()) {
                if (settings.getDeviceProfile() != null && !settings.getDeviceProfile().isInternalAudioStable()) {
                    entries[i] = getTwoLineEntry(mainEntries[i], getString(R.string.settings_audio_incompatible, Build.VERSION.RELEASE));
                } else {
                    entries[i] = getTwoLineEntry(mainEntries[i], audioSource == AudioSource.MIX ? getString(R.string.settings_audio_use_headphones) : getString(R.string.settings_audio_experimental));
                }
            } else {
                entries[i] = mainEntries[i];
            }
        }
        audioSourcePreference.setEntries(entries);
        audioSourcePreference.setEntryValues(entryValues);
        updateSamplingRate();
        addRemovePreference(settings.isRootFlavor(), KEY_COLOR_FIX, colorFixPreference, otherCategory);
        String[] timeLapseValues = getResources().getStringArray(R.array.time_lapse_values);
        timeLapsePreference.setEntryValues(timeLapseValues);
        timeLapsePreference.setEntries(getTimeLapseEntries(timeLapseValues));
        addRemovePreference(settings.isRootFlavor(), KEY_MIC_GAIN, micGainPreference, audioCategory);
        addRemovePreference(Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP, KEY_DOreplacedENT_DIR, doreplacedentDirPreference, otherCategory);
    }

    private void updateSamplingRate() {
        AudioSource audioSource = Settings.getInstance().getAudioSource();
        if (audioSource.getRequiresDriver()) {
            int outSamplingRate = Settings.getInstance().getAudioDriver().getSamplingRate();
            ArrayList<SamplingRate> samplingRates = new ArrayList<SamplingRate>(3);
            for (SamplingRate samplingRate : SamplingRate.values()) {
                if ((outSamplingRate % samplingRate.getSamplingRate()) == 0 && outSamplingRate / samplingRate.getSamplingRate() <= 4) {
                    samplingRates.add(samplingRate);
                }
            }
            samplingRatePreference.setEntryValues(getSamplingRateEntryValues(samplingRates));
            samplingRatePreference.setEntries(getSamplingRateEntries(samplingRates));
        } else {
            samplingRatePreference.setEntryValues(getSamplingRateEntryValues(SamplingRate.STANDARD));
            samplingRatePreference.setEntries(getSamplingRateEntries(SamplingRate.STANDARD));
        }
    }

    private CharSequence[] getSamplingRateEntryValues(List<SamplingRate> samplingRates) {
        String[] entryValues = new String[samplingRates.size()];
        for (int i = 0; i < entryValues.length; i++) {
            entryValues[i] = samplingRates.get(i).name();
        }
        return entryValues;
    }

    private CharSequence[] getSamplingRateEntries(List<SamplingRate> samplingRates) {
        String[] entries = new String[samplingRates.size()];
        for (int i = 0; i < entries.length; i++) {
            entries[i] = samplingRates.get(i).getLabel();
        }
        return entries;
    }

    private CharSequence getTwoLineEntry(CharSequence firstLine, CharSequence secondLine) {
        return Html.fromHtml(firstLine + "<br/><small><font color=\"@android:secondary_text_dark\">" + secondLine + "</font></small>");
    }

    private CharSequence[] getVideoConfigEntries() {
        List<VideoConfig> configs = settings.getDeviceProfile().getVideoConfigs();
        CharSequence[] entries = new CharSequence[configs.size()];
        for (int i = 0; i < entries.length; i++) {
            entries[i] = formatVideoConfig(configs.get(i));
        }
        return entries;
    }

    private CharSequence formatVideoConfig(VideoConfig videoConfig) {
        return getTwoLineEntry(getString(R.string.settings_video_config_entry, videoConfig.getResolution().getWidth(), videoConfig.getResolution().getHeight(), videoConfig.getFrameRate()), formatVideoEncoderEntry(videoConfig.getVideoEncoder()) + (videoConfig.getVideoEncoder() == VideoEncoder.FFMPEG_MPEG_4 ? "" : " " + formatTransformationEntry(videoConfig.getTransformation())) + " " + getString(R.string.settings_video_config_entry_stability, videoConfig.getStability()));
    }

    private String[] getVideoConfigEntryValues() {
        String[] indexes = new String[settings.getDeviceProfile().getVideoConfigs().size()];
        for (int i = 0; i < indexes.length; i++) {
            indexes[i] = String.valueOf(i);
        }
        return indexes;
    }

    private boolean addRemovePreference(boolean add, String key, Preference preference, PreferenceGroup category) {
        if (!add && category.findPreference(key) != null) {
            category.removePreference(preference);
        } else if (add && category.findPreference(key) == null) {
            category.addPreference(preference);
        }
        return add;
    }

    private List<Integer> getVideoEncoders() {
        if (!settings.getShowUnstable() && settings.getDeviceProfile() != null)
            return settings.getDeviceProfile().getStableVideoEncoders();
        return Arrays.asList(VideoEncoder.getAllSupportedEncoders(!settings.isRootEnabled()));
    }

    private String[] getVideoEncoderEntryValues(List<Integer> videoEncoders) {
        String[] entryValues = new String[videoEncoders.size()];
        for (int i = 0; i < videoEncoders.size(); i++) {
            entryValues[i] = String.valueOf(videoEncoders.get(i));
        }
        return entryValues;
    }

    private String[] getVideoEncoderEntries(List<Integer> entryValues) {
        String[] entries = new String[entryValues.size()];
        for (int i = 0; i < entryValues.size(); i++) {
            entries[i] = formatVideoEncoderEntry(entryValues.get(i));
        }
        return entries;
    }

    private String formatVideoEncoderEntry(int encoder) {
        String entry = null;
        switch(encoder) {
            case VideoEncoder.FFMPEG_MPEG_4:
                entry = getString(R.string.settings_video_encoder_ffmpeg_mpeg_4);
                break;
            case VideoEncoder.H264:
                entry = getString(R.string.settings_video_encoder_h264);
                break;
            case VideoEncoder.MPEG_4_SP:
                entry = getString(R.string.settings_video_encoder_mpeg_4_sp);
                break;
            case VideoEncoder.NO_ROOT_H264:
                entry = getString(settings.isRootFlavor() ? R.string.settings_video_encoder_no_root_h264 : R.string.settings_video_encoder_h264);
                break;
            case VideoEncoder.NO_ROOT_MPEG_4:
                entry = getString(settings.isRootFlavor() ? R.string.settings_video_encoder_no_root_mpeg_4 : R.string.settings_video_encoder_mpeg_4);
                break;
        }
        if (settings.getDeviceProfile() != null && settings.getDeviceProfile().hideVideoEncoder(encoder)) {
            entry = getString(R.string.settings_unstable, entry);
        }
        return entry;
    }

    private CharSequence[] getResolutionEntries() {
        Resolution[] resolutions = settings.getResolutions();
        ArrayList<String> entries = new ArrayList<String>(resolutions.length);
        for (Resolution resolution : resolutions) {
            if (!settings.getShowUnstable() && settings.getDeviceProfile() != null && settings.getDeviceProfile().hideResolution(resolution))
                continue;
            entries.add(formatResolutionEntry(resolution));
        }
        return entries.toArray(new String[entries.size()]);
    }

    private String formatResolutionEntry(Resolution r) {
        String entry = String.format(getString(r.getLabelId(), r.getWidth(), r.getHeight()));
        if (settings.getDeviceProfile() != null && settings.getDeviceProfile().hideResolution(r)) {
            entry = getString(R.string.settings_unstable, entry);
        }
        return entry;
    }

    private CharSequence[] getResolutionEntryValues() {
        Resolution[] resolutions = settings.getResolutions();
        ArrayList<String> values = new ArrayList<String>(resolutions.length);
        for (Resolution resolution : resolutions) {
            if (!settings.getShowUnstable() && settings.getDeviceProfile() != null && settings.getDeviceProfile().hideResolution(resolution))
                continue;
            values.add(formatResolutionEntryValue(resolution));
        }
        return values.toArray(new String[values.size()]);
    }

    private String formatResolutionEntryValue(Resolution r) {
        return r.getWidth() + "x" + r.getHeight();
    }

    private Resolution findResolution(String resolution) {
        if (resolution != null) {
            String[] widthAndHeight = resolution.split("x");
            if (widthAndHeight.length == 2) {
                int width = Integer.parseInt(widthAndHeight[0]);
                int height = Integer.parseInt(widthAndHeight[1]);
                for (Resolution r : settings.getResolutions()) {
                    if (r.getWidth() == width && r.getHeight() == height) {
                        return r;
                    }
                }
            }
        }
        Log.w(TAG, "Resolution ont found " + resolution);
        return settings.getDefaultResolution();
    }

    private List<Transformation> getTransformations() {
        if (!settings.getShowUnstable() && settings.getDeviceProfile() != null)
            return settings.getDeviceProfile().getStableTransformations();
        Transformation[] allTransformations = Build.VERSION.SDK_INT < 18 ? new Transformation[] { Transformation.CPU, Transformation.GPU } : new Transformation[] { Transformation.CPU, Transformation.GPU, Transformation.OES };
        return Arrays.asList(allTransformations);
    }

    private String[] getTransformationEntryValues(List<Transformation> transformations) {
        String[] entryValues = new String[transformations.size()];
        for (int i = 0; i < transformations.size(); i++) {
            entryValues[i] = transformations.get(i).name();
        }
        return entryValues;
    }

    private String[] getTransformationEntries(List<Transformation> transformations) {
        String[] entries = new String[transformations.size()];
        for (int i = 0; i < transformations.size(); i++) {
            entries[i] = formatTransformationEntry(transformations.get(i));
        }
        return entries;
    }

    private String formatTransformationEntry(Transformation transformation) {
        String entry = null;
        switch(transformation) {
            case CPU:
                entry = getString(R.string.settings_transformation_cpu);
                break;
            case GPU:
                entry = getString(R.string.settings_transformation_gpu);
                break;
            case OES:
                entry = getString(R.string.settings_transformation_oes);
                break;
        }
        if (settings.getDeviceProfile() != null && settings.getDeviceProfile().hideTransformation(transformation)) {
            entry = getString(R.string.settings_unstable, entry);
        }
        return entry;
    }

    private ArrayList<VideoBitrate> getVideoBitrates() {
        ArrayList<VideoBitrate> bitrates = new ArrayList<VideoBitrate>(VideoBitrate.values().length);
        for (VideoBitrate bitrate : VideoBitrate.values()) {
            if (!settings.getShowUnstable() && settings.getDeviceProfile() != null && settings.getDeviceProfile().hideVideoBitrate(bitrate))
                continue;
            if (!settings.isRootFlavor() && (bitrate == VideoBitrate.BITRATE_AUTO || bitrate == VideoBitrate.BITRATE_30_MBPS))
                continue;
            bitrates.add(bitrate);
        }
        return bitrates;
    }

    private String[] getVideoBitrateEntryValues(ArrayList<VideoBitrate> bitrates) {
        String[] entryValues = new String[bitrates.size()];
        for (int i = 0; i < bitrates.size(); i++) {
            entryValues[i] = bitrates.get(i).name();
        }
        return entryValues;
    }

    private String[] getVideoBitrateEntries(ArrayList<VideoBitrate> bitrates) {
        String[] entries = new String[bitrates.size()];
        for (int i = 0; i < bitrates.size(); i++) {
            entries[i] = bitrates.get(i).getLabel();
            if (settings.getDeviceProfile() != null && settings.getDeviceProfile().hideVideoBitrate(bitrates.get(i))) {
                entries[i] = getString(R.string.settings_unstable, entries[i]);
            }
        }
        return entries;
    }

    private String[] getTimeLapseEntries(String[] values) {
        String[] entries = new String[values.length];
        for (int i = 0; i < entries.length; i++) {
            entries[i] = formatTimeLapseEntry(Integer.parseInt(values[i]));
        }
        return entries;
    }

    private String formatTimeLapseEntry(int timeLapse) {
        if (timeLapse == 1) {
            return getString(R.string.settings_time_lapse_entry_no_time_lapse, timeLapse);
        }
        return getString(R.string.settings_time_lapse_entry, timeLapse);
    }

    private String formatVideoEncoderSummary(int videoEncoder) {
        switch(videoEncoder) {
            case VideoEncoder.FFMPEG_MPEG_4:
                return getString(R.string.settings_video_encoder_ffmpeg_summary);
            case VideoEncoder.H264:
                return getString(R.string.settings_video_encoder_built_in_summary, getString(R.string.settings_video_encoder_h264));
            case VideoEncoder.MPEG_4_SP:
                return getString(R.string.settings_video_encoder_built_in_summary, getString(R.string.settings_video_encoder_mpeg_4_sp));
            case VideoEncoder.NO_ROOT_H264:
                return getString(R.string.settings_video_encoder_built_in_summary, getString(settings.isRootFlavor() ? R.string.settings_video_encoder_no_root_h264 : R.string.settings_video_encoder_h264));
            case VideoEncoder.NO_ROOT_MPEG_4:
                return getString(R.string.settings_video_encoder_built_in_summary, getString(settings.isRootFlavor() ? R.string.settings_video_encoder_no_root_mpeg_4 : R.string.settings_video_encoder_mpeg_4));
        }
        return "";
    }

    private String formatTransformationSummary(Transformation transformation) {
        if (VideoEncoder.isSoftware(settings.getVideoEncoder())) {
            return getString(R.string.settings_transformation_sw_summary);
        }
        if (settings.isNoRootVideoEncoder()) {
            return getString(R.string.settings_root_only);
        }
        switch(transformation) {
            case CPU:
                return getString(R.string.settings_transformation_cpu_summary);
            case GPU:
                return getString(R.string.settings_transformation_gpu_summary, getString(R.string.settings_transformation_gpu));
            case OES:
                return getString(R.string.settings_transformation_gpu_summary, getString(R.string.settings_transformation_oes));
        }
        return "";
    }

    private String formatVideoBitrateSummary(VideoBitrate bitrate) {
        return String.format(getString(R.string.settings_video_bitrate_summary), bitrate.getLabel());
    }

    private CharSequence[] getFrameRateEntries(CharSequence[] values) {
        String[] entries = new String[values.length];
        for (int i = 0; i < entries.length; i++) {
            int frameRate = Integer.parseInt(values[i].toString());
            if (frameRate == -1) {
                entries[i] = getString(R.string.settings_frame_rate_max);
            } else {
                entries[i] = String.format(getString(R.string.settings_frame_rate_up_to), frameRate);
            }
        }
        return entries;
    }

    private String formatFrameRateSummary(int frameRate) {
        if (settings.isNoRootVideoEncoder() || frameRate == -1) {
            return getString(R.string.settings_frame_rate_max_summary);
        }
        return String.format(getString(R.string.settings_frame_rate_summary), frameRate);
    }

    private String formatAudioSourceSummary(AudioSource source, boolean isTimeLapse) {
        if (isTimeLapse) {
            return getString(R.string.settings_audio_time_lapse_summary);
        }
        switch(source) {
            case MIC:
                return getString(R.string.settings_audio_mic_summary);
            case MUTE:
                return getString(R.string.settings_audio_mute_summary);
            case INTERNAL:
                return getString(R.string.settings_audio_internal_summary);
            case MIX:
                return getString(R.string.settings_audio_mix_summary);
        }
        return "";
    }

    private String formatSamplingRateSummary() {
        return settings.getSamplingRate().getLabel();
    }

    private int gainToIndex(int gain) {
        for (int i = 0; i <= 4; i++) {
            if (gain == indexToGain(i)) {
                return i;
            }
        }
        return 0;
    }

    private int indexToGain(int index) {
        return (int) Math.pow(2, index);
    }

    private int gainToDecibel(int gain) {
        return (int) (20.0 * Math.log10(gain));
    }

    private String formatMicGain() {
        if (settings.getAudioSource() != AudioSource.MIX) {
            return getString(R.string.settings_mic_gain_summary_mix_only, getString(R.string.settings_audio_mix));
        }
        if (settings.getMicGain() == 1) {
            return getString(R.string.settings_mic_gain_summary_default);
        }
        return getString(R.string.settings_mic_gain_summary, gainToDecibel(settings.getMicGain()));
    }

    private String formatCameraAlphaSummary() {
        if (getActivity() == null)
            return "";
        if (settings.getCameraAlpha() == 1.0f) {
            return getString(R.string.settings_camera_alpha_summary_100);
        }
        int percentage = (int) (settings.getCameraAlpha() * 100);
        return getString(R.string.settings_camera_alpha_summary, percentage);
    }

    private void openOutputDirChooser() {
        Intent intent = new Intent(getActivity(), DirectoryChooserActivity.clreplaced);
        intent.setData(Uri.fromFile(Settings.getInstance().getOutputDir()));
        intent.putExtra(DirectoryChooserActivity.DEFAULT_DIR_EXTRA, Settings.getInstance().getDefaultOutputDir().getAbsolutePath());
        startActivityForResult(intent, SELECT_OUTPUT_DIR);
    }

    @Override
    public boolean onPreferenceChange(Preference preference, Object newValue) {
        String valueString = null;
        Boolean selected = Boolean.FALSE;
        if (preference instanceof ListPreference) {
            valueString = (String) newValue;
        }
        if (preference instanceof CheckBoxPreference) {
            selected = (Boolean) newValue;
        }
        if (preference == videoConfigPreference) {
            int configIndex = Integer.parseInt(valueString);
            VideoConfig videoConfig = settings.getDeviceProfile().getVideoConfigs().get(configIndex);
            settings.setVideoEncoder(videoConfig.getVideoEncoder());
            settings.setResolution(videoConfig.getResolution());
            settings.setTransformation(videoConfig.getTransformation());
            settings.setVideoBitrate(videoConfig.getVideoBitrate());
            updateValues();
        } else if (preference == videoEncoderPreference) {
            int videoEncoder = Integer.parseInt(valueString);
            settings.setVideoEncoder(videoEncoder);
            updateValues();
        } else if (preference == resolutionPreference) {
            Resolution resolution = findResolution(valueString);
            settings.setResolution(resolution);
            preference.setSummary(formatResolutionEntry(resolution));
            updateSelectedVideoConfig();
        } else if (preference == orientationPreference) {
            Orientation orientation = Orientation.valueOf(valueString);
            settings.setOrientation(orientation);
            preference.setSummary(formatOrientationSummary(orientation));
        } else if (preference == timeLapsePreference) {
            settings.setTimeLapse(Integer.parseInt(valueString));
            updateValues();
        } else if (preference == transformationPreference) {
            Transformation transformation = Transformation.valueOf(valueString);
            settings.setTransformation(transformation);
            preference.setSummary(formatTransformationSummary(transformation));
            updateSelectedVideoConfig();
        } else if (preference == videoBitratePreference) {
            VideoBitrate bitrate = VideoBitrate.valueOf(valueString);
            settings.setVideoBitrate(bitrate);
            preference.setSummary(formatVideoBitrateSummary(bitrate));
            updateSelectedVideoConfig();
        } else if (preference == frameRatePreference) {
            int frameRate = Integer.parseInt(valueString);
            settings.setFrameRate(frameRate);
            preference.setSummary(formatFrameRateSummary(frameRate));
        } else if (preference == verticalFramesPreference) {
            settings.setVerticalFrames(selected);
        } else if (preference == audioSourcePreference) {
            AudioSource source = AudioSource.valueOf(valueString);
            settings.setAudioSource(source);
            AudioDriver audioDriver = settings.getAudioDriver();
            if (source.getRequiresDriver() && audioDriver.shouldInstall()) {
                if (audioDriver.getRequiresHardInstall() && !settings.getDisableAudioWarning()) {
                    new AudioWarningDialogFragment().show(getFragmentManager(), AudioWarningDialogFragment.FRAGMENT_TAG);
                } else {
                    audioDriver.install();
                }
            }
        } else if (preference == samplingRatePreference) {
            SamplingRate rate = SamplingRate.valueOf(valueString);
            settings.setSamplingRate(rate);
            preference.setSummary(rate.getLabel());
        } else if (preference == stereoPreference) {
            settings.setStereo(selected);
        } else if (preference == micGainPreference) {
            settings.setMicGain(indexToGain((Integer) newValue));
            preference.setSummary(formatMicGain());
        } else if (preference == hideIconPreference) {
            settings.setHideIcon(selected);
        } else if (preference == showTouchesPreference) {
            settings.setShowTouches(selected);
        } else if (preference == showCameraPreference) {
            settings.setShowCamera(selected);
        } else if (preference == cameraAlphaPreference) {
            settings.setCameraAlpha(((Integer) newValue) / 100.0f);
            cameraAlphaPreference.setSummary(formatCameraAlphaSummary());
        } else if (preference == stopOnScreenOffPreference) {
            settings.setStopOnScreenOff(selected);
        } else if (preference == colorFixPreference) {
            settings.setColorFix(selected);
        }
        return true;
    }

    @Override
    public boolean onPreferenceClick(Preference preference) {
        if (preference == doreplacedentDirPreference) {
            openDoreplacedentPicker();
            return true;
        } else if (preference == outputDirPreference) {
            openOutputDirChooser();
            return true;
        } else if (preference == donatePreference) {
            donate();
            return true;
        } else if (preference == noRootModePreference) {
            enableRoot();
            return true;
        } else if (preference == gusherPreference) {
            openRecommendedApp(GusherDialogFragment.GUSHER_PACKAGE_ID);
            return true;
        } else if (preference == mp4fixPreference) {
            openRecommendedApp(RecorderService.VIDEO_REPAIR_PACKAGE);
            return true;
        }
        return false;
    }

    private void openRecommendedApp(String packageId) {
        Activity activity = getActivity();
        Intent intent = new Intent(Intent.ACTION_VIEW);
        intent.setData(Uri.parse("market://details?id=" + packageId + "&referrer=utm_source%3DSCR%26utm_medium%3Dsettings%26utm_campaign%3Drecommended_apps"));
        try {
            startActivity(intent);
        } catch (ActivityNotFoundException e) {
            Toast.makeText(activity, R.string.rating_play_error, Toast.LENGTH_LONG).show();
        }
    }

    private void donate() {
        Activity activity = getActivity();
        if (activity != null) {
            Intent payPalIntent = new Intent(Intent.ACTION_VIEW, Uri.parse("https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=3TDE5GYWQYVL6"));
            try {
                activity.startActivity(payPalIntent);
            } catch (Exception e) {
                Log.e(TAG, "Error starting donation intent", e);
            }
        }
    }

    private void enableRoot() {
        settings.setRootEnabled(true);
        Activity activity = getActivity();
        if (activity != null) {
            Intent serviceIntent = new Intent(activity, RecorderService.clreplaced);
            serviceIntent.setAction(RecorderService.ENABLE_ROOT_ACTION);
            activity.startService(serviceIntent);
        }
    }

    private void openDoreplacedentPicker() {
        Intent intent = new Intent(Intent.ACTION_OPEN_DOreplacedENT_TREE);
        startActivityForResult(intent, SELECT_DOreplacedENT_DIR);
    }

    private void setDoreplacedentDir(Intent data) {
        Uri treeUri = data.getData();
        DoreplacedentFile doreplacedentDir = DoreplacedentFile.fromTreeUri(getActivity(), treeUri);
        // Persist access permissions.
        getActivity().getContentResolver().takePersistableUriPermission(treeUri, Intent.FLAG_GRANT_READ_URI_PERMISSION | Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
        Settings.getInstance().setDoreplacedentDirUri(treeUri);
        Settings.getInstance().setDoreplacedentDirName(doreplacedentDir.getName());
    }

    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        if (requestCode == SELECT_OUTPUT_DIR) {
            if (resultCode == Activity.RESULT_OK) {
                settings.setOutputDir(new File(data.getData().getPath()));
                outputDirPreference.setSummary(settings.getOutputDir().getAbsolutePath());
            }
        } else if (requestCode == SELECT_DOreplacedENT_DIR) {
            if (resultCode == Activity.RESULT_OK && data != null) {
                setDoreplacedentDir(data);
                doreplacedentDirPreference.setSummary(settings.getDoreplacedentDirName());
            }
        }
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        settings.unregisterOnSharedPreferenceChangeListener(this);
        settings.getAudioDriver().removeInstallListener(this);
    }

    @Override
    public void onInstall(InstallationStatus status) {
        updateValues();
    }

    @Override
    public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
        if (Settings.ROOT_ENABLED.equals(key)) {
            updateEntries();
            updateValues();
        } else if (Settings.AUDIO_SOURCE.equals(key)) {
            updateSamplingRate();
            updateValues();
        }
    }
}

19 Source : SettingsHolder.java
with MIT License
from hubcarl

private void initChangeWidgetTheme() {
    ListPreference listPreference = (ListPreference) findPreference(WIDGET_STYLE);
    listPreference.setOnPreferenceChangeListener(new OnPreferenceChangeListener() {

        @Override
        public boolean onPreferenceChange(Preference preference, Object newValue) {
            MusicUtils.notifyWidgets(ApolloService.META_CHANGED);
            return true;
        }
    });
}

19 Source : DialerPreferencesActivity.java
with GNU General Public License v3.0
from HenriDellal

@Override
public void onSharedPreferenceChanged(SharedPreferences prefs, String key) {
    Preference pref = findPreference(key);
    if (pref instanceof ListPreference) {
        ListPreference listPreference = (ListPreference) pref;
        listPreference.setSummary(listPreference.getEntry());
    }
    if ("theme".equals(key) || "t9_locale".equals(key)) {
        restartTriggered = true;
    }
}

19 Source : DialerPreferencesActivity.java
with GNU General Public License v3.0
from HenriDellal

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    addPreferencesFromResource(R.xml.preferences);
    ListPreference themePreference = (ListPreference) findPreference("theme");
    themePreference.setSummary(themePreference.getEntry());
    preferences = PreferenceManager.getDefaultSharedPreferences(this);
}

19 Source : Settings.java
with MIT License
from GrapheneOS

@Override
public void onResume() {
    super.onResume();
    final ListPreference networkType = (ListPreference) findPreference(KEY_NETWORK_TYPE);
    networkType.setValue(Integer.toString(getNetworkType(this)));
}

19 Source : SettingActivity.java
with Apache License 2.0
from devallever

/**
 * Created by XM on 2016/4/29.
 */
public clreplaced SettingActivity extends PreferenceActivity implements SharedPreferences.OnSharedPreferenceChangeListener {

    private ListPreference lp_ad_day;

    private ListPreference lp_ad_count;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        addPreferencesFromResource(R.xml.seeting_pref);
        lp_ad_day = (ListPreference) this.findPreference("pref_setting_ad_day_key");
        lp_ad_count = (ListPreference) this.findPreference("pref_setting_ad_count_key");
    }

    @Override
    protected void onResume() {
        super.onResume();
        // 统计activity页面
        StatService.onResume(this);
        SharedPreferences sharedPreferences = getPreferenceScreen().getSharedPreferences();
        String show_day = sharedPreferences.getString("pref_setting_ad_day_key", "选择弹出时间") + "天";
        lp_ad_day.setSummary(show_day);
        String show_count = sharedPreferences.getString("pref_setting_ad_count_key", "选择弹出次数") + "次";
        lp_ad_count.setSummary(show_count);
        // Set up a listener whenever a key changes
        sharedPreferences.registerOnSharedPreferenceChangeListener(this);
    }

    @Override
    protected void onPause() {
        super.onPause();
        // 统计activity页面
        StatService.onPause(this);
    }

    @Override
    public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
        // 设置了系统的生成的配置文件
        String str_daycount = sharedPreferences.getString("pref_setting_ad_day_key", "1");
        String show_day = sharedPreferences.getString("pref_setting_ad_day_key", "1") + "天";
        lp_ad_day.setSummary(show_day);
        String str_count = sharedPreferences.getString("pref_setting_ad_count_key", "1");
        String show_count = sharedPreferences.getString("pref_setting_ad_count_key", "1") + "次";
        lp_ad_count.setSummary(show_count);
        // 设置自己的配置文件
        SharedPreferenceUtil.setADComment(Integer.parseInt(str_daycount), Integer.parseInt(str_count));
        // SharedPreferenceUtil.setAdvertiseDatacannotshow();
        int dayCount;
        if (str_daycount.equals("1")) {
            dayCount = 1;
        } else if (str_daycount.equals("2")) {
            dayCount = 2;
        } else if (str_daycount.equals("3")) {
            dayCount = 3;
        } else {
            dayCount = 1;
        }
        // n天
        int ten_min = 60 * 1000 * 60 * 24 * dayCount;
        // int ten_min = 60*1000;//60s测试
        long triggerAtTime = SystemClock.elapsedRealtime() + ten_min;
        Intent i = new Intent(this, AdvertiseReciever.clreplaced);
        PendingIntent pendingIntent = PendingIntent.getBroadcast(this, 0, i, 0);
        AlarmManager alarmManager = (AlarmManager) getSystemService(ALARM_SERVICE);
    // alarmManager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP,triggerAtTime,pendingIntent);
    }
}

19 Source : SettingsPresenter.java
with GNU General Public License v3.0
from davidmigloz

@Override
public boolean onPreferenceChange(Preference preference, Object value) {
    String stringValue = value.toString();
    if (preference instanceof ListPreference) {
        // For list preferences, look up the correct display value in
        // the preference's 'entries' list (since they have separate labels/values)
        ListPreference listPreference = (ListPreference) preference;
        int prefIndex = listPreference.findIndexOfValue(stringValue);
        if (prefIndex >= 0) {
            preference.setSummary(listPreference.getEntries()[prefIndex]);
        }
    } else {
        // For other preferences, set the summary to the value's simple string representation
        preference.setSummary(stringValue);
    }
    return true;
}

19 Source : MonitoringSettingsFragment.java
with GNU General Public License v3.0
from davidmigloz

/**
 * Update the summary of the preference with the new value.
 *
 * @param preference preference to update summary.
 * @param value      new value.
 */
private void updateSummary(Preference preference, Object value) {
    if (preference instanceof ListPreference) {
        // For list preferences, look up the correct display value in
        // the preference's 'entries' list (since they have separate labels/values)
        ListPreference listPreference = (ListPreference) preference;
        int prefIndex = listPreference.findIndexOfValue((String) value);
        if (prefIndex >= 0) {
            preference.setSummary(listPreference.getEntries()[prefIndex]);
        }
    } else if (preference instanceof VNTNumberPickerPreference) {
        // For number pickers, show the value
        preference.setSummary(Integer.toString((Integer) value));
    } else {
        // For other preferences, set the summary to the value's simple string representation
        preference.setSummary(value.toString());
    }
}

19 Source : ListSummaryPreferenceFragment.java
with GNU General Public License v3.0
from CryptoGuardOSS

protected void initializeListSummary(ListPreference pref) {
    pref.setSummary(pref.getEntry());
}

19 Source : SettingsFragment.java
with MIT License
from crazyhitty

/**
 * Author:      Kartik Sharma
 * Email Id:    [email protected]
 * Created:     1/15/2017 8:17 PM
 * Description: Unavailable
 */
public clreplaced SettingsFragment extends PreferenceFragment implements SettingsContract.View {

    private ListPreference mListPreferenceManageThemes, mListPreferenceChangeFont;

    private PredatorDialogPreference mPredatorDialogPreferenceClearCache;

    private SwitchPreference mSwitchPreferenceEnableExperimentalFeatures, mSwitchPreferenceBackgroundSync, mSwitchPreferenceNotifications;

    private ListPreference mListPreferenceSyncInterval;

    private MultiSelectListPreference mMultiSelectListPreferenceNotificationSettings;

    private SettingsContract.Presenter mSettingsPresenter;

    public static SettingsFragment newInstance() {
        return new SettingsFragment();
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setPresenter(new SettingsPresenter(this));
        mSettingsPresenter.subscribe();
        // Load the preferences from an XML resource
        addPreferencesFromResource(R.xml.settings_preferences);
        bindPreferences();
        manageThemesPreferences();
        // manageEnableExperimentalFeaturesPreferences();
        manageFontsPreferences();
        manageCachePreferences();
        manageBackgroundSyncPreferences();
        manageSyncIntervalPreferences();
        manageNotificationsPreferences();
        manageNotificationSettingsPreferences();
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        mSettingsPresenter.unSubscribe();
    }

    private void bindPreferences() {
        mListPreferenceManageThemes = (ListPreference) findPreference(getString(R.string.settings_manage_themes_key));
        mPredatorDialogPreferenceClearCache = (PredatorDialogPreference) findPreference(getString(R.string.settings_clear_cache_key));
        // mSwitchPreferenceEnableExperimentalFeatures = (SwitchPreference) findPreference(getString(R.string.settings_enable_experimental_features_key));
        mListPreferenceChangeFont = (ListPreference) findPreference(getString(R.string.settings_change_font_key));
        mSwitchPreferenceBackgroundSync = (SwitchPreference) findPreference(getString(R.string.settings_background_sync_key));
        mListPreferenceSyncInterval = (ListPreference) findPreference(getString(R.string.settings_sync_interval_key));
        mSwitchPreferenceNotifications = (SwitchPreference) findPreference(getString(R.string.settings_notifications_key));
        mMultiSelectListPreferenceNotificationSettings = (MultiSelectListPreference) findPreference(getString(R.string.settings_notification_settings_key));
    }

    private void manageThemesPreferences() {
        mListPreferenceManageThemes.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

            @Override
            public boolean onPreferenceChange(Preference preference, Object newValue) {
                SettingsActivity.startActivity(getActivity(), true);
                return true;
            }
        });
    }

    private void manageEnableExperimentalFeaturesPreferences() {
        mSwitchPreferenceEnableExperimentalFeatures.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

            @Override
            public boolean onPreferenceChange(Preference preference, Object newValue) {
                Boolean status = (Boolean) newValue;
                return true;
            }
        });
    }

    private void manageFontsPreferences() {
        // mListPreferenceChangeFont.setEnabled(PredatorSharedPreferences.isExperimentalFeaturesEnabled(getActivity().getApplicationContext()));
        mListPreferenceChangeFont.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

            @Override
            public boolean onPreferenceChange(Preference preference, Object newValue) {
                MainApplication.reInitializeCalligraphy(getActivity().getApplicationContext(), (String) newValue);
                SettingsActivity.startActivity(getActivity(), true);
                return true;
            }
        });
    }

    private void manageCachePreferences() {
        mPredatorDialogPreferenceClearCache.setOnPositiveButtonClickListener(new PredatorDialogPreference.OnPositiveButtonClickListener() {

            @Override
            public void onClick(DialogInterface dialog) {
                // Clear cache.
                mSettingsPresenter.clearCache();
            }
        });
    }

    private void manageBackgroundSyncPreferences() {
        mSwitchPreferenceBackgroundSync.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

            @Override
            public boolean onPreferenceChange(Preference preference, Object newValue) {
                Boolean status = (Boolean) newValue;
                mListPreferenceSyncInterval.setEnabled(status);
                mSwitchPreferenceNotifications.setEnabled(status);
                if (!status) {
                    mSwitchPreferenceNotifications.setChecked(false);
                    mMultiSelectListPreferenceNotificationSettings.setEnabled(false);
                }
                if (status) {
                    PredatorSyncAdapter.initializePeriodicSync(getActivity().getApplicationContext());
                } else {
                    PredatorSyncAdapter.removePeriodicSync(getActivity().getApplicationContext());
                }
                return true;
            }
        });
    }

    private void manageSyncIntervalPreferences() {
        mListPreferenceSyncInterval.setEnabled(PredatorSharedPreferences.isSyncEnabled(getActivity().getApplicationContext()));
        mListPreferenceSyncInterval.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

            @Override
            public boolean onPreferenceChange(Preference preference, Object newValue) {
                String hours = (String) newValue;
                PredatorSyncAdapter.initializePeriodicSync(getActivity().getApplicationContext(), DateUtils.hoursToSeconds(hours));
                return true;
            }
        });
    }

    private void manageNotificationsPreferences() {
        mSwitchPreferenceNotifications.setEnabled(PredatorSharedPreferences.isSyncEnabled(getActivity().getApplicationContext()));
        mSwitchPreferenceNotifications.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

            @Override
            public boolean onPreferenceChange(Preference preference, Object newValue) {
                Boolean status = (Boolean) newValue;
                mMultiSelectListPreferenceNotificationSettings.setEnabled(status);
                return true;
            }
        });
    }

    private void manageNotificationSettingsPreferences() {
        mMultiSelectListPreferenceNotificationSettings.setEnabled(PredatorSharedPreferences.areNotificationsEnabled(getActivity().getApplicationContext()));
    }

    @Override
    public void cacheCleared() {
        Toast.makeText(getActivity().getApplicationContext(), R.string.settings_clear_cache_success_message, Toast.LENGTH_LONG).show();
    }

    @Override
    public void unableToWipeCache() {
        Toast.makeText(getActivity().getApplicationContext(), R.string.settings_clear_cache_failure_message, Toast.LENGTH_LONG).show();
    }

    @Override
    public void setPresenter(SettingsContract.Presenter presenter) {
        mSettingsPresenter = presenter;
    }
}

19 Source : SettingsFragment.java
with Apache License 2.0
from CosimoSguanci

public clreplaced SettingsFragment extends PreferenceFragment {

    private ListPreference mListPreference;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        addPreferencesFromResource(R.xml.preference_hierarchy);
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        View view = super.onCreateView(inflater, container, savedInstanceState);
        view.setBackgroundColor(Color.WHITE);
        mListPreference = (ListPreference) getPreferenceManager().findPreference("theme");
        mListPreference.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

            @Override
            public boolean onPreferenceChange(Preference preference, Object newValue) {
                getActivity().recreate();
                return true;
            }
        });
        return view;
    }

    @Override
    public void onStop() {
        super.onStop();
    }
}

19 Source : VideoPreferencesFragment.java
with Apache License 2.0
from archos-sa

public clreplaced VideoPreferencesFragment extends PreferenceFragment implements OnSharedPreferenceChangeListener {

    public static final String KEY_VIDEO_AD_FREE = "video_ad_free";

    public static final String KEY_VIDEO_AD_FREE_CATEGORY = "preferences_category_complete";

    public static final String KEY_ADVANCED_VIDEO_ENABLED = "preferences_advanced_video_enabled";

    public static final String KEY_ADVANCED_VIDEO_CATEGORY = "preferences_category_advanced_video";

    public static final String KEY_ADVANCED_3D_TV_SWITCH_SUPPORTED = "preferences_tv_switch_supported";

    public static final String KEY_ADVANCED_VIDEO_QUIT = "preferences_video_advanced_quit";

    public static final String KEY_TORRENT_BLOCKLIST = "preferences_torrent_blocklist";

    public static final String KEY_TORRENT_PATH = "preferences_torrent_path";

    public static final String KEY_SHARED_FOLDERS = "share_folders";

    public static final String KEY_FORCE_SW = "force_software_decoding";

    public static final String KEY_FORCE_AUDIO_PreplacedTHROUGH = "force_audio_preplacedthrough";

    public static final String KEY_ACTIVATE_REFRESHRATE_SWITCH = "enable_tv_refreshrate_switch";

    public static final String KEY_ACTIVATE_3D_SWITCH = "activate_tv_switch";

    public static final String KEY_VIDEO_OS = "preferences_video_os";

    public static final String KEY_TMDB = "preferences_video_tmdb";

    public static final String KEY_TVDB = "preferences_video_tvdb";

    public static final String KEY_TRAKT = "preferences_video_trakt";

    public static final String KEY_TRAKT_SYNC_PROGRESS = "trakt_sync_resume";

    public static final String KEY_LICENCES = "preferences_video_licences";

    public static final String KEY_SORT_ORDER_CATEGORY = "preferences_sort_order_category";

    public static final String KEY_TV_SHOW_SORT_ORDER = "preferences_tv_show_sort_order";

    public static final String KEY_DEC_CHOICE = "dec_choice";

    public static final String KEY_SUBreplacedLES_HIDE = "subreplacedles_hide_default";

    public static final String KEY_SUBreplacedLES_FAV_LANG = "favSubLang";

    public static final String KEY_TRAKT_CATEGORY = "trakt_category";

    public static final String KEY_TRAKT_GETFULL = "trakt_getfull";

    public static final String KEY_TRAKT_SIGNIN = "trakt_signin";

    public static final String KEY_TRAKT_WIPE = "trakt_wipe";

    public static final String KEY_TRAKT_LIVE_SCROBBLING = "trakt_live_scrobbling";

    public static final String KEY_TRAKT_SYNC_COLLECTION = "trakt_sync_collection";

    public static final String KEY_HIDE_WATCHED = "hide_watched";

    public static final String KEY_CREATE_REMOTE_THUMBS = VideoProvider.PREFERENCE_CREATE_REMOTE_THUMBS;

    public static final boolean TRAKT_SYNC_COLLECTION_DEFAULT = false;

    public static final boolean TRAKT_LIVE_SCROBBLING_DEFAULT = true;

    public static final String LOGIN_DIALOG = "login_dialog";

    private static final boolean ACTIVATE_EMAIL_MEDIA_DB = true;

    private static final String KEY_RESCAN_STORAGE = "rescan_storage";

    private static final String KEY_DISPLAY_ALL_FILE = "preference_display_all_files";

    private SharedPreferences mSharedPreferences = null;

    private int mAdvancedPrefsClickCount = 0;

    private long mAdvancedPrefsClickLastTime = 0;

    private int mEmailMediaDBPrefsClickCount = 0;

    private long mEmailMediaDBPrefsClickLastTime = 0;

    private ListPreference mDecChoicePreferences = null;

    private CheckBoxPreference mForceSwDecPreferences = null;

    private CheckBoxPreference mForceAudioPreplacedthrough = null;

    private CheckBoxPreference mActivateRefreshrateTVSwitch = null;

    private CheckBoxPreference mActivate3DTVSwitch = null;

    private PreferenceCategory mAdvancedPreferences = null;

    private ListPreference mSubreplacedlesFavLangPreferences = null;

    private String mLastTraktUser = null;

    private Trakt.Status mTraktStatus = Trakt.Status.SUCCESS;

    private TraktSigninDialogPreference mTraktSigninPreference = null;

    private Preference mTraktWipePreference = null;

    private CheckBoxPreference mTraktLiveScrobblingPreference = null;

    private CheckBoxPreference mTraktSyncCollectionPreference = null;

    private CheckBoxPreference mTraktSyncProgressPreference = null;

    private CheckBoxPreference mAutoScrapPreference = null;

    private Handler mHanlder = null;

    BillingUtils u;

    private IsPaidCallback isPaidCallback;

    private Preference mTraktFull;

    private PreferenceCategory mCompleteCategory;

    final public static int ACTIVITY_RESULT_UI_MODE_CHANGED = 665;

    final public static int ACTIVITY_RESULT_UI_ZOOM_CHANGED = 667;

    private Set<String> mDownloadSubsList;

    private Preference mExportManualPreference;

    private void switchAdvancedPreferences() {
        PreferenceCategory prefCategory = (PreferenceCategory) findPreference("preferences_category_video");
        if (!ArchosFeatures.isTV(getActivity())) {
            prefCategory.removePreference(mActivate3DTVSwitch);
            prefCategory.removePreference(mActivateRefreshrateTVSwitch);
        } else {
            prefCategory.addPreference(mActivate3DTVSwitch);
            prefCategory.addPreference(mActivateRefreshrateTVSwitch);
        }
        if (mSharedPreferences.getBoolean(KEY_ADVANCED_VIDEO_ENABLED, false)) {
            // advanced preferences
            Editor editor = mForceSwDecPreferences.getEditor();
            editor.remove(KEY_FORCE_SW);
            editor.apply();
            prefCategory.removePreference(mForceSwDecPreferences);
            prefCategory.addPreference(mDecChoicePreferences);
            getPreferenceScreen().addPreference(mAdvancedPreferences);
        } else {
            // normal preferences
            Editor editor = mDecChoicePreferences.getEditor();
            editor.remove(KEY_DEC_CHOICE);
            editor.apply();
            prefCategory.removePreference(mDecChoicePreferences);
            prefCategory.addPreference(mForceSwDecPreferences);
            getPreferenceScreen().removePreference(mAdvancedPreferences);
        }
    }

    public void launchPurchase() {
        // TODO Auto-generated method stub
        u.purchase(getActivity(), isPaidCallback);
    }

    public static void resetPreplacedthroughPref(SharedPreferences preferences) {
        if (Integer.valueOf(preferences.getString("force_audio_preplacedthrough_multiple", "-1")) == -1 && preferences.getBoolean("force_audio_preplacedthrough", false)) {
            // has never been set
            // has never been set with new mode but was set with old mode
            // set pref
            preferences.edit().putString("force_audio_preplacedthrough_multiple", "1").apply();
        }
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        u = new BillingUtils(getActivity());
        mSharedPreferences = getPreferenceManager().getSharedPreferences();
        // Load the preferences from an XML resource
        resetPreplacedthroughPref(mSharedPreferences);
        addPreferencesFromResource(R.xml.preferences_video);
        isPaidCallback = new IsPaidCallback(getActivity()) {

            @Override
            public void hasBeenPaid(int isPaid) {
                super.hasBeenPaid(isPaid);
                if (!isAdded())
                    return;
                if (checkPayement(isPaid)) {
                    setPaidStatus();
                    if (getActivity().getIntent().getBooleanExtra(VideoPreferencesActivity.EXTRA_LAUNCH_INAPP_PURCHASE, false)) {
                        Toast.makeText(getActivity(), R.string.premium_already_purchased, Toast.LENGTH_LONG).show();
                    }
                } else {
                    setFreeStatus();
                    if (getActivity().getIntent().getBooleanExtra(VideoPreferencesActivity.EXTRA_LAUNCH_INAPP_PURCHASE, false)) {
                        launchPurchase();
                    }
                }
            }
        };
        mSharedPreferences = getPreferenceManager().getSharedPreferences();
        mSharedPreferences.registerOnSharedPreferenceChangeListener(this);
        final Preference pref = (Preference) findPreference(KEY_VIDEO_OS);
        pref.setEnabled(true);
        pref.setOnPreferenceClickListener(new OnPreferenceClickListener() {

            @Override
            public boolean onPreferenceClick(Preference preference) {
                videoPreferenceOsClick();
                return false;
            }
        });
        findPreference(KEY_TMDB).setOnPreferenceClickListener(new OnPreferenceClickListener() {

            @Override
            public boolean onPreferenceClick(Preference preference) {
                videoPreferenceTmdbClick();
                return false;
            }
        });
        findPreference(KEY_TVDB).setOnPreferenceClickListener(new OnPreferenceClickListener() {

            @Override
            public boolean onPreferenceClick(Preference preference) {
                videoPreferenceTvdbClick();
                return false;
            }
        });
        findPreference(KEY_TRAKT).setOnPreferenceClickListener(new OnPreferenceClickListener() {

            @Override
            public boolean onPreferenceClick(Preference preference) {
                videoPreferenceTraktClick();
                return false;
            }
        });
        findPreference(KEY_LICENCES).setOnPreferenceClickListener(new OnPreferenceClickListener() {

            @Override
            public boolean onPreferenceClick(Preference preference) {
                startActivity(new Intent(getActivity(), VideoPreferencesLicencesActivity.clreplaced));
                return false;
            }
        });
        mDecChoicePreferences = (ListPreference) findPreference(KEY_DEC_CHOICE);
        mForceSwDecPreferences = (CheckBoxPreference) findPreference(KEY_FORCE_SW);
        mForceAudioPreplacedthrough = (CheckBoxPreference) findPreference(KEY_FORCE_AUDIO_PreplacedTHROUGH);
        mActivate3DTVSwitch = (CheckBoxPreference) findPreference(KEY_ACTIVATE_3D_SWITCH);
        mActivateRefreshrateTVSwitch = (CheckBoxPreference) findPreference(KEY_ACTIVATE_REFRESHRATE_SWITCH);
        mTraktSyncProgressPreference = (CheckBoxPreference) findPreference(KEY_TRAKT_SYNC_PROGRESS);
        mAdvancedPreferences = (PreferenceCategory) findPreference(KEY_ADVANCED_VIDEO_CATEGORY);
        mExportManualPreference = findPreference(getString(R.string.nfo_export_manual_prefkey));
        mExportManualPreference.setOnPreferenceClickListener(new OnPreferenceClickListener() {

            @Override
            public boolean onPreferenceClick(Preference preference) {
                Intent intent = new Intent(AutoScrapeService.EXPORT_EVERYTHING, null, getActivity(), AutoScrapeService.clreplaced);
                getActivity().startService(intent);
                Toast.makeText(getActivity(), R.string.nfo_export_in_progress, Toast.LENGTH_SHORT).show();
                return true;
            }
        });
        findPreference(getString(R.string.rescrap_all_prefkey)).setOnPreferenceClickListener(new OnPreferenceClickListener() {

            @Override
            public boolean onPreferenceClick(Preference preference) {
                Intent intent = new Intent(getActivity(), AutoScrapeService.clreplaced);
                intent.putExtra(AutoScrapeService.RESCAN_EVERYTHING, true);
                getActivity().startService(intent);
                Toast.makeText(getActivity(), R.string.rescrap_in_progress, Toast.LENGTH_SHORT).show();
                return true;
            }
        });
        findPreference(KEY_RESCAN_STORAGE).setOnPreferenceClickListener(new OnPreferenceClickListener() {

            @Override
            public boolean onPreferenceClick(Preference preference) {
                rescanPath(Environment.getExternalStorageDirectory().getAbsolutePath());
                ExtStorageManager storageManager = ExtStorageManager.getExtStorageManager();
                final boolean hasExternal = storageManager.hasExtStorage();
                if (hasExternal) {
                    for (String s : storageManager.getExtSdcards()) {
                        rescanPath(s);
                    }
                    for (String s : storageManager.getExtUsbStorages()) {
                        rescanPath(s);
                    }
                    for (String s : storageManager.getExtOtherStorages()) {
                        rescanPath(s);
                    }
                }
                Toast.makeText(getActivity(), R.string.rescanning, Toast.LENGTH_SHORT).show();
                return true;
            }
        });
        mAutoScrapPreference = (CheckBoxPreference) findPreference(AutoScrapeService.KEY_ENABLE_AUTO_SCRAP);
        // manage change manually to set pref before starting service
        mAutoScrapPreference.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

            @Override
            public boolean onPreferenceChange(Preference preference, final Object newValue) {
                boolean oldValue = getPreferenceManager().getSharedPreferences().getBoolean(AutoScrapeService.KEY_ENABLE_AUTO_SCRAP, true);
                getPreferenceManager().getSharedPreferences().edit().putBoolean(AutoScrapeService.KEY_ENABLE_AUTO_SCRAP, !oldValue).apply();
                mAutoScrapPreference.setChecked(!oldValue);
                if (!oldValue)
                    AutoScrapeService.startService(getActivity());
                return false;
            }
        });
        mTraktFull = findPreference(KEY_TRAKT_GETFULL);
        mCompleteCategory = (PreferenceCategory) findPreference(KEY_VIDEO_AD_FREE_CATEGORY);
        findPreference(KEY_SHARED_FOLDERS).setOnPreferenceClickListener(new OnPreferenceClickListener() {

            @Override
            public boolean onPreferenceClick(Preference preference) {
                startActivity(new Intent(getActivity(), CredentialsManagerPreferenceActivity.clreplaced));
                return false;
            }
        });
        findPreference("tv_shows").setOnPreferenceClickListener(new OnPreferenceClickListener() {

            @Override
            public boolean onPreferenceClick(Preference preference) {
                Intent intent = new Intent(getActivity(), com.archos.mediascraper.settings.ScraperPreferences.clreplaced);
                intent.putExtra("media", 12);
                startActivity(intent);
                return false;
            }
        });
        findPreference("movies").setOnPreferenceClickListener(new OnPreferenceClickListener() {

            @Override
            public boolean onPreferenceClick(Preference preference) {
                Intent intent = new Intent(getActivity(), com.archos.mediascraper.settings.ScraperPreferences.clreplaced);
                intent.putExtra("media", 11);
                startActivity(intent);
                return false;
            }
        });
        mForceSwDecPreferences.setOnPreferenceClickListener(new Preference.OnPreferenceClickListener() {

            @Override
            public boolean onPreferenceClick(Preference preference) {
                long currentTime = System.currentTimeMillis();
                if (currentTime - mAdvancedPrefsClickLastTime > 1000)
                    mAdvancedPrefsClickCount = 1;
                mAdvancedPrefsClickCount++;
                mAdvancedPrefsClickLastTime = currentTime;
                if (mAdvancedPrefsClickCount > 8) {
                    Editor editor = mSharedPreferences.edit();
                    editor.putBoolean(KEY_ADVANCED_VIDEO_ENABLED, true);
                    editor.apply();
                    switchAdvancedPreferences();
                    return true;
                }
                return false;
            }
        });
        Preference p = findPreference(KEY_ADVANCED_VIDEO_QUIT);
        p.setOnPreferenceClickListener(new Preference.OnPreferenceClickListener() {

            @Override
            public boolean onPreferenceClick(Preference preference) {
                Editor editor = mSharedPreferences.edit();
                editor.putBoolean(KEY_ADVANCED_VIDEO_ENABLED, false);
                editor.apply();
                switchAdvancedPreferences();
                return true;
            }
        });
        switchAdvancedPreferences();
        CheckBoxPreference cbp = (CheckBoxPreference) findPreference(KEY_SUBreplacedLES_HIDE);
        cbp.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

            @Override
            public boolean onPreferenceChange(Preference preference, Object newValue) {
                boolean doHide = ((Boolean) newValue);
                mSubreplacedlesFavLangPreferences.setEnabled(!doHide);
                return true;
            }
        });
        boolean doHide = mSharedPreferences.getBoolean(KEY_SUBreplacedLES_HIDE, false);
        mSubreplacedlesFavLangPreferences = (ListPreference) findPreference(KEY_SUBreplacedLES_FAV_LANG);
        mSubreplacedlesFavLangPreferences.setEnabled(!doHide);
        Locale defaultLocale = Locale.getDefault();
        String locale = defaultLocale.getISO3Language();
        List<String> entries = new ArrayList<String>(Arrays.asList(getResources().getStringArray(R.array.entries_list_preference)));
        List<String> entryValues = new ArrayList<String>(Arrays.asList(getResources().getStringArray(R.array.entryvalues_list_preference)));
        entries.set(0, defaultLocale.getDisplayLanguage());
        Locale currentLocale;
        for (int i = 1; i < entryValues.size(); ++i) {
            currentLocale = new Locale(entryValues.get(i));
            // entries.set(i, currentLocale.getDisplayLanguage()); // better use our translations, Android ones are not very consistant
            if (entryValues.get(i).equalsIgnoreCase(locale)) {
                entries.remove(0);
                entryValues.remove(0);
            }
        }
        final CharSequence[] newEntries = new CharSequence[entries.size()];
        final CharSequence[] newEntryValues = new CharSequence[entryValues.size()];
        entries.toArray(newEntries);
        entryValues.toArray(newEntryValues);
        final boolean[] toCheck = new boolean[newEntryValues.length];
        int systemLanguageIndex = -1;
        final String currentFavoriteLang = getPreferenceManager().getSharedPreferences().getString(KEY_SUBreplacedLES_FAV_LANG, Locale.getDefault().getISO3Language());
        // fill list of languages user has already selected for download
        mDownloadSubsList = getPreferenceManager().getSharedPreferences().getStringSet("languages_list", new HashSet<String>());
        int i = 0;
        for (CharSequence value : newEntryValues) {
            if (value.toString().equalsIgnoreCase(currentFavoriteLang)) {
                systemLanguageIndex = i;
            }
            toCheck[i] = mDownloadSubsList.contains(String.valueOf(value));
            i++;
        }
        findPreference("languages_list").setOnPreferenceClickListener(new OnPreferenceClickListener() {

            @Override
            public boolean onPreferenceClick(Preference preference) {
                AlertDialog.Builder builder = new AlertDialog.Builder(getActivity()).setMultiChoiceItems(newEntries, toCheck, new DialogInterface.OnMultiChoiceClickListener() {

                    @Override
                    public void onClick(DialogInterface dialogInterface, int i, boolean b) {
                        String s = String.valueOf(newEntryValues[i]);
                        if (!b)
                            mDownloadSubsList.remove(s);
                        else
                            mDownloadSubsList.add(s);
                        getPreferenceManager().getSharedPreferences().edit().putStringSet("languages_list", mDownloadSubsList).apply();
                    }
                }).setreplacedle(R.string.preferences_languages);
                if (!ArchosFeatures.isAndroidTV(getActivity()))
                    builder.setPositiveButton(android.R.string.ok, null);
                builder.show();
                return false;
            }
        });
        mSubreplacedlesFavLangPreferences.setEntries(newEntries);
        mSubreplacedlesFavLangPreferences.setEntryValues(newEntryValues);
        if (systemLanguageIndex >= 0)
            mSubreplacedlesFavLangPreferences.setValueIndex(systemLanguageIndex);
        ListPreference lp = (ListPreference) findPreference("codepage");
        int cp = MediaFactory.getCodepage();
        int cpStringID = getResources().getIdentifier("codepage_extra_" + cp, "string", getActivity().getPackageName());
        if (cpStringID == 0)
            cpStringID = R.string.codepage_extra_1252;
        CharSequence[] entryArray = lp.getEntries();
        entryArray[0] = getResources().getString(R.string.codepage_default, getResources().getString(cpStringID));
        lp.setEntries(entryArray);
        mHanlder = new Handler();
        mTraktSigninPreference = (TraktSigninDialogPreference) findPreference(KEY_TRAKT_SIGNIN);
        if (mTraktSigninPreference != null && savedInstanceState != null) {
            // close dialog to prevent leaked window
            mTraktSigninPreference.showDialog(savedInstanceState.getBoolean(LOGIN_DIALOG, false));
        }
        mTraktWipePreference = findPreference(KEY_TRAKT_WIPE);
        mTraktLiveScrobblingPreference = (CheckBoxPreference) findPreference(KEY_TRAKT_LIVE_SCROBBLING);
        // trakt resume must be disabled when no scrobbling
        mTraktSyncProgressPreference.setEnabled(mTraktLiveScrobblingPreference.isChecked() && mTraktLiveScrobblingPreference.isEnabled());
        mTraktLiveScrobblingPreference.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

            @Override
            public boolean onPreferenceChange(Preference preference, Object o) {
                mTraktSyncProgressPreference.setEnabled((Boolean) o && mTraktLiveScrobblingPreference.isEnabled());
                if (!(Boolean) o)
                    mTraktSyncProgressPreference.setChecked(false);
                return true;
            }
        });
        mTraktSyncCollectionPreference = (CheckBoxPreference) findPreference(KEY_TRAKT_SYNC_COLLECTION);
        mTraktStatus = Trakt.Status.SUCCESS;
        CheckBoxPreference nfoExportAutoPreferences = (CheckBoxPreference) findPreference("nfo_export_auto");
        if (nfoExportAutoPreferences != null) {
            nfoExportAutoPreferences.setOnPreferenceClickListener(new Preference.OnPreferenceClickListener() {

                @Override
                public boolean onPreferenceClick(Preference preference) {
                    if (!ACTIVATE_EMAIL_MEDIA_DB) {
                        return false;
                    }
                    // Check click speed
                    long currentTime = System.currentTimeMillis();
                    if (currentTime - mEmailMediaDBPrefsClickLastTime < 1000) {
                        mEmailMediaDBPrefsClickCount++;
                    } else {
                        mEmailMediaDBPrefsClickCount = 0;
                    }
                    mEmailMediaDBPrefsClickLastTime = currentTime;
                    if (mEmailMediaDBPrefsClickCount > 4) {
                        new AlertDialog.Builder(getActivity()).setMessage(R.string.ask_to_mail_media_DB).setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {

                            @Override
                            public void onClick(DialogInterface dialog, int which) {
                                new DebugDbExportDialogFragment().show(getFragmentManager(), "DebugDbExportDialogFragment");
                            }
                        }).setNegativeButton(android.R.string.cancel, null).create().show();
                        // reset to not have several dialogs displayed if user continue to click very quickly
                        mEmailMediaDBPrefsClickCount = 0;
                        return true;
                    }
                    return false;
                }
            });
        }
        PreferenceCategory userInterfaceCategory = (PreferenceCategory) findPreference("category_user_interface");
        if (userInterfaceCategory != null) {
            // Leanback device case: no UI preference at all (for now at least)
            if (getActivity().getPackageManager().hreplacedystemFeature(PackageManager.FEATURE_LEANBACK)) {
                getPreferenceScreen().removePreference(userInterfaceCategory);
            } else // Not a leanback device, but if the APK integrates leanback the user can choose to use it
            {
                if (EntryActivity.isLeanbackUiAvailable()) {
                    // remove the old uimode settings
                    userInterfaceCategory.removePreference(findPreference("uimode"));
                    findPreference("uimode_leanback").setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

                        public boolean onPreferenceChange(Preference preference, Object o) {
                            // way to tell the MainActivity that an important preference has been changed
                            getActivity().setResult(ACTIVITY_RESULT_UI_MODE_CHANGED);
                            // close the preference activity right away
                            getActivity().finish();
                            return true;
                        }
                    });
                    Preference uiZoomPref = findPreference("ui_zoom");
                    uiZoomPref.setOnPreferenceClickListener(new OnPreferenceClickListener() {

                        @Override
                        public boolean onPreferenceClick(Preference preference) {
                            // way to tell the MainActivity that an important preference has been changed
                            getActivity().setResult(ACTIVITY_RESULT_UI_ZOOM_CHANGED);
                            // close the preference activity right away
                            getActivity().finish();
                            return true;
                        }
                    });
                    // Do not show the zoom preference if user is not in TV more UI
                    String currentUiMode = getPreferenceManager().getSharedPreferences().getString(UiChoiceDialog.UI_CHOICE_LEANBACK_KEY, "-");
                    if (!currentUiMode.equals(UiChoiceDialog.UI_CHOICE_LEANBACK_TV_VALUE)) {
                        userInterfaceCategory.removePreference(uiZoomPref);
                    }
                } else {
                    // remove the new leanback settings (keep the old one)
                    userInterfaceCategory.removePreference(findPreference("uimode_leanback"));
                    // remove the zoom settings
                    userInterfaceCategory.removePreference(findPreference("ui_zoom"));
                }
            }
            PreferenceCategory sortOrderCategory = (PreferenceCategory) findPreference(KEY_SORT_ORDER_CATEGORY);
            if (sortOrderCategory != null) {
                if (!UiChoiceDialog.applicationIsInLeanbackMode(getActivity())) {
                    getPreferenceScreen().removePreference(sortOrderCategory);
                } else {
                    ListPreference tvshowSortOrderPref = (ListPreference) findPreference(KEY_TV_SHOW_SORT_ORDER);
                    tvshowSortOrderPref.setEntries(TvshowSortOrderEntries.getSortOrderEntries(getActivity()));
                    tvshowSortOrderPref.setEntryValues(TvshowSortOrderEntries.getSortOrderEntryValues(getActivity()));
                    tvshowSortOrderPref.setDefaultValue(TvshowSortOrderEntries.DEFAULT_SORT);
                }
            }
        }
        // Free / Paid
        if (ArchosUtils.isFreeVersion(getActivity())) {
            if (getPreferenceManager().getSharedPreferences().getBoolean(BillingUtils.PAID_STATUS_PREF, false))
                setPaidStatus();
            else
                setFreeStatus();
            u.checkPayement(isPaidCallback);
        } else {
            setPaidStatus();
        }
    }

    private void rescanPath(String s) {
        isMediaScannerScanning(getActivity().getContentResolver());
        Uri toIndex = Uri.parse(s);
        if (toIndex.getScheme() == null)
            toIndex = Uri.parse("file://" + toIndex.toString());
        Intent scanIntent = new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE);
        scanIntent.setData(toIndex);
        getActivity().sendBroadcast(scanIntent);
    }

    public static boolean isMediaScannerScanning(ContentResolver cr) {
        boolean result = false;
        Cursor cursor = cr.query(MediaStore.getMediaScannerUri(), new String[] { MediaStore.MEDIA_SCANNER_VOLUME }, null, null, null);
        if (cursor != null) {
            if (cursor.getCount() == 1) {
                cursor.moveToFirst();
                result = "external".equals(cursor.getString(0));
            }
            cursor.close();
        }
        return result;
    }

    private void setFreeStatus() {
        PreferenceCategory prefCategorty = (PreferenceCategory) findPreference(KEY_TRAKT_CATEGORY);
        if (prefCategorty != null) {
            if (prefCategorty.findPreference(KEY_TRAKT_GETFULL) == null)
                prefCategorty.addPreference(mTraktFull);
            if (findPreference(KEY_VIDEO_AD_FREE_CATEGORY) == null)
                getPreferenceScreen().addPreference(mCompleteCategory);
        }
        if (findPreference(KEY_TRAKT_GETFULL) != null)
            findPreference(KEY_TRAKT_GETFULL).setOnPreferenceClickListener(new Preference.OnPreferenceClickListener() {

                @Override
                public boolean onPreferenceClick(Preference preference) {
                    launchPurchase();
                    return true;
                }
            });
        findPreference(KEY_VIDEO_AD_FREE).setEnabled(true);
        findPreference(KEY_VIDEO_AD_FREE).setOnPreferenceClickListener(new Preference.OnPreferenceClickListener() {

            @Override
            public boolean onPreferenceClick(Preference preference) {
                launchPurchase();
                return true;
            }
        });
        mTraktSigninPreference.setEnabled(false);
        findPreference(KEY_TORRENT_BLOCKLIST).setOnPreferenceClickListener(new OnPreferenceClickListener() {

            @Override
            public boolean onPreferenceClick(Preference preference) {
                showTorrentBuyDialog();
                return true;
            }
        });
        findPreference(KEY_TORRENT_PATH).setOnPreferenceClickListener(new OnPreferenceClickListener() {

            @Override
            public boolean onPreferenceClick(Preference preference) {
                showTorrentBuyDialog();
                return true;
            }
        });
        setTraktPreferencesEnabled(false);
    }

    private void showTorrentBuyDialog() {
        new AlertDialog.Builder(getActivity()).setMessage(R.string.torrent_buy_premium_message).setPositiveButton(R.string.torrent_buy_premium, new DialogInterface.OnClickListener() {

            @Override
            public void onClick(DialogInterface dialog, int which) {
                launchPurchase();
            }
        }).create().show();
    }

    private void setPaidStatus() {
        PreferenceCategory prefCategorty = (PreferenceCategory) findPreference(KEY_TRAKT_CATEGORY);
        prefCategorty.removePreference(mTraktFull);
        getPreferenceScreen().removePreference(mCompleteCategory);
        mTraktSigninPreference.setEnabled(true);
        findPreference(KEY_TORRENT_BLOCKLIST).setOnPreferenceClickListener(null);
        findPreference(KEY_TORRENT_PATH).setOnPreferenceClickListener(null);
        mLastTraktUser = Trakt.getUserFromPreferences(mSharedPreferences);
        if (onTraktUserChange()) {
            Trakt trakt = new Trakt(getActivity());
            trakt.setListener(new Trakt.Listener() {

                @Override
                public void onResult(Trakt.Result result) {
                    mTraktStatus = result.status;
                    mHanlder.post(new Runnable() {

                        @Override
                        public void run() {
                            if (isVisible())
                                onTraktUserChange();
                        }
                    });
                }
            });
        }
    }

    public void videoPreferenceOsClick() {
    // Breaks AndroidTV acceptance: inappropriate content TV-AA rating on opensubreplacedles web site
    // WebUtils.openWebLink(getActivity(), "http://www.opensubreplacedles.org/support");
    }

    public void videoPreferenceTmdbClick() {
    // Breaks AndroidTV acceptance: text is cut on edges
    // WebUtils.openWebLink(getActivity(), "http://www.themoviedb.org/faq/general");
    }

    public void videoPreferenceTvdbClick() {
        WebUtils.openWebLink(getActivity(), "http://thetvdb.com/donate");
    }

    public void videoPreferenceTraktClick() {
        WebUtils.openWebLink(getActivity(), "http://trakt.tv/about");
    }

    @Override
    public void onDestroy() {
        mSharedPreferences.unregisterOnSharedPreferenceChangeListener(this);
        super.onDestroy();
    }

    private void setTraktPreferencesEnabled(boolean enabled) {
        mTraktWipePreference.setEnabled(enabled);
        mTraktLiveScrobblingPreference.setEnabled(enabled);
        mTraktSyncCollectionPreference.setEnabled(enabled);
        mTraktSyncProgressPreference.setEnabled(mTraktLiveScrobblingPreference.isChecked() && mTraktLiveScrobblingPreference.isEnabled());
    }

    @Override
    public void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        if (mTraktSigninPreference != null && mTraktSigninPreference.isDialogShowing()) {
            // close dialog to prevent leaked window
            mTraktSigninPreference.dismissDialog();
            outState.putBoolean(LOGIN_DIALOG, true);
        }
    }

    private boolean onTraktUserChange() {
        final String traktUser = Trakt.getAccessTokenFromPreferences(mSharedPreferences);
        if (traktUser != null) {
            if (mLastTraktUser != null && !traktUser.equals(mLastTraktUser)) {
                Trakt.wipePreferences(mSharedPreferences, true);
                new TraktService.Client(getActivity(), null, false).wipe();
            }
            setTraktPreferencesEnabled(true);
            if (mTraktStatus == Trakt.Status.ERROR_AUTH) {
                mTraktSigninPreference.setSummary(getResources().getString(R.string.trakt_signin_summary_logged_error));
            } else {
                mTraktSigninPreference.setSummary(getResources().getString(R.string.trakt_signin_summary_logged));
                new TraktService.Client(getActivity(), null, false).sync(0);
            }
        } else {
            if (mLastTraktUser != null) {
                Trakt.wipePreferences(PreferenceManager.getDefaultSharedPreferences(getActivity()), false);
                new TraktService.Client(getActivity(), null, false).wipe();
            }
            mTraktSigninPreference.setSummary(R.string.trakt_signin_summary);
            mTraktSyncCollectionPreference.setChecked(TRAKT_SYNC_COLLECTION_DEFAULT);
            mTraktLiveScrobblingPreference.setChecked(TRAKT_LIVE_SCROBBLING_DEFAULT);
            setTraktPreferencesEnabled(false);
        }
        mLastTraktUser = traktUser;
        return traktUser != null;
    }

    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        if (!u.handleActivityResult(requestCode, resultCode, data)) {
            if (requestCode == VideoPreferencesActivity.FOLDER_PICKER_REQUEST_CODE) {
                if (resultCode == Activity.RESULT_OK) {
                    String newPath = data.getStringExtra(FolderPicker.EXTRA_SELECTED_FOLDER);
                    if (newPath != null) {
                        File f = new File(newPath);
                        if ((f != null) && f.isDirectory() && f.exists()) {
                            // better safe than sorry x3
                            PreferenceManager.getDefaultSharedPreferences(getActivity()).edit().putString(VideoPreferencesFragment.KEY_TORRENT_PATH, f.getAbsolutePath()).apply();
                            ((TorrentPathDialogPreference) findPreference(KEY_TORRENT_PATH)).refresh();
                        }
                    }
                }
            }
        }
    }

    @Override
    public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
        if (key.equals(Trakt.KEY_TRAKT_USER) || key.equals(Trakt.KEY_TRAKT_ACCESS_TOKEN) || key.equals(Trakt.KEY_TRAKT_SHA1)) {
            // preference just changed, replacedume it's valid
            mTraktStatus = Trakt.Status.SUCCESS;
            onTraktUserChange();
        } else if (key.equals(KEY_TRAKT_SYNC_COLLECTION)) {
            if (Trakt.isTraktV2Enabled(getActivity(), mSharedPreferences)) {
                Boolean newBoolean = (Boolean) sharedPreferences.getBoolean(KEY_TRAKT_SYNC_COLLECTION, TRAKT_SYNC_COLLECTION_DEFAULT);
                if (newBoolean) {
                    TraktService.sync(getActivity(), TraktService.FLAG_SYNC_MOVIES | TraktService.FLAG_SYNC_SHOWS | TraktService.FLAG_SYNC_TO_DB_COLLECTION | TraktService.FLAG_SYNC_TO_TRAKT_COLLECTION);
                } else {
                    new TraktService.Client(getActivity(), null, false).wipeCollection();
                }
            }
        }
    }

    /*

        preference helper
     */
    public static clreplaced PreferenceHelper {

        public static boolean shouldDisplayAllFiles(Context context) {
            return PreferenceManager.getDefaultSharedPreferences(context).getBoolean(KEY_DISPLAY_ALL_FILE, false);
        }
    }
}

19 Source : Preferences.java
with Apache License 2.0
from alescdb

private void bindSummary(String key, final int resId) {
    final ListPreference p = (ListPreference) findPreference(key);
    setPreferenceSummaryValue(p, resId, p.getValue());
    p.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {

        @Override
        public boolean onPreferenceChange(Preference preference, Object newValue) {
            setPreferenceSummaryValue(p, resId, (String) newValue);
            return true;
        }
    });
}

19 Source : Preferences.java
with Apache License 2.0
from alescdb

private void setPreferenceSummaryValue(ListPreference prefs, int resId, String value) {
    prefs.setSummary(String.format(Locale.getDefault(), getString(resId), value));
}

See More Examples