安卓日志 alog 开源

太过爱你忘了你带给我的痛 2023-10-03 18:08 0阅读 0赞

[第三方日志文件ALog使用详解\_xxdw1992的博客-程序员宝宝\_alog - 程序员宝宝][ALog_xxdw1992_-_alog -]

[https://github.com/Blankj/ALog![icon-default.png?t=LBL2][icon-default.png_t_LBL2]https://github.com/Blankj/ALog][https_github.com_Blankj_ALog_icon-default.png_t_LBL2_icon-default.png_t_LBL2_https_github.com_Blankj_ALog]

package com.blankj;
    
    import android.content.ClipData;
    import android.content.ComponentName;
    import android.content.Context;
    import android.content.Intent;
    import android.content.pm.PackageInfo;
    import android.content.pm.PackageManager;
    import android.graphics.Rect;
    import android.net.Uri;
    import android.os.Build;
    import android.os.Bundle;
    import android.os.Environment;
    import android.support.annotation.IntDef;
    import android.support.annotation.IntRange;
    import android.support.annotation.NonNull;
    import android.support.annotation.RequiresApi;
    import android.support.v4.util.SimpleArrayMap;
    import android.util.Log;
    
    import org.json.JSONArray;
    import org.json.JSONException;
    import org.json.JSONObject;
    
    import java.io.BufferedWriter;
    import java.io.File;
    import java.io.FileWriter;
    import java.io.FilenameFilter;
    import java.io.IOException;
    import java.io.PrintWriter;
    import java.io.StringReader;
    import java.io.StringWriter;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.reflect.ParameterizedType;
    import java.lang.reflect.Type;
    import java.net.UnknownHostException;
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.Arrays;
    import java.util.Date;
    import java.util.Formatter;
    import java.util.Iterator;
    import java.util.Locale;
    import java.util.Set;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    import javax.xml.transform.OutputKeys;
    import javax.xml.transform.Source;
    import javax.xml.transform.Transformer;
    import javax.xml.transform.TransformerFactory;
    import javax.xml.transform.stream.StreamResult;
    import javax.xml.transform.stream.StreamSource;
    
    /**
     * <pre>
     *     author: Blankj
     *     blog  : http://blankj.com
     *     time  : 2016/09/21
     *     desc  : utils about log
     * </pre>
     */
    public final class ALog {
    
        public static final int V = Log.VERBOSE;
        public static final int D = Log.DEBUG;
        public static final int I = Log.INFO;
        public static final int W = Log.WARN;
        public static final int E = Log.ERROR;
        public static final int A = Log.ASSERT;
    
        @IntDef({V, D, I, W, E, A})
        @Retention(RetentionPolicy.SOURCE)
        public @interface TYPE {
        }
    
        private static final char[] T = new char[]{'V', 'D', 'I', 'W', 'E', 'A'};
    
        private static final int FILE = 0x10;
        private static final int JSON = 0x20;
        private static final int XML  = 0x30;
    
        private static final String FILE_SEP       = System.getProperty("file.separator");
        private static final String LINE_SEP       = System.getProperty("line.separator");
        private static final String TOP_CORNER     = "┌";
        private static final String MIDDLE_CORNER  = "├";
        private static final String LEFT_BORDER    = "│ ";
        private static final String BOTTOM_CORNER  = "└";
        private static final String SIDE_DIVIDER   =
                "────────────────────────────────────────────────────────";
        private static final String MIDDLE_DIVIDER =
                "┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄";
        private static final String TOP_BORDER     = TOP_CORNER + SIDE_DIVIDER + SIDE_DIVIDER;
        private static final String MIDDLE_BORDER  = MIDDLE_CORNER + MIDDLE_DIVIDER + MIDDLE_DIVIDER;
        private static final String BOTTOM_BORDER  = BOTTOM_CORNER + SIDE_DIVIDER + SIDE_DIVIDER;
        private static final int    MAX_LEN        = 3000;
        private static final String NOTHING        = "log nothing";
        private static final String NULL           = "null";
        private static final String ARGS           = "args";
        private static final String PLACEHOLDER    = " ";
    
        private static final ThreadLocal<SimpleDateFormat> SDF_THREAD_LOCAL = new ThreadLocal<>();
    
        private static final ExecutorService EXECUTOR = Executors.newSingleThreadExecutor();
    
        private static final SimpleArrayMap<Class, IFormatter> I_FORMATTER_MAP = new SimpleArrayMap<>();
    
        private static Context sAppContext;
        private static Config  sConfig;
    
    
        private ALog() {
            throw new UnsupportedOperationException("u can't instantiate me...");
        }
    
        public static Config init(@NonNull final Context context) {
            sAppContext = context;
            if (sConfig == null) {
                sConfig = new Config();
            }
            return sConfig;
        }
    
        public static Config getConfig() {
            if (sConfig == null) throw new NullPointerException("U should init first.");
            return sConfig;
        }
    
        public static void v(final Object... contents) {
            log(V, sConfig.mGlobalTag, contents);
        }
    
        public static void vTag(final String tag, final Object... contents) {
            log(V, tag, contents);
        }
    
        public static void d(final Object... contents) {
            log(D, sConfig.mGlobalTag, contents);
        }
    
        public static void dTag(final String tag, final Object... contents) {
            log(D, tag, contents);
        }
    
        public static void i(final Object... contents) {
            log(I, sConfig.mGlobalTag, contents);
        }
    
        public static void iTag(final String tag, final Object... contents) {
            log(I, tag, contents);
        }
    
        public static void w(final Object... contents) {
            log(W, sConfig.mGlobalTag, contents);
        }
    
        public static void wTag(final String tag, final Object... contents) {
            log(W, tag, contents);
        }
    
        public static void e(final Object... contents) {
            log(E, sConfig.mGlobalTag, contents);
        }
    
        public static void eTag(final String tag, final Object... contents) {
            log(E, tag, contents);
        }
    
        public static void a(final Object... contents) {
            log(A, sConfig.mGlobalTag, contents);
        }
    
        public static void aTag(final String tag, final Object... contents) {
            log(A, tag, contents);
        }
    
        public static void file(final Object content) {
            log(FILE | D, sConfig.mGlobalTag, content);
        }
    
        public static void file(@TYPE final int type, final Object content) {
            log(FILE | type, sConfig.mGlobalTag, content);
        }
    
        public static void file(final String tag, final Object content) {
            log(FILE | D, tag, content);
        }
    
        public static void file(@TYPE final int type, final String tag, final Object content) {
            log(FILE | type, tag, content);
        }
    
        public static void json(final String content) {
            log(JSON | D, sConfig.mGlobalTag, content);
        }
    
        public static void json(@TYPE final int type, final String content) {
            log(JSON | type, sConfig.mGlobalTag, content);
        }
    
        public static void json(final String tag, final String content) {
            log(JSON | D, tag, content);
        }
    
        public static void json(@TYPE final int type, final String tag, final String content) {
            log(JSON | type, tag, content);
        }
    
        public static void xml(final String content) {
            log(XML | D, sConfig.mGlobalTag, content);
        }
    
        public static void xml(@TYPE final int type, final String content) {
            log(XML | type, sConfig.mGlobalTag, content);
        }
    
        public static void xml(final String tag, final String content) {
            log(XML | D, tag, content);
        }
    
        public static void xml(@TYPE final int type, final String tag, final String content) {
            log(XML | type, tag, content);
        }
    
        public static void log(final int type, final String tag, final Object... contents) {
            if (!sConfig.mLogSwitch || (!sConfig.mLog2ConsoleSwitch && !sConfig.mLog2FileSwitch))
                return;
            int type_low = type & 0x0f, type_high = type & 0xf0;
            if (type_low < sConfig.mConsoleFilter && type_low < sConfig.mFileFilter) return;
            final TagHead tagHead = processTagAndHead(tag);
            String body = processBody(type_high, contents);
            if (sConfig.mLog2ConsoleSwitch && type_low >= sConfig.mConsoleFilter && type_high != FILE) {
                print2Console(type_low, tagHead.tag, tagHead.consoleHead, body);
            }
            if ((sConfig.mLog2FileSwitch || type_high == FILE) && type_low >= sConfig.mFileFilter) {
                print2File(type_low, tagHead.tag, tagHead.fileHead + body);
            }
        }
    
        private static TagHead processTagAndHead(String tag) {
            if (!sConfig.mTagIsSpace && !sConfig.mLogHeadSwitch) {
                tag = sConfig.mGlobalTag;
            } else {
                final StackTraceElement[] stackTrace = new Throwable().getStackTrace();
                final int stackIndex = 3 + sConfig.mStackOffset;
                if (stackIndex >= stackTrace.length) {
                    StackTraceElement targetElement = stackTrace[3];
                    final String fileName = getFileName(targetElement);
                    if (sConfig.mTagIsSpace && isSpace(tag)) {
                        int index = fileName.indexOf('.');// Use proguard may not find '.'.
                        tag = index == -1 ? fileName : fileName.substring(0, index);
                    }
                    return new TagHead(tag, null, ": ");
                }
                StackTraceElement targetElement = stackTrace[stackIndex];
                final String fileName = getFileName(targetElement);
                if (sConfig.mTagIsSpace && isSpace(tag)) {
                    int index = fileName.indexOf('.');// Use proguard may not find '.'.
                    tag = index == -1 ? fileName : fileName.substring(0, index);
                }
                if (sConfig.mLogHeadSwitch) {
                    String tName = Thread.currentThread().getName();
                    final String head = new Formatter()
                            .format("%s, %s.%s(%s:%d)",
                                    tName,
                                    targetElement.getClassName(),
                                    targetElement.getMethodName(),
                                    fileName,
                                    targetElement.getLineNumber())
                            .toString();
                    final String fileHead = " [" + head + "]: ";
                    if (sConfig.mStackDeep <= 1) {
                        return new TagHead(tag, new String[]{head}, fileHead);
                    } else {
                        final String[] consoleHead =
                                new String[Math.min(
                                        sConfig.mStackDeep,
                                        stackTrace.length - stackIndex
                                )];
                        consoleHead[0] = head;
                        int spaceLen = tName.length() + 2;
                        String space = new Formatter().format("%" + spaceLen + "s", "").toString();
                        for (int i = 1, len = consoleHead.length; i < len; ++i) {
                            targetElement = stackTrace[i + stackIndex];
                            consoleHead[i] = new Formatter()
                                    .format("%s%s.%s(%s:%d)",
                                            space,
                                            targetElement.getClassName(),
                                            targetElement.getMethodName(),
                                            getFileName(targetElement),
                                            targetElement.getLineNumber())
                                    .toString();
                        }
                        return new TagHead(tag, consoleHead, fileHead);
                    }
                }
            }
            return new TagHead(tag, null, ": ");
        }
    
        private static String getFileName(final StackTraceElement targetElement) {
            String fileName = targetElement.getFileName();
            if (fileName != null) return fileName;
            // If name of file is null, should add
            // "-keepattributes SourceFile,LineNumberTable" in proguard file.
            String className = targetElement.getClassName();
            String[] classNameInfo = className.split("\\.");
            if (classNameInfo.length > 0) {
                className = classNameInfo[classNameInfo.length - 1];
            }
            int index = className.indexOf('$');
            if (index != -1) {
                className = className.substring(0, index);
            }
            return className + ".java";
        }
    
        private static String processBody(final int type, final Object... contents) {
            String body = NULL;
            if (contents != null) {
                if (contents.length == 1) {
                    body = formatObject(type, contents[0]);
                } else {
                    StringBuilder sb = new StringBuilder();
                    for (int i = 0, len = contents.length; i < len; ++i) {
                        Object content = contents[i];
                        sb.append(ARGS)
                                .append("[")
                                .append(i)
                                .append("]")
                                .append(" = ")
                                .append(formatObject(content))
                                .append(LINE_SEP);
                    }
                    body = sb.toString();
                }
            }
            return body.length() == 0 ? NOTHING : body;
        }
    
        private static String formatObject(int type, Object object) {
            if (object == null) return NULL;
            if (type == JSON) return LogFormatter.formatJson(object.toString());
            if (type == XML) return LogFormatter.formatXml(object.toString());
            return formatObject(object);
        }
    
        private static String formatObject(Object object) {
            if (object == null) return NULL;
            if (!I_FORMATTER_MAP.isEmpty()) {
                IFormatter iFormatter = I_FORMATTER_MAP.get(getClassFromObject(object));
                if (iFormatter != null) {
                    //noinspection unchecked
                    return iFormatter.format(object);
                }
            }
            if (object.getClass().isArray()) return LogFormatter.array2String(object);
            if (object instanceof Throwable) return LogFormatter.throwable2String((Throwable) object);
            if (object instanceof Bundle) return LogFormatter.bundle2String((Bundle) object);
            if (object instanceof Intent) return LogFormatter.intent2String((Intent) object);
            return object.toString();
        }
    
        private static void print2Console(final int type,
                                          final String tag,
                                          final String[] head,
                                          final String msg) {
            if (sConfig.mSingleTagSwitch) {
                printSingleTagMsg(type, tag, processSingleTagMsg(type, tag, head, msg));
            } else {
                printBorder(type, tag, true);
                printHead(type, tag, head);
                printMsg(type, tag, msg);
                printBorder(type, tag, false);
            }
        }
    
        private static void printBorder(final int type, final String tag, boolean isTop) {
            if (sConfig.mLogBorderSwitch) {
                Log.println(type, tag, isTop ? TOP_BORDER : BOTTOM_BORDER);
            }
        }
    
        private static void printHead(final int type, final String tag, final String[] head) {
            if (head != null) {
                for (String aHead : head) {
                    Log.println(type, tag, sConfig.mLogBorderSwitch ? LEFT_BORDER + aHead : aHead);
                }
                if (sConfig.mLogBorderSwitch) Log.println(type, tag, MIDDLE_BORDER);
            }
        }
    
        private static void printMsg(final int type, final String tag, final String msg) {
            int len = msg.length();
            int countOfSub = len / MAX_LEN;
            if (countOfSub > 0) {
                int index = 0;
                for (int i = 0; i < countOfSub; i++) {
                    printSubMsg(type, tag, msg.substring(index, index + MAX_LEN));
                    index += MAX_LEN;
                }
                if (index != len) {
                    printSubMsg(type, tag, msg.substring(index, len));
                }
            } else {
                printSubMsg(type, tag, msg);
            }
        }
    
        private static void printSubMsg(final int type, final String tag, final String msg) {
            if (!sConfig.mLogBorderSwitch) {
                Log.println(type, tag, msg);
                return;
            }
            StringBuilder sb = new StringBuilder();
            String[] lines = msg.split(LINE_SEP);
            for (String line : lines) {
                Log.println(type, tag, LEFT_BORDER + line);
            }
        }
    
        private static String processSingleTagMsg(final int type,
                                                  final String tag,
                                                  final String[] head,
                                                  final String msg) {
            StringBuilder sb = new StringBuilder();
            sb.append(PLACEHOLDER).append(LINE_SEP);
            if (sConfig.mLogBorderSwitch) {
                sb.append(TOP_BORDER).append(LINE_SEP);
                if (head != null) {
                    for (String aHead : head) {
                        sb.append(LEFT_BORDER).append(aHead).append(LINE_SEP);
                    }
                    sb.append(MIDDLE_BORDER).append(LINE_SEP);
                }
                for (String line : msg.split(LINE_SEP)) {
                    sb.append(LEFT_BORDER).append(line).append(LINE_SEP);
                }
                sb.append(BOTTOM_BORDER);
            } else {
                if (head != null) {
                    for (String aHead : head) {
                        sb.append(aHead).append(LINE_SEP);
                    }
                }
                sb.append(msg);
            }
            return sb.toString();
        }
    
        private static void printSingleTagMsg(final int type, final String tag, final String msg) {
            int len = msg.length();
            int countOfSub = len / MAX_LEN;
            if (countOfSub > 0) {
                if (sConfig.mLogBorderSwitch) {
                    Log.println(type, tag, msg.substring(0, MAX_LEN) + LINE_SEP + BOTTOM_BORDER);
                    int index = MAX_LEN;
                    for (int i = 1; i < countOfSub; i++) {
                        Log.println(type, tag, PLACEHOLDER + LINE_SEP + TOP_BORDER + LINE_SEP
                                + LEFT_BORDER + msg.substring(index, index + MAX_LEN)
                                + LINE_SEP + BOTTOM_BORDER);
                        index += MAX_LEN;
                    }
                    if (index != len) {
                        Log.println(type, tag, PLACEHOLDER + LINE_SEP + TOP_BORDER + LINE_SEP
                                + LEFT_BORDER + msg.substring(index, len));
                    }
                } else {
                    Log.println(type, tag, msg.substring(0, MAX_LEN));
                    int index = MAX_LEN;
                    for (int i = 1; i < countOfSub; i++) {
                        Log.println(type, tag,
                                PLACEHOLDER + LINE_SEP + msg.substring(index, index + MAX_LEN));
                        index += MAX_LEN;
                    }
                    if (index != len) {
                        Log.println(type, tag, PLACEHOLDER + LINE_SEP + msg.substring(index, len));
                    }
                }
            } else {
                Log.println(type, tag, msg);
            }
        }
    
        private static void print2File(final int type, final String tag, final String msg) {
            Date now = new Date(System.currentTimeMillis());
            String format = getSdf().format(now);
            String date = format.substring(0, 10);
            String time = format.substring(11);
            final String fullPath =
                    (sConfig.mDir == null ? sConfig.mDefaultDir : sConfig.mDir)
                            + sConfig.mFilePrefix + "-" + date + ".txt";
            if (!createOrExistsFile(fullPath)) {
                Log.e("ALog", "create " + fullPath + " failed!");
                return;
            }
            StringBuilder sb = new StringBuilder();
            sb.append(time)
                    .append(T[type - V])
                    .append("/")
                    .append(tag)
                    .append(msg)
                    .append(LINE_SEP);
            final String content = sb.toString();
            input2File(content, fullPath);
        }
    
        private static SimpleDateFormat getSdf() {
            SimpleDateFormat simpleDateFormat = SDF_THREAD_LOCAL.get();
            if (simpleDateFormat == null) {
                simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.getDefault());
                SDF_THREAD_LOCAL.set(simpleDateFormat);
            }
            return simpleDateFormat;
        }
    
        private static boolean createOrExistsFile(final String filePath) {
            File file = new File(filePath);
            if (file.exists()) return file.isFile();
            if (!createOrExistsDir(file.getParentFile())) return false;
            try {
                deleteDueLogs(filePath);
                boolean isCreate = file.createNewFile();
                if (isCreate) {
                    printDeviceInfo(filePath);
                }
                return isCreate;
            } catch (IOException e) {
                e.printStackTrace();
                return false;
            }
        }
    
        private static void deleteDueLogs(String filePath) {
            File file = new File(filePath);
            File parentFile = file.getParentFile();
            File[] files = parentFile.listFiles(new FilenameFilter() {
                @Override
                public boolean accept(File dir, String name) {
                    return name.matches("^" + sConfig.mFilePrefix + "-[0-9]{4}-[0-9]{2}-[0-9]{2}.txt$");
                }
            });
            if (files.length <= 0) return;
            final int length = filePath.length();
            final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd", Locale.getDefault());
            try {
                String curDay = filePath.substring(length - 14, length - 4);
                long dueMillis = sdf.parse(curDay).getTime() - sConfig.mSaveDays * 86400000L;
                for (final File aFile : files) {
                    String name = aFile.getName();
                    int l = name.length();
                    String logDay = name.substring(l - 14, l - 4);
                    if (sdf.parse(logDay).getTime() <= dueMillis) {
                        EXECUTOR.execute(new Runnable() {
                            @Override
                            public void run() {
                                boolean delete = aFile.delete();
                                if (!delete) {
                                    Log.e("ALog", "delete " + aFile + " failed!");
                                }
                            }
                        });
                    }
                }
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }
    
        private static void printDeviceInfo(final String filePath) {
            String versionName = "";
            int versionCode = 0;
            try {
                PackageInfo pi = sAppContext
                        .getPackageManager()
                        .getPackageInfo(sAppContext.getPackageName(), 0);
                if (pi != null) {
                    versionName = pi.versionName;
                    versionCode = pi.versionCode;
                }
            } catch (PackageManager.NameNotFoundException e) {
                e.printStackTrace();
            }
            String time = filePath.substring(filePath.length() - 14, filePath.length() - 4);
            final String head = "************* Log Head ****************" +
                    "\nDate of Log        : " + time +
                    "\nDevice Manufacturer: " + Build.MANUFACTURER +
                    "\nDevice Model       : " + Build.MODEL +
                    "\nAndroid Version    : " + Build.VERSION.RELEASE +
                    "\nAndroid SDK        : " + Build.VERSION.SDK_INT +
                    "\nApp VersionName    : " + versionName +
                    "\nApp VersionCode    : " + versionCode +
                    "\n************* Log Head ****************\n\n";
            input2File(head, filePath);
        }
    
        private static boolean createOrExistsDir(final File file) {
            return file != null && (file.exists() ? file.isDirectory() : file.mkdirs());
        }
    
        private static boolean isSpace(final String s) {
            if (s == null) return true;
            for (int i = 0, len = s.length(); i < len; ++i) {
                if (!Character.isWhitespace(s.charAt(i))) {
                    return false;
                }
            }
            return true;
        }
    
        private static void input2File(final String input, final String filePath) {
            EXECUTOR.execute(new Runnable() {
                @Override
                public void run() {
                    BufferedWriter bw = null;
                    try {
                        bw = new BufferedWriter(new FileWriter(filePath, true));
                        bw.write(input);
                    } catch (IOException e) {
                        e.printStackTrace();
                        Log.e("ALog", "log to " + filePath + " failed!");
                    } finally {
                        try {
                            if (bw != null) {
                                bw.close();
                            }
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
            });
        }
    
        public static class Config {
            private String  mDefaultDir;// The default storage directory of log.
            private String  mDir;       // The storage directory of log.
            private String  mFilePrefix        = "util";// The file prefix of log.
            private boolean mLogSwitch         = true;  // The switch of log.
            private boolean mLog2ConsoleSwitch = true;  // The logcat's switch of log.
            private String  mGlobalTag         = null;  // The global tag of log.
            private boolean mTagIsSpace        = true;  // The global tag is space.
            private boolean mLogHeadSwitch     = true;  // The head's switch of log.
            private boolean mLog2FileSwitch    = false; // The file's switch of log.
            private boolean mLogBorderSwitch   = true;  // The border's switch of log.
            private boolean mSingleTagSwitch   = true;  // The single tag of log.
            private int     mConsoleFilter     = V;     // The console's filter of log.
            private int     mFileFilter        = V;     // The file's filter of log.
            private int     mStackDeep         = 1;     // The stack's deep of log.
            private int     mStackOffset       = 0;     // The stack's offset of log.
            private int     mSaveDays          = -1;    // The save days of log.
    
            private Config() {
                if (mDefaultDir != null) return;
                if (Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState())
                        && sAppContext.getExternalCacheDir() != null)
                    mDefaultDir = sAppContext.getExternalCacheDir() + FILE_SEP + "log" + FILE_SEP;
                else {
                    mDefaultDir = sAppContext.getCacheDir() + FILE_SEP + "log" + FILE_SEP;
                }
            }
    
            public Config setLogSwitch(final boolean logSwitch) {
                mLogSwitch = logSwitch;
                return this;
            }
    
            public Config setConsoleSwitch(final boolean consoleSwitch) {
                mLog2ConsoleSwitch = consoleSwitch;
                return this;
            }
    
            public Config setGlobalTag(final String tag) {
                if (isSpace(tag)) {
                    mGlobalTag = "";
                    mTagIsSpace = true;
                } else {
                    mGlobalTag = tag;
                    mTagIsSpace = false;
                }
                return this;
            }
    
            public Config setLogHeadSwitch(final boolean logHeadSwitch) {
                mLogHeadSwitch = logHeadSwitch;
                return this;
            }
    
            public Config setLog2FileSwitch(final boolean log2FileSwitch) {
                mLog2FileSwitch = log2FileSwitch;
                return this;
            }
    
            public Config setDir(final String dir) {
                if (isSpace(dir)) {
                    mDir = null;
                } else {
                    mDir = dir.endsWith(FILE_SEP) ? dir : dir + FILE_SEP;
                }
                return this;
            }
    
            public Config setDir(final File dir) {
                mDir = dir == null ? null : dir.getAbsolutePath() + FILE_SEP;
                return this;
            }
    
            public Config setFilePrefix(final String filePrefix) {
                if (isSpace(filePrefix)) {
                    mFilePrefix = "util";
                } else {
                    mFilePrefix = filePrefix;
                }
                return this;
            }
    
            public Config setBorderSwitch(final boolean borderSwitch) {
                mLogBorderSwitch = borderSwitch;
                return this;
            }
    
            public Config setSingleTagSwitch(final boolean singleTagSwitch) {
                mSingleTagSwitch = singleTagSwitch;
                return this;
            }
    
            public Config setConsoleFilter(@TYPE final int consoleFilter) {
                mConsoleFilter = consoleFilter;
                return this;
            }
    
            public Config setFileFilter(@TYPE final int fileFilter) {
                mFileFilter = fileFilter;
                return this;
            }
    
            public Config setStackDeep(@IntRange(from = 1) final int stackDeep) {
                mStackDeep = stackDeep;
                return this;
            }
    
            public Config setStackOffset(@IntRange(from = 0) final int stackOffset) {
                mStackOffset = stackOffset;
                return this;
            }
    
            public Config setSaveDays(@IntRange(from = 1) final int saveDays) {
                mSaveDays = saveDays;
                return this;
            }
    
            public final <T> Config addFormatter(final IFormatter<T> iFormatter) {
                if (iFormatter != null) {
                    I_FORMATTER_MAP.put(getTypeClassFromInterface(iFormatter), iFormatter);
                }
                return this;
            }
    
            @Override
            public String toString() {
                return "switch: " + mLogSwitch
                        + LINE_SEP + "console: " + mLog2ConsoleSwitch
                        + LINE_SEP + "tag: " + (mTagIsSpace ? "null" : mGlobalTag)
                        + LINE_SEP + "head: " + mLogHeadSwitch
                        + LINE_SEP + "file: " + mLog2FileSwitch
                        + LINE_SEP + "dir: " + (mDir == null ? mDefaultDir : mDir)
                        + LINE_SEP + "filePrefix: " + mFilePrefix
                        + LINE_SEP + "border: " + mLogBorderSwitch
                        + LINE_SEP + "singleTag: " + mSingleTagSwitch
                        + LINE_SEP + "consoleFilter: " + T[mConsoleFilter - V]
                        + LINE_SEP + "fileFilter: " + T[mFileFilter - V]
                        + LINE_SEP + "stackDeep: " + mStackDeep
                        + LINE_SEP + "stackOffset: " + mStackOffset
                        + LINE_SEP + "saveDays: " + mSaveDays
                        + LINE_SEP + "formatter: " + I_FORMATTER_MAP;
            }
        }
    
        public interface IFormatter<T> {
            String format(T t);
        }
    
        private static class TagHead {
            String   tag;
            String[] consoleHead;
            String   fileHead;
    
            TagHead(String tag, String[] consoleHead, String fileHead) {
                this.tag = tag;
                this.consoleHead = consoleHead;
                this.fileHead = fileHead;
            }
        }
    
        private static class LogFormatter {
            private static String formatJson(String json) {
                try {
                    if (json.startsWith("{")) {
                        json = new JSONObject(json).toString(4);
                    } else if (json.startsWith("[")) {
                        json = new JSONArray(json).toString(4);
                    }
                } catch (JSONException e) {
                    e.printStackTrace();
                }
                return json;
            }
    
            private static String formatXml(String xml) {
                try {
                    Source xmlInput = new StreamSource(new StringReader(xml));
                    StreamResult xmlOutput = new StreamResult(new StringWriter());
                    Transformer transformer = TransformerFactory.newInstance().newTransformer();
                    transformer.setOutputProperty(OutputKeys.INDENT, "yes");
                    transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4");
                    transformer.transform(xmlInput, xmlOutput);
                    xml = xmlOutput.getWriter().toString().replaceFirst(">", ">" + LINE_SEP);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return xml;
            }
    
            private static String array2String(Object object) {
                if (object instanceof Object[]) {
                    return Arrays.deepToString((Object[]) object);
                } else if (object instanceof boolean[]) {
                    return Arrays.toString((boolean[]) object);
                } else if (object instanceof byte[]) {
                    return Arrays.toString((byte[]) object);
                } else if (object instanceof char[]) {
                    return Arrays.toString((char[]) object);
                } else if (object instanceof double[]) {
                    return Arrays.toString((double[]) object);
                } else if (object instanceof float[]) {
                    return Arrays.toString((float[]) object);
                } else if (object instanceof int[]) {
                    return Arrays.toString((int[]) object);
                } else if (object instanceof long[]) {
                    return Arrays.toString((long[]) object);
                } else if (object instanceof short[]) {
                    return Arrays.toString((short[]) object);
                }
                throw new IllegalArgumentException("Array has incompatible type: " + object.getClass());
            }
    
            private static String throwable2String(final Throwable e) {
                Throwable t = e;
                while (t != null) {
                    if (t instanceof UnknownHostException) {
                        return "";
                    }
                    t = t.getCause();
                }
                StringWriter sw = new StringWriter();
                PrintWriter pw = new PrintWriter(sw);
                e.printStackTrace(pw);
                Throwable cause = e.getCause();
                while (cause != null) {
                    cause.printStackTrace(pw);
                    cause = cause.getCause();
                }
                pw.flush();
                return sw.toString();
            }
    
            private static String bundle2String(Bundle bundle) {
                Iterator<String> iterator = bundle.keySet().iterator();
                if (!iterator.hasNext()) {
                    return "Bundle {}";
                }
                StringBuilder sb = new StringBuilder(128);
                sb.append("Bundle { ");
                for (; ; ) {
                    String key = iterator.next();
                    Object value = bundle.get(key);
                    sb.append(key).append('=');
                    if (value != null && value instanceof Bundle) {
                        sb.append(value == bundle ? "(this Bundle)" : bundle2String((Bundle) value));
                    } else {
                        sb.append(formatObject(value));
                    }
                    if (!iterator.hasNext()) return sb.append(" }").toString();
                    sb.append(',').append(' ');
                }
            }
    
            private static String intent2String(Intent intent) {
                StringBuilder sb = new StringBuilder(128);
                sb.append("Intent { ");
                boolean first = true;
                String mAction = intent.getAction();
                if (mAction != null) {
                    sb.append("act=").append(mAction);
                    first = false;
                }
                Set<String> mCategories = intent.getCategories();
                if (mCategories != null) {
                    if (!first) {
                        sb.append(' ');
                    }
                    first = false;
                    sb.append("cat=[");
                    boolean firstCategory = true;
                    for (String c : mCategories) {
                        if (!firstCategory) {
                            sb.append(',');
                        }
                        sb.append(c);
                        firstCategory = false;
                    }
                    sb.append("]");
                }
                Uri mData = intent.getData();
                if (mData != null) {
                    if (!first) {
                        sb.append(' ');
                    }
                    first = false;
                    sb.append("dat=").append(mData);
                }
                String mType = intent.getType();
                if (mType != null) {
                    if (!first) {
                        sb.append(' ');
                    }
                    first = false;
                    sb.append("typ=").append(mType);
                }
                int mFlags = intent.getFlags();
                if (mFlags != 0) {
                    if (!first) {
                        sb.append(' ');
                    }
                    first = false;
                    sb.append("flg=0x").append(Integer.toHexString(mFlags));
                }
                String mPackage = intent.getPackage();
                if (mPackage != null) {
                    if (!first) {
                        sb.append(' ');
                    }
                    first = false;
                    sb.append("pkg=").append(mPackage);
                }
                ComponentName mComponent = intent.getComponent();
                if (mComponent != null) {
                    if (!first) {
                        sb.append(' ');
                    }
                    first = false;
                    sb.append("cmp=").append(mComponent.flattenToShortString());
                }
                Rect mSourceBounds = intent.getSourceBounds();
                if (mSourceBounds != null) {
                    if (!first) {
                        sb.append(' ');
                    }
                    first = false;
                    sb.append("bnds=").append(mSourceBounds.toShortString());
                }
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
                    ClipData mClipData = intent.getClipData();
                    if (mClipData != null) {
                        if (!first) {
                            sb.append(' ');
                        }
                        first = false;
                        clipData2String(mClipData, sb);
                    }
                }
                Bundle mExtras = intent.getExtras();
                if (mExtras != null) {
                    if (!first) {
                        sb.append(' ');
                    }
                    first = false;
                    sb.append("extras={");
                    sb.append(bundle2String(mExtras));
                    sb.append('}');
                }
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH_MR1) {
                    Intent mSelector = intent.getSelector();
                    if (mSelector != null) {
                        if (!first) {
                            sb.append(' ');
                        }
                        first = false;
                        sb.append("sel={");
                        sb.append(mSelector == intent ? "(this Intent)" : intent2String(mSelector));
                        sb.append("}");
                    }
                }
                sb.append(" }");
                return sb.toString();
            }
    
            @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN)
            private static void clipData2String(ClipData clipData, StringBuilder sb) {
                ClipData.Item item = clipData.getItemAt(0);
                if (item == null) {
                    sb.append("ClipData.Item {}");
                    return;
                }
                sb.append("ClipData.Item { ");
                String mHtmlText = item.getHtmlText();
                if (mHtmlText != null) {
                    sb.append("H:");
                    sb.append(mHtmlText);
                    sb.append("}");
                    return;
                }
                CharSequence mText = item.getText();
                if (mText != null) {
                    sb.append("T:");
                    sb.append(mText);
                    sb.append("}");
                    return;
                }
                Uri uri = item.getUri();
                if (uri != null) {
                    sb.append("U:").append(uri);
                    sb.append("}");
                    return;
                }
                Intent intent = item.getIntent();
                if (intent != null) {
                    sb.append("I:");
                    sb.append(intent2String(intent));
                    sb.append("}");
                    return;
                }
                sb.append("NULL");
                sb.append("}");
            }
        }
    
        private static <T> Class getTypeClassFromInterface(final IFormatter<T> callback) {
            if (callback == null) return null;
            Type mySuperClass = callback.getClass().getGenericInterfaces()[0];
            Type type = ((ParameterizedType) mySuperClass).getActualTypeArguments()[0];
            while (type instanceof ParameterizedType) {
                type = ((ParameterizedType) type).getRawType();
            }
            String className = type.toString();
            if (className.startsWith("class ")) {
                className = className.substring(6);
            } else if (className.startsWith("interface ")) {
                className = className.substring(10);
            }
            try {
                return Class.forName(className);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        private static Class getClassFromObject(final Object obj) {
            Class objClass = obj.getClass();
            Type[] genericInterfaces = objClass.getGenericInterfaces();
            if (genericInterfaces.length == 1) {
                Type type = genericInterfaces[0];
                while (type instanceof ParameterizedType) {
                    type = ((ParameterizedType) type).getRawType();
                }
                String className = type.toString();
                if (className.startsWith("class ")) {
                    className = className.substring(6);
                } else if (className.startsWith("interface ")) {
                    className = className.substring(10);
                }
                try {
                    return Class.forName(className);
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                }
            }
            return objClass;
        }
    }

[ALog_xxdw1992_-_alog -]: https://cxybb.com/article/xxdw1992/102484307
[icon-default.png_t_LBL2]: https://csdnimg.cn/release/blog_editor_html/release1.9.7/ckeditor/plugins/CsdnLink/icons/icon-default.png?t=LBL2
[https_github.com_Blankj_ALog_icon-default.png_t_LBL2_icon-default.png_t_LBL2_https_github.com_Blankj_ALog]: https://github.com/Blankj/ALog