Primer paso de la investigacion. Se aportan el .apk, las carpetas con el apk extraido y el apk descompilado. El archivo API_DOCUMENTATION.md es un archivo donde se anotaran los descubrimientos del funcionamiento de la API, y los .py son scripts para probar la funcionalidad de la API con los métodos que vayamos encontrando. Finalmente, los archivos .js son scripts de Frida para extraer informacion de la APP durante la ejecucion.

apk_decompiled/sources/com/google/firebase/crashlytics/internal/common/AppData.java

@@ -0,0 +1,46 @@
+package com.google.firebase.crashlytics.internal.common;
+
+import android.content.Context;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import com.google.firebase.crashlytics.internal.DevelopmentPlatformProvider;
+import java.util.List;
+
+/* loaded from: classes3.dex */
+public class AppData {
+    public final String buildId;
+    public final List<BuildIdInfo> buildIdInfoList;
+    public final DevelopmentPlatformProvider developmentPlatformProvider;
+    public final String googleAppId;
+    public final String installerPackageName;
+    public final String packageName;
+    public final String versionCode;
+    public final String versionName;
+
+    public AppData(String str, String str2, List<BuildIdInfo> list, String str3, String str4, String str5, String str6, DevelopmentPlatformProvider developmentPlatformProvider) {
+        this.googleAppId = str;
+        this.buildId = str2;
+        this.buildIdInfoList = list;
+        this.installerPackageName = str3;
+        this.packageName = str4;
+        this.versionCode = str5;
+        this.versionName = str6;
+        this.developmentPlatformProvider = developmentPlatformProvider;
+    }
+
+    public static AppData create(Context context, IdManager idManager, String str, String str2, List<BuildIdInfo> list, DevelopmentPlatformProvider developmentPlatformProvider) throws PackageManager.NameNotFoundException {
+        String packageName = context.getPackageName();
+        String installerPackageName = idManager.getInstallerPackageName();
+        PackageInfo packageInfo = context.getPackageManager().getPackageInfo(packageName, 0);
+        String appBuildVersion = getAppBuildVersion(packageInfo);
+        String str3 = packageInfo.versionName;
+        if (str3 == null) {
+            str3 = IdManager.DEFAULT_VERSION_NAME;
+        }
+        return new AppData(str, str2, list, installerPackageName, packageName, appBuildVersion, str3, developmentPlatformProvider);
+    }
+
+    private static String getAppBuildVersion(PackageInfo packageInfo) {
+        return Long.toString(packageInfo.getLongVersionCode());
+    }
+}

apk_decompiled/sources/com/google/firebase/crashlytics/internal/common/AutoValue_CrashlyticsReportWithSessionId.java

@@ -0,0 +1,63 @@
+package com.google.firebase.crashlytics.internal.common;
+
+import com.google.firebase.crashlytics.internal.model.CrashlyticsReport;
+import java.io.File;
+
+/* JADX INFO: Access modifiers changed from: package-private */
+/* loaded from: classes3.dex */
+public final class AutoValue_CrashlyticsReportWithSessionId extends CrashlyticsReportWithSessionId {
+    private final CrashlyticsReport report;
+    private final File reportFile;
+    private final String sessionId;
+
+    public AutoValue_CrashlyticsReportWithSessionId(CrashlyticsReport crashlyticsReport, String str, File file) {
+        if (crashlyticsReport == null) {
+            throw new NullPointerException("Null report");
+        }
+        this.report = crashlyticsReport;
+        if (str == null) {
+            throw new NullPointerException("Null sessionId");
+        }
+        this.sessionId = str;
+        if (file == null) {
+            throw new NullPointerException("Null reportFile");
+        }
+        this.reportFile = file;
+    }
+
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (obj instanceof CrashlyticsReportWithSessionId) {
+            CrashlyticsReportWithSessionId crashlyticsReportWithSessionId = (CrashlyticsReportWithSessionId) obj;
+            if (this.report.equals(crashlyticsReportWithSessionId.getReport()) && this.sessionId.equals(crashlyticsReportWithSessionId.getSessionId()) && this.reportFile.equals(crashlyticsReportWithSessionId.getReportFile())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override // com.google.firebase.crashlytics.internal.common.CrashlyticsReportWithSessionId
+    public CrashlyticsReport getReport() {
+        return this.report;
+    }
+
+    @Override // com.google.firebase.crashlytics.internal.common.CrashlyticsReportWithSessionId
+    public File getReportFile() {
+        return this.reportFile;
+    }
+
+    @Override // com.google.firebase.crashlytics.internal.common.CrashlyticsReportWithSessionId
+    public String getSessionId() {
+        return this.sessionId;
+    }
+
+    public int hashCode() {
+        return this.reportFile.hashCode() ^ ((((this.report.hashCode() ^ 1000003) * 1000003) ^ this.sessionId.hashCode()) * 1000003);
+    }
+
+    public String toString() {
+        return "CrashlyticsReportWithSessionId{report=" + this.report + ", sessionId=" + this.sessionId + ", reportFile=" + this.reportFile + "}";
+    }
+}

apk_decompiled/sources/com/google/firebase/crashlytics/internal/common/AutoValue_InstallIdProvider_InstallIds.java

@@ -0,0 +1,55 @@
+package com.google.firebase.crashlytics.internal.common;
+
+import C.w;
+import com.google.firebase.crashlytics.internal.common.InstallIdProvider;
+
+/* loaded from: classes3.dex */
+final class AutoValue_InstallIdProvider_InstallIds extends InstallIdProvider.InstallIds {
+    private final String crashlyticsInstallId;
+    private final String firebaseInstallationId;
+
+    public AutoValue_InstallIdProvider_InstallIds(String str, String str2) {
+        if (str == null) {
+            throw new NullPointerException("Null crashlyticsInstallId");
+        }
+        this.crashlyticsInstallId = str;
+        this.firebaseInstallationId = str2;
+    }
+
+    public boolean equals(Object obj) {
+        String str;
+        if (obj == this) {
+            return true;
+        }
+        if (obj instanceof InstallIdProvider.InstallIds) {
+            InstallIdProvider.InstallIds installIds = (InstallIdProvider.InstallIds) obj;
+            if (this.crashlyticsInstallId.equals(installIds.getCrashlyticsInstallId()) && ((str = this.firebaseInstallationId) != null ? str.equals(installIds.getFirebaseInstallationId()) : installIds.getFirebaseInstallationId() == null)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override // com.google.firebase.crashlytics.internal.common.InstallIdProvider.InstallIds
+    public String getCrashlyticsInstallId() {
+        return this.crashlyticsInstallId;
+    }
+
+    @Override // com.google.firebase.crashlytics.internal.common.InstallIdProvider.InstallIds
+    public String getFirebaseInstallationId() {
+        return this.firebaseInstallationId;
+    }
+
+    public int hashCode() {
+        int hashCode = (this.crashlyticsInstallId.hashCode() ^ 1000003) * 1000003;
+        String str = this.firebaseInstallationId;
+        return (str == null ? 0 : str.hashCode()) ^ hashCode;
+    }
+
+    public String toString() {
+        StringBuilder sb = new StringBuilder("InstallIds{crashlyticsInstallId=");
+        sb.append(this.crashlyticsInstallId);
+        sb.append(", firebaseInstallationId=");
+        return w.r(sb, this.firebaseInstallationId, "}");
+    }
+}

apk_decompiled/sources/com/google/firebase/crashlytics/internal/common/BackgroundPriorityRunnable.java

@@ -0,0 +1,14 @@
+package com.google.firebase.crashlytics.internal.common;
+
+import android.os.Process;
+
+/* loaded from: classes3.dex */
+public abstract class BackgroundPriorityRunnable implements Runnable {
+    public abstract void onRun();
+
+    @Override // java.lang.Runnable
+    public final void run() {
+        Process.setThreadPriority(10);
+        onRun();
+    }
+}

apk_decompiled/sources/com/google/firebase/crashlytics/internal/common/BatteryState.java

@@ -0,0 +1,69 @@
+package com.google.firebase.crashlytics.internal.common;
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import com.google.firebase.analytics.FirebaseAnalytics;
+import com.google.firebase.crashlytics.internal.Logger;
+
+/* loaded from: classes3.dex */
+class BatteryState {
+    static final int VELOCITY_CHARGING = 2;
+    static final int VELOCITY_FULL = 3;
+    static final int VELOCITY_UNPLUGGED = 1;
+    private final Float level;
+    private final boolean powerConnected;
+
+    private BatteryState(Float f2, boolean z3) {
+        this.powerConnected = z3;
+        this.level = f2;
+    }
+
+    public static BatteryState get(Context context) {
+        boolean z3 = false;
+        Float f2 = null;
+        try {
+            Intent registerReceiver = context.registerReceiver(null, new IntentFilter("android.intent.action.BATTERY_CHANGED"));
+            if (registerReceiver != null) {
+                z3 = isPowerConnected(registerReceiver);
+                f2 = getLevel(registerReceiver);
+            }
+        } catch (IllegalStateException e4) {
+            Logger.getLogger().e("An error occurred getting battery state.", e4);
+        }
+        return new BatteryState(f2, z3);
+    }
+
+    private static Float getLevel(Intent intent) {
+        int intExtra = intent.getIntExtra(FirebaseAnalytics.Param.LEVEL, -1);
+        int intExtra2 = intent.getIntExtra("scale", -1);
+        if (intExtra == -1 || intExtra2 == -1) {
+            return null;
+        }
+        return Float.valueOf(intExtra / intExtra2);
+    }
+
+    public Float getBatteryLevel() {
+        return this.level;
+    }
+
+    public int getBatteryVelocity() {
+        Float f2;
+        if (!this.powerConnected || (f2 = this.level) == null) {
+            return 1;
+        }
+        return ((double) f2.floatValue()) < 0.99d ? 2 : 3;
+    }
+
+    public boolean isPowerConnected() {
+        return this.powerConnected;
+    }
+
+    private static boolean isPowerConnected(Intent intent) {
+        int intExtra = intent.getIntExtra("status", -1);
+        if (intExtra == -1) {
+            return false;
+        }
+        return intExtra == 2 || intExtra == 5;
+    }
+}

apk_decompiled/sources/com/google/firebase/crashlytics/internal/common/BuildIdInfo.java

@@ -0,0 +1,26 @@
+package com.google.firebase.crashlytics.internal.common;
+
+/* loaded from: classes3.dex */
+public class BuildIdInfo {
+    private final String arch;
+    private final String buildId;
+    private final String libraryName;
+
+    public BuildIdInfo(String str, String str2, String str3) {
+        this.libraryName = str;
+        this.arch = str2;
+        this.buildId = str3;
+    }
+
+    public String getArch() {
+        return this.arch;
+    }
+
+    public String getBuildId() {
+        return this.buildId;
+    }
+
+    public String getLibraryName() {
+        return this.libraryName;
+    }
+}

apk_decompiled/sources/com/google/firebase/crashlytics/internal/common/BytesBackedNativeSessionFile.java

@@ -0,0 +1,79 @@
+package com.google.firebase.crashlytics.internal.common;
+
+import com.google.firebase.crashlytics.internal.model.CrashlyticsReport;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.zip.GZIPOutputStream;
+
+/* JADX INFO: Access modifiers changed from: package-private */
+/* loaded from: classes3.dex */
+public class BytesBackedNativeSessionFile implements NativeSessionFile {
+    private final byte[] bytes;
+    private final String dataTransportFilename;
+    private final String reportsEndpointFilename;
+
+    public BytesBackedNativeSessionFile(String str, String str2, byte[] bArr) {
+        this.dataTransportFilename = str;
+        this.reportsEndpointFilename = str2;
+        this.bytes = bArr;
+    }
+
+    private byte[] asGzippedBytes() {
+        if (isEmpty()) {
+            return null;
+        }
+        try {
+            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+            try {
+                GZIPOutputStream gZIPOutputStream = new GZIPOutputStream(byteArrayOutputStream);
+                try {
+                    gZIPOutputStream.write(this.bytes);
+                    gZIPOutputStream.finish();
+                    byte[] byteArray = byteArrayOutputStream.toByteArray();
+                    gZIPOutputStream.close();
+                    byteArrayOutputStream.close();
+                    return byteArray;
+                } finally {
+                }
+            } catch (Throwable th) {
+                try {
+                    byteArrayOutputStream.close();
+                } catch (Throwable th2) {
+                    th.addSuppressed(th2);
+                }
+                throw th;
+            }
+        } catch (IOException unused) {
+            return null;
+        }
+    }
+
+    private boolean isEmpty() {
+        byte[] bArr = this.bytes;
+        return bArr == null || bArr.length == 0;
+    }
+
+    @Override // com.google.firebase.crashlytics.internal.common.NativeSessionFile
+    public CrashlyticsReport.FilesPayload.File asFilePayload() {
+        byte[] asGzippedBytes = asGzippedBytes();
+        if (asGzippedBytes == null) {
+            return null;
+        }
+        return CrashlyticsReport.FilesPayload.File.builder().setContents(asGzippedBytes).setFilename(this.dataTransportFilename).build();
+    }
+
+    @Override // com.google.firebase.crashlytics.internal.common.NativeSessionFile
+    public String getReportsEndpointFilename() {
+        return this.reportsEndpointFilename;
+    }
+
+    @Override // com.google.firebase.crashlytics.internal.common.NativeSessionFile
+    public InputStream getStream() {
+        if (isEmpty()) {
+            return null;
+        }
+        return new ByteArrayInputStream(this.bytes);
+    }
+}

apk_decompiled/sources/com/google/firebase/crashlytics/internal/common/CLSUUID.java

@@ -0,0 +1,70 @@
+package com.google.firebase.crashlytics.internal.common;
+
+import android.os.Process;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.Date;
+import java.util.Locale;
+import java.util.concurrent.atomic.AtomicLong;
+
+/* JADX INFO: Access modifiers changed from: package-private */
+/* loaded from: classes3.dex */
+public class CLSUUID {
+    private static String _clsId;
+    private static final AtomicLong _sequenceNumber = new AtomicLong(0);
+
+    public CLSUUID(IdManager idManager) {
+        byte[] bArr = new byte[10];
+        populateTime(bArr);
+        populateSequenceNumber(bArr);
+        populatePID(bArr);
+        String sha1 = CommonUtils.sha1(idManager.getInstallIds().getCrashlyticsInstallId());
+        String hexify = CommonUtils.hexify(bArr);
+        Locale locale = Locale.US;
+        _clsId = String.format(locale, "%s%s%s%s", hexify.substring(0, 12), hexify.substring(12, 16), hexify.subSequence(16, 20), sha1.substring(0, 12)).toUpperCase(locale);
+    }
+
+    private static byte[] convertLongToFourByteBuffer(long j4) {
+        ByteBuffer allocate = ByteBuffer.allocate(4);
+        allocate.putInt((int) j4);
+        allocate.order(ByteOrder.BIG_ENDIAN);
+        allocate.position(0);
+        return allocate.array();
+    }
+
+    private static byte[] convertLongToTwoByteBuffer(long j4) {
+        ByteBuffer allocate = ByteBuffer.allocate(2);
+        allocate.putShort((short) j4);
+        allocate.order(ByteOrder.BIG_ENDIAN);
+        allocate.position(0);
+        return allocate.array();
+    }
+
+    private void populatePID(byte[] bArr) {
+        byte[] convertLongToTwoByteBuffer = convertLongToTwoByteBuffer(Integer.valueOf(Process.myPid()).shortValue());
+        bArr[8] = convertLongToTwoByteBuffer[0];
+        bArr[9] = convertLongToTwoByteBuffer[1];
+    }
+
+    private void populateSequenceNumber(byte[] bArr) {
+        byte[] convertLongToTwoByteBuffer = convertLongToTwoByteBuffer(_sequenceNumber.incrementAndGet());
+        bArr[6] = convertLongToTwoByteBuffer[0];
+        bArr[7] = convertLongToTwoByteBuffer[1];
+    }
+
+    private void populateTime(byte[] bArr) {
+        long time = new Date().getTime();
+        byte[] convertLongToFourByteBuffer = convertLongToFourByteBuffer(time / 1000);
+        bArr[0] = convertLongToFourByteBuffer[0];
+        bArr[1] = convertLongToFourByteBuffer[1];
+        bArr[2] = convertLongToFourByteBuffer[2];
+        bArr[3] = convertLongToFourByteBuffer[3];
+        byte[] convertLongToTwoByteBuffer = convertLongToTwoByteBuffer(time % 1000);
+        bArr[4] = convertLongToTwoByteBuffer[0];
+        bArr[5] = convertLongToTwoByteBuffer[1];
+    }
+
+    public String toString() {
+        return _clsId;
+    }
+}

apk_decompiled/sources/com/google/firebase/crashlytics/internal/common/CommonUtils.java

@@ -0,0 +1,340 @@
+package com.google.firebase.crashlytics.internal.common;
+
+import android.annotation.SuppressLint;
+import android.app.ActivityManager;
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.content.res.Resources;
+import android.hardware.SensorManager;
+import android.net.ConnectivityManager;
+import android.net.NetworkInfo;
+import android.os.Build;
+import android.os.Debug;
+import android.os.StatFs;
+import android.text.TextUtils;
+import com.google.firebase.crashlytics.internal.Logger;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Scanner;
+import kotlin.UByte;
+
+/* loaded from: classes3.dex */
+public class CommonUtils {
+    static final String BUILD_IDS_ARCH_RESOURCE_NAME = "com.google.firebase.crashlytics.build_ids_arch";
+    static final String BUILD_IDS_BUILD_ID_RESOURCE_NAME = "com.google.firebase.crashlytics.build_ids_build_id";
+    static final String BUILD_IDS_LIB_NAMES_RESOURCE_NAME = "com.google.firebase.crashlytics.build_ids_lib";
+    public static final int DEVICE_STATE_BETAOS = 8;
+    public static final int DEVICE_STATE_COMPROMISEDLIBRARIES = 32;
+    public static final int DEVICE_STATE_DEBUGGERATTACHED = 4;
+    public static final int DEVICE_STATE_ISSIMULATOR = 1;
+    public static final int DEVICE_STATE_JAILBROKEN = 2;
+    public static final int DEVICE_STATE_VENDORINTERNAL = 16;
+    private static final String GOLDFISH = "goldfish";
+    private static final char[] HEX_VALUES = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
+    static final String LEGACY_MAPPING_FILE_ID_RESOURCE_NAME = "com.crashlytics.android.build_id";
+    public static final String LEGACY_SHARED_PREFS_NAME = "com.crashlytics.prefs";
+    static final String MAPPING_FILE_ID_RESOURCE_NAME = "com.google.firebase.crashlytics.mapping_file_id";
+    private static final String RANCHU = "ranchu";
+    private static final String SDK = "sdk";
+    private static final String SHA1_INSTANCE = "SHA-1";
+    public static final String SHARED_PREFS_NAME = "com.google.firebase.crashlytics";
+
+    /* loaded from: classes3.dex */
+    public enum Architecture {
+        X86_32,
+        X86_64,
+        ARM_UNKNOWN,
+        PPC,
+        PPC64,
+        ARMV6,
+        ARMV7,
+        UNKNOWN,
+        ARMV7S,
+        ARM64;
+
+        private static final Map<String, Architecture> matcher;
+
+        static {
+            Architecture architecture = X86_32;
+            Architecture architecture2 = ARMV6;
+            Architecture architecture3 = ARMV7;
+            Architecture architecture4 = ARM64;
+            HashMap hashMap = new HashMap(4);
+            matcher = hashMap;
+            hashMap.put("armeabi-v7a", architecture3);
+            hashMap.put("armeabi", architecture2);
+            hashMap.put("arm64-v8a", architecture4);
+            hashMap.put("x86", architecture);
+        }
+
+        public static Architecture getValue() {
+            String str = Build.CPU_ABI;
+            if (TextUtils.isEmpty(str)) {
+                Logger.getLogger().v("Architecture#getValue()::Build.CPU_ABI returned null or empty");
+                return UNKNOWN;
+            }
+            Architecture architecture = matcher.get(str.toLowerCase(Locale.US));
+            return architecture == null ? UNKNOWN : architecture;
+        }
+    }
+
+    public static long calculateFreeRamInBytes(Context context) {
+        ActivityManager.MemoryInfo memoryInfo = new ActivityManager.MemoryInfo();
+        ((ActivityManager) context.getSystemService("activity")).getMemoryInfo(memoryInfo);
+        return memoryInfo.availMem;
+    }
+
+    public static synchronized long calculateTotalRamInBytes(Context context) {
+        long j4;
+        synchronized (CommonUtils.class) {
+            ActivityManager.MemoryInfo memoryInfo = new ActivityManager.MemoryInfo();
+            ((ActivityManager) context.getSystemService("activity")).getMemoryInfo(memoryInfo);
+            j4 = memoryInfo.totalMem;
+        }
+        return j4;
+    }
+
+    public static long calculateUsedDiskSpaceInBytes(String str) {
+        long blockSize = new StatFs(str).getBlockSize();
+        return (r0.getBlockCount() * blockSize) - (blockSize * r0.getAvailableBlocks());
+    }
+
+    @SuppressLint({"MissingPermission"})
+    public static boolean canTryConnection(Context context) {
+        if (!checkPermission(context, "android.permission.ACCESS_NETWORK_STATE")) {
+            return true;
+        }
+        NetworkInfo activeNetworkInfo = ((ConnectivityManager) context.getSystemService("connectivity")).getActiveNetworkInfo();
+        return activeNetworkInfo != null && activeNetworkInfo.isConnectedOrConnecting();
+    }
+
+    public static boolean checkPermission(Context context, String str) {
+        return context.checkCallingOrSelfPermission(str) == 0;
+    }
+
+    public static void closeOrLog(Closeable closeable, String str) {
+        if (closeable != null) {
+            try {
+                closeable.close();
+            } catch (IOException e4) {
+                Logger.getLogger().e(str, e4);
+            }
+        }
+    }
+
+    public static void closeQuietly(Closeable closeable) {
+        if (closeable != null) {
+            try {
+                closeable.close();
+            } catch (RuntimeException e4) {
+                throw e4;
+            } catch (Exception unused) {
+            }
+        }
+    }
+
+    public static String createInstanceIdFrom(String... strArr) {
+        if (strArr != null && strArr.length != 0) {
+            ArrayList arrayList = new ArrayList();
+            for (String str : strArr) {
+                if (str != null) {
+                    arrayList.add(str.replace("-", "").toLowerCase(Locale.US));
+                }
+            }
+            Collections.sort(arrayList);
+            StringBuilder sb = new StringBuilder();
+            Iterator it = arrayList.iterator();
+            while (it.hasNext()) {
+                sb.append((String) it.next());
+            }
+            String sb2 = sb.toString();
+            if (sb2.length() > 0) {
+                return sha1(sb2);
+            }
+        }
+        return null;
+    }
+
+    public static boolean getBooleanResourceValue(Context context, String str, boolean z3) {
+        Resources resources;
+        if (context != null && (resources = context.getResources()) != null) {
+            int resourcesIdentifier = getResourcesIdentifier(context, str, "bool");
+            if (resourcesIdentifier > 0) {
+                return resources.getBoolean(resourcesIdentifier);
+            }
+            int resourcesIdentifier2 = getResourcesIdentifier(context, str, "string");
+            if (resourcesIdentifier2 > 0) {
+                return Boolean.parseBoolean(context.getString(resourcesIdentifier2));
+            }
+        }
+        return z3;
+    }
+
+    public static List<BuildIdInfo> getBuildIdInfo(Context context) {
+        ArrayList arrayList = new ArrayList();
+        int resourcesIdentifier = getResourcesIdentifier(context, BUILD_IDS_LIB_NAMES_RESOURCE_NAME, "array");
+        int resourcesIdentifier2 = getResourcesIdentifier(context, BUILD_IDS_ARCH_RESOURCE_NAME, "array");
+        int resourcesIdentifier3 = getResourcesIdentifier(context, BUILD_IDS_BUILD_ID_RESOURCE_NAME, "array");
+        if (resourcesIdentifier == 0 || resourcesIdentifier2 == 0 || resourcesIdentifier3 == 0) {
+            Logger.getLogger().d(String.format("Could not find resources: %d %d %d", Integer.valueOf(resourcesIdentifier), Integer.valueOf(resourcesIdentifier2), Integer.valueOf(resourcesIdentifier3)));
+            return arrayList;
+        }
+        String[] stringArray = context.getResources().getStringArray(resourcesIdentifier);
+        String[] stringArray2 = context.getResources().getStringArray(resourcesIdentifier2);
+        String[] stringArray3 = context.getResources().getStringArray(resourcesIdentifier3);
+        if (stringArray.length != stringArray3.length || stringArray2.length != stringArray3.length) {
+            Logger.getLogger().d(String.format("Lengths did not match: %d %d %d", Integer.valueOf(stringArray.length), Integer.valueOf(stringArray2.length), Integer.valueOf(stringArray3.length)));
+            return arrayList;
+        }
+        for (int i = 0; i < stringArray3.length; i++) {
+            arrayList.add(new BuildIdInfo(stringArray[i], stringArray2[i], stringArray3[i]));
+        }
+        return arrayList;
+    }
+
+    public static int getCpuArchitectureInt() {
+        return Architecture.getValue().ordinal();
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Type inference failed for: r0v1, types: [int] */
+    /* JADX WARN: Type inference failed for: r0v5 */
+    /* JADX WARN: Type inference failed for: r0v6 */
+    public static int getDeviceState() {
+        boolean isEmulator = isEmulator();
+        ?? r02 = isEmulator;
+        if (isRooted()) {
+            r02 = (isEmulator ? 1 : 0) | 2;
+        }
+        return isDebuggerAttached() ? r02 | 4 : r02;
+    }
+
+    public static SharedPreferences getLegacySharedPrefs(Context context) {
+        return context.getSharedPreferences(LEGACY_SHARED_PREFS_NAME, 0);
+    }
+
+    public static String getMappingFileId(Context context) {
+        int resourcesIdentifier = getResourcesIdentifier(context, MAPPING_FILE_ID_RESOURCE_NAME, "string");
+        if (resourcesIdentifier == 0) {
+            resourcesIdentifier = getResourcesIdentifier(context, LEGACY_MAPPING_FILE_ID_RESOURCE_NAME, "string");
+        }
+        if (resourcesIdentifier != 0) {
+            return context.getResources().getString(resourcesIdentifier);
+        }
+        return null;
+    }
+
+    public static boolean getProximitySensorEnabled(Context context) {
+        return (isEmulator() || ((SensorManager) context.getSystemService("sensor")).getDefaultSensor(8) == null) ? false : true;
+    }
+
+    public static String getResourcePackageName(Context context) {
+        int i = context.getApplicationContext().getApplicationInfo().icon;
+        if (i <= 0) {
+            return context.getPackageName();
+        }
+        try {
+            String resourcePackageName = context.getResources().getResourcePackageName(i);
+            return "android".equals(resourcePackageName) ? context.getPackageName() : resourcePackageName;
+        } catch (Resources.NotFoundException unused) {
+            return context.getPackageName();
+        }
+    }
+
+    public static int getResourcesIdentifier(Context context, String str, String str2) {
+        return context.getResources().getIdentifier(str, str2, getResourcePackageName(context));
+    }
+
+    public static SharedPreferences getSharedPrefs(Context context) {
+        return context.getSharedPreferences("com.google.firebase.crashlytics", 0);
+    }
+
+    private static String hash(String str, String str2) {
+        return hash(str.getBytes(), str2);
+    }
+
+    public static String hexify(byte[] bArr) {
+        char[] cArr = new char[bArr.length * 2];
+        for (int i = 0; i < bArr.length; i++) {
+            byte b4 = bArr[i];
+            int i4 = b4 & UByte.MAX_VALUE;
+            int i5 = i * 2;
+            char[] cArr2 = HEX_VALUES;
+            cArr[i5] = cArr2[i4 >>> 4];
+            cArr[i5 + 1] = cArr2[b4 & 15];
+        }
+        return new String(cArr);
+    }
+
+    public static boolean isAppDebuggable(Context context) {
+        return (context.getApplicationInfo().flags & 2) != 0;
+    }
+
+    public static boolean isDebuggerAttached() {
+        return Debug.isDebuggerConnected() || Debug.waitingForDebugger();
+    }
+
+    public static boolean isEmulator() {
+        if (Build.PRODUCT.contains(SDK)) {
+            return true;
+        }
+        String str = Build.HARDWARE;
+        return str.contains(GOLDFISH) || str.contains(RANCHU);
+    }
+
+    @Deprecated
+    public static boolean isLoggingEnabled(Context context) {
+        return false;
+    }
+
+    public static boolean isRooted() {
+        boolean isEmulator = isEmulator();
+        String str = Build.TAGS;
+        if ((isEmulator || str == null || !str.contains("test-keys")) && !new File("/system/app/Superuser.apk").exists()) {
+            return !isEmulator && new File("/system/xbin/su").exists();
+        }
+        return true;
+    }
+
+    public static boolean nullSafeEquals(String str, String str2) {
+        return str == null ? str2 == null : str.equals(str2);
+    }
+
+    public static String padWithZerosToMaxIntWidth(int i) {
+        if (i >= 0) {
+            return String.format(Locale.US, "%1$10s", Integer.valueOf(i)).replace(' ', '0');
+        }
+        throw new IllegalArgumentException("value must be zero or greater");
+    }
+
+    public static String sha1(String str) {
+        return hash(str, SHA1_INSTANCE);
+    }
+
+    public static String streamToString(InputStream inputStream) {
+        Scanner useDelimiter = new Scanner(inputStream).useDelimiter("\\A");
+        return useDelimiter.hasNext() ? useDelimiter.next() : "";
+    }
+
+    private static String hash(byte[] bArr, String str) {
+        try {
+            MessageDigest messageDigest = MessageDigest.getInstance(str);
+            messageDigest.update(bArr);
+            return hexify(messageDigest.digest());
+        } catch (NoSuchAlgorithmException e4) {
+            Logger.getLogger().e("Could not create hashing algorithm: " + str + ", returning empty string.", e4);
+            return "";
+        }
+    }
+}

apk_decompiled/sources/com/google/firebase/crashlytics/internal/common/CrashlyticsAppQualitySessionsStore.java

@@ -0,0 +1,74 @@
+package com.google.firebase.crashlytics.internal.common;
+
+import com.google.firebase.crashlytics.internal.Logger;
+import com.google.firebase.crashlytics.internal.persistence.FileStore;
+import java.io.File;
+import java.io.FilenameFilter;
+import java.io.IOException;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Objects;
+
+/* loaded from: classes3.dex */
+public class CrashlyticsAppQualitySessionsStore {
+    private static final String AQS_SESSION_ID_FILENAME_PREFIX = "aqs.";
+    private static final FilenameFilter AQS_SESSION_ID_FILE_FILTER = new a(0);
+    private static final Comparator<File> FILE_RECENCY_COMPARATOR = new b(0);
+    private final FileStore fileStore;
+    private String sessionId = null;
+    private String appQualitySessionId = null;
+
+    public CrashlyticsAppQualitySessionsStore(FileStore fileStore) {
+        this.fileStore = fileStore;
+    }
+
+    public static /* synthetic */ boolean lambda$static$0(File file, String str) {
+        return str.startsWith(AQS_SESSION_ID_FILENAME_PREFIX);
+    }
+
+    public static /* synthetic */ int lambda$static$1(File file, File file2) {
+        return Long.compare(file2.lastModified(), file.lastModified());
+    }
+
+    private static void persist(FileStore fileStore, String str, String str2) {
+        if (str == null || str2 == null) {
+            return;
+        }
+        try {
+            fileStore.getSessionFile(str, AQS_SESSION_ID_FILENAME_PREFIX.concat(str2)).createNewFile();
+        } catch (IOException e4) {
+            Logger.getLogger().w("Failed to persist App Quality Sessions session id.", e4);
+        }
+    }
+
+    public static String readAqsSessionIdFile(FileStore fileStore, String str) {
+        List<File> sessionFiles = fileStore.getSessionFiles(str, AQS_SESSION_ID_FILE_FILTER);
+        if (!sessionFiles.isEmpty()) {
+            return ((File) Collections.min(sessionFiles, FILE_RECENCY_COMPARATOR)).getName().substring(4);
+        }
+        Logger.getLogger().w("Unable to read App Quality Sessions session id.");
+        return null;
+    }
+
+    public synchronized String getAppQualitySessionId(String str) {
+        if (Objects.equals(this.sessionId, str)) {
+            return this.appQualitySessionId;
+        }
+        return readAqsSessionIdFile(this.fileStore, str);
+    }
+
+    public synchronized void rotateAppQualitySessionId(String str) {
+        if (!Objects.equals(this.appQualitySessionId, str)) {
+            persist(this.fileStore, this.sessionId, str);
+            this.appQualitySessionId = str;
+        }
+    }
+
+    public synchronized void rotateSessionId(String str) {
+        if (!Objects.equals(this.sessionId, str)) {
+            persist(this.fileStore, str, this.appQualitySessionId);
+            this.sessionId = str;
+        }
+    }
+}

apk_decompiled/sources/com/google/firebase/crashlytics/internal/common/CrashlyticsAppQualitySessionsSubscriber.java

@@ -0,0 +1,40 @@
+package com.google.firebase.crashlytics.internal.common;
+
+import com.google.firebase.crashlytics.internal.Logger;
+import com.google.firebase.crashlytics.internal.persistence.FileStore;
+import com.google.firebase.sessions.api.SessionSubscriber;
+
+/* loaded from: classes3.dex */
+public class CrashlyticsAppQualitySessionsSubscriber implements SessionSubscriber {
+    private final CrashlyticsAppQualitySessionsStore appQualitySessionsStore;
+    private final DataCollectionArbiter dataCollectionArbiter;
+
+    public CrashlyticsAppQualitySessionsSubscriber(DataCollectionArbiter dataCollectionArbiter, FileStore fileStore) {
+        this.dataCollectionArbiter = dataCollectionArbiter;
+        this.appQualitySessionsStore = new CrashlyticsAppQualitySessionsStore(fileStore);
+    }
+
+    public String getAppQualitySessionId(String str) {
+        return this.appQualitySessionsStore.getAppQualitySessionId(str);
+    }
+
+    @Override // com.google.firebase.sessions.api.SessionSubscriber
+    public SessionSubscriber.Name getSessionSubscriberName() {
+        return SessionSubscriber.Name.CRASHLYTICS;
+    }
+
+    @Override // com.google.firebase.sessions.api.SessionSubscriber
+    public boolean isDataCollectionEnabled() {
+        return this.dataCollectionArbiter.isAutomaticDataCollectionEnabled();
+    }
+
+    @Override // com.google.firebase.sessions.api.SessionSubscriber
+    public void onSessionChanged(SessionSubscriber.SessionDetails sessionDetails) {
+        Logger.getLogger().d("App Quality Sessions session changed: " + sessionDetails);
+        this.appQualitySessionsStore.rotateAppQualitySessionId(sessionDetails.getSessionId());
+    }
+
+    public void setSessionId(String str) {
+        this.appQualitySessionsStore.rotateSessionId(str);
+    }
+}

apk_decompiled/sources/com/google/firebase/crashlytics/internal/common/CrashlyticsBackgroundWorker.java

@@ -0,0 +1,85 @@
+package com.google.firebase.crashlytics.internal.common;
+
+import com.google.android.gms.tasks.Continuation;
+import com.google.android.gms.tasks.Task;
+import com.google.android.gms.tasks.Tasks;
+import java.util.concurrent.Callable;
+import java.util.concurrent.Executor;
+
+/* loaded from: classes3.dex */
+public class CrashlyticsBackgroundWorker {
+    private final Executor executor;
+    private Task<Void> tail = Tasks.forResult(null);
+    private final Object tailLock = new Object();
+    private final ThreadLocal<Boolean> isExecutorThread = new ThreadLocal<>();
+
+    public CrashlyticsBackgroundWorker(Executor executor) {
+        this.executor = executor;
+        executor.execute(new Runnable() { // from class: com.google.firebase.crashlytics.internal.common.CrashlyticsBackgroundWorker.1
+            @Override // java.lang.Runnable
+            public void run() {
+                CrashlyticsBackgroundWorker.this.isExecutorThread.set(Boolean.TRUE);
+            }
+        });
+    }
+
+    private <T> Task<Void> ignoreResult(Task<T> task) {
+        return task.continueWith(this.executor, new Continuation<T, Void>() { // from class: com.google.firebase.crashlytics.internal.common.CrashlyticsBackgroundWorker.4
+            @Override // com.google.android.gms.tasks.Continuation
+            public Void then(Task<T> task2) throws Exception {
+                return null;
+            }
+        });
+    }
+
+    private boolean isRunningOnThread() {
+        return Boolean.TRUE.equals(this.isExecutorThread.get());
+    }
+
+    private <T> Continuation<Void, T> newContinuation(final Callable<T> callable) {
+        return new Continuation<Void, T>() { // from class: com.google.firebase.crashlytics.internal.common.CrashlyticsBackgroundWorker.3
+            @Override // com.google.android.gms.tasks.Continuation
+            public T then(Task<Void> task) throws Exception {
+                return (T) callable.call();
+            }
+        };
+    }
+
+    public void checkRunningOnThread() {
+        if (!isRunningOnThread()) {
+            throw new IllegalStateException("Not running on background worker thread as intended.");
+        }
+    }
+
+    public Executor getExecutor() {
+        return this.executor;
+    }
+
+    public Task<Void> submit(final Runnable runnable) {
+        return submit(new Callable<Void>() { // from class: com.google.firebase.crashlytics.internal.common.CrashlyticsBackgroundWorker.2
+            @Override // java.util.concurrent.Callable
+            public Void call() throws Exception {
+                runnable.run();
+                return null;
+            }
+        });
+    }
+
+    public <T> Task<T> submitTask(Callable<Task<T>> callable) {
+        Task<T> continueWithTask;
+        synchronized (this.tailLock) {
+            continueWithTask = this.tail.continueWithTask(this.executor, newContinuation(callable));
+            this.tail = ignoreResult(continueWithTask);
+        }
+        return continueWithTask;
+    }
+
+    public <T> Task<T> submit(Callable<T> callable) {
+        Task<T> continueWith;
+        synchronized (this.tailLock) {
+            continueWith = this.tail.continueWith(this.executor, newContinuation(callable));
+            this.tail = ignoreResult(continueWith);
+        }
+        return continueWith;
+    }
+}

apk_decompiled/sources/com/google/firebase/crashlytics/internal/common/CrashlyticsController.java

@@ -0,0 +1,996 @@
+package com.google.firebase.crashlytics.internal.common;
+
+import C.w;
+import android.annotation.SuppressLint;
+import android.app.ActivityManager;
+import android.app.ApplicationExitInfo;
+import android.content.Context;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.Environment;
+import android.os.StatFs;
+import android.util.Base64;
+import com.google.android.gms.tasks.SuccessContinuation;
+import com.google.android.gms.tasks.Task;
+import com.google.android.gms.tasks.TaskCompletionSource;
+import com.google.android.gms.tasks.Tasks;
+import com.google.firebase.crashlytics.internal.CrashlyticsNativeComponent;
+import com.google.firebase.crashlytics.internal.Logger;
+import com.google.firebase.crashlytics.internal.NativeSessionFileProvider;
+import com.google.firebase.crashlytics.internal.analytics.AnalyticsEventLogger;
+import com.google.firebase.crashlytics.internal.common.CrashlyticsUncaughtExceptionHandler;
+import com.google.firebase.crashlytics.internal.metadata.LogFileManager;
+import com.google.firebase.crashlytics.internal.metadata.UserMetadata;
+import com.google.firebase.crashlytics.internal.model.CrashlyticsReport;
+import com.google.firebase.crashlytics.internal.model.StaticSessionData;
+import com.google.firebase.crashlytics.internal.persistence.FileStore;
+import com.google.firebase.crashlytics.internal.settings.Settings;
+import com.google.firebase.crashlytics.internal.settings.SettingsProvider;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FilenameFilter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.Thread;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.SortedSet;
+import java.util.concurrent.Callable;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ScheduledThreadPoolExecutor;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/* loaded from: classes3.dex */
+public class CrashlyticsController {
+    static final FilenameFilter APP_EXCEPTION_MARKER_FILTER = new a(1);
+    static final String APP_EXCEPTION_MARKER_PREFIX = ".ae";
+    static final String FIREBASE_APPLICATION_EXCEPTION = "_ae";
+    static final String FIREBASE_CRASH_TYPE = "fatal";
+    static final int FIREBASE_CRASH_TYPE_FATAL = 1;
+    static final String FIREBASE_TIMESTAMP = "timestamp";
+    private static final String GENERATOR_FORMAT = "Crashlytics Android SDK/%s";
+    private static final String META_INF_FOLDER = "META-INF/";
+    static final String NATIVE_SESSION_DIR = "native-sessions";
+    private static final String VERSION_CONTROL_INFO_FILE = "version-control-info.textproto";
+    private static final String VERSION_CONTROL_INFO_KEY = "com.crashlytics.version-control-info";
+    private final AnalyticsEventLogger analyticsEventLogger;
+    private final AppData appData;
+    private final CrashlyticsBackgroundWorker backgroundWorker;
+    private final Context context;
+    private CrashlyticsUncaughtExceptionHandler crashHandler;
+    private final CrashlyticsFileMarker crashMarker;
+    private final DataCollectionArbiter dataCollectionArbiter;
+    private final FileStore fileStore;
+    private final IdManager idManager;
+    private final LogFileManager logFileManager;
+    private final CrashlyticsNativeComponent nativeComponent;
+    private final SessionReportingCoordinator reportingCoordinator;
+    private final CrashlyticsAppQualitySessionsSubscriber sessionsSubscriber;
+    private final UserMetadata userMetadata;
+    private SettingsProvider settingsProvider = null;
+    final TaskCompletionSource<Boolean> unsentReportsAvailable = new TaskCompletionSource<>();
+    final TaskCompletionSource<Boolean> reportActionProvided = new TaskCompletionSource<>();
+    final TaskCompletionSource<Void> unsentReportsHandled = new TaskCompletionSource<>();
+    final AtomicBoolean checkForUnsentReportsCalled = new AtomicBoolean(false);
+
+    /* renamed from: com.google.firebase.crashlytics.internal.common.CrashlyticsController$1 */
+    /* loaded from: classes3.dex */
+    public class AnonymousClass1 implements CrashlyticsUncaughtExceptionHandler.CrashListener {
+        public AnonymousClass1() {
+        }
+
+        @Override // com.google.firebase.crashlytics.internal.common.CrashlyticsUncaughtExceptionHandler.CrashListener
+        public void onUncaughtException(SettingsProvider settingsProvider, Thread thread, Throwable th) {
+            CrashlyticsController.this.handleUncaughtException(settingsProvider, thread, th);
+        }
+    }
+
+    /* renamed from: com.google.firebase.crashlytics.internal.common.CrashlyticsController$2 */
+    /* loaded from: classes3.dex */
+    public class AnonymousClass2 implements Callable<Task<Void>> {
+        final /* synthetic */ Throwable val$ex;
+        final /* synthetic */ boolean val$isOnDemand;
+        final /* synthetic */ SettingsProvider val$settingsProvider;
+        final /* synthetic */ Thread val$thread;
+        final /* synthetic */ long val$timestampMillis;
+
+        /* renamed from: com.google.firebase.crashlytics.internal.common.CrashlyticsController$2$1 */
+        /* loaded from: classes3.dex */
+        public class AnonymousClass1 implements SuccessContinuation<Settings, Void> {
+            final /* synthetic */ String val$currentSessionId;
+            final /* synthetic */ Executor val$executor;
+
+            public AnonymousClass1(Executor executor, String str) {
+                r2 = executor;
+                r3 = str;
+            }
+
+            @Override // com.google.android.gms.tasks.SuccessContinuation
+            public Task<Void> then(Settings settings) throws Exception {
+                if (settings == null) {
+                    Logger.getLogger().w("Received null app settings, cannot send reports at crash time.");
+                    return Tasks.forResult(null);
+                }
+                return Tasks.whenAll((Task<?>[]) new Task[]{CrashlyticsController.this.logAnalyticsAppExceptionEvents(), CrashlyticsController.this.reportingCoordinator.sendReports(r2, r7 ? r3 : null)});
+            }
+        }
+
+        public AnonymousClass2(long j4, Throwable th, Thread thread, SettingsProvider settingsProvider, boolean z3) {
+            r2 = j4;
+            r4 = th;
+            r5 = thread;
+            r6 = settingsProvider;
+            r7 = z3;
+        }
+
+        @Override // java.util.concurrent.Callable
+        public Task<Void> call() throws Exception {
+            long timestampSeconds = CrashlyticsController.getTimestampSeconds(r2);
+            String currentSessionId = CrashlyticsController.this.getCurrentSessionId();
+            if (currentSessionId == null) {
+                Logger.getLogger().e("Tried to write a fatal exception while no session was open.");
+                return Tasks.forResult(null);
+            }
+            CrashlyticsController.this.crashMarker.create();
+            CrashlyticsController.this.reportingCoordinator.persistFatalEvent(r4, r5, currentSessionId, timestampSeconds);
+            CrashlyticsController.this.doWriteAppExceptionMarker(r2);
+            CrashlyticsController.this.doCloseSessions(r6);
+            CrashlyticsController.this.doOpenSession(new CLSUUID(CrashlyticsController.this.idManager).toString(), Boolean.valueOf(r7));
+            if (!CrashlyticsController.this.dataCollectionArbiter.isAutomaticDataCollectionEnabled()) {
+                return Tasks.forResult(null);
+            }
+            Executor executor = CrashlyticsController.this.backgroundWorker.getExecutor();
+            return r6.getSettingsAsync().onSuccessTask(executor, new SuccessContinuation<Settings, Void>() { // from class: com.google.firebase.crashlytics.internal.common.CrashlyticsController.2.1
+                final /* synthetic */ String val$currentSessionId;
+                final /* synthetic */ Executor val$executor;
+
+                public AnonymousClass1(Executor executor2, String currentSessionId2) {
+                    r2 = executor2;
+                    r3 = currentSessionId2;
+                }
+
+                @Override // com.google.android.gms.tasks.SuccessContinuation
+                public Task<Void> then(Settings settings) throws Exception {
+                    if (settings == null) {
+                        Logger.getLogger().w("Received null app settings, cannot send reports at crash time.");
+                        return Tasks.forResult(null);
+                    }
+                    return Tasks.whenAll((Task<?>[]) new Task[]{CrashlyticsController.this.logAnalyticsAppExceptionEvents(), CrashlyticsController.this.reportingCoordinator.sendReports(r2, r7 ? r3 : null)});
+                }
+            });
+        }
+    }
+
+    /* renamed from: com.google.firebase.crashlytics.internal.common.CrashlyticsController$3 */
+    /* loaded from: classes3.dex */
+    public class AnonymousClass3 implements SuccessContinuation<Void, Boolean> {
+        public AnonymousClass3() {
+        }
+
+        @Override // com.google.android.gms.tasks.SuccessContinuation
+        public Task<Boolean> then(Void r12) throws Exception {
+            return Tasks.forResult(Boolean.TRUE);
+        }
+    }
+
+    /* renamed from: com.google.firebase.crashlytics.internal.common.CrashlyticsController$4 */
+    /* loaded from: classes3.dex */
+    public class AnonymousClass4 implements SuccessContinuation<Boolean, Void> {
+        final /* synthetic */ Task val$settingsDataTask;
+
+        /* renamed from: com.google.firebase.crashlytics.internal.common.CrashlyticsController$4$1 */
+        /* loaded from: classes3.dex */
+        public class AnonymousClass1 implements Callable<Task<Void>> {
+            final /* synthetic */ Boolean val$send;
+
+            /* renamed from: com.google.firebase.crashlytics.internal.common.CrashlyticsController$4$1$1 */
+            /* loaded from: classes3.dex */
+            public class C00161 implements SuccessContinuation<Settings, Void> {
+                final /* synthetic */ Executor val$executor;
+
+                public C00161(Executor executor) {
+                    r2 = executor;
+                }
+
+                @Override // com.google.android.gms.tasks.SuccessContinuation
+                public Task<Void> then(Settings settings) throws Exception {
+                    if (settings == null) {
+                        Logger.getLogger().w("Received null app settings at app startup. Cannot send cached reports");
+                        return Tasks.forResult(null);
+                    }
+                    CrashlyticsController.this.logAnalyticsAppExceptionEvents();
+                    CrashlyticsController.this.reportingCoordinator.sendReports(r2);
+                    CrashlyticsController.this.unsentReportsHandled.trySetResult(null);
+                    return Tasks.forResult(null);
+                }
+            }
+
+            public AnonymousClass1(Boolean bool) {
+                r2 = bool;
+            }
+
+            @Override // java.util.concurrent.Callable
+            public Task<Void> call() throws Exception {
+                if (!r2.booleanValue()) {
+                    Logger.getLogger().v("Deleting cached crash reports...");
+                    CrashlyticsController.deleteFiles(CrashlyticsController.this.listAppExceptionMarkerFiles());
+                    CrashlyticsController.this.reportingCoordinator.removeAllReports();
+                    CrashlyticsController.this.unsentReportsHandled.trySetResult(null);
+                    return Tasks.forResult(null);
+                }
+                Logger.getLogger().d("Sending cached crash reports...");
+                CrashlyticsController.this.dataCollectionArbiter.grantDataCollectionPermission(r2.booleanValue());
+                Executor executor = CrashlyticsController.this.backgroundWorker.getExecutor();
+                return AnonymousClass4.this.val$settingsDataTask.onSuccessTask(executor, new SuccessContinuation<Settings, Void>() { // from class: com.google.firebase.crashlytics.internal.common.CrashlyticsController.4.1.1
+                    final /* synthetic */ Executor val$executor;
+
+                    public C00161(Executor executor2) {
+                        r2 = executor2;
+                    }
+
+                    @Override // com.google.android.gms.tasks.SuccessContinuation
+                    public Task<Void> then(Settings settings) throws Exception {
+                        if (settings == null) {
+                            Logger.getLogger().w("Received null app settings at app startup. Cannot send cached reports");
+                            return Tasks.forResult(null);
+                        }
+                        CrashlyticsController.this.logAnalyticsAppExceptionEvents();
+                        CrashlyticsController.this.reportingCoordinator.sendReports(r2);
+                        CrashlyticsController.this.unsentReportsHandled.trySetResult(null);
+                        return Tasks.forResult(null);
+                    }
+                });
+            }
+        }
+
+        public AnonymousClass4(Task task) {
+            this.val$settingsDataTask = task;
+        }
+
+        @Override // com.google.android.gms.tasks.SuccessContinuation
+        public Task<Void> then(Boolean bool) throws Exception {
+            return CrashlyticsController.this.backgroundWorker.submitTask(new Callable<Task<Void>>() { // from class: com.google.firebase.crashlytics.internal.common.CrashlyticsController.4.1
+                final /* synthetic */ Boolean val$send;
+
+                /* renamed from: com.google.firebase.crashlytics.internal.common.CrashlyticsController$4$1$1 */
+                /* loaded from: classes3.dex */
+                public class C00161 implements SuccessContinuation<Settings, Void> {
+                    final /* synthetic */ Executor val$executor;
+
+                    public C00161(Executor executor2) {
+                        r2 = executor2;
+                    }
+
+                    @Override // com.google.android.gms.tasks.SuccessContinuation
+                    public Task<Void> then(Settings settings) throws Exception {
+                        if (settings == null) {
+                            Logger.getLogger().w("Received null app settings at app startup. Cannot send cached reports");
+                            return Tasks.forResult(null);
+                        }
+                        CrashlyticsController.this.logAnalyticsAppExceptionEvents();
+                        CrashlyticsController.this.reportingCoordinator.sendReports(r2);
+                        CrashlyticsController.this.unsentReportsHandled.trySetResult(null);
+                        return Tasks.forResult(null);
+                    }
+                }
+
+                public AnonymousClass1(Boolean bool2) {
+                    r2 = bool2;
+                }
+
+                @Override // java.util.concurrent.Callable
+                public Task<Void> call() throws Exception {
+                    if (!r2.booleanValue()) {
+                        Logger.getLogger().v("Deleting cached crash reports...");
+                        CrashlyticsController.deleteFiles(CrashlyticsController.this.listAppExceptionMarkerFiles());
+                        CrashlyticsController.this.reportingCoordinator.removeAllReports();
+                        CrashlyticsController.this.unsentReportsHandled.trySetResult(null);
+                        return Tasks.forResult(null);
+                    }
+                    Logger.getLogger().d("Sending cached crash reports...");
+                    CrashlyticsController.this.dataCollectionArbiter.grantDataCollectionPermission(r2.booleanValue());
+                    Executor executor2 = CrashlyticsController.this.backgroundWorker.getExecutor();
+                    return AnonymousClass4.this.val$settingsDataTask.onSuccessTask(executor2, new SuccessContinuation<Settings, Void>() { // from class: com.google.firebase.crashlytics.internal.common.CrashlyticsController.4.1.1
+                        final /* synthetic */ Executor val$executor;
+
+                        public C00161(Executor executor22) {
+                            r2 = executor22;
+                        }
+
+                        @Override // com.google.android.gms.tasks.SuccessContinuation
+                        public Task<Void> then(Settings settings) throws Exception {
+                            if (settings == null) {
+                                Logger.getLogger().w("Received null app settings at app startup. Cannot send cached reports");
+                                return Tasks.forResult(null);
+                            }
+                            CrashlyticsController.this.logAnalyticsAppExceptionEvents();
+                            CrashlyticsController.this.reportingCoordinator.sendReports(r2);
+                            CrashlyticsController.this.unsentReportsHandled.trySetResult(null);
+                            return Tasks.forResult(null);
+                        }
+                    });
+                }
+            });
+        }
+    }
+
+    /* renamed from: com.google.firebase.crashlytics.internal.common.CrashlyticsController$5 */
+    /* loaded from: classes3.dex */
+    public class AnonymousClass5 implements Callable<Void> {
+        final /* synthetic */ String val$msg;
+        final /* synthetic */ long val$timestamp;
+
+        public AnonymousClass5(long j4, String str) {
+            r2 = j4;
+            r4 = str;
+        }
+
+        @Override // java.util.concurrent.Callable
+        public Void call() throws Exception {
+            if (CrashlyticsController.this.isHandlingException()) {
+                return null;
+            }
+            CrashlyticsController.this.logFileManager.writeToLog(r2, r4);
+            return null;
+        }
+    }
+
+    /* renamed from: com.google.firebase.crashlytics.internal.common.CrashlyticsController$6 */
+    /* loaded from: classes3.dex */
+    public class AnonymousClass6 implements Runnable {
+        final /* synthetic */ Throwable val$ex;
+        final /* synthetic */ Thread val$thread;
+        final /* synthetic */ long val$timestampMillis;
+
+        public AnonymousClass6(long j4, Throwable th, Thread thread) {
+            r2 = j4;
+            r4 = th;
+            r5 = thread;
+        }
+
+        @Override // java.lang.Runnable
+        public void run() {
+            if (CrashlyticsController.this.isHandlingException()) {
+                return;
+            }
+            long timestampSeconds = CrashlyticsController.getTimestampSeconds(r2);
+            String currentSessionId = CrashlyticsController.this.getCurrentSessionId();
+            if (currentSessionId == null) {
+                Logger.getLogger().w("Tried to write a non-fatal exception while no session was open.");
+            } else {
+                CrashlyticsController.this.reportingCoordinator.persistNonFatalEvent(r4, r5, currentSessionId, timestampSeconds);
+            }
+        }
+    }
+
+    /* renamed from: com.google.firebase.crashlytics.internal.common.CrashlyticsController$7 */
+    /* loaded from: classes3.dex */
+    public class AnonymousClass7 implements Callable<Void> {
+        final /* synthetic */ String val$sessionIdentifier;
+
+        public AnonymousClass7(String str) {
+            r2 = str;
+        }
+
+        @Override // java.util.concurrent.Callable
+        public Void call() throws Exception {
+            CrashlyticsController.this.doOpenSession(r2, Boolean.FALSE);
+            return null;
+        }
+    }
+
+    /* renamed from: com.google.firebase.crashlytics.internal.common.CrashlyticsController$8 */
+    /* loaded from: classes3.dex */
+    public class AnonymousClass8 implements Callable<Void> {
+        final /* synthetic */ long val$timestamp;
+
+        public AnonymousClass8(long j4) {
+            r2 = j4;
+        }
+
+        @Override // java.util.concurrent.Callable
+        public Void call() throws Exception {
+            Bundle bundle = new Bundle();
+            bundle.putInt(CrashlyticsController.FIREBASE_CRASH_TYPE, 1);
+            bundle.putLong(CrashlyticsController.FIREBASE_TIMESTAMP, r2);
+            CrashlyticsController.this.analyticsEventLogger.logEvent(CrashlyticsController.FIREBASE_APPLICATION_EXCEPTION, bundle);
+            return null;
+        }
+    }
+
+    public CrashlyticsController(Context context, CrashlyticsBackgroundWorker crashlyticsBackgroundWorker, IdManager idManager, DataCollectionArbiter dataCollectionArbiter, FileStore fileStore, CrashlyticsFileMarker crashlyticsFileMarker, AppData appData, UserMetadata userMetadata, LogFileManager logFileManager, SessionReportingCoordinator sessionReportingCoordinator, CrashlyticsNativeComponent crashlyticsNativeComponent, AnalyticsEventLogger analyticsEventLogger, CrashlyticsAppQualitySessionsSubscriber crashlyticsAppQualitySessionsSubscriber) {
+        this.context = context;
+        this.backgroundWorker = crashlyticsBackgroundWorker;
+        this.idManager = idManager;
+        this.dataCollectionArbiter = dataCollectionArbiter;
+        this.fileStore = fileStore;
+        this.crashMarker = crashlyticsFileMarker;
+        this.appData = appData;
+        this.userMetadata = userMetadata;
+        this.logFileManager = logFileManager;
+        this.nativeComponent = crashlyticsNativeComponent;
+        this.analyticsEventLogger = analyticsEventLogger;
+        this.sessionsSubscriber = crashlyticsAppQualitySessionsSubscriber;
+        this.reportingCoordinator = sessionReportingCoordinator;
+    }
+
+    private static StaticSessionData.AppData createAppData(IdManager idManager, AppData appData) {
+        return StaticSessionData.AppData.create(idManager.getAppIdentifier(), appData.versionCode, appData.versionName, idManager.getInstallIds().getCrashlyticsInstallId(), DeliveryMechanism.determineFrom(appData.installerPackageName).getId(), appData.developmentPlatformProvider);
+    }
+
+    private static StaticSessionData.DeviceData createDeviceData(Context context) {
+        StatFs statFs = new StatFs(Environment.getDataDirectory().getPath());
+        return StaticSessionData.DeviceData.create(CommonUtils.getCpuArchitectureInt(), Build.MODEL, Runtime.getRuntime().availableProcessors(), CommonUtils.calculateTotalRamInBytes(context), statFs.getBlockCount() * statFs.getBlockSize(), CommonUtils.isEmulator(), CommonUtils.getDeviceState(), Build.MANUFACTURER, Build.PRODUCT);
+    }
+
+    private static StaticSessionData.OsData createOsData() {
+        return StaticSessionData.OsData.create(Build.VERSION.RELEASE, Build.VERSION.CODENAME, CommonUtils.isRooted());
+    }
+
+    public static void deleteFiles(List<File> list) {
+        Iterator<File> it = list.iterator();
+        while (it.hasNext()) {
+            it.next().delete();
+        }
+    }
+
+    public void doOpenSession(String str, Boolean bool) {
+        long currentTimestampSeconds = getCurrentTimestampSeconds();
+        Logger.getLogger().d("Opening a new session with ID " + str);
+        Locale locale = Locale.US;
+        this.nativeComponent.prepareNativeSession(str, w.z("Crashlytics Android SDK/", CrashlyticsCore.getVersion()), currentTimestampSeconds, StaticSessionData.create(createAppData(this.idManager, this.appData), createOsData(), createDeviceData(this.context)));
+        if (bool.booleanValue() && str != null) {
+            this.userMetadata.setNewSession(str);
+        }
+        this.logFileManager.setCurrentSession(str);
+        this.sessionsSubscriber.setSessionId(str);
+        this.reportingCoordinator.onBeginSession(str, currentTimestampSeconds);
+    }
+
+    public void doWriteAppExceptionMarker(long j4) {
+        try {
+            if (this.fileStore.getCommonFile(APP_EXCEPTION_MARKER_PREFIX + j4).createNewFile()) {
+            } else {
+                throw new IOException("Create new file failed.");
+            }
+        } catch (IOException e4) {
+            Logger.getLogger().w("Could not create app exception marker file.", e4);
+        }
+    }
+
+    private void finalizePreviousNativeSession(String str) {
+        Logger.getLogger().v("Finalizing native report for session " + str);
+        NativeSessionFileProvider sessionFileProvider = this.nativeComponent.getSessionFileProvider(str);
+        File minidumpFile = sessionFileProvider.getMinidumpFile();
+        CrashlyticsReport.ApplicationExitInfo applicationExitInto = sessionFileProvider.getApplicationExitInto();
+        if (nativeCoreAbsent(str, minidumpFile, applicationExitInto)) {
+            Logger.getLogger().w("No native core present");
+            return;
+        }
+        long lastModified = minidumpFile.lastModified();
+        LogFileManager logFileManager = new LogFileManager(this.fileStore, str);
+        File nativeSessionDir = this.fileStore.getNativeSessionDir(str);
+        if (!nativeSessionDir.isDirectory()) {
+            Logger.getLogger().w("Couldn't create directory to store native session files, aborting.");
+            return;
+        }
+        doWriteAppExceptionMarker(lastModified);
+        List<NativeSessionFile> nativeSessionFiles = getNativeSessionFiles(sessionFileProvider, str, this.fileStore, logFileManager.getBytesForLog());
+        NativeSessionFileGzipper.processNativeSessions(nativeSessionDir, nativeSessionFiles);
+        Logger.getLogger().d("CrashlyticsController#finalizePreviousNativeSession");
+        this.reportingCoordinator.finalizeSessionWithNativeEvent(str, nativeSessionFiles, applicationExitInto);
+        logFileManager.clearLog();
+    }
+
+    private static boolean firebaseCrashExists() {
+        try {
+            Class.forName("com.google.firebase.crash.FirebaseCrash");
+            return true;
+        } catch (ClassNotFoundException unused) {
+            return false;
+        }
+    }
+
+    private Context getContext() {
+        return this.context;
+    }
+
+    public String getCurrentSessionId() {
+        SortedSet<String> listSortedOpenSessionIds = this.reportingCoordinator.listSortedOpenSessionIds();
+        if (listSortedOpenSessionIds.isEmpty()) {
+            return null;
+        }
+        return listSortedOpenSessionIds.first();
+    }
+
+    private static long getCurrentTimestampSeconds() {
+        return getTimestampSeconds(System.currentTimeMillis());
+    }
+
+    public static List<NativeSessionFile> getNativeSessionFiles(NativeSessionFileProvider nativeSessionFileProvider, String str, FileStore fileStore, byte[] bArr) {
+        File sessionFile = fileStore.getSessionFile(str, UserMetadata.USERDATA_FILENAME);
+        File sessionFile2 = fileStore.getSessionFile(str, UserMetadata.KEYDATA_FILENAME);
+        File sessionFile3 = fileStore.getSessionFile(str, UserMetadata.ROLLOUTS_STATE_FILENAME);
+        ArrayList arrayList = new ArrayList();
+        arrayList.add(new BytesBackedNativeSessionFile("logs_file", "logs", bArr));
+        arrayList.add(new FileBackedNativeSessionFile("crash_meta_file", "metadata", nativeSessionFileProvider.getMetadataFile()));
+        arrayList.add(new FileBackedNativeSessionFile("session_meta_file", "session", nativeSessionFileProvider.getSessionFile()));
+        arrayList.add(new FileBackedNativeSessionFile("app_meta_file", "app", nativeSessionFileProvider.getAppFile()));
+        arrayList.add(new FileBackedNativeSessionFile("device_meta_file", "device", nativeSessionFileProvider.getDeviceFile()));
+        arrayList.add(new FileBackedNativeSessionFile("os_meta_file", "os", nativeSessionFileProvider.getOsFile()));
+        arrayList.add(nativeCoreFile(nativeSessionFileProvider));
+        arrayList.add(new FileBackedNativeSessionFile("user_meta_file", "user", sessionFile));
+        arrayList.add(new FileBackedNativeSessionFile("keys_file", UserMetadata.KEYDATA_FILENAME, sessionFile2));
+        arrayList.add(new FileBackedNativeSessionFile("rollouts_file", "rollouts", sessionFile3));
+        return arrayList;
+    }
+
+    private InputStream getResourceAsStream(String str) {
+        ClassLoader classLoader = getClass().getClassLoader();
+        if (classLoader == null) {
+            Logger.getLogger().w("Couldn't get Class Loader");
+            return null;
+        }
+        InputStream resourceAsStream = classLoader.getResourceAsStream(str);
+        if (resourceAsStream != null) {
+            return resourceAsStream;
+        }
+        Logger.getLogger().i("No version control information found");
+        return null;
+    }
+
+    public static long getTimestampSeconds(long j4) {
+        return j4 / 1000;
+    }
+
+    public static /* synthetic */ boolean lambda$static$0(File file, String str) {
+        return str.startsWith(APP_EXCEPTION_MARKER_PREFIX);
+    }
+
+    private Task<Void> logAnalyticsAppExceptionEvent(long j4) {
+        if (firebaseCrashExists()) {
+            Logger.getLogger().w("Skipping logging Crashlytics event to Firebase, FirebaseCrash exists");
+            return Tasks.forResult(null);
+        }
+        Logger.getLogger().d("Logging app exception event to Firebase Analytics");
+        return Tasks.call(new ScheduledThreadPoolExecutor(1), new Callable<Void>() { // from class: com.google.firebase.crashlytics.internal.common.CrashlyticsController.8
+            final /* synthetic */ long val$timestamp;
+
+            public AnonymousClass8(long j42) {
+                r2 = j42;
+            }
+
+            @Override // java.util.concurrent.Callable
+            public Void call() throws Exception {
+                Bundle bundle = new Bundle();
+                bundle.putInt(CrashlyticsController.FIREBASE_CRASH_TYPE, 1);
+                bundle.putLong(CrashlyticsController.FIREBASE_TIMESTAMP, r2);
+                CrashlyticsController.this.analyticsEventLogger.logEvent(CrashlyticsController.FIREBASE_APPLICATION_EXCEPTION, bundle);
+                return null;
+            }
+        });
+    }
+
+    public Task<Void> logAnalyticsAppExceptionEvents() {
+        ArrayList arrayList = new ArrayList();
+        for (File file : listAppExceptionMarkerFiles()) {
+            try {
+                arrayList.add(logAnalyticsAppExceptionEvent(Long.parseLong(file.getName().substring(3))));
+            } catch (NumberFormatException unused) {
+                Logger.getLogger().w("Could not parse app exception timestamp from file " + file.getName());
+            }
+            file.delete();
+        }
+        return Tasks.whenAll(arrayList);
+    }
+
+    private static boolean nativeCoreAbsent(String str, File file, CrashlyticsReport.ApplicationExitInfo applicationExitInfo) {
+        if (file == null || !file.exists()) {
+            Logger.getLogger().w("No minidump data found for session " + str);
+        }
+        if (applicationExitInfo == null) {
+            Logger.getLogger().i("No Tombstones data found for session " + str);
+        }
+        return (file == null || !file.exists()) && applicationExitInfo == null;
+    }
+
+    private static NativeSessionFile nativeCoreFile(NativeSessionFileProvider nativeSessionFileProvider) {
+        File minidumpFile = nativeSessionFileProvider.getMinidumpFile();
+        return (minidumpFile == null || !minidumpFile.exists()) ? new BytesBackedNativeSessionFile("minidump_file", "minidump", new byte[]{0}) : new FileBackedNativeSessionFile("minidump_file", "minidump", minidumpFile);
+    }
+
+    private static byte[] readResource(InputStream inputStream) throws IOException {
+        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+        byte[] bArr = new byte[1024];
+        while (true) {
+            int read = inputStream.read(bArr);
+            if (read == -1) {
+                return byteArrayOutputStream.toByteArray();
+            }
+            byteArrayOutputStream.write(bArr, 0, read);
+        }
+    }
+
+    private Task<Boolean> waitForReportAction() {
+        if (this.dataCollectionArbiter.isAutomaticDataCollectionEnabled()) {
+            Logger.getLogger().d("Automatic data collection is enabled. Allowing upload.");
+            this.unsentReportsAvailable.trySetResult(Boolean.FALSE);
+            return Tasks.forResult(Boolean.TRUE);
+        }
+        Logger.getLogger().d("Automatic data collection is disabled.");
+        Logger.getLogger().v("Notifying that unsent reports are available.");
+        this.unsentReportsAvailable.trySetResult(Boolean.TRUE);
+        Task<TContinuationResult> onSuccessTask = this.dataCollectionArbiter.waitForAutomaticDataCollectionEnabled().onSuccessTask(new SuccessContinuation<Void, Boolean>() { // from class: com.google.firebase.crashlytics.internal.common.CrashlyticsController.3
+            public AnonymousClass3() {
+            }
+
+            @Override // com.google.android.gms.tasks.SuccessContinuation
+            public Task<Boolean> then(Void r12) throws Exception {
+                return Tasks.forResult(Boolean.TRUE);
+            }
+        });
+        Logger.getLogger().d("Waiting for send/deleteUnsentReports to be called.");
+        return Utils.race(onSuccessTask, this.reportActionProvided.getTask());
+    }
+
+    private void writeApplicationExitInfoEventIfRelevant(String str) {
+        List<ApplicationExitInfo> historicalProcessExitReasons;
+        int i = Build.VERSION.SDK_INT;
+        if (i < 30) {
+            Logger.getLogger().v("ANR feature enabled, but device is API " + i);
+            return;
+        }
+        historicalProcessExitReasons = ((ActivityManager) this.context.getSystemService("activity")).getHistoricalProcessExitReasons(null, 0, 0);
+        if (historicalProcessExitReasons.size() != 0) {
+            this.reportingCoordinator.persistRelevantAppExitInfoEvent(str, historicalProcessExitReasons, new LogFileManager(this.fileStore, str), UserMetadata.loadFromExistingSession(str, this.fileStore, this.backgroundWorker));
+        } else {
+            Logger.getLogger().v("No ApplicationExitInfo available. Session: " + str);
+        }
+    }
+
+    public Task<Boolean> checkForUnsentReports() {
+        if (this.checkForUnsentReportsCalled.compareAndSet(false, true)) {
+            return this.unsentReportsAvailable.getTask();
+        }
+        Logger.getLogger().w("checkForUnsentReports should only be called once per execution.");
+        return Tasks.forResult(Boolean.FALSE);
+    }
+
+    public Task<Void> deleteUnsentReports() {
+        this.reportActionProvided.trySetResult(Boolean.FALSE);
+        return this.unsentReportsHandled.getTask();
+    }
+
+    public boolean didCrashOnPreviousExecution() {
+        if (!this.crashMarker.isPresent()) {
+            String currentSessionId = getCurrentSessionId();
+            return currentSessionId != null && this.nativeComponent.hasCrashDataForSession(currentSessionId);
+        }
+        Logger.getLogger().v("Found previous crash marker.");
+        this.crashMarker.remove();
+        return true;
+    }
+
+    public void doCloseSessions(SettingsProvider settingsProvider) {
+        doCloseSessions(false, settingsProvider);
+    }
+
+    public void enableExceptionHandling(String str, Thread.UncaughtExceptionHandler uncaughtExceptionHandler, SettingsProvider settingsProvider) {
+        this.settingsProvider = settingsProvider;
+        openSession(str);
+        CrashlyticsUncaughtExceptionHandler crashlyticsUncaughtExceptionHandler = new CrashlyticsUncaughtExceptionHandler(new CrashlyticsUncaughtExceptionHandler.CrashListener() { // from class: com.google.firebase.crashlytics.internal.common.CrashlyticsController.1
+            public AnonymousClass1() {
+            }
+
+            @Override // com.google.firebase.crashlytics.internal.common.CrashlyticsUncaughtExceptionHandler.CrashListener
+            public void onUncaughtException(SettingsProvider settingsProvider2, Thread thread, Throwable th) {
+                CrashlyticsController.this.handleUncaughtException(settingsProvider2, thread, th);
+            }
+        }, settingsProvider, uncaughtExceptionHandler, this.nativeComponent);
+        this.crashHandler = crashlyticsUncaughtExceptionHandler;
+        Thread.setDefaultUncaughtExceptionHandler(crashlyticsUncaughtExceptionHandler);
+    }
+
+    public boolean finalizeSessions(SettingsProvider settingsProvider) {
+        this.backgroundWorker.checkRunningOnThread();
+        if (isHandlingException()) {
+            Logger.getLogger().w("Skipping session finalization because a crash has already occurred.");
+            return false;
+        }
+        Logger.getLogger().v("Finalizing previously open sessions.");
+        try {
+            doCloseSessions(true, settingsProvider);
+            Logger.getLogger().v("Closed all previously open sessions.");
+            return true;
+        } catch (Exception e4) {
+            Logger.getLogger().e("Unable to finalize previously open sessions.", e4);
+            return false;
+        }
+    }
+
+    public UserMetadata getUserMetadata() {
+        return this.userMetadata;
+    }
+
+    public String getVersionControlInfo() throws IOException {
+        InputStream resourceAsStream = getResourceAsStream("META-INF/version-control-info.textproto");
+        if (resourceAsStream == null) {
+            return null;
+        }
+        Logger.getLogger().d("Read version control info");
+        return Base64.encodeToString(readResource(resourceAsStream), 0);
+    }
+
+    public void handleUncaughtException(SettingsProvider settingsProvider, Thread thread, Throwable th) {
+        handleUncaughtException(settingsProvider, thread, th, false);
+    }
+
+    public boolean isHandlingException() {
+        CrashlyticsUncaughtExceptionHandler crashlyticsUncaughtExceptionHandler = this.crashHandler;
+        return crashlyticsUncaughtExceptionHandler != null && crashlyticsUncaughtExceptionHandler.isHandlingException();
+    }
+
+    public List<File> listAppExceptionMarkerFiles() {
+        return this.fileStore.getCommonFiles(APP_EXCEPTION_MARKER_FILTER);
+    }
+
+    public void logFatalException(Thread thread, Throwable th) {
+        SettingsProvider settingsProvider = this.settingsProvider;
+        if (settingsProvider == null) {
+            Logger.getLogger().w("settingsProvider not set");
+        } else {
+            handleUncaughtException(settingsProvider, thread, th, true);
+        }
+    }
+
+    public void openSession(String str) {
+        this.backgroundWorker.submit(new Callable<Void>() { // from class: com.google.firebase.crashlytics.internal.common.CrashlyticsController.7
+            final /* synthetic */ String val$sessionIdentifier;
+
+            public AnonymousClass7(String str2) {
+                r2 = str2;
+            }
+
+            @Override // java.util.concurrent.Callable
+            public Void call() throws Exception {
+                CrashlyticsController.this.doOpenSession(r2, Boolean.FALSE);
+                return null;
+            }
+        });
+    }
+
+    public void saveVersionControlInfo() {
+        try {
+            String versionControlInfo = getVersionControlInfo();
+            if (versionControlInfo != null) {
+                setInternalKey(VERSION_CONTROL_INFO_KEY, versionControlInfo);
+                Logger.getLogger().i("Saved version control info");
+            }
+        } catch (IOException e4) {
+            Logger.getLogger().w("Unable to save version control info", e4);
+        }
+    }
+
+    public Task<Void> sendUnsentReports() {
+        this.reportActionProvided.trySetResult(Boolean.TRUE);
+        return this.unsentReportsHandled.getTask();
+    }
+
+    public void setCustomKey(String str, String str2) {
+        try {
+            this.userMetadata.setCustomKey(str, str2);
+        } catch (IllegalArgumentException e4) {
+            Context context = this.context;
+            if (context != null && CommonUtils.isAppDebuggable(context)) {
+                throw e4;
+            }
+            Logger.getLogger().e("Attempting to set custom attribute with null key, ignoring.");
+        }
+    }
+
+    public void setCustomKeys(Map<String, String> map) {
+        this.userMetadata.setCustomKeys(map);
+    }
+
+    public void setInternalKey(String str, String str2) {
+        try {
+            this.userMetadata.setInternalKey(str, str2);
+        } catch (IllegalArgumentException e4) {
+            Context context = this.context;
+            if (context != null && CommonUtils.isAppDebuggable(context)) {
+                throw e4;
+            }
+            Logger.getLogger().e("Attempting to set custom attribute with null key, ignoring.");
+        }
+    }
+
+    public void setUserId(String str) {
+        this.userMetadata.setUserId(str);
+    }
+
+    @SuppressLint({"TaskMainThread"})
+    public Task<Void> submitAllReports(Task<Settings> task) {
+        if (this.reportingCoordinator.hasReportsToSend()) {
+            Logger.getLogger().v("Crash reports are available to be sent.");
+            return waitForReportAction().onSuccessTask(new AnonymousClass4(task));
+        }
+        Logger.getLogger().v("No crash reports are available to be sent.");
+        this.unsentReportsAvailable.trySetResult(Boolean.FALSE);
+        return Tasks.forResult(null);
+    }
+
+    public void writeNonFatalException(Thread thread, Throwable th) {
+        this.backgroundWorker.submit(new Runnable() { // from class: com.google.firebase.crashlytics.internal.common.CrashlyticsController.6
+            final /* synthetic */ Throwable val$ex;
+            final /* synthetic */ Thread val$thread;
+            final /* synthetic */ long val$timestampMillis;
+
+            public AnonymousClass6(long j4, Throwable th2, Thread thread2) {
+                r2 = j4;
+                r4 = th2;
+                r5 = thread2;
+            }
+
+            @Override // java.lang.Runnable
+            public void run() {
+                if (CrashlyticsController.this.isHandlingException()) {
+                    return;
+                }
+                long timestampSeconds = CrashlyticsController.getTimestampSeconds(r2);
+                String currentSessionId = CrashlyticsController.this.getCurrentSessionId();
+                if (currentSessionId == null) {
+                    Logger.getLogger().w("Tried to write a non-fatal exception while no session was open.");
+                } else {
+                    CrashlyticsController.this.reportingCoordinator.persistNonFatalEvent(r4, r5, currentSessionId, timestampSeconds);
+                }
+            }
+        });
+    }
+
+    public void writeToLog(long j4, String str) {
+        this.backgroundWorker.submit(new Callable<Void>() { // from class: com.google.firebase.crashlytics.internal.common.CrashlyticsController.5
+            final /* synthetic */ String val$msg;
+            final /* synthetic */ long val$timestamp;
+
+            public AnonymousClass5(long j42, String str2) {
+                r2 = j42;
+                r4 = str2;
+            }
+
+            @Override // java.util.concurrent.Callable
+            public Void call() throws Exception {
+                if (CrashlyticsController.this.isHandlingException()) {
+                    return null;
+                }
+                CrashlyticsController.this.logFileManager.writeToLog(r2, r4);
+                return null;
+            }
+        });
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    private void doCloseSessions(boolean z3, SettingsProvider settingsProvider) {
+        String str;
+        ArrayList arrayList = new ArrayList(this.reportingCoordinator.listSortedOpenSessionIds());
+        if (arrayList.size() <= z3) {
+            Logger.getLogger().v("No open sessions to be closed.");
+            return;
+        }
+        String str2 = (String) arrayList.get(z3 ? 1 : 0);
+        if (settingsProvider.getSettingsSync().featureFlagData.collectAnrs) {
+            writeApplicationExitInfoEventIfRelevant(str2);
+        } else {
+            Logger.getLogger().v("ANR feature disabled.");
+        }
+        if (this.nativeComponent.hasCrashDataForSession(str2)) {
+            finalizePreviousNativeSession(str2);
+        }
+        if (z3 != 0) {
+            str = (String) arrayList.get(0);
+        } else {
+            this.sessionsSubscriber.setSessionId(null);
+            str = null;
+        }
+        this.reportingCoordinator.finalizeSessions(getCurrentTimestampSeconds(), str);
+    }
+
+    public synchronized void handleUncaughtException(SettingsProvider settingsProvider, Thread thread, Throwable th, boolean z3) {
+        CrashlyticsController crashlyticsController;
+        try {
+            try {
+                Logger.getLogger().d("Handling uncaught exception \"" + th + "\" from thread " + thread.getName());
+                crashlyticsController = this;
+                try {
+                    Utils.awaitEvenIfOnMainThread(this.backgroundWorker.submitTask(new Callable<Task<Void>>() { // from class: com.google.firebase.crashlytics.internal.common.CrashlyticsController.2
+                        final /* synthetic */ Throwable val$ex;
+                        final /* synthetic */ boolean val$isOnDemand;
+                        final /* synthetic */ SettingsProvider val$settingsProvider;
+                        final /* synthetic */ Thread val$thread;
+                        final /* synthetic */ long val$timestampMillis;
+
+                        /* renamed from: com.google.firebase.crashlytics.internal.common.CrashlyticsController$2$1 */
+                        /* loaded from: classes3.dex */
+                        public class AnonymousClass1 implements SuccessContinuation<Settings, Void> {
+                            final /* synthetic */ String val$currentSessionId;
+                            final /* synthetic */ Executor val$executor;
+
+                            public AnonymousClass1(Executor executor2, String currentSessionId2) {
+                                r2 = executor2;
+                                r3 = currentSessionId2;
+                            }
+
+                            @Override // com.google.android.gms.tasks.SuccessContinuation
+                            public Task<Void> then(Settings settings) throws Exception {
+                                if (settings == null) {
+                                    Logger.getLogger().w("Received null app settings, cannot send reports at crash time.");
+                                    return Tasks.forResult(null);
+                                }
+                                return Tasks.whenAll((Task<?>[]) new Task[]{CrashlyticsController.this.logAnalyticsAppExceptionEvents(), CrashlyticsController.this.reportingCoordinator.sendReports(r2, r7 ? r3 : null)});
+                            }
+                        }
+
+                        public AnonymousClass2(long j4, Throwable th2, Thread thread2, SettingsProvider settingsProvider2, boolean z32) {
+                            r2 = j4;
+                            r4 = th2;
+                            r5 = thread2;
+                            r6 = settingsProvider2;
+                            r7 = z32;
+                        }
+
+                        @Override // java.util.concurrent.Callable
+                        public Task<Void> call() throws Exception {
+                            long timestampSeconds = CrashlyticsController.getTimestampSeconds(r2);
+                            String currentSessionId2 = CrashlyticsController.this.getCurrentSessionId();
+                            if (currentSessionId2 == null) {
+                                Logger.getLogger().e("Tried to write a fatal exception while no session was open.");
+                                return Tasks.forResult(null);
+                            }
+                            CrashlyticsController.this.crashMarker.create();
+                            CrashlyticsController.this.reportingCoordinator.persistFatalEvent(r4, r5, currentSessionId2, timestampSeconds);
+                            CrashlyticsController.this.doWriteAppExceptionMarker(r2);
+                            CrashlyticsController.this.doCloseSessions(r6);
+                            CrashlyticsController.this.doOpenSession(new CLSUUID(CrashlyticsController.this.idManager).toString(), Boolean.valueOf(r7));
+                            if (!CrashlyticsController.this.dataCollectionArbiter.isAutomaticDataCollectionEnabled()) {
+                                return Tasks.forResult(null);
+                            }
+                            Executor executor2 = CrashlyticsController.this.backgroundWorker.getExecutor();
+                            return r6.getSettingsAsync().onSuccessTask(executor2, new SuccessContinuation<Settings, Void>() { // from class: com.google.firebase.crashlytics.internal.common.CrashlyticsController.2.1
+                                final /* synthetic */ String val$currentSessionId;
+                                final /* synthetic */ Executor val$executor;
+
+                                public AnonymousClass1(Executor executor22, String currentSessionId22) {
+                                    r2 = executor22;
+                                    r3 = currentSessionId22;
+                                }
+
+                                @Override // com.google.android.gms.tasks.SuccessContinuation
+                                public Task<Void> then(Settings settings) throws Exception {
+                                    if (settings == null) {
+                                        Logger.getLogger().w("Received null app settings, cannot send reports at crash time.");
+                                        return Tasks.forResult(null);
+                                    }
+                                    return Tasks.whenAll((Task<?>[]) new Task[]{CrashlyticsController.this.logAnalyticsAppExceptionEvents(), CrashlyticsController.this.reportingCoordinator.sendReports(r2, r7 ? r3 : null)});
+                                }
+                            });
+                        }
+                    }));
+                } catch (TimeoutException unused) {
+                    Logger.getLogger().e("Cannot send reports. Timed out while fetching settings.");
+                } catch (Exception e4) {
+                    Logger.getLogger().e("Error handling uncaught exception", e4);
+                }
+            } catch (Throwable th2) {
+                th = th2;
+                crashlyticsController = this;
+                Throwable th3 = th;
+                throw th3;
+            }
+        } catch (Throwable th4) {
+            th = th4;
+        }
+    }
+}

apk_decompiled/sources/com/google/firebase/crashlytics/internal/common/CrashlyticsCore.java

@@ -0,0 +1,294 @@
+package com.google.firebase.crashlytics.internal.common;
+
+import android.content.Context;
+import android.text.TextUtils;
+import android.util.Log;
+import com.google.android.gms.tasks.Task;
+import com.google.android.gms.tasks.Tasks;
+import com.google.firebase.FirebaseApp;
+import com.google.firebase.crashlytics.BuildConfig;
+import com.google.firebase.crashlytics.internal.CrashlyticsNativeComponent;
+import com.google.firebase.crashlytics.internal.Logger;
+import com.google.firebase.crashlytics.internal.RemoteConfigDeferredProxy;
+import com.google.firebase.crashlytics.internal.analytics.AnalyticsEventLogger;
+import com.google.firebase.crashlytics.internal.breadcrumbs.BreadcrumbHandler;
+import com.google.firebase.crashlytics.internal.breadcrumbs.BreadcrumbSource;
+import com.google.firebase.crashlytics.internal.metadata.LogFileManager;
+import com.google.firebase.crashlytics.internal.metadata.UserMetadata;
+import com.google.firebase.crashlytics.internal.persistence.FileStore;
+import com.google.firebase.crashlytics.internal.settings.SettingsProvider;
+import com.google.firebase.crashlytics.internal.stacktrace.MiddleOutFallbackStrategy;
+import com.google.firebase.crashlytics.internal.stacktrace.RemoveRepeatsStrategy;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+/* loaded from: classes3.dex */
+public class CrashlyticsCore {
+    static final String CRASHLYTICS_REQUIRE_BUILD_ID = "com.crashlytics.RequireBuildId";
+    static final boolean CRASHLYTICS_REQUIRE_BUILD_ID_DEFAULT = true;
+    static final String CRASH_MARKER_FILE_NAME = "crash_marker";
+    static final int DEFAULT_MAIN_HANDLER_TIMEOUT_SEC = 3;
+    private static final String INITIALIZATION_MARKER_FILE_NAME = "initialization_marker";
+    static final int MAX_STACK_SIZE = 1024;
+    private static final String MISSING_BUILD_ID_MSG = "The Crashlytics build ID is missing. This occurs when the Crashlytics Gradle plugin is missing from your app's build configuration. Please review the Firebase Crashlytics onboarding instructions at https://firebase.google.com/docs/crashlytics/get-started?platform=android#add-plugin";
+    static final int NUM_STACK_REPETITIONS_ALLOWED = 10;
+    private static final String ON_DEMAND_DROPPED_KEY = "com.crashlytics.on-demand.dropped-exceptions";
+    private static final String ON_DEMAND_RECORDED_KEY = "com.crashlytics.on-demand.recorded-exceptions";
+    private final AnalyticsEventLogger analyticsEventLogger;
+    private final FirebaseApp app;
+    private final CrashlyticsBackgroundWorker backgroundWorker;
+    public final BreadcrumbSource breadcrumbSource;
+    private final Context context;
+    private CrashlyticsController controller;
+    private final ExecutorService crashHandlerExecutor;
+    private CrashlyticsFileMarker crashMarker;
+    private final DataCollectionArbiter dataCollectionArbiter;
+    private boolean didCrashOnPreviousExecution;
+    private final FileStore fileStore;
+    private final IdManager idManager;
+    private CrashlyticsFileMarker initializationMarker;
+    private final CrashlyticsNativeComponent nativeComponent;
+    private final RemoteConfigDeferredProxy remoteConfigDeferredProxy;
+    private final CrashlyticsAppQualitySessionsSubscriber sessionsSubscriber;
+    private final long startTime = System.currentTimeMillis();
+    private final OnDemandCounter onDemandCounter = new OnDemandCounter();
+
+    public CrashlyticsCore(FirebaseApp firebaseApp, IdManager idManager, CrashlyticsNativeComponent crashlyticsNativeComponent, DataCollectionArbiter dataCollectionArbiter, BreadcrumbSource breadcrumbSource, AnalyticsEventLogger analyticsEventLogger, FileStore fileStore, ExecutorService executorService, CrashlyticsAppQualitySessionsSubscriber crashlyticsAppQualitySessionsSubscriber, RemoteConfigDeferredProxy remoteConfigDeferredProxy) {
+        this.app = firebaseApp;
+        this.dataCollectionArbiter = dataCollectionArbiter;
+        this.context = firebaseApp.getApplicationContext();
+        this.idManager = idManager;
+        this.nativeComponent = crashlyticsNativeComponent;
+        this.breadcrumbSource = breadcrumbSource;
+        this.analyticsEventLogger = analyticsEventLogger;
+        this.crashHandlerExecutor = executorService;
+        this.fileStore = fileStore;
+        this.backgroundWorker = new CrashlyticsBackgroundWorker(executorService);
+        this.sessionsSubscriber = crashlyticsAppQualitySessionsSubscriber;
+        this.remoteConfigDeferredProxy = remoteConfigDeferredProxy;
+    }
+
+    private void checkForPreviousCrash() {
+        try {
+            this.didCrashOnPreviousExecution = Boolean.TRUE.equals((Boolean) Utils.awaitEvenIfOnMainThread(this.backgroundWorker.submit(new Callable<Boolean>() { // from class: com.google.firebase.crashlytics.internal.common.CrashlyticsCore.4
+                /* JADX WARN: Can't rename method to resolve collision */
+                @Override // java.util.concurrent.Callable
+                public Boolean call() throws Exception {
+                    return Boolean.valueOf(CrashlyticsCore.this.controller.didCrashOnPreviousExecution());
+                }
+            })));
+        } catch (Exception unused) {
+            this.didCrashOnPreviousExecution = false;
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public Task<Void> doBackgroundInitialization(SettingsProvider settingsProvider) {
+        markInitializationStarted();
+        try {
+            this.breadcrumbSource.registerBreadcrumbHandler(new BreadcrumbHandler() { // from class: com.google.firebase.crashlytics.internal.common.c
+                @Override // com.google.firebase.crashlytics.internal.breadcrumbs.BreadcrumbHandler
+                public final void handleBreadcrumb(String str) {
+                    CrashlyticsCore.this.log(str);
+                }
+            });
+            this.controller.saveVersionControlInfo();
+            if (!settingsProvider.getSettingsSync().featureFlagData.collectReports) {
+                Logger.getLogger().d("Collection of crash reports disabled in Crashlytics settings.");
+                return Tasks.forException(new RuntimeException("Collection of crash reports disabled in Crashlytics settings."));
+            }
+            if (!this.controller.finalizeSessions(settingsProvider)) {
+                Logger.getLogger().w("Previous sessions could not be finalized.");
+            }
+            return this.controller.submitAllReports(settingsProvider.getSettingsAsync());
+        } catch (Exception e4) {
+            Logger.getLogger().e("Crashlytics encountered a problem during asynchronous initialization.", e4);
+            return Tasks.forException(e4);
+        } finally {
+            markInitializationComplete();
+        }
+    }
+
+    private void finishInitSynchronously(final SettingsProvider settingsProvider) {
+        Future<?> submit = this.crashHandlerExecutor.submit(new Runnable() { // from class: com.google.firebase.crashlytics.internal.common.CrashlyticsCore.2
+            @Override // java.lang.Runnable
+            public void run() {
+                CrashlyticsCore.this.doBackgroundInitialization(settingsProvider);
+            }
+        });
+        Logger.getLogger().d("Crashlytics detected incomplete initialization on previous app launch. Will initialize synchronously.");
+        try {
+            submit.get(3L, TimeUnit.SECONDS);
+        } catch (InterruptedException e4) {
+            Logger.getLogger().e("Crashlytics was interrupted during initialization.", e4);
+        } catch (ExecutionException e5) {
+            Logger.getLogger().e("Crashlytics encountered a problem during initialization.", e5);
+        } catch (TimeoutException e6) {
+            Logger.getLogger().e("Crashlytics timed out during initialization.", e6);
+        }
+    }
+
+    public static String getVersion() {
+        return BuildConfig.VERSION_NAME;
+    }
+
+    public static boolean isBuildIdValid(String str, boolean z3) {
+        if (!z3) {
+            Logger.getLogger().v("Configured not to require a build ID.");
+            return CRASHLYTICS_REQUIRE_BUILD_ID_DEFAULT;
+        }
+        if (!TextUtils.isEmpty(str)) {
+            return CRASHLYTICS_REQUIRE_BUILD_ID_DEFAULT;
+        }
+        Log.e(Logger.TAG, ".");
+        Log.e(Logger.TAG, ".     |  | ");
+        Log.e(Logger.TAG, ".     |  |");
+        Log.e(Logger.TAG, ".     |  |");
+        Log.e(Logger.TAG, ".   \\ |  | /");
+        Log.e(Logger.TAG, ".    \\    /");
+        Log.e(Logger.TAG, ".     \\  /");
+        Log.e(Logger.TAG, ".      \\/");
+        Log.e(Logger.TAG, ".");
+        Log.e(Logger.TAG, MISSING_BUILD_ID_MSG);
+        Log.e(Logger.TAG, ".");
+        Log.e(Logger.TAG, ".      /\\");
+        Log.e(Logger.TAG, ".     /  \\");
+        Log.e(Logger.TAG, ".    /    \\");
+        Log.e(Logger.TAG, ".   / |  | \\");
+        Log.e(Logger.TAG, ".     |  |");
+        Log.e(Logger.TAG, ".     |  |");
+        Log.e(Logger.TAG, ".     |  |");
+        Log.e(Logger.TAG, ".");
+        return false;
+    }
+
+    public Task<Boolean> checkForUnsentReports() {
+        return this.controller.checkForUnsentReports();
+    }
+
+    public Task<Void> deleteUnsentReports() {
+        return this.controller.deleteUnsentReports();
+    }
+
+    public boolean didCrashOnPreviousExecution() {
+        return this.didCrashOnPreviousExecution;
+    }
+
+    public boolean didPreviousInitializationFail() {
+        return this.initializationMarker.isPresent();
+    }
+
+    public Task<Void> doBackgroundInitializationAsync(final SettingsProvider settingsProvider) {
+        return Utils.callTask(this.crashHandlerExecutor, new Callable<Task<Void>>() { // from class: com.google.firebase.crashlytics.internal.common.CrashlyticsCore.1
+            /* JADX WARN: Can't rename method to resolve collision */
+            @Override // java.util.concurrent.Callable
+            public Task<Void> call() throws Exception {
+                return CrashlyticsCore.this.doBackgroundInitialization(settingsProvider);
+            }
+        });
+    }
+
+    public CrashlyticsController getController() {
+        return this.controller;
+    }
+
+    public void log(String str) {
+        this.controller.writeToLog(System.currentTimeMillis() - this.startTime, str);
+    }
+
+    public void logException(Throwable th) {
+        this.controller.writeNonFatalException(Thread.currentThread(), th);
+    }
+
+    public void logFatalException(Throwable th) {
+        Logger.getLogger().d("Recorded on-demand fatal events: " + this.onDemandCounter.getRecordedOnDemandExceptions());
+        Logger.getLogger().d("Dropped on-demand fatal events: " + this.onDemandCounter.getDroppedOnDemandExceptions());
+        this.controller.setInternalKey(ON_DEMAND_RECORDED_KEY, Integer.toString(this.onDemandCounter.getRecordedOnDemandExceptions()));
+        this.controller.setInternalKey(ON_DEMAND_DROPPED_KEY, Integer.toString(this.onDemandCounter.getDroppedOnDemandExceptions()));
+        this.controller.logFatalException(Thread.currentThread(), th);
+    }
+
+    public void markInitializationComplete() {
+        this.backgroundWorker.submit(new Callable<Boolean>() { // from class: com.google.firebase.crashlytics.internal.common.CrashlyticsCore.3
+            /* JADX WARN: Can't rename method to resolve collision */
+            @Override // java.util.concurrent.Callable
+            public Boolean call() throws Exception {
+                try {
+                    boolean remove = CrashlyticsCore.this.initializationMarker.remove();
+                    if (!remove) {
+                        Logger.getLogger().w("Initialization marker file was not properly removed.");
+                    }
+                    return Boolean.valueOf(remove);
+                } catch (Exception e4) {
+                    Logger.getLogger().e("Problem encountered deleting Crashlytics initialization marker.", e4);
+                    return Boolean.FALSE;
+                }
+            }
+        });
+    }
+
+    public void markInitializationStarted() {
+        this.backgroundWorker.checkRunningOnThread();
+        this.initializationMarker.create();
+        Logger.getLogger().v("Initialization marker file was created.");
+    }
+
+    public boolean onPreExecute(AppData appData, SettingsProvider settingsProvider) {
+        if (!isBuildIdValid(appData.buildId, CommonUtils.getBooleanResourceValue(this.context, CRASHLYTICS_REQUIRE_BUILD_ID, CRASHLYTICS_REQUIRE_BUILD_ID_DEFAULT))) {
+            throw new IllegalStateException(MISSING_BUILD_ID_MSG);
+        }
+        String clsuuid = new CLSUUID(this.idManager).toString();
+        try {
+            this.crashMarker = new CrashlyticsFileMarker(CRASH_MARKER_FILE_NAME, this.fileStore);
+            this.initializationMarker = new CrashlyticsFileMarker(INITIALIZATION_MARKER_FILE_NAME, this.fileStore);
+            UserMetadata userMetadata = new UserMetadata(clsuuid, this.fileStore, this.backgroundWorker);
+            LogFileManager logFileManager = new LogFileManager(this.fileStore);
+            MiddleOutFallbackStrategy middleOutFallbackStrategy = new MiddleOutFallbackStrategy(1024, new RemoveRepeatsStrategy(10));
+            this.remoteConfigDeferredProxy.setupListener(userMetadata);
+            this.controller = new CrashlyticsController(this.context, this.backgroundWorker, this.idManager, this.dataCollectionArbiter, this.fileStore, this.crashMarker, appData, userMetadata, logFileManager, SessionReportingCoordinator.create(this.context, this.idManager, this.fileStore, appData, logFileManager, userMetadata, middleOutFallbackStrategy, settingsProvider, this.onDemandCounter, this.sessionsSubscriber), this.nativeComponent, this.analyticsEventLogger, this.sessionsSubscriber);
+            boolean didPreviousInitializationFail = didPreviousInitializationFail();
+            checkForPreviousCrash();
+            this.controller.enableExceptionHandling(clsuuid, Thread.getDefaultUncaughtExceptionHandler(), settingsProvider);
+            if (!didPreviousInitializationFail || !CommonUtils.canTryConnection(this.context)) {
+                Logger.getLogger().d("Successfully configured exception handler.");
+                return CRASHLYTICS_REQUIRE_BUILD_ID_DEFAULT;
+            }
+            Logger.getLogger().d("Crashlytics did not finish previous background initialization. Initializing synchronously.");
+            finishInitSynchronously(settingsProvider);
+            return false;
+        } catch (Exception e4) {
+            Logger.getLogger().e("Crashlytics was not started due to an exception during initialization", e4);
+            this.controller = null;
+            return false;
+        }
+    }
+
+    public Task<Void> sendUnsentReports() {
+        return this.controller.sendUnsentReports();
+    }
+
+    public void setCrashlyticsCollectionEnabled(Boolean bool) {
+        this.dataCollectionArbiter.setCrashlyticsDataCollectionEnabled(bool);
+    }
+
+    public void setCustomKey(String str, String str2) {
+        this.controller.setCustomKey(str, str2);
+    }
+
+    public void setCustomKeys(Map<String, String> map) {
+        this.controller.setCustomKeys(map);
+    }
+
+    public void setInternalKey(String str, String str2) {
+        this.controller.setInternalKey(str, str2);
+    }
+
+    public void setUserId(String str) {
+        this.controller.setUserId(str);
+    }
+}

apk_decompiled/sources/com/google/firebase/crashlytics/internal/common/CrashlyticsFileMarker.java

@@ -0,0 +1,39 @@
+package com.google.firebase.crashlytics.internal.common;
+
+import com.google.firebase.crashlytics.internal.Logger;
+import com.google.firebase.crashlytics.internal.persistence.FileStore;
+import java.io.File;
+import java.io.IOException;
+
+/* JADX INFO: Access modifiers changed from: package-private */
+/* loaded from: classes3.dex */
+public class CrashlyticsFileMarker {
+    private final FileStore fileStore;
+    private final String markerName;
+
+    public CrashlyticsFileMarker(String str, FileStore fileStore) {
+        this.markerName = str;
+        this.fileStore = fileStore;
+    }
+
+    private File getMarkerFile() {
+        return this.fileStore.getCommonFile(this.markerName);
+    }
+
+    public boolean create() {
+        try {
+            return getMarkerFile().createNewFile();
+        } catch (IOException e4) {
+            Logger.getLogger().e("Error creating marker: " + this.markerName, e4);
+            return false;
+        }
+    }
+
+    public boolean isPresent() {
+        return getMarkerFile().exists();
+    }
+
+    public boolean remove() {
+        return getMarkerFile().delete();
+    }
+}

apk_decompiled/sources/com/google/firebase/crashlytics/internal/common/CrashlyticsLifecycleEvents.java

@@ -0,0 +1,12 @@
+package com.google.firebase.crashlytics.internal.common;
+
+/* loaded from: classes3.dex */
+interface CrashlyticsLifecycleEvents {
+    void onBeginSession(String str, long j4);
+
+    void onCustomKey(String str, String str2);
+
+    void onLog(long j4, String str);
+
+    void onUserId(String str);
+}

apk_decompiled/sources/com/google/firebase/crashlytics/internal/common/CrashlyticsReportDataCapture.java

@@ -0,0 +1,242 @@
+package com.google.firebase.crashlytics.internal.common;
+
+import android.content.Context;
+import android.os.Build;
+import android.os.Environment;
+import android.os.StatFs;
+import android.text.TextUtils;
+import com.google.firebase.crashlytics.BuildConfig;
+import com.google.firebase.crashlytics.internal.ProcessDetailsProvider;
+import com.google.firebase.crashlytics.internal.model.CrashlyticsReport;
+import com.google.firebase.crashlytics.internal.settings.SettingsProvider;
+import com.google.firebase.crashlytics.internal.stacktrace.StackTraceTrimmingStrategy;
+import com.google.firebase.crashlytics.internal.stacktrace.TrimmedThrowableData;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+
+/* loaded from: classes3.dex */
+public class CrashlyticsReportDataCapture {
+    private static final Map<String, Integer> ARCHITECTURES_BY_NAME;
+    static final String GENERATOR;
+    static final int GENERATOR_TYPE = 3;
+    static final int REPORT_ANDROID_PLATFORM = 4;
+    static final int SESSION_ANDROID_PLATFORM = 3;
+    static final String SIGNAL_DEFAULT = "0";
+    private final AppData appData;
+    private final Context context;
+    private final IdManager idManager;
+    private final ProcessDetailsProvider processDetailsProvider = ProcessDetailsProvider.INSTANCE;
+    private final SettingsProvider settingsProvider;
+    private final StackTraceTrimmingStrategy stackTraceTrimmingStrategy;
+
+    static {
+        HashMap hashMap = new HashMap();
+        ARCHITECTURES_BY_NAME = hashMap;
+        hashMap.put("armeabi", 5);
+        hashMap.put("armeabi-v7a", 6);
+        hashMap.put("arm64-v8a", 9);
+        hashMap.put("x86", 0);
+        hashMap.put("x86_64", 1);
+        Locale locale = Locale.US;
+        GENERATOR = "Crashlytics Android SDK/18.6.0";
+    }
+
+    public CrashlyticsReportDataCapture(Context context, IdManager idManager, AppData appData, StackTraceTrimmingStrategy stackTraceTrimmingStrategy, SettingsProvider settingsProvider) {
+        this.context = context;
+        this.idManager = idManager;
+        this.appData = appData;
+        this.stackTraceTrimmingStrategy = stackTraceTrimmingStrategy;
+        this.settingsProvider = settingsProvider;
+    }
+
+    private CrashlyticsReport.ApplicationExitInfo addBuildIdInfo(CrashlyticsReport.ApplicationExitInfo applicationExitInfo) {
+        List<CrashlyticsReport.ApplicationExitInfo.BuildIdMappingForArch> list;
+        if (!this.settingsProvider.getSettingsSync().featureFlagData.collectBuildIds || this.appData.buildIdInfoList.size() <= 0) {
+            list = null;
+        } else {
+            ArrayList arrayList = new ArrayList();
+            for (BuildIdInfo buildIdInfo : this.appData.buildIdInfoList) {
+                arrayList.add(CrashlyticsReport.ApplicationExitInfo.BuildIdMappingForArch.builder().setLibraryName(buildIdInfo.getLibraryName()).setArch(buildIdInfo.getArch()).setBuildId(buildIdInfo.getBuildId()).build());
+            }
+            list = Collections.unmodifiableList(arrayList);
+        }
+        return CrashlyticsReport.ApplicationExitInfo.builder().setImportance(applicationExitInfo.getImportance()).setProcessName(applicationExitInfo.getProcessName()).setReasonCode(applicationExitInfo.getReasonCode()).setTimestamp(applicationExitInfo.getTimestamp()).setPid(applicationExitInfo.getPid()).setPss(applicationExitInfo.getPss()).setRss(applicationExitInfo.getRss()).setTraceFile(applicationExitInfo.getTraceFile()).setBuildIdMappingForArch(list).build();
+    }
+
+    private CrashlyticsReport.Builder buildReportData() {
+        return CrashlyticsReport.builder().setSdkVersion(BuildConfig.VERSION_NAME).setGmpAppId(this.appData.googleAppId).setInstallationUuid(this.idManager.getInstallIds().getCrashlyticsInstallId()).setFirebaseInstallationId(this.idManager.getInstallIds().getFirebaseInstallationId()).setBuildVersion(this.appData.versionCode).setDisplayVersion(this.appData.versionName).setPlatform(4);
+    }
+
+    private static long ensureNonNegative(long j4) {
+        if (j4 > 0) {
+            return j4;
+        }
+        return 0L;
+    }
+
+    private static int getDeviceArchitecture() {
+        Integer num;
+        String str = Build.CPU_ABI;
+        if (TextUtils.isEmpty(str) || (num = ARCHITECTURES_BY_NAME.get(str.toLowerCase(Locale.US))) == null) {
+            return 7;
+        }
+        return num.intValue();
+    }
+
+    private CrashlyticsReport.Session.Event.Application.Execution.BinaryImage populateBinaryImageData() {
+        return CrashlyticsReport.Session.Event.Application.Execution.BinaryImage.builder().setBaseAddress(0L).setSize(0L).setName(this.appData.packageName).setUuid(this.appData.buildId).build();
+    }
+
+    private List<CrashlyticsReport.Session.Event.Application.Execution.BinaryImage> populateBinaryImagesList() {
+        return Collections.singletonList(populateBinaryImageData());
+    }
+
+    private CrashlyticsReport.Session.Event.Application populateEventApplicationData(int i, TrimmedThrowableData trimmedThrowableData, Thread thread, int i4, int i5, boolean z3) {
+        Boolean bool;
+        CrashlyticsReport.Session.Event.Application.ProcessDetails currentProcessDetails = this.processDetailsProvider.getCurrentProcessDetails(this.context);
+        if (currentProcessDetails.getImportance() > 0) {
+            bool = Boolean.valueOf(currentProcessDetails.getImportance() != 100);
+        } else {
+            bool = null;
+        }
+        return CrashlyticsReport.Session.Event.Application.builder().setBackground(bool).setCurrentProcessDetails(currentProcessDetails).setAppProcessDetails(this.processDetailsProvider.getAppProcessDetails(this.context)).setUiOrientation(i).setExecution(populateExecutionData(trimmedThrowableData, thread, i4, i5, z3)).build();
+    }
+
+    private CrashlyticsReport.Session.Event.Device populateEventDeviceData(int i) {
+        BatteryState batteryState = BatteryState.get(this.context);
+        Float batteryLevel = batteryState.getBatteryLevel();
+        Double valueOf = batteryLevel != null ? Double.valueOf(batteryLevel.doubleValue()) : null;
+        int batteryVelocity = batteryState.getBatteryVelocity();
+        boolean proximitySensorEnabled = CommonUtils.getProximitySensorEnabled(this.context);
+        return CrashlyticsReport.Session.Event.Device.builder().setBatteryLevel(valueOf).setBatteryVelocity(batteryVelocity).setProximityOn(proximitySensorEnabled).setOrientation(i).setRamUsed(ensureNonNegative(CommonUtils.calculateTotalRamInBytes(this.context) - CommonUtils.calculateFreeRamInBytes(this.context))).setDiskUsed(CommonUtils.calculateUsedDiskSpaceInBytes(Environment.getDataDirectory().getPath())).build();
+    }
+
+    private CrashlyticsReport.Session.Event.Application.Execution.Exception populateExceptionData(TrimmedThrowableData trimmedThrowableData, int i, int i4) {
+        return populateExceptionData(trimmedThrowableData, i, i4, 0);
+    }
+
+    private CrashlyticsReport.Session.Event.Application.Execution populateExecutionData(TrimmedThrowableData trimmedThrowableData, Thread thread, int i, int i4, boolean z3) {
+        return CrashlyticsReport.Session.Event.Application.Execution.builder().setThreads(populateThreadsList(trimmedThrowableData, thread, i, z3)).setException(populateExceptionData(trimmedThrowableData, i, i4)).setSignal(populateSignalData()).setBinaries(populateBinaryImagesList()).build();
+    }
+
+    private CrashlyticsReport.Session.Event.Application.Execution.Thread.Frame populateFrameData(StackTraceElement stackTraceElement, CrashlyticsReport.Session.Event.Application.Execution.Thread.Frame.Builder builder) {
+        long j4 = 0;
+        long max = stackTraceElement.isNativeMethod() ? Math.max(stackTraceElement.getLineNumber(), 0L) : 0L;
+        String str = stackTraceElement.getClassName() + "." + stackTraceElement.getMethodName();
+        String fileName = stackTraceElement.getFileName();
+        if (!stackTraceElement.isNativeMethod() && stackTraceElement.getLineNumber() > 0) {
+            j4 = stackTraceElement.getLineNumber();
+        }
+        return builder.setPc(max).setSymbol(str).setFile(fileName).setOffset(j4).build();
+    }
+
+    private List<CrashlyticsReport.Session.Event.Application.Execution.Thread.Frame> populateFramesList(StackTraceElement[] stackTraceElementArr, int i) {
+        ArrayList arrayList = new ArrayList();
+        for (StackTraceElement stackTraceElement : stackTraceElementArr) {
+            arrayList.add(populateFrameData(stackTraceElement, CrashlyticsReport.Session.Event.Application.Execution.Thread.Frame.builder().setImportance(i)));
+        }
+        return Collections.unmodifiableList(arrayList);
+    }
+
+    private CrashlyticsReport.Session.Application populateSessionApplicationData() {
+        return CrashlyticsReport.Session.Application.builder().setIdentifier(this.idManager.getAppIdentifier()).setVersion(this.appData.versionCode).setDisplayVersion(this.appData.versionName).setInstallationUuid(this.idManager.getInstallIds().getCrashlyticsInstallId()).setDevelopmentPlatform(this.appData.developmentPlatformProvider.getDevelopmentPlatform()).setDevelopmentPlatformVersion(this.appData.developmentPlatformProvider.getDevelopmentPlatformVersion()).build();
+    }
+
+    private CrashlyticsReport.Session populateSessionData(String str, long j4) {
+        return CrashlyticsReport.Session.builder().setStartedAt(j4).setIdentifier(str).setGenerator(GENERATOR).setApp(populateSessionApplicationData()).setOs(populateSessionOperatingSystemData()).setDevice(populateSessionDeviceData()).setGeneratorType(3).build();
+    }
+
+    private CrashlyticsReport.Session.Device populateSessionDeviceData() {
+        StatFs statFs = new StatFs(Environment.getDataDirectory().getPath());
+        int deviceArchitecture = getDeviceArchitecture();
+        int availableProcessors = Runtime.getRuntime().availableProcessors();
+        long calculateTotalRamInBytes = CommonUtils.calculateTotalRamInBytes(this.context);
+        long blockCount = statFs.getBlockCount() * statFs.getBlockSize();
+        boolean isEmulator = CommonUtils.isEmulator();
+        int deviceState = CommonUtils.getDeviceState();
+        return CrashlyticsReport.Session.Device.builder().setArch(deviceArchitecture).setModel(Build.MODEL).setCores(availableProcessors).setRam(calculateTotalRamInBytes).setDiskSpace(blockCount).setSimulator(isEmulator).setState(deviceState).setManufacturer(Build.MANUFACTURER).setModelClass(Build.PRODUCT).build();
+    }
+
+    private CrashlyticsReport.Session.OperatingSystem populateSessionOperatingSystemData() {
+        return CrashlyticsReport.Session.OperatingSystem.builder().setPlatform(3).setVersion(Build.VERSION.RELEASE).setBuildVersion(Build.VERSION.CODENAME).setJailbroken(CommonUtils.isRooted()).build();
+    }
+
+    private CrashlyticsReport.Session.Event.Application.Execution.Signal populateSignalData() {
+        return CrashlyticsReport.Session.Event.Application.Execution.Signal.builder().setName("0").setCode("0").setAddress(0L).build();
+    }
+
+    private CrashlyticsReport.Session.Event.Application.Execution.Thread populateThreadData(Thread thread, StackTraceElement[] stackTraceElementArr) {
+        return populateThreadData(thread, stackTraceElementArr, 0);
+    }
+
+    private List<CrashlyticsReport.Session.Event.Application.Execution.Thread> populateThreadsList(TrimmedThrowableData trimmedThrowableData, Thread thread, int i, boolean z3) {
+        ArrayList arrayList = new ArrayList();
+        arrayList.add(populateThreadData(thread, trimmedThrowableData.stacktrace, i));
+        if (z3) {
+            for (Map.Entry<Thread, StackTraceElement[]> entry : Thread.getAllStackTraces().entrySet()) {
+                Thread key = entry.getKey();
+                if (!key.equals(thread)) {
+                    arrayList.add(populateThreadData(key, this.stackTraceTrimmingStrategy.getTrimmedStackTrace(entry.getValue())));
+                }
+            }
+        }
+        return Collections.unmodifiableList(arrayList);
+    }
+
+    private CrashlyticsReport.Session.Event.Application.ProcessDetails processDetailsFromApplicationExitInfo(CrashlyticsReport.ApplicationExitInfo applicationExitInfo) {
+        return this.processDetailsProvider.buildProcessDetails(applicationExitInfo.getProcessName(), applicationExitInfo.getPid(), applicationExitInfo.getImportance());
+    }
+
+    public CrashlyticsReport.Session.Event captureAnrEventData(CrashlyticsReport.ApplicationExitInfo applicationExitInfo) {
+        int i = this.context.getResources().getConfiguration().orientation;
+        return CrashlyticsReport.Session.Event.builder().setType("anr").setTimestamp(applicationExitInfo.getTimestamp()).setApp(populateEventApplicationData(i, addBuildIdInfo(applicationExitInfo))).setDevice(populateEventDeviceData(i)).build();
+    }
+
+    public CrashlyticsReport.Session.Event captureEventData(Throwable th, Thread thread, String str, long j4, int i, int i4, boolean z3) {
+        int i5 = this.context.getResources().getConfiguration().orientation;
+        return CrashlyticsReport.Session.Event.builder().setType(str).setTimestamp(j4).setApp(populateEventApplicationData(i5, TrimmedThrowableData.makeTrimmedThrowableData(th, this.stackTraceTrimmingStrategy), thread, i, i4, z3)).setDevice(populateEventDeviceData(i5)).build();
+    }
+
+    public CrashlyticsReport captureReportData(String str, long j4) {
+        return buildReportData().setSession(populateSessionData(str, j4)).build();
+    }
+
+    private CrashlyticsReport.Session.Event.Application.Execution.Exception populateExceptionData(TrimmedThrowableData trimmedThrowableData, int i, int i4, int i5) {
+        String str = trimmedThrowableData.className;
+        String str2 = trimmedThrowableData.localizedMessage;
+        StackTraceElement[] stackTraceElementArr = trimmedThrowableData.stacktrace;
+        int i6 = 0;
+        if (stackTraceElementArr == null) {
+            stackTraceElementArr = new StackTraceElement[0];
+        }
+        TrimmedThrowableData trimmedThrowableData2 = trimmedThrowableData.cause;
+        if (i5 >= i4) {
+            TrimmedThrowableData trimmedThrowableData3 = trimmedThrowableData2;
+            while (trimmedThrowableData3 != null) {
+                trimmedThrowableData3 = trimmedThrowableData3.cause;
+                i6++;
+            }
+        }
+        CrashlyticsReport.Session.Event.Application.Execution.Exception.Builder overflowCount = CrashlyticsReport.Session.Event.Application.Execution.Exception.builder().setType(str).setReason(str2).setFrames(populateFramesList(stackTraceElementArr, i)).setOverflowCount(i6);
+        if (trimmedThrowableData2 != null && i6 == 0) {
+            overflowCount.setCausedBy(populateExceptionData(trimmedThrowableData2, i, i4, i5 + 1));
+        }
+        return overflowCount.build();
+    }
+
+    private CrashlyticsReport.Session.Event.Application.Execution.Thread populateThreadData(Thread thread, StackTraceElement[] stackTraceElementArr, int i) {
+        return CrashlyticsReport.Session.Event.Application.Execution.Thread.builder().setName(thread.getName()).setImportance(i).setFrames(populateFramesList(stackTraceElementArr, i)).build();
+    }
+
+    private CrashlyticsReport.Session.Event.Application.Execution populateExecutionData(CrashlyticsReport.ApplicationExitInfo applicationExitInfo) {
+        return CrashlyticsReport.Session.Event.Application.Execution.builder().setAppExitInfo(applicationExitInfo).setSignal(populateSignalData()).setBinaries(populateBinaryImagesList()).build();
+    }
+
+    private CrashlyticsReport.Session.Event.Application populateEventApplicationData(int i, CrashlyticsReport.ApplicationExitInfo applicationExitInfo) {
+        return CrashlyticsReport.Session.Event.Application.builder().setBackground(Boolean.valueOf(applicationExitInfo.getImportance() != 100)).setCurrentProcessDetails(processDetailsFromApplicationExitInfo(applicationExitInfo)).setUiOrientation(i).setExecution(populateExecutionData(applicationExitInfo)).build();
+    }
+}

apk_decompiled/sources/com/google/firebase/crashlytics/internal/common/CrashlyticsReportWithSessionId.java

@@ -0,0 +1,19 @@
+package com.google.firebase.crashlytics.internal.common;
+
+import com.google.auto.value.AutoValue;
+import com.google.firebase.crashlytics.internal.model.CrashlyticsReport;
+import java.io.File;
+
+@AutoValue
+/* loaded from: classes3.dex */
+public abstract class CrashlyticsReportWithSessionId {
+    public static CrashlyticsReportWithSessionId create(CrashlyticsReport crashlyticsReport, String str, File file) {
+        return new AutoValue_CrashlyticsReportWithSessionId(crashlyticsReport, str, file);
+    }
+
+    public abstract CrashlyticsReport getReport();
+
+    public abstract File getReportFile();
+
+    public abstract String getSessionId();
+}

apk_decompiled/sources/com/google/firebase/crashlytics/internal/common/CrashlyticsUncaughtExceptionHandler.java

@@ -0,0 +1,76 @@
+package com.google.firebase.crashlytics.internal.common;
+
+import com.google.firebase.crashlytics.internal.CrashlyticsNativeComponent;
+import com.google.firebase.crashlytics.internal.Logger;
+import com.google.firebase.crashlytics.internal.settings.SettingsProvider;
+import java.lang.Thread;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/* JADX INFO: Access modifiers changed from: package-private */
+/* loaded from: classes3.dex */
+public class CrashlyticsUncaughtExceptionHandler implements Thread.UncaughtExceptionHandler {
+    private final CrashListener crashListener;
+    private final Thread.UncaughtExceptionHandler defaultHandler;
+    private final AtomicBoolean isHandlingException = new AtomicBoolean(false);
+    private final CrashlyticsNativeComponent nativeComponent;
+    private final SettingsProvider settingsProvider;
+
+    /* loaded from: classes3.dex */
+    public interface CrashListener {
+        void onUncaughtException(SettingsProvider settingsProvider, Thread thread, Throwable th);
+    }
+
+    public CrashlyticsUncaughtExceptionHandler(CrashListener crashListener, SettingsProvider settingsProvider, Thread.UncaughtExceptionHandler uncaughtExceptionHandler, CrashlyticsNativeComponent crashlyticsNativeComponent) {
+        this.crashListener = crashListener;
+        this.settingsProvider = settingsProvider;
+        this.defaultHandler = uncaughtExceptionHandler;
+        this.nativeComponent = crashlyticsNativeComponent;
+    }
+
+    private boolean shouldRecordUncaughtException(Thread thread, Throwable th) {
+        if (thread == null) {
+            Logger.getLogger().e("Crashlytics will not record uncaught exception; null thread");
+            return false;
+        }
+        if (th == null) {
+            Logger.getLogger().e("Crashlytics will not record uncaught exception; null throwable");
+            return false;
+        }
+        if (!this.nativeComponent.hasCrashDataForCurrentSession()) {
+            return true;
+        }
+        Logger.getLogger().d("Crashlytics will not record uncaught exception; native crash exists for session.");
+        return false;
+    }
+
+    public boolean isHandlingException() {
+        return this.isHandlingException.get();
+    }
+
+    @Override // java.lang.Thread.UncaughtExceptionHandler
+    public void uncaughtException(Thread thread, Throwable th) {
+        this.isHandlingException.set(true);
+        try {
+            try {
+                if (shouldRecordUncaughtException(thread, th)) {
+                    this.crashListener.onUncaughtException(this.settingsProvider, thread, th);
+                } else {
+                    Logger.getLogger().d("Uncaught exception will not be recorded by Crashlytics.");
+                }
+                Logger.getLogger().d("Completed exception processing. Invoking default exception handler.");
+                this.defaultHandler.uncaughtException(thread, th);
+                this.isHandlingException.set(false);
+            } catch (Exception e4) {
+                Logger.getLogger().e("An error occurred in the uncaught exception handler", e4);
+                Logger.getLogger().d("Completed exception processing. Invoking default exception handler.");
+                this.defaultHandler.uncaughtException(thread, th);
+                this.isHandlingException.set(false);
+            }
+        } catch (Throwable th2) {
+            Logger.getLogger().d("Completed exception processing. Invoking default exception handler.");
+            this.defaultHandler.uncaughtException(thread, th);
+            this.isHandlingException.set(false);
+            throw th2;
+        }
+    }
+}

apk_decompiled/sources/com/google/firebase/crashlytics/internal/common/CurrentTimeProvider.java

@@ -0,0 +1,6 @@
+package com.google.firebase.crashlytics.internal.common;
+
+/* loaded from: classes3.dex */
+public interface CurrentTimeProvider {
+    long getCurrentTimeMillis();
+}

apk_decompiled/sources/com/google/firebase/crashlytics/internal/common/DataCollectionArbiter.java

@@ -0,0 +1,165 @@
+package com.google.firebase.crashlytics.internal.common;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
+import android.os.Bundle;
+import com.google.android.gms.tasks.Task;
+import com.google.android.gms.tasks.TaskCompletionSource;
+import com.google.firebase.FirebaseApp;
+import com.google.firebase.crashlytics.internal.Logger;
+import java.util.concurrent.Executor;
+
+/* loaded from: classes3.dex */
+public class DataCollectionArbiter {
+    private static final String FIREBASE_CRASHLYTICS_COLLECTION_ENABLED = "firebase_crashlytics_collection_enabled";
+    private Boolean crashlyticsDataCollectionEnabled;
+    TaskCompletionSource<Void> dataCollectionEnabledTask;
+    private final TaskCompletionSource<Void> dataCollectionExplicitlyApproved;
+    private final FirebaseApp firebaseApp;
+    private boolean setInManifest;
+    private final SharedPreferences sharedPreferences;
+    private final Object taskLock;
+    boolean taskResolved;
+
+    public DataCollectionArbiter(FirebaseApp firebaseApp) {
+        Object obj = new Object();
+        this.taskLock = obj;
+        this.dataCollectionEnabledTask = new TaskCompletionSource<>();
+        this.taskResolved = false;
+        this.setInManifest = false;
+        this.dataCollectionExplicitlyApproved = new TaskCompletionSource<>();
+        Context applicationContext = firebaseApp.getApplicationContext();
+        this.firebaseApp = firebaseApp;
+        this.sharedPreferences = CommonUtils.getSharedPrefs(applicationContext);
+        Boolean dataCollectionValueFromSharedPreferences = getDataCollectionValueFromSharedPreferences();
+        this.crashlyticsDataCollectionEnabled = dataCollectionValueFromSharedPreferences == null ? getDataCollectionValueFromManifest(applicationContext) : dataCollectionValueFromSharedPreferences;
+        synchronized (obj) {
+            try {
+                if (isAutomaticDataCollectionEnabled()) {
+                    this.dataCollectionEnabledTask.trySetResult(null);
+                    this.taskResolved = true;
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    private Boolean getDataCollectionValueFromManifest(Context context) {
+        Boolean readCrashlyticsDataCollectionEnabledFromManifest = readCrashlyticsDataCollectionEnabledFromManifest(context);
+        if (readCrashlyticsDataCollectionEnabledFromManifest == null) {
+            this.setInManifest = false;
+            return null;
+        }
+        this.setInManifest = true;
+        return Boolean.valueOf(Boolean.TRUE.equals(readCrashlyticsDataCollectionEnabledFromManifest));
+    }
+
+    private Boolean getDataCollectionValueFromSharedPreferences() {
+        if (!this.sharedPreferences.contains(FIREBASE_CRASHLYTICS_COLLECTION_ENABLED)) {
+            return null;
+        }
+        this.setInManifest = false;
+        return Boolean.valueOf(this.sharedPreferences.getBoolean(FIREBASE_CRASHLYTICS_COLLECTION_ENABLED, true));
+    }
+
+    private boolean isFirebaseDataCollectionDefaultEnabled() {
+        try {
+            return this.firebaseApp.isDataCollectionDefaultEnabled();
+        } catch (IllegalStateException unused) {
+            return false;
+        }
+    }
+
+    private void logDataCollectionState(boolean z3) {
+        String str = z3 ? "ENABLED" : "DISABLED";
+        String str2 = this.crashlyticsDataCollectionEnabled == null ? "global Firebase setting" : this.setInManifest ? "firebase_crashlytics_collection_enabled manifest flag" : "API";
+        Logger.getLogger().d("Crashlytics automatic data collection " + str + " by " + str2 + ".");
+    }
+
+    private static Boolean readCrashlyticsDataCollectionEnabledFromManifest(Context context) {
+        ApplicationInfo applicationInfo;
+        Bundle bundle;
+        try {
+            PackageManager packageManager = context.getPackageManager();
+            if (packageManager == null || (applicationInfo = packageManager.getApplicationInfo(context.getPackageName(), 128)) == null || (bundle = applicationInfo.metaData) == null || !bundle.containsKey(FIREBASE_CRASHLYTICS_COLLECTION_ENABLED)) {
+                return null;
+            }
+            return Boolean.valueOf(applicationInfo.metaData.getBoolean(FIREBASE_CRASHLYTICS_COLLECTION_ENABLED));
+        } catch (PackageManager.NameNotFoundException e4) {
+            Logger.getLogger().e("Could not read data collection permission from manifest", e4);
+            return null;
+        }
+    }
+
+    @SuppressLint({"ApplySharedPref"})
+    private static void storeDataCollectionValueInSharedPreferences(SharedPreferences sharedPreferences, Boolean bool) {
+        SharedPreferences.Editor edit = sharedPreferences.edit();
+        if (bool != null) {
+            edit.putBoolean(FIREBASE_CRASHLYTICS_COLLECTION_ENABLED, bool.booleanValue());
+        } else {
+            edit.remove(FIREBASE_CRASHLYTICS_COLLECTION_ENABLED);
+        }
+        edit.apply();
+    }
+
+    public void grantDataCollectionPermission(boolean z3) {
+        if (!z3) {
+            throw new IllegalStateException("An invalid data collection token was used.");
+        }
+        this.dataCollectionExplicitlyApproved.trySetResult(null);
+    }
+
+    public synchronized boolean isAutomaticDataCollectionEnabled() {
+        boolean booleanValue;
+        try {
+            Boolean bool = this.crashlyticsDataCollectionEnabled;
+            booleanValue = bool != null ? bool.booleanValue() : isFirebaseDataCollectionDefaultEnabled();
+            logDataCollectionState(booleanValue);
+        } catch (Throwable th) {
+            throw th;
+        }
+        return booleanValue;
+    }
+
+    public synchronized void setCrashlyticsDataCollectionEnabled(Boolean bool) {
+        if (bool != null) {
+            try {
+                this.setInManifest = false;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        this.crashlyticsDataCollectionEnabled = bool != null ? bool : getDataCollectionValueFromManifest(this.firebaseApp.getApplicationContext());
+        storeDataCollectionValueInSharedPreferences(this.sharedPreferences, bool);
+        synchronized (this.taskLock) {
+            try {
+                if (isAutomaticDataCollectionEnabled()) {
+                    if (!this.taskResolved) {
+                        this.dataCollectionEnabledTask.trySetResult(null);
+                        this.taskResolved = true;
+                    }
+                } else if (this.taskResolved) {
+                    this.dataCollectionEnabledTask = new TaskCompletionSource<>();
+                    this.taskResolved = false;
+                }
+            } finally {
+            }
+        }
+    }
+
+    public Task<Void> waitForAutomaticDataCollectionEnabled() {
+        Task<Void> task;
+        synchronized (this.taskLock) {
+            task = this.dataCollectionEnabledTask.getTask();
+        }
+        return task;
+    }
+
+    public Task<Void> waitForDataCollectionPermission(Executor executor) {
+        return Utils.race(executor, this.dataCollectionExplicitlyApproved.getTask(), waitForAutomaticDataCollectionEnabled());
+    }
+}

apk_decompiled/sources/com/google/firebase/crashlytics/internal/common/DeliveryMechanism.java

@@ -0,0 +1,28 @@
+package com.google.firebase.crashlytics.internal.common;
+
+/* loaded from: classes3.dex */
+public enum DeliveryMechanism {
+    DEVELOPER(1),
+    USER_SIDELOAD(2),
+    TEST_DISTRIBUTION(3),
+    APP_STORE(4);
+
+    private final int id;
+
+    DeliveryMechanism(int i) {
+        this.id = i;
+    }
+
+    public static DeliveryMechanism determineFrom(String str) {
+        return str != null ? APP_STORE : DEVELOPER;
+    }
+
+    public int getId() {
+        return this.id;
+    }
+
+    @Override // java.lang.Enum
+    public String toString() {
+        return Integer.toString(this.id);
+    }
+}

apk_decompiled/sources/com/google/firebase/crashlytics/internal/common/ExecutorUtils.java

@@ -0,0 +1,84 @@
+package com.google.firebase.crashlytics.internal.common;
+
+import C.w;
+import android.annotation.SuppressLint;
+import com.google.firebase.crashlytics.internal.Logger;
+import java.util.Locale;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.RejectedExecutionHandler;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicLong;
+
+/* loaded from: classes3.dex */
+public final class ExecutorUtils {
+    private static final long DEFAULT_TERMINATION_TIMEOUT = 2;
+
+    private ExecutorUtils() {
+    }
+
+    private static void addDelayedShutdownHook(String str, ExecutorService executorService) {
+        addDelayedShutdownHook(str, executorService, DEFAULT_TERMINATION_TIMEOUT, TimeUnit.SECONDS);
+    }
+
+    public static ExecutorService buildSingleThreadExecutorService(String str) {
+        ExecutorService newSingleThreadExecutor = newSingleThreadExecutor(getNamedThreadFactory(str), new ThreadPoolExecutor.DiscardPolicy());
+        addDelayedShutdownHook(str, newSingleThreadExecutor);
+        return newSingleThreadExecutor;
+    }
+
+    public static ScheduledExecutorService buildSingleThreadScheduledExecutorService(String str) {
+        ScheduledExecutorService newSingleThreadScheduledExecutor = Executors.newSingleThreadScheduledExecutor(getNamedThreadFactory(str));
+        addDelayedShutdownHook(str, newSingleThreadScheduledExecutor);
+        return newSingleThreadScheduledExecutor;
+    }
+
+    public static ThreadFactory getNamedThreadFactory(final String str) {
+        final AtomicLong atomicLong = new AtomicLong(1L);
+        return new ThreadFactory() { // from class: com.google.firebase.crashlytics.internal.common.ExecutorUtils.1
+            @Override // java.util.concurrent.ThreadFactory
+            public Thread newThread(final Runnable runnable) {
+                Thread newThread = Executors.defaultThreadFactory().newThread(new BackgroundPriorityRunnable() { // from class: com.google.firebase.crashlytics.internal.common.ExecutorUtils.1.1
+                    @Override // com.google.firebase.crashlytics.internal.common.BackgroundPriorityRunnable
+                    public void onRun() {
+                        runnable.run();
+                    }
+                });
+                newThread.setName(str + atomicLong.getAndIncrement());
+                return newThread;
+            }
+        };
+    }
+
+    @SuppressLint({"ThreadPoolCreation"})
+    private static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory, RejectedExecutionHandler rejectedExecutionHandler) {
+        return Executors.unconfigurableExecutorService(new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue(), threadFactory, rejectedExecutionHandler));
+    }
+
+    @SuppressLint({"ThreadPoolCreation"})
+    private static void addDelayedShutdownHook(final String str, final ExecutorService executorService, final long j4, final TimeUnit timeUnit) {
+        Runtime.getRuntime().addShutdownHook(new Thread(new BackgroundPriorityRunnable() { // from class: com.google.firebase.crashlytics.internal.common.ExecutorUtils.2
+            @Override // com.google.firebase.crashlytics.internal.common.BackgroundPriorityRunnable
+            public void onRun() {
+                try {
+                    Logger.getLogger().d("Executing shutdown hook for " + str);
+                    executorService.shutdown();
+                    if (executorService.awaitTermination(j4, timeUnit)) {
+                        return;
+                    }
+                    Logger.getLogger().d(str + " did not shut down in the allocated time. Requesting immediate shutdown.");
+                    executorService.shutdownNow();
+                } catch (InterruptedException unused) {
+                    Logger logger = Logger.getLogger();
+                    Locale locale = Locale.US;
+                    logger.d("Interrupted while waiting for " + str + " to shut down. Requesting immediate shutdown.");
+                    executorService.shutdownNow();
+                }
+            }
+        }, w.z("Crashlytics Shutdown Hook for ", str)));
+    }
+}

apk_decompiled/sources/com/google/firebase/crashlytics/internal/common/FileBackedNativeSessionFile.java

@@ -0,0 +1,95 @@
+package com.google.firebase.crashlytics.internal.common;
+
+import com.google.firebase.crashlytics.internal.model.CrashlyticsReport;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.zip.GZIPOutputStream;
+
+/* JADX INFO: Access modifiers changed from: package-private */
+/* loaded from: classes3.dex */
+public class FileBackedNativeSessionFile implements NativeSessionFile {
+    private final String dataTransportFilename;
+    private final File file;
+    private final String reportsEndpointFilename;
+
+    public FileBackedNativeSessionFile(String str, String str2, File file) {
+        this.dataTransportFilename = str;
+        this.reportsEndpointFilename = str2;
+        this.file = file;
+    }
+
+    private byte[] asGzippedBytes() {
+        byte[] bArr = new byte[8192];
+        try {
+            InputStream stream = getStream();
+            try {
+                ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+                try {
+                    GZIPOutputStream gZIPOutputStream = new GZIPOutputStream(byteArrayOutputStream);
+                    if (stream == null) {
+                        gZIPOutputStream.close();
+                        byteArrayOutputStream.close();
+                        if (stream != null) {
+                            stream.close();
+                        }
+                        return null;
+                    }
+                    while (true) {
+                        try {
+                            int read = stream.read(bArr);
+                            if (read <= 0) {
+                                gZIPOutputStream.finish();
+                                byte[] byteArray = byteArrayOutputStream.toByteArray();
+                                gZIPOutputStream.close();
+                                byteArrayOutputStream.close();
+                                stream.close();
+                                return byteArray;
+                            }
+                            gZIPOutputStream.write(bArr, 0, read);
+                        } finally {
+                        }
+                    }
+                } catch (Throwable th) {
+                    try {
+                        byteArrayOutputStream.close();
+                    } catch (Throwable th2) {
+                        th.addSuppressed(th2);
+                    }
+                    throw th;
+                }
+            } finally {
+            }
+        } catch (IOException unused) {
+            return null;
+        }
+    }
+
+    @Override // com.google.firebase.crashlytics.internal.common.NativeSessionFile
+    public CrashlyticsReport.FilesPayload.File asFilePayload() {
+        byte[] asGzippedBytes = asGzippedBytes();
+        if (asGzippedBytes != null) {
+            return CrashlyticsReport.FilesPayload.File.builder().setContents(asGzippedBytes).setFilename(this.dataTransportFilename).build();
+        }
+        return null;
+    }
+
+    @Override // com.google.firebase.crashlytics.internal.common.NativeSessionFile
+    public String getReportsEndpointFilename() {
+        return this.reportsEndpointFilename;
+    }
+
+    @Override // com.google.firebase.crashlytics.internal.common.NativeSessionFile
+    public InputStream getStream() {
+        if (this.file.exists() && this.file.isFile()) {
+            try {
+                return new FileInputStream(this.file);
+            } catch (FileNotFoundException unused) {
+            }
+        }
+        return null;
+    }
+}

apk_decompiled/sources/com/google/firebase/crashlytics/internal/common/IdManager.java

@@ -0,0 +1,142 @@
+package com.google.firebase.crashlytics.internal.common;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.os.Build;
+import com.google.firebase.crashlytics.internal.Logger;
+import com.google.firebase.crashlytics.internal.common.InstallIdProvider;
+import com.google.firebase.installations.FirebaseInstallationsApi;
+import com.google.firebase.sessions.settings.RemoteSettings;
+import java.util.Locale;
+import java.util.UUID;
+import java.util.regex.Pattern;
+
+/* loaded from: classes3.dex */
+public class IdManager implements InstallIdProvider {
+    public static final String DEFAULT_VERSION_NAME = "0.0";
+    static final String PREFKEY_ADVERTISING_ID = "crashlytics.advertising.id";
+    static final String PREFKEY_FIREBASE_IID = "firebase.installation.id";
+    static final String PREFKEY_INSTALLATION_UUID = "crashlytics.installation.id";
+    static final String PREFKEY_LEGACY_INSTALLATION_UUID = "crashlytics.installation.id";
+    private static final String SYNTHETIC_FID_PREFIX = "SYN_";
+    private final Context appContext;
+    private final String appIdentifier;
+    private final DataCollectionArbiter dataCollectionArbiter;
+    private final FirebaseInstallationsApi firebaseInstallationsApi;
+    private InstallIdProvider.InstallIds installIds;
+    private final InstallerPackageNameProvider installerPackageNameProvider;
+    private static final Pattern ID_PATTERN = Pattern.compile("[^\\p{Alnum}]");
+    private static final String FORWARD_SLASH_REGEX = Pattern.quote(RemoteSettings.FORWARD_SLASH_STRING);
+
+    public IdManager(Context context, String str, FirebaseInstallationsApi firebaseInstallationsApi, DataCollectionArbiter dataCollectionArbiter) {
+        if (context == null) {
+            throw new IllegalArgumentException("appContext must not be null");
+        }
+        if (str == null) {
+            throw new IllegalArgumentException("appIdentifier must not be null");
+        }
+        this.appContext = context;
+        this.appIdentifier = str;
+        this.firebaseInstallationsApi = firebaseInstallationsApi;
+        this.dataCollectionArbiter = dataCollectionArbiter;
+        this.installerPackageNameProvider = new InstallerPackageNameProvider();
+    }
+
+    private synchronized String createAndCacheCrashlyticsInstallId(String str, SharedPreferences sharedPreferences) {
+        String formatId;
+        formatId = formatId(UUID.randomUUID().toString());
+        Logger.getLogger().v("Created new Crashlytics installation ID: " + formatId + " for FID: " + str);
+        sharedPreferences.edit().putString("crashlytics.installation.id", formatId).putString(PREFKEY_FIREBASE_IID, str).apply();
+        return formatId;
+    }
+
+    public static String createSyntheticFid() {
+        return SYNTHETIC_FID_PREFIX + UUID.randomUUID().toString();
+    }
+
+    private static String formatId(String str) {
+        if (str == null) {
+            return null;
+        }
+        return ID_PATTERN.matcher(str).replaceAll("").toLowerCase(Locale.US);
+    }
+
+    public static boolean isSyntheticFid(String str) {
+        return str != null && str.startsWith(SYNTHETIC_FID_PREFIX);
+    }
+
+    private String readCachedCrashlyticsInstallId(SharedPreferences sharedPreferences) {
+        return sharedPreferences.getString("crashlytics.installation.id", null);
+    }
+
+    private String removeForwardSlashesIn(String str) {
+        return str.replaceAll(FORWARD_SLASH_REGEX, "");
+    }
+
+    private boolean shouldRefresh() {
+        InstallIdProvider.InstallIds installIds = this.installIds;
+        if (installIds != null) {
+            return installIds.getFirebaseInstallationId() == null && this.dataCollectionArbiter.isAutomaticDataCollectionEnabled();
+        }
+        return true;
+    }
+
+    public String fetchTrueFid() {
+        try {
+            return (String) Utils.awaitEvenIfOnMainThread(this.firebaseInstallationsApi.getId());
+        } catch (Exception e4) {
+            Logger.getLogger().w("Failed to retrieve Firebase Installation ID.", e4);
+            return null;
+        }
+    }
+
+    public String getAppIdentifier() {
+        return this.appIdentifier;
+    }
+
+    @Override // com.google.firebase.crashlytics.internal.common.InstallIdProvider
+    public synchronized InstallIdProvider.InstallIds getInstallIds() {
+        if (!shouldRefresh()) {
+            return this.installIds;
+        }
+        Logger.getLogger().v("Determining Crashlytics installation ID...");
+        SharedPreferences sharedPrefs = CommonUtils.getSharedPrefs(this.appContext);
+        String string = sharedPrefs.getString(PREFKEY_FIREBASE_IID, null);
+        Logger.getLogger().v("Cached Firebase Installation ID: " + string);
+        if (this.dataCollectionArbiter.isAutomaticDataCollectionEnabled()) {
+            String fetchTrueFid = fetchTrueFid();
+            Logger.getLogger().v("Fetched Firebase Installation ID: " + fetchTrueFid);
+            if (fetchTrueFid == null) {
+                fetchTrueFid = string == null ? createSyntheticFid() : string;
+            }
+            if (fetchTrueFid.equals(string)) {
+                this.installIds = InstallIdProvider.InstallIds.create(readCachedCrashlyticsInstallId(sharedPrefs), fetchTrueFid);
+            } else {
+                this.installIds = InstallIdProvider.InstallIds.create(createAndCacheCrashlyticsInstallId(fetchTrueFid, sharedPrefs), fetchTrueFid);
+            }
+        } else if (isSyntheticFid(string)) {
+            this.installIds = InstallIdProvider.InstallIds.createWithoutFid(readCachedCrashlyticsInstallId(sharedPrefs));
+        } else {
+            this.installIds = InstallIdProvider.InstallIds.createWithoutFid(createAndCacheCrashlyticsInstallId(createSyntheticFid(), sharedPrefs));
+        }
+        Logger.getLogger().v("Install IDs: " + this.installIds);
+        return this.installIds;
+    }
+
+    public String getInstallerPackageName() {
+        return this.installerPackageNameProvider.getInstallerPackageName(this.appContext);
+    }
+
+    public String getModelName() {
+        Locale locale = Locale.US;
+        return removeForwardSlashesIn(Build.MANUFACTURER) + RemoteSettings.FORWARD_SLASH_STRING + removeForwardSlashesIn(Build.MODEL);
+    }
+
+    public String getOsBuildVersionString() {
+        return removeForwardSlashesIn(Build.VERSION.INCREMENTAL);
+    }
+
+    public String getOsDisplayVersionString() {
+        return removeForwardSlashesIn(Build.VERSION.RELEASE);
+    }
+}

apk_decompiled/sources/com/google/firebase/crashlytics/internal/common/InstallIdProvider.java

@@ -0,0 +1,25 @@
+package com.google.firebase.crashlytics.internal.common;
+
+import com.google.auto.value.AutoValue;
+
+/* loaded from: classes3.dex */
+public interface InstallIdProvider {
+
+    @AutoValue
+    /* loaded from: classes3.dex */
+    public static abstract class InstallIds {
+        public static InstallIds create(String str, String str2) {
+            return new AutoValue_InstallIdProvider_InstallIds(str, str2);
+        }
+
+        public static InstallIds createWithoutFid(String str) {
+            return create(str, null);
+        }
+
+        public abstract String getCrashlyticsInstallId();
+
+        public abstract String getFirebaseInstallationId();
+    }
+
+    InstallIds getInstallIds();
+}

apk_decompiled/sources/com/google/firebase/crashlytics/internal/common/InstallerPackageNameProvider.java

@@ -0,0 +1,24 @@
+package com.google.firebase.crashlytics.internal.common;
+
+import android.content.Context;
+
+/* loaded from: classes3.dex */
+class InstallerPackageNameProvider {
+    private static final String NO_INSTALLER_PACKAGE_NAME = "";
+    private String installerPackageName;
+
+    private static String loadInstallerPackageName(Context context) {
+        String installerPackageName = context.getPackageManager().getInstallerPackageName(context.getPackageName());
+        return installerPackageName == null ? "" : installerPackageName;
+    }
+
+    public synchronized String getInstallerPackageName(Context context) {
+        try {
+            if (this.installerPackageName == null) {
+                this.installerPackageName = loadInstallerPackageName(context);
+            }
+        } finally {
+        }
+        return "".equals(this.installerPackageName) ? null : this.installerPackageName;
+    }
+}

apk_decompiled/sources/com/google/firebase/crashlytics/internal/common/NativeSessionFile.java

@@ -0,0 +1,14 @@
+package com.google.firebase.crashlytics.internal.common;
+
+import com.google.firebase.crashlytics.internal.model.CrashlyticsReport;
+import java.io.InputStream;
+
+/* JADX INFO: Access modifiers changed from: package-private */
+/* loaded from: classes3.dex */
+public interface NativeSessionFile {
+    CrashlyticsReport.FilesPayload.File asFilePayload();
+
+    String getReportsEndpointFilename();
+
+    InputStream getStream();
+}

apk_decompiled/sources/com/google/firebase/crashlytics/internal/common/NativeSessionFileGzipper.java

@@ -0,0 +1,58 @@
+package com.google.firebase.crashlytics.internal.common;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+import java.util.zip.GZIPOutputStream;
+
+/* JADX INFO: Access modifiers changed from: package-private */
+/* loaded from: classes3.dex */
+public class NativeSessionFileGzipper {
+    private static void gzipInputStream(InputStream inputStream, File file) throws IOException {
+        if (inputStream == null) {
+            return;
+        }
+        byte[] bArr = new byte[8192];
+        GZIPOutputStream gZIPOutputStream = null;
+        try {
+            GZIPOutputStream gZIPOutputStream2 = new GZIPOutputStream(new FileOutputStream(file));
+            while (true) {
+                try {
+                    int read = inputStream.read(bArr);
+                    if (read <= 0) {
+                        gZIPOutputStream2.finish();
+                        CommonUtils.closeQuietly(gZIPOutputStream2);
+                        return;
+                    }
+                    gZIPOutputStream2.write(bArr, 0, read);
+                } catch (Throwable th) {
+                    th = th;
+                    gZIPOutputStream = gZIPOutputStream2;
+                    CommonUtils.closeQuietly(gZIPOutputStream);
+                    throw th;
+                }
+            }
+        } catch (Throwable th2) {
+            th = th2;
+        }
+    }
+
+    public static void processNativeSessions(File file, List<NativeSessionFile> list) {
+        for (NativeSessionFile nativeSessionFile : list) {
+            InputStream inputStream = null;
+            try {
+                inputStream = nativeSessionFile.getStream();
+                if (inputStream != null) {
+                    gzipInputStream(inputStream, new File(file, nativeSessionFile.getReportsEndpointFilename()));
+                }
+            } catch (IOException unused) {
+            } catch (Throwable th) {
+                CommonUtils.closeQuietly(null);
+                throw th;
+            }
+            CommonUtils.closeQuietly(inputStream);
+        }
+    }
+}

apk_decompiled/sources/com/google/firebase/crashlytics/internal/common/OnDemandCounter.java

@@ -0,0 +1,29 @@
+package com.google.firebase.crashlytics.internal.common;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+/* loaded from: classes3.dex */
+public final class OnDemandCounter {
+    private final AtomicInteger recordedOnDemandExceptions = new AtomicInteger();
+    private final AtomicInteger droppedOnDemandExceptions = new AtomicInteger();
+
+    public int getDroppedOnDemandExceptions() {
+        return this.droppedOnDemandExceptions.get();
+    }
+
+    public int getRecordedOnDemandExceptions() {
+        return this.recordedOnDemandExceptions.get();
+    }
+
+    public void incrementDroppedOnDemandExceptions() {
+        this.droppedOnDemandExceptions.getAndIncrement();
+    }
+
+    public void incrementRecordedOnDemandExceptions() {
+        this.recordedOnDemandExceptions.getAndIncrement();
+    }
+
+    public void resetDroppedOnDemandExceptions() {
+        this.droppedOnDemandExceptions.set(0);
+    }
+}

apk_decompiled/sources/com/google/firebase/crashlytics/internal/common/ResponseParser.java

@@ -0,0 +1,14 @@
+package com.google.firebase.crashlytics.internal.common;
+
+/* loaded from: classes3.dex */
+public class ResponseParser {
+    public static final int ResponseActionDiscard = 0;
+    public static final int ResponseActionRetry = 1;
+
+    public static int parse(int i) {
+        if (i < 200 || i > 299) {
+            return ((i < 300 || i > 399) && i >= 400 && i <= 499) ? 0 : 1;
+        }
+        return 0;
+    }
+}

apk_decompiled/sources/com/google/firebase/crashlytics/internal/common/SessionReportingCoordinator.java

@@ -0,0 +1,289 @@
+package com.google.firebase.crashlytics.internal.common;
+
+import I2.k;
+import android.app.ApplicationExitInfo;
+import android.content.Context;
+import com.google.android.gms.tasks.Task;
+import com.google.android.gms.tasks.Tasks;
+import com.google.firebase.crashlytics.internal.Logger;
+import com.google.firebase.crashlytics.internal.metadata.LogFileManager;
+import com.google.firebase.crashlytics.internal.metadata.UserMetadata;
+import com.google.firebase.crashlytics.internal.model.CrashlyticsReport;
+import com.google.firebase.crashlytics.internal.persistence.CrashlyticsReportPersistence;
+import com.google.firebase.crashlytics.internal.persistence.FileStore;
+import com.google.firebase.crashlytics.internal.send.DataTransportCrashlyticsReportSender;
+import com.google.firebase.crashlytics.internal.settings.SettingsProvider;
+import com.google.firebase.crashlytics.internal.stacktrace.StackTraceTrimmingStrategy;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.SortedSet;
+import java.util.concurrent.Executor;
+
+/* loaded from: classes3.dex */
+public class SessionReportingCoordinator implements CrashlyticsLifecycleEvents {
+    private static final int DEFAULT_BUFFER_SIZE = 8192;
+    private static final int EVENT_THREAD_IMPORTANCE = 4;
+    private static final String EVENT_TYPE_CRASH = "crash";
+    private static final String EVENT_TYPE_LOGGED = "error";
+    private static final int MAX_CHAINED_EXCEPTION_DEPTH = 8;
+    private final CrashlyticsReportDataCapture dataCapture;
+    private final IdManager idManager;
+    private final LogFileManager logFileManager;
+    private final UserMetadata reportMetadata;
+    private final CrashlyticsReportPersistence reportPersistence;
+    private final DataTransportCrashlyticsReportSender reportsSender;
+
+    public SessionReportingCoordinator(CrashlyticsReportDataCapture crashlyticsReportDataCapture, CrashlyticsReportPersistence crashlyticsReportPersistence, DataTransportCrashlyticsReportSender dataTransportCrashlyticsReportSender, LogFileManager logFileManager, UserMetadata userMetadata, IdManager idManager) {
+        this.dataCapture = crashlyticsReportDataCapture;
+        this.reportPersistence = crashlyticsReportPersistence;
+        this.reportsSender = dataTransportCrashlyticsReportSender;
+        this.logFileManager = logFileManager;
+        this.reportMetadata = userMetadata;
+        this.idManager = idManager;
+    }
+
+    private CrashlyticsReport.Session.Event addLogsAndCustomKeysToEvent(CrashlyticsReport.Session.Event event) {
+        return addLogsAndCustomKeysToEvent(event, this.logFileManager, this.reportMetadata);
+    }
+
+    private CrashlyticsReport.Session.Event addMetaDataToEvent(CrashlyticsReport.Session.Event event) {
+        return addRolloutsStateToEvent(addLogsAndCustomKeysToEvent(event, this.logFileManager, this.reportMetadata), this.reportMetadata);
+    }
+
+    private CrashlyticsReport.Session.Event addRolloutsStateToEvent(CrashlyticsReport.Session.Event event, UserMetadata userMetadata) {
+        List<CrashlyticsReport.Session.Event.RolloutAssignment> rolloutsState = userMetadata.getRolloutsState();
+        if (rolloutsState.isEmpty()) {
+            return event;
+        }
+        CrashlyticsReport.Session.Event.Builder builder = event.toBuilder();
+        builder.setRollouts(CrashlyticsReport.Session.Event.RolloutsState.builder().setRolloutAssignments(rolloutsState).build());
+        return builder.build();
+    }
+
+    private static CrashlyticsReport.ApplicationExitInfo convertApplicationExitInfo(ApplicationExitInfo applicationExitInfo) {
+        String applicationExitInfo2;
+        int importance;
+        String processName;
+        int reason;
+        long timestamp;
+        int pid;
+        long pss;
+        long rss;
+        InputStream traceInputStream;
+        String str = null;
+        try {
+            traceInputStream = applicationExitInfo.getTraceInputStream();
+            if (traceInputStream != null) {
+                str = convertInputStreamToString(traceInputStream);
+            }
+        } catch (IOException e4) {
+            Logger logger = Logger.getLogger();
+            StringBuilder sb = new StringBuilder("Could not get input trace in application exit info: ");
+            applicationExitInfo2 = applicationExitInfo.toString();
+            sb.append(applicationExitInfo2);
+            sb.append(" Error: ");
+            sb.append(e4);
+            logger.w(sb.toString());
+        }
+        CrashlyticsReport.ApplicationExitInfo.Builder builder = CrashlyticsReport.ApplicationExitInfo.builder();
+        importance = applicationExitInfo.getImportance();
+        CrashlyticsReport.ApplicationExitInfo.Builder importance2 = builder.setImportance(importance);
+        processName = applicationExitInfo.getProcessName();
+        CrashlyticsReport.ApplicationExitInfo.Builder processName2 = importance2.setProcessName(processName);
+        reason = applicationExitInfo.getReason();
+        CrashlyticsReport.ApplicationExitInfo.Builder reasonCode = processName2.setReasonCode(reason);
+        timestamp = applicationExitInfo.getTimestamp();
+        CrashlyticsReport.ApplicationExitInfo.Builder timestamp2 = reasonCode.setTimestamp(timestamp);
+        pid = applicationExitInfo.getPid();
+        CrashlyticsReport.ApplicationExitInfo.Builder pid2 = timestamp2.setPid(pid);
+        pss = applicationExitInfo.getPss();
+        CrashlyticsReport.ApplicationExitInfo.Builder pss2 = pid2.setPss(pss);
+        rss = applicationExitInfo.getRss();
+        return pss2.setRss(rss).setTraceFile(str).build();
+    }
+
+    public static String convertInputStreamToString(InputStream inputStream) throws IOException {
+        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+        byte[] bArr = new byte[8192];
+        while (true) {
+            int read = inputStream.read(bArr);
+            if (read == -1) {
+                return byteArrayOutputStream.toString(StandardCharsets.UTF_8.name());
+            }
+            byteArrayOutputStream.write(bArr, 0, read);
+        }
+    }
+
+    public static SessionReportingCoordinator create(Context context, IdManager idManager, FileStore fileStore, AppData appData, LogFileManager logFileManager, UserMetadata userMetadata, StackTraceTrimmingStrategy stackTraceTrimmingStrategy, SettingsProvider settingsProvider, OnDemandCounter onDemandCounter, CrashlyticsAppQualitySessionsSubscriber crashlyticsAppQualitySessionsSubscriber) {
+        return new SessionReportingCoordinator(new CrashlyticsReportDataCapture(context, idManager, appData, stackTraceTrimmingStrategy, settingsProvider), new CrashlyticsReportPersistence(fileStore, settingsProvider, crashlyticsAppQualitySessionsSubscriber), DataTransportCrashlyticsReportSender.create(context, settingsProvider, onDemandCounter), logFileManager, userMetadata, idManager);
+    }
+
+    private CrashlyticsReportWithSessionId ensureHasFid(CrashlyticsReportWithSessionId crashlyticsReportWithSessionId) {
+        if (crashlyticsReportWithSessionId.getReport().getFirebaseInstallationId() != null) {
+            return crashlyticsReportWithSessionId;
+        }
+        return CrashlyticsReportWithSessionId.create(crashlyticsReportWithSessionId.getReport().withFirebaseInstallationId(this.idManager.fetchTrueFid()), crashlyticsReportWithSessionId.getSessionId(), crashlyticsReportWithSessionId.getReportFile());
+    }
+
+    private ApplicationExitInfo findRelevantApplicationExitInfo(String str, List<ApplicationExitInfo> list) {
+        long timestamp;
+        int reason;
+        long startTimestampMillis = this.reportPersistence.getStartTimestampMillis(str);
+        Iterator<ApplicationExitInfo> it = list.iterator();
+        while (it.hasNext()) {
+            ApplicationExitInfo c4 = P.c.c(it.next());
+            timestamp = c4.getTimestamp();
+            if (timestamp < startTimestampMillis) {
+                return null;
+            }
+            reason = c4.getReason();
+            if (reason == 6) {
+                return c4;
+            }
+        }
+        return null;
+    }
+
+    private static List<CrashlyticsReport.CustomAttribute> getSortedCustomAttributes(Map<String, String> map) {
+        ArrayList arrayList = new ArrayList();
+        arrayList.ensureCapacity(map.size());
+        for (Map.Entry<String, String> entry : map.entrySet()) {
+            arrayList.add(CrashlyticsReport.CustomAttribute.builder().setKey(entry.getKey()).setValue(entry.getValue()).build());
+        }
+        Collections.sort(arrayList, new b(1));
+        return Collections.unmodifiableList(arrayList);
+    }
+
+    public static /* synthetic */ int lambda$getSortedCustomAttributes$0(CrashlyticsReport.CustomAttribute customAttribute, CrashlyticsReport.CustomAttribute customAttribute2) {
+        return customAttribute.getKey().compareTo(customAttribute2.getKey());
+    }
+
+    public boolean onReportSendComplete(Task<CrashlyticsReportWithSessionId> task) {
+        if (!task.isSuccessful()) {
+            Logger.getLogger().w("Crashlytics report could not be enqueued to DataTransport", task.getException());
+            return false;
+        }
+        CrashlyticsReportWithSessionId result = task.getResult();
+        Logger.getLogger().d("Crashlytics report successfully enqueued to DataTransport: " + result.getSessionId());
+        File reportFile = result.getReportFile();
+        if (reportFile.delete()) {
+            Logger.getLogger().d("Deleted report file: " + reportFile.getPath());
+            return true;
+        }
+        Logger.getLogger().w("Crashlytics could not delete report file: " + reportFile.getPath());
+        return true;
+    }
+
+    private void persistEvent(Throwable th, Thread thread, String str, String str2, long j4, boolean z3) {
+        this.reportPersistence.persistEvent(addMetaDataToEvent(this.dataCapture.captureEventData(th, thread, str2, j4, 4, 8, z3)), str, str2.equals("crash"));
+    }
+
+    public void finalizeSessionWithNativeEvent(String str, List<NativeSessionFile> list, CrashlyticsReport.ApplicationExitInfo applicationExitInfo) {
+        Logger.getLogger().d("SessionReportingCoordinator#finalizeSessionWithNativeEvent");
+        ArrayList arrayList = new ArrayList();
+        Iterator<NativeSessionFile> it = list.iterator();
+        while (it.hasNext()) {
+            CrashlyticsReport.FilesPayload.File asFilePayload = it.next().asFilePayload();
+            if (asFilePayload != null) {
+                arrayList.add(asFilePayload);
+            }
+        }
+        this.reportPersistence.finalizeSessionWithNativeEvent(str, CrashlyticsReport.FilesPayload.builder().setFiles(Collections.unmodifiableList(arrayList)).build(), applicationExitInfo);
+    }
+
+    public void finalizeSessions(long j4, String str) {
+        this.reportPersistence.finalizeReports(str, j4);
+    }
+
+    public boolean hasReportsToSend() {
+        return this.reportPersistence.hasFinalizedReports();
+    }
+
+    public SortedSet<String> listSortedOpenSessionIds() {
+        return this.reportPersistence.getOpenSessionIds();
+    }
+
+    @Override // com.google.firebase.crashlytics.internal.common.CrashlyticsLifecycleEvents
+    public void onBeginSession(String str, long j4) {
+        this.reportPersistence.persistReport(this.dataCapture.captureReportData(str, j4));
+    }
+
+    @Override // com.google.firebase.crashlytics.internal.common.CrashlyticsLifecycleEvents
+    public void onCustomKey(String str, String str2) {
+        this.reportMetadata.setCustomKey(str, str2);
+    }
+
+    @Override // com.google.firebase.crashlytics.internal.common.CrashlyticsLifecycleEvents
+    public void onLog(long j4, String str) {
+        this.logFileManager.writeToLog(j4, str);
+    }
+
+    @Override // com.google.firebase.crashlytics.internal.common.CrashlyticsLifecycleEvents
+    public void onUserId(String str) {
+        this.reportMetadata.setUserId(str);
+    }
+
+    public void persistFatalEvent(Throwable th, Thread thread, String str, long j4) {
+        Logger.getLogger().v("Persisting fatal event for session " + str);
+        persistEvent(th, thread, str, "crash", j4, true);
+    }
+
+    public void persistNonFatalEvent(Throwable th, Thread thread, String str, long j4) {
+        Logger.getLogger().v("Persisting non-fatal event for session " + str);
+        persistEvent(th, thread, str, "error", j4, false);
+    }
+
+    public void persistRelevantAppExitInfoEvent(String str, List<ApplicationExitInfo> list, LogFileManager logFileManager, UserMetadata userMetadata) {
+        ApplicationExitInfo findRelevantApplicationExitInfo = findRelevantApplicationExitInfo(str, list);
+        if (findRelevantApplicationExitInfo == null) {
+            Logger.getLogger().v("No relevant ApplicationExitInfo occurred during session: " + str);
+            return;
+        }
+        CrashlyticsReport.Session.Event captureAnrEventData = this.dataCapture.captureAnrEventData(convertApplicationExitInfo(findRelevantApplicationExitInfo));
+        Logger.getLogger().d("Persisting anr for session " + str);
+        this.reportPersistence.persistEvent(addRolloutsStateToEvent(addLogsAndCustomKeysToEvent(captureAnrEventData, logFileManager, userMetadata), userMetadata), str, true);
+    }
+
+    public void removeAllReports() {
+        this.reportPersistence.deleteAllReports();
+    }
+
+    public Task<Void> sendReports(Executor executor) {
+        return sendReports(executor, null);
+    }
+
+    private CrashlyticsReport.Session.Event addLogsAndCustomKeysToEvent(CrashlyticsReport.Session.Event event, LogFileManager logFileManager, UserMetadata userMetadata) {
+        CrashlyticsReport.Session.Event.Builder builder = event.toBuilder();
+        String logString = logFileManager.getLogString();
+        if (logString != null) {
+            builder.setLog(CrashlyticsReport.Session.Event.Log.builder().setContent(logString).build());
+        } else {
+            Logger.getLogger().v("No log data to include with this event.");
+        }
+        List<CrashlyticsReport.CustomAttribute> sortedCustomAttributes = getSortedCustomAttributes(userMetadata.getCustomKeys());
+        List<CrashlyticsReport.CustomAttribute> sortedCustomAttributes2 = getSortedCustomAttributes(userMetadata.getInternalKeys());
+        if (!sortedCustomAttributes.isEmpty() || !sortedCustomAttributes2.isEmpty()) {
+            builder.setApp(event.getApp().toBuilder().setCustomAttributes(sortedCustomAttributes).setInternalKeys(sortedCustomAttributes2).build());
+        }
+        return builder.build();
+    }
+
+    public Task<Void> sendReports(Executor executor, String str) {
+        List<CrashlyticsReportWithSessionId> loadFinalizedReports = this.reportPersistence.loadFinalizedReports();
+        ArrayList arrayList = new ArrayList();
+        for (CrashlyticsReportWithSessionId crashlyticsReportWithSessionId : loadFinalizedReports) {
+            if (str == null || str.equals(crashlyticsReportWithSessionId.getSessionId())) {
+                arrayList.add(this.reportsSender.enqueueReport(ensureHasFid(crashlyticsReportWithSessionId), str != null).continueWith(executor, new k(this, 17)));
+            }
+        }
+        return Tasks.whenAll(arrayList);
+    }
+}

apk_decompiled/sources/com/google/firebase/crashlytics/internal/common/SystemCurrentTimeProvider.java

@@ -0,0 +1,9 @@
+package com.google.firebase.crashlytics.internal.common;
+
+/* loaded from: classes3.dex */
+public class SystemCurrentTimeProvider implements CurrentTimeProvider {
+    @Override // com.google.firebase.crashlytics.internal.common.CurrentTimeProvider
+    public long getCurrentTimeMillis() {
+        return System.currentTimeMillis();
+    }
+}

apk_decompiled/sources/com/google/firebase/crashlytics/internal/common/Utils.java

@@ -0,0 +1,140 @@
+package com.google.firebase.crashlytics.internal.common;
+
+import I2.k;
+import android.annotation.SuppressLint;
+import android.os.Looper;
+import androidx.fragment.app.RunnableC0143e;
+import com.google.android.gms.tasks.Task;
+import com.google.android.gms.tasks.TaskCompletionSource;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+/* loaded from: classes3.dex */
+public final class Utils {
+    private static final ExecutorService TASK_CONTINUATION_EXECUTOR_SERVICE = ExecutorUtils.buildSingleThreadExecutorService("awaitEvenIfOnMainThread task continuation executor");
+    private static final int TIMEOUT_SEC = 4;
+
+    private Utils() {
+    }
+
+    public static <T> T awaitEvenIfOnMainThread(Task<T> task) throws InterruptedException, TimeoutException {
+        CountDownLatch countDownLatch = new CountDownLatch(1);
+        task.continueWith(TASK_CONTINUATION_EXECUTOR_SERVICE, new k(countDownLatch, 18));
+        if (Looper.getMainLooper() == Looper.myLooper()) {
+            countDownLatch.await(3L, TimeUnit.SECONDS);
+        } else {
+            countDownLatch.await(4L, TimeUnit.SECONDS);
+        }
+        if (task.isSuccessful()) {
+            return task.getResult();
+        }
+        if (task.isCanceled()) {
+            throw new CancellationException("Task is already canceled");
+        }
+        if (task.isComplete()) {
+            throw new IllegalStateException(task.getException());
+        }
+        throw new TimeoutException();
+    }
+
+    public static boolean awaitUninterruptibly(CountDownLatch countDownLatch, long j4, TimeUnit timeUnit) {
+        boolean z3 = false;
+        try {
+            long nanos = timeUnit.toNanos(j4);
+            while (true) {
+                try {
+                    break;
+                } catch (InterruptedException unused) {
+                    z3 = true;
+                    nanos = (System.nanoTime() + nanos) - System.nanoTime();
+                }
+            }
+            return countDownLatch.await(nanos, TimeUnit.NANOSECONDS);
+        } finally {
+            if (z3) {
+                Thread.currentThread().interrupt();
+            }
+        }
+    }
+
+    public static /* synthetic */ Object b(CountDownLatch countDownLatch, Task task) {
+        return lambda$awaitEvenIfOnMainThread$4(countDownLatch, task);
+    }
+
+    public static <T> Task<T> callTask(Executor executor, Callable<Task<T>> callable) {
+        TaskCompletionSource taskCompletionSource = new TaskCompletionSource();
+        executor.execute(new RunnableC0143e(callable, executor, taskCompletionSource, 3));
+        return taskCompletionSource.getTask();
+    }
+
+    public static /* synthetic */ Object lambda$awaitEvenIfOnMainThread$4(CountDownLatch countDownLatch, Task task) throws Exception {
+        countDownLatch.countDown();
+        return null;
+    }
+
+    public static /* synthetic */ Object lambda$callTask$2(TaskCompletionSource taskCompletionSource, Task task) throws Exception {
+        if (task.isSuccessful()) {
+            taskCompletionSource.setResult(task.getResult());
+            return null;
+        }
+        if (task.getException() == null) {
+            return null;
+        }
+        taskCompletionSource.setException(task.getException());
+        return null;
+    }
+
+    public static /* synthetic */ void lambda$callTask$3(Callable callable, Executor executor, TaskCompletionSource taskCompletionSource) {
+        try {
+            ((Task) callable.call()).continueWith(executor, new d(1, taskCompletionSource));
+        } catch (Exception e4) {
+            taskCompletionSource.setException(e4);
+        }
+    }
+
+    public static /* synthetic */ Void lambda$race$0(TaskCompletionSource taskCompletionSource, Task task) throws Exception {
+        if (task.isSuccessful()) {
+            taskCompletionSource.trySetResult(task.getResult());
+            return null;
+        }
+        if (task.getException() == null) {
+            return null;
+        }
+        taskCompletionSource.trySetException(task.getException());
+        return null;
+    }
+
+    public static /* synthetic */ Void lambda$race$1(TaskCompletionSource taskCompletionSource, Task task) throws Exception {
+        if (task.isSuccessful()) {
+            taskCompletionSource.trySetResult(task.getResult());
+            return null;
+        }
+        if (task.getException() == null) {
+            return null;
+        }
+        taskCompletionSource.trySetException(task.getException());
+        return null;
+    }
+
+    @SuppressLint({"TaskMainThread"})
+    public static <T> Task<T> race(Task<T> task, Task<T> task2) {
+        TaskCompletionSource taskCompletionSource = new TaskCompletionSource();
+        d dVar = new d(0, taskCompletionSource);
+        task.continueWith(dVar);
+        task2.continueWith(dVar);
+        return taskCompletionSource.getTask();
+    }
+
+    public static <T> Task<T> race(Executor executor, Task<T> task, Task<T> task2) {
+        TaskCompletionSource taskCompletionSource = new TaskCompletionSource();
+        d dVar = new d(2, taskCompletionSource);
+        task.continueWith(executor, dVar);
+        task2.continueWith(executor, dVar);
+        return taskCompletionSource.getTask();
+    }
+}

apk_decompiled/sources/com/google/firebase/crashlytics/internal/common/a.java

@@ -0,0 +1,25 @@
+package com.google.firebase.crashlytics.internal.common;
+
+import java.io.File;
+import java.io.FilenameFilter;
+
+/* loaded from: classes3.dex */
+public final /* synthetic */ class a implements FilenameFilter {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ int f5967a;
+
+    public /* synthetic */ a(int i) {
+        this.f5967a = i;
+    }
+
+    @Override // java.io.FilenameFilter
+    public final boolean accept(File file, String str) {
+        switch (this.f5967a) {
+            case 0:
+                return CrashlyticsAppQualitySessionsStore.a(file, str);
+            default:
+                return CrashlyticsController.a(file, str);
+        }
+    }
+}

apk_decompiled/sources/com/google/firebase/crashlytics/internal/common/b.java

@@ -0,0 +1,28 @@
+package com.google.firebase.crashlytics.internal.common;
+
+import com.google.firebase.crashlytics.internal.model.CrashlyticsReport;
+import java.io.File;
+import java.util.Comparator;
+
+/* loaded from: classes3.dex */
+public final /* synthetic */ class b implements Comparator {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ int f5968a;
+
+    public /* synthetic */ b(int i) {
+        this.f5968a = i;
+    }
+
+    @Override // java.util.Comparator
+    public final int compare(Object obj, Object obj2) {
+        int lambda$static$1;
+        switch (this.f5968a) {
+            case 0:
+                lambda$static$1 = CrashlyticsAppQualitySessionsStore.lambda$static$1((File) obj, (File) obj2);
+                return lambda$static$1;
+            default:
+                return SessionReportingCoordinator.a((CrashlyticsReport.CustomAttribute) obj, (CrashlyticsReport.CustomAttribute) obj2);
+        }
+    }
+}

apk_decompiled/sources/com/google/firebase/crashlytics/internal/common/d.java

@@ -0,0 +1,40 @@
+package com.google.firebase.crashlytics.internal.common;
+
+import com.google.android.gms.tasks.Continuation;
+import com.google.android.gms.tasks.Task;
+import com.google.android.gms.tasks.TaskCompletionSource;
+
+/* loaded from: classes3.dex */
+public final /* synthetic */ class d implements Continuation {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ int f5970a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ TaskCompletionSource f5971b;
+
+    public /* synthetic */ d(int i, TaskCompletionSource taskCompletionSource) {
+        this.f5970a = i;
+        this.f5971b = taskCompletionSource;
+    }
+
+    @Override // com.google.android.gms.tasks.Continuation
+    public final Object then(Task task) {
+        Void lambda$race$0;
+        Object lambda$callTask$2;
+        Void lambda$race$1;
+        int i = this.f5970a;
+        TaskCompletionSource taskCompletionSource = this.f5971b;
+        switch (i) {
+            case 0:
+                lambda$race$0 = Utils.lambda$race$0(taskCompletionSource, task);
+                return lambda$race$0;
+            case 1:
+                lambda$callTask$2 = Utils.lambda$callTask$2(taskCompletionSource, task);
+                return lambda$callTask$2;
+            default:
+                lambda$race$1 = Utils.lambda$race$1(taskCompletionSource, task);
+                return lambda$race$1;
+        }
+    }
+}