कोटलिन में केवल वर्णमाला स्वीकार करने वाला EditText कैसे बनाएं?

कोटलिन में केवल अक्षर स्वीकार करने वाला EditText

यह उदाहरण दर्शाता है कि InputFilter का उपयोग करके EditText को केवल वर्णमाला अक्षरों (A-Z, a-z, हिंदी अक्षर) तक सीमित कैसे किया जाए।

चरण 1: नया प्रोजेक्ट बनाएं

एंड्रॉइड स्टूडियो में File → New Project चुनें।

चरण 2: लेआउट (activity_main.xml)

<?xml version="1.0" encoding="utf-8"?> 
<RelativeLayout xmlns:android="https://schemas.android.com/apk/res/android"
    xmlns:tools="https://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:padding="16dp"
    tools:context=".MainActivity"> 
    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_centerHorizontal="true"
        android:layout_marginTop="50dp"
        android:text="Tutorials Point"
        android:textAlignment="center"
        android:textColor="@android:color/holo_green_dark"
        android:textSize="32sp"
        android:textStyle="bold" /> 
    <EditText
        android:id="@+id/editTextAlpha"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_centerInParent="true"
        android:hint="केवल अक्षर दर्ज करें"
        android:inputType="textCapWords|textNoSuggestions"
        android:padding="16dp"
        android:textSize="18sp" /> 
    <TextView
        android:id="@+id/textViewStatus"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_below="@id/editTextAlpha"
        android:layout_centerHorizontal="true"
        android:layout_marginTop="16dp"
        android:text="स्थिति: प्रतीक्षा 중..."
        android:textSize="16sp" /> 
</RelativeLayout>

चरण 3: MainActivity.kt

import android.os.Bundle
import android.text.InputFilter
import android.text.Spanned
import android.widget.EditText
import android.widget.TextView
import androidx.appcompat.app.AppCompatActivity

class MainActivity : AppCompatActivity() {
    private lateinit var editTextAlpha: EditText
    private lateinit var textViewStatus: TextView
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        title = "KotlinApp"
        
        editTextAlpha = findViewById(R.id.editTextAlpha)
        textViewStatus = findViewById(R.id.textViewStatus)
        
        // केवल अक्षर फिल्टर सेट करें
        editTextAlpha.filters = arrayOf(AlphaOnlyInputFilter())
        
        // टेक्स्ट परिवर्तन सुनें
        editTextAlpha.addTextChangedListener(object : TextWatcher {
            override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {}
            override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {}
            override fun afterTextChanged(s: Editable?) {
                textViewStatus.text = "स्थिति: मान्य इनपुट (${s?.length ?: 0} अक्षर)"
                textViewStatus.setTextColor(
                    if (s?.isNotEmpty() == true) 
                        android.graphics.Color.GREEN 
                    else 
                        android.graphics.Color.RED
                )
            }
        })
    }
    
    // कस्टम InputFilter केवल अक्षरों के लिए
    private class AlphaOnlyInputFilter : InputFilter {
        // अंग्रेजी + हिंदी + स्पेस + बैकस्पेस की अनुमति
        private val allowedPattern = "[a-zA-Z\\u0900-\\u097F\\s]".toRegex()
        
        override fun filter(
            source: CharSequence?,
            start: Int,
            end: Int,
            dest: Spanned?,
            dstart: Int,
            dend: Int
        ): CharSequence? {
            val input = source.subSequence(start, end).toString()
            
            // खाली इनपुट (डिलीट) की अनुमति दें
            if (input.isEmpty()) return null
            
            // प्रत्येक अक्षर की जांच करें
            for (i in input.indices) {
                val char = input[i].toString()
                if (!allowedPattern.matches(char)) {
                    // अमान्य अक्षर - इसे ब्लॉक करें (खाली स्ट्रिंग लौटाएं)
                    return ""
                }
            }
            
            // सभी अक्षर मान्य हैं - मूल इनपुट लौटाएं
            return null
        }
    }
}

चरण 4: XML में सरल समाधान (android:digits)

सरल मामलों के लिए, XML में ही प्रतिबंधित करें:

<EditText
    android:id="@+id/editTextSimple"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:digits="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ "
    android:hint="केवल अंग्रेजी अक्षर और स्पेस" />

चरण 5: AndroidManifest.xml

<?xml version="1.0" encoding="utf-8"?> 
<manifest xmlns:android="https://schemas.android.com/apk/res/android" 
    package="com.example.alphabetedittext"> 
    <application 
        android:allowBackup="true" 
        android:icon="@mipmap/ic_launcher" 
        android:label="@string/app_name" 
        android:roundIcon="@mipmap/ic_launcher_round" 
        android:supportsRtl="true" 
        android:theme="@style/AppTheme"> 
        <activity android:name=".MainActivity"> 
            <intent-filter> 
                <action android:name="android.intent.action.MAIN" /> 
                <category android:name="android.intent.category.LAUNCHER" /> 
            </intent-filter> 
        </activity> 
    </application> 
</manifest>

उन्नत: पुन: प्रयोज्य एक्सटेंशन फ़ंक्शन

import android.text.InputFilter
import android.text.Spanned
import android.widget.EditText
import java.util.regex.Pattern

// पुन: प्रयोज्य फिल्टर बिल्डर
fun InputFilterBuilder(pattern: String, errorMessage: String = "अमान्य अक्षर"): InputFilter {
    val regex = Pattern.compile(pattern)
    return InputFilter { source, start, end, dest, dstart, dend ->
        val input = source.subSequence(start, end).toString()
        if (input.isEmpty()) return@InputFilter null
        
        return@InputFilter if (regex.matcher(input).matches()) null else ""
    }
}

// EditText एक्सटेंशन
fun EditText.setAlphaOnlyFilter(
    allowHindi: Boolean = true,
    allowSpaces: Boolean = true,
    allowHyphen: Boolean = false
) {
    val pattern = buildString {
        append("[").append("a-zA-Z")
        if (allowHindi) append("\\u0900-\\u097F") // देवनागरी रेंज
        if (allowSpaces) append("\\s")
        if (allowHyphen) append("-")
        append("]")
    }
    
    this.filters = arrayOf(InputFilterBuilder(pattern))
}

// उपयोग:
editText.setAlphaOnlyFilter(allowHindi = true, allowSpaces = true)

अन्य उपयोगी InputFilter उदाहरण:

एकाधिक फिल्टर संयोजित करना:

editText.filters = arrayOf(
    InputFilter.LengthFilter(50),  // अधिकतम 50 अक्षर
    AlphaOnlyInputFilter()         // केवल अक्षर
)