Android Toast가 Toast.LENGTH_LONG보다 길 수 있습니까?
토스트에 setDuration ()을 사용할 때 사용자 정의 길이 또는 적어도 무엇보다 긴 길이를 설정할 수 Toast.LENGTH_LONG있습니까?
의 값 LENGTH_SHORT과는 LENGTH_LONG내가이 값 이외의 기간을 설정할 수있을 것입니다 생각하지 않도록 그들이 아니라 실제 기간보다 더 플래그로 취급되는 0과 1이 수단입니다.
더 오랫동안 사용자에게 메시지를 표시하려면 상태 표시 줄 알림을 고려하십시오 . 상태 표시 줄 알림은 더 이상 관련이 없을 때 프로그래밍 방식으로 취소 할 수 있습니다.
안드로이드 코드를 더 깊이 파고 들었다면 토스트 메시지의 지속 시간을 변경할 수 없다는 것을 분명히 나타내는 줄을 찾을 수 있습니다.
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
시도해 볼 수 있습니다.
for (int i=0; i < 2; i++)
{
Toast.makeText(this, "blah", Toast.LENGTH_LONG).show();
}
시간을 두 배로 늘릴 수 있습니다. 2 대신 3을 지정하면 시간이 3 배가됩니다.
순서대로 시작되는 토스트 사이의 페이딩 효과를 피하는 가장 좋은 솔루션 :
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지속하기 를 원한다면, 당신은 반복적 으로 Timer전화를 걸어 toast.show()(해당 2 초 정도) 해킹 할 수 있다는 것을 알았습니다 . 이 이미 표시되어 show()있으면 전화를 해도 아무런 문제 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);
}
}
}
이 작업을 위해 도우미 클래스를 코딩했습니다. 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);
나는 조금 늦었다는 것을 알고 있지만 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);
나는 대답이 꽤 늦다는 것을 알고있다. 나는 매우 똑같은 문제를 가지고 있었고 토스트에 대한 안드로이드 소스 코드를 조사한 후에 나 자신의 베어 본 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);
}
이것은 빠르고 더러운 구현이었습니다. 성능을 고려하지 않았습니다.
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 초 +)
위 코드를 사용하여 만든 커스텀 토스트 클래스는 다음과 같습니다.
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();
메시지가 길면 사용자가 메시지를 읽는 데 걸리는 시간을 모르기 때문에 계속하려면 사용자가 확인 버튼을 클릭하도록하는 것이 좋습니다. 제 경우에는 사용자가 도움말 아이콘을 클릭 할 때이 기술을 사용합니다.
다른 사람들이 언급했듯이 Android 토스트는 LENGTH_LONG 또는 LENGTH_SHORT가 될 수 있습니다. 이 문제를 해결할 방법이 없으며 게시 된 '해킹'을 따르지 않아야합니다.
토스트의 목적은 "필수적이지 않은"정보를 표시하는 것이며 느린 효과로 인해 메시지의 지속 시간이 특정 임계 값을 초과하는 경우 컨텍스트에서 멀리 떨어져있을 수 있습니다. 주식 토스트가 LENGTH_LONG보다 오래 표시 될 수 있도록 수정 된 경우 토스트보기가 앱의 ViewGroup이 아닌 WindowManager에 추가 될 때 응용 프로그램 프로세스가 종료 될 때까지 메시지가 화면에 남아 있습니다. 이것이 이것이 하드 코딩 된 이유라고 가정합니다.
3 초 반보다 긴 토스트 스타일 메시지를 표시해야하는 경우 활동의 컨텐츠에 첨부 된보기를 작성하는 것이 좋습니다. 이렇게하면 사용자가 애플리케이션을 종료 할 때 사라집니다. My SuperToasts 라이브러리는이 문제와 다른 많은 문제를 다루며 자유롭게 사용하십시오! SuperActivityToasts 사용에 관심이있을 것입니다
간단하게 사용 SuperToast을 어떤 상황에 우아한 토스트를 만들기 위해. 토스트를 화려하게 만드십시오 . 글꼴 색 과 크기를 편집하십시오 . 그것이 당신을 위해 하나가 될 수 있기를 바랍니다.
전체 스낵 바를 가질 수있을 때 토스트를 먹는 이유 : https://developer.android.com/reference/android/support/design/widget/Snackbar.html
스낵바> 토스트, 커스텀 토스트, 크루통
나를 위해 일한 매우 간단한 방법은 다음과 같습니다.
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 초마다 작은 페이딩 효과가 발생할 수 있다는 것입니다. 그러나 눈에 띄지 않습니다. 도움이 되길 바랍니다.
사용자는 토스트 기간을 사용자 정의 할 수 없습니다. 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);
}
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>
맞춤형 배경과 전망의 토스트가 나를 위해 속였습니다. 나는 그것을 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 버전에서와 같이 토스트의 모서리가 둥글게 만듭니다. 파일에 다른보기도 추가 할 수 있습니다. 라이브 앱에서 구현할 계획이므로 개선 및 의견에 대한 수정이 권장됩니다.
진행되는 간격에 대한 정기적 인 알림과 함께 향후 시간까지 카운트 다운을 예약하십시오. 텍스트 필드에 30 초 카운트 다운을 표시하는 예 :
새로운 CountDownTimer (30000, 1000) {
공개 무효 onTick (long millisUntilFinished) {
mTextField.setText ( "초 남음 :"+ millisUntilFinished / 1000);
}
공공 무효 onFinish () {
mTextField.setText ( "완료!");
}
}.스타트();
토스트 지속 시간은 토스트를 독점적으로 실행하는 스레드를 사용하여 해킹 할 수 있습니다. 이것은 작동합니다 (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();
이 텍스트는 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();
약간 더 긴 메시지를 작성하는 매우 간단한 방법은 다음과 같습니다.
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가 유용 할 수 있습니다. 의도 된 사용법과 일치합니다.
토스트를 특정 기간 (밀리 초)으로 설정합니다.
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();
}
사용 가능한 모든 솔루션으로 실패한 후 마침내 재귀를 사용하는 해결 방법이있었습니다.
암호:
//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);
}
아니요, 여기에 나열된 대부분의 모든 해킹은 더 이상 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();
Toast.makeText(this, "Text", Toast.LENGTH_LONG).show();
Toast.makeText(this, "Text", Toast.LENGTH_LONG).show();
질문에 대한 매우 간단한 해결책. 두 배 또는 세 배로 토스트가 더 오래 지속됩니다. 그것은 유일한 길입니다.
다음 Toast.makeText();과 같은 방법으로 원하는 시간을 밀리 초 단위로 설정할 수 있습니다 .
//40 seconds
long mToastLength = 40*1000
//this toast will be displayed for 40 seconds.
Toast.makeText(this, "Hello!!!!!", mToastLength).show();
참고 URL : https://stackoverflow.com/questions/2220560/can-an-android-toast-be-longer-than-toast-length-long
'Programing' 카테고리의 다른 글
| NameValuePair를 사용하여 POST를 사용하여 HttpURLConnection에 매개 변수를 추가하는 방법 (0) | 2020.04.05 |
|---|---|
| 숫자가 홀수인지 짝수인지 테스트 (0) | 2020.04.05 |
| 날짜 선택기 : 편집 텍스트를 클릭 할 때 날짜 선택기를 팝업하는 방법 (0) | 2020.04.05 |
| ActionBar 제목에서 사용자 정의 글꼴을 설정하는 방법은 무엇입니까? (0) | 2020.04.05 |
| JavaScript가 멀티 스레딩을 지원하지 않는 이유는 무엇입니까? (0) | 2020.04.05 |