Android-cacher tous les messages Toast affichés

ma solution a été d'initialiser un Toast unique dans l'activité. Puis changer son texte sur chaque clic.

Toast mToast = Toast.makeText(this, "", Toast.LENGTH_SHORT);
if (a) {
  mToast.setText("This is a");
  mToast.show();
} else if (b) {
  mToast.setText("This is b");
  mToast.show();
}

comment désactiver tous les messages de toast en cours de processus actuellement?

vous pouvez annuler Toasts en appelant cancel() sur l'objet Toast . AFAIK , il n'y a aucun moyen pour vous d'annuler tout en suspens Toasts , cependant.

qu'en est-il de vérifier si un toast est déjà affiché?

private Toast toast;
...
void showToast() {
   if (toast == null || toast.getView().getWindowVisibility() != View.VISIBLE) {
      toast = Toast.makeText(getActivity(), "Toast!", Toast.LENGTH_LONG);
      toast.show();
   }
}

la solution de Mudar a très bien fonctionné pour moi sur un problème similaire - j'ai eu divers toasts empilés dans un arriéré après plusieurs button clics.

un exemple de Toast avec différents setText()s et show() s était exactement la réponse que je cherchais - message précédent annulé dès qu'un nouveau bouton est cliqué. Spot on

juste pour référence, voilà ce que j'ai fait...

Dans OnCreate :

    final Toast myToast = Toast.makeText(getBaseContext(), "", Toast.LENGTH_SHORT);

dans chaque OnClick :

myToast.setText(R.string.toast1);
myToast.show();

ma solution est de sauvegarder toutes les références toast dans une liste et faire une méthode pour les annuler toutes quand le besoin est:

private ArrayList<Toast> msjsToast = new ArrayList<Toast>();

private void killAllToast(){
    for(Toast t:msjsToast){
        if(t!=null) {
            t.cancel();
        }
    }
    msjsToast.clear();
}

Lorsque vous créez un Toast faire de cette façon et de sauver la référence:

Toast t = Toast.makeText(context, "Download error: xx", Toast.LENGTH_LONG);
t.show();
msjsToast.addToast(t);

lorsque vous devez les supprimer:

killAllToast();

, Vous pouvez créer ce comme une méthode statique dans une classe globale et de l'utiliser pour tuer tous le toast de l'application.

je pense que j'ai trouvé un moyen de faire des messages de toasts pas faire la queue pour moi. Pensé que je voudrais partager.

cette partie va au top.

private Toast msg;    

Cette partie va dans mon setOnTouchListener()

if(null == msg)
{
msg = Toast.makeText("Message to user!", Toast.LENGTH_SHORT);
msg.setGravity(Gravity.CENTER, msg.getXOffset() / 2, msg.getYOffset() / 2);
msg.show();

//handels the stupid queueing toast messages
new Handler().postDelayed(new Runnable()
{
      public void run()
      {
          msg = null;

      }
}, 2000);

}

c'est plus un piratage que n'importe quoi. Mais je montre un message toast chaque fois que quelqu'un préfère une partie de mon application. Et s'ils deviennent fous en cliquant sur le bouton préféré il va devenir fou avec les messages toasts. Mais pas plus. Il attendra 2 secondes, puis réglera mon objet toast à null et lui permettra de s'afficher à nouveau.

voici ma réponse simple au problème:

tout d'abord dans votre activité créez un objet global Toast .

    private Toast example;

maintenant chaque fois que vous voulez appeler un nouveau message Toast faites juste ceci:

if(buttonClicked) {
    example.cancel();
    example = Toast.makeText(this, "" , Toast.LENGTH_SHORT);
    example.setText("Button Clicked");
    example.show();
}

cela garde tous les Toasts dans un Toast central et élimine les toasts spam. C'est une solution rapide et rugueuse, donc il y a peut-être une façon plus élégante de le faire.

C'est comme ça que je le fais.

Toast toast;   

if(toast==null)
        toast=Toast.makeText(getApplicationContext(),R.string.act_now_private_post_text,Toast.LENGTH_LONG);
        else
            toast.setText(R.string.act_now_private_post_text);
        toast.setGravity(Gravity.CENTER_VERTICAL|Gravity.CENTER_HORIZONTAL,10,10);
        toast.show();

mToast=Toast.makeText(this, "", Toast.LENGTH_LONG);
        showToast.setOnClickListener(new OnClickListener() {
            public void onClick(View v) {

                mToast.cancel();
                String text=null;
                if(ON)
                {
                    text="Toast is on";
                }
                else
                {
                    text="Toast is off";
                }
                mToast.setText(text);
                mToast.setDuration(Toast.LENGTH_SHORT);
                mToast.show();

            }
        });

vous pouvez utiliser comme ceci..

class MyToast {
private static Toast t;

public MyToast(Context ctx, String message) {
    if (t != null) {
        t.cancel();
        t = null;
    }
    t = Toast.makeText(ctx, message, Toast.LENGTH_SHORT);
}

public void show() {
    t.show();
}
}

en utilisant L'excellente réponse de Madur ci-dessus, j'ai étendu ceci dans une classe qui traiterait de différents types de messages:

public class ToastManager {
    private Toast toastWarningMessage;
    private Toast toastAddMessage;
    ...

    public void messageWarning(Context context, String message) {
        if(toastWarningMessage == null) {
            toastWarningMessage = Toast.makeText(context, message, Toast.LENGTH_SHORT);
        } else {
            toastWarningMessage.cancel();
            toastWarningMessage.setText(message);
        }
        toastWarningMessage.show();
    }

    public void messageAdd(Context context, String message) {
        if(toastAddMessage == null) {
            toastAddMessage = Toast.makeText(context, message, Toast.LENGTH_SHORT);
        } else {
            toastAddMessage.cancel();
            toastAddMessage.setText(message);
        }
        toastAddMessage.show();
    }
    ...
}

et ceci est appelé de l'intérieur de mon activité principale:

ToastManager toastManager;
...
private void toastWarningMessage(String message) {
    if(toastManager == null) toastManager = new ToastManager();
    toastManager.messageWarning(this, message);
}

la raison de classer les messages est de s'assurer qu'aucun message important n'est écrasé. Cette solution semble facile à réutiliser car elle implique seulement de renommer les Toasts et les noms de fonction.

lorsque le l'utilisateur spams le bouton, le toast juste annuler à chaque fois pour le même type de message. Le seul problème est que si l'utilisateur peut spam un mélange de messages. Cela conduit à la répétition du premier message et une fois qu'il expire finalement les autres messages montrant une fois chacun. Pas vraiment un gros problème, mais quelque chose à savoir.

Je n'ai pas examiné les inconvénients possibles d'avoir plusieurs toasts instances.

dans mon application, les toasts en file d'attente apparaissent encore et encore quand l'application passe en arrière-plan donc j'ai suivi pour résoudre le problème.

ajouter du code pour détecter quand app va en arrière-plan. Une façon d'enregistrer le gestionnaire du cycle de vie. Pour plus de détails ref

registerActivityLifecycleCallbacks(new MyLifecycleHandler());

App.inBackground = true; quand l'application va à l'arrière-plan et montrer toast en utilisant la classe SmartToast

public class SmartToast {

    static ArrayList<WeakReference<Toast>> toasts = new ArrayList<>();
    public static void showToast(@NonNull Context context,@NonNull String message){
        //this will not allowed to show toast when app in background
        if(App.inBackground) return;
        Toast toast = Toast.makeText(context,message,Toast.LENGTH_SHORT);
        toasts.add(new WeakReference<>(toast));
        toast.show();

        //clean up WeakReference objects itself
        ArrayList<WeakReference<Toast>> nullToasts = new ArrayList<>();
        for (WeakReference<Toast> weakToast : toasts) {
            if(weakToast.get() == null) nullToasts.add(weakToast);
        }
        toasts.remove(nullToasts);
    }

    public static void cancelAll(){
        for (WeakReference<Toast> weakToast : toasts) {
            if(weakToast.get() != null) weakToast.get().cancel();
        }
        toasts.clear();
    }

}

appel SmartToast.cancelAll(); méthode quand app va dans le fond pour cacher courant et tous les toasts en attente. Le Code, c'est marrant. Profitez-en!

créer un objet Toast à l'extérieur de la fonction onClick et utiliser le code ci-dessous. Il va arrêter tout Toast existant et commencer le dernier Toast.

Toast mToast;

public void onClick(String abc) {

    if(mToast!=null)
        mToast.cancel();
    Context context = this;
    mToast = Toast.makeText(context, abc, Toast.LENGTH_SHORT);
    mToast.show();
}

et ça !?

private Toast toast;

...
// Methods for short toast messages and long toast messages

    private void showShortToast(String message) {
        if(null != toast) toast.cancel();
        (toast = Toast.makeText(getApplicationContext(), message, Toast.LENGTH_SHORT)).show();
    }

    private void showLongToast(String message) {
        if(null != toast) toast.cancel();
        (toast = Toast.makeText(getApplicationContext(), message, Toast.LENGTH_LONG)).show();
    }

et à onPause ()

@Override
    protected void onPause() {
...
if(null != toast) toast.cancel();
..
}

Voici comment désactiver les messages toast, supprimer l'expression show() .

//Disable notification message
Toast.makeText(this,"Message",Toast.LENGTH_SHORT); 

//Enable notification message
Toast.makeText(this,"Message",Toast.LENGTH_SHORT).show();