Android Toast가 Toast.LENGTH_LONG보다 길 수 있습니까?


263

토스트에 setDuration ()을 사용할 때 사용자 정의 길이 또는 적어도 무엇보다 긴 길이를 설정할 수 Toast.LENGTH_LONG있습니까?


4
@Nicolae toast태그 를 제거한 이유는 무엇입니까? 질문과 관련이있는 것 같습니다.
Shadow Wizard는 귀를위한 귀입니다.

2
@ShadowWizard 태그에 관심이있는 질문의 주제를 반영해야합니다. 예를 들어 android 태그가 지정되어 있으므로 Android 전문가가이 질문을 찾습니다. 토스트는이 질문에 전혀 도움이되지 않으며 쓸모없는 태그처럼 보입니다. 토스트가 좋은 경우 Android의 Tag에 대한 질문이기 때문에 길이도 좋은 태그였습니다. 해킹, 질문의 모든 단어는 태그이어야합니다 ... 무례하지, 그냥 내 요점을 :)
Nicu Surdu

11
toast태그를 사용합니다 . 태그가 검색 및 정렬에 도움이되고 toast일반적인 검색 이라고 생각했습니다 . 완벽 androidtoast보입니다.
ChrisWilson4

답변:


142

의 값 LENGTH_SHORT과는 LENGTH_LONG내가이 값 이외의 기간을 설정할 수있을 것입니다 생각하지 않도록 그들이 아니라 실제 기간보다 더 플래그로 취급되는 0과 1이 수단입니다.

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


1
상태 표시 줄에 대한 제안에 감사하지만 사용자 정의 대화 상자 활동을 진행 중입니다.

337

안드로이드 코드를 더 깊이 파고 들었다면 토스트 메시지의 지속 시간을 변경할 수 없다는 것을 분명히 나타내는 줄을 찾을 수 있습니다.

 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

4
고마워 ... 이것은 내가 필요한 것입니다.
mcherm

3
기본값을 게시 해 주셔서 감사합니다! 나는 그들을 찾을 수 없을 까봐 두려웠다.
Amplify91

1
기본 토스트 값도 찾고 있었는데 이것이 첫 번째 히트였습니다. 확실히 공감. 감사!
Dave

120

시도해 볼 수 있습니다.

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

시간을 두 배로 늘릴 수 있습니다. 2 대신 3을 지정하면 시간이 3 배가됩니다.


17
메시지 깜박임 :(
Deniz

61
예를 들어, 토스트 시간 전에 활동을 종료하면 계속 깜박 거릴 것입니다.
dwbrito

@dwbrito : 완전히 동의하고 따라서 -1
Fahim Parkar

[+1] 답변 .... Toast.cancel()적절한 장소에서 토스트를 취소 할 수 있습니다
Devrath

1
그렇습니다. 구현할 수는 있지만, 개수를 지정한만큼 토스트가 깜빡
HendraWD

31

당신이 Toast지속하기 를 원한다면, 당신은 반복적 으로 Timer전화를 걸어 toast.show()(해당 2 초 정도) 해킹 할 수 있다는 것을 알았습니다 . 가 이미 표시되어 show()있으면 전화를 해도 아무런 문제 Toast가 없지만 화면에 머무르는 시간을 새로 고칩니다.


3
이 문제는 사용자가 화면을 터치하면 토스트는 안드로이드에 의해 숨겨 지지만 타이머에 의해 다시 만들어집니다.
바이올렛 기린

2
@VioletGiraffe는 ViewGroup OnTouch이벤트 에서 부울 플래그와 같은 것을 처리하는 것이 쉽지 않습니다 . 이를 최적화하려면 아마도 타이머 Toast가 화면에 표시된 실제 시간 (길이는 3.5 초, 짧게는 2 초)에 가깝게 타이머를 반복해야합니다.
syklon

18

원하는 지속 시간 (밀리 초) 동안 토스트를 표시 할 수있는 사용자 정의 토스트 클래스를 개발했습니다.

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

android.view.WindowManager $ BadTokenException : 창을 추가 할 수 없습니다-토큰 null이 유효하지 않습니다. 활동이 진행 중입니까?
Ahamadullah Saikat

13

이 작업을 위해 도우미 클래스를 코딩했습니다. 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);

Thx와 Nice 그러나 어떻게 스레드 onDestroy를 막을 수 있습니까? 나는 그것을 시도했지만 확실하지 않았다 : public static void cancel (Toast mytoast) {if (null! = t) t.stop (); mytoast.cancel (); }
hornetbzz

10

나는 조금 늦었다는 것을 알고 있지만 Regis_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);

이것은 실제로 작동합니다! 그러나 어떻게 사용자 정의하고 만질 수 있습니까?
안드로이드 개발자

이 초보자 질문에 대해 죄송하지만 위의 Toaster 클래스를 만들면 'App'기호를 해결할 수 없다고 말합니다. 최종 토스트 t = Toast.makeText (App.context (), text, Toast.LENGTH_SHORT); 감사합니다. 사과드립니다.
Brian Fleming

아 죄송합니다! App.context ()는 기본적으로 ApplicationContext에 전달하지 않고 어디에서나 편리하게 액세스하기 위해 작성한 사용자 정의 코드입니다. 많은 용도로 사용할 패턴은 아니지만 ApplicationContext에 적합하다는 것을 알았습니다. 이 스 니펫을 편집하여 ApplicationContext를 메소드에 인수로 전달할 수 있습니다.
Chris Aitchison

9

나는 대답이 꽤 늦다는 것을 알고있다. 나는 매우 똑같은 문제가 있었고 토스트에 대한 안드로이드의 소스 코드를 조사한 후에 나 자신의 베어 본 Toast 버전을 구현하기로 결정했다.

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

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

레이아웃을 초기화 한 후 고유 한 hide 및 show 메소드를 사용할 수 있습니다.

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

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

이제 필요한 것은 handleShow () 및 Handler에 게시 할 수있는 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);

}

이것은 빠르고 더러운 구현이었습니다. 성능을 고려하지 않았습니다.


1
"show ()"호출을 포함하여 실행하려고했지만 아무것도 표시되지 않습니다 (Android 7.1에서 테스트). 당신이 뭔가를 그리워 생각합니다. 또한 짧은 시간 후에 토스트가 사라지면서 뷰가 제거되는 것을 방지하는 부분은 어디입니까?
안드로이드 개발자

8

3.5 초 동안 LONG_DELAY 토스트 표시 및 2 초 동안 SHORT_DELAY 토스트 표시 .

Toast는 내부적으로 INotificationManager를 사용하고 Toast.show ()가 호출 될 때마다 enqueueToast 메서드를 호출합니다.

SHORT_DELAY와 함께 show ()를 두 번 호출하면 동일한 토스트가 다시 대기열에 추가됩니다. 그것을위한 표시 를 4 초 (2 초 + 2 초).

마찬가지로, LONG_DELAY와 함께 show ()를 두 번 호출하면 동일한 토스트가 다시 대기열에 추가됩니다. 그것을위한 표시 7 초 (3.5 초 3.5 초 +)


6

위 코드를 사용하여 만든 커스텀 토스트 클래스는 다음과 같습니다.

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

5

긴 토스트가 필요한 경우 실용적인 대안이 있지만 사용자가 확인 버튼을 클릭하여 사라지게해야합니다. 다음과 같이 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();

메시지가 길면 사용자가 메시지를 읽는 데 걸리는 시간을 모르기 때문에 계속하려면 사용자가 확인 버튼을 클릭하도록하는 것이 좋습니다. 제 경우에는 사용자가 도움말 아이콘을 클릭 할 때이 기술을 사용합니다.


1
이것은 똑똑하지만 ServiceUI가 없는와 같은 방식으로는 구현할 수 없습니다 .
mike47

@mikejeep 실제로, 나는 최근에 활동이없는 대화 상자를 보여주는 Google의 예제를 보았습니다 : developer.android.com/samples/AppShortcuts/index.html
android developer

5

다른 사람들이 언급했듯이 Android 토스트는 LENGTH_LONG 또는 LENGTH_SHORT가 될 수 있습니다. 이 문제를 해결할 방법이 없으며 게시 된 '해킹'을 따라야합니다.

토스트의 목적은 "필수적이지 않은"정보를 표시하는 것이며 느린 효과로 인해 메시지의 지속 시간이 특정 임계 값을 초과하는 경우 컨텍스트에서 멀리 떨어질 수 있습니다. 주식 토스트가 LENGTH_LONG보다 오래 표시 될 수 있도록 수정 된 경우 토스트보기가 앱의 ViewGroup이 아닌 WindowManager에 추가 될 때 응용 프로그램 프로세스가 종료 될 때까지 메시지가 화면에 남아 있습니다. 이것이 이것이 하드 코딩 된 이유라고 생각합니다.

3 초 반보다 긴 토스트 스타일 메시지를 표시해야하는 경우 활동의 컨텐츠에 첨부 된보기를 작성하는 것이 좋습니다. 이렇게하면 사용자가 애플리케이션을 종료 할 때 사라집니다. My SuperToasts 라이브러리는이 문제와 다른 많은 문제를 다루 므로 자유롭게 사용하십시오! SuperActivityToasts 사용에 관심이있을 것입니다


4

간단하게 사용 SuperToast을 어떤 상황에 우아한 토스트를 만들기 위해. 토스트를 화려하게 만드십시오 . 글꼴 색크기를 편집하십시오 . 그것이 당신을 위해 하나가 될 수 있기를 바랍니다.



3

나를 위해 일한 매우 간단한 방법은 다음과 같습니다.

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

LENGTH_SHORT의 지속 시간은 2 초이고 LENGTH_LONG은 3.5 초입니다. 여기서 토스트 메시지는 for 루프로 묶여 있기 때문에 6 초 동안 표시됩니다 . 그러나이 방법의 단점은 2 초마다 작은 페이딩 효과가 발생할 수 있다는 것입니다. 그러나 눈에 띄지 않습니다. 도움이 되길 바랍니다.


2

사용자는 토스트 기간을 사용자 정의 할 수 없습니다. NotificationManagerService의 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);
    }

2

Crouton을 사용하면 매우 유연한 Toast 라이브러리입니다.

크루통

토스트처럼 사용할 수 있습니다.

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

토스트를 위해 팽창 될 Custome Layout.

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

2

토스트 지속 시간은 토스트를 독점적으로 실행하는 스레드를 사용하여 해킹 할 수 있습니다. 이것은 작동합니다 (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();

1

맞춤형 배경과 전망의 토스트가 나를 위해 속였습니다. 나는 그것을 nexus 7 태블릿에서 테스트했으며 루핑하는 동안 fadein fadeout 애니메이션이 없음을 알았습니다. 구현은 다음과 같습니다.

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는 kitkat 버전에서와 같이 토스트의 모서리가 둥글게 만듭니다. 파일에 다른보기도 추가 할 수 있습니다. 라이브 앱에서이를 구현할 계획이므로 개선 및 의견에 대한 모든 수정이 권장됩니다.


1

진행되는 간격에 대한 정기적 인 알림과 함께 향후 시간까지 카운트 다운을 예약하십시오. 텍스트 필드에 30 초 카운트 다운을 표시하는 예 :

     새로운 CountDownTimer (30000, 1000) {

     공개 무효 onTick (long millisUntilFinished) {
         mTextField.setText ( "초 남음 :"+ millisUntilFinished / 1000);
     }

     공공 무효 onFinish () {
         mTextField.setText ( "완료!");
     }
  }.스타트();



1

이 텍스트는 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();

나는이 텍스트는 3.5 초 후에 사라집니다 생각
이타 스펙터

@ItaiSpector : 새 코드를 확인하십시오.
Alireza Noorali

1

아니요, 여기에 나열된 대부분의 모든 해킹은 더 이상 Android 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();

이것이 Hussein이 찾고있는 대답은 아니지만 모든 '핵'보다 더 나은 옵션입니다!
대니 EK 반 데르 콜크

0

약간 더 긴 메시지를 작성하는 매우 간단한 방법은 다음과 같습니다.

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 옵션을 제거합니다.

Toast 클래스의 의도 된 목적이 아니기 때문에 일반적으로 Toast 메시지를 사용하여 매우 긴 간격으로 메시지를 표시하지 않을 것입니다. 그러나 표시해야하는 텍스트 양이 사용자에게 읽는 데 3.5 초 이상 걸릴 수있는 경우가 있으며,이 경우 약간의 시간 연장 (예 : 위의 그림과 같이 6.5 초)으로 IMO가 유용 할 수 있습니다. 의도 된 사용법과 일치합니다.


0

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

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

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

0

사용 가능한 모든 솔루션으로 실패한 후 마침내 재귀를 사용하는 해결 방법이있었습니다.

암호:

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

2
토스트를 표시하기 위해 "show"를 반복적으로 호출하는 것과 관련된이 질문에 대한 대부분의 솔루션은 동일한 토스트 인스턴스로 수행하는 반면, 실제로는 매초마다 새 토스트 인스턴스를 생성하고 각 인스턴스가 LONG에 대해 표시되도록 지정합니다 지속 시간 (일반적으로 3.5 초). 추가 객체 인스턴스를 계속 생성하기 때문에 비효율적 일뿐만 아니라, Android는 지정된 지속 시간 동안 차례대로 표시되도록 토스트 메시지를 대기열에 넣습니다. 따라서 5의 지속 시간으로 이것을 호출하면 메시지는 실제로 17.5 초 동안 표시됩니다.
Niall

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

질문에 대한 매우 간단한 해결책. 두 배 또는 세 배로 토스트가 더 오래 지속됩니다. 유일한 방법입니다.


해킹처럼 들리지만 생각에 감사드립니다!
Sony Kadavan

@Arturo가 언급 한 유사한 솔루션을 downvoted 한 이유는 for 루프와 동일한 트릭을 사용합니다.
shabby

이 접근법은 나를 위해 일했습니다. 왜 그렇게 투표했는지 아래로 투표 한 사람들의 의견을 듣는 것이 좋을 것입니다.
Christopher Mills

-8

다음 Toast.makeText();과 같은 방법으로 원하는 시간을 밀리 초 단위로 설정할 수 있습니다 .

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

1
대답은 정확합니다! LENGTH_LONG 또는 LENGTH_SHORT 이외의 값을 사용할 수 있도록 API가 특정 시점에 확장되었습니다. I
rts

나는 그렇게 생각하지 않습니다. android.googlesource.com/platform/frameworks/base/+/…를
AntiCZ
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.