CODEWITHSUNDEEP
androidbuttononclicklistener
andDev
andDev

Reputation: 275

Single click and double click of a button in android

In my application i have a button. After single and double clicking of the button will perform separate operation. How can i do that? Thanks

Upvotes: 8

Views: 45353

Answers (12)

Kirguduck
Kirguduck

Reputation: 796

on kotlin. add a class

class OnSingleClickListener(private val delay: Long) : View.OnClickListener {

private var lastClickTime = 0L

override fun onClick(view: View) {
    val currentTime = System.currentTimeMillis()
    if (currentTime - lastClickTime < delay) {
        return
    }
    lastClickTime = currentTime
}}

and use extension with adjustable delay

fun View.setOnSingleClickListener(delay: Long = 500L, block: () -> Unit{
setOnClickListener(OnSingleClickListener(delay, block))}

from here

Upvotes: 0

zakaria-alshamere
zakaria-alshamere

Reputation: 43

double click and single click in android

A solution that fits almost all versions

Detect the type of event within the standard duration you want to define It can detect the event in an accelerated and sequential manner, such as passing a video for a certain period

//general definition
private CountDownTimer countDownTimer;
private int click_duble = 1;

button.setOnClickListener(view -> {

    if (countDownTimer == null) {
        float Second= (float) 0.25; //Detecting the type of event within a quarter of a second
        countDownTimer= new CountDownTimer((long) (Second * 1000), 50) {
            @Override public void onTick(long l){}
            @Override
            public void onFinish() {
                if (click_duble >= 2) {
                    Toast.makeText(player_fb.this, "Double", Toast.LENGTH_SHORT).show();

                } else {
                    Toast.makeText(player_fb.this, "Single", Toast.LENGTH_SHORT).show();
                }
                click_duble = 1;
                countDownTimer = null;
            }};countDownTimer.start();
    }else
        click_duble += 1;
});

Upvotes: 1

steven smith
steven smith

Reputation: 1577

This is @saksham's answer in Kotlin.

abstract class DoubleClickListener : View.OnClickListener {
    private val DEFAULT_QUALIFICATION_SPAN = 200L
    private var isSingleEvent = false
    private val doubleClickQualificationSpanInMillis =
        DEFAULT_QUALIFICATION_SPAN
    private var timestampLastClick = 0L
    private val handler = Handler(Looper.getMainLooper())
    private val runnable: () -> Unit = {
        if (isSingleEvent) {
            onSingleClick()
        }
    }
    override fun onClick(v: View) {
        if (SystemClock.elapsedRealtime() - timestampLastClick < doubleClickQualificationSpanInMillis) {
            isSingleEvent = false
            handler.removeCallbacks(runnable)
            onDoubleClick()
            return
        }
        isSingleEvent = true
        handler.postDelayed(runnable, DEFAULT_QUALIFICATION_SPAN)
        timestampLastClick = SystemClock.elapsedRealtime()
    }

    abstract fun onDoubleClick()
    abstract fun onSingleClick()
}

Upvotes: 2

saksham
saksham

Reputation: 3324

Well it is simple just override.

onClick method of OnClickListener

public abstract class DoubleClickListener implements View.OnClickListener {
private static final long DEFAULT_QUALIFICATION_SPAN = 200;
private boolean isSingleEvent;
private long doubleClickQualificationSpanInMillis;
private long timestampLastClick;
private Handler handler;
private Runnable runnable;

public DoubleClickListener() {
    doubleClickQualificationSpanInMillis = DEFAULT_QUALIFICATION_SPAN;
    timestampLastClick = 0;
    handler = new Handler();
    runnable = new Runnable() {
        @Override
        public void run() {
            if (isSingleEvent) {
                onSingleClick();
            }
        }
    };
}

@Override
public void onClick(View v) {
    if((SystemClock.elapsedRealtime() - timestampLastClick) < doubleClickQualificationSpanInMillis) {
        isSingleEvent = false;
        handler.removeCallbacks(runnable);
        onDoubleClick();
        return;
    }

    isSingleEvent = true;
    handler.postDelayed(runnable, DEFAULT_QUALIFICATION_SPAN);
    timestampLastClick = SystemClock.elapsedRealtime();
}

public abstract void onDoubleClick();
public abstract void onSingleClick();
}

Usage

 button.setOnClickListener(new DoubleClickListener() {
        @Override
        public void onDoubleClick() {
            Log.i("onClick", "double");
        }

        @Override
        public void onSingleClick() {
            Log.i("onClick", "single");
        }
    });

Upvotes: 11

Harshid Vasoya
Harshid Vasoya

Reputation: 5721

You have to implement GestureDetector and put your code in single/double click.

TestActivity.java

iv.setOnClickListener(new OnClickListener() {           
                @Override
                public void onClick(View v) {
                    //putyour first activity call.
                }
    }

iv.setOnTouchListener(new OnTouchListener() {
             GestureDetector gestureDetector = new GestureDetector(context, new MyGestureDetector(context));
         @Override
         public boolean onTouch(View v, MotionEvent event) {
                return gestureDetector.onTouchEvent(event);
         }
});

Now you have to create GestureDetector.java class.

public class MyGestureDetector extends SimpleOnGestureListener {
    public Context context;
    public String phno;

    public MyGestureDetector(Context con) {
        this.context=con;       
    }

    @Override
    public boolean onDown(MotionEvent e) {
        return super.onDown(e);
    }

    @Override
    public boolean onDoubleTap(MotionEvent e) {
        System.out.println("in Double tap");

        return true;
    }

    @Override
    public boolean onSingleTapUp(MotionEvent e) {
        System.out.println("in single tap up");
            //put your second activity.
        return super.onSingleTapUp(e);
    }   
}

Upvotes: 3

smallfatter
smallfatter

Reputation: 181

The up solution cannot work for multi click, i test it but failed.

So i suggest to use RxBinding with ProgressDialog.

when click button, the progressDialog show setting it cannot be cancel, Fix it.

Upvotes: 0

forqzy
forqzy

Reputation: 389

Solving this by inherit from the View.OnClickListener and checking the click time to distinguish the single click or double click, this also solve the problem of fast clicking. This solution will bring minor code change, just replace View.OnClickLister. You also can override the getGap() to redefine the time between two clicks.

import android.os.SystemClock;
import android.view.View;

/*****
 * Implement to fix the double click problem.
 * Avoid the fast double click for button and images.
 */
public abstract class OnSingleClickListener implements View.OnClickListener {
    private long prevClickTime =0;

    @Override
    public void onClick(View v) {
        _onClick(v);
    }

    private synchronized void _onClick(View v){
        long current = SystemClock.elapsedRealtime();
        if(current-prevClickTime> getGap()){
            onSingleClick(v);
            prevClickTime = SystemClock.elapsedRealtime();
        }else {
            onDoubleClick(v);
            prevClickTime = 0;
        }
    }

    public abstract void onSingleClick(View v);
    public abstract void onDoubleClick(View v);

    /********
     *
     * @return The time in ms between two clicks.
     */
    public long getGap(){
        return 500L; //500ms
    }
}

Upvotes: 1

ssi-anik
ssi-anik

Reputation: 3694

Though it's too late, but anyone can figure out if they see this.

int number_of_clicks = 0;
boolean thread_started = false;
final int DELAY_BETWEEN_CLICKS_IN_MILLISECONDS = 250;

button.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        ++number_of_clicks;
        if(!thread_started){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    thread_started = true;
                    try {
                        Thread.sleep(DELAY_BETWEEN_CLICKS_IN_MILLISECONDS);
                        if(number_of_clicks == 1){
                            client.send(AppHelper.FORMAT_LEFT_CLICK);
                        } else if(number_of_clicks == 2){
                            client.send(AppHelper.FORMAT_DOUBLE_CLICK);
                        }
                        number_of_clicks = 0;
                        thread_started = false;
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }
});

Explanation:

Before the button click, number_of_click is initialized to 0. thread_started is a flag detecting if the thread is started before or not. Now, on button click, increase the number of button click by incremental operator. check if the thread is previously started or not, if not, then start the thread. on thread, apply your logic by using the number_of_clicks. and the thread will wait for next milliseconds and then will go through your logic. So, now you can apply as many clicks as you want.

Upvotes: 3

chadm
chadm

Reputation: 1

I also got the same problem once 

setOnClickListener(new OnClickListener() {           
            @Override
            public void onClick(View v) {
                if(isFmOn()){
                   //stopFM
                }else{
                  //do other things
                }
            }
}

when I clicked the Button,FM stopped;but when I double clicked,FM did not stop.The problem was that single and double clicking of the button ,the value of isFmOn() was difference. I sloved the problem using this:

setOnClickListener(new OnClickListener() {           
            @Override
            public void onClick(View v) {
                Thread.sleep(500);//500ms was enough to finish stopFM before the second click
                if(isFmOn()){
                   //stopFM
                }else{
                  //do other things
                }
            }
}

Upvotes: -2

Mr.Sandy
Mr.Sandy

Reputation: 4349

Thanks to @NikolaDespotoski.

You can check DOUBLE-TAP example from following URL. that is used in listView. i hope it is useful for you.

https://nodeload.github.com/NikolaDespotoski/DoubleTapListView/zip/master

Upvotes: 3

HalR
HalR

Reputation: 11073

You may want to consider not using a DoubleTap. It is not a normal Android behavior.

When I first started programming on the Android, I kept running into things that were really "hard" to do on the android. Over time, I've found that many of them were difficult because they were a pretty bad idea.

If you are porting an iOS app, or emulating an iOS app's behavior, you may want to consider converting the UI over to Android style behaviors and use a longPress or other 'androidy' gestures.

Here is a similar question and answer:

Android: How to detect double-tap?

Upvotes: 6

Raynold
Raynold

Reputation: 443

You may need to create a delay variable which will differenciate between single click and double click.

See this code, 

private static final long DOUBLE_PRESS_INTERVAL = 250; // in millis
private long lastPressTime;

private boolean mHasDoubleClicked = false;

    @Override
    public boolean onPrepareOptionsMenu(Menu menu) {    

        // Get current time in nano seconds.
        long pressTime = System.currentTimeMillis();


        // If double click...
        if (pressTime - lastPressTime <= DOUBLE_PRESS_INTERVAL) {
            Toast.makeText(getApplicationContext(), "Double Click Event", Toast.LENGTH_SHORT).show();
            mHasDoubleClicked = true;
        }
        else {     // If not double click....
            mHasDoubleClicked = false;
            Handler myHandler = new Handler() {
                 public void handleMessage(Message m) {
                      if (!mHasDoubleClicked) {
                            Toast.makeText(getApplicationContext(), "Single Click Event", Toast.LENGTH_SHORT).show();
                      }
                 }
            };
            Message m = new Message();
            myHandler.sendMessageDelayed(m,DOUBLE_PRESS_INTERVAL);
        }
        // record the last time the menu button was pressed.
        lastPressTime = pressTime;      
        return true;
    }

Upvotes: 9

Related Questions