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/sessions/settings/CrashlyticsSettingsFetcher.java

@@ -0,0 +1,10 @@
+package com.google.firebase.sessions.settings;
+
+import java.util.Map;
+import kotlin.coroutines.Continuation;
+import kotlin.jvm.functions.Function2;
+
+/* loaded from: classes3.dex */
+public interface CrashlyticsSettingsFetcher {
+    Object doConfigFetch(Map map, Function2 function2, Function2 function22, Continuation continuation);
+}

decompiled/sources/com/google/firebase/sessions/settings/LocalOverrideSettings.java

@@ -0,0 +1,62 @@
+package com.google.firebase.sessions.settings;
+
+import android.content.Context;
+import android.os.Bundle;
+import com.google.firebase.sessions.settings.SettingsProvider;
+import kotlin.coroutines.Continuation;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.time.Duration;
+import kotlin.time.DurationKt;
+import kotlin.time.DurationUnit;
+
+/* loaded from: classes3.dex */
+public final class LocalOverrideSettings implements SettingsProvider {
+    public static final Companion Companion = new Companion(null);
+    public final Bundle metadata;
+
+    public LocalOverrideSettings(Context context) {
+        Intrinsics.checkNotNullParameter(context, "context");
+        Bundle bundle = context.getPackageManager().getApplicationInfo(context.getPackageName(), 128).metaData;
+        this.metadata = bundle == null ? Bundle.EMPTY : bundle;
+    }
+
+    @Override // com.google.firebase.sessions.settings.SettingsProvider
+    public Object updateSettings(Continuation continuation) {
+        return SettingsProvider.DefaultImpls.updateSettings(this, continuation);
+    }
+
+    @Override // com.google.firebase.sessions.settings.SettingsProvider
+    public Boolean getSessionEnabled() {
+        if (this.metadata.containsKey("firebase_sessions_enabled")) {
+            return Boolean.valueOf(this.metadata.getBoolean("firebase_sessions_enabled"));
+        }
+        return null;
+    }
+
+    @Override // com.google.firebase.sessions.settings.SettingsProvider
+    /* renamed from: getSessionRestartTimeout-FghU774, reason: not valid java name */
+    public Duration mo852getSessionRestartTimeoutFghU774() {
+        if (this.metadata.containsKey("firebase_sessions_sessions_restart_timeout")) {
+            return Duration.m4073boximpl(DurationKt.toDuration(this.metadata.getInt("firebase_sessions_sessions_restart_timeout"), DurationUnit.SECONDS));
+        }
+        return null;
+    }
+
+    @Override // com.google.firebase.sessions.settings.SettingsProvider
+    public Double getSamplingRate() {
+        if (this.metadata.containsKey("firebase_sessions_sampling_rate")) {
+            return Double.valueOf(this.metadata.getDouble("firebase_sessions_sampling_rate"));
+        }
+        return null;
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        public Companion() {
+        }
+    }
+}

decompiled/sources/com/google/firebase/sessions/settings/RemoteSettings$updateSettings$1.java

@@ -0,0 +1,26 @@
+package com.google.firebase.sessions.settings;
+
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.jvm.internal.ContinuationImpl;
+
+/* loaded from: classes3.dex */
+public final class RemoteSettings$updateSettings$1 extends ContinuationImpl {
+    public Object L$0;
+    public Object L$1;
+    public int label;
+    public /* synthetic */ Object result;
+    public final /* synthetic */ RemoteSettings this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public RemoteSettings$updateSettings$1(RemoteSettings remoteSettings, Continuation continuation) {
+        super(continuation);
+        this.this$0 = remoteSettings;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        this.result = obj;
+        this.label |= Integer.MIN_VALUE;
+        return this.this$0.updateSettings(this);
+    }
+}

decompiled/sources/com/google/firebase/sessions/settings/RemoteSettings$updateSettings$2$1.java

@@ -0,0 +1,59 @@
+package com.google.firebase.sessions.settings;
+
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import org.json.JSONObject;
+
+/* loaded from: classes3.dex */
+public final class RemoteSettings$updateSettings$2$1 extends SuspendLambda implements Function2 {
+    public /* synthetic */ Object L$0;
+    public Object L$1;
+    public Object L$2;
+    public int label;
+    public final /* synthetic */ RemoteSettings this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public RemoteSettings$updateSettings$2$1(RemoteSettings remoteSettings, Continuation continuation) {
+        super(2, continuation);
+        this.this$0 = remoteSettings;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        RemoteSettings$updateSettings$2$1 remoteSettings$updateSettings$2$1 = new RemoteSettings$updateSettings$2$1(this.this$0, continuation);
+        remoteSettings$updateSettings$2$1.L$0 = obj;
+        return remoteSettings$updateSettings$2$1;
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(JSONObject jSONObject, Continuation continuation) {
+        return ((RemoteSettings$updateSettings$2$1) create(jSONObject, continuation)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Removed duplicated region for block: B:12:0x0191 A[RETURN] */
+    /* JADX WARN: Removed duplicated region for block: B:16:0x0157  */
+    /* JADX WARN: Removed duplicated region for block: B:22:0x0137  */
+    /* JADX WARN: Removed duplicated region for block: B:25:0x0154  */
+    /* JADX WARN: Removed duplicated region for block: B:29:0x0117  */
+    /* JADX WARN: Removed duplicated region for block: B:36:0x00f7  */
+    /* JADX WARN: Removed duplicated region for block: B:59:0x00d0  */
+    /* JADX WARN: Removed duplicated region for block: B:63:0x00ef  */
+    /* JADX WARN: Type inference failed for: r12v12, types: [T, java.lang.Integer] */
+    /* JADX WARN: Type inference failed for: r1v6, types: [T, java.lang.Integer] */
+    /* JADX WARN: Type inference failed for: r2v4, types: [T, java.lang.Double] */
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final java.lang.Object invokeSuspend(java.lang.Object r12) {
+        /*
+            Method dump skipped, instructions count: 424
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.google.firebase.sessions.settings.RemoteSettings$updateSettings$2$1.invokeSuspend(java.lang.Object):java.lang.Object");
+    }
+}

decompiled/sources/com/google/firebase/sessions/settings/RemoteSettings$updateSettings$2$2.java

@@ -0,0 +1,42 @@
+package com.google.firebase.sessions.settings;
+
+import android.util.Log;
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+
+/* loaded from: classes3.dex */
+public final class RemoteSettings$updateSettings$2$2 extends SuspendLambda implements Function2 {
+    public /* synthetic */ Object L$0;
+    public int label;
+
+    public RemoteSettings$updateSettings$2$2(Continuation continuation) {
+        super(2, continuation);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        RemoteSettings$updateSettings$2$2 remoteSettings$updateSettings$2$2 = new RemoteSettings$updateSettings$2$2(continuation);
+        remoteSettings$updateSettings$2$2.L$0 = obj;
+        return remoteSettings$updateSettings$2$2;
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(String str, Continuation continuation) {
+        return ((RemoteSettings$updateSettings$2$2) create(str, continuation)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        if (this.label == 0) {
+            ResultKt.throwOnFailure(obj);
+            Log.e("SessionConfigFetcher", "Error failing to fetch the remote configs: " + ((String) this.L$0));
+            return Unit.INSTANCE;
+        }
+        throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+    }
+}

decompiled/sources/com/google/firebase/sessions/settings/RemoteSettings.java

@@ -0,0 +1,110 @@
+package com.google.firebase.sessions.settings;
+
+import androidx.datastore.core.DataStore;
+import com.google.firebase.installations.FirebaseInstallationsApi;
+import com.google.firebase.sessions.ApplicationInfo;
+import kotlin.Lazy;
+import kotlin.LazyKt__LazyJVMKt;
+import kotlin.coroutines.CoroutineContext;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.text.Regex;
+import kotlin.time.Duration;
+import kotlin.time.DurationKt;
+import kotlin.time.DurationUnit;
+import kotlinx.coroutines.sync.Mutex;
+import kotlinx.coroutines.sync.MutexKt;
+
+/* loaded from: classes3.dex */
+public final class RemoteSettings implements SettingsProvider {
+    public static final Companion Companion = new Companion(null);
+    public final ApplicationInfo appInfo;
+    public final CoroutineContext backgroundDispatcher;
+    public final CrashlyticsSettingsFetcher configsFetcher;
+    public final Mutex fetchInProgress;
+    public final FirebaseInstallationsApi firebaseInstallationsApi;
+    public final Lazy settingsCache$delegate;
+
+    public RemoteSettings(CoroutineContext backgroundDispatcher, FirebaseInstallationsApi firebaseInstallationsApi, ApplicationInfo appInfo, CrashlyticsSettingsFetcher configsFetcher, final DataStore dataStore) {
+        Lazy lazy;
+        Intrinsics.checkNotNullParameter(backgroundDispatcher, "backgroundDispatcher");
+        Intrinsics.checkNotNullParameter(firebaseInstallationsApi, "firebaseInstallationsApi");
+        Intrinsics.checkNotNullParameter(appInfo, "appInfo");
+        Intrinsics.checkNotNullParameter(configsFetcher, "configsFetcher");
+        Intrinsics.checkNotNullParameter(dataStore, "dataStore");
+        this.backgroundDispatcher = backgroundDispatcher;
+        this.firebaseInstallationsApi = firebaseInstallationsApi;
+        this.appInfo = appInfo;
+        this.configsFetcher = configsFetcher;
+        lazy = LazyKt__LazyJVMKt.lazy(new Function0() { // from class: com.google.firebase.sessions.settings.RemoteSettings$settingsCache$2
+            {
+                super(0);
+            }
+
+            @Override // kotlin.jvm.functions.Function0
+            public final SettingsCache invoke() {
+                return new SettingsCache(DataStore.this);
+            }
+        });
+        this.settingsCache$delegate = lazy;
+        this.fetchInProgress = MutexKt.Mutex$default(false, 1, null);
+    }
+
+    public final SettingsCache getSettingsCache() {
+        return (SettingsCache) this.settingsCache$delegate.getValue();
+    }
+
+    @Override // com.google.firebase.sessions.settings.SettingsProvider
+    public Boolean getSessionEnabled() {
+        return getSettingsCache().sessionsEnabled();
+    }
+
+    @Override // com.google.firebase.sessions.settings.SettingsProvider
+    /* renamed from: getSessionRestartTimeout-FghU774 */
+    public Duration mo852getSessionRestartTimeoutFghU774() {
+        Integer sessionRestartTimeout = getSettingsCache().sessionRestartTimeout();
+        if (sessionRestartTimeout == null) {
+            return null;
+        }
+        Duration.Companion companion = Duration.Companion;
+        return Duration.m4073boximpl(DurationKt.toDuration(sessionRestartTimeout.intValue(), DurationUnit.SECONDS));
+    }
+
+    @Override // com.google.firebase.sessions.settings.SettingsProvider
+    public Double getSamplingRate() {
+        return getSettingsCache().sessionSamplingRate();
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:29:0x00be A[Catch: all -> 0x004d, TRY_LEAVE, TryCatch #2 {all -> 0x004d, blocks: (B:26:0x0048, B:27:0x00b0, B:29:0x00be, B:33:0x00cc), top: B:25:0x0048 }] */
+    /* JADX WARN: Removed duplicated region for block: B:32:0x00cb  */
+    /* JADX WARN: Removed duplicated region for block: B:43:0x0090 A[Catch: all -> 0x0096, TRY_LEAVE, TryCatch #1 {all -> 0x0096, blocks: (B:41:0x0086, B:43:0x0090, B:46:0x009c), top: B:40:0x0086 }] */
+    /* JADX WARN: Removed duplicated region for block: B:46:0x009c A[Catch: all -> 0x0096, TRY_ENTER, TRY_LEAVE, TryCatch #1 {all -> 0x0096, blocks: (B:41:0x0086, B:43:0x0090, B:46:0x009c), top: B:40:0x0086 }] */
+    /* JADX WARN: Removed duplicated region for block: B:52:0x005e  */
+    /* JADX WARN: Removed duplicated region for block: B:8:0x0026  */
+    @Override // com.google.firebase.sessions.settings.SettingsProvider
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public java.lang.Object updateSettings(kotlin.coroutines.Continuation r15) {
+        /*
+            Method dump skipped, instructions count: 349
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.google.firebase.sessions.settings.RemoteSettings.updateSettings(kotlin.coroutines.Continuation):java.lang.Object");
+    }
+
+    public final String removeForwardSlashesIn(String str) {
+        return new Regex("/").replace(str, "");
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        public Companion() {
+        }
+    }
+}

decompiled/sources/com/google/firebase/sessions/settings/RemoteSettingsFetcher$doConfigFetch$2.java

@@ -0,0 +1,120 @@
+package com.google.firebase.sessions.settings;
+
+import com.ironsource.nb;
+import java.io.BufferedReader;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.net.URL;
+import java.net.URLConnection;
+import java.util.Map;
+import javax.net.ssl.HttpsURLConnection;
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.Ref;
+import kotlinx.coroutines.CoroutineScope;
+import org.json.JSONObject;
+
+/* loaded from: classes3.dex */
+public final class RemoteSettingsFetcher$doConfigFetch$2 extends SuspendLambda implements Function2 {
+    public final /* synthetic */ Map $headerOptions;
+    public final /* synthetic */ Function2 $onFailure;
+    public final /* synthetic */ Function2 $onSuccess;
+    public int label;
+    public final /* synthetic */ RemoteSettingsFetcher this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public RemoteSettingsFetcher$doConfigFetch$2(RemoteSettingsFetcher remoteSettingsFetcher, Map map, Function2 function2, Function2 function22, Continuation continuation) {
+        super(2, continuation);
+        this.this$0 = remoteSettingsFetcher;
+        this.$headerOptions = map;
+        this.$onSuccess = function2;
+        this.$onFailure = function22;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        return new RemoteSettingsFetcher$doConfigFetch$2(this.this$0, this.$headerOptions, this.$onSuccess, this.$onFailure, continuation);
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(CoroutineScope coroutineScope, Continuation continuation) {
+        return ((RemoteSettingsFetcher$doConfigFetch$2) create(coroutineScope, continuation)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Type inference failed for: r6v0, types: [T, java.lang.String] */
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        Object coroutine_suspended;
+        URL url;
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.label;
+        try {
+            if (i == 0) {
+                ResultKt.throwOnFailure(obj);
+                url = this.this$0.settingsUrl();
+                URLConnection openConnection = url.openConnection();
+                Intrinsics.checkNotNull(openConnection, "null cannot be cast to non-null type javax.net.ssl.HttpsURLConnection");
+                HttpsURLConnection httpsURLConnection = (HttpsURLConnection) openConnection;
+                httpsURLConnection.setRequestMethod("GET");
+                httpsURLConnection.setRequestProperty("Accept", nb.L);
+                for (Map.Entry entry : this.$headerOptions.entrySet()) {
+                    httpsURLConnection.setRequestProperty((String) entry.getKey(), (String) entry.getValue());
+                }
+                int responseCode = httpsURLConnection.getResponseCode();
+                if (responseCode == 200) {
+                    InputStream inputStream = httpsURLConnection.getInputStream();
+                    BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
+                    StringBuilder sb = new StringBuilder();
+                    Ref.ObjectRef objectRef = new Ref.ObjectRef();
+                    while (true) {
+                        ?? readLine = bufferedReader.readLine();
+                        objectRef.element = readLine;
+                        if (readLine == 0) {
+                            break;
+                        }
+                        sb.append((String) readLine);
+                    }
+                    bufferedReader.close();
+                    inputStream.close();
+                    JSONObject jSONObject = new JSONObject(sb.toString());
+                    Function2 function2 = this.$onSuccess;
+                    this.label = 1;
+                    if (function2.invoke(jSONObject, this) == coroutine_suspended) {
+                        return coroutine_suspended;
+                    }
+                } else {
+                    Function2 function22 = this.$onFailure;
+                    String str = "Bad response code: " + responseCode;
+                    this.label = 2;
+                    if (function22.invoke(str, this) == coroutine_suspended) {
+                        return coroutine_suspended;
+                    }
+                }
+            } else if (i == 1 || i == 2) {
+                ResultKt.throwOnFailure(obj);
+            } else {
+                if (i != 3) {
+                    throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+                }
+                ResultKt.throwOnFailure(obj);
+            }
+        } catch (Exception e) {
+            Function2 function23 = this.$onFailure;
+            String message = e.getMessage();
+            if (message == null) {
+                message = e.toString();
+            }
+            this.label = 3;
+            if (function23.invoke(message, this) == coroutine_suspended) {
+                return coroutine_suspended;
+            }
+        }
+        return Unit.INSTANCE;
+    }
+}

decompiled/sources/com/google/firebase/sessions/settings/RemoteSettingsFetcher.java

@@ -0,0 +1,56 @@
+package com.google.firebase.sessions.settings;
+
+import android.net.Uri;
+import com.google.firebase.sessions.ApplicationInfo;
+import java.net.URL;
+import java.util.Map;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.CoroutineContext;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlinx.coroutines.BuildersKt;
+
+/* loaded from: classes3.dex */
+public final class RemoteSettingsFetcher implements CrashlyticsSettingsFetcher {
+    public static final Companion Companion = new Companion(null);
+    public final ApplicationInfo appInfo;
+    public final String baseUrl;
+    public final CoroutineContext blockingDispatcher;
+
+    public RemoteSettingsFetcher(ApplicationInfo appInfo, CoroutineContext blockingDispatcher, String baseUrl) {
+        Intrinsics.checkNotNullParameter(appInfo, "appInfo");
+        Intrinsics.checkNotNullParameter(blockingDispatcher, "blockingDispatcher");
+        Intrinsics.checkNotNullParameter(baseUrl, "baseUrl");
+        this.appInfo = appInfo;
+        this.blockingDispatcher = blockingDispatcher;
+        this.baseUrl = baseUrl;
+    }
+
+    public /* synthetic */ RemoteSettingsFetcher(ApplicationInfo applicationInfo, CoroutineContext coroutineContext, String str, int i, DefaultConstructorMarker defaultConstructorMarker) {
+        this(applicationInfo, coroutineContext, (i & 4) != 0 ? "firebase-settings.crashlytics.com" : str);
+    }
+
+    @Override // com.google.firebase.sessions.settings.CrashlyticsSettingsFetcher
+    public Object doConfigFetch(Map map, Function2 function2, Function2 function22, Continuation continuation) {
+        Object coroutine_suspended;
+        Object withContext = BuildersKt.withContext(this.blockingDispatcher, new RemoteSettingsFetcher$doConfigFetch$2(this, map, function2, function22, null), continuation);
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        return withContext == coroutine_suspended ? withContext : Unit.INSTANCE;
+    }
+
+    public final URL settingsUrl() {
+        return new URL(new Uri.Builder().scheme("https").authority(this.baseUrl).appendPath("spi").appendPath("v2").appendPath("platforms").appendPath("android").appendPath("gmp").appendPath(this.appInfo.getAppId()).appendPath("settings").appendQueryParameter("build_version", this.appInfo.getAndroidAppInfo().getAppBuildVersion()).appendQueryParameter("display_version", this.appInfo.getAndroidAppInfo().getVersionName()).build().toString());
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        public Companion() {
+        }
+    }
+}

decompiled/sources/com/google/firebase/sessions/settings/SessionConfigs.java

@@ -0,0 +1,68 @@
+package com.google.firebase.sessions.settings;
+
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes3.dex */
+public final class SessionConfigs {
+    public final Integer cacheDuration;
+    public final Long cacheUpdatedTime;
+    public final Boolean sessionEnabled;
+    public final Integer sessionRestartTimeout;
+    public final Double sessionSamplingRate;
+
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof SessionConfigs)) {
+            return false;
+        }
+        SessionConfigs sessionConfigs = (SessionConfigs) obj;
+        return Intrinsics.areEqual(this.sessionEnabled, sessionConfigs.sessionEnabled) && Intrinsics.areEqual((Object) this.sessionSamplingRate, (Object) sessionConfigs.sessionSamplingRate) && Intrinsics.areEqual(this.sessionRestartTimeout, sessionConfigs.sessionRestartTimeout) && Intrinsics.areEqual(this.cacheDuration, sessionConfigs.cacheDuration) && Intrinsics.areEqual(this.cacheUpdatedTime, sessionConfigs.cacheUpdatedTime);
+    }
+
+    public final Integer getCacheDuration() {
+        return this.cacheDuration;
+    }
+
+    public final Long getCacheUpdatedTime() {
+        return this.cacheUpdatedTime;
+    }
+
+    public final Boolean getSessionEnabled() {
+        return this.sessionEnabled;
+    }
+
+    public final Integer getSessionRestartTimeout() {
+        return this.sessionRestartTimeout;
+    }
+
+    public final Double getSessionSamplingRate() {
+        return this.sessionSamplingRate;
+    }
+
+    public int hashCode() {
+        Boolean bool = this.sessionEnabled;
+        int hashCode = (bool == null ? 0 : bool.hashCode()) * 31;
+        Double d = this.sessionSamplingRate;
+        int hashCode2 = (hashCode + (d == null ? 0 : d.hashCode())) * 31;
+        Integer num = this.sessionRestartTimeout;
+        int hashCode3 = (hashCode2 + (num == null ? 0 : num.hashCode())) * 31;
+        Integer num2 = this.cacheDuration;
+        int hashCode4 = (hashCode3 + (num2 == null ? 0 : num2.hashCode())) * 31;
+        Long l = this.cacheUpdatedTime;
+        return hashCode4 + (l != null ? l.hashCode() : 0);
+    }
+
+    public String toString() {
+        return "SessionConfigs(sessionEnabled=" + this.sessionEnabled + ", sessionSamplingRate=" + this.sessionSamplingRate + ", sessionRestartTimeout=" + this.sessionRestartTimeout + ", cacheDuration=" + this.cacheDuration + ", cacheUpdatedTime=" + this.cacheUpdatedTime + ')';
+    }
+
+    public SessionConfigs(Boolean bool, Double d, Integer num, Integer num2, Long l) {
+        this.sessionEnabled = bool;
+        this.sessionSamplingRate = d;
+        this.sessionRestartTimeout = num;
+        this.cacheDuration = num2;
+        this.cacheUpdatedTime = l;
+    }
+}

decompiled/sources/com/google/firebase/sessions/settings/SessionsSettings$updateSettings$1.java

@@ -0,0 +1,25 @@
+package com.google.firebase.sessions.settings;
+
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.jvm.internal.ContinuationImpl;
+
+/* loaded from: classes3.dex */
+public final class SessionsSettings$updateSettings$1 extends ContinuationImpl {
+    public Object L$0;
+    public int label;
+    public /* synthetic */ Object result;
+    public final /* synthetic */ SessionsSettings this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public SessionsSettings$updateSettings$1(SessionsSettings sessionsSettings, Continuation continuation) {
+        super(continuation);
+        this.this$0 = sessionsSettings;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        this.result = obj;
+        this.label |= Integer.MIN_VALUE;
+        return this.this$0.updateSettings(this);
+    }
+}

decompiled/sources/com/google/firebase/sessions/settings/SessionsSettings.java

@@ -0,0 +1,235 @@
+package com.google.firebase.sessions.settings;
+
+import android.content.Context;
+import android.util.Log;
+import androidx.datastore.core.CorruptionException;
+import androidx.datastore.core.DataStore;
+import androidx.datastore.core.handlers.ReplaceFileCorruptionHandler;
+import androidx.datastore.preferences.PreferenceDataStoreDelegateKt;
+import androidx.datastore.preferences.core.Preferences;
+import androidx.datastore.preferences.core.PreferencesFactory;
+import com.google.firebase.Firebase;
+import com.google.firebase.FirebaseKt;
+import com.google.firebase.installations.FirebaseInstallationsApi;
+import com.google.firebase.sessions.ApplicationInfo;
+import com.google.firebase.sessions.ProcessDetailsProvider;
+import com.google.firebase.sessions.SessionDataStoreConfigs;
+import kotlin.coroutines.CoroutineContext;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.PropertyReference2Impl;
+import kotlin.jvm.internal.Reflection;
+import kotlin.properties.ReadOnlyProperty;
+import kotlin.reflect.KProperty;
+import kotlin.time.Duration;
+import kotlin.time.DurationKt;
+import kotlin.time.DurationUnit;
+
+/* loaded from: classes3.dex */
+public final class SessionsSettings {
+    public static final Companion Companion = new Companion(null);
+    public static final ReadOnlyProperty dataStore$delegate = PreferenceDataStoreDelegateKt.preferencesDataStore$default(SessionDataStoreConfigs.INSTANCE.getSETTINGS_CONFIG_NAME(), new ReplaceFileCorruptionHandler(new Function1() { // from class: com.google.firebase.sessions.settings.SessionsSettings$Companion$dataStore$2
+        @Override // kotlin.jvm.functions.Function1
+        public final Preferences invoke(CorruptionException ex) {
+            Intrinsics.checkNotNullParameter(ex, "ex");
+            Log.w("SessionsSettings", "CorruptionException in settings DataStore in " + ProcessDetailsProvider.INSTANCE.getProcessName$com_google_firebase_firebase_sessions() + '.', ex);
+            return PreferencesFactory.createEmpty();
+        }
+    }), null, null, 12, null);
+    public final SettingsProvider localOverrideSettings;
+    public final SettingsProvider remoteSettings;
+
+    public final boolean isValidSamplingRate(double d) {
+        return 0.0d <= d && d <= 1.0d;
+    }
+
+    public SessionsSettings(SettingsProvider localOverrideSettings, SettingsProvider remoteSettings) {
+        Intrinsics.checkNotNullParameter(localOverrideSettings, "localOverrideSettings");
+        Intrinsics.checkNotNullParameter(remoteSettings, "remoteSettings");
+        this.localOverrideSettings = localOverrideSettings;
+        this.remoteSettings = remoteSettings;
+    }
+
+    public SessionsSettings(Context context, CoroutineContext coroutineContext, CoroutineContext coroutineContext2, FirebaseInstallationsApi firebaseInstallationsApi, ApplicationInfo applicationInfo) {
+        this(new LocalOverrideSettings(context), new RemoteSettings(coroutineContext2, firebaseInstallationsApi, applicationInfo, new RemoteSettingsFetcher(applicationInfo, coroutineContext, null, 4, null), Companion.getDataStore(context)));
+    }
+
+    /* JADX WARN: Illegal instructions before constructor call */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public SessionsSettings(com.google.firebase.FirebaseApp r8, kotlin.coroutines.CoroutineContext r9, kotlin.coroutines.CoroutineContext r10, com.google.firebase.installations.FirebaseInstallationsApi r11) {
+        /*
+            r7 = this;
+            java.lang.String r0 = "firebaseApp"
+            kotlin.jvm.internal.Intrinsics.checkNotNullParameter(r8, r0)
+            java.lang.String r0 = "blockingDispatcher"
+            kotlin.jvm.internal.Intrinsics.checkNotNullParameter(r9, r0)
+            java.lang.String r0 = "backgroundDispatcher"
+            kotlin.jvm.internal.Intrinsics.checkNotNullParameter(r10, r0)
+            java.lang.String r0 = "firebaseInstallationsApi"
+            kotlin.jvm.internal.Intrinsics.checkNotNullParameter(r11, r0)
+            android.content.Context r2 = r8.getApplicationContext()
+            java.lang.String r0 = "firebaseApp.applicationContext"
+            kotlin.jvm.internal.Intrinsics.checkNotNullExpressionValue(r2, r0)
+            com.google.firebase.sessions.SessionEvents r0 = com.google.firebase.sessions.SessionEvents.INSTANCE
+            com.google.firebase.sessions.ApplicationInfo r6 = r0.getApplicationInfo(r8)
+            r1 = r7
+            r3 = r9
+            r4 = r10
+            r5 = r11
+            r1.<init>(r2, r3, r4, r5, r6)
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.google.firebase.sessions.settings.SessionsSettings.<init>(com.google.firebase.FirebaseApp, kotlin.coroutines.CoroutineContext, kotlin.coroutines.CoroutineContext, com.google.firebase.installations.FirebaseInstallationsApi):void");
+    }
+
+    public final boolean getSessionsEnabled() {
+        Boolean sessionEnabled = this.localOverrideSettings.getSessionEnabled();
+        if (sessionEnabled != null) {
+            return sessionEnabled.booleanValue();
+        }
+        Boolean sessionEnabled2 = this.remoteSettings.getSessionEnabled();
+        if (sessionEnabled2 != null) {
+            return sessionEnabled2.booleanValue();
+        }
+        return true;
+    }
+
+    public final double getSamplingRate() {
+        Double samplingRate = this.localOverrideSettings.getSamplingRate();
+        if (samplingRate != null) {
+            double doubleValue = samplingRate.doubleValue();
+            if (isValidSamplingRate(doubleValue)) {
+                return doubleValue;
+            }
+        }
+        Double samplingRate2 = this.remoteSettings.getSamplingRate();
+        if (samplingRate2 == null) {
+            return 1.0d;
+        }
+        double doubleValue2 = samplingRate2.doubleValue();
+        if (isValidSamplingRate(doubleValue2)) {
+            return doubleValue2;
+        }
+        return 1.0d;
+    }
+
+    /* renamed from: getSessionRestartTimeout-UwyO8pc, reason: not valid java name */
+    public final long m853getSessionRestartTimeoutUwyO8pc() {
+        Duration mo852getSessionRestartTimeoutFghU774 = this.localOverrideSettings.mo852getSessionRestartTimeoutFghU774();
+        if (mo852getSessionRestartTimeoutFghU774 != null) {
+            long m4102unboximpl = mo852getSessionRestartTimeoutFghU774.m4102unboximpl();
+            if (m854isValidSessionRestartTimeoutLRDsOJo(m4102unboximpl)) {
+                return m4102unboximpl;
+            }
+        }
+        Duration mo852getSessionRestartTimeoutFghU7742 = this.remoteSettings.mo852getSessionRestartTimeoutFghU774();
+        if (mo852getSessionRestartTimeoutFghU7742 != null) {
+            long m4102unboximpl2 = mo852getSessionRestartTimeoutFghU7742.m4102unboximpl();
+            if (m854isValidSessionRestartTimeoutLRDsOJo(m4102unboximpl2)) {
+                return m4102unboximpl2;
+            }
+        }
+        Duration.Companion companion = Duration.Companion;
+        return DurationKt.toDuration(30, DurationUnit.MINUTES);
+    }
+
+    /* renamed from: isValidSessionRestartTimeout-LRDsOJo, reason: not valid java name */
+    public final boolean m854isValidSessionRestartTimeoutLRDsOJo(long j) {
+        return Duration.m4095isPositiveimpl(j) && Duration.m4090isFiniteimpl(j);
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:19:0x005a A[RETURN] */
+    /* JADX WARN: Removed duplicated region for block: B:20:0x003c  */
+    /* JADX WARN: Removed duplicated region for block: B:8:0x0024  */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final java.lang.Object updateSettings(kotlin.coroutines.Continuation r6) {
+        /*
+            r5 = this;
+            boolean r0 = r6 instanceof com.google.firebase.sessions.settings.SessionsSettings$updateSettings$1
+            if (r0 == 0) goto L13
+            r0 = r6
+            com.google.firebase.sessions.settings.SessionsSettings$updateSettings$1 r0 = (com.google.firebase.sessions.settings.SessionsSettings$updateSettings$1) r0
+            int r1 = r0.label
+            r2 = -2147483648(0xffffffff80000000, float:-0.0)
+            r3 = r1 & r2
+            if (r3 == 0) goto L13
+            int r1 = r1 - r2
+            r0.label = r1
+            goto L18
+        L13:
+            com.google.firebase.sessions.settings.SessionsSettings$updateSettings$1 r0 = new com.google.firebase.sessions.settings.SessionsSettings$updateSettings$1
+            r0.<init>(r5, r6)
+        L18:
+            java.lang.Object r6 = r0.result
+            java.lang.Object r1 = kotlin.coroutines.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED()
+            int r2 = r0.label
+            r3 = 2
+            r4 = 1
+            if (r2 == 0) goto L3c
+            if (r2 == r4) goto L34
+            if (r2 != r3) goto L2c
+            kotlin.ResultKt.throwOnFailure(r6)
+            goto L5b
+        L2c:
+            java.lang.IllegalStateException r6 = new java.lang.IllegalStateException
+            java.lang.String r0 = "call to 'resume' before 'invoke' with coroutine"
+            r6.<init>(r0)
+            throw r6
+        L34:
+            java.lang.Object r2 = r0.L$0
+            com.google.firebase.sessions.settings.SessionsSettings r2 = (com.google.firebase.sessions.settings.SessionsSettings) r2
+            kotlin.ResultKt.throwOnFailure(r6)
+            goto L4d
+        L3c:
+            kotlin.ResultKt.throwOnFailure(r6)
+            com.google.firebase.sessions.settings.SettingsProvider r6 = r5.localOverrideSettings
+            r0.L$0 = r5
+            r0.label = r4
+            java.lang.Object r6 = r6.updateSettings(r0)
+            if (r6 != r1) goto L4c
+            return r1
+        L4c:
+            r2 = r5
+        L4d:
+            com.google.firebase.sessions.settings.SettingsProvider r6 = r2.remoteSettings
+            r2 = 0
+            r0.L$0 = r2
+            r0.label = r3
+            java.lang.Object r6 = r6.updateSettings(r0)
+            if (r6 != r1) goto L5b
+            return r1
+        L5b:
+            kotlin.Unit r6 = kotlin.Unit.INSTANCE
+            return r6
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.google.firebase.sessions.settings.SessionsSettings.updateSettings(kotlin.coroutines.Continuation):java.lang.Object");
+    }
+
+    public static final class Companion {
+        public static final /* synthetic */ KProperty[] $$delegatedProperties = {Reflection.property2(new PropertyReference2Impl(Companion.class, "dataStore", "getDataStore(Landroid/content/Context;)Landroidx/datastore/core/DataStore;", 0))};
+
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        public Companion() {
+        }
+
+        public final SessionsSettings getInstance() {
+            Object obj = FirebaseKt.getApp(Firebase.INSTANCE).get(SessionsSettings.class);
+            Intrinsics.checkNotNullExpressionValue(obj, "Firebase.app[SessionsSettings::class.java]");
+            return (SessionsSettings) obj;
+        }
+
+        public final DataStore getDataStore(Context context) {
+            return (DataStore) SessionsSettings.dataStore$delegate.getValue(context, $$delegatedProperties[0]);
+        }
+    }
+}

decompiled/sources/com/google/firebase/sessions/settings/SettingsCache$updateConfigValue$1.java

@@ -0,0 +1,26 @@
+package com.google.firebase.sessions.settings;
+
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.jvm.internal.ContinuationImpl;
+
+/* loaded from: classes3.dex */
+public final class SettingsCache$updateConfigValue$1 extends ContinuationImpl {
+    public int label;
+    public /* synthetic */ Object result;
+    public final /* synthetic */ SettingsCache this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public SettingsCache$updateConfigValue$1(SettingsCache settingsCache, Continuation continuation) {
+        super(continuation);
+        this.this$0 = settingsCache;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        Object updateConfigValue;
+        this.result = obj;
+        this.label |= Integer.MIN_VALUE;
+        updateConfigValue = this.this$0.updateConfigValue(null, null, this);
+        return updateConfigValue;
+    }
+}

decompiled/sources/com/google/firebase/sessions/settings/SettingsCache$updateConfigValue$2.java

@@ -0,0 +1,57 @@
+package com.google.firebase.sessions.settings;
+
+import androidx.datastore.preferences.core.MutablePreferences;
+import androidx.datastore.preferences.core.Preferences;
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+
+/* loaded from: classes3.dex */
+public final class SettingsCache$updateConfigValue$2 extends SuspendLambda implements Function2 {
+    public final /* synthetic */ Preferences.Key $key;
+    public final /* synthetic */ Object $value;
+    public /* synthetic */ Object L$0;
+    public int label;
+    public final /* synthetic */ SettingsCache this$0;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public SettingsCache$updateConfigValue$2(Object obj, Preferences.Key key, SettingsCache settingsCache, Continuation continuation) {
+        super(2, continuation);
+        this.$value = obj;
+        this.$key = key;
+        this.this$0 = settingsCache;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        SettingsCache$updateConfigValue$2 settingsCache$updateConfigValue$2 = new SettingsCache$updateConfigValue$2(this.$value, this.$key, this.this$0, continuation);
+        settingsCache$updateConfigValue$2.L$0 = obj;
+        return settingsCache$updateConfigValue$2;
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(MutablePreferences mutablePreferences, Continuation continuation) {
+        return ((SettingsCache$updateConfigValue$2) create(mutablePreferences, continuation)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        if (this.label == 0) {
+            ResultKt.throwOnFailure(obj);
+            MutablePreferences mutablePreferences = (MutablePreferences) this.L$0;
+            Object obj2 = this.$value;
+            if (obj2 != null) {
+                mutablePreferences.set(this.$key, obj2);
+            } else {
+                mutablePreferences.remove(this.$key);
+            }
+            this.this$0.updateSessionConfigs(mutablePreferences);
+            return Unit.INSTANCE;
+        }
+        throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+    }
+}

decompiled/sources/com/google/firebase/sessions/settings/SettingsCache.java

@@ -0,0 +1,252 @@
+package com.google.firebase.sessions.settings;
+
+import androidx.datastore.core.DataStore;
+import androidx.datastore.preferences.core.Preferences;
+import androidx.datastore.preferences.core.PreferencesKeys;
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlinx.coroutines.BuildersKt__BuildersKt;
+import kotlinx.coroutines.CoroutineScope;
+import kotlinx.coroutines.flow.Flow;
+import kotlinx.coroutines.flow.FlowKt;
+
+/* loaded from: classes3.dex */
+public final class SettingsCache {
+    public final DataStore dataStore;
+    public SessionConfigs sessionConfigs;
+    public static final Companion Companion = new Companion(null);
+    public static final Preferences.Key SESSIONS_ENABLED = PreferencesKeys.booleanKey("firebase_sessions_enabled");
+    public static final Preferences.Key SAMPLING_RATE = PreferencesKeys.doubleKey("firebase_sessions_sampling_rate");
+    public static final Preferences.Key RESTART_TIMEOUT_SECONDS = PreferencesKeys.intKey("firebase_sessions_restart_timeout");
+    public static final Preferences.Key CACHE_DURATION_SECONDS = PreferencesKeys.intKey("firebase_sessions_cache_duration");
+    public static final Preferences.Key CACHE_UPDATED_TIME = PreferencesKeys.longKey("firebase_sessions_cache_updated_time");
+
+    public SettingsCache(DataStore dataStore) {
+        Intrinsics.checkNotNullParameter(dataStore, "dataStore");
+        this.dataStore = dataStore;
+        BuildersKt__BuildersKt.runBlocking$default(null, new AnonymousClass1(null), 1, null);
+    }
+
+    /* renamed from: com.google.firebase.sessions.settings.SettingsCache$1, reason: invalid class name */
+    public static final class AnonymousClass1 extends SuspendLambda implements Function2 {
+        public Object L$0;
+        public int label;
+
+        public AnonymousClass1(Continuation continuation) {
+            super(2, continuation);
+        }
+
+        @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+        public final Continuation create(Object obj, Continuation continuation) {
+            return SettingsCache.this.new AnonymousClass1(continuation);
+        }
+
+        @Override // kotlin.jvm.functions.Function2
+        public final Object invoke(CoroutineScope coroutineScope, Continuation continuation) {
+            return ((AnonymousClass1) create(coroutineScope, continuation)).invokeSuspend(Unit.INSTANCE);
+        }
+
+        @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+        public final Object invokeSuspend(Object obj) {
+            Object coroutine_suspended;
+            SettingsCache settingsCache;
+            coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+            int i = this.label;
+            if (i == 0) {
+                ResultKt.throwOnFailure(obj);
+                SettingsCache settingsCache2 = SettingsCache.this;
+                Flow data = settingsCache2.dataStore.getData();
+                this.L$0 = settingsCache2;
+                this.label = 1;
+                Object first = FlowKt.first(data, this);
+                if (first == coroutine_suspended) {
+                    return coroutine_suspended;
+                }
+                settingsCache = settingsCache2;
+                obj = first;
+            } else {
+                if (i != 1) {
+                    throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+                }
+                settingsCache = (SettingsCache) this.L$0;
+                ResultKt.throwOnFailure(obj);
+            }
+            settingsCache.updateSessionConfigs(((Preferences) obj).toPreferences());
+            return Unit.INSTANCE;
+        }
+    }
+
+    public final void updateSessionConfigs(Preferences preferences) {
+        this.sessionConfigs = new SessionConfigs((Boolean) preferences.get(SESSIONS_ENABLED), (Double) preferences.get(SAMPLING_RATE), (Integer) preferences.get(RESTART_TIMEOUT_SECONDS), (Integer) preferences.get(CACHE_DURATION_SECONDS), (Long) preferences.get(CACHE_UPDATED_TIME));
+    }
+
+    public final boolean hasCacheExpired$com_google_firebase_firebase_sessions() {
+        SessionConfigs sessionConfigs = this.sessionConfigs;
+        SessionConfigs sessionConfigs2 = null;
+        if (sessionConfigs == null) {
+            Intrinsics.throwUninitializedPropertyAccessException("sessionConfigs");
+            sessionConfigs = null;
+        }
+        Long cacheUpdatedTime = sessionConfigs.getCacheUpdatedTime();
+        SessionConfigs sessionConfigs3 = this.sessionConfigs;
+        if (sessionConfigs3 == null) {
+            Intrinsics.throwUninitializedPropertyAccessException("sessionConfigs");
+        } else {
+            sessionConfigs2 = sessionConfigs3;
+        }
+        Integer cacheDuration = sessionConfigs2.getCacheDuration();
+        return cacheUpdatedTime == null || cacheDuration == null || (System.currentTimeMillis() - cacheUpdatedTime.longValue()) / ((long) 1000) >= ((long) cacheDuration.intValue());
+    }
+
+    public final Boolean sessionsEnabled() {
+        SessionConfigs sessionConfigs = this.sessionConfigs;
+        if (sessionConfigs == null) {
+            Intrinsics.throwUninitializedPropertyAccessException("sessionConfigs");
+            sessionConfigs = null;
+        }
+        return sessionConfigs.getSessionEnabled();
+    }
+
+    public final Double sessionSamplingRate() {
+        SessionConfigs sessionConfigs = this.sessionConfigs;
+        if (sessionConfigs == null) {
+            Intrinsics.throwUninitializedPropertyAccessException("sessionConfigs");
+            sessionConfigs = null;
+        }
+        return sessionConfigs.getSessionSamplingRate();
+    }
+
+    public final Integer sessionRestartTimeout() {
+        SessionConfigs sessionConfigs = this.sessionConfigs;
+        if (sessionConfigs == null) {
+            Intrinsics.throwUninitializedPropertyAccessException("sessionConfigs");
+            sessionConfigs = null;
+        }
+        return sessionConfigs.getSessionRestartTimeout();
+    }
+
+    public final Object updateSettingsEnabled(Boolean bool, Continuation continuation) {
+        Object coroutine_suspended;
+        Object updateConfigValue = updateConfigValue(SESSIONS_ENABLED, bool, continuation);
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        return updateConfigValue == coroutine_suspended ? updateConfigValue : Unit.INSTANCE;
+    }
+
+    public final Object updateSamplingRate(Double d, Continuation continuation) {
+        Object coroutine_suspended;
+        Object updateConfigValue = updateConfigValue(SAMPLING_RATE, d, continuation);
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        return updateConfigValue == coroutine_suspended ? updateConfigValue : Unit.INSTANCE;
+    }
+
+    public final Object updateSessionRestartTimeout(Integer num, Continuation continuation) {
+        Object coroutine_suspended;
+        Object updateConfigValue = updateConfigValue(RESTART_TIMEOUT_SECONDS, num, continuation);
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        return updateConfigValue == coroutine_suspended ? updateConfigValue : Unit.INSTANCE;
+    }
+
+    public final Object updateSessionCacheDuration(Integer num, Continuation continuation) {
+        Object coroutine_suspended;
+        Object updateConfigValue = updateConfigValue(CACHE_DURATION_SECONDS, num, continuation);
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        return updateConfigValue == coroutine_suspended ? updateConfigValue : Unit.INSTANCE;
+    }
+
+    public final Object updateSessionCacheUpdatedTime(Long l, Continuation continuation) {
+        Object coroutine_suspended;
+        Object updateConfigValue = updateConfigValue(CACHE_UPDATED_TIME, l, continuation);
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        return updateConfigValue == coroutine_suspended ? updateConfigValue : Unit.INSTANCE;
+    }
+
+    /* JADX WARN: Can't wrap try/catch for region: R(10:0|1|(2:3|(7:5|6|7|(1:(1:10)(2:16|17))(3:18|19|(1:21))|11|12|13))|24|6|7|(0)(0)|11|12|13) */
+    /* JADX WARN: Code restructure failed: missing block: B:22:0x0029, code lost:
+    
+        r6 = move-exception;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:23:0x0047, code lost:
+    
+        android.util.Log.w("SettingsCache", "Failed to update cache config value: " + r6);
+     */
+    /* JADX WARN: Removed duplicated region for block: B:18:0x0033  */
+    /* JADX WARN: Removed duplicated region for block: B:9:0x0023  */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final java.lang.Object updateConfigValue(androidx.datastore.preferences.core.Preferences.Key r6, java.lang.Object r7, kotlin.coroutines.Continuation r8) {
+        /*
+            r5 = this;
+            boolean r0 = r8 instanceof com.google.firebase.sessions.settings.SettingsCache$updateConfigValue$1
+            if (r0 == 0) goto L13
+            r0 = r8
+            com.google.firebase.sessions.settings.SettingsCache$updateConfigValue$1 r0 = (com.google.firebase.sessions.settings.SettingsCache$updateConfigValue$1) r0
+            int r1 = r0.label
+            r2 = -2147483648(0xffffffff80000000, float:-0.0)
+            r3 = r1 & r2
+            if (r3 == 0) goto L13
+            int r1 = r1 - r2
+            r0.label = r1
+            goto L18
+        L13:
+            com.google.firebase.sessions.settings.SettingsCache$updateConfigValue$1 r0 = new com.google.firebase.sessions.settings.SettingsCache$updateConfigValue$1
+            r0.<init>(r5, r8)
+        L18:
+            java.lang.Object r8 = r0.result
+            java.lang.Object r1 = kotlin.coroutines.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED()
+            int r2 = r0.label
+            r3 = 1
+            if (r2 == 0) goto L33
+            if (r2 != r3) goto L2b
+            kotlin.ResultKt.throwOnFailure(r8)     // Catch: java.io.IOException -> L29
+            goto L5d
+        L29:
+            r6 = move-exception
+            goto L47
+        L2b:
+            java.lang.IllegalStateException r6 = new java.lang.IllegalStateException
+            java.lang.String r7 = "call to 'resume' before 'invoke' with coroutine"
+            r6.<init>(r7)
+            throw r6
+        L33:
+            kotlin.ResultKt.throwOnFailure(r8)
+            androidx.datastore.core.DataStore r8 = r5.dataStore     // Catch: java.io.IOException -> L29
+            com.google.firebase.sessions.settings.SettingsCache$updateConfigValue$2 r2 = new com.google.firebase.sessions.settings.SettingsCache$updateConfigValue$2     // Catch: java.io.IOException -> L29
+            r4 = 0
+            r2.<init>(r7, r6, r5, r4)     // Catch: java.io.IOException -> L29
+            r0.label = r3     // Catch: java.io.IOException -> L29
+            java.lang.Object r6 = androidx.datastore.preferences.core.PreferencesKt.edit(r8, r2, r0)     // Catch: java.io.IOException -> L29
+            if (r6 != r1) goto L5d
+            return r1
+        L47:
+            java.lang.StringBuilder r7 = new java.lang.StringBuilder
+            r7.<init>()
+            java.lang.String r8 = "Failed to update cache config value: "
+            r7.append(r8)
+            r7.append(r6)
+            java.lang.String r6 = r7.toString()
+            java.lang.String r7 = "SettingsCache"
+            android.util.Log.w(r7, r6)
+        L5d:
+            kotlin.Unit r6 = kotlin.Unit.INSTANCE
+            return r6
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.google.firebase.sessions.settings.SettingsCache.updateConfigValue(androidx.datastore.preferences.core.Preferences$Key, java.lang.Object, kotlin.coroutines.Continuation):java.lang.Object");
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        public Companion() {
+        }
+    }
+}

decompiled/sources/com/google/firebase/sessions/settings/SettingsProvider.java

@@ -0,0 +1,23 @@
+package com.google.firebase.sessions.settings;
+
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.time.Duration;
+
+/* loaded from: classes3.dex */
+public interface SettingsProvider {
+    Double getSamplingRate();
+
+    Boolean getSessionEnabled();
+
+    /* renamed from: getSessionRestartTimeout-FghU774 */
+    Duration mo852getSessionRestartTimeoutFghU774();
+
+    Object updateSettings(Continuation continuation);
+
+    public static final class DefaultImpls {
+        public static Object updateSettings(SettingsProvider settingsProvider, Continuation continuation) {
+            return Unit.INSTANCE;
+        }
+    }
+}