Bisakah Android Toast lebih panjang dari Toast.LENGTH_LONG?

Saat menggunakan setDuration () untuk Toast, apakah mungkin untuk menetapkan panjang khusus atau setidaknya sesuatu yang lebih panjang dari itu Toast.LENGTH_LONG?

Nilai-nilai dari LENGTH_SHORTdan LENGTH_LONG0 dan 1. Ini berarti mereka diperlakukan sebagai flag daripada durasi yang sebenarnya jadi saya tidak berpikir akan mungkin untuk mengatur durasi untuk apa pun selain nilai-nilai ini.

Jika Anda ingin menampilkan pesan lebih lama kepada pengguna, pertimbangkan Pemberitahuan Status Bar . Pemberitahuan Status Bar dapat dibatalkan secara program ketika tidak lagi relevan.

Jika Anda menggali lebih dalam pada kode android, Anda dapat menemukan baris yang menunjukkan dengan jelas, bahwa kami tidak dapat mengubah durasi pesan Toast.

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

dan nilai default untuk durasi adalah

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

Anda mungkin ingin mencoba:

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

untuk menggandakan waktu. Jika Anda menentukan 3 sebagai gantinya 2 maka akan berlipat tiga waktu..etc.

Jika Anda ingin Toastbertahan, saya menemukan Anda dapat meretasnya dengan melakukan Timerpanggilan toast.show()berulang kali (setiap detik atau lebih harus dilakukan). Panggilan show()tidak merusak apa pun jika Toastsudah ditampilkan, tetapi itu menyegarkan jumlah waktu tetap di layar.

Saya telah mengembangkan kelas Custom Toast yang dengannya Anda dapat menunjukkan Toast untuk durasi yang diinginkan (dalam mili detik)

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

Saya sudah membuat kode kelas pembantu untuk melakukan ini. Anda dapat melihat kode di github: https://github.com/quiqueqs/Toast-Expander/blob/master/src/com/thirtymatches/toasted/ToastedActivity.java

Inilah cara Anda menampilkan roti panggang selama 5 detik (atau 5000 milidetik):

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

Saya tahu saya agak terlambat, tetapi saya mengambil jawaban Regis_AG dan membungkusnya dalam kelas pembantu dan itu bekerja dengan baik.

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

Dalam kode aplikasi Anda, lakukan saja hal seperti ini:

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

Saya tahu jawabannya sudah agak terlambat .. Saya memiliki masalah yang sama dan memutuskan untuk mengimplementasikan versi saya sendiri Toast Bare tulang, setelah melihat ke kode sumber android untuk roti panggang.

Pada dasarnya Anda perlu membuat manajer Window baru, dan menunjukkan dan menyembunyikan jendela untuk durasi durasi yang diinginkan menggunakan penangan

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

Setelah inisialisasi tata letak, Anda dapat menggunakan metode sembunyikan dan tunjukkan

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

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

Sekarang yang Anda butuhkan adalah menambahkan dua utas runnable yang memanggil handleShow () dan handleHide () yang dapat Anda poskan ke Handler.

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

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

dan bagian terakhir

public void show() {

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

}

Ini adalah implementasi yang cepat dan kotor .. Belum mempertimbangkan kinerja apa pun.

Tampilan roti panggang LONG_DELAY selama 3,5 detik dan tampilan roti panggang SHORT_DELAY selama 2 detik .

Toast secara internal menggunakan INotificationManager dan memanggil metode enqueueToast setiap kali Toast.show () dipanggil.

Panggil acara () dengan SHORT_DELAY dua kali akan memanggang roti yang sama lagi. itu akan ditampilkan selama 4 detik (2 detik + 2 detik).

demikian pula, panggil acara () dengan LONG_DELAY dua kali akan membuat roti panggang yang sama lagi. itu akan ditampilkan selama 7 detik (3,5 detik + 3,5 detik)

Berikut adalah kelas Toast khusus yang saya buat menggunakan kode di atas:

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

Jika Anda membutuhkan Toast yang panjang, ada alternatif praktis, tetapi mengharuskan pengguna Anda mengklik tombol OK untuk membuatnya pergi. Anda dapat menggunakan AlertDialog seperti ini:

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

Jika Anda memiliki pesan yang panjang, kemungkinan besar, Anda tidak tahu berapa lama yang dibutuhkan pengguna Anda untuk membaca pesan, jadi kadang-kadang ada baiknya Anda meminta pengguna untuk mengklik tombol OK untuk melanjutkan. Dalam kasus saya, saya menggunakan teknik ini ketika pengguna mengklik ikon bantuan.

Seperti yang disebutkan oleh orang lain, Android Toasts dapat berupa LENGTH_LONG atau LENGTH_SHORT. Tidak ada jalan keluarnya, Anda juga tidak boleh mengikuti 'peretasan' apa pun yang diposting.

Tujuan dari Toasts adalah untuk menampilkan informasi "tidak penting" dan karena efeknya yang bertahan lama, pesan dapat ditempatkan jauh di luar konteks jika durasinya melebihi batas tertentu. Jika stock Toasts dimodifikasi sehingga mereka dapat menampilkan lebih lama dari LENGTH_LONG, pesan akan berlama-lama di layar sampai proses aplikasi diakhiri karena tampilan roti panggang ditambahkan ke WindowManager dan bukan ViewGroup di aplikasi Anda. Saya akan berasumsi inilah sebabnya ini sulit dikodekan.

Jika Anda benar-benar perlu menampilkan pesan gaya bersulang lebih dari tiga setengah detik, saya sarankan untuk membangun tampilan yang dilampirkan ke konten Aktivitas, dengan cara itu akan hilang ketika pengguna keluar dari aplikasi. Pustaka SuperToasts saya membahas masalah ini dan banyak lainnya, silakan menggunakannya! Anda kemungkinan besar akan tertarik menggunakan SuperActivityToasts

Cukup gunakan SuperToast untuk membuat roti panggang yang elegan pada situasi apa pun. Buat roti panggang Anda berwarna-warni . Edit warna font Anda dan juga ukurannya . Semoga semuanya menjadi satu untuk Anda.

Mengapa makan Toast, ketika Anda dapat memiliki seluruh Snackbar : https://developer.android.com/reference/android/support/design/widget/Snackbar.html

Snackbar> Roti panggang, Roti bakar khusus, Crouton

Berikut adalah metode yang sangat sederhana yang bekerja untuk saya:

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

Durasi LENGTH_SHORT adalah 2 detik dan LENGTH_LONG adalah 3,5 detik, Di sini pesan roti panggang akan ditampilkan selama 6 detik karena terlampir dalam loop for. Tetapi kelemahan dari metode ini adalah setelah masing-masing 2 detik efek memudar kecil mungkin timbul. tetapi tidak terlalu terlihat. Semoga bermanfaat

Pengguna tidak dapat menentukan durasi durasi Toast. karena fungsi scheduleTimeoutLocked () NotificationManagerService tidak menggunakan durasi bidang. kode sumbernya adalah sebagai berikut.

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

Gunakan Crouton, ini adalah perpustakaan Toast yang sangat fleksibel.

Crouton

Anda bisa menggunakannya seperti bersulang:

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

atau Anda bahkan bisa masuk lebih dalam dan menyesuaikannya lebih banyak, seperti mengatur waktu hingga tak terbatas! misalnya di sini saya ingin menampilkan pesan roti panggang sampai pengguna mengakuinya dengan mengkliknya.

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 yang akan dipompa untuk roti panggang.

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

Durasi roti panggang bisa diretas menggunakan utas yang menjalankan roti bakar secara eksklusif. Ini berfungsi (jalankan proses bersulang selama 10 detik, modifikasi waktu tidur dan ctr sesuai keinginan Anda):

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

Bersulang dengan latar belakang khusus dan tampilan melakukan trik untuk saya. Saya mengujinya di tablet nexus 7 dan saya perhatikan tidak ada animasi fadein fadeout selama perulangan. Inilah implementasinya:

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

}

Inilah tampilan teks khusus yang digunakan dalam kode di atas:

<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 membuat roti panggang saya memiliki sudut membulat seperti dalam versi kitkat. Anda dapat menambahkan tampilan lain juga di file. Setiap modifikasi untuk perbaikan dan komentar dianjurkan karena saya berencana untuk mengimplementasikannya di aplikasi langsung saya.

Jadwalkan hitung mundur hingga waktu di masa mendatang, dengan pemberitahuan reguler pada interval di sepanjang jalan. Contoh menampilkan hitungan mundur 30 detik dalam bidang teks:

     CountDownTimer baru (30000, 1000) {

     public void onTick (long millisUntilFinished) {
         mTextField.setText ("detik tersisa:" + millisUntilFinished / 1000);
     }

     public void onFinish () {
         mTextField.setText ("selesai!");
     }
  }.Mulailah();

Teks ini akan hilang dalam 5 detik.

    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

Sunting: Seperti yang dikatakan Itai Spector dalam komentar akan ditampilkan sekitar 3,5 detik, Jadi gunakan kode ini:

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

Tidak, dan sebagian besar / semua peretasan yang tercantum di sini tidak lagi berfungsi di android 9. Tetapi ada solusi yang jauh lebih baik: jika Anda perlu berkeliaran, gunakan kotak dialog.

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

Pendekatan yang sangat sederhana untuk membuat pesan yang sedikit lebih lama adalah sebagai berikut:

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

Perhatikan bahwa contoh di atas menghilangkan opsi LENGTH_SHORT untuk menjaga contoh sederhana.

Anda umumnya tidak ingin menggunakan pesan Toast untuk menampilkan pesan untuk interval yang sangat lama, karena itu bukan tujuan kelas Toast yang dimaksudkan. Tetapi ada kalanya jumlah teks yang Anda butuhkan untuk ditampilkan dapat membuat pengguna lebih lama dari 3,5 detik untuk membaca, dan dalam hal itu sedikit perpanjangan waktu (misalnya, hingga 6,5 ​​detik, seperti yang ditunjukkan di atas) dapat, IMO, bermanfaat dan konsisten dengan penggunaan yang dimaksud.

Menyetel roti panggang ke periode tertentu dalam mili detik:

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

Setelah gagal dengan setiap solusi yang tersedia, akhirnya saya menyelesaikannya menggunakan rekursi.

Kode:

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

Solusi yang sangat sederhana untuk pertanyaan itu. Dua atau tiga dari mereka akan membuat roti panggang lebih lama. Ini satu-satunya jalan keluar.

Anda dapat mengatur waktu yang diinginkan dalam milidetik dalam Toast.makeText();metode seperti ini:

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