android - क्या एंड्रॉइड टोस्ट टोस्ट से अधिक लंबा हो सकता है। LNGTH_LONG?




android-toast (18)

टोस्ट के लिए setDuration () का उपयोग करते समय, क्या कस्टम लंबाई या कम से कम कुछ Toast.LENGTH_LONG सेट करना संभव है?


Crouton का प्रयोग करें, यह एक बहुत लचीला टोस्ट पुस्तकालय है।

github.com/keyboardsurfer/Crouton

आप इसे टोस्ट्स की तरह इस्तेमाल कर सकते हैं:

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

या आप थोड़ा गहरा भी जा सकते हैं और इसे और अधिक अनुकूलित कर सकते हैं, जैसे अनंत समय को सेट करना! उदाहरण के लिए यहां मैं एक टोस्ट संदेश दिखाना चाहता हूं जब तक कि उपयोगकर्ता इसे क्लिक करके इसे स्वीकार न करे।

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

कस्टमा लेआउट जो टोस्ट के लिए फुलाया जाएगा।

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

अनुक्रम में लॉन्च किए गए टोस्ट्स के बीच लुप्तप्राय प्रभाव से बचने का सबसे अच्छा समाधान:

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

यहां टोस्ट लगभग 10 एस प्रदर्शित होता है।

उम्मीद है की यह मदद करेगा।


आप वांछित समय को Toast.makeText(); में मिलीसेकंड में सेट कर सकते हैं Toast.makeText(); इस तरह की विधि:

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

उपयोगकर्ता टोस्ट की अवधि को परिभाषित नहीं कर सकता है। क्योंकि अधिसूचना प्रबंधक सेवा का शेड्यूलटाइम लॉक () फ़ंक्शन फ़ील्ड अवधि का उपयोग नहीं करता है। स्रोत कोड निम्नलिखित है।

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

कस्टम पृष्ठभूमि और दृश्य के साथ एक टोस्ट मेरे लिए चाल थी। मैंने इसे नेक्सस 7 टैबलेट में परीक्षण किया और मैंने लूपिंग के दौरान कोई फीडिन फीडआउट एनीमेशन नहीं देखा। कार्यान्वयन का पालन करता है:

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

}

उपरोक्त कोड में उपयोग किए गए कस्टम टेक्स्टव्यू का पालन करता है:

<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 मेरे टोस्ट को किटकैट संस्करण के रूप में गोलाकार कोने बना रहा है। आप फ़ाइल में अन्य विचार भी जोड़ सकते हैं। सुधार और टिप्पणियों के लिए कोई भी संशोधन प्रोत्साहित किया जाता है क्योंकि मैं इसे अपने लाइव ऐप में लागू करने की योजना बना रहा हूं।


जैसा कि अन्य एंड्रॉइड टोस्ट्स द्वारा उल्लिखित किया गया है या तो LENGTH_LONG या LENGTH_SHORT हो सकता है। इसके चारों ओर कोई रास्ता नहीं है, और न ही आप पोस्ट किए गए किसी भी 'हैक' का पालन करना चाहिए।

टोस्ट्स का उद्देश्य "अनिवार्य" जानकारी प्रदर्शित करना है और उनके लंबे प्रभाव के कारण, संदेशों को संदर्भ से दूर रखा जा सकता है यदि उनकी अवधि निश्चित सीमा से अधिक हो। यदि स्टॉक टोस्ट संशोधित किए गए थे ताकि वे LENGTH_LONG से अधिक प्रदर्शित कर सकें, संदेश तब तक स्क्रीन पर रुक जाएगा जब तक कि एप्लिकेशन की प्रक्रिया को टोस्ट व्यू के रूप में समाप्त नहीं किया जाता है, विंडोमैनेजर में जोड़ा जाता है और आपके ऐप में व्यू ग्रुप नहीं होता है। मुझे लगता है कि यही कारण है कि यह मुश्किल कोडित है।

यदि आपको पूरी तरह से साढ़े तीन सेकंड से अधिक टोस्ट स्टाइल संदेश दिखाना है, तो मैं उस दृश्य को बनाने की अनुशंसा करता हूं जो गतिविधि की सामग्री से जुड़ा हुआ हो, इस तरह जब उपयोगकर्ता एप्लिकेशन से बाहर निकलता है तो यह गायब हो जाएगा। मेरी SuperToasts लाइब्रेरी इस मुद्दे और कई अन्य लोगों से संबंधित है, इसका उपयोग करने में SuperToasts करें! आप SuperActivityToasts का उपयोग करने में रुचि रखते हैं



थोड़ा लंबा संदेश बनाने का एक बहुत ही सरल तरीका इस प्रकार है:

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

ध्यान दें कि उपर्युक्त उदाहरण उदाहरण को सरल रखने के लिए LENGTH_SHORT विकल्प को समाप्त करता है।

आप आमतौर पर बहुत लंबे अंतराल के लिए संदेश प्रदर्शित करने के लिए टोस्ट संदेश का उपयोग नहीं करना चाहते हैं, क्योंकि यह टोस्ट क्लास का इरादा उद्देश्य नहीं है। लेकिन ऐसे समय होते हैं जब आपको प्रदर्शित करने की आवश्यकता वाले पाठ की मात्रा 3.5 सेकंड से अधिक पढ़ने के लिए उपयोगकर्ता को ले सकती है, और उस स्थिति में समय के थोड़े विस्तार (उदाहरण के लिए, ऊपर दिखाए गए अनुसार 6.5 सेकंड तक), आईएमओ उपयोगी हो सकता है और इच्छित उपयोग के साथ संगत।


मिली-सेकेंड में एक विशिष्ट अवधि में टोस्ट सेट करता है:

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

मुझे पता है कि जवाब काफी देर हो चुकी है .. मेरे पास एक ही समस्या थी और टोस्ट के लिए एंड्रॉइड के स्रोत कोड में देखने के बाद, नंगे हड्डियों टोस्ट के अपने संस्करण को लागू करने का फैसला किया।

असल में आपको एक नया विंडो प्रबंधक बनाने की आवश्यकता है, और हैंडलर का उपयोग करके वांछित अवधि अवधि के लिए विंडो को दिखाएं और छुपाएं

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

लेआउट की शुरुआत के बाद आप अपने स्वयं के छिपाने और शो विधियों का उपयोग कर सकते हैं

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

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

अब आपको केवल दो रननेबल थ्रेड जोड़ना है जो हैंडलशो () और हैंडलहाइड () जिन्हें आप हैंडलर पर पोस्ट कर सकते हैं।

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

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

और अंतिम भाग

public void show() {

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

}

यह एक त्वरित और गंदे कार्यान्वयन था .. किसी भी प्रदर्शन को ध्यान में नहीं लिया है।


मैंने ऐसा करने के लिए एक सहायक वर्ग को कोड किया है। आप github पर कोड देख सकते हैं: https://github.com/quiqueqs/Toast-Expander/blob/master/src/com/thirtymatches/toasted/ToastedActivity.java

इस प्रकार आप 5 सेकंड (या 5000 मिलीसेकंड) के लिए टोस्ट प्रदर्शित करेंगे:

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

मैंने कस्टम टोस्ट क्लास विकसित किया है जिसके साथ आप वांछित मात्रा के लिए टोस्ट दिखा सकते हैं (मिली सेकंड में)

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

यदि आप एंड्रॉइड कोड में गहरी खुदाई करते हैं, तो आप उन रेखाओं को पा सकते हैं जो स्पष्ट रूप से इंगित करते हैं कि हम टोस्ट संदेश की अवधि नहीं बदल सकते हैं।

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

और अवधि के लिए डिफ़ॉल्ट मान हैं

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

यदि आपको लंबे टोस्ट की आवश्यकता है, तो एक व्यावहारिक विकल्प है, लेकिन इसके लिए आपके उपयोगकर्ता को इसे दूर करने के लिए ओके बटन पर क्लिक करने की आवश्यकता है। आप इस तरह एक AlertDialog का उपयोग कर सकते हैं:

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

यदि आपके पास लंबा संदेश है, संभावना है, तो आप नहीं जानते कि आपके उपयोगकर्ता को संदेश पढ़ने में कितना समय लगेगा, इसलिए कभी-कभी यह सुनिश्चित करना एक अच्छा विचार है कि आपके उपयोगकर्ता को जारी रखने के लिए ओके बटन पर क्लिक करना आवश्यक है। मेरे मामले में, जब मैं उपयोगकर्ता सहायता आइकन पर क्लिक करता हूं तो मैं इस तकनीक का उपयोग करता हूं।


यहां एक बहुत ही सरल विधि है जो मेरे लिए काम करती है:

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

LENGTH_SHORT की अवधि 2 सेकंड है और LENGTH_LONG 3.5 सेकंड है, यहां टोस्ट संदेश 6 सेकेंड के लिए दिखाया जाएगा क्योंकि यह लूप के लिए संलग्न है। लेकिन इस विधि की कमी प्रत्येक 2 सेकंड के बाद एक छोटा लुप्तप्राय प्रभाव उत्पन्न हो सकता है। लेकिन यह बहुत ध्यान देने योग्य नहीं है। उम्मीद है कि यह सहायक है


रास्ते में अंतराल पर नियमित अधिसूचनाओं के साथ, भविष्य में एक समय तक एक उलटी गिनती निर्धारित करें। टेक्स्ट फ़ील्ड में 30 सेकंड उलटी गिनती दिखाने का उदाहरण:

     new CountDownTimer(30000, 1000) {

     public void onTick(long millisUntilFinished) {
         mTextField.setText("seconds remaining: " + millisUntilFinished / 1000);
     }

     public void onFinish() {
         mTextField.setText("done!");
     }
  }.start();



3.5 सेकंड के लिए LONG_DELAY टोस्ट डिस्प्ले और 2 सेकंड के लिए SHORT_DELAY टोस्ट डिस्प्ले।

टोस्ट आंतरिक रूप से इनोटिफिकेशन मैनेजर का उपयोग करते हैं और टोस्ट.शो () को हर बार टोस्ट विधि कहते हैं।

शो () को SHORT_DELAY के साथ दो बार कॉल करें, उसी टोस्ट को दोबारा लगाएगा। यह 4 सेकंड (2 सेकंड + 2 सेकंड) के लिए प्रदर्शित होगा।

इसी तरह, शो () को LONG_DELAY के साथ दो बार कॉल करें, उसी टोस्ट को दोबारा लगाएगा। यह 7 सेकंड (3.5 सेकंड + 3.5 सेकंड) के लिए प्रदर्शित होगा


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




android-toast