Java 类android.preference.PreferenceScreen 实例源码

@Override
public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) {
    if (preference == mPowerSoundsVibrate) {
        CMSettings.Global.putInt(getContentResolver(),
                CMSettings.Global.POWER_NOTIFICATIONS_VIBRATE,
                mPowerSoundsVibrate.isChecked() ? 1 : 0);

    } else if (preference == mPowerSoundsRingtone) {
        launchNotificationSoundPicker(REQUEST_CODE_POWER_NOTIFICATIONS_RINGTONE,
                CMSettings.Global.getString(getContentResolver(),
                        CMSettings.Global.POWER_NOTIFICATIONS_RINGTONE));
    } else {
        // If we didn't handle it, let preferences handle it.
        return super.onPreferenceTreeClick(preferenceScreen, preference);
    }

    return true;
}

@Override
protected void onPreExecute() {
    autoExpandFolder = (ListPreference) findPreference(PREFERENCE_AUTO_EXPAND_FOLDER);
    autoExpandFolder.setEnabled(false);
    archiveFolder = (ListPreference) findPreference(PREFERENCE_ARCHIVE_FOLDER);
    archiveFolder.setEnabled(false);
    draftsFolder = (ListPreference) findPreference(PREFERENCE_DRAFTS_FOLDER);
    draftsFolder.setEnabled(false);
    sentFolder = (ListPreference) findPreference(PREFERENCE_SENT_FOLDER);
    sentFolder.setEnabled(false);
    spamFolder = (ListPreference) findPreference(PREFERENCE_SPAM_FOLDER);
    spamFolder.setEnabled(false);
    trashFolder = (ListPreference) findPreference(PREFERENCE_TRASH_FOLDER);
    trashFolder.setEnabled(false);

    if (!isMoveCapable) {
        PreferenceScreen foldersCategory =
                (PreferenceScreen) findPreference(PREFERENCE_CATEGORY_FOLDERS);
        foldersCategory.removePreference(archiveFolder);
        foldersCategory.removePreference(spamFolder);
        foldersCategory.removePreference(draftsFolder);
        foldersCategory.removePreference(sentFolder);
        foldersCategory.removePreference(trashFolder);
    }
}

@Override
public void onActivityCreated(Bundle savedInstanceState) {
    super.onActivityCreated(savedInstanceState);

    if (mHavePrefs) {
        bindPreferences();
    }

    mInitDone = true;

    if (savedInstanceState != null) {
        Bundle container = savedInstanceState.getBundle(PREFERENCES_TAG);
        if (container != null) {
            final PreferenceScreen preferenceScreen = getPreferenceScreen();
            if (preferenceScreen != null) {
                preferenceScreen.restoreHierarchyState(container);
            }
        }
    }
}

@Override
public void onCreate(final Bundle icicle) {
    super.onCreate(icicle);
    addPreferencesFromResource(R.xml.prefs_screen_theme);
    final PreferenceScreen screen = getPreferenceScreen();
    final Context context = getActivity();
    final Resources res = getResources();
    final String[] keyboardThemeNames = res.getStringArray(R.array.keyboard_theme_names);
    final int[] keyboardThemeIds = res.getIntArray(R.array.keyboard_theme_ids);
    for (int index = 0; index < keyboardThemeNames.length; index++) {
        final KeyboardThemePreference pref = new KeyboardThemePreference(
                context, keyboardThemeNames[index], keyboardThemeIds[index]);
        screen.addPreference(pref);
        pref.setOnRadioButtonClickedListener(this);
    }
    final KeyboardTheme keyboardTheme = KeyboardTheme.getKeyboardTheme(context);
    mSelectedThemeId = keyboardTheme.mThemeId;
}

@Override
public void onActivityCreated(Bundle savedInstanceState) {
    super.onActivityCreated(savedInstanceState);

    if (mHavePrefs) {
        bindPreferences();
    }

    mInitDone = true;

    if (savedInstanceState != null) {
        Bundle container = savedInstanceState.getBundle(PREFERENCES_TAG);
        if (container != null) {
            final PreferenceScreen preferenceScreen = getPreferenceScreen();
            if (preferenceScreen != null) {
                preferenceScreen.restoreHierarchyState(container);
            }
        }
    }
}

@Override
public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen,
                                     Preference preference)
{
    boolean result =
        super.onPreferenceTreeClick(preferenceScreen, preference);

    // Set home as up
    if (preference instanceof PreferenceScreen)
    {
        Dialog dialog = ((PreferenceScreen)preference).getDialog();
        ActionBar actionBar = dialog.getActionBar();
        actionBar.setDisplayHomeAsUpEnabled(false);
    }

    return result;
}

/**
 * Initialize internal states of this object.
 *
 * @param context    the context for this application.
 * @param prefScreen a PreferenceScreen of PreferenceActivity or PreferenceFragment.
 * @return true if this application is an IME and has two or more subtypes, false otherwise.
 */
public boolean init(final Context context, final PreferenceScreen prefScreen) {
    mImm = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
    mImi = getMyImi(context, mImm);
    if (mImi == null || mImi.getSubtypeCount() <= 1) {
        return false;
    }
    final Intent intent = new Intent(Settings.ACTION_INPUT_METHOD_SUBTYPE_SETTINGS);
    intent.putExtra(Settings.EXTRA_INPUT_METHOD_ID, mImi.getId());
    intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK
            | Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED
            | Intent.FLAG_ACTIVITY_CLEAR_TOP);
    mSubtypeEnablerPreference = new Preference(context);
    mSubtypeEnablerPreference.setIntent(intent);
    prefScreen.addPreference(mSubtypeEnablerPreference);
    updateSubtypeEnabler();
    return true;
}

/**
 * Gets the list of preferences in a PreferenceScreen
 *
 * @param p    preference to add to the list
 * @param list of preferences in the PreferenceScreen
 * @return a list of all the preferences
 */
private ArrayList<Preference> getPreferenceList(Preference p, ArrayList<Preference> list) {
    if (p instanceof PreferenceCategory || p instanceof PreferenceScreen) {
        PreferenceGroup prefGroup = (PreferenceGroup) p;

        final int prefCount = prefGroup.getPreferenceCount();

        for (int i = 0; i < prefCount; i++) {
            getPreferenceList(prefGroup.getPreference(i), list);
        }
    }

    if (!(p instanceof PreferenceCategory)) {
        list.add(p);
    }

    return list;
}

@Override
public void onCreate(final Bundle icicle) {
    super.onCreate(icicle);
    addPreferencesFromResource(R.xml.prefs_screen_theme);
    final PreferenceScreen screen = getPreferenceScreen();
    final Context context = getActivity();
    final Resources res = getResources();
    final String[] keyboardThemeNames = res.getStringArray(R.array.keyboard_theme_names);
    final int[] keyboardThemeIds = res.getIntArray(R.array.keyboard_theme_ids);
    for (int index = 0; index < keyboardThemeNames.length; index++) {
        final KeyboardThemePreference pref = new KeyboardThemePreference(
                context, keyboardThemeNames[index], keyboardThemeIds[index]);
        screen.addPreference(pref);
        pref.setOnRadioButtonClickedListener(this);
    }
    final KeyboardTheme keyboardTheme = KeyboardTheme.getKeyboardTheme(context);
    mSelectedThemeId = keyboardTheme.mThemeId;
}

private void setKeys(PreferenceScreen screen)
{
    for(int i = 0; i < screen.getPreferenceCount(); i++)
    {
        Preference preference = screen.getPreference(i);
        String key = server + ";" + preference.getKey();
        preference.setKey(key);
        if(preference instanceof EditIntPreference)
            ((EditIntPreference)preference).setInt(preference.getSharedPreferences().getInt(key, -1));
        else if(preference instanceof EditTextPreference)
            ((EditTextPreference)preference).setText(preference.getSharedPreferences().getString(key, null));
        else if(preference instanceof ListPreference)
            ((ListPreference)preference).setValue(preference.getSharedPreferences().getString(key, null));
        else if(preference instanceof CheckBoxPreference)
            ((CheckBoxPreference)preference).setChecked(preference.getSharedPreferences().getBoolean(key, false));
        if(preference instanceof PreferenceScreen)
            setKeys((PreferenceScreen)preference);
    }
}

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    addPreferencesFromResource(R.xml.pref_wireless_socket);
    setHasOptionsMenu(true);

    PreferenceScreen preferenceScreen = this.getPreferenceScreen();

    PreferenceCategory preferenceCategory = new PreferenceCategory(preferenceScreen.getContext());
    preferenceCategory.setTitle("Wireless sockets");
    preferenceScreen.addPreference(preferenceCategory);

    for (int index = 0; index < WirelessSocketService.getInstance().GetDataList().getSize(); index++) {
        WirelessSocket wirelessSocket = WirelessSocketService.getInstance().GetDataList().getValue(index);

        SwitchPreference preference = new SwitchPreference(preferenceScreen.getContext());

        preference.setTitle(wirelessSocket.GetName());
        preference.setKey(wirelessSocket.GetSettingsKey());
        preference.setDefaultValue(false);

        preferenceCategory.addPreference(preference);

        bindPreferenceSummaryToValue(preference);
    }
}

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    addPreferencesFromResource(R.xml.pref_wireless_switch);
    setHasOptionsMenu(true);

    PreferenceScreen preferenceScreen = this.getPreferenceScreen();

    PreferenceCategory preferenceCategory = new PreferenceCategory(preferenceScreen.getContext());
    preferenceCategory.setTitle("Wireless switches");
    preferenceScreen.addPreference(preferenceCategory);

    for (int index = 0; index < WirelessSwitchService.getInstance().GetDataList().getSize(); index++) {
        WirelessSwitch wirelessSwitch = WirelessSwitchService.getInstance().GetDataList().getValue(index);

        SwitchPreference preference = new SwitchPreference(preferenceScreen.getContext());

        preference.setTitle(wirelessSwitch.GetName());
        preference.setKey(wirelessSwitch.GetSettingsKey());
        preference.setDefaultValue(false);

        preferenceCategory.addPreference(preference);

        bindPreferenceSummaryToValue(preference);
    }
}

@Override
public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) {
    final String key = preference.getKey();
    switch (key) {
        case KEY_CHECK_UPDATE:
            mTask = CheckUpdateTask.getInstance(false);
            if (!mTask.getStatus().equals(AsyncTask.Status.RUNNING)) {
                mTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, getActivity());
            }
            return true;
        case KEY_CHANGELOG:
            ChangelogFragment changelogFrag = new ChangelogFragment();
            FragmentTransaction transaction = getFragmentManager().beginTransaction();
            transaction.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE);
            transaction.replace(this.getId(), changelogFrag);
            transaction.addToBackStack(this.getClass().getName());
            transaction.commit();
            return true;
        default:
            OTALink link = LinkConfig.getInstance().findLink(key, getActivity());
            if (link != null) {
                OTAUtils.launchUrl(link.getUrl(), getActivity());
            }
            break;
    }
    return super.onPreferenceTreeClick(preferenceScreen, preference);
}

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setRetainInstance(true);

    addPreferencesFromResource(R.xml.ota);

    mRomInfo = (PreferenceScreen) getPreferenceScreen().findPreference(KEY_ROM_INFO);
    mCheckUpdate = (PreferenceScreen) getPreferenceScreen().findPreference(KEY_CHECK_UPDATE);

    mUpdateInterval = (ListPreference) getPreferenceScreen().findPreference(KEY_UPDATE_INTERVAL);
    if (mUpdateInterval != null) {
        mUpdateInterval.setOnPreferenceChangeListener(this);
    }

    mLinksCategory = (PreferenceCategory) getPreferenceScreen().findPreference(CATEGORY_LINKS);
}

private void updateLinks(boolean force) {
    List<OTALink> links = LinkConfig.getInstance().getLinks(getActivity(), force);
    for (OTALink link : links) {
        String id = link.getId();
        PreferenceScreen linkPref = (PreferenceScreen) getPreferenceScreen().findPreference(id);
        if (linkPref == null && mLinksCategory != null) {
            linkPref = getPreferenceManager().createPreferenceScreen(getActivity());
            linkPref.setKey(id);
            mLinksCategory.addPreference(linkPref);
        }
        if (linkPref != null) {
            String title = link.getTitle();
            linkPref.setTitle(title.isEmpty() ? id : title);
            linkPref.setSummary(link.getDescription());
        }
    }
}

private void resetList() {
    getPreferenceScreen().removeAll();
    addPreferencesFromResource(R.xml.usb_device_preferences);

    PreferenceScreen preferenceScreen = getPreferenceScreen();
    Preference header = preferenceScreen.findPreference(PREF_OBJECT_NAME);
    header.setTitle(mUsbInfo.getName());
    header.setOnPreferenceClickListener(this);

    for (int i = 0; i < mSites.size(); ++i) {
        Website site = mSites.get(i);
        Preference preference = new WebsitePreference(getActivity(), site, mCategory);
        preference.getExtras().putSerializable(SingleWebsitePreferences.EXTRA_SITE, site);
        preference.setFragment(SingleWebsitePreferences.class.getCanonicalName());
        preferenceScreen.addPreference(preference);
    }

    // Force this list to be reloaded if the activity is resumed.
    mSites = null;
}

private void clearStoredData() {
    mSite.clearAllStoredData(
            new Website.StoredDataClearedCallback() {
                @Override
                public void onStoredDataCleared() {
                    PreferenceScreen preferenceScreen = getPreferenceScreen();
                    preferenceScreen.removePreference(
                            preferenceScreen.findPreference(PREF_CLEAR_DATA));
                    if (!hasUsagePreferences()) {
                        preferenceScreen.removePreference(
                                preferenceScreen.findPreference(PREF_USAGE));
                    }
                    popBackIfNoSettings();
                }
            });
}

@Override
public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen,
        Preference preference)
{
    Log.v(L.TAG, "onPreferenceTreeClick() for key " + preference.getKey());

    if("backupDb".equals(preference.getKey()))        
    {
        // TODO dialog: This will backup you current SimplyDo database. You
        // can access and manage these backups through mass storage 
        // access to you device. Make backup now to the file ....
        backupDbSelected();
    }
    else if("restoreDb".equals(preference.getKey()))        
    {
        Intent restoreActivity = new Intent(getBaseContext(), RestoreActivity.class);
        startActivity(restoreActivity);

    }

    // the android docs give no clues as to what the returned bool does
    return super.onPreferenceTreeClick(preferenceScreen, preference);
}

private void updateNumberOfPacketsSummary() {
    final PreferenceScreen screen = getPreferenceScreen();
    final SharedPreferences preferences = getPreferenceManager().getSharedPreferences();

       String value = preferences.getString(SETTINGS_NUMBER_OF_PACKETS, String.valueOf(SETTINGS_NUMBER_OF_PACKETS_DEFAULT));
       // Security check
       if (TextUtils.isEmpty(value)) {
           value = String.valueOf(SETTINGS_NUMBER_OF_PACKETS_DEFAULT);
           preferences.edit().putString(SETTINGS_NUMBER_OF_PACKETS, value).apply();
       }
       screen.findPreference(SETTINGS_NUMBER_OF_PACKETS).setSummary(value);

    final int valueInt = Integer.parseInt(value);
    if (valueInt > 200) {
        new AlertDialog.Builder(getActivity()).setMessage(R.string.dfu_settings_dfu_number_of_packets_info).setTitle(R.string.dfu_settings_dfu_information)
                .setPositiveButton(R.string.ok, null)
                .show();
    }
}

@Override
public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) {
    Runnable action = ACTION_MAP.get(preference.getTitle().toString());
    if (action != null) {
        action.run();
        return true;
    } else {
        return super.onPreferenceTreeClick(preferenceScreen, preference);
    }
}

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

    PreferenceScreen prefSet = getPreferenceScreen();

    PreferenceGroup mGeneralPrefs = (PreferenceGroup) prefSet.findPreference("general_section");

    mLightEnabledPref = (CMSystemSettingSwitchPreference) prefSet.findPreference(LIGHT_ENABLED_PREF);
    mPulseEnabledPref = (CMSystemSettingSwitchPreference) prefSet.findPreference(PULSE_ENABLED_PREF);

    if (!getResources().getBoolean(com.android.internal.R.bool.config_ledCanPulse) ||
            getResources().getBoolean(org.cyanogenmod.platform.internal.R.bool.config_useSegmentedBatteryLed)) {
        mGeneralPrefs.removePreference(mPulseEnabledPref);
    }

    // Does the Device support changing battery LED colors?
    if (getResources().getBoolean(com.android.internal.R.bool.config_multiColorBatteryLed)) {
        setHasOptionsMenu(true);

        // Low, Medium and full color preferences
        mLowColorPref = (ApplicationLightPreference) prefSet.findPreference(LOW_COLOR_PREF);
        mLowColorPref.setOnPreferenceChangeListener(this);

        mMediumColorPref = (ApplicationLightPreference) prefSet.findPreference(MEDIUM_COLOR_PREF);
        mMediumColorPref.setOnPreferenceChangeListener(this);

        mFullColorPref = (ApplicationLightPreference) prefSet.findPreference(FULL_COLOR_PREF);
        mFullColorPref.setOnPreferenceChangeListener(this);
    } else {
        prefSet.removePreference(prefSet.findPreference("colors_list"));
        resetColors();
    }
}

@Override
protected void onCreateInternal() {
    addPreferencesFromResource(R.xml.zen_mode_external_rule_settings);
    final PreferenceScreen root = getPreferenceScreen();
    final ServiceInfo si = ServiceListing.findService(mContext,
            ZenModeAutomationSettings.CONFIG, mRule.component);
    if (DEBUG) Log.d(TAG, "ServiceInfo: " + si);
    final RuleInfo ri = getRuleInfo(si);
    if (DEBUG) Log.d(TAG, "RuleInfo: " + ri);
    mType = root.findPreference(KEY_TYPE);
    if (ri == null) {
        mType.setSummary(R.string.zen_mode_rule_type_unknown);
    } else {
        mType.setSummary(ri.caption);
    }

    mConfigure = root.findPreference(KEY_CONFIGURE);
    if (ri == null || ri.configurationActivity == null) {
        mConfigure.setEnabled(false);
    } else {
        mConfigure.setOnPreferenceClickListener(new OnPreferenceClickListener() {
            @Override
            public boolean onPreferenceClick(Preference preference) {
                startActivityForResult(new Intent().setComponent(ri.configurationActivity),
                        REQUEST_CODE_CONFIGURE);
                return true;
            }
        });
    }
}

@Override
public void onCreate(Bundle icicle) {
    super.onCreate(icicle);

    mContext = getActivity();

    final Intent intent = getActivity().getIntent();
    if (DEBUG) Log.d(TAG, "onCreate getIntent()=" + intent);
    if (intent == null) {
        Log.w(TAG, "No intent");
        toastAndFinish();
        return;
    }

    mRuleId = intent.getStringExtra(EXTRA_RULE_ID);
    if (DEBUG) Log.d(TAG, "mRuleId=" + mRuleId);
    if (refreshRuleOrFinish()) {
        return;
    }

    setHasOptionsMenu(true);

    onCreateInternal();

    final PreferenceScreen root = getPreferenceScreen();
    mRuleName = root.findPreference(KEY_RULE_NAME);
    mRuleName.setOnPreferenceClickListener(new OnPreferenceClickListener() {
        @Override
        public boolean onPreferenceClick(Preference preference) {
            showRuleNameDialog();
            return true;
        }
    });

    mZenMode = (DropDownPreference) root.findPreference(KEY_ZEN_MODE);
    mZenMode.addItem(R.string.zen_mode_option_important_interruptions,
            Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS);
    mZenMode.addItem(R.string.zen_mode_option_alarms, Global.ZEN_MODE_ALARMS);
    mZenMode.addItem(R.string.zen_mode_option_no_interruptions,
            Global.ZEN_MODE_NO_INTERRUPTIONS);
    mZenMode.setCallback(new DropDownPreference.Callback() {
        @Override
        public boolean onItemSelected(int pos, Object value) {
            if (mDisableListeners) return true;
            final int zenMode = (Integer) value;
            if (zenMode == mRule.zenMode) return true;
            if (DEBUG) Log.d(TAG, "onPrefChange zenMode=" + zenMode);
            mRule.zenMode = zenMode;
            setZenModeConfig(mConfig);
            return true;
        }
    });
    mZenMode.setOrder(10);  // sort at the bottom of the category
    mZenMode.setDependency(getZenModeDependency());
}

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    addPreferencesFromResource(R.xml.zen_mode_settings);
    final PreferenceScreen root = getPreferenceScreen();

    mPrioritySettings = root.findPreference(KEY_PRIORITY_SETTINGS);
    if (!isScheduleSupported(mContext)) {
        removePreference(KEY_AUTOMATION_SETTINGS);
    }

    mZenAccess = findPreference(KEY_ZEN_ACCESS);
    refreshZenAccess();
}

private void initSummaries(PreferenceGroup pg) {
    for (int i = 0; i < pg.getPreferenceCount(); ++i) {
        Preference p = pg.getPreference(i);
        if (p instanceof PreferenceGroup)
            initSummaries((PreferenceGroup) p);
        else
            setSummary(p, false);
        if (p instanceof PreferenceScreen)
            p.setOnPreferenceClickListener(this);
    }
}

private void emptyAndHidePreference(int preferenceKey) {
    Preference preference = findPreference(getString(preferenceKey));
    if (preference instanceof PreferenceCategory)
        emptyAndHidePreferenceCategory(preferenceKey);
    else if (preference instanceof PreferenceScreen)
        emptyAndHidePreferenceScreen(preferenceKey);
}

private void emptyAndHidePreferenceScreen(int preferenceKey) {
    Preference preference = findPreference(getString(preferenceKey));
    if (!(preference instanceof PreferenceScreen))
        return;

    PreferenceScreen preferenceScreen = (PreferenceScreen) preference;
    preferenceScreen.removeAll();
    hidePreference(preferenceScreen);
}

/**
 * Gets the root of the preference hierarchy that this activity is showing.
 * 
 * @return The {@link PreferenceScreen} that is the root of the preference
 *         hierarchy.
 */
public PreferenceScreen getPreferenceScreen() {
    try {
        Method m = PreferenceManager.class.getDeclaredMethod("getPreferenceScreen");
        m.setAccessible(true);
        return (PreferenceScreen) m.invoke(mPreferenceManager);
    } catch(Exception e) {
        Log.e("[PreferencesListFragment] getPreferenceScreen " + e);
    }

    return null;
}

/**
 * Inflates the given XML resource and adds the preference hierarchy to the current
 * preference hierarchy.
 * 
 * @param preferencesResId The XML resource ID to inflate.
 */
public void addPreferencesFromResource(int preferencesResId) {   
    try {
        Method m = PreferenceManager.class.getDeclaredMethod("inflateFromResource", Context.class, int.class, PreferenceScreen.class);
        m.setAccessible(true);
        PreferenceScreen prefScreen = (PreferenceScreen) m.invoke(mPreferenceManager, getActivity(), preferencesResId, getPreferenceScreen());
        setPreferenceScreen(prefScreen);
    } catch(Exception e) {
        Log.e("[PreferencesListFragment] addPreferencesFromResource " + e);
    }
}

public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    PreferenceScreen screen = getPreferenceScreen();
    n = getArguments().getInt("Account", 0);
    if(n == mPrefs.getAccountCount()) {
        isNewAccount = true;
        builder = new AccountBuilder(LinphoneManager.getLc());
    }
    initAccountPreferencesFields(screen);

    // Force hide keyboard
    getActivity().getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
}

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    addPreferencesFromResource(R.xml.pref_infos);
    setHasOptionsMenu(true);

    findPreference("version").setSummary(getString(R.string.version, BuildConfig.VERSION_NAME, BuildConfig.VERSION_CODE));

    PreferenceScreen prefScreen = getPreferenceScreen();
    for (int i = 0; i < prefScreen.getPreferenceCount(); i++) {
        Preference pref = prefScreen.getPreference(i);
        if (!BuildConfig.DEBUG && pref.getKey().startsWith("debug_"))
            prefScreen.removePreference(pref);
    }

    if (BuildConfig.DEBUG) {
        findPreference("debug_send_notification").setSummary("Package name: " + BuildConfig.APPLICATION_ID);
        findPreference("debug_send_notification").setOnPreferenceClickListener(new Preference.OnPreferenceClickListener() {
            @Override
            public boolean onPreferenceClick(Preference preference) {
                ((NotificationManager) getActivity().getSystemService(Context.NOTIFICATION_SERVICE)).notify(0,
                        new NotificationCompat.Builder(getActivity())
                                .setSmallIcon(R.drawable.info)
                                .setContentTitle("Test Notification")
                                .setContentText("Use " + BuildConfig.APPLICATION_ID + " as the package name to test your actions")
                                .build());
                return true;
            }
        });
    }
}

@Override
  public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference)
  {
SharedPreferences sp = preference.getSharedPreferences();
boolean ON_OFF = sp.getBoolean("auto_send_message", false);
boolean next_screen = sp.getBoolean("next_screen_checkbox_preference", false);
String text = sp.getString("auto_send_message_text", "");
String listtext = sp.getString("auto_send_message_frequency", "");
return true;
  }

@Override
   public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference)
   {
SharedPreferences sp = preference.getSharedPreferences();
boolean ON_OFF = sp.getBoolean("auto_send_message", false);
boolean next_screen = sp.getBoolean("next_screen_checkbox_preference", false);
String text = sp.getString("auto_send_message_text", "");
String listtext = sp.getString("auto_send_message_frequency", "");
return true;
   }

private void updateWheelSizeSummary() {
    final PreferenceScreen screen = getPreferenceScreen();
    final SharedPreferences preferences = getPreferenceManager().getSharedPreferences();

    final String value = preferences.getString(SETTINGS_WHEEL_SIZE, String.valueOf(SETTINGS_WHEEL_SIZE_DEFAULT));
    screen.findPreference(SETTINGS_WHEEL_SIZE).setSummary(getString(R.string.csc_settings_wheel_diameter_summary, value));
}

@Override
public void onSaveInstanceState(Bundle outState) {
    super.onSaveInstanceState(outState);

    final PreferenceScreen preferenceScreen = getPreferenceScreen();
    if (preferenceScreen != null) {
        Bundle container = new Bundle();
        preferenceScreen.saveHierarchyState(container);
        outState.putBundle(PREFERENCES_TAG, container);
    }
}

/**
 * Sets the root of the preference hierarchy that this fragment is showing.
 *
 * @param preferenceScreen The root {@link PreferenceScreen} of the preference hierarchy.
 */
public void setPreferenceScreen(PreferenceScreen preferenceScreen) {
    if (PreferenceManagerCompat.setPreferences(mPreferenceManager, preferenceScreen) && preferenceScreen != null) {
        mHavePrefs = true;
        if (mInitDone) {
            postBindPreferences();
        }
    }
}

/**
 * {@inheritDoc}
 */
public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen,
        Preference preference) {
    //if (preference.getFragment() != null &&
    if (
            getActivity() instanceof OnPreferenceStartFragmentCallback) {
        return ((OnPreferenceStartFragmentCallback)getActivity()).onPreferenceStartFragment(
                this, preference);
    }
    return false;
}

static void setPreferenceEnabled(final String prefKey, final boolean enabled,
        final PreferenceScreen screen) {
    final Preference preference = screen.findPreference(prefKey);
    if (preference != null) {
        preference.setEnabled(enabled);
    }
}

@Override
public void onSaveInstanceState(@NonNull Bundle outState) {
    super.onSaveInstanceState(outState);

    final PreferenceScreen preferenceScreen = getPreferenceScreen();
    if (preferenceScreen != null) {
        Bundle container = new Bundle();
        preferenceScreen.saveHierarchyState(container);
        outState.putBundle(PREFERENCES_TAG, container);
    }
}

/**
 * Sets the root of the preference hierarchy that this fragment is showing.
 *
 * @param preferenceScreen The root {@link android.preference.PreferenceScreen} of the preference hierarchy.
 */
public void setPreferenceScreen(PreferenceScreen preferenceScreen) {
    if (PreferenceManagerCompat.setPreferences(mPreferenceManager, preferenceScreen) && preferenceScreen != null) {
        mHavePrefs = true;
        if (mInitDone) {
            postBindPreferences();
        }
    }
}