Android che impedisce di fare doppio clic su un pulsante


177

Qual è il modo migliore per impedire il doppio clic su un pulsante in Android?


3
Vedi la soluzione di qezt solo che è completamente realizzabile
Gennadiy Ryabkin,

3
La soluzione di qezt avrebbe dovuto essere accettata, in modo che le persone che visitano questa pagina, conoscano lo svantaggio di usare setEnabled (false).
LoveForDroid,

Puoi provare la mia libreria, usando la soluzione dell'ultimo clic: github.com/RexLKW/SClick
Rex Lam

1
@Androider, per favore, cambia la tua migliore risposta
Amir133,

Risposte:


87

Disabilitare il pulsante con setEnabled(false)fino a quando non è possibile per l'utente fare nuovamente clic.


47
setEnabled (false) non sembra funzionare abbastanza "velocemente". Ho impostato un View.OnClickListener.onClick (visualizza) per un pulsante. La prima cosa che faccio in onClick () è scrivere un'istruzione di registro, la seconda istruzione è button.setEnabled (false). Facendo doppio clic sull'emulatore, vedo comparire due volte la frase di registro! Anche quando si aggiunge un setClickable (false) subito dopo, l'istruzione di registro appare due volte.
QQ Domande

Hmmm, forse il codice fino a setEnabled (true) alla fine di onClick () viene eseguito così velocemente che è già abilitato di nuovo ...
Domande QQ

91
Ho avuto un problema simile. Secondo un utile gentiluomo, Android mette effettivamente in coda i clic, quindi non importa quanto veloce o lento venga eseguito il tuo codice onClick (); solo la velocità con cui fai clic sul pulsante. Vale a dire. È possibile che il pulsante sia già stato disabilitato, ma la coda dei clic è già stata riempita con due o tre clic e la disabilitazione del pulsante non ha alcun effetto sulla consegna dei clic in coda. (anche se forse dovrebbe?)
Nick,

3
Quel raro momento in cui vedi "qualcuno" dà una risposta esatta e non abstraaaaaaaact risponde alla domanda che viene posta ..: P
Rahul

questa non è sempre la soluzione giusta. Se onClick è un'operazione costosa, il pulsante non si disattiverà abbastanza velocemente. La soluzione a prova di IMHO consiste nell'utilizzare l'ora dell'ultimo clic, ma disabilita anche il pulsante per evitare che l'utente lo tocchi nuovamente se si prevede che l'operazione duri un po '(come l'accesso).
Sarang,

368

salvare un ultimo clic quando si fa clic per evitare questo problema.

vale a dire

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
    }
}

21
Questa è l'unica soluzione che impedisce effettivamente un doppio clic. Ho appena trascorso un'ora a provare tutti gli altri poiché questo metodo è piuttosto goffo, ma nessuno di essi potrebbe impedire un doppio tocco rapido di una vista tranne questo. Google, per favore
risolvilo

6
Questa soluzione funziona bene. Questa soluzione funziona anche quando hai più pulsanti sullo schermo e vuoi fare clic solo su un singolo pulsante alla volta.
Annullare il

12
Ciò non impedisce completamente i doppi clic se si fa un doppio clic abbastanza velocemente.
Loc

4
La migliore risposta, dovrebbe essere in cima
Gennadiy Ryabkin,

3
Questa soluzione dovrebbe essere la risposta giusta ... setEnabled (false) non è sufficiente.
heloisasim,

55

La mia soluzione è

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);        
    }

}

L'utilizzo è simile a OnClickListener ma sostituisce onSingleClick () invece:

mTextView.setOnClickListener(new OnSingleClickListener() {
            @Override
            public void onSingleClick(View v) {
                if (DEBUG)
                    Log.i("TAG", "onclick!");
            }
     };

1
Facile e perfetto per evitare automaticamente doppi tocchi.
Benjamin Piette,

1
Ciò non impedisce completamente i doppi clic se si fa un doppio clic abbastanza velocemente.
Loc

1
Ottima soluzione Ho appena cambiato MIN_CLICK_INTERVAL = 1000;
Nizam,

5
Se dovessi premere accuratamente il pulsante ogni 0,5 secondi, nessuno dei miei clic successivi passerebbe perché mLastClickTime verrebbe aggiornato ad ogni clic. Il mio suggerimento sarebbe di assegnare mLastClickTime dopo aver verificato l'intervallo.
k2col,

mLastClickTime = currentClickTime; dovrebbe essere inserito dopo if (elapsedTime <= MIN_CLICK_INTERVAL) ritorno;
Loyea,

41

La disabilitazione del pulsante o l'impostazione non selezionabile non è sufficiente se si esegue un lavoro intensivo dal punto di vista computazionale in onClick () poiché gli eventi di clic possono essere messi in coda prima che il pulsante possa essere disabilitato. Ho scritto una classe base astratta che implementa OnClickListener che puoi invece sostituire, che risolve questo problema ignorando qualsiasi clic in coda:

/** 
 * 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;
    }
}

L'utilizzo è uguale a OnClickListener ma sostituisce invece 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);

Grazie per il codice Sulla base di ciò che hai scritto qui ho creato una classe simile che impedisce i clic se il pulsante o il suo genitore è nascosto - è divertente che Android accoda i clic anche se nascondi il pulsante immediatamente dopo il clic.
nikib3ro,

1
Ho una soluzione simile - puoi semplicemente usare questa classe in xml e avvolgerà i clickListeners per te github.com/doridori/AndroidUtilDump/blob/master/android/src/…
Dori

2
Questa è una buona soluzione, ma onClick () e reset () devono essere sincronizzati, altrimenti un doppio clic può ancora intrufolarsi.
Tom anMoney

6
@TomanMoney, come? Non tutti gli eventi clic si verificano su un singolo thread dell'interfaccia utente?
Ken

@Dori il link è morto
naXa

36

Puoi farlo in modo molto elegante con le funzioni di estensione Kotlin e RxBinding

   fun View.clickWithDebounce(debounceTime: Long = 600L, action: () -> Unit): Disposable =
        RxView.clicks(this)
                .debounce(debounceTime, TimeUnit.MILLISECONDS)
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe { action() }

o

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()
        }
    })
}

e poi solo:

View.clickWithDebounce{ Your code }

over engenering
Serg Burlaka,

3
Debounce per Rx non funzionerà bene qui. Invece "ThrottleFirst" dovrebbe adattarsi meglio. demo.nimius.net/debounce_throttle qui è un esempio di come differiscono. PS: e in realtà l'implementazione clickWithDebounce è l'implementazione dell'acceleratore, non il
rimbalzo

13

Ho anche riscontrato un problema simile, stavo visualizzando alcuni datepicker e timepicker in cui a volte veniva fatto clic 2 volte. L'ho risolto da questo

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);
}

Puoi cambiare il tempo a seconda delle tue esigenze. Questo metodo funziona per me.


Questa è la vera soluzione, poiché riattiva automaticamente il pulsante allo scadere del tempo. Le altre soluzioni bloccano il pulsante in modo permanente se si fa clic due volte rapidamente. Questa soluzione risolve il problema! Grazie
Néstor

10

setEnabled(false) funziona perfettamente per me.

L'idea è che scrivo { setEnabled(true); }all'inizio e ce la faccio solo falseal primo clic del pulsante.


9

So che è una vecchia domanda, ma condivido la migliore soluzione che ho trovato per risolvere questo problema comune

        btnSomeButton.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {
            // Prevent Two Click
            Utils.preventTwoClick(view);
            // Do magic
        }
    });

E in un altro file, come 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);
}

8

La vera soluzione a questo problema è usare setEnabled (false) che disattiva il pulsante e setClickable (false) che lo rende in modo che il secondo clic non possa essere ricevuto. Ho provato questo e sembra essere molto efficace.


7

Se qualcuno sta ancora cercando una risposta breve, è possibile utilizzare il codice seguente

 private static long mLastClickTime = 0;
  if (SystemClock.elapsedRealtime() - mLastClickTime < 1000) { // 1000 = 1second
         return;
    }
 mLastClickTime = SystemClock.elapsedRealtime();

Questo codice verrà inserito if statementogni volta che l'utente fa clic su View within 1 seconde quindi return;verrà avviato e non verrà avviato l'ulteriore codice.


2
Questa dovrebbe essere la risposta accettata. Super semplice e funziona anche se fai clic molto velocemente! Grazie per questo.
Geoffroy CALA,

7

Il modo più idiomatico di 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))
}

Uso:

button.setOnSingleClickListener { ... }

6

La mia soluzione è provare a usare una booleanvariabile:

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);
    }
}

E usando come di seguito:

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   
                }
            }
        });

AGGIORNAMENTO : soluzione Kotlin, usando l'estensione di visualizzazione

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)
    }
}

5

Click Guard funziona bene con Butter Knife

ClickGuard.guard(mPlayButton);

4
linrary separato per maniglia doppio clic sul pulsante? ha
Serg Burlaka,

Posso usare questo pulsante personalizzato all'interno?
Ara Badalyan il

@AraBadalyan cosa intendi per 'dentro'. Basta passare il pulsante personalizzato come parametro per il metodo di guardia. Quindi il tuo pulsante sarà protetto dal doppio clic
thanhbinh84

Voglio dire, non voglio aggiungere ClickGuard.guard (mPlayButton) in tutte le attività che usano onclick. Voglio creare il pulsante di estensione CustomButton e inserire ClickGuard in CustomButton. Ma quando aggiungo ClickGuard nel costruttore CustomButton non ha funzionato.
Ara Badalyan il

@AraBadalyan ha ragione. Non funziona così.
Thanhbinh84

5

nella mia situazione stavo usando una vista pulsante e prendevo i clic troppo velocemente. basta disabilitare il clic e riattivarlo dopo qualche secondo ...

Fondamentalmente ho creato una classe wrapper che avvolge il tuo Views onClickListener. puoi anche impostare un ritardo personalizzato se lo desideri.

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);
        }
    }

e per chiamarlo semplicemente fai questo:

mMyButton.setOnClickListener(new OnClickRateLimitedDecoratedListener(new View.OnClickListener() {
             @Override
             public void onClick(View v) {
                 doSomething();
             }
         }));

o fornisci il tuo ritardo:

 mMyButton.setOnClickListener(new OnClickRateLimitedDecoratedListener(new View.OnClickListener() {
                     @Override
                     public void onClick(View v) {
                         doSomething();
                     }
                 },1000));

AGGIORNAMENTO: Soprattutto un po 'vecchio stile ora che RxJava è così prevalente. come altri hanno già detto, in Android potremmo usare un acceleratore per rallentare i clic. ecco un esempio:

 RxView.clicks(myButton)
                    .throttleFirst(2000, TimeUnit.MILLISECONDS, AndroidSchedulers.mainThread())
                    .subscribe {
                        Log.d("i got delayed clicked")
                    }
        }

puoi usare questa libreria per questo: implementation 'com.jakewharton.rxbinding2:rxbinding:2.0.0'


4
    button.setOnClickListener(new OnClickListener() {
        @Override
        public void onClick(View view) {
            //to prevent double click
            button.setOnClickListener(null);
        }
    });

4

Puoi usare questo metodo Utilizzando il ritardo post puoi occuparti degli eventi con doppio clic.

void debounceEffectForClick (Visualizza vista) {

    view.setClickable(false);

    view.postDelayed(new Runnable() {
        @Override
        public void run() {
            view.setClickable(true);

        }
    }, 500);
}

4

Estensione Kotlin che consente un codice in linea conciso e tempi di attesa variabili con doppio clic

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()
        }
    }
}

Uso:

anyView.setNoDoubleClickListener(View.OnClickListener { v ->
    // do stuff
})

O

anyView.setNoDoubleClickListener(View.OnClickListener { v ->
    // do stuff
}, 1500)

Fantastico, tutti dovrebbero usarlo, è un bel pezzo di codice e un'ottima ragione per cui tutti dovrebbero migrare su kotlin.
Achmad Naufal Syafiq,

Potrebbe essere più bello se waitMillis è solo hardcoded, quindi le parentesi esterne possono essere eliminate.
WindRider,

4

Il codice seguente impedisce all'utente di fare clic più volte in una frazione di secondo e lo consente solo dopo 3 secondi.

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();
    }
}

3

Sembra che impostare i tuoi listener di clic in onResume e annullarli in onPause faccia anche il trucco.


3

Per me solo ricordare il timestamp e verificarlo (che è passato più di 1 secondo dal clic precedente) mi ha aiutato.


3

Spero che questo possa aiutarti, inserisci il codice nel gestore dell'evento.

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

    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 );
    }

3

Ho riscontrato che nessuno di questi suggerimenti funziona se il metodo onClick non ritorna immediatamente. L'evento touch viene messo in coda da Android e il successivo onClick viene chiamato solo al termine del primo. (Dato che questo è fatto su un thread dell'interfaccia utente, questo è davvero normale.) Avevo bisogno di usare il tempo in cui la funzione onClick è finita + una variabile booleana per contrassegnare se il dato onClick è in esecuzione. Entrambi questi attributi di marker sono statici per evitare che onClickListener venga eseguito contemporaneamente. (Se l'utente fa clic su un altro pulsante) Puoi semplicemente sostituire il tuo OnClickListener a questa classe e invece di implementare il metodo onClick devi implementare il metodo astratto 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);
}

3

puoi anche usare i collegamenti rx di jake wharton per ottenere questo risultato. ecco un esempio di 2 secondi tra i clic successivi:

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
                });

// nota: ignora l'oggetto v in questo caso e penso sempre.


3

Kotlin crea la classe 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)
    }
}

crea una funzione in baseClass o altro

fun View.setSafeOnClickListener(onSafeClick: (View) -> Unit) {val safeClickListener = SafeClickListener {
        onSafeClick(it)
    }
    setOnClickListener(safeClickListener)
}

e utilizzare il clic sul pulsante

btnSubmit.setSafeOnClickListener {
    showSettingsScreen()
}

1
La soluzione più pulita con estensioni! Grazie!
android_dev il



2

L'impostazione Clickable su false non funziona sul primo doppio clic ma i successivi doppi clic vengono bloccati. È come se il delegato dei clic di caricamento la prima volta fosse più lento e il secondo clic fosse acquisito prima del completamento del primo.

        Button button = contentView.FindViewById<Button>(Resource.Id.buttonIssue);
        button.Clickable = false;
        IssueSelectedItems();
        button.Clickable = true;

2

Risolvo questo problema usando due clasi, uno simile alla risposta di @jinshiyi11 e l'anoter si basa sul clic esplicito, in questo puoi fare clic su un pulsante solo una volta, se vuoi un altro clic devi indicarlo esplicitamente .

/**
 * 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;
    }
}

Esempio di utilizzo:

OnExplicitClickListener clickListener = new OnExplicitClickListener() {
    public void onOneClick(View v) {
        Log.d("example", "explicit click");
        ...
        clickListener.enableClick();    
    }
}
button.setOnClickListener(clickListener);

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");
    }
});

Visualizza i listener sono sempre chiamati su un singolo thread (principale), quindi l'utilizzo AtomicBooleannon potrebbe davvero aiutare.
WindRider,

2

Prova questo, funziona:

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
    }
});
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.