Add decompiled APK source code (JADX)

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

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

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

@@ -0,0 +1,51 @@
+package com.google.firebase.crashlytics.internal.common;
+
+import android.content.Context;
+import android.content.pm.PackageInfo;
+import android.os.Build;
+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 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 static AppData create(Context context, IdManager idManager, String str, String str2, List list, DevelopmentPlatformProvider developmentPlatformProvider) {
+        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 = "0.0";
+        }
+        return new AppData(str, str2, list, installerPackageName, packageName, appBuildVersion, str3, developmentPlatformProvider);
+    }
+
+    public static String getAppBuildVersion(PackageInfo packageInfo) {
+        long longVersionCode;
+        if (Build.VERSION.SDK_INT >= 28) {
+            longVersionCode = packageInfo.getLongVersionCode();
+            return Long.toString(longVersionCode);
+        }
+        return Integer.toString(packageInfo.versionCode);
+    }
+
+    public AppData(String str, String str2, List 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;
+    }
+}

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

@@ -0,0 +1,60 @@
+package com.google.firebase.crashlytics.internal.common;
+
+import com.google.firebase.crashlytics.internal.model.CrashlyticsReport;
+import java.io.File;
+
+/* loaded from: classes3.dex */
+public final class AutoValue_CrashlyticsReportWithSessionId extends CrashlyticsReportWithSessionId {
+    public final CrashlyticsReport report;
+    public final File reportFile;
+    public final String sessionId;
+
+    @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 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 String toString() {
+        return "CrashlyticsReportWithSessionId{report=" + this.report + ", sessionId=" + this.sessionId + ", reportFile=" + this.reportFile + "}";
+    }
+
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (!(obj instanceof CrashlyticsReportWithSessionId)) {
+            return false;
+        }
+        CrashlyticsReportWithSessionId crashlyticsReportWithSessionId = (CrashlyticsReportWithSessionId) obj;
+        return this.report.equals(crashlyticsReportWithSessionId.getReport()) && this.sessionId.equals(crashlyticsReportWithSessionId.getSessionId()) && this.reportFile.equals(crashlyticsReportWithSessionId.getReportFile());
+    }
+
+    public int hashCode() {
+        return ((((this.report.hashCode() ^ 1000003) * 1000003) ^ this.sessionId.hashCode()) * 1000003) ^ this.reportFile.hashCode();
+    }
+}

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

@@ -0,0 +1,68 @@
+package com.google.firebase.crashlytics.internal.common;
+
+import com.google.firebase.crashlytics.internal.common.InstallIdProvider;
+
+/* loaded from: classes3.dex */
+public final class AutoValue_InstallIdProvider_InstallIds extends InstallIdProvider.InstallIds {
+    public final String crashlyticsInstallId;
+    public final String firebaseAuthenticationToken;
+    public final String firebaseInstallationId;
+
+    @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 getFirebaseAuthenticationToken() {
+        return this.firebaseAuthenticationToken;
+    }
+
+    @Override // com.google.firebase.crashlytics.internal.common.InstallIdProvider.InstallIds
+    public String getFirebaseInstallationId() {
+        return this.firebaseInstallationId;
+    }
+
+    public AutoValue_InstallIdProvider_InstallIds(String str, String str2, String str3) {
+        if (str == null) {
+            throw new NullPointerException("Null crashlyticsInstallId");
+        }
+        this.crashlyticsInstallId = str;
+        this.firebaseInstallationId = str2;
+        this.firebaseAuthenticationToken = str3;
+    }
+
+    public String toString() {
+        return "InstallIds{crashlyticsInstallId=" + this.crashlyticsInstallId + ", firebaseInstallationId=" + this.firebaseInstallationId + ", firebaseAuthenticationToken=" + this.firebaseAuthenticationToken + "}";
+    }
+
+    public boolean equals(Object obj) {
+        String str;
+        if (obj == this) {
+            return true;
+        }
+        if (!(obj instanceof InstallIdProvider.InstallIds)) {
+            return false;
+        }
+        InstallIdProvider.InstallIds installIds = (InstallIdProvider.InstallIds) obj;
+        if (this.crashlyticsInstallId.equals(installIds.getCrashlyticsInstallId()) && ((str = this.firebaseInstallationId) != null ? str.equals(installIds.getFirebaseInstallationId()) : installIds.getFirebaseInstallationId() == null)) {
+            String str2 = this.firebaseAuthenticationToken;
+            if (str2 == null) {
+                if (installIds.getFirebaseAuthenticationToken() == null) {
+                    return true;
+                }
+            } else if (str2.equals(installIds.getFirebaseAuthenticationToken())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public int hashCode() {
+        int hashCode = (this.crashlyticsInstallId.hashCode() ^ 1000003) * 1000003;
+        String str = this.firebaseInstallationId;
+        int hashCode2 = (hashCode ^ (str == null ? 0 : str.hashCode())) * 1000003;
+        String str2 = this.firebaseAuthenticationToken;
+        return hashCode2 ^ (str2 != null ? str2.hashCode() : 0);
+    }
+}

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();
+    }
+}

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

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

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 {
+    public final String arch;
+    public final String buildId;
+    public final String libraryName;
+
+    public String getArch() {
+        return this.arch;
+    }
+
+    public String getBuildId() {
+        return this.buildId;
+    }
+
+    public String getLibraryName() {
+        return this.libraryName;
+    }
+
+    public BuildIdInfo(String str, String str2, String str3) {
+        this.libraryName = str;
+        this.arch = str2;
+        this.buildId = str3;
+    }
+}

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

@@ -0,0 +1,72 @@
+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;
+
+/* loaded from: classes3.dex */
+public class BytesBackedNativeSessionFile implements NativeSessionFile {
+    public final byte[] bytes;
+    public final String dataTransportFilename;
+    public final String reportsEndpointFilename;
+
+    @Override // com.google.firebase.crashlytics.internal.common.NativeSessionFile
+    public String getReportsEndpointFilename() {
+        return this.reportsEndpointFilename;
+    }
+
+    public BytesBackedNativeSessionFile(String str, String str2, byte[] bArr) {
+        this.dataTransportFilename = str;
+        this.reportsEndpointFilename = str2;
+        this.bytes = bArr;
+    }
+
+    @Override // com.google.firebase.crashlytics.internal.common.NativeSessionFile
+    public InputStream getStream() {
+        if (isEmpty()) {
+            return null;
+        }
+        return new ByteArrayInputStream(this.bytes);
+    }
+
+    @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();
+    }
+
+    public final boolean isEmpty() {
+        byte[] bArr = this.bytes;
+        return bArr == null || bArr.length == 0;
+    }
+
+    public final 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 {
+                }
+            } finally {
+            }
+        } catch (IOException unused) {
+            return null;
+        }
+    }
+}

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

@@ -0,0 +1,69 @@
+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;
+
+/* loaded from: classes3.dex */
+public class CLSUUID {
+    public static String _clsId;
+    public static final AtomicLong _sequenceNumber = new AtomicLong(0);
+
+    public String toString() {
+        return _clsId;
+    }
+
+    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);
+    }
+
+    public final 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 final void populateSequenceNumber(byte[] bArr) {
+        byte[] convertLongToTwoByteBuffer = convertLongToTwoByteBuffer(_sequenceNumber.incrementAndGet());
+        bArr[6] = convertLongToTwoByteBuffer[0];
+        bArr[7] = convertLongToTwoByteBuffer[1];
+    }
+
+    public final void populatePID(byte[] bArr) {
+        byte[] convertLongToTwoByteBuffer = convertLongToTwoByteBuffer(Integer.valueOf(Process.myPid()).shortValue());
+        bArr[8] = convertLongToTwoByteBuffer[0];
+        bArr[9] = convertLongToTwoByteBuffer[1];
+    }
+
+    public static byte[] convertLongToFourByteBuffer(long j) {
+        ByteBuffer allocate = ByteBuffer.allocate(4);
+        allocate.putInt((int) j);
+        allocate.order(ByteOrder.BIG_ENDIAN);
+        allocate.position(0);
+        return allocate.array();
+    }
+
+    public static byte[] convertLongToTwoByteBuffer(long j) {
+        ByteBuffer allocate = ByteBuffer.allocate(2);
+        allocate.putShort((short) j);
+        allocate.order(ByteOrder.BIG_ENDIAN);
+        allocate.position(0);
+        return allocate.array();
+    }
+}

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

@@ -0,0 +1,330 @@
+package com.google.firebase.crashlytics.internal.common;
+
+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.applovin.exoplayer2.common.base.Ascii;
+import com.google.firebase.crashlytics.internal.Logger;
+import com.unity3d.ads.core.data.datasource.AndroidStaticDeviceInfoDataSource;
+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;
+
+/* loaded from: classes3.dex */
+public abstract class CommonUtils {
+    public static final char[] HEX_VALUES = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
+
+    public static SharedPreferences getSharedPrefs(Context context) {
+        return context.getSharedPreferences("com.google.firebase.crashlytics", 0);
+    }
+
+    public static int getCpuArchitectureInt() {
+        return Architecture.getValue().ordinal();
+    }
+
+    /* JADX WARN: Enum visitor error
+    jadx.core.utils.exceptions.JadxRuntimeException: Can't remove SSA var: r0v0 com.google.firebase.crashlytics.internal.common.CommonUtils$Architecture, still in use, count: 1, list:
+  (r0v0 com.google.firebase.crashlytics.internal.common.CommonUtils$Architecture) from 0x0084: INVOKE (r5v5 java.util.HashMap), ("x86"), (r0v0 com.google.firebase.crashlytics.internal.common.CommonUtils$Architecture) INTERFACE call: java.util.Map.put(java.lang.Object, java.lang.Object):java.lang.Object A[MD:(K, V):V (c)] (LINE:114)
+    	at jadx.core.utils.InsnRemover.removeSsaVar(InsnRemover.java:162)
+    	at jadx.core.utils.InsnRemover.unbindResult(InsnRemover.java:127)
+    	at jadx.core.utils.InsnRemover.lambda$unbindInsns$1(InsnRemover.java:99)
+    	at java.base/java.util.ArrayList.forEach(ArrayList.java:1596)
+    	at jadx.core.utils.InsnRemover.unbindInsns(InsnRemover.java:98)
+    	at jadx.core.utils.InsnRemover.removeAllAndUnbind(InsnRemover.java:252)
+    	at jadx.core.dex.visitors.EnumVisitor.convertToEnum(EnumVisitor.java:180)
+    	at jadx.core.dex.visitors.EnumVisitor.visit(EnumVisitor.java:100)
+     */
+    /* JADX WARN: Failed to restore enum class, 'enum' modifier and super class removed */
+    public static final class Architecture {
+        X86_32,
+        X86_64,
+        ARM_UNKNOWN,
+        PPC,
+        PPC64,
+        ARMV6,
+        ARMV7,
+        UNKNOWN,
+        ARMV7S,
+        ARM64;
+
+        private static final Map<String, Architecture> matcher;
+
+        private Architecture() {
+        }
+
+        public static Architecture valueOf(String str) {
+            return (Architecture) Enum.valueOf(Architecture.class, str);
+        }
+
+        public static Architecture[] values() {
+            return (Architecture[]) $VALUES.clone();
+        }
+
+        static {
+            HashMap hashMap = new HashMap(4);
+            matcher = hashMap;
+            hashMap.put("armeabi-v7a", new Architecture());
+            hashMap.put("armeabi", new Architecture());
+            hashMap.put("arm64-v8a", new Architecture());
+            hashMap.put("x86", new 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 String streamToString(InputStream inputStream) {
+        Scanner useDelimiter = new Scanner(inputStream).useDelimiter("\\A");
+        return useDelimiter.hasNext() ? useDelimiter.next() : "";
+    }
+
+    public static String sha1(String str) {
+        return hash(str, AndroidStaticDeviceInfoDataSource.ALGORITHM_SHA1);
+    }
+
+    public static String hash(String str, String str2) {
+        return hash(str.getBytes(), str2);
+    }
+
+    public static String hash(byte[] bArr, String str) {
+        try {
+            MessageDigest messageDigest = MessageDigest.getInstance(str);
+            messageDigest.update(bArr);
+            return hexify(messageDigest.digest());
+        } catch (NoSuchAlgorithmException e) {
+            Logger.getLogger().e("Could not create hashing algorithm: " + str + ", returning empty string.", e);
+            return "";
+        }
+    }
+
+    public static String createInstanceIdFrom(String... strArr) {
+        if (strArr == null || strArr.length == 0) {
+            return null;
+        }
+        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 synchronized long calculateTotalRamInBytes(Context context) {
+        long j;
+        synchronized (CommonUtils.class) {
+            ActivityManager.MemoryInfo memoryInfo = new ActivityManager.MemoryInfo();
+            ((ActivityManager) context.getSystemService("activity")).getMemoryInfo(memoryInfo);
+            j = memoryInfo.totalMem;
+        }
+        return j;
+    }
+
+    public static long calculateFreeRamInBytes(Context context) {
+        ActivityManager.MemoryInfo memoryInfo = new ActivityManager.MemoryInfo();
+        ((ActivityManager) context.getSystemService("activity")).getMemoryInfo(memoryInfo);
+        return memoryInfo.availMem;
+    }
+
+    public static long calculateUsedDiskSpaceInBytes(String str) {
+        long blockSize = new StatFs(str).getBlockSize();
+        return (r0.getBlockCount() * blockSize) - (blockSize * r0.getAvailableBlocks());
+    }
+
+    public static boolean getProximitySensorEnabled(Context context) {
+        return (isEmulator() || ((SensorManager) context.getSystemService("sensor")).getDefaultSensor(8) == null) ? false : true;
+    }
+
+    public static boolean getBooleanResourceValue(Context context, String str, boolean z) {
+        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 z;
+    }
+
+    public static int getResourcesIdentifier(Context context, String str, String str2) {
+        return context.getResources().getIdentifier(str, str2, getResourcePackageName(context));
+    }
+
+    public static boolean isEmulator() {
+        if (!Build.PRODUCT.contains("sdk")) {
+            String str = Build.HARDWARE;
+            if (!str.contains("goldfish") && !str.contains("ranchu")) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    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 isDebuggerAttached() {
+        return Debug.isDebuggerConnected() || Debug.waitingForDebugger();
+    }
+
+    /* 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();
+        ?? r0 = isEmulator;
+        if (isRooted()) {
+            r0 = (isEmulator ? 1 : 0) | 2;
+        }
+        return isDebuggerAttached() ? r0 | 4 : r0;
+    }
+
+    public static String hexify(byte[] bArr) {
+        char[] cArr = new char[bArr.length * 2];
+        for (int i = 0; i < bArr.length; i++) {
+            byte b = bArr[i];
+            int i2 = i * 2;
+            char[] cArr2 = HEX_VALUES;
+            cArr[i2] = cArr2[(b & 255) >>> 4];
+            cArr[i2 + 1] = cArr2[b & Ascii.SI];
+        }
+        return new String(cArr);
+    }
+
+    public static boolean isAppDebuggable(Context context) {
+        return (context.getApplicationInfo().flags & 2) != 0;
+    }
+
+    public static void closeOrLog(Closeable closeable, String str) {
+        if (closeable != null) {
+            try {
+                closeable.close();
+            } catch (IOException e) {
+                Logger.getLogger().e(str, e);
+            }
+        }
+    }
+
+    public static String getResourcePackageName(Context context) {
+        int i = context.getApplicationContext().getApplicationInfo().icon;
+        if (i > 0) {
+            try {
+                String resourcePackageName = context.getResources().getResourcePackageName(i);
+                return "android".equals(resourcePackageName) ? context.getPackageName() : resourcePackageName;
+            } catch (Resources.NotFoundException unused) {
+                return context.getPackageName();
+            }
+        }
+        return context.getPackageName();
+    }
+
+    public static String getMappingFileId(Context context) {
+        int resourcesIdentifier = getResourcesIdentifier(context, "com.google.firebase.crashlytics.mapping_file_id", "string");
+        if (resourcesIdentifier == 0) {
+            resourcesIdentifier = getResourcesIdentifier(context, "com.crashlytics.android.build_id", "string");
+        }
+        if (resourcesIdentifier != 0) {
+            return context.getResources().getString(resourcesIdentifier);
+        }
+        return null;
+    }
+
+    public static List getBuildIdInfo(Context context) {
+        ArrayList arrayList = new ArrayList();
+        int resourcesIdentifier = getResourcesIdentifier(context, "com.google.firebase.crashlytics.build_ids_lib", "array");
+        int resourcesIdentifier2 = getResourcesIdentifier(context, "com.google.firebase.crashlytics.build_ids_arch", "array");
+        int resourcesIdentifier3 = getResourcesIdentifier(context, "com.google.firebase.crashlytics.build_ids_build_id", "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 void closeQuietly(Closeable closeable) {
+        if (closeable != null) {
+            try {
+                closeable.close();
+            } catch (RuntimeException e) {
+                throw e;
+            } catch (Exception unused) {
+            }
+        }
+    }
+
+    public static boolean checkPermission(Context context, String str) {
+        return context.checkCallingOrSelfPermission(str) == 0;
+    }
+
+    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 nullSafeEquals(String str, String str2) {
+        if (str == null) {
+            return str2 == null;
+        }
+        return str.equals(str2);
+    }
+}

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

@@ -0,0 +1,87 @@
+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 {
+    public static final FilenameFilter AQS_SESSION_ID_FILE_FILTER = new FilenameFilter() { // from class: com.google.firebase.crashlytics.internal.common.CrashlyticsAppQualitySessionsStore$$ExternalSyntheticLambda0
+        @Override // java.io.FilenameFilter
+        public final boolean accept(File file, String str) {
+            boolean lambda$static$0;
+            lambda$static$0 = CrashlyticsAppQualitySessionsStore.lambda$static$0(file, str);
+            return lambda$static$0;
+        }
+    };
+    public static final Comparator FILE_RECENCY_COMPARATOR = new Comparator() { // from class: com.google.firebase.crashlytics.internal.common.CrashlyticsAppQualitySessionsStore$$ExternalSyntheticLambda1
+        @Override // java.util.Comparator
+        public final int compare(Object obj, Object obj2) {
+            int lambda$static$1;
+            lambda$static$1 = CrashlyticsAppQualitySessionsStore.lambda$static$1((File) obj, (File) obj2);
+            return lambda$static$1;
+        }
+    };
+    public final FileStore fileStore;
+    public String sessionId = null;
+    public String appQualitySessionId = null;
+
+    public static /* synthetic */ boolean lambda$static$0(File file, String str) {
+        return str.startsWith("aqs.");
+    }
+
+    public static /* synthetic */ int lambda$static$1(File file, File file2) {
+        return Long.compare(file2.lastModified(), file.lastModified());
+    }
+
+    public CrashlyticsAppQualitySessionsStore(FileStore fileStore) {
+        this.fileStore = fileStore;
+    }
+
+    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;
+        }
+    }
+
+    public static void persist(FileStore fileStore, String str, String str2) {
+        if (str == null || str2 == null) {
+            return;
+        }
+        try {
+            fileStore.getSessionFile(str, "aqs." + str2).createNewFile();
+        } catch (IOException e) {
+            Logger.getLogger().w("Failed to persist App Quality Sessions session id.", e);
+        }
+    }
+
+    public static String readAqsSessionIdFile(FileStore fileStore, String str) {
+        List sessionFiles = fileStore.getSessionFiles(str, AQS_SESSION_ID_FILE_FILTER);
+        if (sessionFiles.isEmpty()) {
+            Logger.getLogger().w("Unable to read App Quality Sessions session id.");
+            return null;
+        }
+        return ((File) Collections.min(sessionFiles, FILE_RECENCY_COMPARATOR)).getName().substring(4);
+    }
+}

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 {
+    public final CrashlyticsAppQualitySessionsStore appQualitySessionsStore;
+    public 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);
+    }
+
+    public void setSessionId(String str) {
+        this.appQualitySessionsStore.rotateSessionId(str);
+    }
+
+    @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());
+    }
+
+    @Override // com.google.firebase.sessions.api.SessionSubscriber
+    public boolean isDataCollectionEnabled() {
+        return this.dataCollectionArbiter.isAutomaticDataCollectionEnabled();
+    }
+
+    @Override // com.google.firebase.sessions.api.SessionSubscriber
+    public SessionSubscriber.Name getSessionSubscriberName() {
+        return SessionSubscriber.Name.CRASHLYTICS;
+    }
+}

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

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

@@ -0,0 +1,602 @@
+package com.google.firebase.crashlytics.internal.common;
+
+import android.app.ActivityManager;
+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 com.ironsource.ad;
+import com.mbridge.msdk.MBridgeConstans;
+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.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 {
+    public static final FilenameFilter APP_EXCEPTION_MARKER_FILTER = new FilenameFilter() { // from class: com.google.firebase.crashlytics.internal.common.CrashlyticsController$$ExternalSyntheticLambda0
+        @Override // java.io.FilenameFilter
+        public final boolean accept(File file, String str) {
+            boolean lambda$static$0;
+            lambda$static$0 = CrashlyticsController.lambda$static$0(file, str);
+            return lambda$static$0;
+        }
+    };
+    public final AnalyticsEventLogger analyticsEventLogger;
+    public final AppData appData;
+    public final CrashlyticsBackgroundWorker backgroundWorker;
+    public final Context context;
+    public CrashlyticsUncaughtExceptionHandler crashHandler;
+    public final CrashlyticsFileMarker crashMarker;
+    public final DataCollectionArbiter dataCollectionArbiter;
+    public final FileStore fileStore;
+    public final IdManager idManager;
+    public final LogFileManager logFileManager;
+    public final CrashlyticsNativeComponent nativeComponent;
+    public final SessionReportingCoordinator reportingCoordinator;
+    public final CrashlyticsAppQualitySessionsSubscriber sessionsSubscriber;
+    public final UserMetadata userMetadata;
+    public SettingsProvider settingsProvider = null;
+    public final TaskCompletionSource unsentReportsAvailable = new TaskCompletionSource();
+    public final TaskCompletionSource reportActionProvided = new TaskCompletionSource();
+    public final TaskCompletionSource unsentReportsHandled = new TaskCompletionSource();
+    public final AtomicBoolean checkForUnsentReportsCalled = new AtomicBoolean(false);
+
+    public static /* synthetic */ boolean lambda$static$0(File file, String str) {
+        return str.startsWith(".ae");
+    }
+
+    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;
+    }
+
+    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
+            @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 void handleUncaughtException(SettingsProvider settingsProvider, Thread thread, Throwable th) {
+        handleUncaughtException(settingsProvider, thread, th, false);
+    }
+
+    public synchronized void handleUncaughtException(final SettingsProvider settingsProvider, final Thread thread, final Throwable th, final boolean z) {
+        Logger.getLogger().d("Handling uncaught exception \"" + th + "\" from thread " + thread.getName());
+        final long currentTimeMillis = System.currentTimeMillis();
+        try {
+            Utils.awaitEvenIfOnMainThread(this.backgroundWorker.submitTask(new Callable() { // from class: com.google.firebase.crashlytics.internal.common.CrashlyticsController.2
+                @Override // java.util.concurrent.Callable
+                public Task call() {
+                    long timestampSeconds = CrashlyticsController.getTimestampSeconds(currentTimeMillis);
+                    final String currentSessionId = CrashlyticsController.this.getCurrentSessionId();
+                    if (currentSessionId != null) {
+                        CrashlyticsController.this.crashMarker.create();
+                        CrashlyticsController.this.reportingCoordinator.persistFatalEvent(th, thread, currentSessionId, timestampSeconds);
+                        CrashlyticsController.this.doWriteAppExceptionMarker(currentTimeMillis);
+                        CrashlyticsController.this.doCloseSessions(settingsProvider);
+                        CrashlyticsController.this.doOpenSession(new CLSUUID(CrashlyticsController.this.idManager).toString(), Boolean.valueOf(z));
+                        if (CrashlyticsController.this.dataCollectionArbiter.isAutomaticDataCollectionEnabled()) {
+                            final Executor executor = CrashlyticsController.this.backgroundWorker.getExecutor();
+                            return settingsProvider.getSettingsAsync().onSuccessTask(executor, new SuccessContinuation() { // from class: com.google.firebase.crashlytics.internal.common.CrashlyticsController.2.1
+                                @Override // com.google.android.gms.tasks.SuccessContinuation
+                                public Task then(Settings settings) {
+                                    if (settings != null) {
+                                        Task[] taskArr = new Task[2];
+                                        taskArr[0] = CrashlyticsController.this.logAnalyticsAppExceptionEvents();
+                                        taskArr[1] = CrashlyticsController.this.reportingCoordinator.sendReports(executor, z ? currentSessionId : null);
+                                        return Tasks.whenAll((Task<?>[]) taskArr);
+                                    }
+                                    Logger.getLogger().w("Received null app settings, cannot send reports at crash time.");
+                                    return Tasks.forResult(null);
+                                }
+                            });
+                        }
+                        return Tasks.forResult(null);
+                    }
+                    Logger.getLogger().e("Tried to write a fatal exception while no session was open.");
+                    return Tasks.forResult(null);
+                }
+            }));
+        } catch (TimeoutException unused) {
+            Logger.getLogger().e("Cannot send reports. Timed out while fetching settings.");
+        } catch (Exception e) {
+            Logger.getLogger().e("Error handling uncaught exception", e);
+        }
+    }
+
+    public final Task 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 onSuccessTask = this.dataCollectionArbiter.waitForAutomaticDataCollectionEnabled().onSuccessTask(new SuccessContinuation() { // from class: com.google.firebase.crashlytics.internal.common.CrashlyticsController.3
+            @Override // com.google.android.gms.tasks.SuccessContinuation
+            public Task then(Void r1) {
+                return Tasks.forResult(Boolean.TRUE);
+            }
+        });
+        Logger.getLogger().d("Waiting for send/deleteUnsentReports to be called.");
+        return Utils.race(onSuccessTask, this.reportActionProvided.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 Task checkForUnsentReports() {
+        if (!this.checkForUnsentReportsCalled.compareAndSet(false, true)) {
+            Logger.getLogger().w("checkForUnsentReports should only be called once per execution.");
+            return Tasks.forResult(Boolean.FALSE);
+        }
+        return this.unsentReportsAvailable.getTask();
+    }
+
+    public Task sendUnsentReports() {
+        this.reportActionProvided.trySetResult(Boolean.TRUE);
+        return this.unsentReportsHandled.getTask();
+    }
+
+    public Task deleteUnsentReports() {
+        this.reportActionProvided.trySetResult(Boolean.FALSE);
+        return this.unsentReportsHandled.getTask();
+    }
+
+    public Task submitAllReports(Task task) {
+        if (!this.reportingCoordinator.hasReportsToSend()) {
+            Logger.getLogger().v("No crash reports are available to be sent.");
+            this.unsentReportsAvailable.trySetResult(Boolean.FALSE);
+            return Tasks.forResult(null);
+        }
+        Logger.getLogger().v("Crash reports are available to be sent.");
+        return waitForReportAction().onSuccessTask(new AnonymousClass4(task));
+    }
+
+    /* renamed from: com.google.firebase.crashlytics.internal.common.CrashlyticsController$4, reason: invalid class name */
+    public class AnonymousClass4 implements SuccessContinuation {
+        public final /* synthetic */ Task val$settingsDataTask;
+
+        public AnonymousClass4(Task task) {
+            this.val$settingsDataTask = task;
+        }
+
+        @Override // com.google.android.gms.tasks.SuccessContinuation
+        public Task then(final Boolean bool) {
+            return CrashlyticsController.this.backgroundWorker.submitTask(new Callable() { // from class: com.google.firebase.crashlytics.internal.common.CrashlyticsController.4.1
+                @Override // java.util.concurrent.Callable
+                public Task call() {
+                    if (!bool.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(bool.booleanValue());
+                    final Executor executor = CrashlyticsController.this.backgroundWorker.getExecutor();
+                    return AnonymousClass4.this.val$settingsDataTask.onSuccessTask(executor, new SuccessContinuation() { // from class: com.google.firebase.crashlytics.internal.common.CrashlyticsController.4.1.1
+                        @Override // com.google.android.gms.tasks.SuccessContinuation
+                        public Task then(Settings settings) {
+                            if (settings != null) {
+                                CrashlyticsController.this.logAnalyticsAppExceptionEvents();
+                                CrashlyticsController.this.reportingCoordinator.sendReports(executor);
+                                CrashlyticsController.this.unsentReportsHandled.trySetResult(null);
+                                return Tasks.forResult(null);
+                            }
+                            Logger.getLogger().w("Received null app settings at app startup. Cannot send cached reports");
+                            return Tasks.forResult(null);
+                        }
+                    });
+                }
+            });
+        }
+    }
+
+    public void writeToLog(final long j, final String str) {
+        this.backgroundWorker.submit(new Callable() { // from class: com.google.firebase.crashlytics.internal.common.CrashlyticsController.5
+            @Override // java.util.concurrent.Callable
+            public Void call() {
+                if (CrashlyticsController.this.isHandlingException()) {
+                    return null;
+                }
+                CrashlyticsController.this.logFileManager.writeToLog(j, str);
+                return null;
+            }
+        });
+    }
+
+    public void writeNonFatalException(final Thread thread, final Throwable th) {
+        final long currentTimeMillis = System.currentTimeMillis();
+        this.backgroundWorker.submit(new Runnable() { // from class: com.google.firebase.crashlytics.internal.common.CrashlyticsController.6
+            @Override // java.lang.Runnable
+            public void run() {
+                if (CrashlyticsController.this.isHandlingException()) {
+                    return;
+                }
+                long timestampSeconds = CrashlyticsController.getTimestampSeconds(currentTimeMillis);
+                String currentSessionId = CrashlyticsController.this.getCurrentSessionId();
+                if (currentSessionId != null) {
+                    CrashlyticsController.this.reportingCoordinator.persistNonFatalEvent(th, thread, currentSessionId, timestampSeconds);
+                } else {
+                    Logger.getLogger().w("Tried to write a non-fatal exception while no session was open.");
+                }
+            }
+        });
+    }
+
+    public void setUserId(String str) {
+        this.userMetadata.setUserId(str);
+    }
+
+    public void setCustomKey(String str, String str2) {
+        try {
+            this.userMetadata.setCustomKey(str, str2);
+        } catch (IllegalArgumentException e) {
+            Context context = this.context;
+            if (context != null && CommonUtils.isAppDebuggable(context)) {
+                throw e;
+            }
+            Logger.getLogger().e("Attempting to set custom attribute with null key, ignoring.");
+        }
+    }
+
+    public void setInternalKey(String str, String str2) {
+        try {
+            this.userMetadata.setInternalKey(str, str2);
+        } catch (IllegalArgumentException e) {
+            Context context = this.context;
+            if (context != null && CommonUtils.isAppDebuggable(context)) {
+                throw e;
+            }
+            Logger.getLogger().e("Attempting to set custom attribute with null key, ignoring.");
+        }
+    }
+
+    public void openSession(final String str) {
+        this.backgroundWorker.submit(new Callable() { // from class: com.google.firebase.crashlytics.internal.common.CrashlyticsController.7
+            @Override // java.util.concurrent.Callable
+            public Void call() {
+                CrashlyticsController.this.doOpenSession(str, Boolean.FALSE);
+                return null;
+            }
+        });
+    }
+
+    public final String getCurrentSessionId() {
+        SortedSet listSortedOpenSessionIds = this.reportingCoordinator.listSortedOpenSessionIds();
+        if (listSortedOpenSessionIds.isEmpty()) {
+            return null;
+        }
+        return (String) listSortedOpenSessionIds.first();
+    }
+
+    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 e) {
+            Logger.getLogger().e("Unable to finalize previously open sessions.", e);
+            return false;
+        }
+    }
+
+    public final void doOpenSession(String str, Boolean bool) {
+        long currentTimestampSeconds = getCurrentTimestampSeconds();
+        Logger.getLogger().d("Opening a new session with ID " + str);
+        this.nativeComponent.prepareNativeSession(str, String.format(Locale.US, "Crashlytics Android SDK/%s", 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 doCloseSessions(SettingsProvider settingsProvider) {
+        doCloseSessions(false, settingsProvider);
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public final void doCloseSessions(boolean z, SettingsProvider settingsProvider) {
+        String str;
+        ArrayList arrayList = new ArrayList(this.reportingCoordinator.listSortedOpenSessionIds());
+        if (arrayList.size() <= z) {
+            Logger.getLogger().v("No open sessions to be closed.");
+            return;
+        }
+        String str2 = (String) arrayList.get(z ? 1 : 0);
+        if (settingsProvider.getSettingsSync().featureFlagData.collectAnrs) {
+            writeApplicationExitInfoEventIfRelevant(str2);
+        } else {
+            Logger.getLogger().v("ANR feature disabled.");
+        }
+        if (this.nativeComponent.hasCrashDataForSession(str2)) {
+            finalizePreviousNativeSession(str2);
+        }
+        if (z != 0) {
+            str = (String) arrayList.get(0);
+        } else {
+            this.sessionsSubscriber.setSessionId(null);
+            str = null;
+        }
+        this.reportingCoordinator.finalizeSessions(getCurrentTimestampSeconds(), str);
+    }
+
+    public List listAppExceptionMarkerFiles() {
+        return this.fileStore.getCommonFiles(APP_EXCEPTION_MARKER_FILTER);
+    }
+
+    public void saveVersionControlInfo() {
+        try {
+            String versionControlInfo = getVersionControlInfo();
+            if (versionControlInfo != null) {
+                setInternalKey("com.crashlytics.version-control-info", versionControlInfo);
+                Logger.getLogger().i("Saved version control info");
+            }
+        } catch (IOException e) {
+            Logger.getLogger().w("Unable to save version control info", e);
+        }
+    }
+
+    public String getVersionControlInfo() {
+        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 final 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 byte[] readResource(InputStream inputStream) {
+        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+        byte[] bArr = new byte[1024];
+        while (true) {
+            int read = inputStream.read(bArr);
+            if (read != -1) {
+                byteArrayOutputStream.write(bArr, 0, read);
+            } else {
+                return byteArrayOutputStream.toByteArray();
+            }
+        }
+    }
+
+    public final 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 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();
+    }
+
+    public 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;
+    }
+
+    public static long getCurrentTimestampSeconds() {
+        return getTimestampSeconds(System.currentTimeMillis());
+    }
+
+    public static long getTimestampSeconds(long j) {
+        return j / 1000;
+    }
+
+    public final void doWriteAppExceptionMarker(long j) {
+        try {
+            if (this.fileStore.getCommonFile(".ae" + j).createNewFile()) {
+            } else {
+                throw new IOException("Create new file failed.");
+            }
+        } catch (IOException e) {
+            Logger.getLogger().w("Could not create app exception marker file.", e);
+        }
+    }
+
+    public 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);
+    }
+
+    public static StaticSessionData.OsData createOsData() {
+        return StaticSessionData.OsData.create(Build.VERSION.RELEASE, Build.VERSION.CODENAME, CommonUtils.isRooted());
+    }
+
+    public 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);
+    }
+
+    public boolean isHandlingException() {
+        CrashlyticsUncaughtExceptionHandler crashlyticsUncaughtExceptionHandler = this.crashHandler;
+        return crashlyticsUncaughtExceptionHandler != null && crashlyticsUncaughtExceptionHandler.isHandlingException();
+    }
+
+    public final Task 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);
+    }
+
+    public final Task logAnalyticsAppExceptionEvent(final long j) {
+        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() { // from class: com.google.firebase.crashlytics.internal.common.CrashlyticsController.8
+            @Override // java.util.concurrent.Callable
+            public Void call() {
+                Bundle bundle = new Bundle();
+                bundle.putInt("fatal", 1);
+                bundle.putLong("timestamp", j);
+                CrashlyticsController.this.analyticsEventLogger.logEvent("_ae", bundle);
+                return null;
+            }
+        });
+    }
+
+    public static void deleteFiles(List list) {
+        Iterator it = list.iterator();
+        while (it.hasNext()) {
+            ((File) it.next()).delete();
+        }
+    }
+
+    public static boolean firebaseCrashExists() {
+        try {
+            Class.forName("com.google.firebase.crash.FirebaseCrash");
+            return true;
+        } catch (ClassNotFoundException unused) {
+            return false;
+        }
+    }
+
+    public static List getNativeSessionFiles(NativeSessionFileProvider nativeSessionFileProvider, String str, FileStore fileStore, byte[] bArr) {
+        File sessionFile = fileStore.getSessionFile(str, "user-data");
+        File sessionFile2 = fileStore.getSessionFile(str, "keys");
+        File sessionFile3 = fileStore.getSessionFile(str, "rollouts-state");
+        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", MBridgeConstans.DYNAMIC_VIEW_WX_APP, nativeSessionFileProvider.getAppFile()));
+        arrayList.add(new FileBackedNativeSessionFile("device_meta_file", "device", nativeSessionFileProvider.getDeviceFile()));
+        arrayList.add(new FileBackedNativeSessionFile("os_meta_file", ad.y, nativeSessionFileProvider.getOsFile()));
+        arrayList.add(nativeCoreFile(nativeSessionFileProvider));
+        arrayList.add(new FileBackedNativeSessionFile("user_meta_file", "user", sessionFile));
+        arrayList.add(new FileBackedNativeSessionFile("keys_file", "keys", sessionFile2));
+        arrayList.add(new FileBackedNativeSessionFile("rollouts_file", "rollouts", sessionFile3));
+        return arrayList;
+    }
+
+    public static NativeSessionFile nativeCoreFile(NativeSessionFileProvider nativeSessionFileProvider) {
+        File minidumpFile = nativeSessionFileProvider.getMinidumpFile();
+        if (minidumpFile == null || !minidumpFile.exists()) {
+            return new BytesBackedNativeSessionFile("minidump_file", "minidump", new byte[]{0});
+        }
+        return new FileBackedNativeSessionFile("minidump_file", "minidump", minidumpFile);
+    }
+
+    public final void writeApplicationExitInfoEventIfRelevant(String str) {
+        List historicalProcessExitReasons;
+        int i = Build.VERSION.SDK_INT;
+        if (i >= 30) {
+            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));
+                return;
+            } else {
+                Logger.getLogger().v("No ApplicationExitInfo available. Session: " + str);
+                return;
+            }
+        }
+        Logger.getLogger().v("ANR feature enabled, but device is API " + i);
+    }
+}

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

@@ -0,0 +1,259 @@
+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.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 csdk.gluads.Consts;
+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 {
+    public final AnalyticsEventLogger analyticsEventLogger;
+    public final FirebaseApp app;
+    public final CrashlyticsBackgroundWorker backgroundWorker;
+    public final BreadcrumbSource breadcrumbSource;
+    public final Context context;
+    public CrashlyticsController controller;
+    public final ExecutorService crashHandlerExecutor;
+    public CrashlyticsFileMarker crashMarker;
+    public final DataCollectionArbiter dataCollectionArbiter;
+    public boolean didCrashOnPreviousExecution;
+    public final FileStore fileStore;
+    public final IdManager idManager;
+    public CrashlyticsFileMarker initializationMarker;
+    public final CrashlyticsNativeComponent nativeComponent;
+    public final RemoteConfigDeferredProxy remoteConfigDeferredProxy;
+    public final CrashlyticsAppQualitySessionsSubscriber sessionsSubscriber;
+    public final long startTime = System.currentTimeMillis();
+    public final OnDemandCounter onDemandCounter = new OnDemandCounter();
+
+    public static String getVersion() {
+        return "19.0.1";
+    }
+
+    public boolean didCrashOnPreviousExecution() {
+        return this.didCrashOnPreviousExecution;
+    }
+
+    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;
+    }
+
+    public boolean onPreExecute(AppData appData, SettingsProvider settingsProvider) {
+        if (!isBuildIdValid(appData.buildId, CommonUtils.getBooleanResourceValue(this.context, "com.crashlytics.RequireBuildId", true))) {
+            throw new IllegalStateException("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");
+        }
+        String clsuuid = new CLSUUID(this.idManager).toString();
+        try {
+            this.crashMarker = new CrashlyticsFileMarker("crash_marker", this.fileStore);
+            this.initializationMarker = new CrashlyticsFileMarker("initialization_marker", 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("Crashlytics did not finish previous background initialization. Initializing synchronously.");
+                finishInitSynchronously(settingsProvider);
+                return false;
+            }
+            Logger.getLogger().d("Successfully configured exception handler.");
+            return true;
+        } catch (Exception e) {
+            Logger.getLogger().e("Crashlytics was not started due to an exception during initialization", e);
+            this.controller = null;
+            return false;
+        }
+    }
+
+    public Task doBackgroundInitializationAsync(final SettingsProvider settingsProvider) {
+        return Utils.callTask(this.crashHandlerExecutor, new Callable() { // from class: com.google.firebase.crashlytics.internal.common.CrashlyticsCore.1
+            @Override // java.util.concurrent.Callable
+            public Task call() {
+                return CrashlyticsCore.this.doBackgroundInitialization(settingsProvider);
+            }
+        });
+    }
+
+    public final Task doBackgroundInitialization(SettingsProvider settingsProvider) {
+        markInitializationStarted();
+        try {
+            this.breadcrumbSource.registerBreadcrumbHandler(new BreadcrumbHandler() { // from class: com.google.firebase.crashlytics.internal.common.CrashlyticsCore$$ExternalSyntheticLambda0
+                @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 e) {
+            Logger.getLogger().e("Crashlytics encountered a problem during asynchronous initialization.", e);
+            return Tasks.forException(e);
+        } finally {
+            markInitializationComplete();
+        }
+    }
+
+    public void setCrashlyticsCollectionEnabled(Boolean bool) {
+        this.dataCollectionArbiter.setCrashlyticsDataCollectionEnabled(bool);
+    }
+
+    public Task checkForUnsentReports() {
+        return this.controller.checkForUnsentReports();
+    }
+
+    public Task sendUnsentReports() {
+        return this.controller.sendUnsentReports();
+    }
+
+    public Task deleteUnsentReports() {
+        return this.controller.deleteUnsentReports();
+    }
+
+    public void logException(Throwable th) {
+        this.controller.writeNonFatalException(Thread.currentThread(), th);
+    }
+
+    public void log(String str) {
+        this.controller.writeToLog(System.currentTimeMillis() - this.startTime, str);
+    }
+
+    public void setUserId(String str) {
+        this.controller.setUserId(str);
+    }
+
+    public void setCustomKey(String str, String str2) {
+        this.controller.setCustomKey(str, str2);
+    }
+
+    public final 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 e) {
+            Logger.getLogger().e("Crashlytics was interrupted during initialization.", e);
+        } catch (ExecutionException e2) {
+            Logger.getLogger().e("Crashlytics encountered a problem during initialization.", e2);
+        } catch (TimeoutException e3) {
+            Logger.getLogger().e("Crashlytics timed out during initialization.", e3);
+        }
+    }
+
+    public void markInitializationStarted() {
+        this.backgroundWorker.checkRunningOnThread();
+        this.initializationMarker.create();
+        Logger.getLogger().v("Initialization marker file was created.");
+    }
+
+    public void markInitializationComplete() {
+        this.backgroundWorker.submit(new Callable() { // from class: com.google.firebase.crashlytics.internal.common.CrashlyticsCore.3
+            @Override // java.util.concurrent.Callable
+            public Boolean call() {
+                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 e) {
+                    Logger.getLogger().e("Problem encountered deleting Crashlytics initialization marker.", e);
+                    return Boolean.FALSE;
+                }
+            }
+        });
+    }
+
+    public boolean didPreviousInitializationFail() {
+        return this.initializationMarker.isPresent();
+    }
+
+    public final void checkForPreviousCrash() {
+        try {
+            this.didCrashOnPreviousExecution = Boolean.TRUE.equals((Boolean) Utils.awaitEvenIfOnMainThread(this.backgroundWorker.submit(new Callable() { // from class: com.google.firebase.crashlytics.internal.common.CrashlyticsCore.4
+                @Override // java.util.concurrent.Callable
+                public Boolean call() {
+                    return Boolean.valueOf(CrashlyticsCore.this.controller.didCrashOnPreviousExecution());
+                }
+            })));
+        } catch (Exception unused) {
+            this.didCrashOnPreviousExecution = false;
+        }
+    }
+
+    public static boolean isBuildIdValid(String str, boolean z) {
+        if (!z) {
+            Logger.getLogger().v("Configured not to require a build ID.");
+            return true;
+        }
+        if (!TextUtils.isEmpty(str)) {
+            return true;
+        }
+        Log.e("FirebaseCrashlytics", Consts.STRING_PERIOD);
+        Log.e("FirebaseCrashlytics", ".     |  | ");
+        Log.e("FirebaseCrashlytics", ".     |  |");
+        Log.e("FirebaseCrashlytics", ".     |  |");
+        Log.e("FirebaseCrashlytics", ".   \\ |  | /");
+        Log.e("FirebaseCrashlytics", ".    \\    /");
+        Log.e("FirebaseCrashlytics", ".     \\  /");
+        Log.e("FirebaseCrashlytics", ".      \\/");
+        Log.e("FirebaseCrashlytics", Consts.STRING_PERIOD);
+        Log.e("FirebaseCrashlytics", "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");
+        Log.e("FirebaseCrashlytics", Consts.STRING_PERIOD);
+        Log.e("FirebaseCrashlytics", ".      /\\");
+        Log.e("FirebaseCrashlytics", ".     /  \\");
+        Log.e("FirebaseCrashlytics", ".    /    \\");
+        Log.e("FirebaseCrashlytics", ".   / |  | \\");
+        Log.e("FirebaseCrashlytics", ".     |  |");
+        Log.e("FirebaseCrashlytics", ".     |  |");
+        Log.e("FirebaseCrashlytics", ".     |  |");
+        Log.e("FirebaseCrashlytics", Consts.STRING_PERIOD);
+        return false;
+    }
+}

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

@@ -0,0 +1,38 @@
+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;
+
+/* loaded from: classes3.dex */
+public class CrashlyticsFileMarker {
+    public final FileStore fileStore;
+    public final String markerName;
+
+    public CrashlyticsFileMarker(String str, FileStore fileStore) {
+        this.markerName = str;
+        this.fileStore = fileStore;
+    }
+
+    public boolean create() {
+        try {
+            return getMarkerFile().createNewFile();
+        } catch (IOException e) {
+            Logger.getLogger().e("Error creating marker: " + this.markerName, e);
+            return false;
+        }
+    }
+
+    public boolean isPresent() {
+        return getMarkerFile().exists();
+    }
+
+    public boolean remove() {
+        return getMarkerFile().delete();
+    }
+
+    public final File getMarkerFile() {
+        return this.fileStore.getCommonFile(this.markerName);
+    }
+}

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

@@ -0,0 +1,237 @@
+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.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 csdk.gluads.Consts;
+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 {
+    public static final Map ARCHITECTURES_BY_NAME;
+    public static final String GENERATOR;
+    public final AppData appData;
+    public final Context context;
+    public final IdManager idManager;
+    public final ProcessDetailsProvider processDetailsProvider = ProcessDetailsProvider.INSTANCE;
+    public final SettingsProvider settingsProvider;
+    public final StackTraceTrimmingStrategy stackTraceTrimmingStrategy;
+
+    public static long ensureNonNegative(long j) {
+        if (j > 0) {
+            return j;
+        }
+        return 0L;
+    }
+
+    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);
+        GENERATOR = String.format(Locale.US, "Crashlytics Android SDK/%s", "19.0.1");
+    }
+
+    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;
+    }
+
+    public CrashlyticsReport captureReportData(String str, long j) {
+        return buildReportData().setSession(populateSessionData(str, j)).build();
+    }
+
+    public CrashlyticsReport.Session.Event captureEventData(Throwable th, Thread thread, String str, long j, int i, int i2, boolean z) {
+        int i3 = this.context.getResources().getConfiguration().orientation;
+        return CrashlyticsReport.Session.Event.builder().setType(str).setTimestamp(j).setApp(populateEventApplicationData(i3, TrimmedThrowableData.makeTrimmedThrowableData(th, this.stackTraceTrimmingStrategy), thread, i, i2, z)).setDevice(populateEventDeviceData(i3)).build();
+    }
+
+    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 final CrashlyticsReport.ApplicationExitInfo addBuildIdInfo(CrashlyticsReport.ApplicationExitInfo applicationExitInfo) {
+        List 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();
+    }
+
+    public final CrashlyticsReport.Builder buildReportData() {
+        return CrashlyticsReport.builder().setSdkVersion("19.0.1").setGmpAppId(this.appData.googleAppId).setInstallationUuid(this.idManager.getInstallIds().getCrashlyticsInstallId()).setFirebaseInstallationId(this.idManager.getInstallIds().getFirebaseInstallationId()).setFirebaseAuthenticationToken(this.idManager.getInstallIds().getFirebaseAuthenticationToken()).setBuildVersion(this.appData.versionCode).setDisplayVersion(this.appData.versionName).setPlatform(4);
+    }
+
+    public final CrashlyticsReport.Session populateSessionData(String str, long j) {
+        return CrashlyticsReport.Session.builder().setStartedAt(j).setIdentifier(str).setGenerator(GENERATOR).setApp(populateSessionApplicationData()).setOs(populateSessionOperatingSystemData()).setDevice(populateSessionDeviceData()).setGeneratorType(3).build();
+    }
+
+    public final 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();
+    }
+
+    public final CrashlyticsReport.Session.OperatingSystem populateSessionOperatingSystemData() {
+        return CrashlyticsReport.Session.OperatingSystem.builder().setPlatform(3).setVersion(Build.VERSION.RELEASE).setBuildVersion(Build.VERSION.CODENAME).setJailbroken(CommonUtils.isRooted()).build();
+    }
+
+    public final 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();
+    }
+
+    public final CrashlyticsReport.Session.Event.Application populateEventApplicationData(int i, TrimmedThrowableData trimmedThrowableData, Thread thread, int i2, int i3, boolean z) {
+        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, i2, i3, z)).build();
+    }
+
+    public final 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();
+    }
+
+    public final 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();
+    }
+
+    public final CrashlyticsReport.Session.Event.Application.Execution populateExecutionData(TrimmedThrowableData trimmedThrowableData, Thread thread, int i, int i2, boolean z) {
+        return CrashlyticsReport.Session.Event.Application.Execution.builder().setThreads(populateThreadsList(trimmedThrowableData, thread, i, z)).setException(populateExceptionData(trimmedThrowableData, i, i2)).setSignal(populateSignalData()).setBinaries(populateBinaryImagesList()).build();
+    }
+
+    public final CrashlyticsReport.Session.Event.Application.Execution populateExecutionData(CrashlyticsReport.ApplicationExitInfo applicationExitInfo) {
+        return CrashlyticsReport.Session.Event.Application.Execution.builder().setAppExitInfo(applicationExitInfo).setSignal(populateSignalData()).setBinaries(populateBinaryImagesList()).build();
+    }
+
+    public final List populateThreadsList(TrimmedThrowableData trimmedThrowableData, Thread thread, int i, boolean z) {
+        ArrayList arrayList = new ArrayList();
+        arrayList.add(populateThreadData(thread, trimmedThrowableData.stacktrace, i));
+        if (z) {
+            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);
+    }
+
+    public final CrashlyticsReport.Session.Event.Application.Execution.Thread populateThreadData(Thread thread, StackTraceElement[] stackTraceElementArr) {
+        return populateThreadData(thread, stackTraceElementArr, 0);
+    }
+
+    public final 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();
+    }
+
+    public final List 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);
+    }
+
+    public final CrashlyticsReport.Session.Event.Application.Execution.Exception populateExceptionData(TrimmedThrowableData trimmedThrowableData, int i, int i2) {
+        return populateExceptionData(trimmedThrowableData, i, i2, 0);
+    }
+
+    public final CrashlyticsReport.Session.Event.Application.Execution.Exception populateExceptionData(TrimmedThrowableData trimmedThrowableData, int i, int i2, int i3) {
+        String str = trimmedThrowableData.className;
+        String str2 = trimmedThrowableData.localizedMessage;
+        StackTraceElement[] stackTraceElementArr = trimmedThrowableData.stacktrace;
+        int i4 = 0;
+        if (stackTraceElementArr == null) {
+            stackTraceElementArr = new StackTraceElement[0];
+        }
+        TrimmedThrowableData trimmedThrowableData2 = trimmedThrowableData.cause;
+        if (i3 >= i2) {
+            TrimmedThrowableData trimmedThrowableData3 = trimmedThrowableData2;
+            while (trimmedThrowableData3 != null) {
+                trimmedThrowableData3 = trimmedThrowableData3.cause;
+                i4++;
+            }
+        }
+        CrashlyticsReport.Session.Event.Application.Execution.Exception.Builder overflowCount = CrashlyticsReport.Session.Event.Application.Execution.Exception.builder().setType(str).setReason(str2).setFrames(populateFramesList(stackTraceElementArr, i)).setOverflowCount(i4);
+        if (trimmedThrowableData2 != null && i4 == 0) {
+            overflowCount.setCausedBy(populateExceptionData(trimmedThrowableData2, i, i2, i3 + 1));
+        }
+        return overflowCount.build();
+    }
+
+    public final CrashlyticsReport.Session.Event.Application.Execution.Thread.Frame populateFrameData(StackTraceElement stackTraceElement, CrashlyticsReport.Session.Event.Application.Execution.Thread.Frame.Builder builder) {
+        long j = 0;
+        long max = stackTraceElement.isNativeMethod() ? Math.max(stackTraceElement.getLineNumber(), 0L) : 0L;
+        String str = stackTraceElement.getClassName() + Consts.STRING_PERIOD + stackTraceElement.getMethodName();
+        String fileName = stackTraceElement.getFileName();
+        if (!stackTraceElement.isNativeMethod() && stackTraceElement.getLineNumber() > 0) {
+            j = stackTraceElement.getLineNumber();
+        }
+        return builder.setPc(max).setSymbol(str).setFile(fileName).setOffset(j).build();
+    }
+
+    public final List populateBinaryImagesList() {
+        return Collections.singletonList(populateBinaryImageData());
+    }
+
+    public final 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();
+    }
+
+    public final CrashlyticsReport.Session.Event.Application.Execution.Signal populateSignalData() {
+        return CrashlyticsReport.Session.Event.Application.Execution.Signal.builder().setName("0").setCode("0").setAddress(0L).build();
+    }
+
+    public static int getDeviceArchitecture() {
+        Integer num;
+        String str = Build.CPU_ABI;
+        if (TextUtils.isEmpty(str) || (num = (Integer) ARCHITECTURES_BY_NAME.get(str.toLowerCase(Locale.US))) == null) {
+            return 7;
+        }
+        return num.intValue();
+    }
+
+    public final CrashlyticsReport.Session.Event.Application.ProcessDetails processDetailsFromApplicationExitInfo(CrashlyticsReport.ApplicationExitInfo applicationExitInfo) {
+        return this.processDetailsProvider.buildProcessDetails(applicationExitInfo.getProcessName(), applicationExitInfo.getPid(), applicationExitInfo.getImportance());
+    }
+}

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

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

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

@@ -0,0 +1,71 @@
+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;
+
+/* loaded from: classes3.dex */
+public class CrashlyticsUncaughtExceptionHandler implements Thread.UncaughtExceptionHandler {
+    public final CrashListener crashListener;
+    public final Thread.UncaughtExceptionHandler defaultHandler;
+    public final AtomicBoolean isHandlingException = new AtomicBoolean(false);
+    public final CrashlyticsNativeComponent nativeComponent;
+    public final SettingsProvider settingsProvider;
+
+    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;
+    }
+
+    @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.");
+                }
+            } catch (Exception e) {
+                Logger.getLogger().e("An error occurred in the uncaught exception handler", e);
+            }
+            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;
+        }
+    }
+
+    public boolean isHandlingException() {
+        return this.isHandlingException.get();
+    }
+
+    public final 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;
+    }
+}

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();
+}

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

@@ -0,0 +1,164 @@
+package com.google.firebase.crashlytics.internal.common;
+
+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 {
+    public Boolean crashlyticsDataCollectionEnabled;
+    public TaskCompletionSource dataCollectionEnabledTask;
+    public final TaskCompletionSource dataCollectionExplicitlyApproved;
+    public final FirebaseApp firebaseApp;
+    public boolean setInManifest;
+    public final SharedPreferences sharedPreferences;
+    public final Object taskLock;
+    public 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;
+            }
+        }
+    }
+
+    public synchronized boolean isAutomaticDataCollectionEnabled() {
+        boolean isFirebaseDataCollectionDefaultEnabled;
+        try {
+            Boolean bool = this.crashlyticsDataCollectionEnabled;
+            if (bool != null) {
+                isFirebaseDataCollectionDefaultEnabled = bool.booleanValue();
+            } else {
+                isFirebaseDataCollectionDefaultEnabled = isFirebaseDataCollectionDefaultEnabled();
+            }
+            logDataCollectionState(isFirebaseDataCollectionDefaultEnabled);
+        } catch (Throwable th) {
+            throw th;
+        }
+        return isFirebaseDataCollectionDefaultEnabled;
+    }
+
+    public final boolean isFirebaseDataCollectionDefaultEnabled() {
+        try {
+            return this.firebaseApp.isDataCollectionDefaultEnabled();
+        } catch (IllegalStateException unused) {
+            return false;
+        }
+    }
+
+    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 waitForAutomaticDataCollectionEnabled() {
+        Task task;
+        synchronized (this.taskLock) {
+            task = this.dataCollectionEnabledTask.getTask();
+        }
+        return task;
+    }
+
+    public Task waitForDataCollectionPermission(Executor executor) {
+        return Utils.race(executor, this.dataCollectionExplicitlyApproved.getTask(), waitForAutomaticDataCollectionEnabled());
+    }
+
+    public void grantDataCollectionPermission(boolean z) {
+        if (!z) {
+            throw new IllegalStateException("An invalid data collection token was used.");
+        }
+        this.dataCollectionExplicitlyApproved.trySetResult(null);
+    }
+
+    public final void logDataCollectionState(boolean z) {
+        Logger.getLogger().d(String.format("Crashlytics automatic data collection %s by %s.", z ? "ENABLED" : "DISABLED", this.crashlyticsDataCollectionEnabled == null ? "global Firebase setting" : this.setInManifest ? "firebase_crashlytics_collection_enabled manifest flag" : "API"));
+    }
+
+    public final 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));
+    }
+
+    public final 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));
+    }
+
+    public 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 e) {
+            Logger.getLogger().e("Could not read data collection permission from manifest", e);
+            return null;
+        }
+    }
+
+    public 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();
+    }
+}

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;
+
+    public static DeliveryMechanism determineFrom(String str) {
+        return str != null ? APP_STORE : DEVELOPER;
+    }
+
+    public int getId() {
+        return this.id;
+    }
+
+    DeliveryMechanism(int i) {
+        this.id = i;
+    }
+
+    @Override // java.lang.Enum
+    public String toString() {
+        return Integer.toString(this.id);
+    }
+}

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

@@ -0,0 +1,66 @@
+package com.google.firebase.crashlytics.internal.common;
+
+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.ThreadFactory;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicLong;
+
+/* loaded from: classes3.dex */
+public abstract class ExecutorUtils {
+    public static ExecutorService buildSingleThreadExecutorService(String str) {
+        ExecutorService newSingleThreadExecutor = newSingleThreadExecutor(getNamedThreadFactory(str), new ThreadPoolExecutor.DiscardPolicy());
+        addDelayedShutdownHook(str, newSingleThreadExecutor);
+        return newSingleThreadExecutor;
+    }
+
+    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;
+            }
+        };
+    }
+
+    public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory, RejectedExecutionHandler rejectedExecutionHandler) {
+        return Executors.unconfigurableExecutorService(new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue(), threadFactory, rejectedExecutionHandler));
+    }
+
+    public static void addDelayedShutdownHook(String str, ExecutorService executorService) {
+        addDelayedShutdownHook(str, executorService, 2L, TimeUnit.SECONDS);
+    }
+
+    public static void addDelayedShutdownHook(final String str, final ExecutorService executorService, final long j, 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(j, timeUnit)) {
+                        return;
+                    }
+                    Logger.getLogger().d(str + " did not shut down in the allocated time. Requesting immediate shutdown.");
+                    executorService.shutdownNow();
+                } catch (InterruptedException unused) {
+                    Logger.getLogger().d(String.format(Locale.US, "Interrupted while waiting for %s to shut down. Requesting immediate shutdown.", str));
+                    executorService.shutdownNow();
+                }
+            }
+        }, "Crashlytics Shutdown Hook for " + str));
+    }
+}

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

@@ -0,0 +1,89 @@
+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;
+
+/* loaded from: classes3.dex */
+public class FileBackedNativeSessionFile implements NativeSessionFile {
+    public final String dataTransportFilename;
+    public final File file;
+    public final String reportsEndpointFilename;
+
+    @Override // com.google.firebase.crashlytics.internal.common.NativeSessionFile
+    public String getReportsEndpointFilename() {
+        return this.reportsEndpointFilename;
+    }
+
+    public FileBackedNativeSessionFile(String str, String str2, File file) {
+        this.dataTransportFilename = str;
+        this.reportsEndpointFilename = str2;
+        this.file = file;
+    }
+
+    @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;
+    }
+
+    @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;
+    }
+
+    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.write(bArr, 0, read);
+                            } else {
+                                gZIPOutputStream.finish();
+                                byte[] byteArray = byteArrayOutputStream.toByteArray();
+                                gZIPOutputStream.close();
+                                byteArrayOutputStream.close();
+                                stream.close();
+                                return byteArray;
+                            }
+                        } finally {
+                        }
+                    }
+                } finally {
+                }
+            } finally {
+            }
+        } catch (IOException unused) {
+            return null;
+        }
+    }
+}

decompiled/sources/com/google/firebase/crashlytics/internal/common/FirebaseInstallationId.java

@@ -0,0 +1,44 @@
+package com.google.firebase.crashlytics.internal.common;
+
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes3.dex */
+public final class FirebaseInstallationId {
+    public final String authToken;
+    public final String fid;
+
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof FirebaseInstallationId)) {
+            return false;
+        }
+        FirebaseInstallationId firebaseInstallationId = (FirebaseInstallationId) obj;
+        return Intrinsics.areEqual(this.fid, firebaseInstallationId.fid) && Intrinsics.areEqual(this.authToken, firebaseInstallationId.authToken);
+    }
+
+    public final String getAuthToken() {
+        return this.authToken;
+    }
+
+    public final String getFid() {
+        return this.fid;
+    }
+
+    public int hashCode() {
+        String str = this.fid;
+        int hashCode = (str == null ? 0 : str.hashCode()) * 31;
+        String str2 = this.authToken;
+        return hashCode + (str2 != null ? str2.hashCode() : 0);
+    }
+
+    public String toString() {
+        return "FirebaseInstallationId(fid=" + this.fid + ", authToken=" + this.authToken + ')';
+    }
+
+    public FirebaseInstallationId(String str, String str2) {
+        this.fid = str;
+        this.authToken = str2;
+    }
+}

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

@@ -0,0 +1,172 @@
+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 java.util.Locale;
+import java.util.Objects;
+import java.util.UUID;
+import java.util.regex.Pattern;
+
+/* loaded from: classes3.dex */
+public class IdManager implements InstallIdProvider {
+    public final Context appContext;
+    public final String appIdentifier;
+    public final DataCollectionArbiter dataCollectionArbiter;
+    public final FirebaseInstallationsApi firebaseInstallations;
+    public InstallIdProvider.InstallIds installIds;
+    public final InstallerPackageNameProvider installerPackageNameProvider;
+    public static final Pattern ID_PATTERN = Pattern.compile("[^\\p{Alnum}]");
+    public static final String FORWARD_SLASH_REGEX = Pattern.quote("/");
+
+    public String getAppIdentifier() {
+        return this.appIdentifier;
+    }
+
+    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.firebaseInstallations = firebaseInstallationsApi;
+        this.dataCollectionArbiter = dataCollectionArbiter;
+        this.installerPackageNameProvider = new InstallerPackageNameProvider();
+    }
+
+    public static String formatId(String str) {
+        return ID_PATTERN.matcher(str).replaceAll("").toLowerCase(Locale.US);
+    }
+
+    @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("firebase.installation.id", null);
+        Logger.getLogger().v("Cached Firebase Installation ID: " + string);
+        if (this.dataCollectionArbiter.isAutomaticDataCollectionEnabled()) {
+            FirebaseInstallationId fetchTrueFid = fetchTrueFid(false);
+            Logger.getLogger().v("Fetched Firebase Installation ID: " + fetchTrueFid.getFid());
+            if (fetchTrueFid.getFid() == null) {
+                fetchTrueFid = new FirebaseInstallationId(string == null ? createSyntheticFid() : string, null);
+            }
+            if (Objects.equals(fetchTrueFid.getFid(), string)) {
+                this.installIds = InstallIdProvider.InstallIds.create(readCachedCrashlyticsInstallId(sharedPrefs), fetchTrueFid);
+            } else {
+                this.installIds = InstallIdProvider.InstallIds.create(createAndCacheCrashlyticsInstallId(fetchTrueFid.getFid(), 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 final boolean shouldRefresh() {
+        InstallIdProvider.InstallIds installIds = this.installIds;
+        return installIds == null || (installIds.getFirebaseInstallationId() == null && this.dataCollectionArbiter.isAutomaticDataCollectionEnabled());
+    }
+
+    public static String createSyntheticFid() {
+        return "SYN_" + UUID.randomUUID().toString();
+    }
+
+    public static boolean isSyntheticFid(String str) {
+        return str != null && str.startsWith("SYN_");
+    }
+
+    public final String readCachedCrashlyticsInstallId(SharedPreferences sharedPreferences) {
+        return sharedPreferences.getString("crashlytics.installation.id", null);
+    }
+
+    /* JADX WARN: Can't wrap try/catch for region: R(9:0|1|(7:13|14|4|5|6|7|8)|3|4|5|6|7|8) */
+    /* JADX WARN: Code restructure failed: missing block: B:11:0x002e, code lost:
+    
+        r1 = move-exception;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:12:0x002f, code lost:
+    
+        com.google.firebase.crashlytics.internal.Logger.getLogger().w("Error getting Firebase installation id.", r1);
+     */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public com.google.firebase.crashlytics.internal.common.FirebaseInstallationId fetchTrueFid(boolean r5) {
+        /*
+            r4 = this;
+            r0 = 0
+            if (r5 == 0) goto L1f
+            com.google.firebase.installations.FirebaseInstallationsApi r5 = r4.firebaseInstallations     // Catch: java.lang.Exception -> L15
+            r1 = 0
+            com.google.android.gms.tasks.Task r5 = r5.getToken(r1)     // Catch: java.lang.Exception -> L15
+            java.lang.Object r5 = com.google.firebase.crashlytics.internal.common.Utils.awaitEvenIfOnMainThread(r5)     // Catch: java.lang.Exception -> L15
+            com.google.firebase.installations.InstallationTokenResult r5 = (com.google.firebase.installations.InstallationTokenResult) r5     // Catch: java.lang.Exception -> L15
+            java.lang.String r5 = r5.getToken()     // Catch: java.lang.Exception -> L15
+            goto L20
+        L15:
+            r5 = move-exception
+            com.google.firebase.crashlytics.internal.Logger r1 = com.google.firebase.crashlytics.internal.Logger.getLogger()
+            java.lang.String r2 = "Error getting Firebase authentication token."
+            r1.w(r2, r5)
+        L1f:
+            r5 = r0
+        L20:
+            com.google.firebase.installations.FirebaseInstallationsApi r1 = r4.firebaseInstallations     // Catch: java.lang.Exception -> L2e
+            com.google.android.gms.tasks.Task r1 = r1.getId()     // Catch: java.lang.Exception -> L2e
+            java.lang.Object r1 = com.google.firebase.crashlytics.internal.common.Utils.awaitEvenIfOnMainThread(r1)     // Catch: java.lang.Exception -> L2e
+            java.lang.String r1 = (java.lang.String) r1     // Catch: java.lang.Exception -> L2e
+            r0 = r1
+            goto L38
+        L2e:
+            r1 = move-exception
+            com.google.firebase.crashlytics.internal.Logger r2 = com.google.firebase.crashlytics.internal.Logger.getLogger()
+            java.lang.String r3 = "Error getting Firebase installation id."
+            r2.w(r3, r1)
+        L38:
+            com.google.firebase.crashlytics.internal.common.FirebaseInstallationId r1 = new com.google.firebase.crashlytics.internal.common.FirebaseInstallationId
+            r1.<init>(r0, r5)
+            return r1
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.google.firebase.crashlytics.internal.common.IdManager.fetchTrueFid(boolean):com.google.firebase.crashlytics.internal.common.FirebaseInstallationId");
+    }
+
+    public final 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("firebase.installation.id", str).apply();
+        return formatId;
+    }
+
+    public String getOsDisplayVersionString() {
+        return removeForwardSlashesIn(Build.VERSION.RELEASE);
+    }
+
+    public String getOsBuildVersionString() {
+        return removeForwardSlashesIn(Build.VERSION.INCREMENTAL);
+    }
+
+    public String getModelName() {
+        return String.format(Locale.US, "%s/%s", removeForwardSlashesIn(Build.MANUFACTURER), removeForwardSlashesIn(Build.MODEL));
+    }
+
+    public final String removeForwardSlashesIn(String str) {
+        return str.replaceAll(FORWARD_SLASH_REGEX, "");
+    }
+
+    public String getInstallerPackageName() {
+        return this.installerPackageNameProvider.getInstallerPackageName(this.appContext);
+    }
+}

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

@@ -0,0 +1,22 @@
+package com.google.firebase.crashlytics.internal.common;
+
+/* loaded from: classes3.dex */
+public interface InstallIdProvider {
+    InstallIds getInstallIds();
+
+    public static abstract class InstallIds {
+        public abstract String getCrashlyticsInstallId();
+
+        public abstract String getFirebaseAuthenticationToken();
+
+        public abstract String getFirebaseInstallationId();
+
+        public static InstallIds createWithoutFid(String str) {
+            return new AutoValue_InstallIdProvider_InstallIds(str, null, null);
+        }
+
+        public static InstallIds create(String str, FirebaseInstallationId firebaseInstallationId) {
+            return new AutoValue_InstallIdProvider_InstallIds(str, firebaseInstallationId.getFid(), firebaseInstallationId.getAuthToken());
+        }
+    }
+}

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

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

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

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

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

@@ -0,0 +1,61 @@
+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.Iterator;
+import java.util.List;
+import java.util.zip.GZIPOutputStream;
+
+/* loaded from: classes3.dex */
+public abstract class NativeSessionFileGzipper {
+    public static void processNativeSessions(File file, List list) {
+        Iterator it = list.iterator();
+        while (it.hasNext()) {
+            NativeSessionFile nativeSessionFile = (NativeSessionFile) it.next();
+            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);
+        }
+    }
+
+    public static void gzipInputStream(InputStream inputStream, File file) {
+        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.write(bArr, 0, read);
+                    } else {
+                        gZIPOutputStream2.finish();
+                        CommonUtils.closeQuietly(gZIPOutputStream2);
+                        return;
+                    }
+                } catch (Throwable th) {
+                    th = th;
+                    gZIPOutputStream = gZIPOutputStream2;
+                    CommonUtils.closeQuietly(gZIPOutputStream);
+                    throw th;
+                }
+            }
+        } catch (Throwable th2) {
+            th = th2;
+        }
+    }
+}

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

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

decompiled/sources/com/google/firebase/crashlytics/internal/common/SessionReportingCoordinator$$ExternalSyntheticApiModelOutline0.java

@@ -0,0 +1,5 @@
+package com.google.firebase.crashlytics.internal.common;
+
+/* loaded from: classes3.dex */
+public abstract /* synthetic */ class SessionReportingCoordinator$$ExternalSyntheticApiModelOutline0 {
+}

decompiled/sources/com/google/firebase/crashlytics/internal/common/SessionReportingCoordinator$$ExternalSyntheticApiModelOutline1.java

@@ -0,0 +1,5 @@
+package com.google.firebase.crashlytics.internal.common;
+
+/* loaded from: classes3.dex */
+public abstract /* synthetic */ class SessionReportingCoordinator$$ExternalSyntheticApiModelOutline1 {
+}

decompiled/sources/com/google/firebase/crashlytics/internal/common/SessionReportingCoordinator$$ExternalSyntheticApiModelOutline2.java

@@ -0,0 +1,5 @@
+package com.google.firebase.crashlytics.internal.common;
+
+/* loaded from: classes3.dex */
+public abstract /* synthetic */ class SessionReportingCoordinator$$ExternalSyntheticApiModelOutline2 {
+}

decompiled/sources/com/google/firebase/crashlytics/internal/common/SessionReportingCoordinator$$ExternalSyntheticApiModelOutline3.java

@@ -0,0 +1,5 @@
+package com.google.firebase.crashlytics.internal.common;
+
+/* loaded from: classes3.dex */
+public abstract /* synthetic */ class SessionReportingCoordinator$$ExternalSyntheticApiModelOutline3 {
+}

decompiled/sources/com/google/firebase/crashlytics/internal/common/SessionReportingCoordinator$$ExternalSyntheticApiModelOutline4.java

@@ -0,0 +1,5 @@
+package com.google.firebase.crashlytics.internal.common;
+
+/* loaded from: classes3.dex */
+public abstract /* synthetic */ class SessionReportingCoordinator$$ExternalSyntheticApiModelOutline4 {
+}

decompiled/sources/com/google/firebase/crashlytics/internal/common/SessionReportingCoordinator$$ExternalSyntheticApiModelOutline5.java

@@ -0,0 +1,5 @@
+package com.google.firebase.crashlytics.internal.common;
+
+/* loaded from: classes3.dex */
+public abstract /* synthetic */ class SessionReportingCoordinator$$ExternalSyntheticApiModelOutline5 {
+}

decompiled/sources/com/google/firebase/crashlytics/internal/common/SessionReportingCoordinator$$ExternalSyntheticApiModelOutline6.java

@@ -0,0 +1,5 @@
+package com.google.firebase.crashlytics.internal.common;
+
+/* loaded from: classes3.dex */
+public abstract /* synthetic */ class SessionReportingCoordinator$$ExternalSyntheticApiModelOutline6 {
+}

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

@@ -0,0 +1,284 @@
+package com.google.firebase.crashlytics.internal.common;
+
+import android.app.ApplicationExitInfo;
+import android.content.Context;
+import androidx.work.impl.utils.ForceStopRunnable$$ExternalSyntheticApiModelOutline1;
+import com.google.android.gms.measurement.AppMeasurement;
+import com.google.android.gms.tasks.Continuation;
+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.Comparator;
+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 {
+    public final CrashlyticsReportDataCapture dataCapture;
+    public final IdManager idManager;
+    public final LogFileManager logFileManager;
+    public final UserMetadata reportMetadata;
+    public final CrashlyticsReportPersistence reportPersistence;
+    public final DataTransportCrashlyticsReportSender reportsSender;
+
+    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);
+    }
+
+    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;
+    }
+
+    public void onBeginSession(String str, long j) {
+        this.reportPersistence.persistReport(this.dataCapture.captureReportData(str, j));
+    }
+
+    public void persistFatalEvent(Throwable th, Thread thread, String str, long j) {
+        Logger.getLogger().v("Persisting fatal event for session " + str);
+        persistEvent(th, thread, str, AppMeasurement.CRASH_ORIGIN, j, true);
+    }
+
+    public void persistNonFatalEvent(Throwable th, Thread thread, String str, long j) {
+        Logger.getLogger().v("Persisting non-fatal event for session " + str);
+        persistEvent(th, thread, str, "error", j, false);
+    }
+
+    public void persistRelevantAppExitInfoEvent(String str, List 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 finalizeSessionWithNativeEvent(String str, List list, CrashlyticsReport.ApplicationExitInfo applicationExitInfo) {
+        Logger.getLogger().d("SessionReportingCoordinator#finalizeSessionWithNativeEvent");
+        ArrayList arrayList = new ArrayList();
+        Iterator it = list.iterator();
+        while (it.hasNext()) {
+            CrashlyticsReport.FilesPayload.File asFilePayload = ((NativeSessionFile) 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 j, String str) {
+        this.reportPersistence.finalizeReports(str, j);
+    }
+
+    public SortedSet listSortedOpenSessionIds() {
+        return this.reportPersistence.getOpenSessionIds();
+    }
+
+    public boolean hasReportsToSend() {
+        return this.reportPersistence.hasFinalizedReports();
+    }
+
+    public void removeAllReports() {
+        this.reportPersistence.deleteAllReports();
+    }
+
+    public Task sendReports(Executor executor) {
+        return sendReports(executor, null);
+    }
+
+    public Task 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 Continuation() { // from class: com.google.firebase.crashlytics.internal.common.SessionReportingCoordinator$$ExternalSyntheticLambda8
+                    @Override // com.google.android.gms.tasks.Continuation
+                    public final Object then(Task task) {
+                        boolean onReportSendComplete;
+                        onReportSendComplete = SessionReportingCoordinator.this.onReportSendComplete(task);
+                        return Boolean.valueOf(onReportSendComplete);
+                    }
+                }));
+            }
+        }
+        return Tasks.whenAll(arrayList);
+    }
+
+    public final CrashlyticsReportWithSessionId ensureHasFid(CrashlyticsReportWithSessionId crashlyticsReportWithSessionId) {
+        if (crashlyticsReportWithSessionId.getReport().getFirebaseInstallationId() != null && crashlyticsReportWithSessionId.getReport().getFirebaseAuthenticationToken() != null) {
+            return crashlyticsReportWithSessionId;
+        }
+        FirebaseInstallationId fetchTrueFid = this.idManager.fetchTrueFid(true);
+        return CrashlyticsReportWithSessionId.create(crashlyticsReportWithSessionId.getReport().withFirebaseInstallationId(fetchTrueFid.getFid()).withFirebaseAuthenticationToken(fetchTrueFid.getAuthToken()), crashlyticsReportWithSessionId.getSessionId(), crashlyticsReportWithSessionId.getReportFile());
+    }
+
+    public final CrashlyticsReport.Session.Event addMetaDataToEvent(CrashlyticsReport.Session.Event event) {
+        return addRolloutsStateToEvent(addLogsAndCustomKeysToEvent(event, this.logFileManager, this.reportMetadata), this.reportMetadata);
+    }
+
+    public final 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 sortedCustomAttributes = getSortedCustomAttributes(userMetadata.getCustomKeys());
+        List sortedCustomAttributes2 = getSortedCustomAttributes(userMetadata.getInternalKeys());
+        if (!sortedCustomAttributes.isEmpty() || !sortedCustomAttributes2.isEmpty()) {
+            builder.setApp(event.getApp().toBuilder().setCustomAttributes(sortedCustomAttributes).setInternalKeys(sortedCustomAttributes2).build());
+        }
+        return builder.build();
+    }
+
+    public final CrashlyticsReport.Session.Event addRolloutsStateToEvent(CrashlyticsReport.Session.Event event, UserMetadata userMetadata) {
+        List 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();
+    }
+
+    public final void persistEvent(Throwable th, Thread thread, String str, String str2, long j, boolean z) {
+        this.reportPersistence.persistEvent(addMetaDataToEvent(this.dataCapture.captureEventData(th, thread, str2, j, 4, 8, z)), str, str2.equals(AppMeasurement.CRASH_ORIGIN));
+    }
+
+    public final boolean onReportSendComplete(Task task) {
+        if (task.isSuccessful()) {
+            CrashlyticsReportWithSessionId crashlyticsReportWithSessionId = (CrashlyticsReportWithSessionId) task.getResult();
+            Logger.getLogger().d("Crashlytics report successfully enqueued to DataTransport: " + crashlyticsReportWithSessionId.getSessionId());
+            File reportFile = crashlyticsReportWithSessionId.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;
+        }
+        Logger.getLogger().w("Crashlytics report could not be enqueued to DataTransport", task.getException());
+        return false;
+    }
+
+    public static List getSortedCustomAttributes(Map map) {
+        ArrayList arrayList = new ArrayList();
+        arrayList.ensureCapacity(map.size());
+        for (Map.Entry entry : map.entrySet()) {
+            arrayList.add(CrashlyticsReport.CustomAttribute.builder().setKey((String) entry.getKey()).setValue((String) entry.getValue()).build());
+        }
+        Collections.sort(arrayList, new Comparator() { // from class: com.google.firebase.crashlytics.internal.common.SessionReportingCoordinator$$ExternalSyntheticLambda7
+            @Override // java.util.Comparator
+            public final int compare(Object obj, Object obj2) {
+                int lambda$getSortedCustomAttributes$0;
+                lambda$getSortedCustomAttributes$0 = SessionReportingCoordinator.lambda$getSortedCustomAttributes$0((CrashlyticsReport.CustomAttribute) obj, (CrashlyticsReport.CustomAttribute) obj2);
+                return lambda$getSortedCustomAttributes$0;
+            }
+        });
+        return Collections.unmodifiableList(arrayList);
+    }
+
+    public static /* synthetic */ int lambda$getSortedCustomAttributes$0(CrashlyticsReport.CustomAttribute customAttribute, CrashlyticsReport.CustomAttribute customAttribute2) {
+        return customAttribute.getKey().compareTo(customAttribute2.getKey());
+    }
+
+    public 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 e) {
+            Logger logger = Logger.getLogger();
+            StringBuilder sb = new StringBuilder();
+            sb.append("Could not get input trace in application exit info: ");
+            applicationExitInfo2 = applicationExitInfo.toString();
+            sb.append(applicationExitInfo2);
+            sb.append(" Error: ");
+            sb.append(e);
+            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) {
+        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+        byte[] bArr = new byte[8192];
+        while (true) {
+            int read = inputStream.read(bArr);
+            if (read != -1) {
+                byteArrayOutputStream.write(bArr, 0, read);
+            } else {
+                return byteArrayOutputStream.toString(StandardCharsets.UTF_8.name());
+            }
+        }
+    }
+
+    public final ApplicationExitInfo findRelevantApplicationExitInfo(String str, List list) {
+        long timestamp;
+        int reason;
+        long startTimestampMillis = this.reportPersistence.getStartTimestampMillis(str);
+        Iterator it = list.iterator();
+        while (it.hasNext()) {
+            ApplicationExitInfo m = ForceStopRunnable$$ExternalSyntheticApiModelOutline1.m(it.next());
+            timestamp = m.getTimestamp();
+            if (timestamp < startTimestampMillis) {
+                return null;
+            }
+            reason = m.getReason();
+            if (reason == 6) {
+                return m;
+            }
+        }
+        return null;
+    }
+}

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();
+    }
+}

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

@@ -0,0 +1,162 @@
+package com.google.firebase.crashlytics.internal.common;
+
+import android.os.Looper;
+import com.google.android.gms.tasks.Continuation;
+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 abstract class Utils {
+    public static final ExecutorService TASK_CONTINUATION_EXECUTOR_SERVICE = ExecutorUtils.buildSingleThreadExecutorService("awaitEvenIfOnMainThread task continuation executor");
+
+    public static Task race(Task task, Task task2) {
+        final TaskCompletionSource taskCompletionSource = new TaskCompletionSource();
+        Continuation continuation = new Continuation() { // from class: com.google.firebase.crashlytics.internal.common.Utils$$ExternalSyntheticLambda4
+            @Override // com.google.android.gms.tasks.Continuation
+            public final Object then(Task task3) {
+                Void lambda$race$0;
+                lambda$race$0 = Utils.lambda$race$0(TaskCompletionSource.this, task3);
+                return lambda$race$0;
+            }
+        };
+        task.continueWith(continuation);
+        task2.continueWith(continuation);
+        return taskCompletionSource.getTask();
+    }
+
+    public static /* synthetic */ Void lambda$race$0(TaskCompletionSource taskCompletionSource, Task task) {
+        if (task.isSuccessful()) {
+            taskCompletionSource.trySetResult(task.getResult());
+            return null;
+        }
+        if (task.getException() == null) {
+            return null;
+        }
+        taskCompletionSource.trySetException(task.getException());
+        return null;
+    }
+
+    public static Task race(Executor executor, Task task, Task task2) {
+        final TaskCompletionSource taskCompletionSource = new TaskCompletionSource();
+        Continuation continuation = new Continuation() { // from class: com.google.firebase.crashlytics.internal.common.Utils$$ExternalSyntheticLambda1
+            @Override // com.google.android.gms.tasks.Continuation
+            public final Object then(Task task3) {
+                Void lambda$race$1;
+                lambda$race$1 = Utils.lambda$race$1(TaskCompletionSource.this, task3);
+                return lambda$race$1;
+            }
+        };
+        task.continueWith(executor, continuation);
+        task2.continueWith(executor, continuation);
+        return taskCompletionSource.getTask();
+    }
+
+    public static /* synthetic */ Void lambda$race$1(TaskCompletionSource taskCompletionSource, Task task) {
+        if (task.isSuccessful()) {
+            taskCompletionSource.trySetResult(task.getResult());
+            return null;
+        }
+        if (task.getException() == null) {
+            return null;
+        }
+        taskCompletionSource.trySetException(task.getException());
+        return null;
+    }
+
+    public static Task callTask(final Executor executor, final Callable callable) {
+        final TaskCompletionSource taskCompletionSource = new TaskCompletionSource();
+        executor.execute(new Runnable() { // from class: com.google.firebase.crashlytics.internal.common.Utils$$ExternalSyntheticLambda2
+            @Override // java.lang.Runnable
+            public final void run() {
+                Utils.lambda$callTask$3(callable, executor, taskCompletionSource);
+            }
+        });
+        return taskCompletionSource.getTask();
+    }
+
+    public static /* synthetic */ void lambda$callTask$3(Callable callable, Executor executor, final TaskCompletionSource taskCompletionSource) {
+        try {
+            ((Task) callable.call()).continueWith(executor, new Continuation() { // from class: com.google.firebase.crashlytics.internal.common.Utils$$ExternalSyntheticLambda3
+                @Override // com.google.android.gms.tasks.Continuation
+                public final Object then(Task task) {
+                    Object lambda$callTask$2;
+                    lambda$callTask$2 = Utils.lambda$callTask$2(TaskCompletionSource.this, task);
+                    return lambda$callTask$2;
+                }
+            });
+        } catch (Exception e) {
+            taskCompletionSource.setException(e);
+        }
+    }
+
+    public static /* synthetic */ Object lambda$callTask$2(TaskCompletionSource taskCompletionSource, Task task) {
+        if (task.isSuccessful()) {
+            taskCompletionSource.setResult(task.getResult());
+            return null;
+        }
+        if (task.getException() == null) {
+            return null;
+        }
+        taskCompletionSource.setException(task.getException());
+        return null;
+    }
+
+    public static Object awaitEvenIfOnMainThread(Task task) {
+        final CountDownLatch countDownLatch = new CountDownLatch(1);
+        task.continueWith(TASK_CONTINUATION_EXECUTOR_SERVICE, new Continuation() { // from class: com.google.firebase.crashlytics.internal.common.Utils$$ExternalSyntheticLambda0
+            @Override // com.google.android.gms.tasks.Continuation
+            public final Object then(Task task2) {
+                Object lambda$awaitEvenIfOnMainThread$4;
+                lambda$awaitEvenIfOnMainThread$4 = Utils.lambda$awaitEvenIfOnMainThread$4(countDownLatch, task2);
+                return lambda$awaitEvenIfOnMainThread$4;
+            }
+        });
+        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 /* synthetic */ Object lambda$awaitEvenIfOnMainThread$4(CountDownLatch countDownLatch, Task task) {
+        countDownLatch.countDown();
+        return null;
+    }
+
+    public static boolean awaitUninterruptibly(CountDownLatch countDownLatch, long j, TimeUnit timeUnit) {
+        boolean z = false;
+        try {
+            long nanos = timeUnit.toNanos(j);
+            while (true) {
+                try {
+                    break;
+                } catch (InterruptedException unused) {
+                    z = true;
+                    nanos = (System.nanoTime() + nanos) - System.nanoTime();
+                }
+            }
+            return countDownLatch.await(nanos, TimeUnit.NANOSECONDS);
+        } finally {
+            if (z) {
+                Thread.currentThread().interrupt();
+            }
+        }
+    }
+}