При использовании setDuration() для Toast можно установить произвольную длину или, по крайней мере, что-то большее, чем Toast.LENGTH_LONG?
Может ли Android Toast быть дольше, чем Toast.LENGTH_LONG?
Ответ 1
Значения LENGTH_SHORT и LENGTH_LONG равны 0 и 1. Это означает, что они рассматриваются как флаги, а не фактические длительности, поэтому я не думаю, что можно будет установить продолжительность на что-либо иное, чем эти значения.
Если вы хотите более долго показывать сообщение пользователю, рассмотрите Уведомление о состоянии строки. Значки состояния могут быть программно отменены, если они больше не актуальны.
Ответ 2
Если вы копаете глубже в коде Android, вы можете найти строки, которые четко указывают, что мы не можем изменить продолжительность сообщения Toast.
NotificationManagerService.scheduleTimeoutLocked() {
...
long delay = immediate ? 0 : (r.duration == Toast.LENGTH_LONG ? LONG_DELAY : SHORT_DELAY);
}
и значения по умолчанию для продолжительности -
private static final int LONG_DELAY = 3500; // 3.5 seconds
private static final int SHORT_DELAY = 2000; // 2 seconds
Ответ 3
Вы можете попробовать:
for (int i=0; i < 2; i++)
{
Toast.makeText(this, "blah", Toast.LENGTH_LONG).show();
}
удвоить время. Если вы укажете 3 вместо 2, это утроит время .cc.
Ответ 4
Лучшее решение, чтобы избежать эффектов затухания между тостами, которые запускаются последовательно:
final Toast tag = Toast.makeText(getBaseContext(), "YOUR MESSAGE",Toast.LENGTH_SHORT);
tag.show();
new CountDownTimer(9000, 1000)
{
public void onTick(long millisUntilFinished) {tag.show();}
public void onFinish() {tag.show();}
}.start();
Здесь тост отображается примерно 10 с.
Надеюсь, что это поможет.
Ответ 5
Если вы хотите, чтобы Toast сохранялся, я обнаружил, что вы можете взломать его вокруг, повторяя Timer вызов toast.show() несколько раз (каждая секунда или так должна делать). Вызов show() ничего не сломает, если Toast уже показывает, но он обновляет количество времени, которое он остается на экране.
Ответ 6
Я разработал класс Custom Toast, с помощью которого вы можете показать Toast для желаемого количества продолжительности (в миллисекундах)
import android.content.Context;
import android.os.Build;
import android.os.Handler;
import android.util.Log;
import android.util.TypedValue;
import android.view.Gravity;
import android.view.View;
import android.view.WindowManager;
import android.widget.TextView;
public final class ToastHelper {
private static final String TAG = ToastHelper.class.getName();
public static interface OnShowListener {
public void onShow(ToastHelper toast);
}
public static interface OnDismissListener {
public void onDismiss(ToastHelper toast);
}
private static final int WIDTH_PADDING_IN_DIP = 25;
private static final int HEIGHT_PADDING_IN_DIP = 15;
private static final long DEFAULT_DURATION_MILLIS = 2000L;
private final Context context;
private final WindowManager windowManager;
private View toastView;
private int gravity = Gravity.CENTER_HORIZONTAL | Gravity.BOTTOM;
private int mX;
private int mY;
private long duration = DEFAULT_DURATION_MILLIS;
private CharSequence text = "";
private int horizontalMargin;
private int verticalMargin;
private WindowManager.LayoutParams params;
private Handler handler;
private boolean isShowing;
private boolean leadingInfinite;
private OnShowListener onShowListener;
private OnDismissListener onDismissListener;
private final Runnable timer = new Runnable() {
@Override
public void run() {
cancel();
}
};
public ToastHelper(Context context) {
Context mContext = context.getApplicationContext();
if (mContext == null) {
mContext = context;
}
this.context = mContext;
windowManager = (WindowManager) mContext
.getSystemService(Context.WINDOW_SERVICE);
init();
}
private void init() {
mY = context.getResources().getDisplayMetrics().widthPixels / 5;
params = new WindowManager.LayoutParams();
params.height = WindowManager.LayoutParams.WRAP_CONTENT;
params.width = WindowManager.LayoutParams.WRAP_CONTENT;
params.flags = WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
| WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE
| WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON;
params.format = android.graphics.PixelFormat.TRANSLUCENT;
params.type = WindowManager.LayoutParams.TYPE_TOAST;
params.setTitle("ToastHelper");
params.alpha = 1.0f;
// params.buttonBrightness = 1.0f;
params.packageName = context.getPackageName();
params.windowAnimations = android.R.style.Animation_Toast;
}
@SuppressWarnings("deprecation")
@android.annotation.TargetApi(Build.VERSION_CODES.JELLY_BEAN)
private View getDefaultToastView() {
TextView textView = new TextView(context);
textView.setText(text);
textView.setGravity(Gravity.CENTER_VERTICAL | Gravity.START);
textView.setClickable(false);
textView.setFocusable(false);
textView.setFocusableInTouchMode(false);
textView.setTextColor(android.graphics.Color.WHITE);
// textView.setBackgroundColor(Color.BLACK);
android.graphics.drawable.Drawable drawable = context.getResources()
.getDrawable(android.R.drawable.toast_frame);
if (Build.VERSION.SDK_INT < 16) {
textView.setBackgroundDrawable(drawable);
} else {
textView.setBackground(drawable);
}
int wP = getPixFromDip(context, WIDTH_PADDING_IN_DIP);
int hP = getPixFromDip(context, HEIGHT_PADDING_IN_DIP);
textView.setPadding(wP, hP, wP, hP);
return textView;
}
private static int getPixFromDip(Context context, int dip) {
return (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,
dip, context.getResources().getDisplayMetrics());
}
public void cancel() {
removeView(true);
}
private void removeView(boolean invokeListener) {
if (toastView != null && toastView.getParent() != null) {
try {
Log.i(TAG, "Cancelling Toast...");
windowManager.removeView(toastView);
handler.removeCallbacks(timer);
} finally {
isShowing = false;
if (onDismissListener != null && invokeListener) {
onDismissListener.onDismiss(this);
}
}
}
}
public void show() {
if (leadingInfinite) {
throw new InfiniteLoopException(
"Calling show() in OnShowListener leads to infinite loop.");
}
cancel();
if (onShowListener != null) {
leadingInfinite = true;
onShowListener.onShow(this);
leadingInfinite = false;
}
if (toastView == null) {
toastView = getDefaultToastView();
}
params.gravity = android.support.v4.view.GravityCompat
.getAbsoluteGravity(gravity, android.support.v4.view.ViewCompat
.getLayoutDirection(toastView));
if ((gravity & Gravity.HORIZONTAL_GRAVITY_MASK) == Gravity.FILL_HORIZONTAL) {
params.horizontalWeight = 1.0f;
}
if ((gravity & Gravity.VERTICAL_GRAVITY_MASK) == Gravity.FILL_VERTICAL) {
params.verticalWeight = 1.0f;
}
params.x = mX;
params.y = mY;
params.verticalMargin = verticalMargin;
params.horizontalMargin = horizontalMargin;
removeView(false);
windowManager.addView(toastView, params);
isShowing = true;
if (handler == null) {
handler = new Handler();
}
handler.postDelayed(timer, duration);
}
public boolean isShowing() {
return isShowing;
}
public void setDuration(long durationMillis) {
this.duration = durationMillis;
}
public void setView(View view) {
removeView(false);
toastView = view;
}
public void setText(CharSequence text) {
this.text = text;
}
public void setText(int resId) {
text = context.getString(resId);
}
public void setGravity(int gravity, int xOffset, int yOffset) {
this.gravity = gravity;
mX = xOffset;
mY = yOffset;
}
public void setMargin(int horizontalMargin, int verticalMargin) {
this.horizontalMargin = horizontalMargin;
this.verticalMargin = verticalMargin;
}
public long getDuration() {
return duration;
}
public int getGravity() {
return gravity;
}
public int getHorizontalMargin() {
return horizontalMargin;
}
public int getVerticalMargin() {
return verticalMargin;
}
public int getXOffset() {
return mX;
}
public int getYOffset() {
return mY;
}
public View getView() {
return toastView;
}
public void setOnShowListener(OnShowListener onShowListener) {
this.onShowListener = onShowListener;
}
public void setOnDismissListener(OnDismissListener onDismissListener) {
this.onDismissListener = onDismissListener;
}
public static ToastHelper makeText(Context context, CharSequence text,
long durationMillis) {
ToastHelper helper = new ToastHelper(context);
helper.setText(text);
helper.setDuration(durationMillis);
return helper;
}
public static ToastHelper makeText(Context context, int resId,
long durationMillis) {
String string = context.getString(resId);
return makeText(context, string, durationMillis);
}
public static ToastHelper makeText(Context context, CharSequence text) {
return makeText(context, text, DEFAULT_DURATION_MILLIS);
}
public static ToastHelper makeText(Context context, int resId) {
return makeText(context, resId, DEFAULT_DURATION_MILLIS);
}
public static void showToast(Context context, CharSequence text) {
makeText(context, text, DEFAULT_DURATION_MILLIS).show();
}
public static void showToast(Context context, int resId) {
makeText(context, resId, DEFAULT_DURATION_MILLIS).show();
}
private static class InfiniteLoopException extends RuntimeException {
private static final long serialVersionUID = 6176352792639864360L;
private InfiniteLoopException(String msg) {
super(msg);
}
}
}
Ответ 7
Я закодировал вспомогательный класс для этого. Вы можете увидеть код в github: https://github.com/quiqueqs/Toast-Expander/blob/master/src/com/thirtymatches/toasted/ToastedActivity.java
Таким образом вы будете показывать тост за 5 секунд (или 5000 миллисекунд):
Toast aToast = Toast.makeText(this, "Hello World", Toast.LENGTH_SHORT);
ToastExpander.showFor(aToast, 5000);
Ответ 8
Я знаю, что немного опоздал, но я принял ответ Regis_AG и завернул его в класс-помощник, и он отлично работает.
public class Toaster {
private static final int SHORT_TOAST_DURATION = 2000;
private Toaster() {}
public static void makeLongToast(String text, long durationInMillis) {
final Toast t = Toast.makeText(App.context(), text, Toast.LENGTH_SHORT);
t.setGravity(Gravity.TOP | Gravity.CENTER_HORIZONTAL, 0, 0);
new CountDownTimer(Math.max(durationInMillis - SHORT_TOAST_DURATION, 1000), 1000) {
@Override
public void onFinish() {
t.show();
}
@Override
public void onTick(long millisUntilFinished) {
t.show();
}
}.start();
}
}
В коде приложения просто сделайте следующее:
Toaster.makeLongToast("Toasty!", 8000);
Ответ 9
Я знаю, что ответ довольно поздний. У меня была такая же проблема, и я решил реализовать свою собственную версию голых костей Toast, посмотрев в исходный код Android для тоста.
В основном вам нужно создать новый диспетчер окон и показать и скрыть окно для требуемой продолжительности продолжительности с помощью обработчика
//Create your handler
Handler mHandler = new Handler();
//Custom Toast Layout
mLayout = layoutInflater.inflate(R.layout.customtoast, null);
//Initialisation
mWindowManager = (WindowManager) context.getApplicationContext()
.getSystemService(Context.WINDOW_SERVICE);
WindowManager.LayoutParams params = new WindowManager.LayoutParams();
params.gravity = Gravity.BOTTOM
params.height = WindowManager.LayoutParams.WRAP_CONTENT;
params.width = WindowManager.LayoutParams.WRAP_CONTENT;
params.flags = WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
| WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE
| WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON;
params.format = PixelFormat.TRANSLUCENT;
params.windowAnimations = android.R.style.Animation_Toast;
params.type = WindowManager.LayoutParams.TYPE_TOAST;
После инициализации макета вы можете использовать свои собственные методы скрыть и показать
public void handleShow() {
mWindowManager.addView(mLayout, mParams);
}
public void handleHide() {
if (mLayout != null) {
if (mLayout.getParent() != null) {
mWindowManager.removeView(mLayout);
}
mLayout = null;
}
Теперь вам нужно добавить два runnable threads, которые вызывают handleShow() и handleHide(), которые вы могли бы отправить обработчику.
Runnable toastShowRunnable = new Runnable() {
public void run() {
handleShow();
}
};
Runnable toastHideRunnable = new Runnable() {
public void run() {
handleHide();
}
};
и заключительная часть
public void show() {
mHandler.post(toastShowRunnable);
//The duration that you want
mHandler.postDelayed(toastHideRunnable, mDuration);
}
Это была быстрая и грязная реализация. Не прислушивались.
Ответ 10
LONG_DELAY тост для 3,5 с и SHORT_DELAY тост для 2 сек.
Toast внутренне использует INotificationManager и вызывает его метод enqueueToast каждый раз, когда вызывается Toast.show().
Вызвать шоу() с помощью SHORT_DELAY дважды, снова запустит тот же тост. он будет отображаться для 4 сек (2 с + 2 с).
аналогично вызовите show() с LONG_DELAY дважды, чтобы снова поставить в очередь тот же самый тост. он будет отображаться для 7 секунд (3,5 с + 3,5 сек)
Ответ 11
Вот специальный класс Toast, который я сделал, используя приведенный выше код:
import android.content.Context;
import android.os.CountDownTimer;
import android.widget.Toast;
public class CustomToast extends Toast {
int mDuration;
boolean mShowing = false;
public CustomToast(Context context) {
super(context);
mDuration = 2;
}
/**
* Set the time to show the toast for (in seconds)
* @param seconds Seconds to display the toast
*/
@Override
public void setDuration(int seconds) {
super.setDuration(LENGTH_SHORT);
if(seconds < 2) seconds = 2; //Minimum
mDuration = seconds;
}
/**
* Show the toast for the given time
*/
@Override
public void show() {
super.show();
if(mShowing) return;
mShowing = true;
final Toast thisToast = this;
new CountDownTimer((mDuration-2)*1000, 1000)
{
public void onTick(long millisUntilFinished) {thisToast.show();}
public void onFinish() {thisToast.show(); mShowing = false;}
}.start();
}
}
Ответ 12
Как уже упоминалось, Android Toasts может быть LENGTH_LONG или LENGTH_SHORT. Нет никакого способа обойти это, и вы не должны следовать за любым из "хаков".
Цель тостов - отображать "несущественную" информацию, и из-за их затяжного эффекта сообщения могут быть удалены вне контекста, если их продолжительность превышает определенный порог. Если запасы тоста были изменены так, что они могут отображаться дольше, чем LENGTH_LONG, сообщение будет задерживаться на экране до тех пор, пока процесс приложения не будет завершен, так как в приложение WindowManager добавлено представление тоста, а не приложение ViewGroup. Я бы предположил, что именно поэтому он жестко закодирован.
Если вам абсолютно необходимо показать сообщение в стиле тоста более трех с половиной секунд, я рекомендую создать представление, которое привязывается к содержимому Activity, таким образом оно исчезнет, когда пользователь выйдет из приложения. Моя библиотека SuperToasts занимается этой проблемой и многими другими, не стесняйтесь ее использовать! Вы, скорее всего, будете заинтересованы в использовании SuperActivityToasts
Ответ 13
Если вам нужен длинный тост, есть практическая альтернатива, но для этого требуется, чтобы ваш пользователь нажал кнопку "ОК", чтобы заставить его уйти. Вы можете использовать AlertDialog следующим образом:
String message = "This is your message";
new AlertDialog.Builder(YourActivityName.this)
.setTitle("Optional Title (you can omit this)")
.setMessage(message)
.setPositiveButton("ok", null)
.show();
Если у вас длинное сообщение, скорее всего, вы не знаете, сколько времени потребуется вашему пользователю для чтения сообщения, поэтому иногда рекомендуется, чтобы ваш пользователь нажал кнопку OK, чтобы продолжить, В моем случае я использую этот метод, когда пользователь нажимает на значок справки.
Ответ 14
Просто используйте SuperToast, чтобы сделать элегантный тост в любой ситуации. Сделайте свой тост красочным. Измените цвет шрифта, а также размер. Надеюсь, что все будет в одном для вас.
Ответ 15
Зачем есть тост, когда у вас может быть вся Закусочная: https://developer.android.com/reference/android/support/design/widget/Snackbar.html
Закусочная > Тост, пользовательский тост, Crouton
Ответ 16
Вот очень простой метод, который работал у меня:
for (int i=0; i < 3; i++)
{
Toast.makeText(this, "MESSAGE", Toast.LENGTH_SHORT).show();
}
Продолжительность LENGTH_SHORT составляет 2 секунды, а LENGTH_LONG - 3,5 секунды. Здесь будет показано сообщение для тоста 6 секунд, поскольку оно заключено в цикл for. Но недостатком этого метода является то, что через каждые 2 секунды может возникнуть небольшой эффект замирания. но это не так заметно. Надеюсь, что это полезно
Ответ 17
Пользователь не может custome определить продолжительность Toast. потому что функция NotificationManagerService scheduleTimeoutLocked() не использует длительность поля. исходный код следующий.
private void scheduleTimeoutLocked(ToastRecord r, boolean immediate)
{
Message m = Message.obtain(mHandler, MESSAGE_TIMEOUT, r);
long delay = immediate ? 0 : (r.duration == Toast.LENGTH_LONG ? LONG_DELAY : SHORT_DELAY);
mHandler.removeCallbacksAndMessages(r);
mHandler.sendMessageDelayed(m, delay);
}
Ответ 18
Используйте Crouton, это очень гибкая библиотека Toast.
Вы можете использовать его так же, как тосты:
Crouton.makeText(context, "YOUR_MESSAGE", Style.INFO);
или вы даже можете немного углубиться и настроить его больше, например, установить время на бесконечность! например, здесь я хочу показать тост-сообщение, пока пользователь не подтвердит его, нажав на него.
private static void showMessage(final Activity context, MessageType type, String header, String message) {
View v = context.getLayoutInflater().inflate(R.layout.toast_layout, null);
TextView headerTv = (TextView) v.findViewById(R.id.toastHeader);
headerTv.setText(header);
TextView messageTv = (TextView) v.findViewById(R.id.toastMessage);
messageTv.setText(message);
ImageView toastIcon = (ImageView) v.findViewById(R.id.toastIcon);
final Crouton crouton = getCrouton(context, v);
v.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Crouton.hide(crouton);
}
});
crouton.show();
}
private static Crouton getCrouton(final Activity context, View v) {
Crouton crouton = Crouton.make(context, v);
crouton.setConfiguration(new Configuration.Builder().setDuration(Configuration.DURATION_INFINITE).build());
return crouton;
}
Custome Layout, который будет завышен для тоста.
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:animateLayoutChanges="true"
android:background="@drawable/shadow_container"
android:gravity="center_vertical"
android:orientation="horizontal"
android:padding="@dimen/default_margin"
tools:ignore="Overdraw">
<ImageView
android:id="@+id/toastIcon"
android:layout_width="wrap_content"
android:layout_height="wrap_content" />
<LinearLayout
android:layout_width="0dp"
android:layout_height="wrap_content"
android:layout_marginStart="@dimen/default_spacing_full"
android:layout_weight="1"
android:orientation="vertical">
<TextView
android:id="@+id/toastHeader"
style="@style/ItemText"
android:layout_width="wrap_content"
android:layout_height="wrap_content" />
<TextView
android:id="@+id/toastMessage"
style="@style/ItemSubText"
android:layout_width="wrap_content"
android:layout_height="wrap_content" />
</LinearLayout>
</LinearLayout>
Ответ 19
Тост с пользовательским фоном и просмотром помогло. Я тестировал его на планшете nxus 7, и я не заметил анимации fadein fadeout во время цикла. Это реализация:
public static void customToast(Context context, String message, int duration) {
for (int i = 0; i < duration; i++) {
Toast toast = new Toast(context);
toast.setDuration(Toast.LENGTH_LONG);
toast.setGravity(Gravity.CENTER, 0, 0);
LayoutInflater inflater = (LayoutInflater) context
.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
View view = inflater.inflate(R.layout.toast_layout, null);
TextView textViewToast = (TextView) view
.findViewById(R.id.textViewToast);
textViewToast.setText(message);
toast.setView(view);
toast.show();
}
}
Получает пользовательский текст, используемый в приведенном выше коде:
<TextView xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+id/textViewToast"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:background="@drawable/fragment_background"
android:padding="8dp"
android:text="Large Text"
android:textAppearance="?android:attr/textAppearanceLarge"
android:textColor="@color/blue" />
@drawable/fragment_background делает мой тост округленным, как в версии kitkat. Вы можете добавить и другие виды в файл. Любые изменения для улучшения и комментариев поощряются, поскольку я планирую реализовать это в своем прямом приложении.
Ответ 20
Расписание обратного отсчета до времени в будущем, с регулярными уведомлениями об интервалах в пути. Пример показа 30-секундного обратного отсчета в текстовом поле:
new CountDownTimer(30000, 1000) {
public void onTick(long millisUntilFinished) {
mTextField.setText("seconds remaining: " + millisUntilFinished / 1000);
}
public void onFinish() {
mTextField.setText("done!");
}
}.start();
Ответ 21
Этот текст исчезнет через 5 секунд.
final Toast toast = Toast.makeText(getApplicationContext(), "My Text", Toast.LENGTH_SHORT);
toast.show();
Handler handler = new Handler();
handler.postDelayed(new Runnable() {
@Override
public void run() {
toast.cancel();
}
}, 5000); // Change to what you want
Изменение: Как сказал в комментарии Itai Spector, он будет отображаться около 3,5 секунд, поэтому используйте этот код:
int toastDuration = 5000; // in MilliSeconds
Toast mToast = Toast.makeText(this, "My text", Toast.LENGTH_LONG);
CountDownTimer countDownTimer;
countDownTimer = new CountDownTimer(toastDuration, 1000) {
public void onTick(long millisUntilFinished) {
mToast.show();
}
public void onFinish() {
mToast.cancel();
}
};
mToast.show();
countDownTimer.start();
Ответ 22
Длительность тоста может быть взломана с помощью потока, который запускает тост исключительно. Это работает (запускает тост в течение 10 секунд, изменяет сон и ctr по своему вкусу):
final Toast toast = Toast.makeText(this, "Your Message", Toast.LENGTH_LONG);
Thread t = new Thread(){
public void run(){
int ctr = 0;
try{
while( ctr<10 ){
toast.show();
sleep(1000);
ctr++;
}
} catch (Exception e) {
Log.e("Error", "", e);
}
}
};
t.start();
Ответ 23
Очень простой подход к созданию немного более длинного сообщения выглядит следующим образом:
private Toast myToast;
public MyView(Context context) {
myToast = Toast.makeText(getContext(), "", Toast.LENGTH_LONG);
}
private Runnable extendStatusMessageLengthRunnable = new Runnable() {
@Override
public void run() {
//Show the toast for another interval.
myToast.show();
}
};
public void displayMyToast(final String statusMessage, boolean extraLongDuration) {
removeCallbacks(extendStatusMessageLengthRunnable);
myToast.setText(statusMessage);
myToast.show();
if(extraLongDuration) {
postDelayed(extendStatusMessageLengthRunnable, 3000L);
}
}
Обратите внимание, что приведенный выше пример исключает параметр LENGTH_SHORT, чтобы простой пример.
Как правило, вы не хотите использовать сообщение Toast для отображения сообщений в течение очень длинных интервалов, поскольку это не предназначено для цели Toast. Но есть моменты, когда количество текста, которое вам нужно отобразить, может потребовать пользователя более 3,5 секунд для чтения, и в этом случае небольшое увеличение времени (например, до 6.5 секунд, как показано выше) может, ИМО, быть полезным и в соответствии с предполагаемым использованием.
Ответ 24
Устанавливает тост за определенный период в миллисекундах:
public void toast(int millisec, String msg) {
Handler handler = null;
final Toast[] toasts = new Toast[1];
for(int i = 0; i < millisec; i+=2000) {
toasts[0] = Toast.makeText(this, msg, Toast.LENGTH_SHORT);
toasts[0].show();
if(handler == null) {
handler = new Handler();
handler.postDelayed(new Runnable() {
@Override
public void run() {
toasts[0].cancel();
}
}, millisec);
}
}
}
Ответ 25
private Toast mToastToShow;
public void showToast(View view) {
// Set the toast and duration
int toastDurationInMilliSeconds = 10000;
mToastToShow = Toast.makeText(this, "Hello world, I am a toast.", Toast.LENGTH_LONG);
// Set the countdown to display the toast
CountDownTimer toastCountDown;
toastCountDown = new CountDownTimer(toastDurationInMilliSeconds, 1000 /*Tick duration*/) {
public void onTick(long millisUntilFinished) {
mToastToShow.show();
}
public void onFinish() {
mToastToShow.cancel();
}
};
// Show the toast and starts the countdown
mToastToShow.show();
toastCountDown.start();
}
Ответ 26
После сбоя в каждом доступном решении я наконец-то нашел обходной путь с использованием рекурсии.
Код:
//Recursive function, pass duration in seconds
public void showToast(int duration) {
if (duration <= 0)
return;
Toast.makeText(this, "Hello, it a toast", Toast.LENGTH_LONG).show();
Handler handler = new Handler();
handler.postDelayed(new Runnable() {
@Override
public void run() {
showToast(duration-1);
}
}, 1000);
}
Ответ 27
Нет, и большинство/все хаки, перечисленные здесь, больше не работают в Android 9. Но есть гораздо лучшее решение: если ваше сообщение должно зависать, используйте диалоговое окно.
(new AlertDialog.Builder(this)).setTitle("Sorry!")
.setMessage("Please let me know by posting a beta comment on the play store .")
.setPositiveButton("OK", null).create().show();
Ответ 28
Toast.makeText(this, "Text", Toast.LENGTH_LONG).show();
Toast.makeText(this, "Text", Toast.LENGTH_LONG).show();
Очень простое решение вопроса. Дважды или тройка из них сделают Toast дольше. Это единственный способ обойти.
Ответ 29
Вы можете установить желаемое время в миллисекундах в методе Toast.makeText();, например:
//40 seconds
long mToastLength = 40*1000
//this toast will be displayed for 40 seconds.
Toast.makeText(this, "Hello!!!!!", mToastLength).show();