Un toast Android peut-il être plus long que Toast.LENGTH_LONG?

Lorsque vous utilisez setDuration () pour un Toast, est-il possible de définir une longueur personnalisée ou au moins quelque chose de plus long que Toast.LENGTH_LONG ?

    Les valeurs de LENGTH_SHORT et de LENGTH_LONG sont 0 et 1. Cela signifie qu’elles sont traitées comme des indicateurs plutôt que comme des durées réelles. Je ne pense donc pas qu’il soit possible de définir la durée autrement que sur ces valeurs.

    Si vous souhaitez afficher un message plus longtemps à l’utilisateur, envisagez une notification de barre d’état . Barre d’état Les notifications peuvent être annulées par programme lorsqu’elles ne sont plus pertinentes.

    Si vous creusez plus profondément dans le code Android, vous pouvez trouver les lignes qui indiquent clairement que nous ne pouvons pas modifier la durée du message Toast.

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

    et les valeurs par défaut pour la durée sont

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

    Vous pouvez vouloir essayer:

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

    doubler le temps Si vous spécifiez 3 au lieu de 2, il sortingplera le temps..etc.

    La meilleure solution pour éviter les effets de décoloration entre les toasts lancés en séquence:

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

    Ici, le toast est affiché environ 10 s.

    J’espère que cela t’aides.

    Si vous voulez qu’un Toast persiste, j’ai trouvé que vous pouviez le contourner en appelant plusieurs fois le Timer toast.show() (chaque seconde devrait le faire). L’appel de show() ne casse rien si le Toast est déjà affiché, mais il rafraîchit le temps qu’il rest à l’écran.

    J’ai développé une classe de Toast personnalisé avec laquelle vous pouvez afficher Toast pour la durée souhaitée (en Milli secondes)

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

    J’ai codé une classe d’assistance pour ce faire. Vous pouvez voir le code à github: https://github.com/quiqueqs/Toast-Expander/blob/master/src/com/thirtymatches/toasted/ToastedActivity.java

    Voici comment afficher un toast pendant 5 secondes (ou 5000 millisecondes):

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

    Je sais que je suis un peu en retard, mais j’ai pris la réponse de Regis_AG et je l’ai emballée dans une classe d’assistance et cela fonctionne très bien.

     public class Toaster { private static final int SHORT_TOAST_DURATION = 2000; private Toaster() {} public static void makeLongToast(Ssortingng 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(); } } 

    Dans votre code d’application, faites simplement quelque chose comme ceci:

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

    Je sais que la réponse est assez tardive. J’ai eu le même problème et j’ai décidé de mettre en œuvre ma propre version de Toast, après avoir examiné le code source d’android pour le pain grillé.

    Fondamentalement, vous devez créer un nouveau gestionnaire de fenêtres et afficher et masquer la fenêtre pour la durée souhaitée à l’aide d’un gestionnaire.

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

    Après l’initialisation de la mise en page, vous pouvez utiliser vos propres méthodes masquer et afficher

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

    Il ne vous rest plus qu’à append deux threads exécutables qui appellent le handleShow () et le handleHide () que vous pouvez publier sur le gestionnaire.

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

    et la dernière partie

     public void show() { mHandler.post(toastShowRunnable); //The duration that you want mHandler.postDelayed(toastHideRunnable, mDuration); } 

    Ce fut une mise en œuvre rapide et sale. Je n’ai pris aucune mesure en considération.

    LONG_DELAY affiche pendant 3,5 secondes et SHORT_DELAY affiche l’affichage pendant 2 secondes .

    Toast utilise en interne INotificationManager et appelle sa méthode enqueueToast chaque fois qu’un Toast.show () est appelé.

    Appelez le show () avec SHORT_DELAY à deux resockets pour remettre en queue le même toast. il affichera pendant 4 sec (2 sec + 2 sec).

    de même, appelez le show () avec LONG_DELAY deux fois pour remettre en file le même toast. il affichera pendant 7 sec (3.5 sec + 3.5 sec)

    Voici une classe de Toast personnalisée que j’ai faite en utilisant le code ci-dessus:

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

    Si vous avez besoin d’un long Toast, il existe une alternative pratique, mais votre utilisateur doit cliquer sur un bouton OK pour le faire disparaître. Vous pouvez utiliser un AlertDialog comme ceci:

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

    Si vous avez un long message, il y a de fortes chances que vous ne sachiez pas combien de temps votre utilisateur aura à lire le message. Il est donc parfois utile de demander à votre utilisateur de cliquer sur le bouton OK pour continuer. Dans mon cas, j’utilise cette technique lorsqu’un utilisateur clique sur une icône d’aide.

    Comme mentionné par d’autres, Android Toasts peut être LENGTH_LONG ou LENGTH_SHORT. Il n’ya aucun moyen de contourner cela, et vous ne devez suivre aucun des «hacks» affichés.

    Les Toasts ont pour but d’afficher des informations “non essentielles” et, en raison de leur effet persistant, les messages peuvent être mis hors contexte si leur durée dépasse un certain seuil. Si les Toasts stock ont ​​été modifiés pour qu’ils puissent afficher plus longtemps que LENGTH_LONG, le message persisterait à l’écran jusqu’à ce que le processus de l’application se termine, car des vues de toast sont ajoutées au WindowManager et non à ViewGroup dans votre application. Je suppose que c’est pour cela que c’est codé en dur.

    Si vous devez absolument afficher un message de style Toast de plus de trois secondes et demie, je vous recommande de créer une vue attachée au contenu de l’Activité, afin qu’elle disparaisse lorsque l’utilisateur quitte l’application. Ma bibliothèque SuperToasts traite de ce problème et de bien d’autres, n’hésitez pas à l’utiliser! Vous seriez très probablement intéressé à utiliser SuperActivityToasts

    Utilisez simplement SuperToast pour faire un toast élégant dans toutes les situations. Rendez votre toast coloré . Modifiez la couleur de votre police et aussi sa taille . J’espère que tout sera en un pour vous.

    L’utilisateur ne peut pas définir la durée du Toast. car la fonction scheduleTimeoutLocked () de NotificationManagerService n’utilise pas la durée du champ. le code source est le suivant

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

    Utilisez Crouton, c’est une bibliothèque Toast très flexible.

    Croûton

    Vous pouvez l’utiliser comme des toasts:

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

    ou vous pouvez même aller un peu plus loin et le personnaliser davantage, comme pour régler le temps à l’infini! Par exemple, ici, je veux afficher un message de toast jusqu’à ce que l’utilisateur le confirme en cliquant dessus.

     private static void showMessage(final Activity context, MessageType type, Ssortingng header, Ssortingng 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 qui sera gonflé pour le pain grillé.

            

    Pourquoi manger Toast, alors que vous pouvez avoir toute la Snackbar : https://developer.android.com/reference/android/support/design/widget/Snackbar.html

    Snackbar> Toast, pain grillé personnalisé, croûtons

    Voici une méthode très simple qui a fonctionné pour moi:

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

    La durée de LENGTH_SHORT est de 2 secondes et LENGTH_LONG est de 3,5 secondes. Ici, le message de toast sera affiché pendant 6 secondes car il est entouré d'une boucle for. Mais un inconvénient de cette méthode est qu'après chaque seconde, un petit effet de fondu peut se produire. mais ce n'est pas très perceptible. J'espère que c'est utile

    Un toast avec un arrière-plan personnalisé et une vue a fait le tour pour moi. Je l’ai testé sur la tablette Nexus 7 et je n’ai remarqué aucune animation de fadein lors de la mise en boucle. Voici la mise en œuvre:

     public static void customToast(Context context, Ssortingng 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(); } } 

    Voici la vue de texte personnalisée utilisée dans le code ci-dessus:

      

    @ drawable / fragment_background fait que mon toast a un coin arrondi comme dans la version kitkat. Vous pouvez également append d'autres vues dans le fichier. Toute modification pour amélioration et commentaires est encouragée, car je prévois de l'implémenter dans mon application en direct.

    Planifiez un compte à rebours jusqu’à une date ultérieure, avec des notifications régulières sur les intervalles en cours de route. Exemple d’affichage d’un compte à rebours de 30 secondes dans un champ de texte:

    
          new CountDownTimer (30000, 1000) {
    
          vide public surTick (long millisUntilFinished) {
              mTextField.setText ("secondes restantes:" + millisUntilFinished / 1000);
          }
    
          annulation publique surFinish () {
              mTextField.setText ("done!");
          }
       }.début();
    
    
    

    Toast Durée peut être piraté en utilisant un thread qui exécute le toast exclusivement. Cela fonctionne (exécute le toast pendant 10 secondes, modifie le sumil et le ctr à votre convenance):

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

    Ce texte disparaîtra dans 5 secondes.

      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 

    Edit: Comme Itai Spector dans le commentaire a dit qu’il sera montré environ 3,5 secondes, utilisez donc ce code:

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

    Une approche très simple pour créer un message légèrement plus long est la suivante:

     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 Ssortingng statusMessage, boolean extraLongDuration) { removeCallbacks(extendStatusMessageLengthRunnable); myToast.setText(statusMessage); myToast.show(); if(extraLongDuration) { postDelayed(extendStatusMessageLengthRunnable, 3000L); } } 

    Notez que l’exemple ci-dessus élimine l’option LENGTH_SHORT pour garder l’exemple simple.

    Vous ne voudrez généralement pas utiliser un message Toast pour afficher des messages à des intervalles très longs, car ce n’est pas le but de la classe Toast. Mais il y a des moments où la quantité de texte à afficher peut prendre plus de 3,5 secondes pour que l’utilisateur puisse lire et, dans ce cas, une légère extension de temps (par exemple, jusqu’à 6,5 secondes, comme indiqué ci-dessus) peut être utile et compatible avec l’utilisation prévue.

    Définit le toast sur une période spécifique en milli-secondes:

     public void toast(int millisec, Ssortingng 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(); } 

    Après avoir échoué avec toutes les solutions disponibles, j’ai finalement trouvé une solution de rechange en utilisant la récursivité.

    Code:

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

    Une solution très simple à la question. Deux ou trois d’entre eux feront durer Toast plus longtemps. C’est la seule solution.

    Vous pouvez définir le temps souhaité en millisecondes dans Toast.makeText(); méthode comme celle-ci:

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