Bir Android Tostu Toast.LENGTH_LONG değerinden daha uzun olabilir mi?

Tost için setDuration () kullanılırken, özel bir uzunluk veya en azından daha uzun bir şey ayarlamak mümkün müdür Toast.LENGTH_LONG?

Değerleri LENGTH_SHORTve LENGTH_LONGbunu bu değerlerin dışında bir süresini ayarlamak mümkün olacaktır sanmıyorum bu yüzden oldukça gerçek süreleri daha bayraklar olarak kabul edilir 0 ve 1. Bu araçlardır.

Bir iletiyi kullanıcıya daha uzun süre görüntülemek istiyorsanız, Durum Çubuğu Bildirimi'ni göz önünde bulundurun . Durum Çubuğu Bildirimleri artık alakalı olmadıklarında programlı olarak iptal edilebilir.

Android kodunda daha derine inerseniz, Tost mesajının süresini değiştiremeyeceğimizi açıkça belirten satırları bulabilirsiniz.

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

ve süre için varsayılan değerler:

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

Denemek isteyebilirsiniz:

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

zamanı iki katına çıkarmak. Bunun yerine 3 belirtirseniz, zaman üçe katlanır .. vb.

Eğer bir Toastdevam etmek istiyorsanız , tekrar tekrar bir Timerçağrı yaparak toast.show()(her saniye ya da yapmalı) etrafında yolunuzu kesmek olduğunu buldum . Arama zaten gösteriliyorsa show()hiçbir şeyi bozmaz Toast, ancak ekranda kaldığı süreyi yeniler.

Tost'u istediğiniz süre boyunca (Milli saniye cinsinden) gösterebileceğiniz bir Özel Tost sınıfı geliştirdim

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

Bunu yapmak için bir yardımcı sınıf kodladım. Kodu github'da görebilirsiniz: https://github.com/quiqueqs/Toast-Expander/blob/master/src/com/thirtymatches/toasted/ToastedActivity.java

Tostu 5 saniye (veya 5000 milisaniye) boyunca şu şekilde görüntülersiniz:

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

Biraz geç kaldığımı biliyorum, ama Regis_AG'ın cevabını aldım ve yardımcı bir sınıfa girdim ve harika çalışıyor.

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

Uygulama kodunuzda böyle bir şey yapmanız yeterlidir:

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

Cevabın oldukça geç olduğunu biliyorum .. Ben de aynı sorunu vardı ve tost için android kaynak koduna baktıktan sonra çıplak kemikler Toast kendi sürümünü uygulamaya karar verdi.

Temel olarak yeni bir Pencere yöneticisi oluşturmanız ve pencereyi bir işleyici kullanarak istenen süre boyunca göstermeniz ve gizlemeniz gerekir

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

Düzeni başlattıktan sonra kendi gizleme ve gösterme yöntemlerinizi kullanabilirsiniz

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

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

Şimdi ihtiyacınız olan tek şey işleyiciye gönderebileceğiniz handleShow () ve handleHide () işlevlerini çağıran çalıştırılabilir iki iş parçacığı eklemektir.

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

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

ve son bölüm

public void show() {

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

}

Bu hızlı ve kirli bir uygulama oldu .. Hiçbir performansı dikkate almadım.

LONG_DELAY ekranda ekmek 3.5 saniye ve SHORT_DELAY ekranda ekmek 2 sn .

Tost dahili olarak INotificationManager'ı kullanır ve Toast.show () her çağrıldığında enqueueToast yöntemini çağırır.

Şovu () SHORT_DELAY ile iki kez çağırdığınızda aynı tost tekrar tekrar sıralanır. Bu görüntülenecektir 4 saniye (2 sn + 2 sn).

benzer şekilde, iki kez LONG_DELAY ile show () işlevini tekrarlamak, aynı ekmeği yeniden sıralar. Bu görüntülenecektir 7 sn (3.5 sn + 3.5 sn)

Yukarıdaki kodu kullanarak yaptığım özel bir Tost sınıfı:

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

Uzun bir Tost'a ihtiyacınız varsa, pratik bir alternatif var, ancak kullanıcının ortadan kalkması için bir Tamam düğmesine tıklaması gerekiyor. Bunun gibi bir AlertDialog kullanabilirsiniz:

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

Uzun bir mesajınız varsa, büyük olasılıkla, kullanıcının mesajı okumasının ne kadar zaman alacağını bilmiyorsunuz, bu nedenle bazen devam etmek için kullanıcının bir Tamam düğmesine tıklamasını istemek iyi bir fikirdir. Benim durumumda, bir kullanıcı bir yardım simgesini tıkladığında bu tekniği kullanıyorum.

Başkaları tarafından belirtildiği gibi Android Toasts LENGTH_LONG veya LENGTH_SHORT olabilir. Bunun hiçbir yolu yok, ayrıca yayınlanan 'hack'lerin hiçbirini takip etmemelisiniz.

Tostların amacı "zorunlu olmayan" bilgileri göstermektir ve süren etkileri nedeniyle, süreleri belirli bir eşiği aşarsa mesajlar bağlamın dışına çıkabilir. Stok Tostlar, LENGTH_LONG değerinden daha uzun görünecek şekilde değiştirildiyse, uygulamada bir görüntü grubu eklendikçe, tost görünümleri WindowManager'a eklendikçe uygulama işlemi sonlandırılana kadar ekranda görünmez. Bu yüzden kodlanmış olduğunu düşünürdüm.

Kesinlikle üç buçuk saniyeden uzun bir tost tarzı mesaj göstermeniz gerekiyorsa, Aktivitenin içeriğine eklenmiş bir görünüm oluşturmanızı öneririm, böylece kullanıcı uygulamadan çıktığında kaybolacaktır. Benim SuperToasts bu konuda ve diğerleri ile kütüphane fırsatlar, bunu kullanmaktan çekinmeyin! Büyük olasılıkla SuperActivityToasts kullanmakla ilgilenirsiniz

Basitçe kullanmak SuperToast her durumda şık bir tost yapmak için. Tostunu renkli yap . Senin düzenleyin tipi rengini ve ayrıca 's boyutunu . Umarım hepsi sizin için bir arada olacaktır.

Snackbar'ın tamamına sahip olduğunuzda neden Tost'u yersiniz : https://developer.android.com/reference/android/support/design/widget/Snackbar.html

Snackbar> Tost, Özel Tost, Kruton

İşte benim için çalışan çok basit bir yöntem:

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

LENGTH_SHORT süresi 2 saniyedir ve LENGTH_LONG 3,5 saniyedir. Burada, tost mesajı bir for döngüsünün içine alındığı için 6 saniye boyunca gösterilecektir . Ancak bu yöntemin bir dezavantajı her 2 saniyeden sonra küçük bir solma etkisi ortaya çıkabilir. ama pek farkedilmez. Umarım yardımcı olur

Kullanıcı, Tost'un süresini tanımlayarak saklamaz. çünkü NotificationManagerService'in scheduleTimeoutLocked () işlevi alan süresini kullanmaz. kaynak kodu şudur.

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

Crouton kullanın, çok esnek bir Tost kütüphanesi.

kızarmış ekmek parçaları

Tost gibi kullanabilirsiniz:

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

ya da biraz daha derine inebilir ve daha çok özelleştirebilirsiniz, örneğin sonsuz zamanı ayarlamak gibi! örneğin burada kullanıcı üzerine tıklayarak onaylayana kadar bir tost mesajı göstermek istiyorum.

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

Tost için şişirilecek Custome Düzeni.

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

Tost süresi, tostu sadece çalıştıran bir iplik kullanılarak kesilebilir. Bu çalışır (tostu 10 saniye boyunca çalıştırır, uykuyu ve ctr değerini beğeninize göre değiştirin):

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

Özel arka plan ve görünüm ile bir tost benim için hile yaptı. Nexus 7 tablette test ettim ve döngü sırasında hiçbir solma fadeout animasyonu fark ettim. Heres uygulaması:

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

}

Yukarıdaki kodda kullanılan özel metin görünümünü içerir:

<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, tostumun kitkat versiyonunda olduğu gibi yuvarlak köşeli olmasını sağlıyor. Dosyaya başka görünümler de ekleyebilirsiniz. Bunu canlı uygulamamda uygulamayı planladığım için, iyileştirme ve yorumlar için herhangi bir değişiklik yapılması önerilir.

İlerideki bir zamana kadar geri sayım planlayın ve yol boyunca aralıklarla düzenli olarak bildirim alın. Metin alanında 30 saniyelik geri sayım gösterme örneği:

     yeni CountDownTimer (30000, 1000) {

     herkese açık void onTick (uzun milisUntilFinished) {
         mTextField.setText ("kalan saniye:" + millisUntilFinished / 1000);
     }

     herkese açık geçersiz (onfinish () {
         mTextField.setText ( "bitmiş!");
     }
  }.Başlat();

Bu metin 5 saniye içinde kaybolacaktır.

    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

Düzenleme: Yorumda Itai Spector yaklaşık 3.5 saniye gösterileceğini söyledi, Yani bu kodu kullanın:

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

Hayır ve burada listelenen bilgisayar korsanlarının çoğu artık android 9'da çalışmıyor. Ama çok daha iyi bir çözüm var: mesajın takılması gerekiyorsa bir iletişim kutusu kullanın.

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

Biraz daha uzun bir mesaj oluşturmak için çok basit bir yaklaşım aşağıdaki gibidir:

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

Yukarıdaki örneğin, örneği basit tutmak için LENGTH_SHORT seçeneğini ortadan kaldırdığını unutmayın.

Toast sınıfının amaçlanan amacı olmadığı için, mesajları çok uzun aralıklarla görüntülemek için genellikle bir Tost mesajı kullanmak istemezsiniz. Ancak, görüntülemeniz gereken metin miktarının kullanıcının okunması için 3,5 saniyeden daha uzun sürebileceği zamanlar vardır ve bu durumda biraz zaman uzatımı (örneğin, yukarıda gösterildiği gibi 6,5 saniyeye kadar) IMO yararlı olabilir ve kullanım amacına uygun.

Tostu belirli bir süreye milli saniye olarak ayarlar:

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

Mevcut her çözümde başarısız olduktan sonra, nihayet özyineleme kullanarak geçici bir çözüm vardı.

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

Soruya çok basit bir çözüm. İki veya üç kez Toast daha uzun süre dayanır. Tek yol bu.

İstediğiniz zamanı aşağıdaki gibi milisaniye cinsinden ayarlayabilirsiniz Toast.makeText();:

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