You can use the GestureDetector. See the following code:

public class MyView extends View { GestureDetector gestureDetector; public MyView(Context context, AttributeSet attrs) { super(context, attrs); // creating new gesture detector gestureDetector = new GestureDetector(context, new GestureListener()); } // skipping measure calculation and drawing // delegate the event to the gesture detector @Override public boolean onTouchEvent(MotionEvent e) { return gestureDetector.onTouchEvent(e); } private class GestureListener extends GestureDetector.SimpleOnGestureListener { @Override public boolean onDown(MotionEvent e) { return true; } // event when double tap occurs @Override public boolean onDoubleTap(MotionEvent e) { float x = e.getX(); float y = e.getY(); Log.d("Double Tap", "Tapped at: (" + x + "," + y + ")"); return true; } } } 

You can override other methods of the listener to get single taps, flinges and so on.

As a lightweight alternative to GestureDetector you can use this class

public abstract class DoubleClickListener implements OnClickListener { private static final long DOUBLE_CLICK_TIME_DELTA = 300;//milliseconds long lastClickTime = 0; @Override public void onClick(View v) { long clickTime = System.currentTimeMillis(); if (clickTime - lastClickTime < DOUBLE_CLICK_TIME_DELTA){ onDoubleClick(v); } else { onSingleClick(v); } lastClickTime = clickTime; } public abstract void onSingleClick(View v); public abstract void onDoubleClick(View v); } 

Example:

 view.setOnClickListener(new DoubleClickListener() { @Override public void onSingleClick(View v) { } @Override public void onDoubleClick(View v) { } }); 

combining "Bughi" "DoubleClickListner" and "Jayant Arora" Timer in one contained class:

public abstract class DoubleClickListener implements OnClickListener { private Timer timer = null; //at class level; private int DELAY = 400; private static final long DOUBLE_CLICK_TIME_DELTA = 300;//milliseconds long lastClickTime = 0; @Override public void onClick(View v) { long clickTime = System.currentTimeMillis(); if (clickTime - lastClickTime < DOUBLE_CLICK_TIME_DELTA){ processDoubleClickEvent(v); } else { processSingleClickEvent(v); } lastClickTime = clickTime; } public void processSingleClickEvent(final View v){ final Handler handler=new Handler(); final Runnable mRunnable=new Runnable(){ public void run(){ onSingleClick(v); //Do what ever u want on single click } }; TimerTask timertask=new TimerTask(){ @Override public void run(){ handler.post(mRunnable); } }; timer=new Timer(); timer.schedule(timertask,DELAY); } public void processDoubleClickEvent(View v){ if(timer!=null) { timer.cancel(); //Cancels Running Tasks or Waiting Tasks. timer.purge(); //Frees Memory by erasing cancelled Tasks. } onDoubleClick(v);//Do what ever u want on Double Click } public abstract void onSingleClick(View v); public abstract void onDoubleClick(View v); } 

and can be called as :

view.setOnClickListener(new DoubleClickListener() { @Override public void onSingleClick(View v) { } @Override public void onDoubleClick(View v) { } }); 

if you do not wish to go for custom view then you can use following approach. e.g. ImageView

// class level GestureDetector gestureDetector; boolean tapped; ImageView imageView; // inside onCreate of Activity or Fragment gestureDetector = new GestureDetector(context,new GestureListener()); 

//--------------------------------------------------------------------------------

public class GestureListener extends GestureDetector.SimpleOnGestureListener { @Override public boolean onDown(MotionEvent e) { return true; } // event when double tap occurs @Override public boolean onDoubleTap(MotionEvent e) { tapped = !tapped; if (tapped) { } else { } return true; } } 

//--------------------------------------------------------------------------------

for ImageView

imageView.setOnTouchListener(new OnTouchListener() { @Override public boolean onTouch(View v, MotionEvent event) { // TODO Auto-generated method stub return gestureDetector.onTouchEvent(event); } }); 

Double-tap and Single-tap

Double-tap only

It is quite easy to detect a double tap on a view by using SimpleOnGestureListener (as demonstrated in Hannes Niederhausen's answer).

private class GestureListener extends GestureDetector.SimpleOnGestureListener { @Override public boolean onDown(MotionEvent e) { return true; } @Override public boolean onDoubleTap(MotionEvent e) { return true; } } 

I can't see a big advantage to re-inventing the logic for this (like bughi's answer).

Double-tap and Single-tap with delay

You can also use the SimpleOnGestureListener to differentiate a single-tap and a double-tap as mutually exclusive events. To do that you just override onSingleTapConfirmed. This will delay running the single-tap code until the system is certain that the user hasn't double-tapped (ie, the delay > ViewConfiguration.getDoubleTapTimeout()). There is definately no reason to re-invent all the logic for that (as is done in this, this and other answers).

private class GestureListener extends GestureDetector.SimpleOnGestureListener { @Override public boolean onDown(MotionEvent e) { return true; } @Override public boolean onSingleTapConfirmed(MotionEvent e) { return true; } @Override public boolean onDoubleTap(MotionEvent e) { return true; } } 

Double-tap and Single-tap with no delay

The potential problem with onSingleTapConfirmed is the delay. Sometimes a noticeable delay is not acceptable. In that case you can replace onSingleTapConfirmed with onSingleTapUp.

private class GestureListener extends GestureDetector.SimpleOnGestureListener { @Override public boolean onDown(MotionEvent e) { return true; } @Override public boolean onSingleTapUp(MotionEvent e) { return true; } @Override public boolean onDoubleTap(MotionEvent e) { return true; } } 

You need to realize, though, that both onSingleTapUp and onDoubleTap will be called if there is a double-tap. (This is essentially what bughi's answer does and what some of the commenters were complaining about.) You either need to use the delay or call both methods. It's not possible have a single-tap with no delay and at the same time know whether the user is going to tap again.

If the single-tap delay is not acceptable for you then you have a couple options:

• Accept that both onSingleTapUp and onDoubleTap will be called for a double-tap. Just divide up your logic appropriately so that it doesn't matter. This is essentially what I did when I implemented a double-tap for caps-lock on a custom keyboard.

• Don't use a double-tap. It's not an intuitive UI action for most things. As Dave Webb suggests, a long press is probably better. You can also implement that with the SimpleOnGestureListener:

  private class GestureListener extends GestureDetector.SimpleOnGestureListener { @Override public boolean onDown(MotionEvent e) { return true; } @Override public boolean onSingleTapUp(MotionEvent e) { return true; } @Override public void onLongPress(MotionEvent e) { } } 

This is my solution, it uses default setOnItemClickListener(). I had the same task to implement. Soon I'll post example and custom class on my github. Brief explanation is given. I'm not sure if the time in milliseconds is right difference for the system (See ViewConfiguration.getDoubleTapTimeout() source) to decide between single and double tap.

Edit: See it here: https://github.com/NikolaDespotoski/DoubleTapListView or https://github.com/NikolaDespotoski/DoubleTapListViewHandler

GuestureDetecter Works Well on Most Devices, I would like to know how the time between two clicks can be customized on double click event, i wasn't able to do that. I updated the above code by "Bughi" "DoubleClickListner", added a timer using handler that executes a code after a specific delay on single click, and if double click is performed before that delay it cancels the timer and single click task and only execute double click task. Code is working Fine Makes it perfect to use as double click listner:

 private Timer timer = null; //at class level; private int DELAY = 500; view.setOnClickListener(new DoubleClickListener() { @Override public void onSingleClick(View v) { final Handler handler = new Handler(); final Runnable mRunnable = new Runnable() { public void run() { processSingleClickEvent(v); //Do what ever u want on single click } }; TimerTask timertask = new TimerTask() { @Override public void run() { handler.post(mRunnable); } }; timer = new Timer(); timer.schedule(timertask, DELAY); } @Override public void onDoubleClick(View v) { if(timer!=null) { timer.cancel(); //Cancels Running Tasks or Waiting Tasks. timer.purge(); //Frees Memory by erasing cancelled Tasks. } processDoubleClickEvent(v);//Do what ever u want on Double Click } }); 

boolean nonDoubleClick = true, singleClick = false; private long firstClickTime = 0L; private final int DOUBLE_CLICK_TIMEOUT = 200; listview.setOnItemClickListener(new OnItemClickListener() { @Override public void onItemClick(AdapterView<?> parent, View v, int pos, long id) { // TODO Auto-generated method stub Handler handler = new Handler(); handler.postDelayed(new Runnable() { @Override public void run() { // TODO Auto-generated method stub if (singleClick) { Toast.makeText(getApplicationContext(), "Single Tap Detected", Toast.LENGTH_SHORT).show(); } firstClickTime = 0L; nonDoubleClick = true; singleClick = false; } }, 200); if (firstClickTime == 0) { firstClickTime = SystemClock.elapsedRealtime(); nonDoubleClick = true; singleClick = true; } else { long deltaTime = SystemClock.elapsedRealtime() - firstClickTime; firstClickTime = 0; if (deltaTime < DOUBLE_CLICK_TIMEOUT) { nonDoubleClick = false; singleClick = false; Toast.makeText(getApplicationContext(), "Double Tap Detected", Toast.LENGTH_SHORT).show(); } } } }); 

Improvised dhruvi code

public abstract class DoubleClickListener implements View.OnClickListener { private static final long DOUBLE_CLICK_TIME_DELTA = 300;//milliseconds long lastClickTime = 0; boolean tap = true; @Override public void onClick(View v) { long clickTime = System.currentTimeMillis(); if (clickTime - lastClickTime < DOUBLE_CLICK_TIME_DELTA){ onDoubleClick(v); tap = false; } else tap = true; v.postDelayed(new Runnable() { @Override public void run() { if(tap) onSingleClick(); } },DOUBLE_CLICK_TIME_DELTA); lastClickTime = clickTime; } public abstract void onDoubleClick(View v); public abstract void onSingleClick(); } 

My solution, may be helpful.

long lastTouchUpTime = 0; boolean isDoubleClick = false; private void performDoubleClick() { long currentTime = System.currentTimeMillis(); if(!isDoubleClick && currentTime - lastTouchUpTime < DOUBLE_CLICK_TIME_INTERVAL) { isDoubleClick = true; lastTouchUpTime = currentTime; Toast.makeText(context, "double click", Toast.LENGTH_SHORT).show(); } else { lastTouchUpTime = currentTime; isDoubleClick = false; } } 

If you are using Kotlin then you can do it like this:

I spend a lot of time to convert this code to Kotlin hope it save someone's time

Create a gesture detector:

 val gestureDetector = GestureDetector(this, object : GestureDetector.SimpleOnGestureListener() { override fun onDoubleTap(e: MotionEvent): Boolean { Toast.makeText(this@DemoActivity,"Double Tap",Toast.LENGTH_LONG).show() //Show or hide Ip address on double tap toggleIPaddressVisibility() return true; } override fun onLongPress(e: MotionEvent) { super.onLongPress(e); //rotate frame on long press toggleFrameRotation() Toast.makeText(this@DemoActivity,"LongClick",Toast.LENGTH_LONG).show() } override fun onDoubleTapEvent(e: MotionEvent): Boolean { return true } override fun onDown(e: MotionEvent): Boolean { return true } }) 

Assign to any of your view:

 IPAddress.setOnTouchListener { v, event -> return@setOnTouchListener gestureDetector.onTouchEvent(event) } 

This is a solution that wait if there is a second clic before executing any action

 int init = 0; myView.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { if (init == 0) { init++; new Handler().postDelayed(new Runnable() { @Override public void run() { if (init == 1) { Log.d("hereGoes", "actionOne"); } else { Log.d("hereGoes", "actionTwo"); } init = 0; } }, 250); } else { init++; } } }); 

Realization single and double click

public abstract class DoubleClickListener implements View.OnClickListener { private static final long DOUBLE_CLICK_TIME_DELTA = 200; private long lastClickTime = 0; private View view; private Handler handler = new Handler(); private Runnable runnable = new Runnable() { @Override public void run() { onSingleClick(view); } }; private void runTimer(){ handler.removeCallbacks(runnable); handler.postDelayed(runnable,DOUBLE_CLICK_TIME_DELTA); } @Override public void onClick(View view) { this.view = view; long clickTime = System.currentTimeMillis(); if (clickTime - lastClickTime < DOUBLE_CLICK_TIME_DELTA){ handler.removeCallbacks(runnable); lastClickTime = 0; onDoubleClick(view); } else { runTimer(); lastClickTime = clickTime; } } public abstract void onSingleClick(View v); public abstract void onDoubleClick(View v); 

}

public class MyView extends View { GestureDetector gestureDetector; public MyView(Context context, AttributeSet attrs) { super(context, attrs); // creating new gesture detector gestureDetector = new GestureDetector(context, new GestureListener()); } // skipping measure calculation and drawing // delegate the event to the gesture detector @Override public boolean onTouchEvent(MotionEvent e) { return gestureDetector.onTouchEvent(e); } private class GestureListener extends GestureDetector.SimpleOnGestureListener { @Override public boolean onDown(MotionEvent e) { return true; } // event when double tap occurs @Override public boolean onDoubleTap(MotionEvent e) { float x = e.getX(); float y = e.getY(); Log.d("Double Tap", "Tapped at: (" + x + "," + y + ")"); return true; } } } 

you can implement double-tap using the GestureDetectorCompat class. in this sample when double-tap on textview you can do your logic.

public class MainActivity extends AppCompatActivity { GestureDetectorCompat gestureDetectorCompat; TextView textElement; @Override protected void onCreate(Bundle savedInstanceState) { ..... textElement = findViewById(R.id.textElement); gestureDetectorCompat = new GestureDetectorCompat(this, new MyGesture()); textElement.setOnTouchListener(onTouchListener); } View.OnTouchListener onTouchListener = new View.OnTouchListener() { @Override public boolean onTouch(View v, MotionEvent event) { gestureDetectorCompat.onTouchEvent(event); return true; } }; class MyGesture extends GestureDetector.SimpleOnGestureListener { @Override public boolean onDown(MotionEvent e) { return true; } @Override public boolean onDoubleTap(MotionEvent e) { // whatever on double click return true; } } 

Thread + Interface = DoubleTapListener, AnyTap listener etc

In this example, I have implemented the DoubleTap Listener with a Thread. You can add my listener with any View object as you do with any ClickListener. Using this approach you can easily pull off any kind of click listener.

yourButton.setOnClickListener(new DoubleTapListener(this));

1) My Listrener class

public class DoubleTapListener implements View.OnClickListener{ private boolean isRunning= false; private int resetInTime =500; private int counter=0; private DoubleTapCallback listener; public DoubleTapListener(Context context){ listener = (DoubleTapCallback)context; Log.d("Double Tap","New"); } @Override public void onClick(View v) { if(isRunning){ if(counter==1) listener.onDoubleClick(v); } counter++; if(!isRunning){ isRunning=true; new Thread(new Runnable() { @Override public void run() { try { Thread.sleep(resetInTime); isRunning = false; counter=0; } catch (InterruptedException e) { e.printStackTrace(); } } }).start(); } } } 

2) Listener Callback

public interface DoubleTapCallback { public void onDoubleClick(View v); } 

3) Implement in your Activity

public class MainActivity extends AppCompatActivity implements DoubleTapCallback{ private Button button; private int counter; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); button = (Button)findViewById(R.id.button); button.setOnClickListener(new DoubleTapListener(this)); // Set mt listener } @Override public void onDoubleClick(View v) { counter++; textView.setText(counter+""); } 

Relevant link:

You can see the full working code HERE

Solution by bughi & Jayant Arora for copypast:

public abstract class DoubleClickListener implements View.OnClickListener { private int position; private Timer timer; private static final long DOUBLE_CLICK_TIME_DELTA = 300;//milliseconds long lastClickTime = 0; public DoubleClickListener (int position) { this.position = position; } @Override public void onClick(View v) { long clickTime = System.currentTimeMillis(); if (clickTime - lastClickTime < DOUBLE_CLICK_TIME_DELTA){ if (timer != null) { timer.cancel(); //Cancels Running Tasks or Waiting Tasks. timer.purge(); //Frees Memory by erasing cancelled Tasks. } onDoubleClick(v, position); } else { final Handler handler = new Handler(); final Runnable mRunnable = () -> { onSingleClick(v, position); }; TimerTask timertask = new TimerTask() { @Override public void run() { handler.post(mRunnable); } }; timer = new Timer(); timer.schedule(timertask, DOUBLE_CLICK_TIME_DELTA); } lastClickTime = clickTime; } public abstract void onSingleClick(View v, int position); public abstract void onDoubleClick(View v, int position);} 

Equivalent C# code which i used to implement same functionality and can even customize to accept N number of Taps

public interface IOnTouchInterface { void ViewTapped(); } public class MultipleTouchGestureListener : Java.Lang.Object, View.IOnTouchListener { int clickCount = 0; long startTime; static long MAX_DURATION = 500; public int NumberOfTaps { get; set; } = 7; readonly IOnTouchInterface interfc; public MultipleTouchGestureListener(IOnTouchInterface tch) { this.interfc = tch; } public bool OnTouch(View v, MotionEvent e) { switch (e.Action) { case MotionEventActions.Down: clickCount++; if(clickCount == 1) startTime = Utility.CurrentTimeSince1970; break; case MotionEventActions.Up: var currentTime = Utility.CurrentTimeSince1970; long time = currentTime - startTime; if(time <= MAX_DURATION * NumberOfTaps) { if (clickCount == NumberOfTaps) { this.interfc.ViewTapped(); clickCount = 0; } } else { clickCount = 0; } break; } return true; } } public static class Utility { public static long CurrentTimeSince1970 { get { DateTime dt = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Local); DateTime dtNow = DateTime.Now; TimeSpan result = dtNow.Subtract(dt); long seconds = (long)result.TotalMilliseconds; return seconds; } } } 

Currently Above code accepts 7 as number of taps before it raises the View Tapped event. But it can be customized with any number

I have implemented a simple custom method using kotlin coroutines (for java can be done via threads).

var click = 0 view.setOnClickListener{ click++ clicksHandling() } fun clicksHandling() { if (click == 1) { launch { delay(300) // custom delay duration between clicks // if user didn't double tap then click counter still 1 if (click == 1) { // single click handling runOnUiThread { // whatever you wanna do on UI thread } } click = 0 //reset counter , this will run no matter single / double tap } //double click handling if (click == 2) { // whatever on double click } } 

I created a simple library to handle this. it can also detect more than two clicks (it all depends on you). after you import the ClickCounter class, here is how you use it to detect single and multiple clicks:

ClickCounter counter = new ClickCounter(); view.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View view) { counter.addClick(); // submits click to be counted } }); counter.setClickCountListener(new ClickCounter.ClickCountListener() { @Override public void onClickingCompleted(int clickCount) { rewardUserWithClicks(clickCount); // Thats All!!😃 } }); 

In Kotlin you can try this,

like i am using cardview for clicking,

(Example : on double click i perform like and dislike.)

cardviewPostCard.setOnClickListener(object : DoubleClickListener() { override fun onDoubleClick(v: View?) { if (holder.toggleButtonLike.isChecked) { holder.toggleButtonLike.setChecked(false) // } else { holder.toggleButtonLike.setChecked(true) } } }) 

and here is your DoubleClickListener class,

abstract class DoubleClickListener : View.OnClickListener { var lastClickTime: Long = 0 override fun onClick(v: View?) { val clickTime = System.currentTimeMillis() if (clickTime - lastClickTime < DOUBLE_CLICK_TIME_DELTA) { onDoubleClick(v) } lastClickTime = clickTime } abstract fun onDoubleClick(v: View?) companion object { private const val DOUBLE_CLICK_TIME_DELTA: Long = 300 //milliseconds } } 

While I liked the simplicity of the approach in the original answer

Here is my version

public abstract class OnDoubleClickListener implements View.OnClickListener { private static final int TIME_OUT = ViewConfiguration.getDoubleTapTimeout(); private TapHandler tapHandler = new TapHandler(); public abstract void onSingleClick(View v); public abstract void onDoubleClick(View v); @Override public void onClick(View v) { tapHandler.cancelSingleTap(v); if (tapHandler.isDoubleTap()){ onDoubleClick(v); } else { tapHandler.performSingleTap(v); } } private class TapHandler implements Runnable { public boolean isDoubleTap() { final long tapTime = System.currentTimeMillis(); boolean doubleTap = tapTime - lastTapTime < TIME_OUT; lastTapTime = tapTime; return doubleTap; } public void performSingleTap(View v) { view = v; v.postDelayed(this, TIME_OUT); } public void cancelSingleTap(View v) { view = null; v.removeCallbacks(this); } @Override public void run() { if (view != null) { onSingleClick(view); } } private View view; private long lastTapTime = 0; } } 

Usage is same as the original

view.setOnClickListener(new OnDoubleClickListener() { @Override public void onSingleClick(View v) { } @Override public void onDoubleClick(View v) { } }); 

A simple way to do this in Kotlin:

button.setOnTouchListener(object : View.OnTouchListener{ val gestureDetector = GestureDetector(object : GestureDetector.SimpleOnGestureListener(){ override fun onDoubleTap(e: MotionEvent?): Boolean { //do something here return super.onDoubleTap(e) } }) override fun onTouch(v: View?, event: MotionEvent?): Boolean { //do something here gestureDetector.onTouchEvent(event) return true } }) 

To detect the type of gesture tap one can implement something inline with this (here projectText is an EditText):

projectText.setOnTouchListener(new View.OnTouchListener() { private GestureDetector gestureDetector = new GestureDetector(activity, new GestureDetector.SimpleOnGestureListener() { @Override public boolean onDoubleTap(MotionEvent e) { projectText.setInputType(InputType.TYPE_CLASS_TEXT); activity.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE); return super.onDoubleTap(e); } @Override public boolean onSingleTapUp(MotionEvent e) { projectText.setInputType(InputType.TYPE_NULL); // disable soft input final int itemPosition = getLayoutPosition(); if(!projects.get(itemPosition).getProjectId().equals("-1")) listener.selectedClick(projects.get(itemPosition)); return super.onSingleTapUp(e); } }); @Override public boolean onTouch(View v, MotionEvent event) { gestureDetector.onTouchEvent(event); return false; //true stops propagation of the event } }); 

This is the Kotlin extension function version:

fun View.setOnDoubleTapListener(action: () -> Unit) { // instantiate GestureDetectorCompat val gDetector = GestureDetectorCompat( this.context, GestureDetector.SimpleOnGestureListener() ) // Create anonymous class extend OnTouchListener and SimpleOnGestureListener val touchListener = object : View.OnTouchListener, GestureDetector.SimpleOnGestureListener() { override fun onTouch(view: View?, event: MotionEvent?): Boolean { gDetector.onTouchEvent(event) gDetector.setOnDoubleTapListener(this) return true } override fun onDoubleTap(e: MotionEvent?): Boolean { action() return true } } this.setOnTouchListener(touchListener) } 

Kotlin w/o extra class

override fun onCreate(savedInstanceState: Bundle?) { // ... var listview: ListView = findViewById(R.id.<your_listview_id>) var itemLastClickTime: Long = 0 var singleClickHandler: Handler = Handler(Looper.getMainLooper()) // ListView item 'double click' and 'single click' listview.setOnItemClickListener(OnItemClickListener { av, iv, pos, id -> // if double click occurs, disable single click handler if (System.currentTimeMillis() - itemLastClickTime < 300) { singleClickHandler.removeCallbacksAndMessages(null) // do double click handling return@OnItemClickListener } // store the time of the item's click event itemLastClickTime = System.currentTimeMillis() // single click handler only fires, if no double click occured singleClickHandler.postDelayed({ // do single click handling }, 300) }) // ... } 

Java w/o extra class

@Override protected void onCreate(Bundle savedInstanceState) { // ... ListView listview = findViewById(R.id.<your_listview_id>); final long[] itemLastClickTime = {0}; Handler singleClickHandler = new Handler(); listview.setOnItemClickListener(new AdapterView.OnItemClickListener() { @Override public void onItemClick(AdapterView<?> av, View iv, int pos, long id) { // if double click occurs, disable single click handler if (System.currentTimeMillis() - itemLastClickTime[0] < 300) { singleClickHandler.removeCallbacksAndMessages(null); // do double click handling return; } // store the time of the item's click event itemLastClickTime[0] = System.currentTimeMillis(); // single click handler only fires, if no double click occured singleClickHandler.postDelayed(new Runnable() { @Override public void run() { // do single click handling } }, 300); } }); // ... } 

Just listen the time of previous click. You can use this class for double click listening.

abstract class DoubleClickListener : View.OnClickListener { private var lastClickTime: Long = 0 override fun onClick(v: View) { val clickTime = System.currentTimeMillis() if (clickTime - lastClickTime < DOUBLE_CLICK_TIME_DELTA) { onDoubleClick(v) lastClickTime = 0 } lastClickTime = clickTime } abstract fun onDoubleClick(v: View) companion object { private const val DOUBLE_CLICK_TIME_DELTA: Long = 300 //milliseconds } } 

And, you can use it like this:

yourView.setOnClickListener(object : DoubleClickListener() { override fun onDoubleClick(v: View) { // do to } }) 

Add this class:

class DoubleTapListener(context: Context, doubleTapped: () -> Unit) : View.OnTouchListener { private val gestureDetector: GestureDetector init { gestureDetector = GestureDetector(context, object : GestureDetector.SimpleOnGestureListener() { override fun onDown(e: MotionEvent): Boolean { return true } override fun onDoubleTap(e: MotionEvent): Boolean { doubleTapped() return true } }) } override fun onTouch(v: View, event: MotionEvent): Boolean { return gestureDetector.onTouchEvent(event) } } 

And then inside any View you want to listen to double taps, add this line:

setOnTouchListener(DoubleTapListener(context) { // Execute logic })