Android - 隐藏所有显示的Toast消息

时间：2010-05-02 22:32:05

标签： android hide messages toast

如何删除当前显示的所有Toast消息？

在我的应用程序中，有一个列表，当用户点击某个项目时，会显示一个Toast消息， 10项 - 10个吐司信息。

因此，如果用户点击10次，然后按下菜单按钮，他们必须等待几秒钟，直到他们能够阅读菜单选项文本。

不应该那样：）

17 个答案:

答案 0 :(得分：78)

我的解决方案是在活动中初始化单个Toast。然后在每次点击时更改其文字。

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

答案 1 :(得分：30)

  

如何禁用所有Toast消息   目前正在进行？

您可以通过调用Toasts对象上的cancel()来取消个人Toast。 AFAIK，你无法取消所有未完成的Toasts。

答案 2 :(得分：12)

检查是否已经显示吐司怎么样？

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

答案 3 :(得分：8)

Mudar的解决方案在类似的问题上对我很有效 - 在多次button点击后，我在待办事项中堆积了各种各样的祝酒词。

具有不同setText()s和show() s的Toast的一个实例正是我正在寻找的答案 - 一旦点击新按钮，就会取消之前的消息。发现

仅供参考，这是我做的......

在OnCreate：

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

在每个OnClick内：

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

答案 4 :(得分：4)

我的解决方案是在列表中保存所有toast引用，并在需要时创建一个取消所有它们的方法：

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

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

以这种方式创建Toast并保存引用：

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

当您需要删除它们时：

killAllToast();

您可以像在全局类中使用静态方法一样创建它，并使用它来杀死应用程序的所有toast。

答案 5 :(得分：3)

我想我找到了一种方法让toast消息不为我排队。以为我会分享。

这一部分排在最前面。 

private Toast msg;

这部分在我的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);

}

这比任何事都更糟糕。但是，每当有人收藏我的应用程序的一部分时，我都会显示一个祝酒词。如果他们疯狂地点击收藏夹按钮，它会因为祝酒词而疯狂。但不是了。它将等待2秒，然后将我的toast对象设置为null并允许它再次显示。

答案 6 :(得分：3)

以下是我对问题的简单回答：

在您的活动中首先创建一个全局Toast对象。

    private Toast example;

现在，只要您想要调用新的Toast消息，就这样做：

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

这会将所有Toast保存在一个中央Toast中并删除Toast垃圾邮件。这是一个快速粗略的解决方案，所以可能有一种更优雅的方式来做到这一点。

答案 7 :(得分：2)

在onClick函数之外创建一个Toast对象，并使用下面的代码。 它将停止任何现有的Toast并启动最新的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();
}

答案 8 :(得分：1)

在科特林中，这很容易解决。

在我的示例中，我在用户单击按钮时切换排序类型。如果用户快速单击该按钮，它将在显示另一个按钮之前取消当前显示的sortToast。

private var sortToast: Toast? = null

sortButton.onClickListener {
    sortToast?.cancel()
    sortToast = Toast.makeText(context, "Sort by toggled", Toast.LENGTH_SHORT)
    sortToast?.show()
}

答案 9 :(得分：1)

我就是这样做的。

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

答案 10 :(得分：0)

•Kotlin Version通过Extension Function

取消先前显示的Toast并立即显示新的Toast的最佳方法是保留对当前显示的import android.content.Context import android.widget.Toast import androidx.annotation.StringRes /** * @author aminography */ private var toast: Toast? = null fun Context.toast(message: CharSequence?) { toast?.cancel() toast = message?.let { Toast.makeText(this, it, Toast.LENGTH_SHORT) }?.apply { show() } } fun Context.longToast(message: CharSequence?) { toast?.cancel() toast = message?.let { Toast.makeText(this, it, Toast.LENGTH_LONG) }?.apply { show() } } fun Context.toast(@StringRes message: Int) { toast?.cancel() toast = Toast.makeText(this, message, Toast.LENGTH_SHORT).apply { show() } } fun Context.longToast(@StringRes message: Int) { toast?.cancel() toast = Toast.makeText(this, message, Toast.LENGTH_LONG).apply { show() } } 的引用以使其能够取消。因此，使用这些扩展功能确实有帮助：


ToastUtils.kt 

context.toast("Text 1")
context.longToast("Text 2")

context.toast(R.string.text3)
context.longToast(R.string.text4)

用法：

+------------+--------------+------------+
| product_id | product_name | unit_price |
+------------+--------------+------------+
| 1          | S8           | 1000       |
| 2          | G4           | 800        |
| 3          | iPhone       | 1400       |
+------------+--------------+------------+

Sales table:
+-----------+------------+----------+------------+----------+-------+
| seller_id | product_id | buyer_id | sale_date  | quantity | price |
+-----------+------------+----------+------------+----------+-------+
| 1         | 1          | 1        | 2019-01-21 | 2        | 2000  |
| 1         | 2          | 2        | 2019-02-17 | 1        | 800   |
| 2         | 2          | 3        | 2019-06-02 | 1        | 800   |
| 3         | 3          | 4        | 2019-05-13 | 2        | 2800  |
+-----------+------------+----------+------------+----------+-------+

答案 11 :(得分：0)

这些怎么样！？

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

和onpause（）

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

答案 12 :(得分：0)

在我的应用程序中，当应用程序进入后台时，排队的多士一次又一次出现，所以我按照以下方式解决了问题。

添加代码以检测应用何时进入后台。注册生命周期处理程序的一种方法。详情请参阅ref 

registerActivityLifecycleCallbacks(new MyLifecycleHandler());
当应用程序转到后台并使用SmartToast类显示吐司时

App.inBackground = true; 

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

}
当app进入后台以隐藏当前和所有待处理状态时，

调用SmartToast.cancelAll();方法。代码很有趣。享受！

答案 13 :(得分：0)

使用上面的Madur优秀答案，我将其扩展为一个处理不同类型消息的类：

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

这是从我的主要活动中调用的：

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

对邮件进行分类的原因是为了确保不会覆盖任何重要邮件。这个解决方案似乎很容易重用，因为它只涉及重命名Toasts和函数名称。

当用户垃圾邮件按钮时，toast将每次取消相同的消息类型。唯一的问题是用户是否可以垃圾邮件混合。这导致第一条消息重复，一旦它最终到期，其他每条消息都显示一次。这不是一个很大的问题，但需要注意的事情。

我还没有考虑过多个Toast实例的可能缺点。

答案 14 :(得分：0)

你可以这样使用.. 

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

答案 15 :(得分：0)

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

            }
        });

答案 16 :(得分：-11)

以下是禁用Toast消息的方法，删除show()表达式。

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

//Enable notification message
Toast.makeText(this,"Message",Toast.LENGTH_SHORT).show();
相关问题
最新问题