小红书.apk(点击下载) / UploadInfoCollector.java

package com.qiniu.android.collect;

import com.qiniu.android.http.UserAgent;
import com.qiniu.android.storage.UpToken;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.Charset;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;

public final class UploadInfoCollector {
    private static OkHttpClient httpClient;
    private static UploadInfoCollector httpCollector;
    private static ExecutorService singleServer;
    private long lastUpload;
    private File recordFile = null;
    private final String recordFileName;
    private final String serverURL;

    public static abstract class RecordMsg {
        public abstract String toRecordMsg();
    }

    private UploadInfoCollector(String str, String str2) {
        this.recordFileName = str;
        this.serverURL = str2;
        try {
            reset0();
        } catch (Exception e14) {
            e14.printStackTrace();
        }
    }

    private static OkHttpClient getHttpClient() {
        if (httpClient == null) {
            OkHttpClient.Builder builder = new OkHttpClient.Builder();
            TimeUnit timeUnit = TimeUnit.SECONDS;
            builder.connectTimeout(10, timeUnit);
            builder.readTimeout(15, timeUnit);
            builder.writeTimeout((long) ((((Config.interval / 2) + 1) * 60) - 10), timeUnit);
            httpClient = builder.build();
        }
        return httpClient;
    }

    private static UploadInfoCollector getHttpCollector() {
        if (httpCollector == null) {
            httpCollector = new UploadInfoCollector("_qiniu_record_file_hs5z9lo7anx03", "https://uplog.qbox.me/log/4");
        }
        return httpCollector;
    }

    private File getRecordDir(String str) {
        return new File(str);
    }

    private void handle0(final UpToken upToken, final RecordMsg recordMsg) {
        ExecutorService executorService = singleServer;
        if (executorService != null && !executorService.isShutdown()) {
            singleServer.submit(new Runnable() {
                /* class com.qiniu.android.collect.UploadInfoCollector.AnonymousClass1 */

                public void run() {
                    if (Config.isRecord) {
                        try {
                            UploadInfoCollector.this.tryRecode(recordMsg.toRecordMsg(), UploadInfoCollector.this.recordFile);
                        } catch (Throwable unused) {
                        }
                    }
                }
            });
            if (Config.isUpload && !UpToken.isInvalid(upToken)) {
                singleServer.submit(new Runnable() {
                    /* class com.qiniu.android.collect.UploadInfoCollector.AnonymousClass2 */

                    public void run() {
                        if (Config.isRecord && Config.isUpload) {
                            try {
                                UploadInfoCollector uploadInfoCollector = UploadInfoCollector.this;
                                uploadInfoCollector.tryUploadAndClean(upToken, uploadInfoCollector.recordFile);
                            } catch (Throwable unused) {
                            }
                        }
                    }
                });
            }
        }
    }

    public static void handleHttp(UpToken upToken, RecordMsg recordMsg) {
        try {
            if (Config.isRecord) {
                getHttpCollector().handle0(upToken, recordMsg);
            }
        } catch (Throwable unused) {
        }
    }

    public static void handleUpload(UpToken upToken, RecordMsg recordMsg) {
        handleHttp(upToken, recordMsg);
    }

    private void initRecordFile(File file) throws IOException {
        if (file == null) {
            throw new IOException("record's dir is not setted");
        } else if (!file.exists()) {
            if (!file.mkdirs()) {
                throw new IOException("mkdir failed: " + file.getAbsolutePath());
            }
        } else if (file.isDirectory()) {
            this.recordFile = new File(file, this.recordFileName);
        } else {
            throw new IOException(file.getAbsolutePath() + " is not a dir");
        }
    }

    private boolean isOk(Response response) {
        return response.isSuccessful() && response.header("X-Reqid") != null;
    }

    private void reset0() throws IOException {
        ExecutorService executorService;
        if (Config.isRecord) {
            initRecordFile(getRecordDir(Config.recordDir));
        }
        if (!Config.isRecord && (executorService = singleServer) != null) {
            executorService.shutdown();
        }
        if (Config.isRecord) {
            ExecutorService executorService2 = singleServer;
            if (executorService2 == null || executorService2.isShutdown()) {
                singleServer = Executors.newSingleThreadExecutor();
            }
        }
    }

    /* access modifiers changed from: private */
    /* access modifiers changed from: public */
    private void tryRecode(String str, File file) {
        if (Config.isRecord && file.length() < ((long) Config.maxRecordFileSize)) {
            writeToFile(file, str + "\n", true);
        }
    }

    /* access modifiers changed from: private */
    /* access modifiers changed from: public */
    private void tryUploadAndClean(UpToken upToken, File file) {
        if (Config.isUpload && file.length() > ((long) Config.uploadThreshold)) {
            long time = new Date().getTime();
            if (time > this.lastUpload + ((long) (Config.interval * 60 * 1000))) {
                this.lastUpload = time;
                if (upload(upToken, file)) {
                    writeToFile(file, "", false);
                    writeToFile(file, "", false);
                }
            }
        }
    }

    private boolean upload(UpToken upToken, File file) {
        try {
            OkHttpClient httpClient2 = getHttpClient();
            RequestBody create = RequestBody.create(MediaType.parse("text/plain"), file);
            Request.Builder url = new Request.Builder().url(this.serverURL);
            Request.Builder post = url.addHeader("Authorization", "UpToken " + upToken.token).addHeader("User-Agent", UserAgent.instance().getUa(upToken.accessKey)).post(create);
            String str = UploadInfoElement.x_log_client_id;
            if (str != "") {
                post.addHeader("X-Log-Client-Id", str);
            }
            Response execute = httpClient2.newCall(post.build()).execute();
            UploadInfoElement.x_log_client_id = execute.header("X-Log-Client-Id");
            try {
                return isOk(execute);
            } finally {
                try {
                    execute.body().close();
                } catch (Exception unused) {
                }
            }
        } catch (Exception e14) {
            e14.printStackTrace();
            return false;
        }
    }

    /* JADX WARNING: Removed duplicated region for block: B:25:0x0039 A[SYNTHETIC, Splitter:B:25:0x0039] */
    /* JADX WARNING: Removed duplicated region for block: B:30:? A[RETURN, SYNTHETIC] */
    /* JADX WARNING: Removed duplicated region for block: B:32:? A[RETURN, SYNTHETIC] */
    private static void writeToFile(File file, String str, boolean z14) {
        Throwable th3;
        FileNotFoundException e14;
        IOException e15;
        FileOutputStream fileOutputStream = null;
        try {
            FileOutputStream fileOutputStream2 = new FileOutputStream(file, z14);
            try {
                fileOutputStream2.write(str.getBytes(Charset.forName("UTF-8")));
                fileOutputStream2.flush();
                try {
                    fileOutputStream2.close();
                } catch (IOException unused) {
                }
            } catch (FileNotFoundException e16) {
                e14 = e16;
                fileOutputStream = fileOutputStream2;
                e14.printStackTrace();
                if (fileOutputStream == null) {
                    return;
                }
                fileOutputStream.close();
            } catch (IOException e17) {
                e15 = e17;
                fileOutputStream = fileOutputStream2;
                try {
                    e15.printStackTrace();
                    if (fileOutputStream == null) {
                        return;
                    }
                    fileOutputStream.close();
                } catch (Throwable th4) {
                    th3 = th4;
                    if (fileOutputStream != null) {
                        try {
                            fileOutputStream.close();
                        } catch (IOException unused2) {
                        }
                    }
                    throw th3;
                }
            } catch (Throwable th5) {
                th3 = th5;
                fileOutputStream = fileOutputStream2;
                if (fileOutputStream != null) {
                }
                throw th3;
            }
        } catch (FileNotFoundException e18) {
            e14 = e18;
            e14.printStackTrace();
            if (fileOutputStream == null) {
            }
            fileOutputStream.close();
        } catch (IOException e19) {
            e15 = e19;
            e15.printStackTrace();
            if (fileOutputStream == null) {
            }
            fileOutputStream.close();
        }
    }
}