Android
Manutentionnaire

Remarques

Utiliser un gestionnaire pour exécuter du code après un laps de temps retardé

Exécution du code après 1,5 seconde:

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

Exécuter le code à plusieurs reprises toutes les 1 secondes:

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 et communication entre les threads

Comme Handler s sont utilisés pour envoyer un Message s et Runnable au message d'un fil de file d' attente , il est facile à mettre en œuvre une communication à base d'événements entre plusieurs threads. Chaque fil doté d'un Looper peut recevoir et traiter des messages. Un HandlerThread est un thread qui implémente un tel Looper , par exemple le thread principal (UI Thread) implémente les fonctionnalités d'un HandlerThread .

Créer un gestionnaire pour le thread en cours

Handler handler = new Handler();

Création d'un gestionnaire pour le thread principal (thread d'interface utilisateur)

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

Envoyer un runnable d'un autre thread au thread principal

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

Créer un gestionnaire pour un autre HandlerThread et lui envoyer des événements

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

Arrêter le gestionnaire d'exécution

Pour arrêter l'exécution du gestionnaire, supprimez le rappel qui lui est associé à l'aide du fichier exécutable exécuté à l'intérieur:

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

Utilisez Handler pour créer un minuteur (similaire à javax.swing.Timer)

Cela peut être utile si vous écrivez un jeu ou quelque chose qui doit exécuter un morceau de code toutes les quelques secondes.

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

Exemple d'utilisation:

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

Ce code affichera "Hello" toutes les secondes.