Petal Maps v4.7.0.310001 - LogWrite.java 源代码

package com.huawei.location.lite.common.log.logwrite;

import android.text.TextUtils;
import android.util.Log;
import com.huawei.hms.network.embedded.k;
import com.huawei.location.base.activity.constant.ActivityRecognitionConstants;
import com.huawei.location.lite.common.android.context.ContextUtil;
import com.huawei.location.lite.common.log.logwrite.LogWrite;
import com.huawei.location.lite.common.util.PermissionUtil;
import com.huawei.location.lite.common.util.SDKComponentType;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.Serializable;
import java.nio.charset.StandardCharsets;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Comparator;
import java.util.Iterator;
import java.util.Locale;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public final class LogWrite {
    private static final long DAY_TO_MILL = 86400000;
    private static final int DOWN_LINE_INDEX = 17;
    private static final int FILE_NAME_LENTH = 28;
    private static final int FIVE = 5;
    private static final String PATTERN_ONE = "yyyyMMdd_HHmmss";
    private static final String PATTERN_TWO = "yy-MM-dd HH:mm:ss.SSS";
    private static final String TAG = "LogWrite";
    private static final int TWENTY = 20;
    private static final int TWO = 2;
    private static final int UNIT_CONVERSION = 1024;
    private static boolean enableWriteLog = false;
    private Map<String, FileParam> fileInfoMap = new ConcurrentHashMap();
    private String logDirPath = null;
    private long maxFileExpired;
    private int maxFileNum;
    private int maxFileSize;

    public static class FileComparator implements Comparator<File>, Serializable {
        private static final long serialVersionUID = 1;

        private FileComparator() {
        }

        @Override
        public int compare(File file, File file2) {
            return (int) (file.lastModified() - file2.lastModified());
        }
    }

    private void beforeWriteCheck(FileParam fileParam, String str) throws IOException {
        String fileName = fileParam.getFileName();
        String fileDirPath = fileParam.getFileDirPath();
        if (!TextUtils.isEmpty(fileName)) {
            if (new File(fileDirPath, fileName).exists()) {
                return;
            } else {
                Log.i(TAG, "writeToFile file is not exit");
            }
        }
        File file = new File(fileDirPath);
        if (file.exists()) {
            pathExistsDeal(file, fileParam, str);
            return;
        }
        Log.i(TAG, "beforeWriteCheck None of the paths exist--Create a path--Create a file");
        fileParam.setNeedCheck(false);
        creatFolder(fileDirPath);
        createNewLogFile(fileParam, makeLogFileName(str), str);
    }

    private void creatFolder(String str) {
        File file = new File(str);
        if (file.exists()) {
            return;
        }
        try {
            if (file.mkdirs()) {
                Log.i(TAG, "createFolder success");
                return;
            }
        } catch (SecurityException unused) {
            Log.e(TAG, "createFolder SecurityException:");
        }
        Log.e(TAG, "createFolder fail");
    }

    private void createNewLogFile(FileParam fileParam, String str, String str2) throws IOException {
        String fileDirPath = fileParam.getFileDirPath();
        BufferedWriter writer = fileParam.getWriter();
        if (TextUtils.isEmpty(fileDirPath) || TextUtils.isEmpty(str)) {
            Log.e(TAG, "createNewLogFile Exception");
            return;
        }
        File file = new File(fileDirPath, str);
        FileOutputStream fileOutputStream = new FileOutputStream(file, true);
        synchronized (LogWrite.class) {
            if (writer != null) {
                try {
                    writer.close();
                } catch (IOException unused) {
                    Log.e(TAG, "createNewLogFile IOException");
                }
            }
            fileParam.setWriter(new BufferedWriter(new OutputStreamWriter(fileOutputStream, StandardCharsets.UTF_8)));
            if (fileParam.isNeedCheck()) {
                filesNumAndUsefulCheck(fileDirPath, str2);
            }
            fileParam.setFileName(str);
            enableWriteLog = true;
            if (str2.equals(LogWriteConstants.LOCATION_TYPE) && file.length() == 0) {
                fileParam.getWriter().append((CharSequence) getCSVFileHeader());
                fileParam.getWriter().flush();
            }
            Log.i(TAG, "createNewLogFile:File creation complete logFileName:" + str);
        }
    }

    private boolean deleteFiles(File[] fileArr, int i) {
        if (fileArr != null && fileArr.length > 0) {
            try {
                if (i == -1) {
                    for (int length = fileArr.length - 1; length >= 0; length--) {
                        if (!fileArr[length].delete()) {
                            Log.e(TAG, "deleteFiles result false");
                            return false;
                        }
                    }
                } else {
                    for (int i2 = i - 1; i2 >= 0; i2--) {
                        if (!fileArr[i2].delete()) {
                            Log.e(TAG, "deleteFiles result false");
                            return false;
                        }
                    }
                }
                return true;
            } catch (SecurityException unused) {
                Log.e(TAG, "deleteFiles SecurityException");
            }
        }
        return false;
    }

    private void doWrite(AppLog appLog, FileParam fileParam) throws IOException {
        String msgByFileType = getMsgByFileType(appLog);
        BufferedWriter writer = fileParam.getWriter();
        if (writer != null) {
            writer.append((CharSequence) msgByFileType);
            writer.flush();
        }
    }

    private void filesNumAndUsefulCheck(java.lang.String r6, java.lang.String r7) {
        throw new UnsupportedOperationException("Method not decompiled: com.huawei.location.lite.common.log.logwrite.LogWrite.filesNumAndUsefulCheck(java.lang.String, java.lang.String):void");
    }

    private static String getCSVFileHeader() {
        return "writeTime,transId,provider,latitude,longitude,accuracy,locationTime,speed,sessionId,sourceType,locateType,vendorType,src,switchHd,floor,floorAcc,buildingId" + System.lineSeparator();
    }

    private File[] getExistedFiles(File file, String str) {
        return file.listFiles(str.equals(LogWriteConstants.LOCATION_TYPE) ? new FilenameFilter() {
            @Override
            public final boolean accept(File file2, String str2) {
                boolean lambda$getExistedFiles$0;
                lambda$getExistedFiles$0 = LogWrite.lambda$getExistedFiles$0(file2, str2);
                return lambda$getExistedFiles$0;
            }
        } : new FilenameFilter() {
            @Override
            public final boolean accept(File file2, String str2) {
                boolean lambda$getExistedFiles$1;
                lambda$getExistedFiles$1 = LogWrite.lambda$getExistedFiles$1(file2, str2);
                return lambda$getExistedFiles$1;
            }
        });
    }

    private FileParam getFileInfo(String str) {
        if (this.fileInfoMap.containsKey(str)) {
            return this.fileInfoMap.get(str);
        }
        FileParam fileParam = new FileParam();
        String str2 = this.logDirPath;
        if (!str.equals(LogWriteConstants.LOG_TYPE) && str.equals(LogWriteConstants.LOCATION_TYPE)) {
            str2 = this.logDirPath + LogWriteConstants.DEBUG_PATH + LogWriteConstants.LOCATION_PATH;
        }
        fileParam.setFileDirPath(str2);
        this.fileInfoMap.put(str, fileParam);
        return fileParam;
    }

    private long getFileSavaTimeMill(File file) throws SecurityException {
        return file.lastModified();
    }

    private String getMsgByFileType(AppLog appLog) {
        if (appLog.getFileType().equals(LogWriteConstants.LOCATION_TYPE)) {
            Locale locale = Locale.ENGLISH;
            return (appLog.getMsg() + System.lineSeparator());
        }
        Locale locale2 = Locale.ENGLISH;
        return getNow() + ": " + appLog.getLevel() + "/" + appLog.getTag() + ": " + (appLog.getMsg() + System.lineSeparator() + Log.getStackTraceString(appLog.getTr()));
    }

    private String getNow() {
        return DateUtil.formate(Calendar.getInstance().getTime(), PATTERN_TWO);
    }

    public static boolean isEnableWriteLog() {
        return enableWriteLog;
    }

    private boolean isFileFull(String str, String str2, String str3) {
        File file = new File(str2, str3);
        boolean equals = str.equals(LogWriteConstants.LOCATION_TYPE);
        long length = file.length();
        return equals ? length > ((long) 1048576) : length > ((long) this.maxFileSize);
    }

    public static boolean lambda$getExistedFiles$0(File file, String str) {
        return str.startsWith(ActivityRecognitionConstants.LOCATION_MODULE) && str.endsWith(".csv") && str.length() == 28 && "_".equals(String.valueOf(str.charAt(17)));
    }

    public static boolean lambda$getExistedFiles$1(File file, String str) {
        return str.startsWith(ActivityRecognitionConstants.LOCATION_MODULE) && str.endsWith(".log") && str.length() == 28 && "_".equals(String.valueOf(str.charAt(17)));
    }

    private String makeLogFileName(String str) {
        String str2 = str.equals(LogWriteConstants.LOCATION_TYPE) ? ".csv" : ".log";
        return "Location." + new SimpleDateFormat(PATTERN_ONE, Locale.getDefault()).format(Calendar.getInstance().getTime()) + str2;
    }

    private void openLogFile(FileParam fileParam) throws IOException {
        BufferedWriter writer = fileParam.getWriter();
        String fileDirPath = fileParam.getFileDirPath();
        String fileName = fileParam.getFileName();
        if (writer == null) {
            if (TextUtils.isEmpty(fileDirPath) || TextUtils.isEmpty(fileName)) {
                Log.e(TAG, "openLogFile Exception");
                return;
            }
            FileOutputStream fileOutputStream = new FileOutputStream(new File(fileDirPath, fileName), true);
            synchronized (LogWrite.class) {
                fileParam.setWriter(new BufferedWriter(new OutputStreamWriter(fileOutputStream, StandardCharsets.UTF_8)));
            }
        }
    }

    private void pathExistsDeal(File file, FileParam fileParam, String str) throws IOException {
        boolean isFirstWrite = fileParam.isFirstWrite();
        String fileDirPath = fileParam.getFileDirPath();
        if (isFirstWrite) {
            filesNumAndUsefulCheck(fileDirPath, str);
            fileParam.setNeedCheck(false);
        }
        File[] existedFiles = getExistedFiles(file, str);
        if (existedFiles == null) {
            Log.e(TAG, "beforeWriteCheck  existedFiles is null");
            return;
        }
        if (existedFiles.length == 0) {
            Log.i(TAG, "beforeWriteCheck  Path Exist -- No File -- Create File");
            fileParam.setNeedCheck(false);
            createNewLogFile(fileParam, makeLogFileName(str), str);
        } else {
            try {
                Arrays.sort(existedFiles, new FileComparator());
            } catch (IllegalArgumentException unused) {
                Log.e(TAG, "beforeWriteCheck Arrays sort IllegalArgumentException");
            }
            fileParam.setFileName(existedFiles[existedFiles.length - 1].getName());
        }
    }

    public static void setEnableWriteLog(boolean z) {
        enableWriteLog = z;
    }

    public void init(int i, String str, int i2, int i3) {
        boolean z;
        this.maxFileSize = i > 0 ? Math.min(i, 2) * 1048576 : k.e.b;
        this.maxFileNum = i2 > 0 ? Math.min(i2, 20) : 20;
        this.maxFileExpired = i3 > 0 ? Math.min(i3, 5) * 86400000 : 432000000L;
        if (str != null) {
            this.logDirPath = str;
            z = true;
        } else {
            z = false;
        }
        setEnableWriteLog(z);
        Log.i(TAG, "LogWrite init complete");
    }

    public boolean permissionCheck(String str) {
        if (str.startsWith(LogWriteConstants.INNER_PATH_DATA_USER1) || str.startsWith(LogWriteConstants.INNER_PATH_DATA_DATA1) || str.startsWith(LogWriteConstants.INNER_PATH_DATA_DATA) || str.startsWith(LogWriteConstants.INNER_PATH_DATA_USER) || PermissionUtil.checkWriteLogPermission(ContextUtil.getContext())) {
            return true;
        }
        Log.e(TAG, "Storage permission check unPass");
        return false;
    }

    public void shutdown() {
        synchronized (LogWrite.class) {
            Iterator<Map.Entry<String, FileParam>> it = this.fileInfoMap.entrySet().iterator();
            while (it.hasNext()) {
                FileParam value = it.next().getValue();
                if (value != null && value.getWriter() != null) {
                    try {
                        value.getWriter().close();
                    } catch (IOException unused) {
                        Log.e(TAG, "shutdown IOException");
                    }
                    value.setWriter(null);
                }
            }
        }
    }

    public void writeToFile(AppLog appLog) {
        FileParam fileInfo;
        if (enableWriteLog) {
            String fileType = appLog.getFileType();
            synchronized (LogWrite.class) {
                try {
                    fileInfo = getFileInfo(fileType);
                } catch (IOException unused) {
                    Log.e(TAG, "writeToFile IOException");
                }
                if (SDKComponentType.getComponentType() != 100 || permissionCheck(this.logDirPath)) {
                    beforeWriteCheck(fileInfo, fileType);
                    if (TextUtils.isEmpty(fileInfo.getFileName())) {
                        return;
                    }
                    if (isFileFull(fileType, fileInfo.getFileDirPath(), fileInfo.getFileName())) {
                        fileInfo.setNeedCheck(true);
                        createNewLogFile(fileInfo, makeLogFileName(fileType), fileType);
                    } else {
                        openLogFile(fileInfo);
                    }
                    doWrite(appLog, fileInfo);
                }
            }
        }
    }
}