wake-up-neo.com

Gibt es eine Möglichkeit, einen Min- und Max-Wert für EditText in Android zu definieren?

Ich möchte einen Min- und Max-Wert für ein _ EditText definieren. 

Beispiel: Wenn eine Person versucht, einen Monatswert einzugeben, muss der Wert zwischen 1 und 12 liegen.

Ich kann dies mit TextWatcher tun, aber ich möchte wissen, ob es eine andere Möglichkeit gibt, dies in der Layoutdatei oder anderswo zu tun.

Edit: Ich möchte die Anzahl der Zeichen nicht begrenzen. Ich möchte den Wert begrenzen. Wenn ich zum Beispiel die Monatszeichen EditText w bei der Eingabe von 12 einschränke, wird es akzeptiert, aber wenn ich 22 eingebe, darf es die Eingabe während der Eingabe nicht akzeptieren.

105
mertaydin

Machen Sie zuerst diese Klasse:

package com.test;

import Android.text.InputFilter;
import Android.text.Spanned;

public class InputFilterMinMax implements InputFilter {

    private int min, max;

    public InputFilterMinMax(int min, int max) {
        this.min = min;
        this.max = max;
    }

    public InputFilterMinMax(String min, String max) {
        this.min = Integer.parseInt(min);
        this.max = Integer.parseInt(max);
    }

    @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 (isInRange(min, max, input))
                return null;
        } catch (NumberFormatException nfe) { }     
        return "";
    }

    private boolean isInRange(int a, int b, int c) {
        return b > a ? c >= a && c <= b : c >= b && c <= a;
    }
}

Dann verwenden Sie das aus Ihrer Aktivität:

EditText et = (EditText) findViewById(R.id.myEditText);
et.setFilters(new InputFilter[]{ new InputFilterMinMax("1", "12")});

Dies ermöglicht dem Benutzer die Eingabe von Werten von 1 bis 12 nur .

BEARBEITEN:

Stellen Sie Ihren Edittext mit Android:inputType="number" ein.

Vielen Dank.

245
Pratik Sharma

In Pratiks Code ist ein kleiner Fehler aufgetreten. Wenn beispielsweise ein Wert 10 ist und Sie am Anfang eine 1 hinzufügen, um 110 zu erstellen, würde die Filterfunktion den neuen Wert als 101 behandeln.

Siehe unten für ein Update dazu:

@Override
public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
    try {
        // Remove the string out of destination that is to be replaced
        String newVal = dest.toString().substring(0, dstart) + dest.toString().substring(dend, dest.toString().length());
        // Add the new string in
        newVal = newVal.substring(0, dstart) + source.toString() + newVal.substring(dstart, newVal.length());
        int input = Integer.parseInt(newVal);
        if (isInRange(min, max, input))
            return null;
    } catch (NumberFormatException nfe) { }
    return "";
}
75
Zac

Erweiterung der Antwort von Pratik und Zac. Zac behebte einen kleinen Fehler von Pratik in seiner Antwort. Ich habe jedoch nicht mitbekommen, dass Code negative Werte nicht unterstützt, sondern eine NumberFormatException auslöst. Verwenden Sie den folgenden Code, um das Problem zu beheben und das MIN negativ zu machen. 

Fügen Sie diese Zeile (fett gedruckt) zwischen den beiden anderen Zeilen hinzu: 

newVal = newValSubstring (0, dstart) + source.toString () + newValSubstring (dstart, newVal.length ());

if (newVal.equalsIgnoreCase ("-") && min <0) gibt null zurück;

int input = Integer.parseInt (newVal); 

public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
    try {
        // Remove the string out of destination that is to be replaced
        String newVal = dest.toString().substring(0, dstart) + dest.toString().substring(dend, dest.toString().length());
        // Add the new string in
        newVal = newVal.substring(0, dstart) + source.toString() + newVal.substring(dstart, newVal.length());
        //****Add this line (below) to allow Negative values***// 
        if(newVal.equalsIgnoreCase("-") && min < 0)return null;
        int input = Integer.parseInt(newVal);
        if (isInRange(min, max, input))
            return null;
    } catch (NumberFormatException nfe) {
        nfe.printStackTrace();
    }
    return "";
}
9
Anthony B

Was ich von der Lösung von @ Patrik und dem Zusatz von @ Zac gesehen habe, hat der bereitgestellte Code immer noch ein großes Problem:

Wenn min==3, ist es unmöglich, eine Zahl einzugeben, die mit 1 oder 2 beginnt (Beispiel: 15, 23).
Wenn min>=10 dann nichts eingegeben werden kann, da jede Zahl mit 1,2,3 ... beginnen muss.

Nach meinem Verständnis können wir die Min-Max-Begrenzung eines Werts von EditText nicht mit der einfachen Verwendung der Klasse InputFilterMinMax erreichen, zumindest nicht für den Min-Wert. Wenn der Benutzer eine positive Zahl eingibt, wird der Wert größer und wir können einen Wert leicht erhöhen On-the-Fly-Test, um zu überprüfen, ob der Grenzwert erreicht wurde oder außerhalb des Bereichs lag, und Einträge blockieren, die nicht den Anforderungen entsprechen. Das Testen des Mindestwerts ist eine andere Geschichte, da wir nicht sicher sind, ob der Benutzer die Eingabe beendet hat oder nicht, und daher nicht entscheiden können, ob wir blockieren sollen oder nicht.

Es ist nicht genau das, was OP angefordert hat, aber zu Validierungszwecken habe ich in meiner Lösung ein InputFilter zum Testen von Maximalwerten kombiniert, mit einem OnFocusChangeListener-Objekt, um den minimalen Wert erneut zu testen, wenn das EditText den Fokus verliert, wenn der Benutzer die Eingabe abgeschlossen hat :

package test;


import Android.text.InputFilter;

import Android.text.Spanned;

public class InputFilterMax implements InputFilter {

private int max;

public InputFilterMax(int max) {
    this.max = max;
}

public InputFilterMax(String max) {
    this.max = Integer.parseInt(max);
}

@Override
public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {   
    try {
        String replacement = source.subSequence(start, end).toString(); 

        String newVal = dest.toString().substring(0, dstart) + replacement +dest.toString().substring(dend, dest.toString().length());

        int input = Integer.parseInt(newVal);

        if (input<=max)
            return null;
    } catch (NumberFormatException nfe) { }   
//Maybe notify user that the value is not good      
return "";
}
}

Und OnFocusChangeListenerMin 

package test;

import Android.text.TextUtils;
import Android.view.View;
import Android.view.View.OnFocusChangeListener;

public class OnFocusChangeListenerMin implements OnFocusChangeListener {

private int min;

public OnFocusChangeListenerMin(int min) {
    this.min = min;
}

public OnFocusChangeListenerMin(String min) {
    this.min = Integer.parseInt(min);
}


@Override
public void onFocusChange(View v, boolean hasFocus) {
    if(!hasFocus) {
        String val = ((EditText)v).getText().toString();
        if(!TextUtils.isEmpty(val)){
            if(Integer.valueOf(val)<min){
                //Notify user that the value is not good
            }

        }
    }
}
}

Setzen Sie in Activity dann InputFilterMax und OnFocusChangeListenerMin auf EditText Hinweis: In onFocusChangeListener können Sie sowohl min als auch max.

mQteEditText.setOnFocusChangeListener( new OnFocusChangeListenerMin('20');
mQteEditText.setFilters(new InputFilter[]{new InputFilterMax(getActivity(),'50')});
5
Guerneen4

Ich habe @Pratik Sharmas-Code erweitert, um BigDecimal-Objekte anstelle von Ints zu verwenden, sodass größere Zahlen akzeptiert werden können und alle Formatierungen im EditText berücksichtigt werden können, die keine Zahlen sind (z. B. Währungsformatierung, z. B. Leerzeichen, Kommas und Punkte).

BEARBEITEN: Beachten Sie, dass bei dieser Implementierung für die BigDecimal-Zahl 2 (als MIN_SIG_FIG-Konstante) festgelegt ist, da ich sie für die Währung verwendet habe. Vor dem Dezimalpunkt befanden sich immer 2 führende Zahlen. Ändern Sie die MIN_SIG_FIG-Konstante nach Bedarf für Ihre eigene Implementierung. 

public class InputFilterMinMax implements InputFilter {
private static final int MIN_SIG_FIG = 2;
private BigDecimal min, max;

public InputFilterMinMax(BigDecimal min, BigDecimal max) {
    this.min = min;
    this.max = max;
}

public InputFilterMinMax(String min, String max) {
    this.min = new BigDecimal(min);
    this.max = new BigDecimal(max);
}

@Override
public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart,
        int dend) {
    try {
        BigDecimal input = formatStringToBigDecimal(dest.toString()
                + source.toString());

        if (isInRange(min, max, input)) {

            return null;
        }
    } catch (NumberFormatException nfe) {

    }
    return "";
}

private boolean isInRange(BigDecimal a, BigDecimal b, BigDecimal c) {
    return b.compareTo(a) > 0 ? c.compareTo(a) >= 0 && c.compareTo(b) <= 0
            : c.compareTo(b) >= 0 && c.compareTo(a) <= 0;
}

public static BigDecimal formatStringToBigDecimal(String n) {

    Number number = null;
    try {
        number = getDefaultNumberFormat().parse(n.replaceAll("[^\\d]", ""));

        BigDecimal parsed = new BigDecimal(number.doubleValue()).divide(new BigDecimal(100), 2,
                BigDecimal.ROUND_UNNECESSARY);
        return parsed;
    } catch (ParseException e) {
        return new BigDecimal(0);
    }
}

private static NumberFormat getDefaultNumberFormat() {
    NumberFormat nf = NumberFormat.getInstance(Locale.getDefault());
    nf.setMinimumFractionDigits(MIN_SIG_FIG);
    return nf;
}
5
AndroidNoob

Wenn Sie einen Bereich mit negativen Zahlen wie -90: 90 benötigen, können Sie diese Lösung verwenden. 

public class InputFilterMinMax implements InputFilter {

private int min, max;

public InputFilterMinMax(int min, int max) {
    this.min = min;
    this.max = max;
}

public InputFilterMinMax(String min, String max) {
    this.min = Integer.parseInt(min);
    this.max = Integer.parseInt(max);
}

@Override
public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
    try {
        String stringInput = dest.toString() + source.toString();
        int value;
        if (stringInput.length() == 1 && stringInput.charAt(0) == '-') {
            value = -1;
        } else {
            value = Integer.parseInt(stringInput);
        }
        if (isInRange(min, max, value))
            return null;
    } catch (NumberFormatException nfe) {
    }
    return "";
}

private boolean isInRange(int min, int max, int value) {
    return max > min ? value >= min && value <= max : value >= max && value <= min;
}
}
5
Denys Vasylenko

In der akzeptierten Antwort stimmt etwas nicht.

int input = Integer.parseInt(dest.toString() + source.toString());

Wenn ich den Cursor in die Mitte des Texts schiebe, dann etwas eingeben, wird die obige Anweisung ein falsches Ergebnis erzeugen. __ Geben Sie beispielsweise zuerst "12" und dann "0" zwischen 1 und 2 ein, dann wird die oben erwähnte Anweisung verwendet Produziere "120" anstelle von 102 . Ich habe diese Anweisung in folgende Anweisungen geändert:

String destString = dest.toString();
  String inputString = destString.substring(0, dstart) + source.toString() + destString.substring(dstart);
  int input = Integer.parseInt(inputString);
4
谭春茂

Ich habe einen einfacheren Weg gemacht, ein Min/Max für eine Edittext festzulegen. Ich verwende eine arithmetische Tastatur und arbeite mit dieser Methode: 

 private int limit(EditText x,int z,int limin,int limax){

    if( x.getText().toString()==null || x.getText().toString().length()==0){
        x.setText(Integer.toString(limin));
        return z=0;
    }
    else{
        z = Integer.parseInt(x.getText().toString());
         if(z <limin || z>limax){
             if(z<10){
                 x.setText(Integer.toString(limin));
                return  z=0;
             }
            else{
                x.setText(Integer.toString(limax));
                return z=limax;
            }

         }
         else
            return z = Integer.parseInt(x.getText().toString());
    }
 }

Die Methode akzeptiert alle Ihre Werte, aber wenn ein Wert von Benutzern Ihre Grenzwerte nicht einhält, wird er automatisch auf die Min/Max-Grenze gesetzt. Für ex. limit limin = 10, limax = 80 Wenn der Benutzer 8 einstellt, wird automatisch 10 in einer Variablen gespeichert und EditText auf 10 gesetzt.

3
Argyris

Ich habe meine eigene Antwort gefunden. Es ist jetzt sehr spät, aber ich möchte es mit Ihnen teilen ... Ich implementiere diese Schnittstelle:

import Android.text.TextWatcher;


public abstract class MinMaxTextWatcher implements TextWatcher {
    int min, max;
    public MinMaxTextWatcher(int min, int max) {
        super();
        this.min = min;
        this.max = max;
    }

}

Und dann implementieren Sie es auf diese Weise in Ihrer Aktivität:

private void limitEditText(final EditText ed, int min, int max) {
    ed.addTextChangedListener(new MinMaxTextWatcher(min, max) {
        @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(Editable s) {
            String str = s.toString();
            int n = 0;
            try {
                n = Integer.parseInt(str);
                if(n < min) {
                    ed.setText(min);
                    Toast.makeText(getApplicationContext(), "Minimum allowed is " + min, Toast.LENGTH_SHORT).show();
                }
                else if(n > max) {
                    ed.setText("" + max);
                    Toast.makeText(getApplicationContext(), "Maximum allowed is " + max, Toast.LENGTH_SHORT).show();
                }
            }
            catch(NumberFormatException nfe) {
                ed.setText("" + min);
                Toast.makeText(getApplicationContext(), "Bad format for number!" + max, Toast.LENGTH_SHORT).show();
            }
        }
    });
}

Dies ist eine sehr einfache Antwort, wenn es besser ist, bitte sagen Sie es mir.

2
Nacho García

bitte überprüfen Sie diesen Code 

    String pass = EditText.getText().toString(); 
    if(TextUtils.isEmpty(pass) || pass.length < [YOUR MIN LENGTH]) 
    { 
       EditText.setError("You must have x characters in your txt"); 
        return; 
    }

    //continue processing



edittext.setOnFocusChangeListener( new OnFocusChangeListener() {

       @Override
       public void onFocusChange(View v, boolean hasFocus) {
          if(hasFocus) {
           // USE your code here 
  }

Unter dem folgenden Link finden Sie weitere Informationen zu edittext und den edittextfilteres mit dem Textwächter. 

http://www.mobisoftinfotech.com/blog/Android/android-edittext-setfilters-example-numeric-text-field-patterns-and-length-restriction/

2
itsrajesh4uguys
@Override
public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
    try {
        String prefix = dest.toString().substring(0, dstart);
        String insert = source.toString();
        String suffix = dest.toString().substring(dend);
        String input_string = prefix + insert + suffix;
        int input = Integer.parseInt(input_string);

        if (isInRange(min, max, input) || input_string.length() < String.valueOf(min).length())
            return null;
    } catch (NumberFormatException nfe) { }
    return "";
}

private boolean isInRange(int a, int b, int c) {
    return b > a ? c >= a && c <= b : c >= b && c <= a;
}
2
jet27

Wenn Sie nur über das maximale Limit besorgt sind, fügen Sie einfach die folgende Zeile in .__ hinzu.

Android:maxLength="10" 

Wenn Sie ein Mindestlimit hinzufügen müssen, können Sie dies auf diese Weise tun. In diesem Fall ist das Mindestlimit 7. Der Benutzer kann Zeichen zwischen dem Mindest- und dem Maximalgrenzwert (zwischen 8 und 10) eingeben. 

public final static boolean isValidCellPhone(String number){
        if (number.length() < 8 || number.length() >10 ) {
            return false;
        } else {

           return Android.util.Patterns.PHONE.matcher(number).matches();
        }
    }

Wenn Sie auch den Benutzer auf die Eingabe von 01 beim Start einschränken müssen, ändern Sie die obige Bedingung 

if (!(number.startsWith("01")) || number.length() < 8 || number.length() >10 ) {  
.
.
.
}

Am Ende rufen Sie die Methode gerne auf

   ....else if (!(Helper.isValidMobilePhone(textMobileNo))){
                        Helper.setEditTextError(etMobileNo,"Invalid Mobile Number");
                    }......
1
Faakhir

@Pratik Sharma

Für die Unterstützung vonnegativen Zahlenfügen Sie den folgenden Code in die filter -Methode ein:

package ir.aboy.electronicarsenal;

import Android.text.InputFilter;
import Android.text.Spanned;

public class InputFilterMinMax implements InputFilter {

  private int min, max;
  int input;

  InputFilterMinMax(int min, int max) {
    this.min = min;
    this.max = max;
  }

  public InputFilterMinMax(String min, String max) {
    this.min = Integer.parseInt(min);
    this.max = Integer.parseInt(max);
  }

  @Override
  public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
    try {

      if ((dest.toString() + source.toString()).equals("-")) {
        source = "-1";
      }

      input = Integer.parseInt(dest.toString() + source.toString());
      if (isInRange(min, max, input))
        return null;

    } catch (NumberFormatException ignored) {
    }
    return "";
  }

  private boolean isInRange(int a, int b, int c) {
    return b > a ? c >= a && c <= b : c >= b && c <= a;
  }

}

Dann verwenden Sie das aus Ihrer Aktivität:

findViewById(R.id.myEditText).setFilters(new InputFilter[]{ new InputFilterMinMax(1, 12)});

Setze deinen Text mit:

Android:inputType="number|numberSigned"
1
gadolf

Ich weiß, dass es bereits eine Million Antworten gibt, von denen eine akzeptiert wurde. Es gibt jedoch zahlreiche Fehler in der akzeptierten Antwort, und die meisten anderen beheben einfach einen (oder vielleicht zwei) von ihnen, ohne sich auf alle möglichen Anwendungsfälle auszudehnen.

Daher habe ich im Wesentlichen die meisten der in den Support-Antworten vorgeschlagenen Fehlerbehebungen zusammengestellt und eine Methode hinzugefügt, mit der fortlaufende Eingabe von Zahlen außerhalb des Bereichs in Richtung 0 möglich ist (wenn der Bereich nicht bei 0 beginnt), zumindest bis dies der Fall ist sicher, dass es nicht mehr im Bereich sein kann. Es ist klar, dass dies der einzige Zeitpunkt ist, der bei vielen anderen Lösungen Probleme verursacht.

Hier ist der Fix:

public class InputFilterIntRange implements InputFilter, View.OnFocusChangeListener {

    private final int min, max;

    public InputFilterIntRange(int min, int max) {
        if (min > max) {
            // Input sanitation for the filter itself
            int mid = max;
            max = min;
            min = mid;
        }
        this.min = min;
        this.max = max;
    }

    @Override
    public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {

        // Determine the final string that will result from the attempted input
        String destString = dest.toString();
        String inputString = destString.substring(0, dstart) + source.toString() + destString.substring(dstart);

        // Don't prevent - sign from being entered first if min is negative
        if (inputString.equalsIgnoreCase("-") && min < 0) return null;

        try {
            int input = Integer.parseInt(inputString);
            if (mightBeInRange(input))
                return null;
        } catch (NumberFormatException nfe) {}

        return "";
    }

    @Override
    public void onFocusChange(View v, boolean hasFocus) {

        // Since we can't actively filter all values
        // (ex: range 25 -> 350, input "15" - could be working on typing "150"),
        // lock values to range after text loses focus
        if (!hasFocus) {
            if (v instanceof EditText) sanitizeValues((EditText) v);
        }
    }

    private boolean mightBeInRange(int value) {
        // Quick "fail"
        if (value >= 0 && value > max) return false;
        if (value >= 0 && value >= min) return true;
        if (value < 0 && value < min) return false;
        if (value < 0 && value <= max) return true;

        boolean negativeInput = value < 0;

        // If min and max have the same number of digits, we can actively filter
        if (numberOfDigits(min) == numberOfDigits(max)) {
            if (!negativeInput) {
                if (numberOfDigits(value) >= numberOfDigits(min) && value < min) return false;
            } else {
                if (numberOfDigits(value) >= numberOfDigits(max) && value > max) return false;
            }
        }

        return true;
    }

    private int numberOfDigits(int n) {
        return String.valueOf(n).replace("-", "").length();
    }

    private void sanitizeValues(EditText valueText) {
        try {
            int value = Integer.parseInt(valueText.getText().toString());
            // If value is outside the range, bring it up/down to the endpoint
            if (value < min) {
                value = min;
                valueText.setText(String.valueOf(value));
            } else if (value > max) {
                value = max;
                valueText.setText(String.valueOf(value));
            }
        } catch (NumberFormatException nfe) {
            valueText.setText("");
        }
    }

}

Beachten Sie, dass einige Eingabefälle nicht "aktiv" behandelt werden können (d. H. Wenn der Benutzer sie eingibt). Wir müssen sie daher ignorieren und behandeln, nachdem der Benutzer den Text bearbeitet hat.

So können Sie es verwenden:

EditText myEditText = findViewById(R.id.my_edit_text);
InputFilterIntRange rangeFilter = new InputFilterIntRange(25, 350);
myEditText.setFilters(new InputFilter[]{rangeFilter});

// Following line is only necessary if your range is like [25, 350] or [-350, -25].
// If your range has 0 as an endpoint or allows some negative AND positive numbers, 
// all cases will be handled pre-emptively.
myEditText.setOnFocusChangeListener(rangeFilter);

Wenn der Benutzer versucht, eine Zahl einzugeben, die näher an 0 liegt, als der Bereich zulässt, wird eines von zwei Dingen passieren:

  1. Wenn min und max dieselbe Anzahl von Ziffern haben, ist es ihnen nicht gestattet, sie überhaupt einzugeben, sobald sie an der letzten Ziffer angekommen sind.

  2. Wenn eine Zahl außerhalb des Bereichs im Feld verbleibt, wenn der Text den Fokus verliert, wird er automatisch an die engste Grenze angepasst.

Natürlich darf der Benutzer niemals einen Wert weiter als 0 eingeben, als es der Bereich zulässt, und es ist auch nicht möglich, dass eine solche Zahl aus diesem Grund "versehentlich" im Textfeld steht.

Bekanntes Problem (s?)

  1. Dies funktioniert nur, wenn die EditText den Fokus verliert, wenn der Benutzer damit fertig ist. 

Die andere Option ist die Bereinigung, wenn der Benutzer die "Fertig"/Return-Taste drückt, aber in vielen oder sogar den meisten Fällen führt dies zu einem Konzentrationsverlust.

Wenn Sie die Soft-Tastatur schließen, wird das Element durch nicht automatisch unscharf. Ich bin mir sicher, dass 99,99% der Android-Entwickler dies wünschen (und dass die Behandlung von EditText-Elementen im Allgemeinen weniger minderwertig war), aber bisher gibt es keine integrierten Funktionen. Die einfachste Methode, die ich gefunden habe, um dies zu umgehen, besteht darin, EditText so zu erweitern:

public class EditTextCloseEvent extends AppCompatEditText {

    public EditTextCloseEvent(Context context) {
        super(context);
    }

    public EditTextCloseEvent(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public EditTextCloseEvent(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
    }

    @Override
    public boolean onKeyPreIme(int keyCode, KeyEvent event) {
        if (event.getKeyCode() == KeyEvent.KEYCODE_BACK) {
            for (InputFilter filter : this.getFilters()) {
                if (filter instanceof InputFilterIntRange)
                    ((InputFilterIntRange) filter).onFocusChange(this, false);
            }
        }
        return super.dispatchKeyEvent(event);
    }
}

Dadurch wird der Filter dazu verleitet, die Eingabe zu bereinigen, obwohl die Ansicht nicht tatsächlich den Fokus verloren hat. Wenn die Ansicht später den Fokus von selbst verliert, wird die Eingabesanierung erneut ausgelöst, es ändert sich jedoch nichts, da sie bereits behoben wurde.

Schließen

Wütend. Das war viel. Was ursprünglich so aussah, als wäre es ein ziemlich trivial leichtes Problem, das viele kleine hässliche Stücke von Vanilla Android (zumindest in Java) enthüllte. Und noch einmal, Sie müssen nur den Listener hinzufügen und EditText erweitern, wenn Ihr Bereich nicht irgendwie 0 enthält. (Und wenn Ihr Bereich nicht 0 enthält, sondern bei 1 oder -1 beginnt, haben Sie auch keine Probleme.)

Als letzte Anmerkung funktioniert dies nur für ints. Es gibt sicherlich eine Möglichkeit, es mit Dezimalzahlen zu implementieren (double, float), aber da weder ich noch der ursprüngliche Fragesteller dies brauchen, möchte ich nicht unbedingt alles so tief in die Sache eintauchen. Es ist sehr einfach, die Post-Completion-Filterung zusammen mit den folgenden Zeilen zu verwenden:

// Quick "fail"
if (value >= 0 && value > max) return false;
if (value >= 0 && value >= min) return true;
if (value < 0 && value < min) return false;
if (value < 0 && value <= max) return true;

Sie müssten lediglich von int zu float (oder double) wechseln, das Einfügen eines einzelnen . (oder ,, je nach Land?) Zulassen und als einen der Dezimaltypen statt einer int analysieren.

Das erledigt die meiste Arbeit trotzdem, also würde es sehr ähnlich funktionieren.

0
VerumCH

Sehr einfaches Beispiel zu Kotlin:

import Android.text.InputFilter
import Android.text.Spanned

class InputFilterRange(private var range: IntRange) : InputFilter {

    override fun filter(source: CharSequence, start: Int, end: Int, dest: Spanned, dstart: Int, dend: Int) = try {
        val input = Integer.parseInt(dest.toString() + source.toString())
        if (range.contains(input)) null else ""
    } catch (nfe: NumberFormatException) {
        ""
    }
}
0
Andrew

Um den Mindestwert des EditText zu definieren, habe ich Folgendes verwendet:

if (message.trim().length() >= 1 && message.trim().length() <= 12) {
  // do stuf
} else {
  // Too short or too long
}
0
Bonne Bogaert

Sie können dies mit einem InputFilter tun. Anscheinend gibt es nur diese Eingabefilteroberfläche, die Sie verwenden können. Bevor Sie es auf die nervige Weise tun, eine neue Klasse zu erstellen, die den Eingabefilter erweitert, können Sie diese Verknüpfung mit einer Interface-Instanziierung der inneren Klasse verwenden.

Deshalb machst du das einfach:

EditText subTargetTime = (EditText) findViewById(R.id.my_time);
subTargetTime.setFilters( new InputFilter[] {
                new InputFilter() {
                    @Override
                    public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
                        int t = Integer.parseInt(source.toString());
                        if(t <8) { t = 8; }
                        return t+"";

                    }
                }
        });

In diesem Beispiel überprüfe ich, ob der Wert von EditText größer als 8 ist. Andernfalls muss der Wert auf 8 gesetzt werden. Sie müssen also unbedingt die minimale Max-Zahl oder eine andere Filterlogik selbst festlegen. Aber zumindest kann man die Filterlogik ziemlich direkt und direkt in den EditText schreiben.

Hoffe das hilft

Um Pratiks Antwort hinzuzufügen, ist hier eine modifizierte Version, in der der Benutzer mindestens 2 Ziffern eingeben kann, beispielsweise 15 bis 100:

 import Android.text.InputFilter;
 import Android.text.Spanned;

public class InputFilterMinMax implements InputFilter {

    private int min, max;

    public InputFilterMinMax(int min, int max) {
        this.min = min;
        this.max = max;
    }

    public InputFilterMinMax(String min, String max) {
        this.min = Integer.parseInt(min);
        this.max = Integer.parseInt(max);
    }

    @Override
    public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {

        try {
            if(end==1)
                min=Integer.parseInt(source.toString());
            int input = Integer.parseInt(dest.toString() + source.toString());
            if (isInRange(min, max, input))
                return null;
        } catch (NumberFormatException nfe) {
        }
        return "";
    }

    private boolean isInRange(int a, int b, int c) {

        return b > a ? c >= a && c <= b : c >= b && c <= a;
    }}

hinzugefügt: if (end == 1) min = Integer.parseInt (source.toString ());

Hoffen Sie, dass dies hilft. Bitte nicht abstimmen ohne Gründe.

0
sanjeeb

// hat immer noch Probleme, aber hier können Sie min, max in einem beliebigen Bereich (positiv oder negativ) verwenden.

// in filter calss
 @Override
 public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
        try {
            // Remove the string out of destination that is to be replaced
            int input;
            String newVal = dest.toString() + source.toString();
            if (newVal.length() == 1 && newVal.charAt(0) == '-') {
                input = min; //allow
            }
            else {
                newVal = dest.toString().substring(0, dstart) + dest.toString().substring(dend, dest.toString().length());
                // Add the new string in
                newVal = newVal.substring(0, dstart) + source.toString() + newVal.substring(dstart, newVal.length());
                input = Integer.parseInt(newVal);
            }

            //int input = Integer.parseInt(dest.toString() + source.toString());

            if (isInRange(min, max, input))
                return null;
        } catch (NumberFormatException nfe) {
        }
        return "";
    }

//also the filler must set as below: in the edit createview
// to allow enter number and backspace.
et.setFilters(new InputFilter[]{new InputFilterMinMax(min >= 10 ?  "0" : String.valueOf(min), max >-10 ? String.valueOf(max) :"0" )});



//and at same time must check range in the TextWatcher()
et.addTextChangedListener(new
 TextWatcher() {

      @Override
      public void afterTextChanged (Editable editable)
      {
         String tmpstr = et.getText().toString();
         if (!tmpstr.isEmpty() && !tmpstr.equals("-") ) {
             int datavalue = Integer.parseInt(tmpstr);
             if ( datavalue >= min || datavalue <= max) {
               // accept data ...     
             }
         }
      }
 });
0
CHTsai

dies ist mein Code max = 100, min = 0

xml

<TextView
                    Android:id="@+id/txt_Mass_smallWork"
                    Android:layout_width="match_parent"
                    Android:layout_height="wrap_content"
                    Android:textColor="#000"
                    Android:textSize="20sp"
                    Android:textStyle="bold" />

Java

EditText ed = findViewById(R.id.txt_Mass_smallWork);
    ed.addTextChangedListener(new TextWatcher() {
        @Override
        public void beforeTextChanged(CharSequence charSequence, int i, int i1, int i2) {`

        }

        @Override
        public void onTextChanged(CharSequence charSequence, int i, int i1, int i2) {
            if(!charSequence.equals("")) {
                int massValue = Integer.parseInt(charSequence.toString());
                if (massValue > 10) {
                    ed.setFilters(new InputFilter[]{new InputFilter.LengthFilter(2)});
                } else {
                    ed.setFilters(new InputFilter[]{new InputFilter.LengthFilter(3)});
                }
            }
        }

        @Override
        public void afterTextChanged(Editable editable) {

        }
    });
0
Hoàng

hier ist die Art und Weise, wie ich sie verwendet habe, sie arbeitet für eine negative Zahl

Erstellen Sie zunächst die MinMaxFIlter.Java-Klasse mit dem folgenden Code:

import Android.text.InputFilter;
import Android.text.Spanned;
import Android.util.Log;

/**
* Created by 21 on 4/5/2016.
*/
public class MinMaxFilter implements InputFilter {

private double mIntMin, mIntMax;

public MinMaxFilter(double minValue, double maxValue) {
    this.mIntMin = minValue;
    this.mIntMax = maxValue;
}

public MinMaxFilter(String minValue, String maxValue) {
    this.mIntMin = Double.parseDouble(minValue);
    this.mIntMax = Double.parseDouble(maxValue);
}

@Override
public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
    try {
        Boolean isNeg = false;
        String provi = dest.toString() + source.toString();
        if("-".equals(provi.substring(0,1))){
            if(provi.length()>1) {
                provi = provi.substring(1, provi.length());
                isNeg = true;
            }
            else{
                if("".equals(source)){
                    return null;
                }
                return "-";
            }
        }

        double input = Double.parseDouble(provi); 
        if(isNeg){input = input * (-1);}

        if (isInRange(mIntMin, mIntMax, input)) {
            return null;
        }
    } catch (Exception nfe) {}
    return "";
}

private boolean isInRange(double a, double b, double c) {
    if((c>=a && c<=b)){
        return true;
    }
    else{
        return false;
    }
}
}

Erstellen Sie dann Ihren Filter wie folgt:

EditText edittext = new EditText(context);
editext.setInputType(InputType.TYPE_CLASS_NUMBER | InputType.TYPE_NUMBER_FLAG_SIGNED);
eInt.setFilters(new InputFilter[]{new MinMaxFilter(min, max)});
0
maloromano