Java Code Examples for android.preference.PreferenceGroup#getPreferenceCount()

private WordListPreference findWordListPreference(final String id) {
    final PreferenceGroup prefScreen = getPreferenceScreen();
    if (null == prefScreen) {
        Log.e(TAG, "Could not find the preference group");
        return null;
    }
    for (int i = prefScreen.getPreferenceCount() - 1; i >= 0; --i) {
        final Preference pref = prefScreen.getPreference(i);
        if (pref instanceof WordListPreference) {
            final WordListPreference wlPref = (WordListPreference)pref;
            if (id.equals(wlPref.mWordlistId)) {
                return wlPref;
            }
        }
    }
    Log.e(TAG, "Could not find the preference for a word list id " + id);
    return null;
}
 

private static void replaceAllCheckBoxPreferencesBySwitchPreferences(
        final PreferenceGroup group) {
    final ArrayList<Preference> preferences = new ArrayList<>();
    final int count = group.getPreferenceCount();
    for (int index = 0; index < count; index++) {
        preferences.add(group.getPreference(index));
    }
    group.removeAll();
    for (int index = 0; index < count; index++) {
        final Preference preference = preferences.get(index);
        if (preference instanceof CheckBoxPreference) {
            addSwitchPreferenceBasedOnCheckBoxPreference((CheckBoxPreference)preference, group);
        } else {
            group.addPreference(preference);
            if (preference instanceof PreferenceGroup) {
                replaceAllCheckBoxPreferencesBySwitchPreferences((PreferenceGroup)preference);
            }
        }
    }
}
 

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

    for (int i = 0; i < getPreferenceScreen().getPreferenceCount(); ++i) {
        Preference preference = getPreferenceScreen().getPreference(i);
        if (preference instanceof PreferenceGroup) {
            PreferenceGroup preferenceGroup = (PreferenceGroup) preference;
            for (int j = 0; j < preferenceGroup.getPreferenceCount(); ++j) {
                updatePreference(preferenceGroup.getPreference(j));
            }
        } else {
            updatePreference(preference);
        }
    }
}
 

@Override
public void onResume() {
    super.onResume();
    PreferenceScreen preferenceScreen = getPreferenceScreen();
    for (int i = 0; i < preferenceScreen.getPreferenceCount(); i++) {
        Preference preference = preferenceScreen.getPreference(i);
        if (preference instanceof PreferenceGroup) {
            PreferenceGroup preferenceGroup = (PreferenceGroup) preference;
            for (int j = 0; j < preferenceGroup.getPreferenceCount(); j++) {
                Preference subPref = preferenceGroup.getPreference(j);
                updatePreference(subPref, subPref.getKey());
            }
        } else {
            updatePreference(preference, preference.getKey());
        }
    }
}
 

private static void replaceAllCheckBoxPreferencesBySwitchPreferences(
        final PreferenceGroup group) {
    final ArrayList<Preference> preferences = new ArrayList<>();
    final int count = group.getPreferenceCount();
    for (int index = 0; index < count; index++) {
        preferences.add(group.getPreference(index));
    }
    group.removeAll();
    for (int index = 0; index < count; index++) {
        final Preference preference = preferences.get(index);
        if (preference instanceof CheckBoxPreference) {
            addSwitchPreferenceBasedOnCheckBoxPreference((CheckBoxPreference)preference, group);
        } else {
            group.addPreference(preference);
            if (preference instanceof PreferenceGroup) {
                replaceAllCheckBoxPreferencesBySwitchPreferences((PreferenceGroup)preference);
            }
        }
    }
}
 

private void initGatewayEditTextPreference(Preference preference) {
    if (preference instanceof PreferenceGroup) {
        PreferenceGroup preferenceGroup = (PreferenceGroup) preference;
        for (int i=0; i<preferenceGroup.getPreferenceCount(); i++) {
            if (preferenceGroup.getPreference(i).getTitle().equals("Gateway")) {
                PreferenceCategory preferenceCategory = (PreferenceCategory) preferenceGroup.getPreference(i);
                initGatewayEditTextPreference(preferenceCategory.getPreference(0));
            } else {
                initGatewayEditTextPreference(preferenceGroup.getPreference(i));
            }
        }
    } else if (preference instanceof EditTextPreference) {
        // TODO wrong ClassCastException ?!?!
        gatewayEditTextPreference = (GatewayEditTextPreference) preference;
    }
}
 

/**
 * Recursively traverses the tree from the given group as the route and
 * tries to delete the preference. Traversal stops once the preference
 * was found and removed.
 */
private boolean recursiveDelete(PreferenceGroup group, Preference preference)
{
    if (group == null)
    {
        Log.d(TAG, "attempting to delete from null preference group");
        return false;
    }
    if (preference == null)
    {
        Log.d(TAG, "attempting to delete null preference");
        return false;
    }
    if (group.removePreference(preference))
    {
        // Removal was successful.
        return true;
    }

    for (int i = 0; i < group.getPreferenceCount(); ++i)
    {
        Preference pref = group.getPreference(i);
        if (pref instanceof PreferenceGroup)
        {
            if (recursiveDelete((PreferenceGroup) pref, preference))
            {
                return true;
            }
        }
    }
    return false;
}
 

private List<Preference> getPreferenceList(Preference p, ArrayList<Preference> list) {
    if( p instanceof PreferenceCategory || p instanceof PreferenceScreen) {
        PreferenceGroup pGroup = (PreferenceGroup) p;
        int pCount = pGroup.getPreferenceCount();
        for(int i = 0; i < pCount; i++) {
            getPreferenceList(pGroup.getPreference(i), list); // recursive call
        }
    } else if (p != null) {
        list.add(p);
    }
    return list;
}
 

private void bindPreferencesSummaryToValue(PreferenceGroup group) {
    int prefCount = group.getPreferenceCount();
    for(int c = 0; c < prefCount; c++) {
        Preference preference = group.getPreference(c);
        if(preference instanceof PreferenceGroup) {
            bindPreferencesSummaryToValue((PreferenceGroup)preference);
        } else {
            bindPreferenceSummaryToValue(preference);
        }
    }
}
 

private ArrayList<Preference> getAllPreferenceScreen(Preference p, ArrayList<Preference> list) {
    if( p instanceof PreferenceCategory || p instanceof PreferenceScreen) {
        PreferenceGroup pGroup = (PreferenceGroup) p;
        int pCount = pGroup.getPreferenceCount();
        if(p instanceof PreferenceScreen){
            list.add(p);
        }
        for(int i = 0; i < pCount; i++) {
            getAllPreferenceScreen(pGroup.getPreference(i), list);
        }
    }
    return list;
}
 

private static void dependBindPreference(PreferenceGroup pg) {
        int count = pg.getPreferenceCount();
        Preference preference;
        String key;
        Object value;

        Pref pref = Pref.getInstance(pg.getContext());

        for(int i = 0; i < count; i++) {
            preference = pg.getPreference(i);
            key = preference.getKey();

            if(preference instanceof PreferenceGroup) {
                dependBindPreference((PreferenceGroup) preference);
                continue;
            }

            Class<? extends Preference> cls = preference.getClass();
            if(cls.equals(Preference.class))
                continue;

            value = pref.getValue(key);

            if(preference instanceof JecListPreference) {
//                if("pref_font_size".equals(key)) {
//                    new FontSizePreference((JecListPreference)preference);
//                } else if("pref_cursor_width".equals(key)) {
//                    new CursorWidthPreference((JecListPreference)preference);
//                }
            } else if(preference instanceof EditTextPreference) {
                ((EditTextPreference)preference).setText(String.valueOf(value));
            } else if(preference instanceof CheckBoxPreference) {
                ((CheckBoxPreference)preference).setChecked((boolean)value);
            }

            if (!Pref.KEY_SYMBOL.equals(key))
                bindPreferenceSummaryToValue(preference);
        }
    }
 

/**
 * Adds a generic {@link android.preference.Preference.OnPreferenceChangeListener} to update the preferences with {@link Pref}.
 * It does that recursively for every Preference contained in the supplied {@link PreferenceGroup}.
 * This is what you get, when customizing too much stuff.
 *
 * @param preferenceGroup the current {@link PreferenceGroup}
 */
private static void addOnPreferenceChangeListeners(PreferenceGroup preferenceGroup) {
    for (int i = 0; i < preferenceGroup.getPreferenceCount(); i++) {
        Preference p = preferenceGroup.getPreference(i);
        if (p instanceof PreferenceCategory) {
            addOnPreferenceChangeListeners((PreferenceCategory) p);
        } else {
            setOnPreferenceChangeListener(p);
        }
    }
}
 

private InputMethodSubtype[] getSubtypes() {
    final PreferenceGroup group = getPreferenceScreen();
    final ArrayList<InputMethodSubtype> subtypes = new ArrayList<>();
    final int count = group.getPreferenceCount();
    for (int i = 0; i < count; i++) {
        final Preference pref = group.getPreference(i);
        if (pref instanceof CustomInputStylePreference) {
            final CustomInputStylePreference subtypePref = (CustomInputStylePreference)pref;
            // We should not save newly adding subtype to preference because it is incomplete.
            if (subtypePref.isIncomplete()) continue;
            subtypes.add(subtypePref.getSubtype());
        }
    }
    return subtypes.toArray(new InputMethodSubtype[subtypes.size()]);
}
 

/**
 * Recursively go through settings and fill entries and summaries of our
 * preferences.
 */
private void fillEntriesAndSummaries(PreferenceGroup group)
{
    for (int i = 0; i < group.getPreferenceCount(); ++i)
    {
        Preference pref = group.getPreference(i);
        if (pref instanceof PreferenceGroup)
        {
            fillEntriesAndSummaries((PreferenceGroup) pref);
        }
        setSummary(pref);
        setEntries(pref);
    }
}
 

private boolean removePreference(@NonNull PreferenceGroup pg,
                                 @NonNull Preference preference) {
    for (int i = pg.getPreferenceCount() - 1; i >= 0; i--) {
        Preference child = pg.getPreference(i);
        if (child == preference) {
            pg.removePreference(preference);
            return true;
        } else if (child instanceof PreferenceGroup) {
            if (removePreference((PreferenceGroup) child, preference)) return true;
        }
    }
    return false;
}
 

private InputMethodSubtype[] getSubtypes() {
    final PreferenceGroup group = getPreferenceScreen();
    final ArrayList<InputMethodSubtype> subtypes = new ArrayList<>();
    final int count = group.getPreferenceCount();
    for (int i = 0; i < count; i++) {
        final Preference pref = group.getPreference(i);
        if (pref instanceof CustomInputStylePreference) {
            final CustomInputStylePreference subtypePref = (CustomInputStylePreference)pref;
            // We should not save newly adding subtype to preference because it is incomplete.
            if (subtypePref.isIncomplete()) continue;
            subtypes.add(subtypePref.getSubtype());
        }
    }
    return subtypes.toArray(new InputMethodSubtype[subtypes.size()]);
}
 

private InputMethodSubtype[] getSubtypes() {
    final PreferenceGroup group = getPreferenceScreen();
    final ArrayList<InputMethodSubtype> subtypes = new ArrayList<>();
    final int count = group.getPreferenceCount();
    for (int i = 0; i < count; i++) {
        final Preference pref = group.getPreference(i);
        if (pref instanceof CustomInputStylePreference) {
            final CustomInputStylePreference subtypePref = (CustomInputStylePreference)pref;
            // We should not save newly adding subtype to preference because it is incomplete.
            if (subtypePref.isIncomplete()) continue;
            subtypes.add(subtypePref.getSubtype());
        }
    }
    return subtypes.toArray(new InputMethodSubtype[subtypes.size()]);
}
 

private void initSummary(Preference p) {
    if (p instanceof PreferenceGroup) {
        PreferenceGroup pGrp = (PreferenceGroup) p;
        for (int i = 0; i < pGrp.getPreferenceCount(); i++) {
            initSummary(pGrp.getPreference(i));
        }
    } else {
        updatePrefSummary(p);
    }
}
 

private void mapping(PreferenceGroup group) {
        for (int i = 0; i < group.getPreferenceCount(); i++) {
            Preference preference = group.getPreference(i);
            if (preference instanceof PreferenceGroup) {
                mapping((PreferenceGroup) preference);
            } else {
                preference.setOnPreferenceChangeListener(this);
//                if (preference instanceof ListPreference) {
//                    preference.setSummary(((ListPreference) preference).getEntry());
//                }
            }
        }
    }
 

static void removeAnyDictSettings(final PreferenceGroup prefGroup) {
    for (int i = prefGroup.getPreferenceCount() - 1; i >= 0; --i) {
        prefGroup.removePreference(prefGroup.getPreference(i));
    }
}