ユーザーがもう一度クリックしても安全になるまで、setEnabled(false)でボタンを無効にします。
クリックしたときに最後のクリック時間を節約すると、この問題を防ぐことができます。
つまり.
private long mLastClickTime = 0;
...
// inside onCreate or so:
findViewById(R.id.button).setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
// mis-clicking prevention, using threshold of 1000 ms
if (SystemClock.elapsedRealtime() - mLastClickTime < 1000){
return;
}
mLastClickTime = SystemClock.elapsedRealtime();
// do your magic here
}
}
私の解決策は
package com.shuai.view;
import Android.os.SystemClock;
import Android.view.View;
/**
* 处理快速在某个控件上双击2次(或多次)会导致onClick被触发2次(或多次)的问题
* 通过判断2次click事件的时间间隔进行过滤
*
* 子类通过实现{@link #onSingleClick}响应click事件
*/
public abstract class OnSingleClickListener implements View.OnClickListener {
/**
* 最短click事件的时间间隔
*/
private static final long MIN_CLICK_INTERVAL=600;
/**
* 上次click的时间
*/
private long mLastClickTime;
/**
* click响应函数
* @param v The view that was clicked.
*/
public abstract void onSingleClick(View v);
@Override
public final void onClick(View v) {
long currentClickTime=SystemClock.uptimeMillis();
long elapsedTime=currentClickTime-mLastClickTime;
//有可能2次连击，也有可能3连击，保证mLastClickTime记录的总是上次click的时间
mLastClickTime=currentClickTime;
if(elapsedTime<=MIN_CLICK_INTERVAL)
return;
onSingleClick(v);
}
}
使用法はOnClickListenerと似ていますが、代わりにonSingleClick（）をオーバーライドします。
mTextView.setOnClickListener(new OnSingleClickListener() {
@Override
public void onSingleClick(View v) {
if (DEBUG)
Log.i("TAG", "onclick！");
}
};
OnClick（）で計算負荷の高い作業をしている場合、ボタンを無効にする前にクリックイベントをキューに入れることができるため、ボタンを無効にするか、クリック不可能に設定するだけでは不十分です。代わりにオーバーライドできるOnClickListenerを実装する抽象基本クラスを作成しました。この基本クラスは、キューに入れられたクリックを無視することでこの問題を修正します。
/**
* This class allows a single click and prevents multiple clicks on
* the same button in rapid succession. Setting unclickable is not enough
* because click events may still be queued up.
*
* Override onOneClick() to handle single clicks. Call reset() when you want to
* accept another click.
*/
public abstract class OnOneOffClickListener implements OnClickListener {
private boolean clickable = true;
/**
* Override onOneClick() instead.
*/
@Override
public final void onClick(View v) {
if (clickable) {
clickable = false;
onOneClick(v);
//reset(); // uncomment this line to reset automatically
}
}
/**
* Override this function to handle clicks.
* reset() must be called after each click for this function to be called
* again.
* @param v
*/
public abstract void onOneClick(View v);
/**
* Allows another click.
*/
public void reset() {
clickable = true;
}
}
使用法はOnClickListenerと同じですが、代わりにOnOneClick（）をオーバーライドします。
OnOneOffClickListener clickListener = new OnOneOffClickListener() {
@Override
public void onOneClick(View v) {
// Do stuff
this.reset(); // or you can reset somewhere else with clickListener.reset();
}
};
myButton.setOnClickListener(clickListener);
Kotlin Extension Functions および RxBinding を使用すると、非常におしゃれな方法で実行できます。
fun View.clickWithDebounce(debounceTime: Long = 600L, action: () -> Unit): Disposable =
RxView.clicks(this)
.debounce(debounceTime, TimeUnit.MILLISECONDS)
.observeOn(AndroidSchedulers.mainThread())
.subscribe { action() }
または
fun View.clickWithDebounce(debounceTime: Long = 600L, action: () -> Unit) {
this.setOnClickListener(object : View.OnClickListener {
private var lastClickTime: Long = 0
override fun onClick(v: View) {
if (SystemClock.elapsedRealtime() - lastClickTime < debounceTime) return
else action()
lastClickTime = SystemClock.elapsedRealtime()
}
})
}
そしてそれから：
View.clickWithDebounce{ Your code }
私も同様の問題を抱えており、日付ピッカーとタイムピッカーを表示していましたが、2回クリックされることがありました。これで解決しました
long TIME = 1 * 1000;
@Override
public void onClick(final View v) {
v.setEnabled(false);
new Handler().postDelayed(new Runnable() {
@Override
public void run() {
v.setEnabled(true);
}
}, TIME);
}
要件に応じて時間を変更できます。この方法は私には有効です。
setEnabled(false)は私にとって完璧に機能します。
アイデアは、最初に{ setEnabled(true); }と記述し、ボタンを最初にクリックしたときにfalseにするだけです。
この問題の実際の解決策は、ボタンをグレー表示するsetEnabled（false）と、2回目のクリックを受け取れないようにするsetClickable（false）を使用することです。これをテストしましたが、非常に効果的です。
私はそれが古い質問であることを知っていますが、この一般的な問題を解決するために見つけた最良の解決策を共有します
btnSomeButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
// Prevent Two Click
Utils.preventTwoClick(view);
// Do magic
}
});
そして、Utils.Javaのような別のファイルで
/**
* Método para prevenir doble click en un elemento
* @param view
*/
public static void preventTwoClick(final View view){
view.setEnabled(false);
view.postDelayed(new Runnable() {
public void run() {
view.setEnabled(true);
}
}, 500);
}
私の状況では、ボタンビューを使用していましたが、クリックが速すぎました。クリック可能なものを無効にし、数秒後に再び有効にします...
基本的に、Views onClickListenerをラップするラッパークラスを作成しました。必要に応じて、カスタム遅延を設定することもできます。
public class OnClickRateLimitedDecoratedListener implements View.OnClickListener {
private final static int CLICK_DELAY_DEFAULT = 300;
private View.OnClickListener onClickListener;
private int mClickDelay;
public OnClickRateLimitedDecoratedListener(View.OnClickListener onClickListener) {
this(onClickListener, CLICK_DELAY_DEFAULT);
}
//customize your own delay
public OnClickRateLimitedDecoratedListener(View.OnClickListener onClickListener, int delay) {
this.onClickListener = onClickListener;
mClickDelay = delay;
}
@Override
public void onClick(final View v) {
v.setClickable(false);
onClickListener.onClick(v);
v.postDelayed(new Runnable() {
@Override
public void run() {
v.setClickable(true);
}
}, mClickDelay);
}
}
それを呼び出すには、これを単純に行います：
mMyButton.setOnClickListener(new OnClickRateLimitedDecoratedListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
doSomething();
}
}));
または、独自の遅延を提供します。
mMyButton.setOnClickListener(new OnClickRateLimitedDecoratedListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
doSomething();
}
},1000));
更新：RxJavaが非常に普及している今、上記の方法は少し古い方法です。他の人が言及したように、Androidでは、スロットルを使用してクリックを遅くすることができます。次に例を示します。
RxView.clicks(myButton)
.throttleFirst(2000, TimeUnit.MILLISECONDS, AndroidSchedulers.mainThread())
.subscribe {
Log.d("i got delayed clicked")
}
}
このライブラリを使用できます：implementation 'com.jakewharton.rxbinding2:rxbinding:2.0.0'
私の解決策はboolean変数を使用することです：
public class Blocker {
private static final int DEFAULT_BLOCK_TIME = 1000;
private boolean mIsBlockClick;
/**
* Block any event occurs in 1000 millisecond to prevent spam action
* @return false if not in block state, otherwise return true.
*/
public boolean block(int blockInMillis) {
if (!mIsBlockClick) {
mIsBlockClick = true;
new Handler().postDelayed(new Runnable() {
@Override
public void run() {
mIsBlockClick = false;
}
}, blockInMillis);
return false;
}
return true;
}
public boolean block() {
return block(DEFAULT_BLOCK_TIME);
}
}
そして、次のように使用します：
view.setOnClickListener(new View.OnClickListener() {
private Blocker mBlocker = new Blocker();
@Override
public void onClick(View v) {
if (!mBlocker.block(block-Time-In-Millis)) {
// do your action
}
}
});
簡潔なインラインコードと可変のダブルクリック待機時間を可能にするKotlin拡張機能
fun View.setDoubleClickListener(listener: View.OnClickListener, waitMillis : Long = 1000) {
var lastClickTime = 0L
setOnClickListener { view ->
if (System.currentTimeMillis() > lastClickTime + waitMillis) {
listener.onClick(view)
lastClickTime = System.currentTimeMillis()
}
}
}
使用法：
anyView.setNoDoubleClickListener(View.OnClickListener { v ->
// do stuff
})
または
anyView.setNoDoubleClickListener(View.OnClickListener { v ->
// do stuff
}, 1500)
クリックガード バターナイフでうまく機能します
ClickGuard.guard(mPlayButton);
OnResumeでクリックリスナを設定し、onPauseでクリックリスナを無効にすると、トリックも行われるようです。
誰かがまだ短い答えを探している場合は、以下のコードを使用できます
private static long mLastClickTime = 0;
if (SystemClock.elapsedRealtime() - mLastClickTime < 1000) { // 1000 = 1second
return;
}
mLastClickTime = SystemClock.elapsedRealtime();
このコードは、ユーザーがif statementをクリックするたびにView within 1 second内に配置され、その後return;が開始され、以降のコードは開始されません。
OnClickメソッドがすぐに返らない場合、これらの提案はいずれも機能しないことがわかりました。タッチイベントはAndroidによってキューに入れられ、次のonClickは最初のイベントが終了した後にのみ呼び出されます。 （これは1つのUIスレッドで行われるため、これは実際に正常です。）onClick関数が終了する時間+ 1つのブール変数を使用して、特定のonClickが実行されているかどうかをマークする必要がありました。これらのマーカー属性は両方とも静的であるため、onClickListenerが同時に実行されることはありません。 （ユーザーが別のボタンをクリックした場合）OnClickListenerをこのクラスに簡単に置き換えることができ、onClickメソッドを実装する代わりに、抽象oneClick（）メソッドを実装する必要があります。
abstract public class OneClickListener implements OnClickListener {
private static boolean started = false;
private static long lastClickEndTime = 0;
/* (non-Javadoc)
* @see Android.view.View.OnClickListener#onClick(Android.view.View)
*/
@Override
final public void onClick(final View v) {
if(started || SystemClock.elapsedRealtime()-lastClickEndTime <1000 ){
Log.d(OneClickListener.class.toString(), "Rejected double click, " + new Date().toString() );
return;
}
Log.d(OneClickListener.class.toString(), "One click, start: " + new Date().toString() );
try{
started = true;
oneClick(v);
}finally{
started = false;
lastClickEndTime = SystemClock.elapsedRealtime();
Log.d(OneClickListener.class.toString(), "One click, end: " + new Date().toString() );
}
}
abstract protected void oneClick(View v);
}
これがお役に立てば幸いです。コードをイベントハンドラに入れてください。
// ------------------------------------------------ --------------------------------
boolean hasTag = null != which.getTag( R.id.preventing_double_click_tag );
if ( hasTag ) {
// Do not handle again...
return;
} else {
which.setTag( R.id.action, Boolean.TRUE );
which.postDelayed( new Runnable() {
@Override
public void run() {
which.setTag( R.id.action, null );
Log.d( "onActin", " The preventing double click tag was removed." );
}
}, 2000 );
}
私にとっては、タイムスタンプを覚えて、それをチェックするだけです（前回のクリックから1秒以上経過しました）。
jake whartonによるrxバインディング を使用してこれを実現することもできます。連続するクリックの間に2秒を埋めるサンプルを次に示します。
RxView.clicks(btnSave)
.throttleFirst(2000, TimeUnit.MILLISECONDS, AndroidSchedulers.mainThread())
.subscribe(new Consumer<Object>() {
@Override
public void accept( Object v) throws Exception {
//handle onclick event here
});
//注意：この場合、オブジェクトvは無視してください。
次のように同期されたボタンを使用できます。
@Override
public void onClick(final View view) {
synchronized (view) {
view.setEnabled(false);
switch (view.getId()) {
case R.id.id1:
...
break;
case R.id.id2:
...
break;
...
}
new Handler().postDelayed(new Runnable() {
@Override
public void run() {
view.setEnabled(true);
}
}, 1000);
}
}
幸運を）
Clickableをfalseに設定しても、最初のダブルクリックでは機能しませんが、その後のダブルクリックはブロックされます。最初のロードクリックデリゲートは遅く、最初のクリックが完了する前に2回目のクリックがキャプチャされるようです。
Button button = contentView.FindViewById<Button>(Resource.Id.buttonIssue);
button.Clickable = false;
IssueSelectedItems();
button.Clickable = true;
button.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View view) {
//to prevent double click
button.setOnClickListener(null);
}
});
私はこの問題を2つのクラスを使用して修正します.1つは@ jinshiyi11の回答に似ており、アノーターは明示的なクリックに基づいています。これでは、ボタンを一度だけクリックできますが、別のクリックが必要な場合は明示的に指定する必要があります。
/**
* Listener que sólo permite hacer click una vez, para poder hacer click
* posteriormente se necesita indicar explicitamente.
*
* @author iberck
*/
public abstract class OnExplicitClickListener implements View.OnClickListener {
// you can perform a click only once time
private boolean canClick = true;
@Override
public synchronized void onClick(View v) {
if (canClick) {
canClick = false;
onOneClick(v);
}
}
public abstract void onOneClick(View v);
public synchronized void enableClick() {
canClick = true;
}
public synchronized void disableClick() {
canClick = false;
}
}
使用例：
OnExplicitClickListener clickListener = new OnExplicitClickListener() {
public void onOneClick(View v) {
Log.d("example", "explicit click");
...
clickListener.enableClick();
}
}
button.setOnClickListener(clickListener);
final Button button = (Button) findViewById(R.id.button);
button.setOnClickListener(new View.OnClickListener() {
private final AtomicBoolean onClickEnabled = new AtomicBoolean(true);
@Override
public void onClick(View v) {
Log.i("TAG", "onClick begin");
if (!onClickEnabled.compareAndSet(true, false)) {
Log.i("TAG", "onClick not enabled");
return;
}
button.setEnabled(false);
// your action here
button.setEnabled(true);
onClickEnabled.set(true);
Log.i("TAG", "onClick end");
}
});
これを試してください、それは働いています：
mButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
mSlotLayout.setEnabled(false);
// do your work here
Timer buttonTimer = new Timer();
buttonTimer.schedule(new TimerTask() {
@Override
public void run() {
runOnUiThread(new Runnable() {
@Override
public void run() {
mButton.setEnabled(true);
}
});
}
}, 500); // delay button enable for 0.5 sec
}
});
この方法を使用できます。ポスト遅延を使用することにより、ダブルクリックイベントを処理できます。
void debounceEffectForClick（View view）{
view.setClickable(false);
view.postDelayed(new Runnable() {
@Override
public void run() {
view.setClickable(true);
}
}, 500);
}
KotlinはクラスSafeClickListenerを作成します
class SafeClickListener(
private var defaultInterval: Int = 1000,
private val onSafeCLick: (View) -> Unit
) : View.OnClickListener {
private var lastTimeClicked: Long = 0 override fun onClick(v: View) {
if (SystemClock.elapsedRealtime() - lastTimeClicked < defaultInterval) {
return
}
lastTimeClicked = SystemClock.elapsedRealtime()
onSafeCLick(v)
}
}
baseClassなどで関数を作成します
fun View.setSafeOnClickListener(onSafeClick: (View) -> Unit) {val safeClickListener = SafeClickListener {
onSafeClick(it)
}
setOnClickListener(safeClickListener)
}
ボタンのクリックで使用
btnSubmit.setSafeOnClickListener {
showSettingsScreen()
}
データバインディングを使用している場合：
@BindingAdapter("onClickWithDebounce")
fun onClickWithDebounce(view: View, listener: Android.view.View.OnClickListener) {
view.setClickWithDebounce {
listener.onClick(view)
}
}
object LastClickTimeSingleton {
var lastClickTime: Long = 0
}
fun View.setClickWithDebounce(action: () -> Unit) {
setOnClickListener(object : View.OnClickListener {
override fun onClick(v: View) {
if (SystemClock.elapsedRealtime() - LastClickTimeSingleton.lastClickTime < 500L) return
else action()
LastClickTimeSingleton.lastClickTime = SystemClock.elapsedRealtime()
}
})
}
<androidx.appcompat.widget.AppCompatButton
..
Android:text="@string/signup_signin"
app:onClickWithDebounce="@{() -> viewModel.onSignUpClicked()}"
... />
これは私の解決策です：
if (waitDouble) {
waitDouble = false;
Thread thread = new Thread() {
@Override
public void run() {
try {
sleep(300);
if (waitDouble == false) {
waitDouble = true;
singleClick(); //singleClick
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
thread.start();
} else {//DoubleClick
DoubleClick();
waitDouble = true;
}
または別の解決策：
public class NoDoubleClickUtils {
private static long lastClickTime;
private final static int SPACE_TIME = 500;
public static void initLastClickTime() {
lastClickTime = 0;
}
public synchronized static boolean isDoubleClick() {
long currentTime = System.currentTimeMillis();
boolean isClick2;
if (currentTime - lastClickTime > SPACE_TIME) {
isClick2 = false;
} else {
isClick2 = true;
}
lastClickTime = currentTime;
return isClick2;
}
}
UIスレッドがブロックされると、クリックイベントがキューに入れられます。ボタンクリックイベントでは、クリックイベントが互いにキューイングするのを避けるために、できるだけ早くバックグラウンドタスクに変更します。
アクティビティクラス内で揮発性ブール値またはロックを宣言します。
private volatile boolean saving = false;
保存することによってゲートされるonClickListenerを使用してボタンを作成し、バックグラウンドタスクを開始して作業を実行します。
saveButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
if (!saving) {
saving = true;
new SaveAsyncTask().execute();
}
}
});
バックグラウンドで作業を行うために、内部SaveAsyncTaskクラスを作成します。
class SaveAsyncTask extends AsyncTask {
@Override
protected Object doInBackground(Object[] objects) {
// Do something here, simulate a 3 second task
SystemClock.sleep(3000);
saving = false;
return null;
}
}
セマフォブロックを使用することを好みます。スレッドセーフであり、ボタンだけでなく使用できます。
コードサンプルは単純です。
private UtilsSemaphore buttonSemaphore = new UtilsSemaphore();
public void onClick(View view)
{
boolean isAllowed = buttonSemaphore.lock();
if(!isAllowed)
{
return;
}
final View clickedButton = view;
clickedButton.setEnabled(false);
/* some code */
buttonSemaphore.unlock();
clickedButton.setEnabled(true);
}
public class UtilsSemaphore {
public int counter = 0;
public boolean lock()
{
int counterValue = ++counter;
boolean isAllowed = counterValue < 2;
if(!isAllowed)
{
unlock();
}
return isAllowed;
}
public void unlock()
{
--counter;
}
}
The Best and simple solution i found is
1. to create a boolean and set as false (default) like
private boolean itemClicked = false;
/* for a safer side you can also declare boolean false in onCreate() also. */
and at onclick() method check
2. if(!itemClicked)
{
itemClicked = true;
// rest of your coding functionality goes here of onClick method.
}
3. last step is to set boolean false in onResume()
@override
onResume()
{
super.onResume(0);
itemClicked = false;
}
ボタンをクリックして新しいフラグメントを開く場合は、開く新しいフラグメントのルートビューにAndroid:clickable="true"を追加するだけです。
汎用ソリューション
@Override
public void onClick(View v) {
tempDisableButton(v);
//all the buttons view..
}
public void tempDisableButton(View viewBtn) {
final View button = viewBtn;
button.setEnabled(false);
button.postDelayed(new Runnable() {
@Override
public void run() {
button.setEnabled(true);
}
}, 3000);
}
私はフラグメントでそのウォーキングを必要とし、クリックを制御するためにフラグを立てるだけです：私は最初のものだけが欲しい、他のものはリスナーにアクセスできません
private boolean flag = true;
...
@Override
public void onClick(View view) {
...
if (flag) {
...
listener.onFragmentInteraction(Constants.MY_FRAGMENT, bundle);
flag = false;
}
...
}
それが役に立つことを願っており、正しくない場合は私を修正してください
booleanフラグを使用したくない（またはできない）場合、またはonClickListenerをオーバーライドする場合は、AndroidManifest.xmlでAndroid:launchMode="singleTop"を使用してアクティビティを宣言することもできます。
仕組みは？
- アクティビティのインスタンスがスタックの一番上にある場合-新しいアクティビティは作成されず、代わりにonNewIntent（）が呼び出されます。
- アクティビティは複数のインスタンスを持つことができます
- インスタンスは異なるタスクに常駐できます
- 1つのタスクに複数のインスタンスを含めることができます
ボタンが新しいアクティビティを起動するだけの場合は、「 singleTop 起動モードと FLAG_ACTIVITY_CLEAR_TOP をインテントに設定することで問題を解決できます。これは、複雑なアクティビティの階層の場合は機能しませんが、単純なツリーのようなアプリケーション構造には適しています。
2ステップのみ。アプリケーションのあらゆる場所で使用できます。
Step1。マネージャーへのシングルトンの作成[複数クリックの回避]
package com.im.av.mediator;
import Android.os.SystemClock;
import Java.util.HashMap;
/**
* Created by ShuHeng on 16/6/1.
*/
public class ClickManager {
private HashMap<Integer,Long> laskClickTimeMap=new HashMap<Integer,Long>();
public volatile static ClickManager mInstance =null;
public static ClickManager getInstance(){
if (mInstance == null) {
synchronized(ClickManager.class) {
if (mInstance == null) {
mInstance = new ClickManager();
}
}
}
return mInstance;
}
public boolean isClickable1s(Integer key){
Long keyLong = laskClickTimeMap.get(key);
if(keyLong==null){
laskClickTimeMap.put(key,SystemClock.elapsedRealtime());
return true;
}else{
if (SystemClock.elapsedRealtime() - keyLong.longValue() < 1000){
return false;
}else{
laskClickTimeMap.put(key,new Long(SystemClock.elapsedRealtime()));
return true;
}
}
}
}
Step2。複数のクリックを避けるために1行追加します。
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
int id = v.getId();
if (id == R.id.iv_back) {
if(!ClickManager.getInstance().isClickable1s(R.id.iv_back))return;
//do something
} else if (id == R.id.iv_light) {
if(!ClickManager.getInstance().isClickable1s(R.id.iv_light))return;
//do something
} else if (id == R.id.iv_camerarotate) {
if(!ClickManager.getInstance().isClickable1s(R.id.iv_camerarotate))return;
//do something
} else if (id == R.id.btn_delete_last_clip) {
if(!ClickManager.getInstance().isClickable1s(R.id.btn_delete_last_clip))return;
//do something
} else if (id == R.id.iv_ok) {
if(!ClickManager.getInstance().isClickable1s(R.id.iv_ok))return;
//do something
}
}