Un Android Toast peut-il être plus long que Toast.LENGTH_LONG?
Lors de l'utilisation de setDuration () pour un pain grillé, est-il possible de définir une longueur personnalisée ou au moins quelque chose de plus long que Toast.LENGTH_LONG?
Les valeurs LENGTH_SHORT et 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, donc je ne pense pas il sera possible de définir la durée sur autre chose que ces valeurs.
Si vous souhaitez afficher un message à l'utilisateur plus longtemps, considérez un Notification de la 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 voudrez peut-être 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, le temps sera triple, etc.
La meilleure solution pour éviter les effets d’atténuation 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 pain grillé est affiché environ 10 s.
J'espère que cela t'aides.
Si vous voulez qu'une Toast persiste, j'ai découvert que vous pouvez la contourner en faisant en sorte que Timer appelle toast.show() à plusieurs reprises (chaque seconde ou plus devrait suffire). L'appel de show() n'interrompt rien si le Toast est déjà affiché, mais il actualise la durée pendant laquelle il reste à l'écran.
J'ai développé une classe de Toast personnalisée avec laquelle vous pouvez montrer Toast pendant une 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 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);
}
}
}
J'ai codé une classe d'assistance pour faire cela. Vous pouvez voir le code sur github: https://github.com/quiqueqs/Toast-Expander/blob/master/src/com/thirtymatches/toasted/ToastedActivity.Java
Voici comment afficher un pain grillé pendant 5 secondes (ou 5 000 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 enveloppé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(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();
}
}
Dans votre code d'application, procédez comme suit:
Toaster.makeLongToast("Toasty!", 8000);
Je sais que la réponse est assez tardive. J'avais exactement le même problème et j'ai décidé de mettre en œuvre ma propre version de Toast bare bones, après avoir examiné le code source d'Android pour le pain grillé.
En gros, vous devez créer un nouveau gestionnaire de fenêtres, puis afficher et masquer la fenêtre pendant 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 présentation, vous pouvez utiliser vos propres méthodes de masquage et d’affichage.
public void handleShow() {
mWindowManager.addView(mLayout, mParams);
}
public void handleHide() {
if (mLayout != null) {
if (mLayout.getParent() != null) {
mWindowManager.removeView(mLayout);
}
mLayout = null;
}
Tout ce dont vous avez besoin maintenant est d’ajouter deux threads exécutables qui appellent les descripteurs handleShow () et handleHide () que vous pouvez poster dans 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. N'a pris aucune performance en considération.
LONG_DELAY Affichage du pain grillé pour ,5 secondes et SHORT_DELAY Affichage du pain grillé pour 2 secondes.
Toast utilise en interne INotificationManager et appelle sa méthode enqueueToast chaque fois qu'un Toast.show () est appelé.
Appelez show () avec SHORT_DELAY deux fois pour mettre en file d'attente le même pain grillé. il s'affichera pendant 4 secondes (2 secondes + 2 secondes).
de même, appelez show () avec LONG_DELAY deux fois pour mettre en file d'attente le même pain grillé. il affichera pendant 7 secondes (3.5 secondes + 3.5 secondes)
Voici une classe Toast personnalisée que j'ai créée à l'aide du 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 pain grillé, il existe une alternative pratique, mais il faut que l'utilisateur clique sur un bouton OK pour le faire disparaître. Vous pouvez utiliser un AlertDialog comme ceci:
String message = "This is your message";
new AlertDialog.Builder(YourActivityName.this)
.setTitle("Optional Title (you can omit this)")
.setMessage(message)
.setPositiveButton("ok", null)
.show();
Si votre message est long, il est probable que vous ne sachiez pas combien de temps il faudra à votre utilisateur pour le lire. Il est donc parfois judicieux 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, les toasts peuvent être LENGTH_LONG ou LENGTH_SHORT. Il n’ya aucun moyen de contourner cela, et vous ne devriez pas non plus suivre les "hacks" postés.
Les toasts ont pour but d'afficher des informations "non essentielles" et, en raison de leur effet de longue durée, les messages peuvent être très éloignés du contexte si leur durée dépasse un certain seuil. Si les toasts en stock ont été modifiés pour pouvoir afficher plus longtemps que LENGTH_LONG, le message persiste jusqu'à ce que le processus de l'application se termine, car les vues de pain grillé sont ajoutées au WindowManager et non à un ViewGroup dans votre application. Je suppose que c'est pourquoi c'est codé en dur.
Si vous devez absolument afficher un message de style toast de plus de trois secondes et demie, nous vous recommandons de créer une vue qui sera attachée au contenu de l'activité, afin qu'elle disparaisse lorsque l'utilisateur quittera l'application. Ma bibliothèque SuperToasts traite de cette question et de nombreuses autres, n'hésitez pas à l'utiliser! Vous voudriez probablement utiliser SuperActivityToasts
Utilisez simplement SuperToast pour créer un toast élégant dans toutes les situations. Faites votre pain grillé coloré . Modifiez votre couleur de police et sa taille . J'espère que ce sera tout en un pour vous.
Pourquoi manger du pain grillé, quand vous pouvez avoir tout Snackbar : https://developer.Android.com/reference/Android/support/ design/widget/Snackbar.html
Snackbar> Toast, Toast personnalisé, Crouton
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 celle de LENGTH_LONG est de 3,5 secondes. Le message toast sera affiché ici pendant 6 secondes puisqu'il est enfermé dans une boucle for. Mais un inconvénient de cette méthode est qu’après 2 secondes, un léger effet de fondu peut apparaître. mais ce n'est pas beaucoup perceptible. J'espère que c'est utile
Utilisez Crouton, c'est une bibliothèque Toast très flexible.
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 régler le temps à l'infini! par exemple ici je veux montrer un message de pain grillé jusqu'à ce que l'utilisateur le reconnaisse en cliquant dessus.
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 qui sera gonflé pour le pain grillé.
<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>
L'utilisateur ne peut pas définir la durée du Toast. parce que 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);
}
La durée du toast peut être piratée à l’aide d’un thread exécutant exclusivement le toast. Cela fonctionne (exécute le toast pendant 10 secondes, modifie veille et 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();
Planifiez un compte à rebours jusqu'à une date ultérieure, avec des notifications régulières sur les intervalles. Exemple d'affichage d'un compte à rebours de 30 secondes dans un champ de texte:
new CountDownTimer (30000, 1000) {
public void onTick (long millisUntilFinished) {
mTextField.setText ("secondes restantes:" + millisUntilFinished/1000);
}
public void onFinish () {
mTextField.setText ("done!");
}
}.début();
Un pain grillé avec un arrière-plan et une vue personnalisés a fait l'affaire pour moi. Je l'ai testé dans Nexus 7 Tablet et je n'ai remarqué aucune animation de fadein lors de la boucle. Heres la mise en œuvre:
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();
}
}
Voici le texte personnalisé utilisé dans le code ci-dessus:
<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 est en train de faire mon pain grillé ont coin arrondi comme dans la version KitKat. Vous pouvez également ajouter d'autres vues dans le fichier. Toute modification apportée à des améliorations et commentaires sont encouragés, car je prévois de mettre cela en œuvre dans mon application en direct.
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 un commentaire a déclaré qu'il sera affiché 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 String 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 conserver l'exemple simple.
En règle générale, vous ne voudrez pas utiliser un message Toast pour afficher des messages sur de très longs intervalles, car cela n’est pas l’objet de la classe Toast. Mais il arrive parfois que la quantité de texte que vous devez afficher prenne plus de 3,5 secondes de lecture, et dans ce cas, une légère extension de temps (par exemple, jusqu'à 6,5 secondes, comme indiqué ci-dessus) peut, IMO, être utile et compatible avec l'utilisation prévue.
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();
}
Non, et la plupart/tous les hacks répertoriés ici ne fonctionnent plus dans Android 9. Mais il existe une bien meilleure solution: si vous devez conserver un message, utilisez une boîte de dialogue.
(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();
Après avoir échoué avec toutes les solutions disponibles, j'ai finalement eu une solution de contournement 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);
}
Définit le toast sur une période spécifique en millisecondes:
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);
}
}
}