Czy Android Toast może być dłuższy niż Toast.LENGTH_LONG?

Czy podczas korzystania z metody setDuration () dla Toast można ustawić niestandardową długość lub przynajmniej coś dłuższego niż Toast.LENGTH_LONG?

Wartości LENGTH_SHORTi LENGTH_LONGwynoszą 0 i 1. Oznacza to, że są one traktowane jako flagi, a nie rzeczywiste czasy trwania, więc nie sądzę, aby można było ustawić czas trwania na cokolwiek innego niż te wartości.

Jeśli chcesz wyświetlać użytkownikowi wiadomość dłużej, rozważ Powiadomienie na pasku stanu . Powiadomienia na pasku stanu można programowo anulować, gdy nie są już istotne.

Jeśli zagłębisz się głębiej w kod Androida, możesz znaleźć wiersze, które wyraźnie wskazują, że nie możemy zmienić czasu trwania wiadomości Toast.

 NotificationManagerService.scheduleTimeoutLocked() {
    ...
    long delay = immediate ? 0 : (r.duration == Toast.LENGTH_LONG ? LONG_DELAY : SHORT_DELAY);
    }

a domyślne wartości czasu trwania to

private static final int LONG_DELAY = 3500; // 3.5 seconds
private static final int SHORT_DELAY = 2000; // 2 seconds

Możesz spróbować:

for (int i=0; i < 2; i++)
{
      Toast.makeText(this, "blah", Toast.LENGTH_LONG).show();
}

podwoić czas. Jeśli podasz 3 zamiast 2, potroi to czas ... itd.

Jeśli chcesz się Toastupierać, odkryłem, że możesz zhakować sobie drogę, powtarzając Timerpołączenie toast.show()(co sekunda powinno to zrobić). Wywołanie show()niczego nie psuje, jeśli Toastjest już wyświetlane, ale odświeża ilość czasu, jaki pozostaje na ekranie.

Opracowałem niestandardową klasę toastów, dzięki której możesz pokazywać tosty przez określony czas (w milisekundach)

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

Stworzyłem klasę pomocników, aby to zrobić. Możesz zobaczyć kod na github: https://github.com/quiqueqs/Toast-Expander/blob/master/src/com/thirtymatches/toasted/ToastedActivity.java

Oto sposób wyświetlania toastu przez 5 sekund (lub 5000 milisekund):

Toast aToast = Toast.makeText(this, "Hello World", Toast.LENGTH_SHORT);
ToastExpander.showFor(aToast, 5000);

Wiem, że jestem trochę spóźniony, ale wziąłem odpowiedź Regis_AG i umieściłem ją w klasie pomocniczej i działa świetnie.

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

W kodzie aplikacji po prostu zrób coś takiego:

    Toaster.makeLongToast("Toasty!", 8000);

Wiem, że odpowiedź jest dość późna. Miałem ten sam problem i postanowiłem wdrożyć własną wersję gołej kości Toast, po zapoznaniu się z kodem źródłowym Androida na toast.

Zasadniczo musisz utworzyć nowy menedżer okien oraz pokazać i ukryć okno przez żądany czas trwania za pomocą modułu obsługi

 //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;

Po zainicjowaniu układu możesz użyć własnych metod ukrywania i pokazywania

    public void handleShow() {
    mWindowManager.addView(mLayout, mParams);
    }

    public void handleHide() {
        if (mLayout != null) {
            if (mLayout.getParent() != null) {
                mWindowManager.removeView(mLayout);
            }
                         mLayout = null;
        }

Teraz wystarczy dodać dwa działające wątki, które wywołują uchwytShow () i uchwytHide (), które można opublikować w module obsługi.

    Runnable toastShowRunnable = new Runnable() {
        public void run() {
            handleShow();
        }
    };

 Runnable toastHideRunnable = new Runnable() {
        public void run() {
            handleHide();
        }
    }; 

i ostatnia część

public void show() {

    mHandler.post(toastShowRunnable);
    //The duration that you want
    mHandler.postDelayed(toastHideRunnable, mDuration);

}

To była szybka i brudna implementacja. Nie wziąłem pod uwagę wydajności.

Wyświetlanie tostów LONG_DELAY przez 3,5 sekundy i wyświetlanie toastów SHORT_DELAY przez 2 sekundy .

Toast wewnętrznie używa INotificationManager i wywołuje metodę enqueueToast za każdym razem, gdy wywoływana jest Toast.show ().

Dwukrotne wywołanie show () za pomocą SHORT_DELAY spowoduje ponowne umieszczenie tego samego toastu. będzie wyświetlany przez 4 sekundy (2 sekundy + 2 sekundy).

podobnie, wywołanie show () za pomocą LONG_DELAY dwukrotnie spowoduje kolejkowanie tego samego toastu. będzie wyświetlany przez 7 sekund (3,5 sekundy + 3,5 sekundy)

Oto niestandardowa klasa Toast utworzona przy użyciu powyższego kodu:

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

Jeśli potrzebujesz długiego Toastu, istnieje praktyczna alternatywa, ale wymaga kliknięcia przycisku OK, aby go usunąć. Możesz użyć AlertDialog w następujący sposób:

String message = "This is your message";
new AlertDialog.Builder(YourActivityName.this)
    .setTitle("Optional Title (you can omit this)")
    .setMessage(message)
    .setPositiveButton("ok", null)
    .show();

Jeśli masz długą wiadomość, prawdopodobnie nie wiesz, ile czasu zajmie jej przeczytanie przez użytkownika, więc czasami dobrym pomysłem jest wymaganie od użytkownika kliknięcia przycisku OK, aby kontynuować. W moim przypadku używam tej techniki, gdy użytkownik kliknie ikonę pomocy.

Jak wspomnieli inni, Android Toast może mieć wartość LENGTH_LONG lub LENGTH_SHORT. Nie można tego obejść, ani nie należy śledzić żadnego z opublikowanych „hacków”.

Celem Toastów jest wyświetlanie „nieistotnych” informacji, a ze względu na ich trwały efekt wiadomości mogą być odsunięte od kontekstu, jeśli ich czas trwania przekroczy określony próg. Jeśli zapasowe Tosty zostały zmodyfikowane, aby mogły wyświetlać się dłużej niż LENGTH_LONG, wiadomość pozostawałaby na ekranie, dopóki proces aplikacji nie zostanie zakończony, ponieważ widoki Toast są dodawane do WindowManager, a nie ViewGroup w Twojej aplikacji. Zakładam, że właśnie dlatego jest mocno zakodowany.

Jeśli absolutnie musisz pokazać wiadomość w stylu toast dłuższą niż trzy i pół sekundy, zalecam zbudowanie widoku, który zostanie dołączony do treści działania, w ten sposób zniknie, gdy użytkownik wyjdzie z aplikacji. Moja biblioteka SuperToastów zajmuje się tym problemem i wielu innych, zachęcamy do korzystania z niego! Najprawdopodobniej byłbyś zainteresowany korzystaniem z SuperActivityToasts

Wystarczy użyć SuperToast, aby zrobić elegancki toast w każdej sytuacji. Spraw, aby toast był kolorowy . Edytuj kolor czcionki, a także jej rozmiar . Mam nadzieję, że będzie to dla ciebie wszystko w jednym.

Po co jeść Tosty, skoro możesz mieć cały Snackbar : https://developer.android.com/reference/android/support/design/widget/Snackbar.html

Snackbar> Toast, Custom Toast, Crouton

Oto bardzo prosta metoda, która zadziałała dla mnie:

for (int i=0; i < 3; i++) { Toast.makeText(this, "MESSAGE", Toast.LENGTH_SHORT).show(); }

Czas trwania LENGTH_SHORT wynosi 2 sekundy, a LENGTH_LONG wynosi 3,5 sekundy, tutaj komunikat toast będzie wyświetlany przez 6 sekund, ponieważ jest zamknięty w pętli for. Jednak wadą tej metody jest to, że po każdych 2 sekundach może pojawić się niewielki efekt zanikania. ale nie jest to zbytnio zauważalne. Mam nadzieję, że to jest pomocne

Użytkownik nie może zdefiniować czasu trwania Toastu. ponieważ funkcja scheduleTimeoutLocked () NotificationManagerService nie używa czasu trwania pola. kod źródłowy jest następujący.

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

Użyj Crouton, jest to bardzo elastyczna biblioteka Toast.

Grzanka

Możesz go używać tak jak tosty:

Crouton.makeText(context, "YOUR_MESSAGE", Style.INFO);

lub możesz pójść trochę głębiej i dostosować go bardziej, na przykład ustawić czas na nieskończoność! na przykład tutaj chcę wyświetlać wiadomość toast, dopóki użytkownik nie potwierdzi jej, klikając ją.

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

Układ klienta, który zostanie napompowany do tostów.

<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>

Czas trwania toastu można zhakować za pomocą wątku, który uruchamia toast wyłącznie. Działa to (uruchamia toast na 10 sekund, modyfikuje tryb uśpienia i ctr do własnych upodobań):

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

Toast za niestandardowe tło i widok załatwił sprawę. Testowałem to na tablecie Nexus 7 i nie zauważyłem żadnej animacji zanikania / zanikania podczas zapętlania. Oto wdrożenie:

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

}

Oto niestandardowy widok tekstu użyty w powyższym kodzie:

<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 sprawia, że ​​mój toast ma zaokrąglony róg, jak w wersji KitKat. Możesz także dodać inne widoki w pliku. Zachęca się do wprowadzania jakichkolwiek zmian w celu ulepszenia i komentarzy, ponieważ planuję wdrożyć to w mojej aplikacji na żywo.

Zaplanuj odliczanie do czasu w przyszłości, z regularnymi powiadomieniami o interwałach po drodze. Przykład pokazujący 30-sekundowe odliczanie w polu tekstowym:

     nowy CountDownTimer (30000, 1000) {

     public void onTick (long millisUntilFinished) {
         mTextField.setText („pozostało sekund:” + millisUntilFinished / 1000);
     }

     public void onFinish () {
         mTextField.setText („gotowe!”);
     }
  }.początek();

Ten tekst zniknie za 5 sekund.

    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

Edycja: Jak powiedział Itai Spector w komentarzu, będzie wyświetlany około 3,5 sekundy, więc użyj tego kodu:

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

Nie, a większość wymienionych tu włamań nie działa już w Androidzie 9. Jest jednak o wiele lepsze rozwiązanie: jeśli wiadomość musi się zawiesić, użyj okna dialogowego.

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

Bardzo proste podejście do tworzenia nieco dłuższej wiadomości jest następujące:

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

Zauważ, że powyższy przykład eliminuje opcję LENGTH_SHORT, aby zachować prostotę przykładu.

Zasadniczo nie będziesz chciał używać komunikatu Toast do wyświetlania komunikatów przez bardzo długie okresy, ponieważ nie jest to zamierzonym celem klasy Toast. Ale są chwile, kiedy ilość tekstu, który musisz wyświetlić, może zająć użytkownikowi więcej niż 3,5 sekundy, aby przeczytać, i w takim przypadku niewielkie wydłużenie czasu (np. Do 6,5 sekundy, jak pokazano powyżej) może być przydatne, IMO, i zgodne z przeznaczeniem.

Ustawia toast na określony okres w milisekundach:

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

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

Po niepowodzeniu z każdym dostępnym rozwiązaniem w końcu miałem obejście za pomocą rekurencji.

Kod:

//Recursive function, pass duration in seconds
public void showToast(int duration) {
    if (duration <= 0)
        return;

    Toast.makeText(this, "Hello, it's a toast", Toast.LENGTH_LONG).show();
    Handler handler = new Handler();
    handler.postDelayed(new Runnable() {
        @Override
        public void run() {
            showToast(duration-1);
        }
    }, 1000);
}

Toast.makeText(this, "Text", Toast.LENGTH_LONG).show(); 
Toast.makeText(this, "Text", Toast.LENGTH_LONG).show();

Bardzo proste rozwiązanie tego pytania. Dwa lub trzy z nich sprawią, że Toast będzie trwać dłużej. To jedyna droga.

Możesz ustawić żądany czas w milisekundach w następujący Toast.makeText();sposób:

//40 seconds
long mToastLength = 40*1000 
//this toast will be displayed for 40 seconds.
Toast.makeText(this, "Hello!!!!!", mToastLength).show();