AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Toast自定义显示时长的解决方案

2016-09-02 7789
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：

版权声明：本文为博主原创文章，未经博主允许不得转载。
关于Toast，大家可能熟的不能再熟了，但是都知道它有一个缺点，就是没有办法控制显示时长，默认有俩种状态，
Toast.LENGTH_LONG 默认显示3.5秒
Toast.LENGTH_SHORT 默认显示2秒。

源码就不说了，直接说解决方式：


（1）、通过源码发现只要避免了让他加入系统维修的Toast队列中，那么就可以让我们来操作

他的显示还有隐藏，那么就只能通过反射来实现了：

代码：

[java] view plain copy print?在CODE上查看代码片派生到我的代码片
package com.duoku.platform.single.view;

import android.content.Context;
import android.graphics.Color;
import android.os.Build;
import android.os.Handler;
import android.os.Message;
import android.view.Gravity;
import android.view.LayoutInflater;
import android.view.View;
import android.widget.TextView;
import android.widget.Toast;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**

  • Created by chenpengfei_d on 2016/9/1.
    */

public class DkToast {

private static Toast mToast;  
private static Context mContext;  
private static TextView mTextView;  
private static long duration;  
private static DkToast mDkToast;  
private static final int SHOW = 1;  
private static final int HIDE = 0;  
private static Object mTN;  
private static Method mShow;  
private static Method mHide;  
private static Field mViewFeild;  
private static Handler handler  = new Handler(){  
    @Override  
    public void handleMessage(Message msg) {  
        super.handleMessage(msg);  
        switch (msg.what){  

            case SHOW:  
                handler.sendEmptyMessageDelayed(HIDE,duration);  
                break;  

            case HIDE:  
                hide();  
                break;  
        }  
    }  
};  
public static DkToast makeDkToast(Context context,String msg,long dur) {  

    mDkToast = new DkToast();  
    mContext = context;  
    duration = dur;  
    mToast = new Toast(mContext);  
    mTextView = new TextView(mContext);  
    mTextView.setText(msg);  
    mTextView.setTextSize(18);  
    mTextView.setTextColor(Color.RED);  
    mToast.setView(mTextView);  
    mToast.setGravity(Gravity.CENTER,0,0);  
    reflectToast();  
    return mDkToast;  
}  

public static void reflectToast(){  
    Field field = null;  
    try {  
        field = mToast.getClass().getDeclaredField("mTN");  
        field.setAccessible(true);  
        mTN = field.get(mToast);  
        mShow = mTN.getClass().getDeclaredMethod("show");  
        mHide = mTN.getClass().getDeclaredMethod("hide");  
        mViewFeild = mTN.getClass().getDeclaredField("mNextView");  
        mViewFeild.setAccessible(true);  

    } catch (NoSuchFieldException e) {  
        e.printStackTrace();  
    } catch (IllegalAccessException e) {  
        e.printStackTrace();  
    } catch (IllegalArgumentException e) {  
        e.printStackTrace();  
    } catch (NoSuchMethodException e1) {  
        e1.printStackTrace();  
    }  

}  
public static void show(){  

    try {  
        //android4.0以上就要以下处理  
        if(Build.VERSION.SDK_INT >14) {  
            Field mNextViewField = mTN.getClass().getDeclaredField("mNextView");  
            mNextViewField.setAccessible(true);  
            LayoutInflater inflate = (LayoutInflater) mContext.getSystemService(Context.LAYOUT_INFLATER_SERVICE);  
            View v = mToast.getView();  
            mNextViewField.set(mTN, v);  
            Method method = mTN.getClass().getDeclaredMethod("show", null);  
            method.invoke(mTN, null);  
        }  
        mShow.invoke(mTN, null);  
    }catch (Exception e){  
        e.printStackTrace();  
    }  

    handler.sendEmptyMessage(SHOW);  
}  

private static void hide(){  
    try {  
        mHide.invoke(mTN, null);  
    } catch (IllegalAccessException e) {  
        e.printStackTrace();  
    } catch (IllegalArgumentException e) {  
        e.printStackTrace();  
    } catch (InvocationTargetException e) {  
        e.printStackTrace();  
    }  
}

}
上边是一个完整的Toast，直接就能使用，调用简单：

实例：
DkToast.makeDkToast(this,"显示效果",100000).show();
位置调整，已经自定义View须要自己加了
（2）第二种方式，使用过桌面悬浮窗的都应该知道，通过WindowManager可以实现类似360小火箭的悬浮效果
，那么我们也可以使用这个来进行Toast的显示：
不了解WindowManager实现悬浮窗的可以看下边资料：
http://blog.csdn.net/u012808234/article/details/52209713

Toast实现的代码：

[java] view plain copy print?在CODE上查看代码片派生到我的代码片
package com.duoku.platform.demo.single;

import android.content.Context;
import android.graphics.Color;
import android.graphics.PixelFormat;
import android.os.Handler;
import android.os.Message;
import android.view.Gravity;
import android.view.View;
import android.view.WindowManager;
import android.widget.TextView;

/**

  • Created by chenpengfei_d on 2016/9/2.
    */

public class WindowToast {

private WindowManager mWindowManager;  
private View view;  
WindowManager.LayoutParams params;  
private static final int SHOW = 0;  
private static final int HIDE = 1;  
private int duration ;  
private Handler handler = new Handler(){  
    @Override  
    public void handleMessage(Message msg) {  
        super.handleMessage(msg);  

        switch (msg.what){  
            case SHOW:  
                handler.sendEmptyMessageDelayed(HIDE,duration);  
                break;  
            case HIDE:  
                hide();  

                break;  

        }  
    }  
};  

public  WindowToast makeToast(Context context ,String msg ,int duration){  
    mWindowManager  = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);  
     params = new WindowManager.LayoutParams();  
    params.type = WindowManager.LayoutParams.TYPE_TOAST;  
    params.windowAnimations = android.R.style.Animation_Toast;  
    params.flags = WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE;  
    params.format = PixelFormat.TRANSLUCENT;  
    params.width  = WindowManager.LayoutParams.WRAP_CONTENT;  
    params.height = WindowManager.LayoutParams.WRAP_CONTENT;  
    params.gravity = Gravity.BOTTOM;  
    view = new TextView(context);  
    TextView textView = (TextView) view;  
    textView.setText(msg);  
    textView.setTextColor(Color.BLACK);  
    textView.setTextSize(18);  
    this.duration = duration;  
    return this;  
}  

public WindowToast setGravity(int type){  
    params.gravity = type;  
    return this;  
}  

public WindowToast setView(View view) {  
    this.view = view;  
    return this;  
}  

public void show(){  
    if(view == null){  
        throw  new RuntimeException("setView must have been called");  
    }  
    mWindowManager.addView(view,params);  
    handler.sendEmptyMessage(SHOW);  
}  

public void hide(){  

    mWindowManager.removeView(view);  
}

}


简单的实现了一个Toast的功能，可以自定义显示时长。

关于4.0以上手机反射不起作用，可以使用这个。
（3）第三种，其实跟第二种很类似，只是我们仿照Toast源码来自己构建Toast队列，进行Toast

的整体控制，当然Toast的实现还是WindowManager（代码不难就不自己写了，网上一位大神解决MIUI系统不显示写的）：
（地址：http://caizhitao.com/2016/02/09/android-toast-compat/）
[java] view plain copy print?在CODE上查看代码片派生到我的代码片
package io.github.zhitaocai.toastcompat.toastcompat;

import android.annotation.TargetApi;
import android.content.Context;
import android.content.res.Configuration;
import android.graphics.PixelFormat;
import android.os.Build;
import android.os.Handler;
import android.view.Gravity;
import android.view.View;
import android.view.WindowManager;
import android.widget.TextView;
import android.widget.Toast;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.atomic.AtomicInteger;

import io.github.zhitaocai.toastcompat.util.DisplayUtil;

/**

  • @author zhitao
  • @since 2016-01-21 14:33
    */

public class MIUIToast implements IToast {

private static Handler mHandler = new Handler();  

/** 
 * 维护toast的队列 
 */  
private static BlockingQueue<MIUIToast> mQueue = new LinkedBlockingQueue<MIUIToast>();  

/** 
 * 原子操作：判断当前是否在读取{@linkplain #mQueue 队列}来显示toast 
 */  
protected static AtomicInteger mAtomicInteger = new AtomicInteger(0);  

private WindowManager mWindowManager;  

private long mDurationMillis;  

private View mView;  

private WindowManager.LayoutParams mParams;  

private Context mContext;  

public static IToast makeText(Context context, String text, long duration) {  
    return new MIUIToast(context).setText(text).setDuration(duration)  
            .setGravity(Gravity.BOTTOM, 0, DisplayUtil.dip2px(context, 64));  
}  

public MIUIToast(Context context) {  

    mContext = context;  
    mWindowManager = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE);  
    mParams = new WindowManager.LayoutParams();  
    mParams.height = WindowManager.LayoutParams.WRAP_CONTENT;  
    mParams.width = WindowManager.LayoutParams.WRAP_CONTENT;  
    mParams.format = PixelFormat.TRANSLUCENT;  
    mParams.windowAnimations = android.R.style.Animation_Toast;  
    mParams.type = WindowManager.LayoutParams.TYPE_TOAST;  
    mParams.setTitle("Toast");  
    mParams.flags = WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON | WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE |  
                    WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE;  
    // 默认小米Toast在下方居中  
    mParams.gravity = Gravity.BOTTOM | Gravity.CENTER_HORIZONTAL;  
}  

/** 
 * Set the location at which the notification should appear on the screen. 
 * 
 * @param gravity 
 * @param xOffset 
 * @param yOffset 
 */  
@TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR1)  
@Override  
public IToast setGravity(int gravity, int xOffset, int yOffset) {  

    // We can resolve the Gravity here by using the Locale for getting  
    // the layout direction  
    final int finalGravity;  
    if (Build.VERSION.SDK_INT >= 14) {  
        final Configuration config = mView.getContext().getResources().getConfiguration();  
        finalGravity = Gravity.getAbsoluteGravity(gravity, config.getLayoutDirection());  
    } else {  
        finalGravity = gravity;  
    }  
    mParams.gravity = finalGravity;  
    if ((finalGravity & Gravity.HORIZONTAL_GRAVITY_MASK) == Gravity.FILL_HORIZONTAL) {  
        mParams.horizontalWeight = 1.0f;  
    }  
    if ((finalGravity & Gravity.VERTICAL_GRAVITY_MASK) == Gravity.FILL_VERTICAL) {  
        mParams.verticalWeight = 1.0f;  
    }  
    mParams.y = yOffset;  
    mParams.x = xOffset;  
    return this;  
}  

@Override  
public IToast setDuration(long durationMillis) {  
    if (durationMillis < 0) {  
        mDurationMillis = 0;  
    }  
    if (durationMillis == Toast.LENGTH_SHORT) {  
        mDurationMillis = 2000;  
    } else if (durationMillis == Toast.LENGTH_LONG) {  
        mDurationMillis = 3500;  
    } else {  
        mDurationMillis = durationMillis;  
    }  
    return this;  
}  

/** 
 * 不能和{@link #setText(String)}一起使用，要么{@link #setView(View)} 要么{@link #setView(View)} 
 * 
 * @param view 
 * 
 * @return 
 */  
@Override  
public IToast setView(View view) {  
    mView = view;  
    return this;  
}  

@Override  
public IToast setMargin(float horizontalMargin, float verticalMargin) {  
    mParams.horizontalMargin = horizontalMargin;  
    mParams.verticalMargin = verticalMargin;  
    return this;  
}  

/** 
 * 不能和{@link #setView(View)}一起使用，要么{@link #setView(View)} 要么{@link #setView(View)} 
 * 
 * @return 
 */  
@Override  
public IToast setText(String text) {  

    // 模拟Toast的布局文件 com.android.internal.R.layout.transient_notification  
    // 虽然可以手动用java写，但是不同厂商系统，这个布局的设置好像是不同的，因此我们自己获取原生Toast的view进行配置  

    View view = Toast.makeText(mContext, text, Toast.LENGTH_SHORT).getView();  
    if (view != null) {  
        TextView tv = (TextView) view.findViewById(android.R.id.message);  
        tv.setText(text);  
        setView(view);  
    }  

    return this;  
}  

@Override  
public void show() {  
    // 1. 将本次需要显示的toast加入到队列中  
    mQueue.offer(this);  

    // 2. 如果队列还没有激活，就激活队列，依次展示队列中的toast  
    if (0 == mAtomicInteger.get()) {  
        mAtomicInteger.incrementAndGet();  
        mHandler.post(mActivite);  
    }  
}  

@Override  
public void cancel() {  
    // 1. 如果队列已经处于非激活状态或者队列没有toast了，就表示队列没有toast正在展示了，直接return  
    if (0 == mAtomicInteger.get() && mQueue.isEmpty()) {  
        return;  
    }  

    // 2. 当前显示的toast是否为本次要取消的toast，如果是的话  
    // 2.1 先移除之前的队列逻辑  
    // 2.2 立即暂停当前显示的toast  
    // 2.3 重新激活队列  
    if (this.equals(mQueue.peek())) {  
        mHandler.removeCallbacks(mActivite);  
        mHandler.post(mHide);  
        mHandler.post(mActivite);  
    }  

    //TODO 如果一个Toast在队列中的等候展示，当调用了这个toast的取消时，考虑是否应该从对队列中移除，看产品需求吧  
}  

private void handleShow() {  
    if (mView != null) {  
        if (mView.getParent() != null) {  
            mWindowManager.removeView(mView);  
        }  
        mWindowManager.addView(mView, mParams);  
    }  
}  

private void handleHide() {  
    if (mView != null) {  
        // note: checking parent() just to make sure the view has  
        // been added...  i have seen cases where we get here when  
        // the view isn't yet added, so let's try not to crash.  
        if (mView.getParent() != null) {  
            mWindowManager.removeView(mView);  
            // 同时从队列中移除这个toast  
            mQueue.poll();  
        }  
        mView = null;  
    }  
}  

private static void activeQueue() {  
    MIUIToast miuiToast = mQueue.peek();  
    if (miuiToast == null) {  
        // 如果不能从队列中获取到toast的话，那么就表示已经暂时完所有的toast了  
        // 这个时候需要标记队列状态为：非激活读取中  
        mAtomicInteger.decrementAndGet();  
    } else {  

        // 如果还能从队列中获取到toast的话，那么就表示还有toast没有展示  
        // 1. 展示队首的toast  
        // 2. 设置一定时间后主动采取toast消失措施  
        // 3. 设置展示完毕之后再次执行本逻辑，以展示下一个toast  
        mHandler.post(miuiToast.mShow);  
        mHandler.postDelayed(miuiToast.mHide, miuiToast.mDurationMillis);  
        mHandler.postDelayed(mActivite, miuiToast.mDurationMillis);  
    }  
}  

private final Runnable mShow = new Runnable() {  
    @Override  
    public void run() {  
        handleShow();  
    }  
};  

private final Runnable mHide = new Runnable() {  
    @Override  
    public void run() {  
        handleHide();  
    }  
};  

private final static Runnable mActivite = new Runnable() {  
    @Override  
    public void run() {  
        activeQueue();  
    }  
};

}

总结： （1）解决了Toast 无法自定义时长的问题

   （2）解决了4.0以上手机使用反射自定义时长不生效的问题
   （3）解决了Toast显示不灵活的问题
文章标签：
Java
非花非雾
目录
相关文章
码上来科技
|
前端开发 JavaScript Java
【实训项目】易行APP设计（c2c二手交易平台）
【实训项目】易行APP设计（c2c二手交易平台）
码上来科技
410 0
青云@yd
|
3月前
|
NoSQL 安全 Redis
Docker Compose ：从入门到企业级部署
Docker Compose 是用于定义和运行多容器应用的工具，支持服务、网络和卷三大核心要素。通过简洁的 YAML 文件，可实现应用的快速部署与管理，适用于开发、测试及生产环境。
青云@yd
264 0
Ant.Dream
|
算法 安全 数据安全/隐私保护
Android经典实战之常见的移动端加密算法和用kotlin进行AES-256加密和解密
本文介绍了移动端开发中常用的数据加密算法，包括对称加密（如 AES 和 DES）、非对称加密（如 RSA）、散列算法（如 SHA-256 和 MD5）及消息认证码（如 HMAC）。重点展示了如何使用 Kotlin 实现 AES-256 的加密和解密，提供了详细的代码示例。
Ant.Dream
328 2
编程千纸鹤
|
数据处理
基于51单片机的无线充电器设计与实现
无线电能传输技术是一种新的能量传输技术，其主要功能是共振耦合的无线电能传输，其传输效率高，适合中等传输距离，基于磁场与共振耦合原理，可有效地将电能传输至负荷，从而解决了传统电力传输模式存在的诸多弊端。本论文以单片机为核心，利用无线充电线圈的电磁感应原理，对移动电话进行充电。首先，在参考国内外有关资料的基础上，对整个无线充电设备的总体设计进行了研究，确定了各模块的功能，并对其进行了硬件电路的设计和构建。在此基础上，编写了单片机的控制软件，完成了各部分的控制，并完成了实际的焊接和试验，并完成了以单片机为核心的无线充电设备的系统设计。
编程千纸鹤
546 0
wljslmz
|
11月前
|
存储 安全 网络安全
光猫的两种工作模式：路由模式和桥接模式
【10月更文挑战第24天】
wljslmz
3188 2
光猫的两种工作模式：路由模式和桥接模式
Ant.Dream
|
12月前
|
缓存 前端开发 Android开发
Android实战之如何截取Activity或者Fragment的内容？
本文首发于公众号“AntDream”，介绍了如何在Android中截取Activity或Fragment的屏幕内容并保存为图片。包括截取整个Activity、特定控件或区域的方法，以及处理包含RecyclerView的复杂情况。
Ant.Dream
180 3
弹性计算小冉
|
存储 弹性计算 安全
阿里云服务器怎么样？云服务器ECS产品优势、应用场景、价格解析及常见问题参考
阿里云服务器ECS（Elastic Compute Service）是阿里云提供的性能卓越、稳定可靠、弹性扩展的IaaS（Infrastructure as a Service）级别云计算服务。把物理服务器比作买的房子，云服务器ECS，就是租赁的房子，阿里云云服务商就是管家。云服务商负责搭建机房、提供配套服务和维护，用户只需要付租金，即可“拎包入住”，无需自建机房、采购和配置硬件设施。如果不再需要云服务器，可随时“退租”(释放资源)，节省成本。本文为大家解析云服务器ECS产品优势、应用场景和最新价格及常见问题。
弹性计算小冉
714 2
阿里云服务器怎么样？云服务器ECS产品优势、应用场景、价格解析及常见问题参考
jcLee95
|
存储 Dart 编译器
Dart笔记：Dart语言中的注解（元数据）
Dart笔记：Dart语言中的注解（元数据）
jcLee95
704 0
一个车迷
|
缓存 JavaScript 前端开发
为什么for循环比forEach性能高？
在 JavaScript 中，常用的循环有 for 循环和 forEach 循环。虽然两者都可以遍历数组，但它们的实现方式不同，因此性能也有所不同。
一个车迷
263 0
咖啡兔子
|
程序员 开发工具 git
Git Submodule使用完整教程
咖啡兔子
15767 0