LogUtil.java

package com.aotom.dvr.utils;

import android.text.TextUtils;
import android.util.Log;

/**
 *
 * @author ckb58
 */
@SuppressWarnings({"DefaultFileTemplate", "JavaDoc", "unused"})
public class LogUtil {
    /**
     * 用来记录 VERBOSE 类型的日志
     */
    private static final int     VERBOSE         = 1;
    /**
     * 用来记录 DEBUG 类型的日志
     */
    private static final int     DEBUG           = 2;
    /**
     * 用来记录 INFO 类型的日志
     */
    private static final int     INFO            = 3;
    /**
     * 用来记录 WARN 类型的日志
     */
    private static final int     WARN            = 4;
    /**
     * 用来记录 ERROR 类型的日志
     */
    private static final int     ERROR           = 5;
    /**
     * 用来记录 ASSERT 类型的日志
     */
    private static final int     ASSERT          = 6;
    /**
     * 是否打印日志
     */
    public static        boolean isPrint         = true;
    /**
     * 自定义 TAG 的前缀
     */
    public static        String  customTagPrefix = "";

    private LogUtil() {
        //不能实例化的的异常
        throw new UnsupportedOperationException("cannot be instantiated");
    }

    /**
     * VERBOSE 类型的日志
     *
     * @param msg 内容
     */
    public static void v(String msg) {
        print(VERBOSE, msg, null);
    }

    /**
     * VERBOSE 类型的日志
     *
     * @param msg 内容
     * @param tr  异常
     */
    public static void v(String msg, Throwable tr) {
        print(VERBOSE, msg, tr);
    }

    /**
     * DEBUG 类型的日志
     *
     * @param msg 内容
     */
    public static void d(String msg) {
        print(DEBUG, msg, null);
    }

    /**
     * DEBUG 类型的日志
     *
     * @param msg 内容
     * @param tr  异常
     */
    public static void d(String msg, Throwable tr) {
        print(DEBUG, msg, tr);
    }

    /**
     * INFO 类型的日志
     *
     * @param msg 内容
     */
    public static void i(String msg) {
        print(INFO, msg, null);
    }

    /**
     * INFO 类型的日志
     *
     * @param msg 内容
     * @param tr  异常
     */
    public static void i(String msg, Throwable tr) {
        print(INFO, msg, tr);
    }

    /**
     * WARN 类型的日志
     *
     * @param msg 内容
     */
    public static void w(String msg) {
        print(WARN, msg, null);
    }

    /**
     * WARN 类型的日志
     *
     * @param tr 异常
     */
    public static void w(Throwable tr) {
        print(WARN, null, tr);
    }

    /**
     * WARN 类型的日志
     *
     * @param msg 内容
     * @param tr  异常
     */
    public static void w(String msg, Throwable tr) {
        print(WARN, msg, tr);
    }

    /**
     * ERROR 类型的日志
     *
     * @param msg 内容
     */
    public static void e(String msg) {
        print(ERROR, msg, null);
    }

    /**
     * ERROR 类型的日志
     *
     * @param msg 内容
     * @param tr  异常
     */
    public static void e(String msg, Throwable tr) {
        print(ERROR, msg, tr);
    }

    /**
     * ASSERT 类型的日志
     *
     * @param msg 内容
     */
    public static void wtf(String msg) {
        print(ASSERT, msg, null);
    }

    /**
     * ASSERT 类型的日志
     *
     * @param tr 异常
     */
    public static void wtf(Throwable tr) {
        print(ASSERT, null, tr);
    }

    /**
     * ASSERT 类型的日志
     *
     * @param msg 内容
     * @param tr  异常
     */
    public static void wtf(String msg, Throwable tr) {
        print(ASSERT, msg, tr);
    }

    /**
     * 获取 StackTraceElement
     *
     * @return
     */
    private static StackTraceElement getStackTraceElement() {
        boolean isStackTraceElement = false;
        StackTraceElement stackTraceElement = null;
        StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();
        for (StackTraceElement ste : stackTraceElements) {
            boolean isClassName = ste.getClassName().equals(LogUtil.class.getName());
            if (isStackTraceElement && !isClassName) {
                stackTraceElement = ste;
                break;
            }
            isStackTraceElement = isClassName;
        }
        return stackTraceElement;
    }

    /**
     * 根据 StackTraceElement 获取相关的包名、类名，并设置 TAG
     *
     * @param stackTraceElement StackTraceElement
     * @return
     */
    private static String generateTag(StackTraceElement stackTraceElement) {
        //获取包名和类名
        String className = stackTraceElement.getClassName();
        //截取类名
        className = className.substring(className.lastIndexOf(".") + 1);
        //自定义 TAG 的前缀拼接类名
        String customTagPrefixClassName = customTagPrefix + "[" + className + "]";
        return TextUtils.isEmpty(customTagPrefix) ? className : customTagPrefixClassName;
    }

    /**
     * 根据 StackTraceElement 获取相关的文件名、包名、类名、方法名、行号，并设置 msg
     *
     * @param stackTraceElement StackTraceElement
     * @return
     */
    private static String generateMsg(StackTraceElement stackTraceElement) {
        //获取文件名
        String fileName = stackTraceElement.getFileName();
        //获取包名和类名
        String className = stackTraceElement.getClassName();
        //获取方法名
        String methodName = stackTraceElement.getMethodName();
        //获取行号
        int lineNumber = stackTraceElement.getLineNumber();
        //可点击跳转的标准 msg 拼接格式
        String msg = "at " + className + "." + methodName + "(" + fileName + ":" + lineNumber + ")";
        //拼接线程名和 msg 为新的 msg(追加4个空格保持对齐)
        msg = msg + "\r\n" + "ThreadName:" + Thread.currentThread().getName() + "\r\n";
        return msg;
    }

    /**
     * 打印 Log
     *
     * @param level   Log 的等级
     * @param content Log 的内容
     * @param tr      Log 的异常
     */
    private static void print(int level, String content, Throwable tr) {
        if (isPrint) {
            String tag = generateTag(getStackTraceElement());
            String msg = generateMsg(getStackTraceElement()) + content;
            switch (level) {
                case VERBOSE:
                    if (tr == null) {
                        Log.v(tag, msg);
                    } else {
                        Log.v(tag, msg, tr);
                    }
                    break;
                case DEBUG:
                    if (tr == null) {
                        Log.d(tag, msg);
                    } else {
                        Log.d(tag, msg, tr);
                    }
                    break;
                case INFO:
                    if (tr == null) {
                        Log.i(tag, msg);
                    } else {
                        Log.i(tag, msg, tr);
                    }
                    break;
                case WARN:
                    if (tr == null) {
                        Log.w(tag, msg);
                    } else if (content == null) {
                        Log.w(tag, tr);
                    } else {
                        Log.w(tag, msg, tr);
                    }
                    break;
                case ERROR:
                    if (tr == null) {
                        Log.e(tag, msg);
                    } else {
                        Log.e(tag, msg, tr);
                    }
                    break;
                case ASSERT:
                    if (tr == null) {
                        Log.wtf(tag, msg);
                    } else if (content == null) {
                        Log.wtf(tag, tr);
                    } else {
                        Log.wtf(tag, msg, tr);
                    }
                    break;
                default:
                    break;
            }
        }
    }
}