Android - Ocultar todos los mensajes de Toast

Question

¿Cómo elimino todos los mensajes de pan que actualmente se muestran?

En mi aplicación, hay una lista, cuando un usuario hace clic en un elemento, se muestra un mensaje de brindis, 10 elementos - 10 mensajes de brindis.

Así que si el usuario hace clic 10 veces, presiona el botón de menú, tienen que esperar unos segundos hasta que puedan leer el texto de la opción del menú.

No debería ser así :)

Answer 1

¿Cómo desactivo todo ser tostadas proceso de mensajes actualmente?

Usted puede cancelar individuo Toasts llamando cancel() en el objeto Toast. AFAIK, no hay manera de que cancele todos los Toasts pendientes, sin embargo.

Answer 2

Mi solución fue inicializar un solo brindis en la actividad. Luego, cambia su texto en cada 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(); 
} 

Answer 3

solución de Mudar trabajado muy bien para mí en un problema similar - que tenía varias tostadas apilar en un atraso después de múltiples button clics.

Una instancia de Toast con diferentes setText()s y show() s fue exactamente la respuesta que estaba buscando, mensaje anterior cancelado tan pronto como se hace clic en un nuevo botón. Lugar en

Sólo como referencia, esto es lo que hice ...

En OnCreate:

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

Dentro de cada OnClick:

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

Answer 4

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

      } 
     }); 

Answer 5

Así es como para desactivar tostar mensajes, eliminar la expresión show().

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

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

Answer 6

Creo que encontré una manera de hacer que el mensaje de tostadas no haga cola para mí. Pensé que compartiría.

esta parte va en la parte superior.

private Toast msg;  

Esta parte va en mi 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); 

} 

Es más de un truco que cualquier otra cosa. Pero muestro un mensaje de brindis cuando alguien prefiere una parte de mi aplicación. Y si se vuelven locos haciendo clic en el botón favorito se volverá loco con los mensajes de brindis. Pero ya no más. Esperará 2 segundos y luego establecerá mi objeto tostado en nulo y permitirá que vuelva a mostrarse.

Answer 7

¿Qué hay de comprobar si ya se está mostrando un brindis?

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

Answer 8

Así es como lo hago.

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

Answer 9

Se puede utilizar como esto ..

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

Answer 10

Usando una excelente respuesta de Madur arriba, extendió esta en una clase que hacer frente a diferentes tipos de mensajes:

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

Y esto se llama desde dentro de mi actividad principal:

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

La razón para clasificar los mensajes es asegurarse de que no se sobrescriban los mensajes importantes. Esta solución parece fácil de reutilizar, ya que solo implica el cambio de nombre de los nombres de las funciones de Toasts.

Cuando el usuario espacia el botón, el pan tostado se cancelará cada vez para el mismo tipo de mensaje. El único problema es si el usuario puede enviar una combinación de mensajes. Esto lleva al primer mensaje que se repite y una vez que caduca, los otros mensajes que aparecen una vez cada uno. No es realmente un gran problema, pero hay que tenerlo en cuenta.

No he analizado las posibles desventajas de tener varias instancias de Toast.

Answer 11

Mi solución es guardar todas las referencias de pan tostado en una lista y hacer un método para cancelar todos ellos cuando lo necesitan:

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

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

Cuando se crea una tostada de hacerlo de esta manera y guardar la referencia:

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

Cuando tenga que eliminarlos:

killAllToast(); 

puede crear este como un estático método en una clase global y utilizarlo para matar a todos los brindis de la aplicación.

Answer 12

aquí está mi respuesta simple al problema:

En primer lugar, en su actividad de crear un objeto global Toast.

private Toast example; 

Ahora cada vez que desee llamar a un nuevo mensaje de aviso emergente a hacer esto:

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

Esto mantiene todas las tostadas en una tostada de pan tostado central y elimina el spam. Esta es una solución rápida y aproximada, así que tal vez haya una forma más elegante de hacerlo.

Answer 13

En mi aplicación, tostadas en cola aparecen una y otra vez cuando la aplicación entra en el fondo, así que lo hice para resolver el problema.

Agregue el código para detectar cuando la aplicación entra en el fondo. Una forma de registrar el controlador del ciclo de vida.Para más detalles ref

registerActivityLifecycleCallbacks(new MyLifecycleHandler()); 

App.inBackground = true; cuando la aplicación va a fondo y mostrar tostadas usando la clase 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(); 
    } 

} 

llamada SmartToast.cancelAll(); método cuando entra en aplicación de fondo para ocultar tostadas pendientes actuales y todos. El código es divertido ¡Disfrutar!