Handling User Input

<EditText
    android:id="@+id/editText"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:text="Initial text"
    android:hint="Enter your name"
    android:inputType="text"
    android:maxLength="50"/>

val editText = findViewById<EditText>(R.id.editText)
val userInput = editText.text.toString()

val editText = findViewById<EditText>(R.id.editText)
editText.setText("New text")

class MyTextWatcher : TextWatcher {
    override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {
        // Prepare for text change
    }

    override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {
        // Handle text change in real-time
    }

    override fun afterTextChanged(s: Editable?) {
        // Handle text change after it's applied
    }
}

val editText = findViewById<EditText>(R.id.editText)
editText.addTextChangedListener(MyTextWatcher())

fun validateEmail(email: String): Boolean {
    val emailRegex = Regex("^[A-Za-z0-9+_.-]+@([A-Za-z0-9.-]+\\.[A-Za-z]{2,})$")
    return emailRegex.matches(email)
}

fun validatePhone(phone: String): Boolean {
    val phoneRegex = Regex("^\\+?[1-9]\\d{1,14}$")
    return phoneRegex.matches(phone)
}

fun validateAge(age: String): Boolean {
    return age.toIntOrNull() != null && age.toInt() in 1..120
}

val editText = findViewById<EditText>(R.id.editText)
editText.imeOptions = EditorInfo.IME_ACTION_DONE
editText.inputType = InputType.TYPE_CLASS_TEXT

val checkBox = CheckBox(context)
checkBox.text = "Accept Terms"
checkBox.isChecked = false
checkBox.setOnCheckedChangeListener { _, isChecked ->
    if (isChecked) {
        // Handle checked state
    } else {
        // Handle unchecked state
    }
}

val radioButton = RadioButton(context)
radioButton.text = "Option 1"
radioButton.isChecked = false
radioButton.setOnCheckedChangeListener { _, isChecked ->
    if (isChecked) {
        // Handle selection
    }
}

<Spinner
    android:id="@+id/spinner"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:entries="@array/choices"
    android:prompt="@string/spinner_prompt" />

val choices = arrayOf("Option 1", "Option 2", "Option 3")
val adapter = ArrayAdapter(this, android.R.layout.simple_spinner_item, choices)
adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item)
spinner.adapter = adapter

val datePicker = DatePickerDialog(this, { _, year, month, dayOfMonth ->
    // Handle date selection
    val selectedDate = "$year-${month + 1}-$dayOfMonth"
}, 2024, 5, 15)

datePicker.show()

val timePicker = TimePickerDialog(this, { _, hourOfDay, minute ->
    // Handle time selection
    val selectedTime = "$hourOfDay:$minute"
}, 14, 30, true)

timePicker.show()

val seekBar = findViewById<SeekBar>(R.id.seekBar)
seekBar.max = 100
seekBar.setOnSeekBarChangeListener(object : SeekBar.OnSeekBarChangeListener {
    override fun onProgressChanged(seekBar: SeekBar?, progress: Int, fromUser: Boolean) {
        Log.d("SeekBar", "Progress: $progress")
    }

    override fun onStartTrackingTouch(seekBar: SeekBar?) {}

    override fun onStopTrackingTouch(seekBar: SeekBar?) {}
})

val slider = findViewById<Slider>(R.id.slider)
slider.valueFrom = 0f
slider.valueTo = 100f
slider.stepSize = 1f
slider.thumbDrawable = ContextCompat.getDrawable(this, R.drawable.custom_thumb)

class MainActivity : AppCompatActivity() {
    override fun onTouchEvent(event: MotionEvent): Boolean {
        when (event.action) {
            MotionEvent.ACTION_DOWN -> {
                // Handle touch start
                Log.d("Touch", "Down at (${event.x}, ${event.y})")
            }
            MotionEvent.ACTION_MOVE -> {
                // Handle touch movement
                Log.d("Touch", "Moving to (${event.x}, ${event.y})")
            }
            MotionEvent.ACTION_UP -> {
                // Handle touch end
                Log.d("Touch", "Up at (${event.x}, ${event.y})")
            }
        }
        return true
    }
}

class SwipeDetector(private val listener: OnSwipeListener) : View.OnTouchListener {
    private var startX = 0f
    private var startY = 0f

    override fun onTouch(v: View?, event: MotionEvent?): Boolean {
        when (event?.action) {
            MotionEvent.ACTION_DOWN -> {
                startX = event.x
                startY = event.y
            }
            MotionEvent.ACTION_UP -> {
                val endX = event.x
                val endY = event.y
                val deltaX = endX - startX
                val deltaY = endY - startY

                if (abs(deltaX) > abs(deltaY)) {
                    if (deltaX > 50) listener.onSwipeRight()
                    else if (deltaX < -50) listener.onSwipeLeft()
                } else {
                    if (deltaY > 50) listener.onSwipeDown()
                    else if (deltaY < -50) listener.onSwipeUp()
                }
            }
        }
        return true
    }

    interface OnSwipeListener {
        fun onSwipeLeft()
        fun onSwipeRight()
        fun onSwipeUp()
        fun onSwipeDown()
    }
}

class SwipeGestureDetector : GestureDetector.SimpleOnGestureListener() {
    private val SWIPE_THRESHOLD = 100
    private val SWIPE_VELOCITY_THRESHOLD = 100

    override fun onFling(
        e1: MotionEvent,
        e2: MotionEvent,
        velocityX: Float,
        velocityY: Float
    ): Boolean {
        val diffX = e2.x - e1.x
        val diffY = e2.y - e1.y

        if (abs(diffX) > SWIPE_THRESHOLD && abs(velocityX) > SWIPE_VELOCITY_THRESHOLD) {
            if (diffX > 0) {
                // Swipe right
            } else {
                // Swipe left
            }
            return true
        }
        return false
    }
}

class ZoomableImageView : ImageView() {
    private val scaleDetector = ScaleGestureDetector(context, ScaleListener())

    override fun onTouchEvent(event: MotionEvent): Boolean {
        scaleDetector.onTouchEvent(event)
        return true
    }

    private inner class ScaleListener : ScaleGestureDetector.SimpleOnScaleGestureListener() {
        override fun onScale(detector: ScaleGestureDetector): Boolean {
            val scale = detector.scaleFactor
            // Apply zoom transformation to the view
            scaleX *= scale
            scaleY *= scale
            return true
        }
    }
}