অ্যান্ড্রয়েড এডিটেক্সট এর জন্য ন্যূনতম এবং সর্বাধিক মান নির্ধারণ করার কোনও উপায় আছে কি?


133

আমি একটি এর জন্য একটি ন্যূনতম এবং সর্বোচ্চ মান নির্ধারণ করতে চাই EditText

উদাহরণস্বরূপ: যদি কোনও ব্যক্তি এতে এক মাসের মান প্রবেশ করার চেষ্টা করে তবে মানটি অবশ্যই 1-12 এর মধ্যে হওয়া উচিত।

আমি এটি ব্যবহার করে করতে পারি TextWatcherতবে আমি এটি জানতে চাই যে লেআউট ফাইল বা অন্য কোথাও এটি করার কোনও অন্য উপায় আছে কিনা।

সম্পাদনা: আমি অক্ষর গণনা সীমাবদ্ধ করতে চাই না। আমি মান সীমাবদ্ধ করতে চাই। উদাহরণস্বরূপ, আমি EditTextযখন 12 টি প্রবেশ করি তখন আমি যদি মাসের ডাব্লু অক্ষর সীমাবদ্ধ করি তবে এটি তা গ্রহণ করবে তবে আমি 22 এ প্রবেশ করলে অবশ্যই প্রবেশ করার সময় এটি গ্রহণ করা উচিত নয়।


কারও উচিত এই সমস্ত ধরণের ইনপুট ফিল্টারগুলির একটি গ্রন্থাগার / সংগ্রহ করা। তারপরে সবাই কাজ করতে এবং এক সাথে তাদের পরীক্ষা করতে পারে। বরং প্রতিটি ব্যক্তি তাদের নিজস্ব জিনিস করছেন।
Zapnologica

আপনার সমস্যা সমাধানের জন্য এই সম্পাদনা পাঠ্য ফিল্টারটি ব্যবহার করুন। ফিল্টার
তারাস স্মাকুলা

উত্তর:


286

প্রথমে এই ক্লাসটি তৈরি করুন:

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;
    }
}

তারপরে আপনার ক্রিয়াকলাপ থেকে এটি ব্যবহার করুন:

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

এটি ব্যবহারকারীকে কেবল 1 থেকে 12 পর্যন্ত মান প্রবেশের অনুমতি দেবে ।

সম্পাদনা:

আপনার edittext এর সাথে সেট করুন android:inputType="number"

আপনি https://www.techcompose.com/how-to-set-minimum-and-maximum-value-in-edittext-in-android-app-de વિકાસ ment/ এ আরও বিশদ জানতে পারেন ।

ধন্যবাদ।


1
@মারতায়দিন নিশ্চিত একবার চেষ্টা করে দেখুন আপনার যদি আমার সহায়তার দরকার হয় তবে আমাকে জানান। ধন্যবাদ।
প্রতীক শর্মা

12
আহ, আমার সাহায্য দরকার need 1930 এবং 1999-এর মধ্যে রাইটিগ মান চলাকালীন আমার একটি সমস্যা আছে i
মের্তায়দিন

1
@মারতায়দিন হেই দুঃখিত তবে আমি আমার কাজ নিয়ে কিছুটা ব্যস্ত জ্বালিয়েছি। আমি এটি খতিয়ে দেখার জন্য কিছুটা সময় পেয়েছি, আমার মনে হয় ফিল্টার ক্লাসে প্রয়োগ করা অ্যালগরিদমে আমাকে পরিবর্তন করতে হবে। আমি আপনাকে আপডেট করব একবার আমি এটি দিয়ে করব।
প্রতীক শর্মা

1
এর থেকে কিছু অক্ষর কিছু অক্ষর sourceপ্রতিস্থাপন করবে dest। আমি মনে করি আপনার প্রতিস্থাপনটি অনুকরণ করা উচিত, এবং শেষ ফলাফল পাওয়া উচিত, তারপরে, এটি বৈধ করুন।
এসডি

3
@ প্রতীক শর্মা, আমি যখন ১৯০০ থেকে ২০০০ এর মধ্যে সীমা প্রবেশ করি তখন এটি কার্যকর হয় না, আপনি কি কিছু প্রস্তাব দিতে পারেন
এমিনেটটি

89

প্রতীকের কোডে একটি ছোট্ট ত্রুটি রয়েছে। উদাহরণস্বরূপ, যদি মান 10 হয় এবং আপনি 110 তৈরির শুরুতে 1 যোগ করেন, ফিল্টার ফাংশনটি 101 হিসাবে নতুন মান হিসাবে বিবেচনা করবে।

এটি ঠিক করার জন্য নীচে দেখুন:

@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 "";
}

ধন্যবাদ এটি আমাকে অনেক সাহায্য করেছে!
জোছপ্লুসা

4
আমি মনে করি এটা পরিষ্কার হয় এই প্রোগ্রামটিতে :String replacement = source.subSequence(start, end).toString(); String newVal = dest.subSequence(0, dstart).toString() + replacement + dest.subSequence(dend, dest.length()).toString();
সেভেন জাকব্স

1
+1 টি। এই সমাধান গৃহীত চেয়ে আরো সঠিক। এটি যাচাই করতে উদাহরণস্বরূপ নির্বাচন করা সমস্তঅনফোকাস বিকল্পটি ইনপুটফিল্টারমিনম্যাক্স ব্যবহারের চেষ্টা করুন এবং ফলাফলের সাথে তুলনা করুন।
সাশ0 কে

1
কেন না String newVal= dest.toString().substring(0, dstart) + source.toString().substring(start, end) + dest.toString().substring(dend, dest.toString().length());, আরও পরিষ্কার এবং পরিষ্কার দেখাচ্ছে।
শিশির গুপ্ত 13

5
@ পেট্রিকের উত্তরে মন্তব্য করে ওপি @ মার্টাউদ্দিন দ্বারা উল্লিখিত হিসাবে, এই সমাধানটির এখনও একটি বড় ত্রুটি রয়েছে, আমি কেন অবাক হইনি তা অবাক করে: যদি min==3তা হয় তবে 1 বা 2 দিয়ে প্রারম্ভিক কোনও সংখ্যা টাইপ করা অসম্ভব (যেমন: 15, 23)
গের্নেন 4

10

@ প্যাট্রিকের সমাধান এবং @ জ্যাকের সংযোজন সম্পর্কে আমি যা দেখেছি তার মধ্যে প্রদত্ত কোডটিতে এখনও একটি বড় সমস্যা রয়েছে:

তবে যদি min==31 বা 2 দিয়ে শুরু করে কোনও সংখ্যা টাইপ করা অসম্ভব (উদা: 15, 23) তবে কোনও সংখ্যা টাইপ করা
যদি min>=10অসম্ভব হয় তবে প্রতিটি সংখ্যা 1,2,3 দিয়ে শুরু করতে হবে ...

আমার বোধগম্যতায় আমরা EditTextশ্রেণীর সহজ ব্যবহারের সাথে মানের সর্বাধিক সীমাবদ্ধতা অর্জন করতে পারি না InputFilterMinMax, কমপক্ষে ন্যূনতম মানের জন্য নয়, কারণ যখন ব্যবহারকারী কোনও ধনাত্মক সংখ্যা টাইপ করেন, তখন মানটি বৃদ্ধি পায় এবং আমরা সহজেই একটি সম্পাদন করতে পারি অন-ফ্লাই টেস্টটি এটি সীমাতে পৌঁছেছে কিনা তা পরীক্ষা করে পরীক্ষা করে পরীক্ষা করে পরীক্ষা করে দেখুন যে এটি সীমাবদ্ধতার বাইরে চলে গেছে এবং মেনে চলে না এমন প্রবেশদ্বারগুলিতে প্রবেশ করে। ন্যূনতম মানটি পরীক্ষা করা একটি ভিন্ন গল্প, কারণ আমরা নিশ্চিত হতে পারি না যে ব্যবহারকারী টাইপিং শেষ করেছেন কিনা এবং তাই সিদ্ধান্ত নিতে পারছেন না আমাদের ব্লক করা উচিত কিনা।

এটি ওপি অনুরোধ করেছিল ঠিক তাই নয় তবে বৈধতার উদ্দেশ্যে আমি আমার সমাধানটিতে InputFilterসর্বাধিক মানগুলি পরীক্ষা করার জন্য একত্রিত করেছি , OnFocusChangeListenerন্যূনতম মানটির পুনরায় পরীক্ষা করার জন্য যখন EditTextব্যবহারকারীর সমাপ্ত টাইপিং ধরে ফোকাস হারাতে থাকে এবং এটি এরকম কিছু হয়:

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 "";
}
}

এবং 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
            }

        }
    }
}
}

তারপর কার্যকলাপে সেট InputFilterMaxএবং OnFocusChangeListenerMinকরতে EditText নোট: আপনি 2 পারেন উভয় সর্বনিম্ন ও সর্বোচ্চ মধ্যে onFocusChangeListener

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

অনফোকাস চ্যাঞ্জলিস্টনারমিন কাজ করছে না, এটি শূন্য থেকে সমস্ত মান রেখে গেছে
এমিনেটটি

1
আপনি কি আরও কিছু বিশদ বিবরণ করতে চান? শূন্য থেকে সমস্ত মান রাখার অর্থ কী ?
গের্নিন 4

কোড থেকে অনফোকাস চেঞ্জলিস্টনারমিন অবশ্যই ২০ এর উপরে কাজ করতে হবে যেমন সমস্যা সমাধানে আলোচিত হয়েছে কারণ এটি ২০ এর চেয়ে কম মান যেমন 0, 1, 2, ------ 19 ইত্যাদি গ্রহণ করবে
এমিনেট

আপনি কি কোন সমাধান খুঁজে পেয়েছেন?
EminenT

আমি বৈধকরণের উদ্দেশ্যে অনফোনকাসচেঞ্জলিস্টনার ব্যবহার করেছি, আমার ক্ষেত্রে আমি সম্পাদনা পাঠ্যপুস্তকে একটি টোস্ট দ্বারা ব্যবহারকারীকে অবহিত করব যে মানটি ভাল নয় এবং তাকে একটি নতুন মান প্রবেশের জন্য আমন্ত্রণ জানিয়েছি if(Integer.valueOf(val)<min){ //Notify user that the value is not good } আপনি সেখানে যা চান তা করতে পারেন, অবহিত করুন ব্যবহারকারী এবং
এডিট টেক্সটটি ফাঁকাতে

9

প্রতীক এবং জ্যাক এর উত্তর প্রসারিত। জ্যাক তার উত্তরে প্রতীকের একটি ছোট বাগ ঠিক করে দিয়েছে। তবে আমি চিহ্নিত করেছি যে কোডটি নেতিবাচক মানগুলিকে সমর্থন করে না, এটি একটি নম্বর ফরম্যাট এক্সেক্সশন ফেলে দেবে। এটি স্থির করতে এবং MIN কে নেতিবাচক হতে দেয়, নীচের কোডটি ব্যবহার করুন।

অন্যান্য দুটি লাইনের মধ্যে এই লাইনটি (সাহসীভাবে) যুক্ত করুন:

newVal = newVal.substring (0, dstart) + Source.toString () + newVal.substring (dstart, newVal.length ());

যদি (newVal.equalsIgnoreCase ("-") && মিনিট <0) নাল;

int ইনপুট = পূর্ণসংখ্যা.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 "";
}

5

আপনার যদি -90: 90 এর মতো নেতিবাচক সংখ্যার সাথে পরিসীমা প্রয়োজন হয় তবে আপনি এই সমাধানটি ব্যবহার করতে পারেন।

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

আমি @ প্রতীক শর্মার কোডটি প্রসারিতের পরিবর্তে বিগডিসিমাল অবজেক্টগুলি ব্যবহার করার জন্য প্রসারিত করেছি যাতে এটি বৃহত্তর সংখ্যা গ্রহণ করতে পারে এবং এডিটেক্সটে এমন কোনও বিন্যাসের জন্য অ্যাকাউন্ট করে যা মুদ্রার বিন্যাসকরণ যেমন শূন্যস্থান, কমা এবং সময়সীমার মতো)

সম্পাদনা: নোট করুন যে এই বাস্তবায়নের বিগডিসিমালে ন্যূনতম উল্লেখযোগ্য পরিসংখ্যান হিসাবে 2 রয়েছে (যেমন MIN_SIG_FIG ধ্রুবকটি দেখুন) আমি মুদ্রার জন্য এটি ব্যবহার করেছি, সুতরাং দশমিক পয়েন্টের আগে সর্বদা 2 টি শীর্ষস্থানীয় ছিল। আপনার নিজের প্রয়োগের জন্য প্রয়োজনীয় হিসাবে MIN_SIG_FIG ধ্রুবকটি পরিবর্তন করুন।

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;
}

4

আমি আমার নিজের উত্তর খুঁজে পেয়েছি। এখন অনেক দেরি হয়ে গেছে তবে আমি এটি আপনার সাথে ভাগ করে নিতে চাই। আমি এই ইন্টারফেস বাস্তবায়ন:

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;
    }

}

এবং তারপরে এটি আপনার ক্রিয়াকলাপের মধ্যে এভাবে বাস্তবায়ন করুন:

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();
            }
        }
    });
}

এটি একটি খুব সহজ উত্তর, আরও ভাল যদি আমাকে বলুন।


int n = 0; অপ্রয়োজনীয়। যেহেতু n এর ডিফল্ট মান 0 হয়
কেনি ডাবিরি

1
এখানে কেন এনটি = 0 অপ্রয়োজনীয়? এটি একটি স্থানীয় পরিবর্তনশীল এবং উদাহরণ ভেরিয়েবল এখানে নয়।
ব্যবহারকারী 12111111

4

গৃহীত উত্তরে কিছু ভুল আছে।

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

যদি আমি কার্সারটিকে পাঠ্যের মাঝখানে সরিয়ে নিয়ে যাই, তবে কিছু টাইপ করুন, তবে উপরের বিবৃতিটি ভুল ফল দেবে। উদাহরণস্বরূপ, প্রথমে "12" টাইপ করুন, তারপরে 1 এবং 2 এর মধ্যে "0" টাইপ করুন, তারপরে উপরে বর্ণিত বিবৃতিটি 102 এর পরিবর্তে "120" উত্পাদন করবে will আমি এই বিবৃতিটি নীচের বিবৃতিগুলিতে পরিবর্তন করেছি:

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

4

কোটলিন যদি কারও এটির প্রয়োজন হয় (ইউটিলিটিগুলি ব্যবহার করুন)

class InputFilterMinMax: InputFilter {
    private var min:Int = 0
    private var max:Int = 0
    constructor(min:Int, max:Int) {
        this.min = min
        this.max = max
    }
    constructor(min:String, max:String) {
        this.min = Integer.parseInt(min)
        this.max = Integer.parseInt(max)
    }
    override fun filter(source:CharSequence, start:Int, end:Int, dest: Spanned, dstart:Int, dend:Int): CharSequence? {
        try
        {
            val input = Integer.parseInt(dest.toString() + source.toString())
            if (isInRange(min, max, input))
                return null
        }
        catch (nfe:NumberFormatException) {}
        return ""
    }
    private fun isInRange(a:Int, b:Int, c:Int):Boolean {
        return if (b > a) c in a..b else c in b..a
    }
}

তারপরে আপনার কোটলিন ক্লাস থেকে এটি ব্যবহার করুন

percentage_edit_text.filters = arrayOf(Utilities.InputFilterMinMax(1, 100))

এই এডিটেক্সটটি 1 থেকে 100 পর্যন্ত অনুমতি দেয়।

তারপরে আপনার এক্সএমএল থেকে এটি ব্যবহার করুন

android:inputType="number"

আমি ফেরত উৎস এবং কাজ ব্যবহার আমার জন্য ==> থাকেন (isInRange (কমপক্ষে, সর্বোচ্চ, ইনপুট)) আগমন উৎস
Muzafferus

3

আমি একটি সম্পাদনা পাঠ্য প্রতি মিনিট / সর্বোচ্চ সেট করতে একটি সহজ উপায় তৈরি করেছি। আমি পাটিগণিত কীপ্যাড ব্যবহার করি এবং আমি এই পদ্ধতিটি নিয়ে কাজ করি:

 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());
    }
 }

পদ্ধতিটি আপনার সমস্ত মানগুলিকে গ্রহণ করে তবে ব্যবহারকারীদের কোনও মান যদি আপনার সীমা অনুসরণ করে না তবে এটি ন্যূনতম / সর্বোচ্চ সীমাতে স্বয়ংক্রিয়ভাবে সেট হয়ে যাবে। প্রাক্তন জন্য। সীমাবদ্ধতা = 10, লিমাক্স = 80 ব্যবহারকারী যদি 8 টি সেট করে, স্বয়ংক্রিয়ভাবে 10 একটি ভেরিয়েবলে সংরক্ষণ করা হয় এবং সম্পাদনা পাঠ 10 তে সেট করা থাকে।


3

আমি জানি যে এর একটি মিলিয়ন উত্তর ইতিমধ্যে গ্রহণ করা আছে। যাইহোক, গৃহীত উত্তরে অসংখ্য বাগ রয়েছে এবং সমস্ত সম্ভাব্য ব্যবহারের ক্ষেত্রে প্রসারিত না করেই বাকিগুলির বেশিরভাগই কেবল তার মধ্যে একটি (বা দুটি) ঠিক করতে পারেন।

সুতরাং আমি মূলত সমর্থন উত্তরগুলিতে প্রস্তাবিত বেশিরভাগ বাগ ফিক্সগুলি সংকলন করার পাশাপাশি 0 এর দিকে সীমার বাইরে সংখ্যার একটানা ইনপুটকে অনুমতি দেওয়ার জন্য একটি পদ্ধতি যুক্ত করে (যদি রেঞ্জটি 0 থেকে শুরু না হয়) তবে কমপক্ষে এটি না হওয়া পর্যন্ত নিশ্চিত যে এটি আর সীমাতে থাকতে পারে না। পরিষ্কার হওয়ার কারণ, এটি কেবলমাত্র অন্যান্য সময়গুলির সমাধানের সাথেই সমস্যা সৃষ্টি করে।

এখানে ঠিক আছে:

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("");
        }
    }

}

নোট করুন যে কিছু ইনপুট কেসগুলি "সক্রিয়ভাবে" পরিচালনা করা অসম্ভব (যেমন, ব্যবহারকারী এটি আউটপুট দিচ্ছে), তাই ব্যবহারকারীকে পাঠ্য সম্পাদনা করার পরে আমাদের তাদের অবশ্যই এড়ানো এবং সেগুলি পরিচালনা করতে হবে।

আপনি এটি কীভাবে ব্যবহার করতে পারেন তা এখানে:

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);

এখন, ব্যবহারকারী যখন পরিসরের অনুমতি চেয়ে 0 এর কাছাকাছি একটি সংখ্যা টাইপ করার চেষ্টা করবে, তখন দুটি জিনিসের একটি ঘটবে:

  1. যদি minএবংmax একই সংখ্যার সংখ্যা থাকে তবে তারা চূড়ান্ত অঙ্কটিতে পৌঁছানোর পরে একে একে ইনপুট করার অনুমতি পাবে না।

  2. পাঠ্যটি ফোকাস হারিয়ে ফেললে যদি ক্ষেত্রের মধ্যে যদি রেঞ্জের বাইরের একটি নম্বর ছেড়ে যায় তবে এটি স্বয়ংক্রিয়ভাবে নিকটতম সীমানায় সামঞ্জস্য হবে।

এবং অবশ্যই, ব্যবহারকারীর দ্বারা পরিসীমা অনুমতি দেয় না তার চেয়ে বেশি 0 থেকে একটি মান ইনপুট করার অনুমতি দেওয়া হবে না এবং এই জাতীয় সংখ্যার পক্ষে "দুর্ঘটনাক্রমে" এই কারণে পাঠ্য ক্ষেত্রে থাকতে পারে না।

জ্ঞাত সমস্যা?)

  1. এটি কেবল EditTextতখনই কার্যকর হয় যখন ব্যবহারকারীর সাথে এটি করা হয়ে গেলে ফোকাস হারায়।

অন্য বিকল্পটি স্যানিটাইজিং হয় যখন ব্যবহারকারী "সম্পন্ন" / রিটার্ন কীটি হিট করে তবে অনেক বা এমনকি বেশিরভাগ ক্ষেত্রেই এটি ফোকাস হ্রাস করে causes

তবে নরম কীবোর্ড বন্ধ করা স্বয়ংক্রিয়ভাবে উপাদানটিকে আন-ফোকাস করবে না । আমি নিশ্চিত যে ৯৯.৯৯% অ্যান্ড্রয়েড বিকাশকারী এটি করতে চান (এবং যে EditTextউপাদানগুলিতে ফোকাস পরিচালনা করা সাধারণভাবে একটি চৌম্বক কম ছিল) তবে এখনও এর জন্য কোনও অন্তর্নির্মিত কার্যকারিতা নেই। এটির সন্ধান করার জন্য আমি সবচেয়ে সহজ পদ্ধতিটি খুঁজে পেয়েছি, যদি আপনার প্রয়োজন হয় তবে তা EditTextএই জাতীয় কিছু প্রসারিত করুন :

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);
    }
}

এটি ফিল্টারটিকে "চালিত করে" ইনপুটটিকে স্বাস্থ্যকরকরণে সক্রিয় করবে যদিও ভিউ আসলে ফোকাসটি হারিয়েছে না । পরে যদি দৃষ্টিভঙ্গিটি তার নিজের মনোযোগ হারিয়ে ফেলতে পারে তবে ইনপুট স্যানিটেশন আবার ট্রিগার করবে, তবে এটি ইতিমধ্যে ঠিক হয়ে যাওয়ার পরে কিছুই পরিবর্তন হবে না।

বন্ধ

রক্ষে। এটা অনেক ছিল। মূলত যা দেখে মনে হচ্ছিল এটি একটি খুব তুচ্ছ সহজ সমস্যা ভ্যানিলা অ্যান্ড্রয়েডের কিছুটা কুরুচিপূর্ণ টুকরো উন্মুক্ত করে (অন্তত জাভাতে)। এবং আবারও, আপনাকে কেবল শ্রোতা যুক্ত করতে হবে এবং প্রসারিত করতে হবে EditTextযদি আপনার পরিসরটি কোনও উপায়ে 0 টি অন্তর্ভুক্ত না করে। (এবং বাস্তববাদী, যদি আপনার পরিসীমা 0 টি অন্তর্ভুক্ত না করে তবে 1 বা -1 থেকে শুরু হয় তবে আপনি সমস্যাগুলির মধ্যেও পড়বেন না))

একটি সর্বশেষ নোট হিসাবে, এটি কেবল ints জন্য কাজ করে । দশমিক ( double, float) দিয়ে কাজ করার জন্য এটি অবশ্যই বাস্তবায়নের একটি উপায় রয়েছে তবে যেহেতু আমার বা মূল জিজ্ঞাসাকারীর কোনওটির প্রয়োজন নেই, তাই আমি বিশেষভাবে এটি সমস্ত গভীরভাবে পেতে চাই না। নিম্নলিখিত লাইনগুলির সাথে কেবল সমাপ্তির পরবর্তী ফিল্টারিংটি ব্যবহার করা খুব সহজ হবে:

// 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;

আপনি শুধুমাত্র পরিবর্তিত করতে হবে intকরতে float(বা double), একটি একক ঢোকানোর অনুমতি .(অথবা ,, দেশের উপর নির্ভর করে?), এবং একটি পরিবর্তে দশমিক ধরনের এক হিসাবে পার্স int

এটি বেশিরভাগ কাজ পরিচালনা করে যাইহোক, তাই এটি খুব একইভাবে কাজ করবে would


2
@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

কোটলিনের উপর খুব সাধারণ উদাহরণ:

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) {
        ""
    }
}

1

দয়া করে এই কোডটি পরীক্ষা করুন

    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 
  }

এডিটেক্সট এবং পাঠ্য প্রহরী সহ সম্পাদনা ফিল্টারগুলি সম্পর্কে আরও তথ্যের জন্য নীচের লিঙ্কটি ব্যবহার করুন ..

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


ওপি মান প্রবেশ করার সময় এটিটি বৈধ করতে চায়। আমি মনে করি আপনি মানটি প্রবেশের পরে দৃশ্যের সমাধান দিয়েছেন
MysticMagicag

আমি প্রশ্নকর্তা নই। আপনার উত্তর সম্পর্কে আমার কেবল সন্দেহ ছিল, তাই আমি এটি স্পষ্ট করে বলছিলাম।
মাইস্টিক ম্যাজিকϡ

আমি চরিত্রের গণনা যাচাই করতে চাই না। আমি মনে করি আপনি এই কোডটিতে গণনাটি যাচাই করার চেষ্টা করছেন: যদি (TextUtils.isEmpty (পাস) || Pass.length <[আপনার MIN দৈর্ঘ্য]) আমি কেবলমাত্র মাসের মানের জন্য মূল্য সীমাবদ্ধ করি ব্যবহারকারীকে অবশ্যই মানটির মধ্যে লিখতে হবে 1-12 নয় 13,14, বা ইত্যাদি। সুতরাং, 12,13,14, 99 অবধি 2 চরিত্রের দৈর্ঘ্য।
Mertaydin

হাই @মারতায়দিন আপনি যে লিঙ্কটি দিয়েছিলেন তা দিয়ে আপনি কি চেষ্টা করেছিলেন .. উদাহরণটি দেখুন .. আপনি যা চান তা হতে পারে। আপনি প্রবেশ করার সময় এটি পাঠ্যটি দেখবে ..
#rajesh4uguys

ঠিক আছে ধন্যবাদ, আমি আপনার উত্তর এবং @ প্রতীক শর্মার উত্তর চেষ্টা করব।
মেরটায়দিন

1

আপনি যদি সর্বাধিক সীমা সম্পর্কে উদ্বিগ্ন হন তবে কেবল নীচে লাইনটি যুক্ত করুন

android:maxLength="10" 

যদি আপনাকে ন্যূনতম সীমা যুক্ত করতে হয় তবে আপনি এই ক্ষেত্রে মিনিট সীমাটি 7 এর মতো করতে পারেন like ব্যবহারকারী ন্যূনতম এবং সর্বাধিক সীমাতে (8 থেকে 10 এর মধ্যে) অক্ষর প্রবেশ করতে সীমাবদ্ধ is

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();
        }
    }

আপনার যদি শুরুতে 01 প্রবেশ করানোর জন্য ব্যবহারকারীকেও সীমাবদ্ধ করতে হয় তবে শর্তটি যদি এইভাবে হয় তবে সংশোধন করুন

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

শেষে কল পদ্ধতিটি পছন্দ করুন

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

2
এটি মূল্য নয়, দৈর্ঘ্য
পোর্টফোলিওবিল্ডার

1

@ প্রতীক শর্মা

সমর্থন নেতিবাচক সংখ্যাগুলির জন্য , ফিল্টার পদ্ধতির মধ্যে নিম্নলিখিত কোড যুক্ত করুন :

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;
  }

}

তারপরে আপনার ক্রিয়াকলাপ থেকে এটি ব্যবহার করুন:

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

আপনার সম্পাদনাটি এর সাথে সেট করুন:

android:inputType="number|numberSigned"

0

// এখনও কিছু সমস্যা আছে তবে এখানে আপনি কোনও পরিসরে ন্যূনতম, সর্বোচ্চ ব্যবহার করতে পারেন (ইতিবাচক বা নেতিবাচক)

// 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

প্রতীকের উত্তরে যোগ করতে এখানে একটি পরিবর্তিত সংস্করণ দেওয়া হয়েছে যেখানে ব্যবহারকারী কমপক্ষে 2 টি সংখ্যাও প্রবেশ করতে পারে, উদাহরণস্বরূপ, 15 থেকে 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;
    }}

যুক্ত: যদি (শেষ == 1) মিনিট = পূর্ণসংখ্যা.parseInt (উত্স। টোস্ট্রিং ());

আশাকরি এটা সাহায্য করবে. বিনা কারণে বিনা কারণে downvote না।


0

আমি এখানে যেভাবে ব্যবহার করেছি এটি নেতিবাচক সংখ্যার জন্য কাজ করছে

প্রথমে নিম্নলিখিত কোড সহ MinMaxFIlter.java ক্লাস তৈরি করুন:

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;
    }
}
}

তারপরে আপনার এডিটেক্সটগুলিতে আপনার ফিল্টারটি তৈরি করুন এবং সেট করুন:

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

এটি আমার কোড সর্বাধিক = 100, মিনিট = 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" />

জাভা

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

আপনি ইনপুটফিল্টার দিয়ে এটি করতে পারেন। সম্ভবত আপনি কেবলমাত্র এই ইনপুট ফিল্টার ইন্টারফেসটি ব্যবহার করতে পারেন। আপনি বিরক্তিকর উপায়ে এটি করার আগে একটি নতুন ক্লাস তৈরি করুন যা ইনপুট ফিল্টারকে প্রসারিত করে, আপনি এই শর্টকাটটিকে একটি অভ্যন্তরক্লাস ইন্টারফেস ইনস্ট্যান্টেশন দিয়ে ব্যবহার করতে পারেন।

অতএব আপনি কেবল এটি করুন:

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+"";

                    }
                }
        });

এই উদাহরণে আমি এডিটেক্সটটির মান 8 এর চেয়ে বেশি কিনা তা যাচাই করে নিই তবে এটি 8 এ সেট করা হবে না ap সুতরাং আপত্তিজনকভাবে আপনাকে নিজের দ্বারা ন্যূনতম সর্বাধিক বা ফিল্টার যুক্তির সাথে যুক্ত হওয়া উচিত। তবে কমপক্ষে আপনি সরাসরি এডিট টেক্সটে ফিল্টার লজিকটি বেশ ঝরঝরে এবং সংক্ষিপ্ত লিখতে পারেন।

আশাকরি এটা সাহায্য করবে


0

এডিট টেক্সটের সর্বনিম্ন মান নির্ধারণ করতে, আমি এটি ব্যবহার করেছি:

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

0

@ প্যাট্রিকের কোডটিতে একটি দুর্দান্ত ধারণা রয়েছে তবে প্রচুর বাগ রয়েছে। @ জ্যাক এবং @ অ্যান্থনি বি (নেতিবাচক সংখ্যা সমাধান) এর কয়েকটি সমাধান করেছে, তবে @ জ্যাকের কোডটিতে এখনও 3 জন মেয়র বাগ রয়েছে:

১. ব্যবহারকারী যদি এডিট টেক্সটে সমস্ত এন্ট্রি মুছে ফেলেন তবে আবার কোনও সংখ্যা টাইপ করা অসম্ভব .. অবশ্যই প্রতিটি ক্ষেত্রে এটি সম্পাদনা পাঠ্য পরিবর্তিত শ্রোতার সাহায্যে নিয়ন্ত্রণ করা যেতে পারে তবে এটি প্রতিটি জন্য একটি সাধারণ ইনপুটফিলার শ্রেণি ব্যবহারের সৌন্দর্য মুছে ফেলবে 1. আপনার অ্যাপ্লিকেশন এডিটেক্সট।

2। @ গের্নি says বলেছে যে উদাহরণস্বরূপ ন্যূনতম = ৩, 1 দিয়ে শুরু করে কোনও সংখ্যা টাইপ করা অসম্ভব।

৩. উদাহরণস্বরূপ যদি মিনিট = ০, আপনি টাইপ করতে পারেন আপনার ইচ্ছামত অনেক শূন্য, এটি ফলাফলটি মার্জিত নয়। বা এছাড়াও, ন্যূনতম মানটি নির্বিশেষে, ব্যবহারকারী প্রথম সংখ্যার বাম আকারে কার্সারটি রাখতে পারেন, এটি একটি স্থান বাম দিকে জিরোগুলির একগুচ্ছ, মার্জিতও নয়।

আমি এই 3 বাগটি সমাধান করার জন্য @ জ্যাকের কোডের এই সামান্য পরিবর্তনগুলি সাদা করে তুলেছি। বাগ # 3 সম্পর্কিত, আমি এখনও বাম দিকের সমস্ত নেতৃস্থানীয় শূন্যগুলি পুরোপুরি সরাতে সক্ষম হইনি; এটি সর্বদা এক হতে পারে তবে 00, 01, 0100 ইত্যাদি ক্ষেত্রে এটি আরও মার্জিত একটি বৈধ যা একটি 000000, 001, 000100, ইত্যাদি et প্রভৃতি

কোডটি এখানে:

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

            // Using @Zac's initial solution
            String lastVal = dest.toString().substring(0, dstart) + dest.toString().substring(dend);
            String newVal = lastVal.substring(0, dstart) + source.toString() + lastVal.substring(dstart);
            int input = Integer.parseInt(newVal);

            // To avoid deleting all numbers and avoid @Guerneen4's case
            if (input < min && lastVal.equals("")) return String.valueOf(min);

            // Normal min, max check
            if (isInRange(min, max, input)) {

                // To avoid more than two leading zeros to the left
                String lastDest = dest.toString();
                String checkStr = lastDest.replaceFirst("^0+(?!$)", "");
                if (checkStr.length() < lastDest.length()) return "";

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

আপনার দিনটি শুভ হোক!


-1

প্রতীক শর্মার উত্তরটি গ্রহণ করা Kotlinএবং কারও Doubleযদি এটির প্রয়োজন হয় তবে তা এখানে রইলাম

class InputFilterMinMax : InputFilter {

private var min: Double = MIN_LIMIT
private var max: Double = MIN_LIMIT

constructor(min: Int, max: Int) {
    this.min = min.toDouble()
    this.max = max.toDouble()
}

constructor(min: String, max: String) {
    this.min = min.toDouble()
    this.max = max.toDouble()
}

constructor(min: Double, max: Double) {
    this.min = min
    this.max = max
}

override fun filter(
    source: CharSequence,
    start: Int,
    end: Int,
    dest: Spanned,
    dstart: Int,
    dend: Int
): CharSequence? {
    try {
        val input = (dest.toString() + source.toString()).toDouble()
        if (isInRange(min, max, input))
            return null
    } catch (nfe: NumberFormatException) {
        Timber.e(nfe)
    }

    return ""
}

private fun isInRange(a: Double, b: Double, c: Double): Boolean {
    return if (b > a) c in a..b else c in b..a
}
}

এই ইনপুট ফিল্টারকে ভুল, এটা উপেক্ষা করে শুরু, শেষ, dstart, লেখার dend সূচকের, তাই এটি সঠিকভাবে কাজ করবে না যদি আপনি মাঝখানে একটি অক্ষর সন্নিবেশ করার মাধ্যেমে পাঠ্য সম্পাদনা করুন পরিবর্তন
Radu
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.