Android - Masquer tous les messages affichés
Comment puis-je supprimer tous les messages de pain grillé actuellement affichés?
Dans mon application, il y a une liste, lorsqu'un utilisateur clique sur un élément, un message de pain grillé est affiché, 10 éléments - 10 messages de pain grillé.
Ainsi, si l'utilisateur clique 10 fois sur le bouton de menu, il doit attendre quelques secondes avant de pouvoir lire le texte de l'option de menu.
Ça ne devrait pas être comme ça :)
Ma solution consistait à initialiser un seul Toast dans l'activité. Puis changer son texte à 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 pain grillé en cours de traitement?
Vous pouvez annuler une Toasts individuelle en appelant cancel() sur l'objet Toast. Si je comprends bien, il n’ya aucun moyen pour vous d’annuler tous les Toasts en suspens, cependant.
Pourquoi ne pas 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 fonctionné à merveille pour moi sur un problème similaire: plusieurs toasts se sont accumulés dans un carnet de commandes après plusieurs clics button.
Une instance de Toast avec setText()s et show()s différents était exactement la réponse que je cherchais: le message précédent était annulé dès qu'un nouveau bouton était cliqué. Spot sur
Juste pour référence, voici 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 de pain grillé dans une liste et de créer une méthode pour les annuler en cas de besoin:
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, procédez de cette manière et enregistrez 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 cela comme une méthode statique dans une classe globale et l'utiliser pour tuer tous les toasts de l'application.
Je pense avoir trouvé un moyen de faire des toasts, pas de faire la queue pour moi. Je pensais partager.
cette partie va au sommet.
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 bidouillage qu'autre chose. Mais je montre un message de pain grillé chaque fois que quelqu'un préfère une partie de mon application. Et s’ils deviennent fous en cliquant sur le bouton favori, les messages de toasts le rendront fous. Mais plus maintenant. Il attendra 2 secondes, puis définira mon objet toast sur 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 souhaitez appeler un nouveau message Toast, procédez comme suit:
if(buttonClicked) {
example.cancel();
example = Toast.makeText(this, "" , Toast.LENGTH_SHORT);
example.setText("Button Clicked");
example.show();
}
Cela conserve tous les Toasts dans un seul Toast et supprime le spam Toast. Il s’agit d’une solution rapide, alors il existe peut-être un moyen plus élégant de le faire.
Créez un objet Toast en dehors de la fonction onClick et utilisez le code ci-dessous . Il arrêtera tout Toast existant et démarrera 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();
}
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();
}
});
Que penses-tu de ceux-ci !?
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();
..
}
Dans mon application, les toasts en file d'attente apparaissant encore et encore lorsque l'application passe en arrière-plan, j'ai donc suivi pour résoudre le problème.
Ajoutez du code pour détecter quand l'application passe en arrière-plan. Une façon d'enregistrer un gestionnaire de cycle de vie. Pour plus de détail réf
registerActivityLifecycleCallbacks(new MyLifecycleHandler());
App.inBackground = true; lorsque l'application passe en arrière-plan et affiche un toast à l'aide de 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();
}
}
appelez la méthode SmartToast.cancelAll(); lorsque l'application passe en arrière-plan pour masquer les toasts actuels et en attente. Le code est amusant. Prendre plaisir!
En utilisant l'excellente réponse de Madur ci-dessus, j'ai étendu cela à un cours 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 cela s’appelle de mon activité principale:
ToastManager toastManager;
...
private void toastWarningMessage(String message) {
if(toastManager == null) toastManager = new ToastManager();
toastManager.messageWarning(this, message);
}
La raison de la classification des messages est de s’assurer qu’aucun message important n’est écrasé. Cette solution semble facile à réutiliser car elle implique uniquement de renommer les Toasts et les noms de fonctions.
Lorsque l'utilisateur actionne le bouton, le pain grillé s'annule à chaque fois pour le même type de message. Le seul problème est si l'utilisateur peut spammer une combinaison de messages. Cela entraîne la répétition du premier message et, une fois celui-ci expiré, les autres messages affichés une fois chacun. Pas vraiment un problème énorme, mais une chose à prendre en compte.
Je n'ai pas étudié les inconvénients possibles de plusieurs instances de Toast.
Vous pouvez utiliser comme ça ..
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();
}
}