Add decompiled APK source code (JADX)

- 28,932 files
- Full Java source code
- Smali files
- Resources

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

decompiled/sources/com/google/firebase/crashlytics/internal/persistence/CrashlyticsReportPersistence.java

@@ -0,0 +1,364 @@
+package com.google.firebase.crashlytics.internal.persistence;
+
+import androidx.core.app.NotificationCompat;
+import com.google.firebase.crashlytics.internal.Logger;
+import com.google.firebase.crashlytics.internal.common.CrashlyticsAppQualitySessionsSubscriber;
+import com.google.firebase.crashlytics.internal.common.CrashlyticsReportWithSessionId;
+import com.google.firebase.crashlytics.internal.metadata.UserMetadata;
+import com.google.firebase.crashlytics.internal.model.CrashlyticsReport;
+import com.google.firebase.crashlytics.internal.model.serialization.CrashlyticsReportJsonTransform;
+import com.google.firebase.crashlytics.internal.settings.SettingsProvider;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.FilenameFilter;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.nio.charset.Charset;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Locale;
+import java.util.SortedSet;
+import java.util.TreeSet;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/* loaded from: classes3.dex */
+public class CrashlyticsReportPersistence {
+    public final AtomicInteger eventCounter = new AtomicInteger(0);
+    public final FileStore fileStore;
+    public final CrashlyticsAppQualitySessionsSubscriber sessionsSubscriber;
+    public final SettingsProvider settingsProvider;
+    public static final Charset UTF_8 = Charset.forName("UTF-8");
+    public static final int EVENT_NAME_LENGTH = 15;
+    public static final CrashlyticsReportJsonTransform TRANSFORM = new CrashlyticsReportJsonTransform();
+    public static final Comparator LATEST_SESSION_ID_FIRST_COMPARATOR = new Comparator() { // from class: com.google.firebase.crashlytics.internal.persistence.CrashlyticsReportPersistence$$ExternalSyntheticLambda2
+        @Override // java.util.Comparator
+        public final int compare(Object obj, Object obj2) {
+            int lambda$static$0;
+            lambda$static$0 = CrashlyticsReportPersistence.lambda$static$0((File) obj, (File) obj2);
+            return lambda$static$0;
+        }
+    };
+    public static final FilenameFilter EVENT_FILE_FILTER = new FilenameFilter() { // from class: com.google.firebase.crashlytics.internal.persistence.CrashlyticsReportPersistence$$ExternalSyntheticLambda3
+        @Override // java.io.FilenameFilter
+        public final boolean accept(File file, String str) {
+            boolean lambda$static$1;
+            lambda$static$1 = CrashlyticsReportPersistence.lambda$static$1(file, str);
+            return lambda$static$1;
+        }
+    };
+
+    public static long convertTimestampFromSecondsToMs(long j) {
+        return j * 1000;
+    }
+
+    public static /* synthetic */ int lambda$static$0(File file, File file2) {
+        return file2.getName().compareTo(file.getName());
+    }
+
+    public static /* synthetic */ boolean lambda$static$1(File file, String str) {
+        return str.startsWith(NotificationCompat.CATEGORY_EVENT);
+    }
+
+    public CrashlyticsReportPersistence(FileStore fileStore, SettingsProvider settingsProvider, CrashlyticsAppQualitySessionsSubscriber crashlyticsAppQualitySessionsSubscriber) {
+        this.fileStore = fileStore;
+        this.settingsProvider = settingsProvider;
+        this.sessionsSubscriber = crashlyticsAppQualitySessionsSubscriber;
+    }
+
+    public void persistReport(CrashlyticsReport crashlyticsReport) {
+        CrashlyticsReport.Session session = crashlyticsReport.getSession();
+        if (session == null) {
+            Logger.getLogger().d("Could not get session for report");
+            return;
+        }
+        String identifier = session.getIdentifier();
+        try {
+            writeTextFile(this.fileStore.getSessionFile(identifier, "report"), TRANSFORM.reportToJson(crashlyticsReport));
+            writeTextFile(this.fileStore.getSessionFile(identifier, "start-time"), "", session.getStartedAt());
+        } catch (IOException e) {
+            Logger.getLogger().d("Could not persist report for session " + identifier, e);
+        }
+    }
+
+    public void persistEvent(CrashlyticsReport.Session.Event event, String str, boolean z) {
+        int i = this.settingsProvider.getSettingsSync().sessionData.maxCustomExceptionEvents;
+        try {
+            writeTextFile(this.fileStore.getSessionFile(str, generateEventFilename(this.eventCounter.getAndIncrement(), z)), TRANSFORM.eventToJson(event));
+        } catch (IOException e) {
+            Logger.getLogger().w("Could not persist event for session " + str, e);
+        }
+        trimEvents(str, i);
+    }
+
+    public SortedSet getOpenSessionIds() {
+        return new TreeSet(this.fileStore.getAllOpenSessionIds()).descendingSet();
+    }
+
+    public long getStartTimestampMillis(String str) {
+        return this.fileStore.getSessionFile(str, "start-time").lastModified();
+    }
+
+    public boolean hasFinalizedReports() {
+        return (this.fileStore.getReports().isEmpty() && this.fileStore.getPriorityReports().isEmpty() && this.fileStore.getNativeReports().isEmpty()) ? false : true;
+    }
+
+    public void deleteAllReports() {
+        deleteFiles(this.fileStore.getReports());
+        deleteFiles(this.fileStore.getPriorityReports());
+        deleteFiles(this.fileStore.getNativeReports());
+    }
+
+    public final void deleteFiles(List list) {
+        Iterator it = list.iterator();
+        while (it.hasNext()) {
+            ((File) it.next()).delete();
+        }
+    }
+
+    public void finalizeReports(String str, long j) {
+        for (String str2 : capAndGetOpenSessions(str)) {
+            Logger.getLogger().v("Finalizing report for session " + str2);
+            synthesizeReport(str2, j);
+            this.fileStore.deleteSessionFiles(str2);
+        }
+        capFinalizedReports();
+    }
+
+    public void finalizeSessionWithNativeEvent(String str, CrashlyticsReport.FilesPayload filesPayload, CrashlyticsReport.ApplicationExitInfo applicationExitInfo) {
+        File sessionFile = this.fileStore.getSessionFile(str, "report");
+        Logger.getLogger().d("Writing native session report for " + str + " to file: " + sessionFile);
+        synthesizeNativeReportFile(sessionFile, filesPayload, str, applicationExitInfo);
+    }
+
+    public List loadFinalizedReports() {
+        List<File> allFinalizedReportFiles = getAllFinalizedReportFiles();
+        ArrayList arrayList = new ArrayList();
+        for (File file : allFinalizedReportFiles) {
+            try {
+                arrayList.add(CrashlyticsReportWithSessionId.create(TRANSFORM.reportFromJson(readTextFile(file)), file.getName(), file));
+            } catch (IOException e) {
+                Logger.getLogger().w("Could not load report file " + file + "; deleting", e);
+                file.delete();
+            }
+        }
+        return arrayList;
+    }
+
+    public final SortedSet capAndGetOpenSessions(String str) {
+        this.fileStore.cleanupPreviousFileSystems();
+        SortedSet openSessionIds = getOpenSessionIds();
+        if (str != null) {
+            openSessionIds.remove(str);
+        }
+        if (openSessionIds.size() <= 8) {
+            return openSessionIds;
+        }
+        while (openSessionIds.size() > 8) {
+            String str2 = (String) openSessionIds.last();
+            Logger.getLogger().d("Removing session over cap: " + str2);
+            this.fileStore.deleteSessionFiles(str2);
+            openSessionIds.remove(str2);
+        }
+        return openSessionIds;
+    }
+
+    public final void capFinalizedReports() {
+        int i = this.settingsProvider.getSettingsSync().sessionData.maxCompleteSessionsCount;
+        List allFinalizedReportFiles = getAllFinalizedReportFiles();
+        int size = allFinalizedReportFiles.size();
+        if (size <= i) {
+            return;
+        }
+        Iterator it = allFinalizedReportFiles.subList(i, size).iterator();
+        while (it.hasNext()) {
+            ((File) it.next()).delete();
+        }
+    }
+
+    public final List getAllFinalizedReportFiles() {
+        ArrayList arrayList = new ArrayList();
+        arrayList.addAll(this.fileStore.getPriorityReports());
+        arrayList.addAll(this.fileStore.getNativeReports());
+        Comparator comparator = LATEST_SESSION_ID_FIRST_COMPARATOR;
+        Collections.sort(arrayList, comparator);
+        List reports = this.fileStore.getReports();
+        Collections.sort(reports, comparator);
+        arrayList.addAll(reports);
+        return arrayList;
+    }
+
+    public final void synthesizeReport(String str, long j) {
+        boolean z;
+        List<File> sessionFiles = this.fileStore.getSessionFiles(str, EVENT_FILE_FILTER);
+        if (sessionFiles.isEmpty()) {
+            Logger.getLogger().v("Session " + str + " has no events.");
+            return;
+        }
+        Collections.sort(sessionFiles);
+        ArrayList arrayList = new ArrayList();
+        loop0: while (true) {
+            z = false;
+            for (File file : sessionFiles) {
+                try {
+                    arrayList.add(TRANSFORM.eventFromJson(readTextFile(file)));
+                } catch (IOException e) {
+                    Logger.getLogger().w("Could not add event to report for " + file, e);
+                }
+                if (z || isHighPriorityEventFile(file.getName())) {
+                    z = true;
+                }
+            }
+        }
+        if (arrayList.isEmpty()) {
+            Logger.getLogger().w("Could not parse event files for session " + str);
+            return;
+        }
+        synthesizeReportFile(this.fileStore.getSessionFile(str, "report"), arrayList, j, z, UserMetadata.readUserId(str, this.fileStore), this.sessionsSubscriber.getAppQualitySessionId(str));
+    }
+
+    public final void synthesizeNativeReportFile(File file, CrashlyticsReport.FilesPayload filesPayload, String str, CrashlyticsReport.ApplicationExitInfo applicationExitInfo) {
+        String appQualitySessionId = this.sessionsSubscriber.getAppQualitySessionId(str);
+        try {
+            CrashlyticsReportJsonTransform crashlyticsReportJsonTransform = TRANSFORM;
+            writeTextFile(this.fileStore.getNativeReport(str), crashlyticsReportJsonTransform.reportToJson(crashlyticsReportJsonTransform.reportFromJson(readTextFile(file)).withNdkPayload(filesPayload).withApplicationExitInfo(applicationExitInfo).withAppQualitySessionId(appQualitySessionId)));
+        } catch (IOException e) {
+            Logger.getLogger().w("Could not synthesize final native report file for " + file, e);
+        }
+    }
+
+    public final void synthesizeReportFile(File file, List list, long j, boolean z, String str, String str2) {
+        File report;
+        try {
+            CrashlyticsReportJsonTransform crashlyticsReportJsonTransform = TRANSFORM;
+            CrashlyticsReport withEvents = crashlyticsReportJsonTransform.reportFromJson(readTextFile(file)).withSessionEndFields(j, z, str).withAppQualitySessionId(str2).withEvents(list);
+            CrashlyticsReport.Session session = withEvents.getSession();
+            if (session == null) {
+                return;
+            }
+            Logger.getLogger().d("appQualitySessionId: " + str2);
+            if (z) {
+                report = this.fileStore.getPriorityReport(session.getIdentifier());
+            } else {
+                report = this.fileStore.getReport(session.getIdentifier());
+            }
+            writeTextFile(report, crashlyticsReportJsonTransform.reportToJson(withEvents));
+        } catch (IOException e) {
+            Logger.getLogger().w("Could not synthesize final report file for " + file, e);
+        }
+    }
+
+    public static boolean isHighPriorityEventFile(String str) {
+        return str.startsWith(NotificationCompat.CATEGORY_EVENT) && str.endsWith("_");
+    }
+
+    public static boolean isNormalPriorityEventFile(File file, String str) {
+        return str.startsWith(NotificationCompat.CATEGORY_EVENT) && !str.endsWith("_");
+    }
+
+    public static String generateEventFilename(int i, boolean z) {
+        return NotificationCompat.CATEGORY_EVENT + String.format(Locale.US, "%010d", Integer.valueOf(i)) + (z ? "_" : "");
+    }
+
+    public final int trimEvents(String str, int i) {
+        List sessionFiles = this.fileStore.getSessionFiles(str, new FilenameFilter() { // from class: com.google.firebase.crashlytics.internal.persistence.CrashlyticsReportPersistence$$ExternalSyntheticLambda0
+            @Override // java.io.FilenameFilter
+            public final boolean accept(File file, String str2) {
+                boolean isNormalPriorityEventFile;
+                isNormalPriorityEventFile = CrashlyticsReportPersistence.isNormalPriorityEventFile(file, str2);
+                return isNormalPriorityEventFile;
+            }
+        });
+        Collections.sort(sessionFiles, new Comparator() { // from class: com.google.firebase.crashlytics.internal.persistence.CrashlyticsReportPersistence$$ExternalSyntheticLambda1
+            @Override // java.util.Comparator
+            public final int compare(Object obj, Object obj2) {
+                int oldestEventFileFirst;
+                oldestEventFileFirst = CrashlyticsReportPersistence.oldestEventFileFirst((File) obj, (File) obj2);
+                return oldestEventFileFirst;
+            }
+        });
+        return capFilesCount(sessionFiles, i);
+    }
+
+    public static String getEventNameWithoutPriority(String str) {
+        return str.substring(0, EVENT_NAME_LENGTH);
+    }
+
+    public static int oldestEventFileFirst(File file, File file2) {
+        return getEventNameWithoutPriority(file.getName()).compareTo(getEventNameWithoutPriority(file2.getName()));
+    }
+
+    public static void writeTextFile(File file, String str) {
+        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream(file), UTF_8);
+        try {
+            outputStreamWriter.write(str);
+            outputStreamWriter.close();
+        } catch (Throwable th) {
+            try {
+                outputStreamWriter.close();
+            } catch (Throwable th2) {
+                th.addSuppressed(th2);
+            }
+            throw th;
+        }
+    }
+
+    public static void writeTextFile(File file, String str, long j) {
+        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream(file), UTF_8);
+        try {
+            outputStreamWriter.write(str);
+            file.setLastModified(convertTimestampFromSecondsToMs(j));
+            outputStreamWriter.close();
+        } catch (Throwable th) {
+            try {
+                outputStreamWriter.close();
+            } catch (Throwable th2) {
+                th.addSuppressed(th2);
+            }
+            throw th;
+        }
+    }
+
+    public static String readTextFile(File file) {
+        byte[] bArr = new byte[8192];
+        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+        FileInputStream fileInputStream = new FileInputStream(file);
+        while (true) {
+            try {
+                int read = fileInputStream.read(bArr);
+                if (read > 0) {
+                    byteArrayOutputStream.write(bArr, 0, read);
+                } else {
+                    String str = new String(byteArrayOutputStream.toByteArray(), UTF_8);
+                    fileInputStream.close();
+                    return str;
+                }
+            } catch (Throwable th) {
+                try {
+                    fileInputStream.close();
+                } catch (Throwable th2) {
+                    th.addSuppressed(th2);
+                }
+                throw th;
+            }
+        }
+    }
+
+    public static int capFilesCount(List list, int i) {
+        int size = list.size();
+        Iterator it = list.iterator();
+        while (it.hasNext()) {
+            File file = (File) it.next();
+            if (size <= i) {
+                return size;
+            }
+            FileStore.recursiveDelete(file);
+            size--;
+        }
+        return size;
+    }
+}

decompiled/sources/com/google/firebase/crashlytics/internal/persistence/FileStore.java

@@ -0,0 +1,161 @@
+package com.google.firebase.crashlytics.internal.persistence;
+
+import android.app.Application;
+import android.content.Context;
+import android.os.Build;
+import com.google.firebase.crashlytics.internal.Logger;
+import java.io.File;
+import java.io.FilenameFilter;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+/* loaded from: classes3.dex */
+public class FileStore {
+    public final File crashlyticsDir;
+    public final File filesDir;
+    public final File nativeReportsDir;
+    public final File priorityReportsDir;
+    public final File reportsDir;
+    public final File sessionsDir;
+
+    public static boolean useV2FileSystem() {
+        return Build.VERSION.SDK_INT >= 28;
+    }
+
+    public FileStore(Context context) {
+        String str;
+        String processName;
+        File filesDir = context.getFilesDir();
+        this.filesDir = filesDir;
+        if (useV2FileSystem()) {
+            StringBuilder sb = new StringBuilder();
+            sb.append(".com.google.firebase.crashlytics.files.v2");
+            sb.append(File.pathSeparator);
+            processName = Application.getProcessName();
+            sb.append(sanitizeName(processName));
+            str = sb.toString();
+        } else {
+            str = ".com.google.firebase.crashlytics.files.v1";
+        }
+        File prepareBaseDir = prepareBaseDir(new File(filesDir, str));
+        this.crashlyticsDir = prepareBaseDir;
+        this.sessionsDir = prepareBaseDir(new File(prepareBaseDir, "open-sessions"));
+        this.reportsDir = prepareBaseDir(new File(prepareBaseDir, "reports"));
+        this.priorityReportsDir = prepareBaseDir(new File(prepareBaseDir, "priority-reports"));
+        this.nativeReportsDir = prepareBaseDir(new File(prepareBaseDir, "native-reports"));
+    }
+
+    public void cleanupPreviousFileSystems() {
+        cleanupDir(new File(this.filesDir, ".com.google.firebase.crashlytics"));
+        cleanupDir(new File(this.filesDir, ".com.google.firebase.crashlytics-ndk"));
+        if (useV2FileSystem()) {
+            cleanupDir(new File(this.filesDir, ".com.google.firebase.crashlytics.files.v1"));
+        }
+    }
+
+    public final void cleanupDir(File file) {
+        if (file.exists() && recursiveDelete(file)) {
+            Logger.getLogger().d("Deleted previous Crashlytics file system: " + file.getPath());
+        }
+    }
+
+    public static boolean recursiveDelete(File file) {
+        File[] listFiles = file.listFiles();
+        if (listFiles != null) {
+            for (File file2 : listFiles) {
+                recursiveDelete(file2);
+            }
+        }
+        return file.delete();
+    }
+
+    public File getCommonFile(String str) {
+        return new File(this.crashlyticsDir, str);
+    }
+
+    public List getCommonFiles(FilenameFilter filenameFilter) {
+        return safeArrayToList(this.crashlyticsDir.listFiles(filenameFilter));
+    }
+
+    public final File getSessionDir(String str) {
+        return prepareDir(new File(this.sessionsDir, str));
+    }
+
+    public File getSessionFile(String str, String str2) {
+        return new File(getSessionDir(str), str2);
+    }
+
+    public List getSessionFiles(String str, FilenameFilter filenameFilter) {
+        return safeArrayToList(getSessionDir(str).listFiles(filenameFilter));
+    }
+
+    public File getNativeSessionDir(String str) {
+        return prepareDir(new File(getSessionDir(str), "native"));
+    }
+
+    public boolean deleteSessionFiles(String str) {
+        return recursiveDelete(new File(this.sessionsDir, str));
+    }
+
+    public List getAllOpenSessionIds() {
+        return safeArrayToList(this.sessionsDir.list());
+    }
+
+    public File getReport(String str) {
+        return new File(this.reportsDir, str);
+    }
+
+    public List getReports() {
+        return safeArrayToList(this.reportsDir.listFiles());
+    }
+
+    public File getPriorityReport(String str) {
+        return new File(this.priorityReportsDir, str);
+    }
+
+    public List getPriorityReports() {
+        return safeArrayToList(this.priorityReportsDir.listFiles());
+    }
+
+    public File getNativeReport(String str) {
+        return new File(this.nativeReportsDir, str);
+    }
+
+    public List getNativeReports() {
+        return safeArrayToList(this.nativeReportsDir.listFiles());
+    }
+
+    public static File prepareDir(File file) {
+        file.mkdirs();
+        return file;
+    }
+
+    public static synchronized File prepareBaseDir(File file) {
+        synchronized (FileStore.class) {
+            try {
+                if (file.exists()) {
+                    if (file.isDirectory()) {
+                        return file;
+                    }
+                    Logger.getLogger().d("Unexpected non-directory file: " + file + "; deleting file and creating new directory.");
+                    file.delete();
+                }
+                if (!file.mkdirs()) {
+                    Logger.getLogger().e("Could not create Crashlytics-specific directory: " + file);
+                }
+                return file;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public static List safeArrayToList(Object[] objArr) {
+        return objArr == null ? Collections.emptyList() : Arrays.asList(objArr);
+    }
+
+    public static String sanitizeName(String str) {
+        return str.replaceAll("[^a-zA-Z0-9.]", "_");
+    }
+}