Log.java 源代码

package com.x8zs.morgoo.helper;

import android.os.Environment;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Process;
import androidx.exifinterface.media.ExifInterface;
import com.x8zs.morgoo.droidplugin.hook.HookFactory;
import com.x8zs.morgoo.droidplugin.hook.proxy.LibCoreHook;
import java.io.File;
import java.io.FileWriter;
import java.io.PrintWriter;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Log {
    private static final int ASSERT = 7;
    private static final int DEBUG = 3;
    private static final int ERROR = 6;
    private static final int INFO = 4;
    private static final long MAX_LOG_FILE = 8388608;
    public static final String TAG = "x8zs";
    private static final int VERBOSE = 2;
    private static final int WARN = 5;
    private static boolean sDebug = true;
    private static final File sDir;
    private static boolean sFileLog = false;
    private static final SimpleDateFormat sFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
    private static final SimpleDateFormat sFormat1 = new SimpleDateFormat("yyyyMMdd");
    private static Handler sHandler;
    private static HandlerThread sHandlerThread;

    static {
        boolean z6;
        File file = new File(Environment.getExternalStorageDirectory(), "360Log/Plugin/");
        sDir = file;
        if (file.exists() && file.isDirectory()) {
            z6 = true;
        } else {
            z6 = false;
        }
        sFileLog = z6;
        sDebug = z6;
        HandlerThread handlerThread = new HandlerThread("DroidPlugin@FileLogThread");
        sHandlerThread = handlerThread;
        handlerThread.start();
        sHandler = new Handler(sHandlerThread.getLooper());
    }

    private Log() {
    }

    public static void d(String str, String str2, Object... objArr) {
        d(str, str2, null, objArr);
    }

    public static void e(String str, String str2, Object... objArr) {
        e(str, str2, null, objArr);
    }

    private static File getLogFile() {
        File file = new File(Environment.getExternalStorageDirectory(), String.format("360Log/Plugin/Log_%s_%s.log", sFormat1.format(new Date()), Integer.valueOf(Process.myPid())));
        File parentFile = file.getParentFile();
        if (!parentFile.exists()) {
            parentFile.mkdirs();
        }
        return file;
    }

    private static String getProcessName() {
        return "?";
    }

    public static void i(String str, String str2, Object... objArr) {
        i(str, str2, null, objArr);
    }

    public static boolean isDebug() {
        return false;
    }

    private static boolean isFileLog() {
        return sFileLog;
    }

    public static boolean isLoggable(int i6) {
        return isDebug();
    }

    private static String levelToStr(int i6) {
        switch (i6) {
            case 2:
                return ExifInterface.GPS_MEASUREMENT_INTERRUPTED;
            case 3:
                return "D";
            case 4:
                return "I";
            case 5:
                return ExifInterface.LONGITUDE_WEST;
            case 6:
                return ExifInterface.LONGITUDE_EAST;
            case 7:
                return ExifInterface.GPS_MEASUREMENT_IN_PROGRESS;
            default:
                return "UNKNOWN";
        }
    }

    private static void logToFile(final int i6, final String str, final String str2, final Object[] objArr, final Throwable th) {
        sHandler.post(new Runnable() {
            @Override
            public void run() {
                Log.logToFileInner(i6, str, str2, objArr, th);
            }
        });
    }

    public static void logToFileInner(int i6, String str, String str2, Object[] objArr, Throwable th) {
        PrintWriter printWriter = null;
        try {
            try {
                if (!isFileLog()) {
                    HookFactory.getInstance().setHookEnable(LibCoreHook.class, true);
                    return;
                }
                HookFactory.getInstance().setHookEnable(LibCoreHook.class, false);
                File logFile = getLogFile();
                if (logFile.length() > MAX_LOG_FILE) {
                    logFile.delete();
                }
                PrintWriter printWriter2 = new PrintWriter(new FileWriter(logFile, true));
                try {
                    printWriter2.println(String.format("%s %s-%s/%s %s/%s %s", sFormat.format(new Date()), Integer.valueOf(Process.myPid()), Integer.valueOf(Process.myUid()), getProcessName(), levelToStr(i6), str, String.format(str2, objArr)));
                    if (th != null) {
                        th.printStackTrace(printWriter2);
                        printWriter2.println();
                    }
                    printWriter2.close();
                } catch (Throwable th2) {
                    th = th2;
                    printWriter = printWriter2;
                    try {
                        th.printStackTrace();
                        if (printWriter != null) {
                            printWriter.close();
                        }
                        HookFactory.getInstance().setHookEnable(LibCoreHook.class, true);
                    } catch (Throwable th3) {
                        if (printWriter != null) {
                            try {
                                printWriter.close();
                            } catch (Throwable unused) {
                            }
                        }
                        HookFactory.getInstance().setHookEnable(LibCoreHook.class, true);
                        throw th3;
                    }
                }
            } catch (Throwable unused2) {
                HookFactory.getInstance().setHookEnable(LibCoreHook.class, true);
            }
        } catch (Throwable th4) {
            th = th4;
        }
    }

    private static void println(int i6, String str, String str2, Object[] objArr, Throwable th) {
        logToFile(i6, str, str2, objArr, th);
        if (objArr != null && objArr.length > 0) {
            str2 = String.format(str2, objArr);
        }
        if (th != null) {
            str2 = str2 + android.util.Log.getStackTraceString(th);
        }
        android.util.Log.println(i6, str, str2);
    }

    public static void v(String str, String str2, Object... objArr) {
        v(str, str2, null, objArr);
    }

    public static void w(String str, String str2, Object... objArr) {
        w(str, str2, null, objArr);
    }

    public static void wtf(String str, String str2, Object... objArr) {
        wtf(str, str2, null, objArr);
    }

    public static void d(String str, String str2, Throwable th, Object... objArr) {
        if (isLoggable(3)) {
            println(3, str, str2, objArr, th);
        }
    }

    public static void e(String str, String str2, Throwable th, Object... objArr) {
        if (isLoggable(6)) {
            println(6, str, str2, objArr, th);
        }
    }

    public static void i(String str, String str2, Throwable th, Object... objArr) {
        if (isLoggable(4)) {
            println(4, str, str2, objArr, th);
        }
    }

    public static boolean isLoggable() {
        return isDebug();
    }

    public static void v(String str, String str2, Throwable th, Object... objArr) {
        if (isLoggable(2)) {
            println(2, str, str2, objArr, th);
        }
    }

    public static void w(String str, String str2, Throwable th, Object... objArr) {
        if (isLoggable(5)) {
            println(5, str, str2, objArr, th);
        }
    }

    public static void wtf(String str, Throwable th) {
        wtf(str, "wtf", th, new Object[0]);
    }

    public static void wtf(String str, String str2, Throwable th, Object... objArr) {
        if (isLoggable()) {
            println(7, str, str2, objArr, th);
        }
    }

    public static void w(String str, Throwable th) {
        w(str, "Log.warn", th, new Object[0]);
    }
}