Comment valider une valeur EditTextPreference pour une gamme int spécifique

Question

Je veux valider une valeur EditTextPreference être à l'intérieur d'une plage de int spécifique (disons 1 à 22). La seule partie que je valideriez était le inputType (numéro uniquement) avec la déclaration xml suivante dans le fichier prefs.xml.

android: inputType = "nombre"

La deuxième chose que je fait est d'écrire le code suivant dans l'activité ListSettings.

public class ListSettings extends PreferenceActivity implements OnSharedPreferenceChangeListener{

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    addPreferencesFromResource(R.xml.prefs);
    SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this);
    sp.registerOnSharedPreferenceChangeListener(this);
}
 public void onSharedPreferenceChanged(SharedPreferences sp, String key) {
        String value = sp.getString(key, null);
        int intZoomValue = Integer.parseInt(value);
        if (intZoomValue < 1 || intZoomValue > 22) {
            Intent intent = new Intent().setClass(this, dialog.class);
            // I want to call the dialog activity here...
        }

  }

et le dialog.class est le suivant:

public class dialog extends Activity {
@Override
public void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);

  AlertDialog.Builder builder = new AlertDialog.Builder(this);
  builder.setMessage("Please enter a value between 1-22!");
  builder.setCancelable(true);

  AlertDialog alert = builder.create();
  alert.show();
  }
}

Ce que je veux atteindre est d'appeler la dialog.class (la boîte de dialogue d'alerte) à chaque fois que l'utilisateur entre une valeur pas dans la plage 1-22.

Je ne peux pas vraiment comprendre comment valider avec la bonne façon.

Answer 1

Il est peut-être plus convivial pour serrer juste la valeur à la plage autorisée si une valeur non valide est entré, et avertir l'utilisateur avec un Toast que vous avez fait.

Si votre gamme est faible, comme 1-22, alors vous pouvez même envisager d'utiliser un Spinner au lieu d'un EditText afin que l'utilisateur ne peut pas entrer une valeur non valide en premier lieu.

Answer 2

Voici ce que je faisais:

    EditTextPreference pref = (EditTextPreference) findPreference(this.getString(R.string.my_setting_key));
    pref.getEditText().setFilters(new InputFilter[]{
            new InputFilter (){

                @Override
                public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {   
                    try {
                        int input = Integer.parseInt(dest.toString() + source.toString());
                        if (input<MAX_VALUE && input >0)
                            return null;
                    } catch (NumberFormatException nfe) { }     
                    return "";
                }
            }
    });

Donc, l'astuce est que vous pouvez obtenir et EditText de votre EditTextPreference en utilisant:

    pref.getEditText()

vous pouvez définir un filtre. Le filtre doit retourner null quand tout est ok et une chaîne vide lorsque l'omble chevalier entré par l'utilisateur rendrait invalide le texte.

Voir aussi ici

Answer 3

Vous pouvez utiliser setPositivteButton et valider l'entrée une fois que l'utilisateur touche OK, sinon d'accord, Répop la boîte de dialogue.

Answer 4

La solution InputFilter ne fonctionne pas, surtout avec selectAllOnFocus. Si vous ne pouvez pas utiliser l'alternative sélecteur / spinner suggéré, par exemple, lorsque vous souhaitez appliquer un minimum, mais pas au maximum, vous pouvez désactiver le bouton OK lorsque la valeur est invalide comme ceci:

public static void setNumberRange(final EditTextPreference preference, 
                                  final Number min, final Number max) {
    setNumberRange(preference, min, max, false);
}

public static void setNumberRange(final EditTextPreference preference,
                                  final Number min, final Number max, 
                                  final boolean allowEmpty) {

    preference.getEditText().addTextChangedListener(new TextWatcher() {

        @Override
        public void beforeTextChanged(CharSequence s, int start, int count, int after) {
        }

        @Override
        public void onTextChanged(CharSequence s, int start, int before, int count) {
        }

        @Override
        public void afterTextChanged(final Editable s) {

            Dialog dialog = preference.getDialog();
            if (dialog instanceof AlertDialog) {
                Button button = ((AlertDialog) dialog).getButton(DialogInterface.BUTTON_POSITIVE);
                if (allowEmpty && s.length() == 0) {
                    button.setEnabled(true);
                    return;
                }
                try {
                    if (min instanceof Integer || max instanceof Integer) {
                        int input = Integer.parseInt(s.toString());
                        button.setEnabled((min == null || input >= min.intValue()) && (max == null || input <= max.intValue()));
                    } else if (min instanceof Float || max instanceof Float) {
                        float input = Float.parseFloat(s.toString());
                        button.setEnabled((min == null || input >= min.floatValue()) && (max == null || input <= max.floatValue()));
                    } else if (min instanceof Double || max instanceof Double) {
                        double input = Double.parseDouble(s.toString());
                        button.setEnabled((min == null || input >= min.doubleValue()) && (max == null || input <= max.doubleValue()));
                    }
                } catch (Exception e) {
                    button.setEnabled(false);
                }
            }
        }
    });
}

Cela vous permet de spécifier au minimum et / ou des valeurs maximales en entier, Flottant ou Double (null passe pour sans bornes). En option, vous pouvez autoriser / interdire les valeurs vides. (Les valeurs non valides sont initialement acceptées.)