Android Touch Event Basics — Understanding dispatchTouchEvent() and onTouchEvent()

Handling touch events is one of the most important aspects of building interactive Android UIs. Whether you’re implementing gestures, custom views, or advanced animations, understanding how touch events flow through the View hierarchy is essential.

In Android, two key methods control how touch events are distributed and handled:

• dispatchTouchEvent(MotionEvent event)
• onTouchEvent(MotionEvent event)

Let’s explore how they work and how Android decides which View actually handles your touch input.

---

The Touch Event Flow in Android

Every ViewGroup (including Activity, LinearLayout, RelativeLayout, etc.) has both:

• dispatchTouchEvent() — responsible for distributing the event.
• onTouchEvent() — responsible for handling the event.

The Android system delivers touch events top-down, starting from the Activity’s window, through its view hierarchy, and finally to the individual view under your finger.

---

Step-by-Step Touch Event Flow

1. Parent ViewGroup receives the event
   • When a user touches the screen, the event first reaches the root ViewGroup (e.g., the Activity’s decor view).
   • Its dispatchTouchEvent() method is called.
2. Parent calls child’s dispatchTouchEvent()
   • The parent ViewGroup checks if any child view should receive this touch event.
   • If the child is another ViewGroup, it calls the child’s dispatchTouchEvent().
   • If the child is a simple View (like a Button), it calls the child’s onTouchEvent() directly.
3. Event propagation decision
   • If a child consumes the event (returns true), it means “I handled it” — the event stops there.
   • If it returns false, the parent gets a chance to handle it in its own onTouchEvent().
4. If no one handles it
   • The event bubbles up until it reaches the Activity.
   • Finally, Activity.onTouchEvent() is called — the last stop for the event.

---

Analogy — Layers of Touch

Think of your app’s UI as stacked layers:

• The Activity sits at the bottom.
• Various layouts and views are stacked on top.
• When you touch the screen, the event starts from the top-most visible view and moves downward (child to parent) until a view decides to consume it.

---

Difference Between onClick() and onTouch()

Feature	onClick()	onTouch()
Trigger	Fires once when user taps and releases	Fires for every touch event (ACTION_DOWN, MOVE, UP, etc.)
Motion Details	Doesn’t provide movement info	Provides full touch coordinates and motion history
Event Object	None	MotionEvent
Use Case	Simple tap actions	Gestures, drag & drop, swipes, drawing, etc.

---

Example Touch Event Lifecycle

A single touch can include multiple actions:

Touch Event = [ACTION_DOWN → ACTION_MOVE(s) → ACTION_UP]

Each stage is represented by a MotionEvent object, which stores:

• x, y coordinates of the touch
• Event type (ACTION_DOWN, ACTION_MOVE, ACTION_UP)
• Number of pointers (for multi-touch)
• Timestamps, pressure, etc.

---

The Role of MotionEvent

MotionEvent carries all touch information.
You can access coordinates like this:

override fun onTouchEvent(event: MotionEvent): Boolean {
    when (event.action) {
        MotionEvent.ACTION_DOWN -> Log.d("Touch", "Finger down at (${event.x}, ${event.y})")
        MotionEvent.ACTION_MOVE -> Log.d("Touch", "Moved to (${event.x}, ${event.y})")
        MotionEvent.ACTION_UP -> Log.d("Touch", "Finger lifted")
    }
    return true
}

Returning true means the event is consumed — no further propagation happens.

---

Event Propagation Direction

There are two perspectives:

1. Top-down (Dispatch Phase):
   • Parent → Child → Leaf View
     Each view gets a chance to handle or pass the event.
2. Bottom-up (Bubbling Phase):
   • If no child consumes it, the event travels back up to the parent views and finally the Activity.

💡 Summary:

• Parent → Child: Dispatches event
• Child → Parent: Returns handling result (true/false)

---

Disabling Touch Events in an Activity

You can override dispatchTouchEvent() to block all touch inputs:

override fun dispatchTouchEvent(ev: MotionEvent?): Boolean {
    // Disable all touch events
    return false
    // Or call super to allow normal behavior
    // return super.dispatchTouchEvent(ev)
}

---

Key Method Order in Activity

1. First Called:
   dispatchTouchEvent(MotionEvent ev)
2. If No Child Consumes:
   onTouchEvent(MotionEvent event)

If none of the children handle the touch, the Activity itself gets a final opportunity through onTouchEvent().

---

Summary

Concept	Description
dispatchTouchEvent()	Distributes touch events to children
onTouchEvent()	Handles the event when received
MotionEvent	Contains detailed touch data
Propagation	Child to parent if unhandled
onClick() vs onTouch()	onTouch gives finer control with multiple motion stages

---

Reference

📘 Source: Understanding Android Input Touch Events – CodeTheory
📗 Official Docs: Android MotionEvent

---

Final Takeaway

“Every touch event in Android travels down the view hierarchy via dispatchTouchEvent() and bubbles back up via onTouchEvent() until it’s handled.”

Understanding this flow helps you build smoother gestures, responsive UIs, and custom touch-based experiences.

---