What is the best way to prevent double clicks on a button in Android?
问问题
174031 次
53 回答
420
单击时保存最后一次单击时间将防止此问题。
IE
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
}
}
于 2013-05-13T03:56:40.067 回答
102
Disable the button with setEnabled(false) until it is safe for the user to click it again.
于 2011-04-09T23:56:23.580 回答
64
我的解决方案是
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！");
}
};
于 2013-12-19T03:32:09.930 回答
44
如果您在 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);
于 2012-03-30T21:49:52.623 回答
41
您可以使用Kotlin 扩展函数和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 }
于 2018-01-09T12:33:02.817 回答
22
K LEANEST Kotlin惯用方式：
class OnSingleClickListener(private val block: () -> Unit) : View.OnClickListener {
private var lastClickTime = 0L
override fun onClick(view: View) {
if (SystemClock.elapsedRealtime() - lastClickTime < 1000) {
return
}
lastClickTime = SystemClock.elapsedRealtime()
block()
}
}
fun View.setOnSingleClickListener(block: () -> Unit) {
setOnClickListener(OnSingleClickListener(block))
}
用法：
button.setOnSingleClickListener { ... }
或添加用于控制油门的参数
class OnClickListenerThrottled(private val block: () -> Unit, private val wait: Long) : View.OnClickListener {
private var lastClickTime = 0L
override fun onClick(view: View) {
if (SystemClock.elapsedRealtime() - lastClickTime < wait) {
return
}
lastClickTime = SystemClock.elapsedRealtime()
block()
}
}
/**
* A throttled click listener that only invokes [block] at most once per every [wait] milliseconds.
*/
fun View.setOnClickListenerThrottled(wait: Long = 1000L, block: () -> Unit) {
setOnClickListener(OnClickListenerThrottled(block, wait))
}
用途：
button.setOnClickListenerThrottled(2000L) { /** some action */}
or
button.setOnClickListenerThrottled { /** some action */}
于 2019-09-16T15:21:11.810 回答
17
我也遇到了类似的问题，我正在显示一些日期选择器和时间选择器，有时它会被点击 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);
}
您可以根据需要更改时间。
于 2013-09-28T21:25:21.777 回答
15
我知道这是一个老问题，但我分享了我找到的解决这个常见问题的最佳解决方案
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(
()-> view.setEnabled(true),
500
);
}
于 2017-11-30T19:10:25.603 回答
9
setEnabled(false)非常适合我。
这个想法是我{ setEnabled(true); }一开始就写，然后false在第一次点击按钮时完成。
于 2012-09-12T17:38:51.773 回答
8
这个问题的实际解决方案是使用 setEnabled(false) 使按钮变灰，并使用 setClickable(false) 使其无法接收到第二次点击我已经测试过了，它似乎非常有效。
于 2011-12-16T05:39:57.497 回答
8
如果有人仍在寻找简短的答案，您可以使用以下代码
private static long mLastClickTime = 0;
if (SystemClock.elapsedRealtime() - mLastClickTime < 1000) { // 1000 = 1second
return;
}
mLastClickTime = SystemClock.elapsedRealtime();
if statement每当用户单击 时，此代码将进入内部View within 1 second，然后return;将启动，并且不会启动进一步的代码。
于 2018-01-09T11:30:38.243 回答
6
在科特林
button.setOnClickListener {
it?.apply { isEnabled = false; postDelayed({ isEnabled = true }, 400) } //400 ms
//do your work
}
于 2019-11-30T20:04:37.173 回答
6
我的解决方案是尝试使用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.safeClick(listener: View.OnClickListener, blockInMillis: Long = 500) {
var lastClickTime: Long = 0
this.setOnClickListener {
if (SystemClock.elapsedRealtime() - lastClickTime < blockInMillis) return@setOnClickListener
lastClickTime = SystemClock.elapsedRealtime()
listener.onClick(this)
}
}
于 2018-08-22T03:19:20.043 回答
6
我们可以使用刚刚同步的按钮，例如：
示例 #1（Java）
@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);
}
}
Example #2 (kotlin) 使用同步
myButton.setOnClickListener { view ->
synchronized(view) {
view.isEnabled = false
// do something
view.postDelayed({ view.isEnabled = true }, 500L)
}
}
祝你好运）
于 2018-05-15T07:51:25.223 回答
5
in my situation i was using a button view and it was taking the clicks too quickly. just disable the clickable and enable it again after a few seconds...
Basically i made a wrapper class that wraps around your Views onClickListener. you can also set a custom delay if you want.
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);
}
}
and to call it simply do this:
mMyButton.setOnClickListener(new OnClickRateLimitedDecoratedListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
doSomething();
}
}));
or provide your own delay:
mMyButton.setOnClickListener(new OnClickRateLimitedDecoratedListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
doSomething();
}
},1000));
UPDATE: Above ways a little old fashion now that RxJava is so prevalent. as others have mentioned, in android we could use a throttle to slow down the clicks. here is one example:
RxView.clicks(myButton)
.throttleFirst(2000, TimeUnit.MILLISECONDS, AndroidSchedulers.mainThread())
.subscribe {
Log.d("i got delayed clicked")
}
}
you can use this library for it: implementation 'com.jakewharton.rxbinding2:rxbinding:2.0.0'
于 2017-03-16T18:45:23.823 回答
5
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()
}
于 2019-07-04T04:29:55.763 回答
5
Click Guard与黄油刀配合得很好
ClickGuard.guard(mPlayButton);
于 2017-09-08T08:51:41.357 回答
5
下面的代码将阻止用户在几分之一秒内多次单击，并且仅在 3 秒后允许。
private long lastClickTime = 0;
View.OnClickListener buttonHandler = new View.OnClickListener() {
public void onClick(View v) {
// preventing double, using threshold of 3000 ms
if (SystemClock.elapsedRealtime() - lastClickTime < 3000){
return;
}
lastClickTime = SystemClock.elapsedRealtime();
}
}
于 2019-12-10T10:04:01.223 回答
4
如果 onClick 方法没有立即返回，我发现这些建议都不起作用。触摸事件由 Android 排队，只有在第一个事件完成后才会调用下一个 onClick。（因为这是在一个 UI 线程上完成的，这很正常。）我需要使用 onClick 函数完成的时间 + 一个布尔变量来标记给定的 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);
}
于 2016-03-01T15:34:36.283 回答
4
您可以使用此方法。通过使用后期延迟，您可以处理双击事件。
void debounceEffectForClick(查看视图) {
view.setClickable(false);
view.postDelayed(new Runnable() {
@Override
public void run() {
view.setClickable(true);
}
}, 500);
}
于 2018-01-16T07:22:52.213 回答
4
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)
于 2018-07-12T15:12:12.530 回答
4
button.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View view) {
//to prevent double click
button.setOnClickListener(null);
}
});
于 2015-10-05T07:04:43.627 回答
3
我希望这可以帮助你，把代码放在你的事件处理程序中。
//------------------------------------------------ --------------------------------
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 );
}
于 2014-09-25T08:25:06.783 回答
3
对我来说，只记住时间戳并对其进行检查（自上次点击以来已超过 1 秒）有帮助。
于 2012-11-26T12:12:08.970 回答
3
似乎在 onResume 中设置您的点击侦听器并在 onPause 中将它们清空也可以解决问题。
于 2011-05-12T13:03:25.830 回答
3
fun View.setOnSingleClick(onClick: () -> Unit) {
var lastClickTime = 0L
setOnClickListener {
if (currentTimeMillis() > lastClickTime + 750) onClick()
lastClickTime = currentTimeMillis()
}
}
用法：
aView.setOnSingleClick { }
于 2019-11-05T16:10:23.670 回答
3
我的解决方案（科特林）：
class OnDebouncedClickListener(private val delayInMilliSeconds: Long, val action: () -> Unit) : View.OnClickListener {
var enable = true
override fun onClick(view: View?) {
if (enable) {
enable = false
view?.postDelayed(delayInMilliSeconds) { enable = true }
action()
}
}
}
fun View.setOnDebouncedClickListener(delayInMilliSeconds: Long = 500, action: () -> Unit) {
val onDebouncedClickListener = OnDebouncedClickListener(delayInMilliSeconds, action)
setOnClickListener(onDebouncedClickListener)
}
利用 ：
button.apply {
setOnDebouncedClickListener {
//your action on click
}
}
于 2020-01-09T14:49:03.097 回答
3
您还可以使用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，我总是认为。
于 2017-08-12T18:21:24.573 回答
2
我使用两个类来解决这个问题，一个类似于@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);
于 2015-04-12T18:06:59.203 回答
2
将 Clickable 设置为 false 对第一次双击不起作用，但随后的双击被阻止。就好像第一次加载点击委托比较慢，第二次点击在第一次完成之前被捕获。
Button button = contentView.FindViewById<Button>(Resource.Id.buttonIssue);
button.Clickable = false;
IssueSelectedItems();
button.Clickable = true;
于 2012-03-28T15:57:36.427 回答
2
这个解决方案（Kotlin）适用于我：
abstract class SingleClickListener : View.OnClickListener {
private val MIN_CLICK_INTERVAL: Long = 1000
private var mLastClickTime: Long = 0
abstract fun onSingleClick(v: View?)
override fun onClick(v: View?) {
if (mLastClickTime <= 0) {
mLastClickTime = SystemClock.uptimeMillis()
onSingleClick(v)
return
}
if (SystemClock.uptimeMillis() - mLastClickTime <= MIN_CLICK_INTERVAL) {
return
}
mLastClickTime = SystemClock.uptimeMillis()
onSingleClick(v)
}
}
用法：
someView.setOnClickListener(object : SingleClickListener() {
override fun onSingleClick(v: View?) {
v?.also { klik(it) }
}
})
或者还可以创建扩展函数以轻松在视图上添加 ClickListener：
fun View.click(klik: (View) -> Unit) {
this.setOnClickListener(object : SingleClickListener() {
override fun onSingleClick(v: View?) {
v?.also { klik(it) }
}
})
}
// Usage
class XPerimentActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_xperiment_layout)
submit_button.click {
// do your magic
}
}
}
于 2020-11-01T06:18:24.450 回答
2
试试这个，它正在工作：
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
}
});
于 2016-12-14T13:09:36.153 回答
2
Java中有一个原生的去抖动点击监听器
view.setOnClickListener(new DebouncedOnClickListener(1000) { //in milisecs
@Override
public void onDebouncedClick(View v) {
//action
}
});
于 2020-09-29T08:31:15.680 回答
2
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");
}
});
于 2016-11-06T20:16:05.957 回答
1
使用 Kotlin 扩展功能：
fun View.onSingleClick(action: (v: View) -> Unit) {
setOnClickListener(object : View.OnClickListener {
override fun onClick(v: View) {
isEnabled = false
action(v)
postDelayed({ isEnabled = true }, 700)
}
})
}
用法：
button.onSingleClick { myAction() }
于 2021-01-10T09:09:25.283 回答
1
以下是具有扩展功能的 kotlin 方式，适用于所有视图，请在 Utils 或任何文件中保留以下功能
fun View.preventDoubleClick() {
this.isEnabled = false
this.postDelayed( { this.isEnabled = true }, 1000)
}
下面是如何从片段或活动中使用它
anyIdOfView?.setOnClickListener {
it.preventDoubleClick()
YourAction()
}
于 2021-11-01T15:51:17.803 回答
1
只需 2 步，您就可以在应用程序的任何地方使用它。
步骤 1。为经理创建一个单身人士[避免多次点击]
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;
}
}
}
}
步骤 2。添加一行以避免多次单击。
@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
}
}
于 2016-06-02T02:10:40.363 回答
0
如果您不想（或不能）使用boolean标志或覆盖onClickListener，您也可以尝试android:launchMode="singleTop"在 AndroidManifest.xml 中声明您的活动。
它是如何工作的？
- 如果 Activity 的实例位于堆栈的顶部，则不会创建新的 Activity，而是会调用 onNewIntent()。
- Activity 可以有多个实例
- 实例可以驻留在不同的任务中
- 一项任务可以有多个实例
于 2014-06-26T07:23:34.183 回答
0
我更喜欢使用信号量块。它是线程安全的，不仅可以用于按钮。
代码示例很简单：
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;
}
}
于 2015-05-01T09:17:10.720 回答
0
如果按钮所做的唯一事情是启动一个新活动，则可以通过“ singleTop ”活动启动模式和在意图上设置FLAG_ACTIVITY_CLEAR_TOP来解决问题。这不适用于复杂活动的层次结构，但适用于简单的树状应用程序结构。
于 2015-05-06T03:53:36.650 回答
0
该解决方案快速而简洁。
基本上，您只需防止应用程序中基本样式的双重触摸，并在点击侦听器上实现标准。这就像一种魅力，同时具有不同的观点。
<style name="AppTheme" parent="Theme.AppCompat.NoActionBar">
...
<item name="android:splitMotionEvents">false</item>
<item name="android:windowEnableSplitTouch">false</item>
</style>
如果您的应用程序使用某种手势事件，这不是正确的答案。
于 2019-10-28T20:51:51.840 回答
0
如果单击按钮，您正在打开一个新片段，只需添加android:clickable="true"到正在打开的新片段的根视图。
于 2017-04-05T10:05:23.807 回答
0
试试这个 Kotlin 扩展功能：
private var lastClickTime = 0L
fun View.click(action: () -> Unit) {
setOnClickListener {
if (SystemClock.elapsedRealtime() - lastClickTime < 600L)
return@setOnClickListener
lastClickTime = SystemClock.elapsedRealtime()
action()
}
}
它还可以防止同时单击应用程序的各个部分。
于 2020-06-15T10:26:35.510 回答
0
对于任何使用数据绑定的人：
@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()}"
... />
于 2019-05-31T14:36:26.560 回答
0
根据qezt 的回答，这是一个防止连续点击的OnClickListener 代理。
import android.os.SystemClock;
import android.view.View;
public class MultiClickGuard implements View.OnClickListener {
private long mLastClickTime;
private final int mThresholdMillis;
private final View.OnClickListener mListener;
public MultiClickGuard(View.OnClickListener listener, int thresholdMillis) {
if (listener == null) {
throw new NullPointerException("Null OnClickListener");
}
if (thresholdMillis < 0) {
throw new IllegalArgumentException("Negative click threshold: " + thresholdMillis);
}
mListener = listener;
mThresholdMillis = thresholdMillis;
}
@Override
public void onClick(View v) {
// Using a time threshold to prevent successive clicks.
if (SystemClock.elapsedRealtime() - mLastClickTime < mThresholdMillis) {
return;
}
mLastClickTime = SystemClock.elapsedRealtime();
// Forward the click event to the *real* listener.
mListener.onClick(v);
}
}
使用示例
button.setOnClickListener(new MultiClickGuard(new View.OnClickListener() {
@Override
public void onClick(View v) {
// do something
}
}, 1000));
button.setOnClickListener(new MultiClickGuard(v -> {...}, 1000));
button.setOnClickListener(new MultiClickGuard(v -> doSomething(), 1000));
在您试图阻止启动多个活动实例的情况下，请考虑指定启动模式：了解任务和返回堆栈，这是执行此操作的可靠方法。
如果您试图阻止打开对话框片段的多个实例，您可以检查片段管理器是否已经包含对话框，例如getSupportFragmentManager().findFragmentByTag(tag).
于 2021-03-10T15:01:51.410 回答
0
这是我的解决方案：
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;
}
}
于 2016-10-26T10:19:20.477 回答
0
当 UI 线程被阻塞时，单击事件排队。在按钮单击事件上，尽快更改为后台任务，以避免单击事件相互排队。
在活动类中声明一个 volatile 布尔值或锁：
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;
}
}
于 2016-10-11T12:13:25.613 回答
0
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;
}
于 2018-05-04T06:53:36.287 回答
0
通用解决方案
@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);
}
于 2016-05-09T15:14:56.410 回答
0
正确的方法是在单击时将按钮设置为可点击的 false 并在希望再次使按钮可点击时设置为 true 。例如，考虑以下场景：您在单击按钮时进行服务调用，一旦服务完成，您希望显示一个对话框。为此，单击按钮后，您可以设置 setClickable(false) 并且一旦服务响应，您将通过传递给自定义对话框的引用执行 setClicklable(true)。当对话框调用 isShowing() 时，您可以触发侦听器和 setClicklable(true)。
于 2019-09-22T07:26:43.963 回答
0
防止点击multiply btns
使用：
private val disposables = CompositeDisposable()
private val clickInteractor = ClickInteractor(disposables)
...
button1.setOnClickListener{
clickInteractor.click {
Toast.makeText(context, "Btn1", Toast.LENGTH_LONG).show()
}
}
button2.setOnClickListener{
clickInteractor.click {
Toast.makeText(context, "Btn2", Toast.LENGTH_LONG).show()
}
}
ClickInteractor.kt：
class ClickInteractor constructor(disposables: CompositeDisposable) {
private val performPublish = PublishSubject.create<ClickInteractorCallback>()
init {
performPublish
.subscribeOn(Schedulers.io())
.observeOn(Schedulers.io())
.throttleFirst(1, TimeUnit.SECONDS, Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.doOnNext { callback ->
callback.invoke()
}
.retry()
.execute(disposables)
}
fun click(callback: ClickInteractorCallback) {
performPublish.onNext(callback)
}
}
typealias ClickInteractorCallback = () -> Unit
于 2021-04-15T15:11:21.843 回答
0
我需要使用片段来唤醒，只需放置一个标志来控制点击：我只想要第一个，其他人无法访问侦听器
private boolean flag = true;
...
@Override
public void onClick(View view) {
...
if (flag) {
...
listener.onFragmentInteraction(Constants.MY_FRAGMENT, bundle);
flag = false;
}
...
}
希望有用，如有不妥请指正
于 2016-08-04T17:18:59.883 回答
-3
更优选的解决方案是，
onclick(){
btn.setEnabled(false);
btn.setClickable(false);
//yourwork
myWork();
}
myWork(){
//your tasks.
btn.setEnabled(true);
btn.setClickable(true);
}
由于链接很容易被忽略，我不得不一次又一次地重复这个
于 2013-09-18T03:23:29.063 回答