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/androidx/room/RoomDatabaseKt.java

@@ -0,0 +1,149 @@
+package androidx.room;
+
+import java.util.concurrent.RejectedExecutionException;
+import kotlin.Result;
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.ContinuationInterceptor;
+import kotlin.coroutines.CoroutineContext;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsJvmKt;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.DebugMetadata;
+import kotlin.coroutines.jvm.internal.DebugProbesKt;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+import kotlinx.coroutines.BuildersKt;
+import kotlinx.coroutines.CancellableContinuation;
+import kotlinx.coroutines.CancellableContinuationImpl;
+import kotlinx.coroutines.CoroutineScope;
+import kotlinx.coroutines.ThreadContextElementKt;
+import kotlinx.coroutines.flow.Flow;
+import kotlinx.coroutines.flow.FlowKt;
+
+@SourceDebugExtension({"SMAP\nRoomDatabaseExt.kt\nKotlin\n*S Kotlin\n*F\n+ 1 RoomDatabaseExt.kt\nandroidx/room/RoomDatabaseKt\n+ 2 CancellableContinuation.kt\nkotlinx/coroutines/CancellableContinuationKt\n*L\n1#1,239:1\n314#2,11:240\n*S KotlinDebug\n*F\n+ 1 RoomDatabaseExt.kt\nandroidx/room/RoomDatabaseKt\n*L\n92#1:240,11\n*E\n"})
+/* loaded from: classes.dex */
+public final class RoomDatabaseKt {
+    public static final <R> Object withTransaction(RoomDatabase roomDatabase, Function1 function1, Continuation continuation) {
+        RoomDatabaseKt$withTransaction$transactionBlock$1 roomDatabaseKt$withTransaction$transactionBlock$1 = new RoomDatabaseKt$withTransaction$transactionBlock$1(roomDatabase, function1, null);
+        TransactionElement transactionElement = (TransactionElement) continuation.getContext().get(TransactionElement.Key);
+        ContinuationInterceptor transactionDispatcher$room_ktx_release = transactionElement != null ? transactionElement.getTransactionDispatcher$room_ktx_release() : null;
+        if (transactionDispatcher$room_ktx_release != null) {
+            return BuildersKt.withContext(transactionDispatcher$room_ktx_release, roomDatabaseKt$withTransaction$transactionBlock$1, continuation);
+        }
+        return startTransactionCoroutine(roomDatabase, continuation.getContext(), roomDatabaseKt$withTransaction$transactionBlock$1, continuation);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static final CoroutineContext createTransactionContext(RoomDatabase roomDatabase, ContinuationInterceptor continuationInterceptor) {
+        TransactionElement transactionElement = new TransactionElement(continuationInterceptor);
+        return continuationInterceptor.plus(transactionElement).plus(ThreadContextElementKt.asContextElement(roomDatabase.getSuspendingTransactionId(), Integer.valueOf(System.identityHashCode(transactionElement))));
+    }
+
+    public static /* synthetic */ Flow invalidationTrackerFlow$default(RoomDatabase roomDatabase, String[] strArr, boolean z, int i, Object obj) {
+        if ((i & 2) != 0) {
+            z = true;
+        }
+        return invalidationTrackerFlow(roomDatabase, strArr, z);
+    }
+
+    public static final Flow invalidationTrackerFlow(RoomDatabase roomDatabase, String[] strArr, boolean z) {
+        return FlowKt.callbackFlow(new RoomDatabaseKt$invalidationTrackerFlow$1(z, roomDatabase, strArr, null));
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static final <R> Object startTransactionCoroutine(final RoomDatabase roomDatabase, final CoroutineContext coroutineContext, final Function2 function2, Continuation continuation) {
+        Continuation intercepted;
+        Object coroutine_suspended;
+        intercepted = IntrinsicsKt__IntrinsicsJvmKt.intercepted(continuation);
+        final CancellableContinuationImpl cancellableContinuationImpl = new CancellableContinuationImpl(intercepted, 1);
+        cancellableContinuationImpl.initCancellability();
+        try {
+            roomDatabase.getTransactionExecutor().execute(new Runnable() { // from class: androidx.room.RoomDatabaseKt$startTransactionCoroutine$2$1
+
+                @DebugMetadata(c = "androidx.room.RoomDatabaseKt$startTransactionCoroutine$2$1$1", f = "RoomDatabaseExt.kt", l = {103}, m = "invokeSuspend")
+                /* renamed from: androidx.room.RoomDatabaseKt$startTransactionCoroutine$2$1$1, reason: invalid class name */
+                public static final class AnonymousClass1 extends SuspendLambda implements Function2 {
+                    final /* synthetic */ CancellableContinuation $continuation;
+                    final /* synthetic */ RoomDatabase $this_startTransactionCoroutine;
+                    final /* synthetic */ Function2 $transactionBlock;
+                    private /* synthetic */ Object L$0;
+                    int label;
+
+                    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+                    public AnonymousClass1(RoomDatabase roomDatabase, CancellableContinuation cancellableContinuation, Function2 function2, Continuation continuation) {
+                        super(2, continuation);
+                        this.$this_startTransactionCoroutine = roomDatabase;
+                        this.$continuation = cancellableContinuation;
+                        this.$transactionBlock = function2;
+                    }
+
+                    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+                    public final Continuation create(Object obj, Continuation continuation) {
+                        AnonymousClass1 anonymousClass1 = new AnonymousClass1(this.$this_startTransactionCoroutine, this.$continuation, this.$transactionBlock, continuation);
+                        anonymousClass1.L$0 = obj;
+                        return anonymousClass1;
+                    }
+
+                    @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;
+                        CoroutineContext createTransactionContext;
+                        Continuation continuation;
+                        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+                        int i = this.label;
+                        if (i == 0) {
+                            ResultKt.throwOnFailure(obj);
+                            CoroutineContext.Element element = ((CoroutineScope) this.L$0).getCoroutineContext().get(ContinuationInterceptor.Key);
+                            Intrinsics.checkNotNull(element);
+                            createTransactionContext = RoomDatabaseKt.createTransactionContext(this.$this_startTransactionCoroutine, (ContinuationInterceptor) element);
+                            CancellableContinuation cancellableContinuation = this.$continuation;
+                            Result.Companion companion = Result.Companion;
+                            Function2 function2 = this.$transactionBlock;
+                            this.L$0 = cancellableContinuation;
+                            this.label = 1;
+                            obj = BuildersKt.withContext(createTransactionContext, function2, this);
+                            if (obj == coroutine_suspended) {
+                                return coroutine_suspended;
+                            }
+                            continuation = cancellableContinuation;
+                        } else {
+                            if (i != 1) {
+                                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+                            }
+                            continuation = (Continuation) this.L$0;
+                            ResultKt.throwOnFailure(obj);
+                        }
+                        continuation.resumeWith(Result.m4060constructorimpl(obj));
+                        return Unit.INSTANCE;
+                    }
+                }
+
+                @Override // java.lang.Runnable
+                public final void run() {
+                    try {
+                        BuildersKt.runBlocking(CoroutineContext.this.minusKey(ContinuationInterceptor.Key), new AnonymousClass1(roomDatabase, cancellableContinuationImpl, function2, null));
+                    } catch (Throwable th) {
+                        cancellableContinuationImpl.cancel(th);
+                    }
+                }
+            });
+        } catch (RejectedExecutionException e) {
+            cancellableContinuationImpl.cancel(new IllegalStateException("Unable to acquire a thread to perform the database transaction.", e));
+        }
+        Object result = cancellableContinuationImpl.getResult();
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        if (result == coroutine_suspended) {
+            DebugProbesKt.probeCoroutineSuspended(continuation);
+        }
+        return result;
+    }
+}