안드로이드 토스트가 토스트보다 더 길 수 있습니까?LEGTH_LONG?

안드로이드 토스트가 토스트보다 더 길 수 있습니까?LEGTH_LONG?

을 때하거나 setDuration() 에보다 긴할 수 Toast.LENGTH_LONG?

안드로이드 코드에 대해 자세히 알아보면 토스트 메시지의 지속 시간을 변경할 수 없다는 것을 명확하게 나타내는 줄을 찾을 수 있습니다.

 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

의 값은 0과 1입니다.이것은 실제 기간이 아닌 플래그로 취급된다는 것을 의미하기 때문에 기간을 이 값 이외에 설정하는 것은 불가능할 것 같습니다.

사용자에게 메시지를 더 길게 표시하려면 상태 표시줄 알림을 고려합니다.상태 표시줄 알림은 더 이상 관련이 없을 때 프로그래밍 방식으로 취소할 수 있습니다.

다음을 시도해 볼 수 있습니다.

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

시간을 두 배로 늘리려고요2 대신 3을 지정하면 시간이 3배로 늘어납니다.기타.

당신이 원한다면,Toast지속적으로 말하자면, 당신이 그것을 함으로써 당신의 길을 해킹할 수 있다는 것을 발견했습니다.Timertoast.show()반복적으로 (매초 그렇게 해야 함). 중인gshow()면이 Toast이미 표시되고 있지만 화면에 남아 있는 시간을 새로 고칩니다.

원하는 기간(밀리초 단위) 동안 토스트를 보여줄 수 있는 커스텀 토스트 클래스를 개발했습니다.

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

LONG_DELLAY 토스트 디스플레이는 3.5초, SHORT_DELLAY 토스트 디스플레이는 2초.

토스트는 내부적으로 INotification Manager를 사용하며, Tast.show()가 호출될 때마다 enqueueTast 메서드를 호출합니다.

쇼()를 SHOT_DELLAY로 두 번 호출하면 동일한 토스트가 다시 이어집니다.4초(2초 + 2초) 동안 표시됩니다.

마찬가지로 LONG_DELLAY로 쇼()를 두 번 호출하면 동일한 토스트가 다시 이어집니다.7초(3.5초 + 3.5초) 동안 표시됩니다.

나는 이것을 하기 위해 도우미 수업을 코드화했습니다.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);

제가 좀 늦었지만 레지스를 데려갔습니다.AG의 답변과 헬퍼 클래스로 포장했는데 잘 되네요.

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

응용 프로그램 코드에서 다음과 같은 작업을 수행합니다.

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

답이 꽤 늦었다는 것을 압니다.저는 같은 문제를 가지고 있었고 토스트에 대한 안드로이드의 소스 코드를 조사한 후 저만의 베어본 토스트 버전을 구현하기로 결정했습니다.

기본적으로 새 윈도우 관리자를 만들고 핸들러를 사용하여 원하는 기간 동안 윈도우를 표시하고 숨겨야 합니다.

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

이제 핸들 Show()와 핸들러에 게시할 수 있는 handleHide()라는 두 개의 실행 가능한 스레드를 추가하기만 하면 됩니다.

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

}

이는 신속하고 더러운 구현이었습니다.성능을 전혀 고려하지 않았습니다.

다음은 위 코드를 사용하여 만든 맞춤형 토스트 클래스입니다.

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

긴 토스트가 필요하다면 실용적인 대안이 있지만, 그것을 없애려면 사용자가 확인 버튼을 클릭해야 합니다.다음과 같이 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();

메시지가 긴 경우 사용자가 메시지를 읽는 데 얼마나 걸릴지 알 수 없으므로 계속하려면 사용자에게 확인 버튼을 클릭하도록 요구하는 것이 좋습니다.제 경우에는 도움말 아이콘을 클릭할 때 이 방법을 사용합니다.

다른 사람들이 언급한 것처럼 안드로이드 토스트는 LENGTH_LONG 또는 LENGTH_Short가 될 수 있습니다.이를 피할 방법은 없으며 게시된 '핵'을 따라서도 안 됩니다.

건배의 목적은 "필수적이지 않은" 정보를 표시하는 것이며, 메시지의 지속 시간이 일정 한계를 초과할 경우 메시지가 맥락을 훨씬 벗어날 수 있습니다.재고 토스트가 LENGTH_LONG보다 길게 표시될 수 있도록 수정된 경우 앱의 ViewGroup이 아닌 WindowManager에 토스트 보기가 추가되어 응용 프로그램의 프로세스가 종료될 때까지 메시지가 화면에 표시됩니다.나는 이것이 왜 그것이 하드 코딩된 이유라고 추측할 것입니다.

3초 반 이상의 토스트 스타일 메시지를 꼭 보여주어야 할 경우, 사용자가 프로그램을 종료할 때 작업 내용에 첨부된 보기를 작성하는 것이 좋습니다.나의 슈퍼토스트 라이브러리는 이 문제를 다루고 있으며 다른 많은 것들도 자유롭게 사용할 수 있습니다.수퍼액티비티를 사용하는 데 가장 관심이 있을 것입니다.토스트

어떤 상황에서든 우아한 토스트를 만들기만 하면 됩니다.토스트를 알록달록하게 만드세요.글꼴 색과 크기를 편집합니다.당신을 위해 모든 것이 하나가 되기를 바랍니다.

스낵바 전체를 먹을 수 있는데 토스트를 먹는 이유: https://developer.android.com/reference/android/support/design/widget/Snackbar.html

스낵바 > 토스트, 커스텀 토스트, 크루통

아니요, 그리고 여기 나열된 대부분의 해킹은 안드로이드 9에서 더 이상 작동하지 않습니다.하지만 훨씬 더 좋은 해결책이 있습니다. 메시지를 보내야 한다면 대화 상자를 사용하는 것입니다.

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

사용자가 토스트 기간을 정의한 것을 사용자 지정할 수 없습니다.Notification Manager Service의 scheduleTimeoutLocked() 함수가 필드 지속 시간을 사용하지 않기 때문입니다.소스코드는 다음과 같습니다.

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

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>

토스트를 독점적으로 실행하는 스레드를 사용하여 토스트 시간을 해킹할 수 있습니다.다음과 같이 작동합니다(10초간 토스트 실행, 수면 및 ctr을 원하는 대로 수정).

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

저는 맞춤 배경과 전망이 있는 건배사가 효과가 있었습니다.넥서스 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는 내 토스트를 킷캣 버전처럼 둥글게 만듭니다.파일에 다른 보기도 추가할 수 있습니다.개선을 위한 수정사항과 댓글은 제 라이브 앱에서 구현할 예정이기 때문에 권장합니다.

앞으로 일정 시간까지 카운트다운 일정을 잡습니다. 일정 간격마다 정기적으로 알림을 보냅니다.텍스트 필드에 30초 카운트다운을 표시하는 예:

new 카운트다운타이머(30000, 1000) {
Tick에 대한 공개공백(끝날 때까지 긴 밀리스) {mTextField.setText("남은 시간: " + millisFinished / 1000까지");}
피니시() {에 대한 공적 무효.mTextField.setText("완료!");}()을(를) 시작합니다.

가능한 모든 해결책에 실패한 후, 저는 마침내 재귀를 이용한 해결책을 갖게 되었습니다.

코드:

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

조금 더 긴 메시지를 만드는 아주 간단한 방법은 다음과 같습니다.

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초 이상 걸릴 수 있으며, 이 경우 IMO는 유용하고 의도된 용도와 일치할 수 있습니다.

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

질문에 대한 아주 간단한 해결책.그것들을 두배나 세배는 토스트를 더 오래 지속하게 만들 것입니다.그것이 유일한 길입니다.

특정 기간(밀리초)에 토스트를 설정합니다.

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

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

이 텍스트는 5초 후에 사라집니다.

    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

편집: Itai Spector가 댓글로 3.5초 정도 보여진다고 했으므로 다음 코드를 사용합니다.

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

val toast = Toast.makeText(this, "", Toast.LENGTH_LONG)

val countDownTimer = object : CountDownTimer(5000, 1000) {
    override fun onTick(millisUntilFinished: Long) { }
    override fun onFinish() { toast.cancel() }
}

toast.show()
countDownTimer.start()

언급URL : https://stackoverflow.com/questions/2220560/can-an-android-toast-be-longer-than-toast-length-long