Comment faire pour supprimer tous les rappels à partir d'un Gestionnaire?

Pour tout Runnable instance, appel Handler.removeCallbacks(). Notez qu'il utilise le Runnable instance de déterminer lui-même les rappels pour annuler l'inscription, donc si vous êtes à la création d'une nouvelle instance à chaque fois qu'un post est fait, vous devez vous assurer que vous avez des références à l'exact Runnable pour annuler. Exemple:

Handler myHandler = new Handler();
Runnable myRunnable = new Runnable() {
    public void run() {
        //Some interesting task
    }
};

Vous pouvez appeler myHandler.postDelayed(myRunnable, x) de poster un autre rappel de la file d'attente de messages à d'autres endroits dans votre code, et de supprimer tous les rappels en attente avec myHandler.removeCallbacks(myRunnable)

Malheureusement, vous ne pouvez pas simplement "clair" sur l'ensemble du MessageQueue pour un Handler, même si vous faites une demande pour la MessageQueue objet associé, car les méthodes d'ajout et de suppression d'éléments sont paquet protégé (seules les classes au sein de l'android.package du système d'exploitation puissent les appeler). Vous pourriez avoir à créer une fine Handler sous-classe pour gérer une liste de Runnables qu'ils sont détachés/exécutée...ou de regarder un autre paradigme pour passer vos messages entre chaque Activity

Espère que ça Aide!

Définir un nouveau gestionnaire et praticable:

private Handler handler = new Handler(Looper.getMainLooper());
private Runnable runnable = new Runnable() {
        @Override
        public void run() {
            //Do what ever you want
        }
    };

Poste retardé:

handler.postDelayed(runnable, sleep_time);

Supprimer votre rappel à partir de votre gestionnaire de:

handler.removeCallbacks(runnable);

Comme josh527 dit, handler.removeCallbacksAndMessages(null); peut travailler.

Mais pourquoi?

Si vous regardez le code source, vous pouvez le comprendre plus clairement.
Il y a 3 type de méthode pour supprimer les rappels ou de messages de gestionnaire(le MessageQueue):

1. supprimer par le rappel (et un jeton)
2. supprimer par message.ce que (et le jeton)
3. supprimer par jeton

Handler.java (laisser de la surcharge de méthode）

/**
 * Remove any pending posts of Runnable <var>r</var> with Object
 * <var>token</var> that are in the message queue.  If <var>token</var> is null,
 * all callbacks will be removed.
 */
public final void removeCallbacks(Runnable r, Object token)
{
    mQueue.removeMessages(this, r, token);
}

/**
 * Remove any pending posts of messages with code 'what' and whose obj is
 * 'object' that are in the message queue.  If <var>object</var> is null,
 * all messages will be removed.
 */
public final void removeMessages(int what, Object object) {
    mQueue.removeMessages(this, what, object);
}

/**
 * Remove any pending posts of callbacks and sent messages whose
 * <var>obj</var> is <var>token</var>.  If <var>token</var> is null,
 * all callbacks and messages will be removed.
 */
public final void removeCallbacksAndMessages(Object token) {
    mQueue.removeCallbacksAndMessages(this, token);
}

MessageQueue.java faire le vrai travail:

void removeMessages(Handler h, int what, Object object) {
if (h == null) {
return;
}
synchronized (this) {
Message p = mMessages;
//Remove all messages at front.
while (p != null && p.target == h && p.what == what
&& (object == null || p.obj == object)) {
Message n = p.next;
mMessages = n;
p.recycleUnchecked();
p = n;
}
//Remove all messages after front.
while (p != null) {
Message n = p.next;
if (n != null) {
if (n.target == h && n.what == what
&& (object == null || n.obj == object)) {
Message nn = n.next;
n.recycleUnchecked();
p.next = nn;
continue;
}
}
p = n;
}
}
}
void removeMessages(Handler h, Runnable r, Object object) {
if (h == null || r == null) {
return;
}
synchronized (this) {
Message p = mMessages;
//Remove all messages at front.
while (p != null && p.target == h && p.callback == r
&& (object == null || p.obj == object)) {
Message n = p.next;
mMessages = n;
p.recycleUnchecked();
p = n;
}
//Remove all messages after front.
while (p != null) {
Message n = p.next;
if (n != null) {
if (n.target == h && n.callback == r
&& (object == null || n.obj == object)) {
Message nn = n.next;
n.recycleUnchecked();
p.next = nn;
continue;
}
}
p = n;
}
}
}
void removeCallbacksAndMessages(Handler h, Object object) {
if (h == null) {
return;
}
synchronized (this) {
Message p = mMessages;
//Remove all messages at front.
while (p != null && p.target == h
&& (object == null || p.obj == object)) {
Message n = p.next;
mMessages = n;
p.recycleUnchecked();
p = n;
}
//Remove all messages after front.
while (p != null) {
Message n = p.next;
if (n != null) {
if (n.target == h && (object == null || n.obj == object)) {
Message nn = n.next;
n.recycleUnchecked();
p.next = nn;
continue;
}
}
p = n;
}
}
}