usar - toast android xamarin

¿Puede una tostada de Android ser más larga que Toast.LENGTH_LONG?

Question

Cuando se usa setDuration () para un Toast, ¿es posible establecer una longitud personalizada o al menos algo más largo que Toast.LENGTH_LONG ?

Answer 1

Aquí hay un método muy simple que me funcionó:

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

La duración de LENGTH_SHORT es de 2 segundos y LENGTH_LONG es de 3.5 segundos. Aquí se mostrará el mensaje de tostado durante 6 segundos ya que está encerrado en un bucle for. Pero un inconveniente de este método es que después de cada 2 segundos puede surgir un pequeño efecto de desvanecimiento. Pero no se nota mucho. Espero que sea de ayuda

Answer 2

Aquí hay una clase personalizada de Toast que hice con el código anterior:

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

Answer 3

Como lo mencionaron otros, los brindis de Android pueden ser LENGTH_LONG o LENGTH_SHORT. No hay forma de evitar esto, ni debes seguir ninguno de los ''hacks'' publicados.

El objetivo de Toasts es mostrar información "no esencial" y, debido a su efecto persistente, los mensajes pueden quedar fuera de contexto si su duración supera un cierto umbral. Si se modificaron los brindis comunes para que se muestren más de LONGITUD, el mensaje permanecerá en la pantalla hasta que el proceso de la aplicación finalice a medida que se agregan vistas de toast al WindowManager y no a ViewGroup en su aplicación. Supongo que esta es la razón por la que está codificado.

Si es absolutamente necesario mostrar un mensaje de estilo de brindis por más de tres segundos y medio, recomiendo crear una vista que se adjunte al contenido de la Actividad, de esa forma desaparecerá cuando el usuario salga de la aplicación. Mi biblioteca SuperToasts ocupa de este problema y de muchos otros, ¡no dude en usarlo! Lo más probable es que SuperActivityToasts interesado en usar SuperActivityToasts

Answer 4

Después de fallar con cada solución disponible, finalmente tuve una solución alternativa utilizando la recursión.

Código:

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

Answer 5

El usuario no puede tener definida la duración del Toast. porque la función scheduleTimeoutLocked () de NotificationManagerService no usa la duración del campo. El código fuente es el siguiente.

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

Answer 6

Es posible que desee probar:

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

doblar el tiempo. Si especifica 3 en lugar de 2, se triplicará el tiempo ... etc.

Answer 7

Establece el brindis a un período específico en milisegundos:

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

Answer 8

Este texto desaparecerá en 5 segundos.

 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: Como Itai Spector en el comentario dijo que se mostrará unos 3,5 segundos, así que usa este código:

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

Answer 9

He codificado una clase de ayuda para hacer esto. Puede ver el código en github: https://github.com/quiqueqs/Toast-Expander/blob/master/src/com/thirtymatches/toasted/ToastedActivity.java

Así es como mostrarías un brindis durante 5 segundos (o 5000 milisegundos):

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

Answer 10

He desarrollado una clase de Toast personalizado con la que puedes mostrar Toast durante un tiempo deseado (en Milli segundos)

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

Answer 11

La duración de la tostada se puede hackear utilizando un hilo que ejecuta la tostada exclusivamente. Esto funciona (ejecuta el brindis durante 10 segundos, modifica el reposo y presiona el botón a tu gusto):

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

Answer 12

La mejor solución para evitar efectos de desvanecimiento entre los brindis que se lanzan en secuencia:

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

Aquí la tostada se muestra aproximadamente 10 s.

Espero que esto ayude.

Answer 13

Los valores de LENGTH_SHORT y LENGTH_LONG son 0 y 1. Esto significa que se tratan como indicadores en lugar de duraciones reales, por lo que no creo que sea posible establecer la duración en otra cosa que no sean estos valores.

Si desea mostrar un mensaje al usuario por más tiempo, considere una Notificación de barra de estado . Las notificaciones de la barra de estado pueden cancelarse programáticamente cuando ya no son relevantes.

Answer 14

Por qué comer Toast, cuando puedes tener todo el Snackbar : https://developer.android.com/reference/android/support/design/widget/Snackbar.html

Snackbar> Tostadas, Tostadas Personalizadas, Crouton

Answer 15

Programe una cuenta regresiva hasta un momento en el futuro, con notificaciones regulares en intervalos a lo largo del camino. Ejemplo de mostrar una cuenta atrás de 30 segundos en un campo de texto:

new CountDownTimer(30000, 1000) { public void onTick(long millisUntilFinished) { mTextField.setText("seconds remaining: " + millisUntilFinished / 1000); } public void onFinish() { mTextField.setText("done!"); } }.start();

Answer 16

Puede establecer el tiempo deseado en milisegundos en Toast.makeText(); método como este:

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

Answer 17

Sé que la respuesta es bastante tardía ... Tuve el mismo problema y decidí implementar mi propia versión de Toast con huesos desnudos, después de buscar en el código fuente de Android.

Básicamente, necesita crear un nuevo administrador de ventanas y mostrar y ocultar la ventana para la duración deseada utilizando un controlador

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

Después de la inicialización del diseño, puede utilizar sus propios métodos de ocultar y mostrar.

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

Ahora todo lo que necesita es agregar dos subprocesos ejecutables que llamen a handleShow () y a handleHide () que podría publicar en el controlador.

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

y la parte final

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

Esta fue una implementación rápida y sucia ... No he tenido en cuenta ningún rendimiento.

Answer 18

Sé que llego un poco tarde, pero tomé la respuesta de Regis_AG y la envolví en una clase de ayuda y funciona muy 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();
}
}

En su código de aplicación, simplemente haga algo como esto:

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

Answer 19

Si desea que persista un Toast , descubrí que puede hacerlo a través de un Timer call toast.show() repetidamente (cada segundo debe hacerlo). Llamar a show() no rompe nada si el Toast ya se está mostrando, pero actualiza la cantidad de tiempo que permanece en la pantalla.

Answer 20

Si necesita un brindis largo, hay una alternativa práctica, pero requiere que su usuario haga clic en el botón Aceptar para que desaparezca. Puedes usar un AlertDialog como este:

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 tiene un mensaje largo, lo más probable es que no sepa cuánto le tomará a su usuario leer el mensaje, por lo que a veces es una buena idea pedirle a su usuario que haga clic en el botón Aceptar para continuar. En mi caso, uso esta técnica cuando un usuario hace clic en un icono de ayuda.

Answer 21

Si profundiza en el código de Android, puede encontrar las líneas que indican claramente que no podemos cambiar la duración del mensaje de Toast.

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

y los valores por defecto para la duración son

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

Answer 22

Simplemente use SuperToast para hacer un brindis elegante en cualquier situación. Haz tu tostada colorida . Edita el color de tu fuente y también su tamaño . Espero que sea todo en uno para ti.

Answer 23

Un brindis con fondo y vista personalizados hizo el truco para mí. Lo probé en la tableta nexus 7 y no noté ninguna animación fadeout fadeout durante el bucle. Aquí está la implementación:

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

Aquí está la vista de texto personalizada utilizada en el código anterior:

<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á haciendo que mi tostada tenga una esquina redondeada como en la versión kitkat. Puede agregar otras vistas también en el archivo. Cualquier modificación para mejorar y comentarios son recomendables ya que planeo implementar esto en mi aplicación en vivo.

Answer 24

Un enfoque muy simple para crear un mensaje un poco más largo es el siguiente:

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

Tenga en cuenta que el ejemplo anterior elimina la opción LENGTH_SHORT para mantener el ejemplo simple.

Por lo general, no querrá usar un mensaje de Toast para mostrar mensajes durante intervalos muy largos, ya que no es el propósito de la clase Toast. Pero hay ocasiones en que la cantidad de texto que necesita mostrar puede llevarle al usuario más de 3.5 segundos leer, y en ese caso una ligera extensión de tiempo (por ejemplo, a 6.5 segundos, como se muestra arriba) puede ser útil, IMO, y consistente con el uso previsto.

Answer 25

Usa Crouton, es una biblioteca muy flexible de Toast.

github.com/keyboardsurfer/Crouton

Puedes usarlo como tostadas:

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

¡O incluso puedes profundizar un poco más y personalizarlo más, como ajustar el tiempo a infinito! por ejemplo, aquí quiero mostrar un mensaje de brindis hasta que el usuario lo reconozca haciendo clic en él.

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 que será inflado para la tostada.

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

Answer 26

LONG_DELAY muestra de tostado durante 3,5 segundos y SHORT_DELAY muestra de tostado durante 2 segundos .

Toast usa internamente INotificationManager y llama a su método enqueueToast cada vez que se llama a Toast.show ().

Llamar al show () con SHORT_DELAY dos veces se pondrá en cola del mismo modo nuevamente. se mostrará durante 4 segundos (2 segundos + 2 segundos).

de manera similar, llamar al show () con LONG_DELAY dos veces en cola del mismo modo nuevamente. se mostrará durante 7 segundos (3.5 segundos + 3.5 segundos)

Answer 27

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

Answer 28

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

Una solución muy simple a la pregunta. El doble o el triple de ellos hará que Toast dure más tiempo. Es la única manera alrededor.