Può un toast Android essere più lungo di Toast.LENGTH_LONG?

Quando si utilizza setDuration () per un Toast, è ansible impostare una lunghezza personalizzata o alless qualcosa di più lungo di Toast.LENGTH_LONG ?

  • Applicazione ibrida di Visual Studio 2015 - "EPERM, operazione non consentita"
  • android GCM ottiene l'ID originale di ID canonical
  • Vista personalizzata della barra degli strumenti
  • Android LEGGERA IL FONO STATO?
  • Salva BottomNavigationView l'elemento selezionato durante la rotazione dello schermo
  • Adattatore di sincronizzazione per Android?
  • Come utilizzare le prese UDP in android?
  • Android - notifyDataSetChange dall'interno della class Custom ArrayAdapter
  • IabHelper AcquistoFinishedListener
  • Passaggio di dati tramite intenti invece di costruttori
  • Quali sono i tipi di pelle in Android Studio?
  • Android - FAB da hide quando si naviga tra diversi frammenti in un viewpager
  • 25 Solutions collect form web for “Può un toast Android essere più lungo di Toast.LENGTH_LONG?”

    I valori di LENGTH_SHORT e LENGTH_LONG sono 0 e 1. Ciò significa che sono trattati come bandiere piuttosto che durate effettive, quindi non credo che sarà ansible impostare la durata su qualsiasi cosa diverso da questi valori.

    Se desideri mostrare un messaggio all'utente più a lungo, consideri una notifica della barra di stato . Le notifiche delle barre di stato possono essere annullate in modo programmato quando non sono più rilevanti.

    Se si scava più a fondo nel codice android, è ansible trovare le righe che indicano chiaramente che non è ansible modificare la durata del messaggio Toast.

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

    ei valori predefiniti per la durata sono

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

    Puoi provare:

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

    per raddoublere il tempo. Se si specifica 3 invece il 2 si tripla il tempo .. ecc.

    La soluzione migliore per evitare effetti di dissolvenza tra i toast lanciati in sequenza:

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

    Qui il toast viene visualizzato circa 10 s.

    Spero che questo ti aiuti.

    Se vuoi che un Toast persista, ho trovato che puoi farti strada in giro con un Timer call toast.show() ripetutamente (each secondo o così dovrebbe fare). Lo show() non interrompe se il Toast sta già visualizzando, ma aggiorna la quantità di tempo che rimane sullo schermo.

    Ho codificato una class di aiutante per farlo. Puoi vedere il codice in github: https://github.com/quiqueqs/Toast-Expander/blob/master/src/com/thirtymatches/toasted/ToastedActivity.java

    Questo è il modo in cui visualizzare un toast per 5 secondi (o 5000 millisecondi):

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

    Ho sviluppato una class di Toast personalizzato con cui puoi mostrare Toast per una durata desiderata (in millesimi secondi)

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

    So che sono un po 'tardi, ma ho preso la risposta di Regis_AG e lo ho avvolto in una class di aiutanti e funziona ottimamente.

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

    Nel codice dell'applicazione, fai qualcosa di simile:

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

    So che la risposta è abbastanza tardi .. ho avuto la stessa questione e ho deciso di implementare la mia versione di ossa nude Toast, dopo aver esaminato il codice sorgente android per toast.

    Fondamentalmente è necessario creare un nuovo gestore di windows e mostrare e hide la window per la durata desiderata utilizzando un gestore

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

    Dopo l'initialization del layout è ansible utilizzare i propri methods di hide e mostrare

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

    Ora tutto ciò che serve è aggiungere due thread fattibili che chiamano il handleShow () e il handleHide () che puoi submit al gestore.

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

    e la parte finale

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

    Questa è stata un'applicazione rapida e sporca .. Non hanno preso in considerazione alcuna prestazione.

    LONG_DELAY visualizzazione del pane tostato per 3,5 sec e SHORT_DELAY display per 2 secondi .

    Il Toast utilizza internamente INotificationManager e chiama il metodo enqueueToast each volta che viene chiamato un Toast.show ().

    Chiamare lo spettacolo () con SHORT_DELAY due volte avrà nuovamente lo stesso brindisi. viene visualizzato per 4 sec (2 sec + 2 sec).

    allo stesso modo, call lo show () con LONG_DELAY due volte nuovamente lo stesso toast. verrà visualizzato per 7 sec (3,5 sec + 3,5 sec)

    Ecco una class Toast personalizzata che ho fatto utilizzando il codice riportto di seguito:

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

    Se hai bisogno di un toast lungo, c'è un'alternativa pratica, ma richiede all'utente di fare clic su un button OK per farla andare via. È ansible utilizzare un AlertDialog come questo:

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

    Se si dispone di un messaggio lungo, le probabilità sono che non sappiamo quanto tempo ci vorrà per il tuo utente per leggere il messaggio, quindi a volte è una buona idea richiedere all'utente di fare clic su un button OK per continuare. Nel mio caso, utilizzo questa tecnica quando un utente fa clic su un'icona di aiuto.

    Come indicato da altri Android Toasts possono essere LENGTH_LONG o LENGTH_SHORT. Non c'è nessun modo per questo, né dovresti seguire nessuna delle "hack" inviate.

    Lo scopo dei brindisi è quello di visualizzare informazioni "non essenziali" e, a causa del loro effetto persistente, i messaggi possono essere messi al di fuori del context se la loro durata supera una determinata soglia. Se i panieri di riserva sono stati modificati in modo che possano visualizzare più a lungo di LENGTH_LONG il messaggio rimanere sullo schermo finché il process dell'applicazione non verrà terminato, poiché le viste di toast vengono aggiunte a WindowManager e non a ViewGroup nell'applicazione. Suppongo che questo è il motivo per cui è codificato.

    Se è assolutamente necessario mostrare un messaggio di stile di pane tostato superiore a tre e mezzo secondi, consiglio di creare una vista che sia collegata ai contenuti dell'attività, in questo modo sparirà quando l'utente esce dall'applicazione. La mia biblioteca SuperToasts si occupa di questo problema e di tante altre persone, sentitevi liberi di usarla! Probabilmente siete interessati ad utilizzare SuperActivityToasts

    Utilizza semplicemente SuperToast per creare un toast elegante in qualsiasi situazione. Rendi il tuo tostato colorato . Modifica il colore del carattere e anche la sua dimensione . Spero che sia tutto in uno per te.

    L'utente non può definire la durata del Toast. perché la function scheduleTimeoutLocked () di NotificationManagerService non utilizza la durata del field. il codice sorgente è il seguente.

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

    Usa Crouton, è una libreria flessibile di toast.

    Crostino

    Puoi utilizzarlo come i brindisi:

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

    o puoi anche andare un po 'più in profondità e personalizzarla di più, come impostare il tempo in infinito! ad esempio qui voglio mostrare un messaggio di toast finché l'utente lo riconosce cliccando su di esso.

     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 che sarà gonfiato per il toast.

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

    Perché mangiare Toast, quando puoi avere l'integer Snackbar : https://developer.android.com/reference/android/support/design/widget/Snackbar.html

    Snackbar> Toast, Pane tostato, Crostino

    Un toast con background e vista personalizzati ha fatto il trucco per me. Ho provato in tablet nexus 7 e non ho notato alcuna animation fadein fadein durante looping. Ecco l'implementazione:

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

    Ecco la vista testuale personalizzata utilizzata nel codice precedente:

     <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 sta facendo il mio pane tostato con angolo arrotondato come nella versione del kitkat. È anche ansible aggiungere altre viste nel file. Le modifiche per il miglioramento e le osservazioni sono incoraggiate in quanto ho intenzione di metterlo in pratica nella mia app live.

    Ecco un metodo molto semplice che ha funzionato per me:

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

    La durata di LENGTH_SHORT è di 2 secondi e LENGTH_LONG è di 3,5 secondi. Qui il messaggio di toast viene visualizzato per 6 secondi in quanto è incluso in un for loop. Ma un inconveniente di questo metodo è dopo each 2 sec che potrebbe sorgere un piccolo effetto di dissolvenza. ma non è molto evidente. Spero che sia utile

    Pianificare un conto alla rovescia fino a un tempo in futuro, con notifiche regolari sugli intervalli lungo la strada. Esempio di mostrare un conto alla rovescia di 30 secondi in un field di text:

    
          nuovo CountDownTimer (30000, 1000) {
    
          pubblica void onTick (long millisUntilFinished) {
              mTextField.setText ("secondi restanti:" + millisUntilFinished / 1000);
          }
    
          pubblica void onFinish () {
              mTextField.setText ( "fatto!");
          }
       }.inizio();
    
    
    

    Un approccio molto semplice per creare un messaggio leggermente più lungo è il seguente:

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

    Si noti che l'esempio sopra elimina l'opzione LENGTH_SHORT per mantenere l'esempio semplice.

    Generalmente non si desidera utilizzare un messaggio Toast per visualizzare i messaggi per intervalli molto lunghi, in quanto ciò non è lo scopo previsto della class Toast. Ma ci sono momentjs in cui la quantità di text che si desidera visualizzare può richiedere all'utente più di 3,5 secondi per leggere, e in tal caso una lieve estensione del tempo (ad esempio, a 6,5 ​​secondi, come indicato in precedenza) può essere IMO utile e coerente con l'uso previsto.

    Imposta il toast a un periodo specifico in milli-second:

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

    Questo text scompare in 5 secondi.

      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 
     Toast.makeText(this, "Text", Toast.LENGTH_LONG).show(); Toast.makeText(this, "Text", Toast.LENGTH_LONG).show(); 

    Una soluzione molto semplice alla domanda. Due o tre volte di loro farà tostare più a lungo. È l'unico modo in giro.

    È ansible impostare il tempo desiderato in millisecondi nel Toast.makeText(); metodo come questo:

     //40 seconds long mToastLength = 40*1000 //this toast will be displayed for 40 seconds. Toast.makeText(this, "Hello!!!!!", mToastLength).show(); 
    L'Android è un fan Android di Google, tutto su telefoni Android, Android Wear, Android Dev e applicazioni Android Games e così via.