Ricerca…


Osservazioni

Un gestore può essere facilmente utilizzato per eseguire il codice dopo un periodo di tempo ritardato. È anche utile per eseguire il codice ripetutamente dopo un determinato periodo di tempo chiamando nuovamente il metodo Handler.postDelayed () dal metodo run () di Runnable.

Utilizzo di un gestore per eseguire il codice dopo un periodo di tempo ritardato

Esecuzione del codice dopo 1,5 secondi:

Handler handler = new Handler();
handler.postDelayed(new Runnable() {
    @Override
    public void run() {
        //The code you want to run after the time is up
    }
}, 1500); //the time you want to delay in milliseconds

Eseguendo codice ripetutamente ogni 1 secondo:

Handler handler = new Handler();
handler.postDelayed(new Runnable() {
    @Override
    public void run() {
        handler.postDelayed(this, 1000);
    }
}, 1000); //the time you want to delay in milliseconds

HandlerThreads e comunicazione tra thread

Poiché i Handler vengono utilizzati per inviare Message e Runnable s alla coda dei messaggi di Thread, è facile implementare la comunicazione basata su eventi tra più thread. Ogni Thread che ha un Looper è in grado di ricevere ed elaborare messaggi. Un HandlerThread è un Thread che implementa tale Looper , ad esempio il Thread principale (Thread UI) implementa le funzionalità di un HandlerThread .

Creazione di un gestore per il thread corrente

Handler handler = new Handler();

Creazione di un gestore per il thread principale (thread UI)

Handler handler = new Handler(Looper.getMainLooper());

Invia un Runnable da un altro thread alla discussione principale

new Thread(new Runnable() {
    public void run() {
        // this is executed on another Thread

        // create a Handler associated with the main Thread
        Handler handler = new Handler(Looper.getMainLooper());

        // post a Runnable to the main Thread
        handler.post(new Runnable() {
            public void run() {
                // this is executed on the main Thread
            }
        });
    }
}).start();

Creazione di un gestore per un altro handlerThread e invio di eventi ad esso

// create another Thread
HandlerThread otherThread = new HandlerThread("name");

// create a Handler associated with the other Thread
Handler handler = new Handler(otherThread.getLooper());

// post an event to the other Thread
handler.post(new Runnable() {
    public void run() {
        // this is executed on the other Thread
    }
});

Arresta il gestore dall'esecuzione

Per fermare il gestore dall'esecuzione, rimuovere il callback ad esso collegato utilizzando il runnable in esecuzione al suo interno:

Runnable my_runnable = new Runnable() {
    @Override
    public void run() {
        // your code here
    }
};

public Handler handler = new Handler(); // use 'new Handler(Looper.getMainLooper());' if you want this handler to control something in the UI
// to start the handler
public void start() {
    handler.postDelayed(my_runnable, 10000);
}

// to stop the handler
public void stop() {
    handler.removeCallbacks(my_runnable);
}

// to reset the handler
public void restart() {
    handler.removeCallbacks(my_runnable);
    handler.postDelayed(my_runnable, 10000);
}

Utilizzare il gestore per creare un timer (simile a javax.swing.Timer)

Questo può essere utile se stai scrivendo un gioco o qualcosa che deve eseguire un pezzo di codice ogni pochi secondi.

import android.os.Handler;

public class Timer {
    private Handler handler;
    private boolean paused;

    private int interval;

    private Runnable task = new Runnable () {
        @Override
        public void run() {
            if (!paused) {
                runnable.run ();
                Timer.this.handler.postDelayed (this, interval);
            }
        }
    };

    private Runnable runnable;

    public int getInterval() {
        return interval;
    }

    public void setInterval(int interval) {
        this.interval = interval;
    }

    public void startTimer () {
        paused = false;
        handler.postDelayed (task, interval);
    }

    public void stopTimer () {
        paused = true;
    }

    public Timer (Runnable runnable, int interval, boolean started) {
        handler = new Handler ();
        this.runnable = runnable;
        this.interval = interval;
        if (started)
            startTimer ();
    }
}

Esempio di utilizzo:

Timer timer = new Timer(new Runnable() {
    public void run() {
        System.out.println("Hello");
    }
}, 1000, true)

Questo codice stamperà "Hello" ogni secondo.



Modified text is an extract of the original Stack Overflow Documentation
Autorizzato sotto CC BY-SA 3.0
Non affiliato con Stack Overflow