blocks|key|101729|text|这是我最近写的一个“被揭穿”的onClick监听器。您可以告诉它，两次单击之间可接受的最小毫秒数是多少。用onDebouncedClick而不是onClick实现你的逻辑|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|101730|import+android.os.SystemClock;
import+android.view.View;

import+java.util.Map;
import+java.util.WeakHashMap;

/**
+*+A+Debounced+OnClickListener
+*+Rejects+clicks+that+are+too+close+together+in+time.
+*+This+class+is+safe+to+use+as+an+OnClickListener+for+multiple+views,+and+will+debounce+each+one+separately.
+*/
public+abstract+class+DebouncedOnClickListener+implements+View.OnClickListener+{

++++private+final+long+minimumIntervalMillis;
++++private+Map<View,+Long>+lastClickMap;

++++/**
+++++*+Implement+this+in+your+subclass+instead+of+onClick
+++++*+@param+v+The+view+that+was+clicked
+++++*/
++++public+abstract+void+onDebouncedClick(View+v);

++++/**
+++++*+The+one+and+only+constructor
+++++*+@param+minimumIntervalMillis+The+minimum+allowed+time+between+clicks+-+any+click+sooner+than+this+after+a+previous+click+will+be+rejected
+++++*/
++++public+DebouncedOnClickListener(long+minimumIntervalMillis)+{
++++++++this.minimumIntervalMillis+=+minimumIntervalMillis;
++++++++this.lastClickMap+=+new+WeakHashMap<>();
++++}

++++@Override+
++++public+void+onClick(View+clickedView)+{
++++++++Long+previousClickTimestamp+=+lastClickMap.get(clickedView);
++++++++long+currentTimestamp+=+SystemClock.uptimeMillis();

++++++++lastClickMap.put(clickedView,+currentTimestamp);
++++++++if(previousClickTimestamp+==+null+%7C%7C+Math.abs(currentTimestamp+-+previousClickTimestamp)+>+minimumIntervalMillis)+{
++++++++++++onDebouncedClick(clickedView);
++++++++}
++++}
}|code-block|syntax|javascript|101731|entityMap^0|1H|G|20|7|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

Here's a 'debounced' onClick listener that I wrote recently.
You tell it what the minimum acceptable number of milliseconds between clicks is.
Implement your logic in <code>onDebouncedClick</code> instead of <code>onClick</code>

<pre><code>import android.os.SystemClock;
import android.view.View;

import java.util.Map;
import java.util.WeakHashMap;

/**
 * A Debounced OnClickListener
 * Rejects clicks that are too close together in time.
 * This class is safe to use as an OnClickListener for multiple views, and will debounce each one separately.
 */
public abstract class DebouncedOnClickListener implements View.OnClickListener {

 private final long minimumIntervalMillis;
 private Map&lt;View, Long&gt; lastClickMap;

 /**
 * Implement this in your subclass instead of onClick
 * @param v The view that was clicked
 */
 public abstract void onDebouncedClick(View v);

 /**
 * The one and only constructor
 * @param minimumIntervalMillis The minimum allowed time between clicks - any click sooner than this after a previous click will be rejected
 */
 public DebouncedOnClickListener(long minimumIntervalMillis) {
 this.minimumIntervalMillis = minimumIntervalMillis;
 this.lastClickMap = new WeakHashMap&lt;&gt;();
 }

 @Override 
 public void onClick(View clickedView) {
 Long previousClickTimestamp = lastClickMap.get(clickedView);
 long currentTimestamp = SystemClock.uptimeMillis();

 lastClickMap.put(clickedView, currentTimestamp);
 if(previousClickTimestamp == null || Math.abs(currentTimestamp - previousClickTimestamp) &gt; minimumIntervalMillis) {
 onDebouncedClick(clickedView);
 }
 }
}
</code></pre>

blocks|key|101782|text|这是我接受的答案的版本。它非常类似，但没有尝试将视图存储在Map中，我认为这不是一个好主意。它还添加了一个在许多情况下都很有用的wrap方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|101783|/**
+*+Implementation+of+{@link+OnClickListener}+that+ignores+subsequent+clicks+that+happen+too+quickly+after+the+first+one. 
+*+To+use+this+class,+implement+{@link+#onSingleClick(View)}+instead+of+{@link+OnClickListener#onClick(View)}.
+*/
public+abstract+class+OnSingleClickListener+implements+OnClickListener+{
++++private+static+final+String+TAG+=+OnSingleClickListener.class.getSimpleName();

++++private+static+final+long+MIN_DELAY_MS+=+500;

++++private+long+mLastClickTime;

++++@Override
++++public+final+void+onClick(View+v)+{
++++++++long+lastClickTime+=+mLastClickTime;
++++++++long+now+=+System.currentTimeMillis();
++++++++mLastClickTime+=+now;
++++++++if+(now+-+lastClickTime+<+MIN_DELAY_MS)+{
++++++++++++//+Too+fast:+ignore
++++++++++++if+(Config.LOGD)+Log.d(TAG,+"onClick+Clicked+too+quickly:+ignored");
++++++++}+else+{
++++++++++++//+Register+the+click
++++++++++++onSingleClick(v);
++++++++}
++++}

++++/**
+++++*+Called+when+a+view+has+been+clicked.
+++++*+
+++++*+@param+v+The+view+that+was+clicked.
+++++*/
++++public+abstract+void+onSingleClick(View+v);

++++/**
+++++*+Wraps+an+{@link+OnClickListener}+into+an+{@link+OnSingleClickListener}. 
+++++*+The+argument's+{@link+OnClickListener#onClick(View)}+method+will+be+called+when+a+single+click+is+registered.
+++++*+
+++++*+@param+onClickListener+The+listener+to+wrap.
+++++*+@return+the+wrapped+listener.
+++++*/
++++public+static+OnClickListener+wrap(final+OnClickListener+onClickListener)+{
++++++++return+new+OnSingleClickListener()+{
++++++++++++@Override
++++++++++++public+void+onSingleClick(View+v)+{
++++++++++++++++onClickListener.onClick(v);
++++++++++++}
++++++++};
++++}
}|code-block|syntax|javascript|101784|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here's my version of the accepted answer. It is very similar, but doesn't try to store Views in a Map which I don't think is such a good idea.
It also adds a wrap method that could be useful in many situations.

<pre><code>/**
 * Implementation of {@link OnClickListener} that ignores subsequent clicks that happen too quickly after the first one.&lt;br/&gt;
 * To use this class, implement {@link #onSingleClick(View)} instead of {@link OnClickListener#onClick(View)}.
 */
public abstract class OnSingleClickListener implements OnClickListener {
 private static final String TAG = OnSingleClickListener.class.getSimpleName();

 private static final long MIN_DELAY_MS = 500;

 private long mLastClickTime;

 @Override
 public final void onClick(View v) {
 long lastClickTime = mLastClickTime;
 long now = System.currentTimeMillis();
 mLastClickTime = now;
 if (now - lastClickTime &lt; MIN_DELAY_MS) {
 // Too fast: ignore
 if (Config.LOGD) Log.d(TAG, "onClick Clicked too quickly: ignored");
 } else {
 // Register the click
 onSingleClick(v);
 }
 }

 /**
 * Called when a view has been clicked.
 * 
 * @param v The view that was clicked.
 */
 public abstract void onSingleClick(View v);

 /**
 * Wraps an {@link OnClickListener} into an {@link OnSingleClickListener}.&lt;br/&gt;
 * The argument's {@link OnClickListener#onClick(View)} method will be called when a single click is registered.
 * 
 * @param onClickListener The listener to wrap.
 * @return the wrapped listener.
 */
 public static OnClickListener wrap(final OnClickListener onClickListener) {
 return new OnSingleClickListener() {
 @Override
 public void onSingleClick(View v) {
 onClickListener.onClick(v);
 }
 };
 }
}
</code></pre>

blocks|key|101790|text|下面是一个简单的例子：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|101791|public+abstract+class+SingleClickListener+implements+View.OnClickListener+{
++++private+static+final+long+THRESHOLD_MILLIS+=+1000L;
++++private+long+lastClickMillis;

++++@Override+public+void+onClick(View+v)+{
++++++++long+now+=+SystemClock.elapsedRealtime();
++++++++if+(now+-+lastClickMillis+>+THRESHOLD_MILLIS)+{
++++++++++++onClicked(v);
++++++++}
++++++++lastClickMillis+=+now;
++++}

++++public+abstract+void+onClicked(View+v);
}|code-block|syntax|javascript|101792|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here's a simple example:

<pre><code>public abstract class SingleClickListener implements View.OnClickListener {
 private static final long THRESHOLD_MILLIS = 1000L;
 private long lastClickMillis;

 @Override public void onClick(View v) {
 long now = SystemClock.elapsedRealtime();
 if (now - lastClickMillis &gt; THRESHOLD_MILLIS) {
 onClicked(v);
 }
 lastClickMillis = now;
 }

 public abstract void onClicked(View v);
}
</code></pre>

blocks|key|101847|text|您可以使用此项目：https://github.com/fengdai/clickguard通过一条语句解决此问题：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|101848|ClickGuard.guard(button);|code-block|syntax|javascript|101849|更新:不再推荐这个库。我更喜欢尼基塔的解决方案。请改用RxBinding。|101850|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/fengdai/clickguard^0|9|11|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

You can use this project: <a href="https://github.com/fengdai/clickguard" rel="nofollow noreferrer">https://github.com/fengdai/clickguard</a>
to resolve this problem with a single statement:

<pre><code>ClickGuard.guard(button);
</code></pre>

UPDATE: This library is not recommended any more. I prefer Nikita's solution. Use RxBinding instead.

blocks|key|318991|text|只是对GreyBeardedGeek解决方案的快速更新。更改if子句并添加Math.abs函数。如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|318992|++if(previousClickTimestamp+==+null+%7C%7C+(Math.abs(currentTimestamp+-+previousClickTimestamp.longValue())+>+minimumInterval))+{
++++++++onDebouncedClick(clickedView);
++++}|code-block|syntax|javascript|318993|用户可以更改Android设备上的时间并将其设置为过去的时间，因此如果不这样做，可能会导致错误。|318994|PS:没有足够的分数来评论你的解决方案，所以我只是换了一个答案。|318995|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Just a quick update on GreyBeardedGeek solution. Change if clause and add Math.abs function. Set it like this:

<pre><code> if(previousClickTimestamp == null || (Math.abs(currentTimestamp - previousClickTimestamp.longValue()) &gt; minimumInterval)) {
 onDebouncedClick(clickedView);
 }
</code></pre>

The user can change the time on Android device and put it in past, so without this it could lead to bug. 

PS: don't have enough points to comment on your solution, so I just put another answer.

blocks|key|101898|text|使用RxJava的类似解决方案|type|unstyled|depth|inlineStyleRanges|entityRanges|data|101899|import+android.view.View;

import+java.util.concurrent.TimeUnit;

import+rx.android.schedulers.AndroidSchedulers;
import+rx.functions.Action1;
import+rx.subjects.PublishSubject;

public+abstract+class+SingleClickListener+implements+View.OnClickListener+{
++++private+static+final+long+THRESHOLD_MILLIS+=+600L;
++++private+final+PublishSubject<View>+viewPublishSubject+=+PublishSubject.<View>create();

++++public+SingleClickListener()+{
++++++++viewPublishSubject.throttleFirst(THRESHOLD_MILLIS,+TimeUnit.MILLISECONDS)
++++++++++++++++.observeOn(AndroidSchedulers.mainThread())
++++++++++++++++.subscribe(new+Action1<View>()+{
++++++++++++++++++++@Override
++++++++++++++++++++public+void+call(View+view)+{
++++++++++++++++++++++++onClicked(view);
++++++++++++++++++++}
++++++++++++++++});
++++}

++++@Override
++++public+void+onClick(View+v)+{
++++++++viewPublishSubject.onNext(v);
++++}

++++public+abstract+void+onClicked(View+v);
}|code-block|syntax|javascript|101900|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Similar Solution using RxJava

<pre><code>import android.view.View;

import java.util.concurrent.TimeUnit;

import rx.android.schedulers.AndroidSchedulers;
import rx.functions.Action1;
import rx.subjects.PublishSubject;

public abstract class SingleClickListener implements View.OnClickListener {
 private static final long THRESHOLD_MILLIS = 600L;
 private final PublishSubject&lt;View&gt; viewPublishSubject = PublishSubject.&lt;View&gt;create();

 public SingleClickListener() {
 viewPublishSubject.throttleFirst(THRESHOLD_MILLIS, TimeUnit.MILLISECONDS)
 .observeOn(AndroidSchedulers.mainThread())
 .subscribe(new Action1&lt;View&gt;() {
 @Override
 public void call(View view) {
 onClicked(view);
 }
 });
 }

 @Override
 public void onClick(View v) {
 viewPublishSubject.onNext(v);
 }

 public abstract void onClicked(View v);
}
</code></pre>

blocks|key|101940|text|使用RxBinding可以很容易地完成此任务。下面是一个示例：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|101941|RxView.clicks(view).throttleFirst(500,+TimeUnit.MILLISECONDS).subscribe(empty+->+{
++++++++++++//+action+on+click
++++++++});|code-block|syntax|javascript|101942|在build.gradle中添加以下行，以添加RxBinding依赖：|style|CODE|101943|compile+'com.jakewharton.rxbinding:rxbinding:0.3.0'|101944|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/JakeWharton/RxBinding^0|2|9|0|0|0|1|C|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|11|8|@$A|12|B|13|K|L]]|9|@]|C|$]]|$1|M|3|N|5|F|7|14|8|@]|9|@]|C|$G|H]]|$1|O|3|-4|5|6|7|15|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]]]

With <a href="https://github.com/JakeWharton/RxBinding">RxBinding</a> it can be done easily. Here is an example:

<pre><code>RxView.clicks(view).throttleFirst(500, TimeUnit.MILLISECONDS).subscribe(empty -&gt; {
 // action on click
 });
</code></pre>

Add the following line in <code>build.gradle</code> to add RxBinding dependency:

<pre><code>compile 'com.jakewharton.rxbinding:rxbinding:0.3.0'
</code></pre>

blocks|key|319069|text|这是这样解决的|type|unstyled|depth|inlineStyleRanges|entityRanges|data|319070|Observable<Object>+tapEventEmitter+=+_rxBus.toObserverable().share();
Observable<Object>+debouncedEventEmitter+=+tapEventEmitter.debounce(1,+TimeUnit.SECONDS);
Observable<List<Object>>+debouncedBufferEmitter+=+tapEventEmitter.buffer(debouncedEventEmitter);

debouncedBufferEmitter.buffer(debouncedEventEmitter)
++++.observeOn(AndroidSchedulers.mainThread())
++++.subscribe(new+Action1<List<Object>>()+{
++++++@Override
++++++public+void+call(List<Object>+taps)+{
++++++++_showTapCount(taps.size());
++++++}
++++});|code-block|syntax|javascript|319071|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This is solved like this

<pre><code>Observable&lt;Object&gt; tapEventEmitter = _rxBus.toObserverable().share();
Observable&lt;Object&gt; debouncedEventEmitter = tapEventEmitter.debounce(1, TimeUnit.SECONDS);
Observable&lt;List&lt;Object&gt;&gt; debouncedBufferEmitter = tapEventEmitter.buffer(debouncedEventEmitter);

debouncedBufferEmitter.buffer(debouncedEventEmitter)
 .observeOn(AndroidSchedulers.mainThread())
 .subscribe(new Action1&lt;List&lt;Object&gt;&gt;() {
 @Override
 public void call(List&lt;Object&gt; taps) {
 _showTapCount(taps.size());
 }
 });
</code></pre>

blocks|key|102001|text|这里有一些东西可以用在任何事件上，而不仅仅是点击。它还将提供最后一个事件，即使它是一系列快速事件(如rx+debounce)的一部分。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|102002|class+Debouncer(timeout:+Long,+unit:+TimeUnit,+fn:+()+->+Unit)+{

++++private+val+timeoutMillis+=+unit.toMillis(timeout)

++++private+var+lastSpamMillis+=+0L

++++private+val+handler+=+Handler()

++++private+val+runnable+=+Runnable+{
++++++++fn()
++++}

++++fun+spam()+{
++++++++if+(SystemClock.uptimeMillis()+-+lastSpamMillis+<+timeoutMillis)+{
++++++++++++handler.removeCallbacks(runnable)
++++++++}
++++++++handler.postDelayed(runnable,+timeoutMillis)
++++++++lastSpamMillis+=+SystemClock.uptimeMillis()
++++}
}


//+example
view.addOnClickListener.setOnClickListener(object:+View.OnClickListener+{
++++val+debouncer+=+Debouncer(1,+TimeUnit.SECONDS,+{
++++++++showSomething()
++++})

++++override+fun+onClick(v:+View?)+{
++++++++debouncer.spam()
++++}
})|code-block|syntax|javascript|102003|1)在监听器的某个字段内，在回调函数的外部构造Debouncer，配置timeout和您要限制的回调fn。|102004|2)在监听器的回调函数中调用您的Debouncer的垃圾邮件方法。|102005|entityMap|0|LINK|mutability|MUTABLE|url|http://reactivex.io/documentation/operators/debounce.html^0|1E|B|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|C|$]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|C|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

Here's something that will work with any event, not just clicks. It will also deliver the last event even if it's part of a series of rapid events (like <a href="http://reactivex.io/documentation/operators/debounce.html" rel="noreferrer">rx debounce</a>).

<pre><code>class Debouncer(timeout: Long, unit: TimeUnit, fn: () -&gt; Unit) {

 private val timeoutMillis = unit.toMillis(timeout)

 private var lastSpamMillis = 0L

 private val handler = Handler()

 private val runnable = Runnable {
 fn()
 }

 fun spam() {
 if (SystemClock.uptimeMillis() - lastSpamMillis &lt; timeoutMillis) {
 handler.removeCallbacks(runnable)
 }
 handler.postDelayed(runnable, timeoutMillis)
 lastSpamMillis = SystemClock.uptimeMillis()
 }
}


// example
view.addOnClickListener.setOnClickListener(object: View.OnClickListener {
 val debouncer = Debouncer(1, TimeUnit.SECONDS, {
 showSomething()
 })

 override fun onClick(v: View?) {
 debouncer.spam()
 }
})
</code></pre>

1) Construct Debouncer in a field of the listener but outside of the callback function, configured with timeout and the callback fn that you want to throttle.

2) Call your Debouncer's spam method in the listener's callback function.

blocks|key|319129|text|我将这个类与数据绑定一起使用。效果很好。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|319130|/**
+*+This+class+will+prevent+multiple+clicks+being+dispatched.
+*/
class+OneClickListener(private+val+onClickListener:+View.OnClickListener)+:+View.OnClickListener+{
++++private+var+lastTime:+Long+=+0

++++override+fun+onClick(v:+View?)+{
++++++++val+current+=+System.currentTimeMillis()
++++++++if+((current+-+lastTime)+>+500)+{
++++++++++++onClickListener.onClick(v)
++++++++++++lastTime+=+current
++++++++}
++++}

++++companion+object+{
++++++++@JvmStatic+@BindingAdapter("oneClick")
++++++++fun+setOnClickListener(theze:+View,+f:+View.OnClickListener?)+{
++++++++++++when+(f)+{
++++++++++++++++null+->+theze.setOnClickListener(null)
++++++++++++++++else+->+theze.setOnClickListener(OneClickListener(f))
++++++++++++}
++++++++}
++++}
}|code-block|syntax|javascript|319131|我的布局看起来像这样|319132|<TextView
++++++++app:layout_constraintTop_toBottomOf="@id/bla"
++++++++app:layout_constraintLeft_toLeftOf="parent"
++++++++app:layout_constraintRight_toRightOf="parent"
++++++++android:gravity="center"
++++++++android:textSize="18sp"
++++++++app:oneClick="@{viewModel::myHandler}"+/>|319133|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I use this class together with databinding. Works great.

<pre><code>/**
 * This class will prevent multiple clicks being dispatched.
 */
class OneClickListener(private val onClickListener: View.OnClickListener) : View.OnClickListener {
 private var lastTime: Long = 0

 override fun onClick(v: View?) {
 val current = System.currentTimeMillis()
 if ((current - lastTime) &gt; 500) {
 onClickListener.onClick(v)
 lastTime = current
 }
 }

 companion object {
 @JvmStatic @BindingAdapter("oneClick")
 fun setOnClickListener(theze: View, f: View.OnClickListener?) {
 when (f) {
 null -&gt; theze.setOnClickListener(null)
 else -&gt; theze.setOnClickListener(OneClickListener(f))
 }
 }
 }
}
</code></pre>

And my layout looks like this

<pre><code>&lt;TextView
 app:layout_constraintTop_toBottomOf="@id/bla"
 app:layout_constraintLeft_toLeftOf="parent"
 app:layout_constraintRight_toRightOf="parent"
 android:gravity="center"
 android:textSize="18sp"
 app:oneClick="@{viewModel::myHandler}" /&gt;
</code></pre>

blocks|key|319154|text|来自Signal+App的基于Handler的节流器。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|319155|import+android.os.Handler;
import+android.support.annotation.NonNull;

/**
+*+A+class+that+will+throttle+the+number+of+runnables+executed+to+be+at+most+once+every+specified
+*+interval.
+*
+*+Useful+for+performing+actions+in+response+to+rapid+user+input+where+you+want+to+take+action+on
+*+the+initial+input+but+prevent+follow-up+spam.
+*
+*+This+is+different+from+a+Debouncer+in+that+it+will+run+the+first+runnable+immediately
+*+instead+of+waiting+for+input+to+die+down.
+*
+*+See+http://rxmarbles.com/#throttle
+*/
public+final+class+Throttler+{

++++private+static+final+int+WHAT+=+8675309;

++++private+final+Handler+handler;
++++private+final+long++++thresholdMs;

++++/**
+++++*+@param+thresholdMs+Only+one+runnable+will+be+executed+via+{@link+#publish}+every
+++++*++++++++++++++++++{@code+thresholdMs}+milliseconds.
+++++*/
++++public+Throttler(long+thresholdMs)+{
++++++++this.handler+++++=+new+Handler();
++++++++this.thresholdMs+=+thresholdMs;
++++}

++++public+void+publish(@NonNull+Runnable+runnable)+{
++++++++if+(handler.hasMessages(WHAT))+{
++++++++++++return;
++++++++}

++++++++runnable.run();
++++++++handler.sendMessageDelayed(handler.obtainMessage(WHAT),+thresholdMs);
++++}

++++public+void+clear()+{
++++++++handler.removeCallbacksAndMessages(null);
++++}
}|code-block|syntax|javascript|319156|示例用法：|319157|throttler.publish(()+->+Log.d("TAG",+"Example"));|319158|OnClickListener中的用法示例|319159|view.setOnClickListener(v+->+throttler.publish(()+->+Log.d("TAG",+"Example")));|319160|Kt用法示例：|319161|view.setOnClickListener+{
++++throttler.publish+{
++++++++Log.d("TAG",+"Example")
++++}
}|319162|或使用扩展名：|319163|fun+View.setThrottledOnClickListener(throttler:+Throttler,+function:+()+->+Unit)+{
++++throttler.publish(function)
}|319164|然后举例用法：|319165|view.setThrottledOnClickListener(throttler)+{
++++Log.d("TAG",+"Example")
}|319166|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/signalapp/Signal-Android/blob/master/src/org/thoughtcrime/securesms/util/Throttler.java^0|F|7|2|A|0|0|0|0|0|0|F|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1C|8|@$9|1D|A|1E|B|C]]|D|@$9|1F|A|1G|1|1H]]|E|$]]|$1|F|3|G|5|H|7|1I|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1J|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|1K|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1L|8|@$9|1M|A|1N|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|H|7|1O|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|1P|8|@]|D|@]|E|$]]|$1|U|3|V|5|H|7|1Q|8|@]|D|@]|E|$I|J]]|$1|W|3|X|5|6|7|1R|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|H|7|1S|8|@]|D|@]|E|$I|J]]|$1|10|3|11|5|6|7|1T|8|@]|D|@]|E|$]]|$1|12|3|13|5|H|7|1U|8|@]|D|@]|E|$I|J]]|$1|14|3|-4|5|6|7|1V|8|@]|D|@]|E|$]]]|15|$16|$5|17|18|19|E|$1A|1B]]]]

A <code>Handler</code> based throttler from <a href="https://github.com/signalapp/Signal-Android/blob/master/src/org/thoughtcrime/securesms/util/Throttler.java" rel="nofollow noreferrer">Signal App</a>.

<pre><code>import android.os.Handler;
import android.support.annotation.NonNull;

/**
 * A class that will throttle the number of runnables executed to be at most once every specified
 * interval.
 *
 * Useful for performing actions in response to rapid user input where you want to take action on
 * the initial input but prevent follow-up spam.
 *
 * This is different from a Debouncer in that it will run the first runnable immediately
 * instead of waiting for input to die down.
 *
 * See http://rxmarbles.com/#throttle
 */
public final class Throttler {

 private static final int WHAT = 8675309;

 private final Handler handler;
 private final long thresholdMs;

 /**
 * @param thresholdMs Only one runnable will be executed via {@link #publish} every
 * {@code thresholdMs} milliseconds.
 */
 public Throttler(long thresholdMs) {
 this.handler = new Handler();
 this.thresholdMs = thresholdMs;
 }

 public void publish(@NonNull Runnable runnable) {
 if (handler.hasMessages(WHAT)) {
 return;
 }

 runnable.run();
 handler.sendMessageDelayed(handler.obtainMessage(WHAT), thresholdMs);
 }

 public void clear() {
 handler.removeCallbacksAndMessages(null);
 }
}
</code></pre>

Example usage:

<pre><code>throttler.publish(() -&gt; Log.d("TAG", "Example"));
</code></pre>

Example usage in an <code>OnClickListener</code>:

<pre><code>view.setOnClickListener(v -&gt; throttler.publish(() -&gt; Log.d("TAG", "Example")));
</code></pre>

Example Kt usage:

<pre><code>view.setOnClickListener {
 throttler.publish {
 Log.d("TAG", "Example")
 }
}
</code></pre>

Or with an extension:

<pre><code>fun View.setThrottledOnClickListener(throttler: Throttler, function: () -&gt; Unit) {
 throttler.publish(function)
}
</code></pre>

Then example usage:

<pre><code>view.setThrottledOnClickListener(throttler) {
 Log.d("TAG", "Example")
}
</code></pre>

blocks|key|102089|text|我们不需要任何库就可以做到这一点。只需创建一个扩展函数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|102090|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()
++++++++}
++++})
}|code-block|syntax|javascript|102091|使用以下代码查看onClick：|102092|buttonShare.clickWithDebounce+{+
+++//+Do+anything+you+want
}|102093|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

We can do it without any library. Just create one single extension function:
<pre><code>fun View.clickWithDebounce(debounceTime: Long = 600L, action: () -&gt; Unit) {
 this.setOnClickListener(object : View.OnClickListener {
 private var lastClickTime: Long = 0

 override fun onClick(v: View) {
 if (SystemClock.elapsedRealtime() - lastClickTime &lt; debounceTime) return
 else action()

 lastClickTime = SystemClock.elapsedRealtime()
 }
 })
}
</code></pre>
View onClick using below code:
<pre><code>buttonShare.clickWithDebounce { 
 // Do anything you want
}
</code></pre>

blocks|key|102131|text|我的解决方案是，当我们从片段和活动中退出(销毁)时需要调用removeall：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|102132|import+android.os.Handler
import+android.os.Looper
import+java.util.concurrent.TimeUnit

++++//single+click+handler
++++object+ClickHandler+{

++++++++//used+to+post+messages+and+runnable+objects
++++++++private+val+mHandler+=+Handler(Looper.getMainLooper())

++++++++//default+delay+is+250+millis
++++++++@Synchronized
++++++++fun+handle(runnable:+Runnable,+delay:+Long+=+TimeUnit.MILLISECONDS.toMillis(250))+{
++++++++++++removeAll()//remove+all+before+placing+event+so+that+only+one+event+will+execute+at+a+time
++++++++++++mHandler.postDelayed(runnable,+delay)
++++++++}

++++++++@Synchronized
++++++++fun+removeAll()+{
++++++++++++mHandler.removeCallbacksAndMessages(null)
++++++++}
++++}|code-block|syntax|javascript|102133|entityMap^0|T|9|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

My solution, need to call <code>removeall</code> when we exit (destroy) from the fragment and activity:

<pre><code>import android.os.Handler
import android.os.Looper
import java.util.concurrent.TimeUnit

 //single click handler
 object ClickHandler {

 //used to post messages and runnable objects
 private val mHandler = Handler(Looper.getMainLooper())

 //default delay is 250 millis
 @Synchronized
 fun handle(runnable: Runnable, delay: Long = TimeUnit.MILLISECONDS.toMillis(250)) {
 removeAll()//remove all before placing event so that only one event will execute at a time
 mHandler.postDelayed(runnable, delay)
 }

 @Synchronized
 fun removeAll() {
 mHandler.removeCallbacksAndMessages(null)
 }
 }
</code></pre>

blocks|key|102185|text|我想说最简单的方法是使用像KProgressHUD这样的“加载”库。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|102186|https://github.com/Kaopiz/KProgressHUD|offset|length|102187|onClick方法的第一件事是调用加载动画，它会立即阻止所有UI，直到开发人员决定释放它。|102188|因此，对于onClick操作，您可以使用以下代码(这使用了蝶形刀，但它显然适用于任何类型的方法)：|102189|另外，别忘了在点击后禁用按钮。|102190|@OnClick(R.id.button)
void+didClickOnButton()+{
++++startHUDSpinner();
++++button.setEnabled(false);
++++doAction();
}|code-block|syntax|javascript|102191|然后：|102192|public+void+startHUDSpinner()+{
++++stopHUDSpinner();
++++currentHUDSpinner+=+KProgressHUD.create(this)
++++++++++++.setStyle(KProgressHUD.Style.SPIN_INDETERMINATE)
++++++++++++.setLabel(getString(R.string.loading_message_text))
++++++++++++.setCancellable(false)
++++++++++++.setAnimationSpeed(3)
++++++++++++.setDimAmount(0.5f)
++++++++++++.show();
}

public+void+stopHUDSpinner()+{
++++if+(currentHUDSpinner+!=+null+&&+currentHUDSpinner.isShowing())+{
++++++++currentHUDSpinner.dismiss();
++++}
++++currentHUDSpinner+=+null;
}|102193|如果愿意，还可以在doAction()方法中使用stopHUDSpinner方法：|102194|private+void+doAction(){+
+++//+some+action
+++stopHUDSpinner()
}|102195|根据您的应用逻辑重新启用按钮:+button.setEnabled(true)；|102196|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|12|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|17|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|18|8|@]|9|@$D|19|E|1A|1|1B]]|A|$]]|$1|F|3|G|5|6|7|1C|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|1D|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|1E|8|@]|9|@]|A|$]]|$1|L|3|M|5|N|7|1F|8|@]|9|@]|A|$O|P]]|$1|Q|3|R|5|6|7|1G|8|@]|9|@]|A|$]]|$1|S|3|T|5|N|7|1H|8|@]|9|@]|A|$O|P]]|$1|U|3|V|5|6|7|1I|8|@]|9|@]|A|$]]|$1|W|3|X|5|N|7|1J|8|@]|9|@]|A|$O|P]]|$1|Y|3|Z|5|6|7|1K|8|@]|9|@]|A|$]]|$1|10|3|-4|5|6|7|1L|8|@]|9|@]|A|$]]]|11|$12|$5|13|14|15|A|$16|C]]]]

I would say the easiest way is to use a "loading" library like KProgressHUD.

<a href="https://github.com/Kaopiz/KProgressHUD" rel="nofollow noreferrer">https://github.com/Kaopiz/KProgressHUD</a>

The first thing at the onClick method would be to call the loading animation which instantly blocks all UI until the dev decides to free it.

So you would have this for the onClick action (this uses Butterknife but it obviously works with any kind of approach):

Also, don't forget to disable the button after the click.

<pre><code>@OnClick(R.id.button)
void didClickOnButton() {
 startHUDSpinner();
 button.setEnabled(false);
 doAction();
}
</code></pre>

Then:

<pre><code>public void startHUDSpinner() {
 stopHUDSpinner();
 currentHUDSpinner = KProgressHUD.create(this)
 .setStyle(KProgressHUD.Style.SPIN_INDETERMINATE)
 .setLabel(getString(R.string.loading_message_text))
 .setCancellable(false)
 .setAnimationSpeed(3)
 .setDimAmount(0.5f)
 .show();
}

public void stopHUDSpinner() {
 if (currentHUDSpinner != null &amp;&amp; currentHUDSpinner.isShowing()) {
 currentHUDSpinner.dismiss();
 }
 currentHUDSpinner = null;
}
</code></pre>

And you can use the stopHUDSpinner method in the doAction() method if you so desire:

<pre><code>private void doAction(){ 
 // some action
 stopHUDSpinner()
}
</code></pre>

Re-enable the button according to your app logic:
 button.setEnabled(true);

blocks|key|102246|text|处理这种情况的更重要的方法是在RxJava2中使用节流操作符(首先节流)。在Kotlin中实现这一点的步骤：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|102247|1)。依赖项:-在build.gradle应用级文件中添加rxjava2依赖项。|102248|implementation+'io.reactivex.rxjava2:rxandroid:2.1.1'
implementation+'io.reactivex.rxjava2:rxjava:2.2.10'|code-block|syntax|javascript|102249|2)。构造一个实现View.OnClickListener的抽象类&包含throttle操作符来处理视图的OnClick()方法。代码片段如下：|102250|import+android.util.Log
import+android.view.View
import+io.reactivex.android.schedulers.AndroidSchedulers
import+io.reactivex.subjects.PublishSubject
import+java.util.concurrent.TimeUnit

abstract+class+SingleClickListener+:+View.OnClickListener+{
+++private+val+publishSubject:+PublishSubject<View>+=+PublishSubject.create()
+++private+val+THRESHOLD_MILLIS:+Long+=+600L

+++abstract+fun+onClicked(v:+View)

+++override+fun+onClick(p0:+View?)+{
+++++++if+(p0+!=+null)+{
+++++++++++Log.d("Tag",+"Clicked+occurred")
+++++++++++publishSubject.onNext(p0)
+++++++}
+++}

+++init+{
+++++++publishSubject.throttleFirst(THRESHOLD_MILLIS,+TimeUnit.MILLISECONDS)
+++++++++++++++.observeOn(AndroidSchedulers.mainThread())
+++++++++++++++.subscribe+{+v+->+onClicked(v)+}
+++}
}|102251|3)。在activity中单击视图时实现此SingleClickListener类。这可以通过以下方式实现：|102252|override+fun+onCreate(savedInstanceState:+Bundle?)++{
+++super.onCreate(savedInstanceState)
+++setContentView(R.layout.activity_main)

+++val+singleClickListener+=+object+:+SingleClickListener(){
++++++override+fun+onClicked(v:+View)+{
+++++++//+operation+on+click+of+xm_view_id
++++++}
++}
xm_viewl_id.setOnClickListener(singleClickListener)
}|102253|在应用程序中实现上述步骤，可以简单地避免在600mS之前多次点击视图。祝你编码愉快！|102254|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|10|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

More significant way to handle this scenario is using Throttling operator (Throttle First) with RxJava2.
 Steps to achieve this in Kotlin :

1). Dependencies :- Add rxjava2 dependency in build.gradle app level file.

<pre><code>implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'
implementation 'io.reactivex.rxjava2:rxjava:2.2.10'
</code></pre>

2). Construct an abstract class that implements View.OnClickListener &amp; contains throttle first operator to handle the view’s OnClick() method. Code snippet is as:

<pre><code>import android.util.Log
import android.view.View
import io.reactivex.android.schedulers.AndroidSchedulers
import io.reactivex.subjects.PublishSubject
import java.util.concurrent.TimeUnit

abstract class SingleClickListener : View.OnClickListener {
 private val publishSubject: PublishSubject&lt;View&gt; = PublishSubject.create()
 private val THRESHOLD_MILLIS: Long = 600L

 abstract fun onClicked(v: View)

 override fun onClick(p0: View?) {
 if (p0 != null) {
 Log.d("Tag", "Clicked occurred")
 publishSubject.onNext(p0)
 }
 }

 init {
 publishSubject.throttleFirst(THRESHOLD_MILLIS, TimeUnit.MILLISECONDS)
 .observeOn(AndroidSchedulers.mainThread())
 .subscribe { v -&gt; onClicked(v) }
 }
}
</code></pre>

3). Implement this SingleClickListener class on the click of view in activity. This can be achieved as :

<pre><code>override fun onCreate(savedInstanceState: Bundle?) {
 super.onCreate(savedInstanceState)
 setContentView(R.layout.activity_main)

 val singleClickListener = object : SingleClickListener(){
 override fun onClicked(v: View) {
 // operation on click of xm_view_id
 }
 }
xm_viewl_id.setOnClickListener(singleClickListener)
}
</code></pre>

Implementing these above steps into the app can simply avoid the multiple clicks on a view till 600mS.
Happy coding!

blocks|key|102295|text|所以，这个答案是由ButterKnife库提供的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|102296|package+butterknife.internal;

import+android.view.View;

/**
+*+A+{@linkplain+View.OnClickListener+click+listener}+that+debounces+multiple+clicks+posted+in+the
+*+same+frame.+A+click+on+one+button+disables+all+buttons+for+that+frame.
+*/
public+abstract+class+DebouncingOnClickListener+implements+View.OnClickListener+{
++static+boolean+enabled+=+true;

++private+static+final+Runnable+ENABLE_AGAIN+=+()+->+enabled+=+true;

++@Override+public+final+void+onClick(View+v)+{
++++if+(enabled)+{
++++++enabled+=+false;
++++++v.post(ENABLE_AGAIN);
++++++doClick(v);
++++}
++}

++public+abstract+void+doClick(View+v);
}|code-block|syntax|javascript|102297|此方法仅在处理完前一次单击之后才处理单击，请注意，它避免了在一个框架中多次单击。|102298|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

So, this answer is provided by ButterKnife library.

<pre><code>package butterknife.internal;

import android.view.View;

/**
 * A {@linkplain View.OnClickListener click listener} that debounces multiple clicks posted in the
 * same frame. A click on one button disables all buttons for that frame.
 */
public abstract class DebouncingOnClickListener implements View.OnClickListener {
 static boolean enabled = true;

 private static final Runnable ENABLE_AGAIN = () -&gt; enabled = true;

 @Override public final void onClick(View v) {
 if (enabled) {
 enabled = false;
 v.post(ENABLE_AGAIN);
 doClick(v);
 }
 }

 public abstract void doClick(View v);
}
</code></pre>

This method handles clicks only after previous click has been handled and note that it avoids multiple clicks in a frame.

blocks|key|102316|text|您可以使用Rxbinding3来实现此目的。只需在build.gradle中添加此依赖项即可|type|unstyled|depth|inlineStyleRanges|entityRanges|data|102317|build.gradle|offset|length|style|CODE|102318|implementation+'com.jakewharton.rxbinding3:rxbinding:3.1.0'|code-block|syntax|javascript|102319|然后在你的活动或片段中，使用下面的代码|102320|your_button.clicks().throttleFirst(10000,+TimeUnit.MILLISECONDS).subscribe+{
++++//+your+action
}|102321|entityMap^0|0|0|C|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@$D|U|E|V|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|W|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|Y|8|@]|9|@]|A|$K|L]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

You can use Rxbinding3 for that purpose. Just add this dependency in build.gradle
<code>build.gradle</code>
<pre><code>implementation 'com.jakewharton.rxbinding3:rxbinding:3.1.0'
</code></pre>
Then in your activity or fragment, use the bellow code
<pre><code>your_button.clicks().throttleFirst(10000, TimeUnit.MILLISECONDS).subscribe {
 // your action
}
</code></pre>

I have a problem with my app that if the user clicks the button multiple times quickly, then multiple events are generated before even my dialog holding the button disappears

I know a solution by setting a boolean variable as a flag when a button is clicked so future clicks can be prevented until the dialog is closed. However I have many buttons and having to do this everytime for every buttons seems to be an overkill. Is there no other way in android (or maybe some smarter solution) to allow only only event action generated per button click?

What's even worse is that multiple quick clicks seems to generate multiple event action before even the first action is handled so if I want to disable the button in the first click handling method, there are already existing events actions in the queue waiting to be handled!

Please help
Thanks

Avoid button multiple rapid clicks

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我的应用程序有一个问题，如果用户快速地多次单击按钮，那么在我的按住按钮的对话框消失之前就会生成多个事件我知道一个解决方案，当一个按钮被点击时，将一个布尔变量设置为一个标志，这样就可以在对话框关闭之前阻止以后的点击。然而，我有很多按钮，每次都要为每个按钮做这件事似乎有点过头了。在android中有没有其他方法(或者可能是...

问避免按钮多次快速点击
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问避免按钮多次快速点击EN