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/util/CursorUtil.java

@@ -0,0 +1,153 @@
+package androidx.room.util;
+
+import android.database.Cursor;
+import android.database.CursorWrapper;
+import android.database.MatrixCursor;
+import androidx.annotation.RestrictTo;
+import androidx.annotation.VisibleForTesting;
+import kotlin.collections.ArraysKt___ArraysKt;
+import kotlin.io.CloseableKt;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.InlineMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+import kotlin.text.StringsKt__StringsJVMKt;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+@SourceDebugExtension({"SMAP\nCursorUtil.kt\nKotlin\n*S Kotlin\n*F\n+ 1 CursorUtil.kt\nandroidx/room/util/CursorUtil\n+ 2 _Arrays.kt\nkotlin/collections/ArraysKt___ArraysKt\n+ 3 fake.kt\nkotlin/jvm/internal/FakeKt\n*L\n1#1,184:1\n145#1,7:185\n13644#2,3:192\n1#3:195\n*S KotlinDebug\n*F\n+ 1 CursorUtil.kt\nandroidx/room/util/CursorUtil\n*L\n39#1:185,7\n127#1:192,3\n*E\n"})
+/* loaded from: classes.dex */
+public final class CursorUtil {
+    private static final int findColumnIndexBySuffix(Cursor cursor, String str) {
+        return -1;
+    }
+
+    public static final Cursor copyAndClose(Cursor c) {
+        Intrinsics.checkNotNullParameter(c, "c");
+        try {
+            MatrixCursor matrixCursor = new MatrixCursor(c.getColumnNames(), c.getCount());
+            while (c.moveToNext()) {
+                Object[] objArr = new Object[c.getColumnCount()];
+                int columnCount = c.getColumnCount();
+                for (int i = 0; i < columnCount; i++) {
+                    int type = c.getType(i);
+                    if (type == 0) {
+                        objArr[i] = null;
+                    } else if (type == 1) {
+                        objArr[i] = Long.valueOf(c.getLong(i));
+                    } else if (type == 2) {
+                        objArr[i] = Double.valueOf(c.getDouble(i));
+                    } else if (type == 3) {
+                        objArr[i] = c.getString(i);
+                    } else if (type == 4) {
+                        objArr[i] = c.getBlob(i);
+                    } else {
+                        throw new IllegalStateException();
+                    }
+                }
+                matrixCursor.addRow(objArr);
+            }
+            CloseableKt.closeFinally(c, null);
+            return matrixCursor;
+        } finally {
+        }
+    }
+
+    public static final int getColumnIndex(Cursor c, String name) {
+        Intrinsics.checkNotNullParameter(c, "c");
+        Intrinsics.checkNotNullParameter(name, "name");
+        int columnIndex = c.getColumnIndex(name);
+        if (columnIndex >= 0) {
+            return columnIndex;
+        }
+        int columnIndex2 = c.getColumnIndex('`' + name + '`');
+        return columnIndex2 >= 0 ? columnIndex2 : findColumnIndexBySuffix(c, name);
+    }
+
+    public static final int getColumnIndexOrThrow(Cursor c, String name) {
+        String str;
+        Intrinsics.checkNotNullParameter(c, "c");
+        Intrinsics.checkNotNullParameter(name, "name");
+        int columnIndex = getColumnIndex(c, name);
+        if (columnIndex >= 0) {
+            return columnIndex;
+        }
+        try {
+            String[] columnNames = c.getColumnNames();
+            Intrinsics.checkNotNullExpressionValue(columnNames, "c.columnNames");
+            str = ArraysKt___ArraysKt.joinToString$default(columnNames, (CharSequence) null, (CharSequence) null, (CharSequence) null, 0, (CharSequence) null, (Function1) null, 63, (Object) null);
+        } catch (Exception unused) {
+            str = "unknown";
+        }
+        throw new IllegalArgumentException("column '" + name + "' does not exist. Available columns: " + str);
+    }
+
+    @VisibleForTesting
+    public static final int findColumnIndexBySuffix(String[] columnNames, String name) {
+        Intrinsics.checkNotNullParameter(columnNames, "columnNames");
+        Intrinsics.checkNotNullParameter(name, "name");
+        String str = '.' + name;
+        String str2 = '.' + name + '`';
+        int length = columnNames.length;
+        int i = 0;
+        int i2 = 0;
+        while (i < length) {
+            String str3 = columnNames[i];
+            int i3 = i2 + 1;
+            if (str3.length() >= name.length() + 2) {
+                if (StringsKt__StringsJVMKt.endsWith$default(str3, str, false, 2, null)) {
+                    return i2;
+                }
+                if (str3.charAt(0) == '`' && StringsKt__StringsJVMKt.endsWith$default(str3, str2, false, 2, null)) {
+                    return i2;
+                }
+            }
+            i++;
+            i2 = i3;
+        }
+        return -1;
+    }
+
+    public static final <R> R useCursor(Cursor cursor, Function1 block) {
+        Intrinsics.checkNotNullParameter(cursor, "<this>");
+        Intrinsics.checkNotNullParameter(block, "block");
+        try {
+            R r = (R) block.invoke(cursor);
+            InlineMarker.finallyStart(1);
+            CloseableKt.closeFinally(cursor, null);
+            InlineMarker.finallyEnd(1);
+            return r;
+        } finally {
+        }
+    }
+
+    public static final Cursor wrapMappedColumns(final Cursor cursor, final String[] columnNames, final int[] mapping) {
+        Intrinsics.checkNotNullParameter(cursor, "cursor");
+        Intrinsics.checkNotNullParameter(columnNames, "columnNames");
+        Intrinsics.checkNotNullParameter(mapping, "mapping");
+        if (columnNames.length != mapping.length) {
+            throw new IllegalStateException("Expected columnNames.length == mapping.length".toString());
+        }
+        return new CursorWrapper(cursor) { // from class: androidx.room.util.CursorUtil$wrapMappedColumns$2
+            @Override // android.database.CursorWrapper, android.database.Cursor
+            public int getColumnIndex(String columnName) {
+                boolean equals;
+                Intrinsics.checkNotNullParameter(columnName, "columnName");
+                String[] strArr = columnNames;
+                int[] iArr = mapping;
+                int length = strArr.length;
+                int i = 0;
+                int i2 = 0;
+                while (i < length) {
+                    int i3 = i2 + 1;
+                    equals = StringsKt__StringsJVMKt.equals(strArr[i], columnName, true);
+                    if (equals) {
+                        return iArr[i2];
+                    }
+                    i++;
+                    i2 = i3;
+                }
+                return super.getColumnIndex(columnName);
+            }
+        };
+    }
+}

decompiled/sources/androidx/room/util/DBUtil.java

@@ -0,0 +1,158 @@
+package androidx.room.util;
+
+import android.database.AbstractWindowedCursor;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteConstraintException;
+import android.os.CancellationSignal;
+import androidx.annotation.RestrictTo;
+import androidx.room.RoomDatabase;
+import androidx.sqlite.db.SupportSQLiteCompat;
+import androidx.sqlite.db.SupportSQLiteDatabase;
+import androidx.sqlite.db.SupportSQLiteQuery;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import kotlin.Unit;
+import kotlin.collections.CollectionsKt__CollectionsJVMKt;
+import kotlin.io.CloseableKt;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+import kotlin.text.StringsKt__StringsJVMKt;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+@SourceDebugExtension({"SMAP\nDBUtil.kt\nKotlin\n*S Kotlin\n*F\n+ 1 DBUtil.kt\nandroidx/room/util/DBUtil\n+ 2 CursorUtil.kt\nandroidx/room/util/CursorUtil\n+ 3 _Collections.kt\nkotlin/collections/CollectionsKt___CollectionsKt\n*L\n1#1,214:1\n145#2,7:215\n145#2,7:224\n1855#3,2:222\n*S KotlinDebug\n*F\n+ 1 DBUtil.kt\nandroidx/room/util/DBUtil\n*L\n100#1:215,7\n121#1:224,7\n107#1:222,2\n*E\n"})
+/* loaded from: classes.dex */
+public final class DBUtil {
+    public static final Cursor query(RoomDatabase db, SupportSQLiteQuery sqLiteQuery, boolean z) {
+        Intrinsics.checkNotNullParameter(db, "db");
+        Intrinsics.checkNotNullParameter(sqLiteQuery, "sqLiteQuery");
+        return query(db, sqLiteQuery, z, null);
+    }
+
+    public static final Cursor query(RoomDatabase db, SupportSQLiteQuery sqLiteQuery, boolean z, CancellationSignal cancellationSignal) {
+        Intrinsics.checkNotNullParameter(db, "db");
+        Intrinsics.checkNotNullParameter(sqLiteQuery, "sqLiteQuery");
+        Cursor query = db.query(sqLiteQuery, cancellationSignal);
+        if (!z || !(query instanceof AbstractWindowedCursor)) {
+            return query;
+        }
+        AbstractWindowedCursor abstractWindowedCursor = (AbstractWindowedCursor) query;
+        int count = abstractWindowedCursor.getCount();
+        return (abstractWindowedCursor.hasWindow() ? abstractWindowedCursor.getWindow().getNumRows() : count) < count ? CursorUtil.copyAndClose(query) : query;
+    }
+
+    public static final void dropFtsSyncTriggers(SupportSQLiteDatabase db) {
+        List createListBuilder;
+        List<String> build;
+        Intrinsics.checkNotNullParameter(db, "db");
+        createListBuilder = CollectionsKt__CollectionsJVMKt.createListBuilder();
+        Cursor query = db.query("SELECT name FROM sqlite_master WHERE type = 'trigger'");
+        while (query.moveToNext()) {
+            try {
+                createListBuilder.add(query.getString(0));
+            } finally {
+            }
+        }
+        Unit unit = Unit.INSTANCE;
+        CloseableKt.closeFinally(query, null);
+        build = CollectionsKt__CollectionsJVMKt.build(createListBuilder);
+        for (String triggerName : build) {
+            Intrinsics.checkNotNullExpressionValue(triggerName, "triggerName");
+            if (StringsKt__StringsJVMKt.startsWith$default(triggerName, "room_fts_content_sync_", false, 2, null)) {
+                db.execSQL("DROP TRIGGER IF EXISTS " + triggerName);
+            }
+        }
+    }
+
+    public static final void foreignKeyCheck(SupportSQLiteDatabase db, String tableName) {
+        Intrinsics.checkNotNullParameter(db, "db");
+        Intrinsics.checkNotNullParameter(tableName, "tableName");
+        Cursor query = db.query("PRAGMA foreign_key_check(`" + tableName + "`)");
+        try {
+            if (query.getCount() > 0) {
+                throw new SQLiteConstraintException(processForeignKeyCheckFailure(query));
+            }
+            Unit unit = Unit.INSTANCE;
+            CloseableKt.closeFinally(query, null);
+        } catch (Throwable th) {
+            try {
+                throw th;
+            } catch (Throwable th2) {
+                CloseableKt.closeFinally(query, th);
+                throw th2;
+            }
+        }
+    }
+
+    public static final int readVersion(File databaseFile) throws IOException {
+        Intrinsics.checkNotNullParameter(databaseFile, "databaseFile");
+        FileChannel channel = new FileInputStream(databaseFile).getChannel();
+        try {
+            ByteBuffer allocate = ByteBuffer.allocate(4);
+            channel.tryLock(60L, 4L, true);
+            channel.position(60L);
+            if (channel.read(allocate) != 4) {
+                throw new IOException("Bad database header, unable to read 4 bytes at offset 60");
+            }
+            allocate.rewind();
+            int i = allocate.getInt();
+            CloseableKt.closeFinally(channel, null);
+            return i;
+        } catch (Throwable th) {
+            try {
+                throw th;
+            } catch (Throwable th2) {
+                CloseableKt.closeFinally(channel, th);
+                throw th2;
+            }
+        }
+    }
+
+    public static final CancellationSignal createCancellationSignal() {
+        return SupportSQLiteCompat.Api16Impl.createCancellationSignal();
+    }
+
+    private static final String processForeignKeyCheckFailure(Cursor cursor) {
+        StringBuilder sb = new StringBuilder();
+        int count = cursor.getCount();
+        LinkedHashMap linkedHashMap = new LinkedHashMap();
+        while (cursor.moveToNext()) {
+            if (cursor.isFirst()) {
+                sb.append("Foreign key violation(s) detected in '");
+                sb.append(cursor.getString(0));
+                sb.append("'.\n");
+            }
+            String constraintIndex = cursor.getString(3);
+            if (!linkedHashMap.containsKey(constraintIndex)) {
+                Intrinsics.checkNotNullExpressionValue(constraintIndex, "constraintIndex");
+                String string = cursor.getString(2);
+                Intrinsics.checkNotNullExpressionValue(string, "cursor.getString(2)");
+                linkedHashMap.put(constraintIndex, string);
+            }
+        }
+        sb.append("Number of different violations discovered: ");
+        sb.append(linkedHashMap.keySet().size());
+        sb.append("\n");
+        sb.append("Number of rows in violation: ");
+        sb.append(count);
+        sb.append("\n");
+        sb.append("Violation(s) detected in the following constraint(s):\n");
+        for (Map.Entry entry : linkedHashMap.entrySet()) {
+            String str = (String) entry.getKey();
+            String str2 = (String) entry.getValue();
+            sb.append("\tParent Table = ");
+            sb.append(str2);
+            sb.append(", Foreign Key Constraint Index = ");
+            sb.append(str);
+            sb.append("\n");
+        }
+        String sb2 = sb.toString();
+        Intrinsics.checkNotNullExpressionValue(sb2, "StringBuilder().apply(builderAction).toString()");
+        return sb2;
+    }
+}

decompiled/sources/androidx/room/util/FileUtil.java

@@ -0,0 +1,27 @@
+package androidx.room.util;
+
+import android.annotation.SuppressLint;
+import androidx.annotation.RestrictTo;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.ReadableByteChannel;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+@SourceDebugExtension({"SMAP\nFileUtil.kt\nKotlin\n*S Kotlin\n*F\n+ 1 FileUtil.kt\nandroidx/room/util/FileUtil\n+ 2 fake.kt\nkotlin/jvm/internal/FakeKt\n*L\n1#1,59:1\n1#2:60\n*E\n"})
+/* loaded from: classes.dex */
+public final class FileUtil {
+    @SuppressLint({"LambdaLast"})
+    public static final void copy(ReadableByteChannel input, FileChannel output) throws IOException {
+        Intrinsics.checkNotNullParameter(input, "input");
+        Intrinsics.checkNotNullParameter(output, "output");
+        try {
+            output.transferFrom(input, 0L, Long.MAX_VALUE);
+            output.force(false);
+        } finally {
+            input.close();
+            output.close();
+        }
+    }
+}

decompiled/sources/androidx/room/util/FtsTableInfo.java

@@ -0,0 +1,214 @@
+package androidx.room.util;
+
+import android.database.Cursor;
+import androidx.annotation.RestrictTo;
+import androidx.annotation.VisibleForTesting;
+import androidx.sqlite.db.SupportSQLiteDatabase;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Set;
+import kotlin.Unit;
+import kotlin.collections.CollectionsKt___CollectionsKt;
+import kotlin.collections.SetsKt__SetsJVMKt;
+import kotlin.collections.SetsKt__SetsKt;
+import kotlin.io.CloseableKt;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+import kotlin.text.StringsKt__StringsJVMKt;
+import kotlin.text.StringsKt__StringsKt;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+/* loaded from: classes.dex */
+public final class FtsTableInfo {
+    public static final Companion Companion = new Companion(null);
+    private static final String[] FTS_OPTIONS = {"tokenize=", "compress=", "content=", "languageid=", "matchinfo=", "notindexed=", "order=", "prefix=", "uncompress="};
+    public final Set<String> columns;
+    public final String name;
+    public final Set<String> options;
+
+    @VisibleForTesting
+    public static final Set<String> parseOptions(String str) {
+        return Companion.parseOptions(str);
+    }
+
+    public static final FtsTableInfo read(SupportSQLiteDatabase supportSQLiteDatabase, String str) {
+        return Companion.read(supportSQLiteDatabase, str);
+    }
+
+    public FtsTableInfo(String name, Set<String> columns, Set<String> options) {
+        Intrinsics.checkNotNullParameter(name, "name");
+        Intrinsics.checkNotNullParameter(columns, "columns");
+        Intrinsics.checkNotNullParameter(options, "options");
+        this.name = name;
+        this.columns = columns;
+        this.options = options;
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public FtsTableInfo(String name, Set<String> columns, String createSql) {
+        this(name, columns, Companion.parseOptions(createSql));
+        Intrinsics.checkNotNullParameter(name, "name");
+        Intrinsics.checkNotNullParameter(columns, "columns");
+        Intrinsics.checkNotNullParameter(createSql, "createSql");
+    }
+
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof FtsTableInfo)) {
+            return false;
+        }
+        FtsTableInfo ftsTableInfo = (FtsTableInfo) obj;
+        if (Intrinsics.areEqual(this.name, ftsTableInfo.name) && Intrinsics.areEqual(this.columns, ftsTableInfo.columns)) {
+            return Intrinsics.areEqual(this.options, ftsTableInfo.options);
+        }
+        return false;
+    }
+
+    public int hashCode() {
+        return (((this.name.hashCode() * 31) + this.columns.hashCode()) * 31) + this.options.hashCode();
+    }
+
+    public String toString() {
+        return "FtsTableInfo{name='" + this.name + "', columns=" + this.columns + ", options=" + this.options + "'}";
+    }
+
+    @SourceDebugExtension({"SMAP\nFtsTableInfo.kt\nKotlin\n*S Kotlin\n*F\n+ 1 FtsTableInfo.kt\nandroidx/room/util/FtsTableInfo$Companion\n+ 2 CursorUtil.kt\nandroidx/room/util/CursorUtil\n+ 3 _Strings.kt\nkotlin/text/StringsKt___StringsKt\n+ 4 Strings.kt\nkotlin/text/StringsKt__StringsKt\n+ 5 _Collections.kt\nkotlin/collections/CollectionsKt___CollectionsKt\n+ 6 _Arrays.kt\nkotlin/collections/ArraysKt___ArraysKt\n*L\n1#1,182:1\n145#2,7:183\n145#2,7:190\n1183#3,2:197\n1185#3:222\n107#4:199\n79#4,22:200\n766#5:223\n857#5:224\n858#5:227\n12744#6,2:225\n*S KotlinDebug\n*F\n+ 1 FtsTableInfo.kt\nandroidx/room/util/FtsTableInfo$Companion\n*L\n94#1:183,7\n108#1:190,7\n148#1:197,2\n148#1:222\n163#1:199\n163#1:200,22\n173#1:223\n173#1:224\n173#1:227\n174#1:225,2\n*E\n"})
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+
+        public final FtsTableInfo read(SupportSQLiteDatabase database, String tableName) {
+            Intrinsics.checkNotNullParameter(database, "database");
+            Intrinsics.checkNotNullParameter(tableName, "tableName");
+            return new FtsTableInfo(tableName, readColumns(database, tableName), readOptions(database, tableName));
+        }
+
+        private final Set<String> readColumns(SupportSQLiteDatabase supportSQLiteDatabase, String str) {
+            Set createSetBuilder;
+            Set<String> build;
+            createSetBuilder = SetsKt__SetsJVMKt.createSetBuilder();
+            Cursor query = supportSQLiteDatabase.query("PRAGMA table_info(`" + str + "`)");
+            try {
+                if (query.getColumnCount() > 0) {
+                    int columnIndex = query.getColumnIndex("name");
+                    while (query.moveToNext()) {
+                        String string = query.getString(columnIndex);
+                        Intrinsics.checkNotNullExpressionValue(string, "cursor.getString(nameIndex)");
+                        createSetBuilder.add(string);
+                    }
+                }
+                Unit unit = Unit.INSTANCE;
+                CloseableKt.closeFinally(query, null);
+                build = SetsKt__SetsJVMKt.build(createSetBuilder);
+                return build;
+            } finally {
+            }
+        }
+
+        private final Set<String> readOptions(SupportSQLiteDatabase supportSQLiteDatabase, String str) {
+            Cursor query = supportSQLiteDatabase.query("SELECT * FROM sqlite_master WHERE `name` = '" + str + '\'');
+            try {
+                String sql = query.moveToFirst() ? query.getString(query.getColumnIndexOrThrow("sql")) : "";
+                CloseableKt.closeFinally(query, null);
+                Intrinsics.checkNotNullExpressionValue(sql, "sql");
+                return parseOptions(sql);
+            } finally {
+            }
+        }
+
+        @VisibleForTesting
+        public final Set<String> parseOptions(String createStatement) {
+            CharSequence trim;
+            Set<String> set;
+            Character ch;
+            Set<String> emptySet;
+            Intrinsics.checkNotNullParameter(createStatement, "createStatement");
+            if (createStatement.length() == 0) {
+                emptySet = SetsKt__SetsKt.emptySet();
+                return emptySet;
+            }
+            String substring = createStatement.substring(StringsKt__StringsKt.indexOf$default((CharSequence) createStatement, '(', 0, false, 6, (Object) null) + 1, StringsKt__StringsKt.lastIndexOf$default((CharSequence) createStatement, ')', 0, false, 6, (Object) null));
+            Intrinsics.checkNotNullExpressionValue(substring, "this as java.lang.String…ing(startIndex, endIndex)");
+            ArrayList arrayList = new ArrayList();
+            ArrayDeque arrayDeque = new ArrayDeque();
+            int i = -1;
+            int i2 = 0;
+            int i3 = 0;
+            while (i2 < substring.length()) {
+                char charAt = substring.charAt(i2);
+                int i4 = i3 + 1;
+                if (charAt == '\'' || charAt == '\"' || charAt == '`') {
+                    if (arrayDeque.isEmpty()) {
+                        arrayDeque.push(Character.valueOf(charAt));
+                    } else {
+                        Character ch2 = (Character) arrayDeque.peek();
+                        if (ch2 != null && ch2.charValue() == charAt) {
+                            arrayDeque.pop();
+                        }
+                    }
+                } else if (charAt == '[') {
+                    if (arrayDeque.isEmpty()) {
+                        arrayDeque.push(Character.valueOf(charAt));
+                    }
+                } else if (charAt == ']') {
+                    if (!arrayDeque.isEmpty() && (ch = (Character) arrayDeque.peek()) != null && ch.charValue() == '[') {
+                        arrayDeque.pop();
+                    }
+                } else if (charAt == ',' && arrayDeque.isEmpty()) {
+                    String substring2 = substring.substring(i + 1, i3);
+                    Intrinsics.checkNotNullExpressionValue(substring2, "this as java.lang.String…ing(startIndex, endIndex)");
+                    int length = substring2.length() - 1;
+                    int i5 = 0;
+                    boolean z = false;
+                    while (i5 <= length) {
+                        boolean z2 = Intrinsics.compare((int) substring2.charAt(!z ? i5 : length), 32) <= 0;
+                        if (z) {
+                            if (!z2) {
+                                break;
+                            }
+                            length--;
+                        } else if (z2) {
+                            i5++;
+                        } else {
+                            z = true;
+                        }
+                    }
+                    arrayList.add(substring2.subSequence(i5, length + 1).toString());
+                    i = i3;
+                }
+                i2++;
+                i3 = i4;
+            }
+            String substring3 = substring.substring(i + 1);
+            Intrinsics.checkNotNullExpressionValue(substring3, "this as java.lang.String).substring(startIndex)");
+            trim = StringsKt__StringsKt.trim(substring3);
+            arrayList.add(trim.toString());
+            ArrayList arrayList2 = new ArrayList();
+            for (Object obj : arrayList) {
+                String str = (String) obj;
+                String[] strArr = FtsTableInfo.FTS_OPTIONS;
+                int length2 = strArr.length;
+                int i6 = 0;
+                while (true) {
+                    if (i6 >= length2) {
+                        break;
+                    }
+                    if (StringsKt__StringsJVMKt.startsWith$default(str, strArr[i6], false, 2, null)) {
+                        arrayList2.add(obj);
+                        break;
+                    }
+                    i6++;
+                }
+            }
+            set = CollectionsKt___CollectionsKt.toSet(arrayList2);
+            return set;
+        }
+    }
+}

decompiled/sources/androidx/room/util/RelationUtil.java

@@ -0,0 +1,114 @@
+package androidx.room.util;
+
+import androidx.annotation.RestrictTo;
+import androidx.collection.ArrayMap;
+import androidx.collection.LongSparseArray;
+import java.util.HashMap;
+import java.util.Map;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.Intrinsics;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+/* loaded from: classes.dex */
+public final class RelationUtil {
+    public static final <K, V> void recursiveFetchHashMap(HashMap<K, V> map, boolean z, Function1 fetchBlock) {
+        int i;
+        Intrinsics.checkNotNullParameter(map, "map");
+        Intrinsics.checkNotNullParameter(fetchBlock, "fetchBlock");
+        HashMap hashMap = new HashMap(999);
+        loop0: while (true) {
+            i = 0;
+            for (K key : map.keySet()) {
+                if (z) {
+                    Intrinsics.checkNotNullExpressionValue(key, "key");
+                    hashMap.put(key, map.get(key));
+                } else {
+                    Intrinsics.checkNotNullExpressionValue(key, "key");
+                    hashMap.put(key, null);
+                }
+                i++;
+                if (i == 999) {
+                    fetchBlock.invoke(hashMap);
+                    if (!z) {
+                        map.putAll(hashMap);
+                    }
+                    hashMap.clear();
+                }
+            }
+            break loop0;
+        }
+        if (i > 0) {
+            fetchBlock.invoke(hashMap);
+            if (z) {
+                return;
+            }
+            map.putAll(hashMap);
+        }
+    }
+
+    public static final <V> void recursiveFetchLongSparseArray(LongSparseArray<V> map, boolean z, Function1 fetchBlock) {
+        Intrinsics.checkNotNullParameter(map, "map");
+        Intrinsics.checkNotNullParameter(fetchBlock, "fetchBlock");
+        LongSparseArray<? extends V> longSparseArray = new LongSparseArray<>(999);
+        int size = map.size();
+        int i = 0;
+        int i2 = 0;
+        while (i < size) {
+            if (z) {
+                longSparseArray.put(map.keyAt(i), map.valueAt(i));
+            } else {
+                longSparseArray.put(map.keyAt(i), null);
+            }
+            i++;
+            i2++;
+            if (i2 == 999) {
+                fetchBlock.invoke(longSparseArray);
+                if (!z) {
+                    map.putAll(longSparseArray);
+                }
+                longSparseArray.clear();
+                i2 = 0;
+            }
+        }
+        if (i2 > 0) {
+            fetchBlock.invoke(longSparseArray);
+            if (z) {
+                return;
+            }
+            map.putAll(longSparseArray);
+        }
+    }
+
+    public static final <K, V> void recursiveFetchArrayMap(ArrayMap<K, V> map, boolean z, Function1 fetchBlock) {
+        Intrinsics.checkNotNullParameter(map, "map");
+        Intrinsics.checkNotNullParameter(fetchBlock, "fetchBlock");
+        ArrayMap arrayMap = new ArrayMap(999);
+        int size = map.size();
+        int i = 0;
+        int i2 = 0;
+        while (i < size) {
+            if (z) {
+                arrayMap.put(map.keyAt(i), map.valueAt(i));
+            } else {
+                arrayMap.put(map.keyAt(i), null);
+            }
+            i++;
+            i2++;
+            if (i2 == 999) {
+                fetchBlock.invoke(arrayMap);
+                if (!z) {
+                    map.putAll((Map) arrayMap);
+                }
+                arrayMap.clear();
+                i2 = 0;
+            }
+        }
+        if (i2 > 0) {
+            fetchBlock.invoke(arrayMap);
+            if (z) {
+                return;
+            }
+            map.putAll((Map) arrayMap);
+        }
+    }
+}

decompiled/sources/androidx/room/util/StringUtil.java

@@ -0,0 +1,94 @@
+package androidx.room.util;
+
+import androidx.annotation.RestrictTo;
+import java.util.List;
+import kotlin.collections.CollectionsKt___CollectionsKt;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+@SourceDebugExtension({"SMAP\nStringUtil.kt\nKotlin\n*S Kotlin\n*F\n+ 1 StringUtil.kt\nandroidx/room/util/StringUtil\n+ 2 _Collections.kt\nkotlin/collections/CollectionsKt___CollectionsKt\n+ 3 fake.kt\nkotlin/jvm/internal/FakeKt\n*L\n1#1,86:1\n1603#2,9:87\n1855#2:96\n1856#2:98\n1612#2:99\n1#3:97\n*S KotlinDebug\n*F\n+ 1 StringUtil.kt\nandroidx/room/util/StringUtil\n*L\n66#1:87,9\n66#1:96\n66#1:98\n66#1:99\n66#1:97\n*E\n"})
+/* loaded from: classes.dex */
+public final class StringUtil {
+    public static final String[] EMPTY_STRING_ARRAY = new String[0];
+
+    public static /* synthetic */ void getEMPTY_STRING_ARRAY$annotations() {
+    }
+
+    public static final StringBuilder newStringBuilder() {
+        return new StringBuilder();
+    }
+
+    public static final void appendPlaceholders(StringBuilder builder, int i) {
+        Intrinsics.checkNotNullParameter(builder, "builder");
+        for (int i2 = 0; i2 < i; i2++) {
+            builder.append("?");
+            if (i2 < i - 1) {
+                builder.append(",");
+            }
+        }
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:3:0x0003, code lost:
+    
+        r8 = kotlin.text.StringsKt__StringsKt.split$default((java.lang.CharSequence) r8, new char[]{','}, false, 0, 6, (java.lang.Object) null);
+     */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public static final java.util.List<java.lang.Integer> splitToIntList(java.lang.String r8) {
+        /*
+            r0 = 0
+            if (r8 == 0) goto L46
+            r1 = 1
+            char[] r3 = new char[r1]
+            r1 = 0
+            r2 = 44
+            r3[r1] = r2
+            r4 = 0
+            r5 = 0
+            r6 = 6
+            r7 = 0
+            r2 = r8
+            java.util.List r8 = kotlin.text.StringsKt.split$default(r2, r3, r4, r5, r6, r7)
+            if (r8 == 0) goto L46
+            java.lang.Iterable r8 = (java.lang.Iterable) r8
+            java.util.ArrayList r1 = new java.util.ArrayList
+            r1.<init>()
+            java.util.Iterator r8 = r8.iterator()
+        L21:
+            boolean r2 = r8.hasNext()
+            if (r2 == 0) goto L45
+            java.lang.Object r2 = r8.next()
+            java.lang.String r2 = (java.lang.String) r2
+            int r2 = java.lang.Integer.parseInt(r2)     // Catch: java.lang.NumberFormatException -> L36
+            java.lang.Integer r2 = java.lang.Integer.valueOf(r2)     // Catch: java.lang.NumberFormatException -> L36
+            goto L3f
+        L36:
+            r2 = move-exception
+            java.lang.String r3 = "ROOM"
+            java.lang.String r4 = "Malformed integer list"
+            android.util.Log.e(r3, r4, r2)
+            r2 = r0
+        L3f:
+            if (r2 == 0) goto L21
+            r1.add(r2)
+            goto L21
+        L45:
+            r0 = r1
+        L46:
+            return r0
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.room.util.StringUtil.splitToIntList(java.lang.String):java.util.List");
+    }
+
+    public static final String joinIntoString(List<Integer> list) {
+        String joinToString$default;
+        if (list == null) {
+            return null;
+        }
+        joinToString$default = CollectionsKt___CollectionsKt.joinToString$default(list, ",", null, null, 0, null, null, 62, null);
+        return joinToString$default;
+    }
+}

decompiled/sources/androidx/room/util/TableInfo.java

@@ -0,0 +1,489 @@
+package androidx.room.util;
+
+import androidx.annotation.RestrictTo;
+import androidx.annotation.VisibleForTesting;
+import androidx.room.ColumnInfo;
+import androidx.room.Index;
+import androidx.sqlite.db.SupportSQLiteDatabase;
+import com.google.android.gms.ads.AdError;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+import kotlin.text.StringsKt__StringsJVMKt;
+import kotlin.text.StringsKt__StringsKt;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+/* loaded from: classes.dex */
+public final class TableInfo {
+    public static final int CREATED_FROM_DATABASE = 2;
+    public static final int CREATED_FROM_ENTITY = 1;
+    public static final int CREATED_FROM_UNKNOWN = 0;
+    public static final Companion Companion = new Companion(null);
+    public final Map<String, Column> columns;
+    public final Set<ForeignKey> foreignKeys;
+    public final Set<Index> indices;
+    public final String name;
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface CreatedFrom {
+    }
+
+    public static final TableInfo read(SupportSQLiteDatabase supportSQLiteDatabase, String str) {
+        return Companion.read(supportSQLiteDatabase, str);
+    }
+
+    public TableInfo(String name, Map<String, Column> columns, Set<ForeignKey> foreignKeys, Set<Index> set) {
+        Intrinsics.checkNotNullParameter(name, "name");
+        Intrinsics.checkNotNullParameter(columns, "columns");
+        Intrinsics.checkNotNullParameter(foreignKeys, "foreignKeys");
+        this.name = name;
+        this.columns = columns;
+        this.foreignKeys = foreignKeys;
+        this.indices = set;
+    }
+
+    public /* synthetic */ TableInfo(String str, Map map, Set set, Set set2, int i, DefaultConstructorMarker defaultConstructorMarker) {
+        this(str, map, set, (i & 8) != 0 ? null : set2);
+    }
+
+    /* 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 TableInfo(java.lang.String r2, java.util.Map<java.lang.String, androidx.room.util.TableInfo.Column> r3, java.util.Set<androidx.room.util.TableInfo.ForeignKey> r4) {
+        /*
+            r1 = this;
+            java.lang.String r0 = "name"
+            kotlin.jvm.internal.Intrinsics.checkNotNullParameter(r2, r0)
+            java.lang.String r0 = "columns"
+            kotlin.jvm.internal.Intrinsics.checkNotNullParameter(r3, r0)
+            java.lang.String r0 = "foreignKeys"
+            kotlin.jvm.internal.Intrinsics.checkNotNullParameter(r4, r0)
+            java.util.Set r0 = kotlin.collections.SetsKt.emptySet()
+            r1.<init>(r2, r3, r4, r0)
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.room.util.TableInfo.<init>(java.lang.String, java.util.Map, java.util.Set):void");
+    }
+
+    public boolean equals(Object obj) {
+        Set<Index> set;
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof TableInfo)) {
+            return false;
+        }
+        TableInfo tableInfo = (TableInfo) obj;
+        if (!Intrinsics.areEqual(this.name, tableInfo.name) || !Intrinsics.areEqual(this.columns, tableInfo.columns) || !Intrinsics.areEqual(this.foreignKeys, tableInfo.foreignKeys)) {
+            return false;
+        }
+        Set<Index> set2 = this.indices;
+        if (set2 == null || (set = tableInfo.indices) == null) {
+            return true;
+        }
+        return Intrinsics.areEqual(set2, set);
+    }
+
+    public int hashCode() {
+        return (((this.name.hashCode() * 31) + this.columns.hashCode()) * 31) + this.foreignKeys.hashCode();
+    }
+
+    public String toString() {
+        return "TableInfo{name='" + this.name + "', columns=" + this.columns + ", foreignKeys=" + this.foreignKeys + ", indices=" + this.indices + '}';
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+
+        public final TableInfo read(SupportSQLiteDatabase database, String tableName) {
+            Intrinsics.checkNotNullParameter(database, "database");
+            Intrinsics.checkNotNullParameter(tableName, "tableName");
+            return TableInfoKt.readTableInfo(database, tableName);
+        }
+    }
+
+    public static final class Column {
+        public static final Companion Companion = new Companion(null);
+        public final int affinity;
+        public final int createdFrom;
+        public final String defaultValue;
+        public final String name;
+        public final boolean notNull;
+        public final int primaryKeyPosition;
+        public final String type;
+
+        @VisibleForTesting
+        public static final boolean defaultValueEquals(String str, String str2) {
+            return Companion.defaultValueEquals(str, str2);
+        }
+
+        @ColumnInfo.SQLiteTypeAffinity
+        public static /* synthetic */ void getAffinity$annotations() {
+        }
+
+        public final boolean isPrimaryKey() {
+            return this.primaryKeyPosition > 0;
+        }
+
+        public Column(String name, String type, boolean z, int i, String str, int i2) {
+            Intrinsics.checkNotNullParameter(name, "name");
+            Intrinsics.checkNotNullParameter(type, "type");
+            this.name = name;
+            this.type = type;
+            this.notNull = z;
+            this.primaryKeyPosition = i;
+            this.defaultValue = str;
+            this.createdFrom = i2;
+            this.affinity = findAffinity(type);
+        }
+
+        /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+        public Column(String name, String type, boolean z, int i) {
+            this(name, type, z, i, null, 0);
+            Intrinsics.checkNotNullParameter(name, "name");
+            Intrinsics.checkNotNullParameter(type, "type");
+        }
+
+        @ColumnInfo.SQLiteTypeAffinity
+        private final int findAffinity(String str) {
+            boolean contains$default;
+            boolean contains$default2;
+            boolean contains$default3;
+            boolean contains$default4;
+            boolean contains$default5;
+            boolean contains$default6;
+            boolean contains$default7;
+            boolean contains$default8;
+            if (str == null) {
+                return 5;
+            }
+            Locale US = Locale.US;
+            Intrinsics.checkNotNullExpressionValue(US, "US");
+            String upperCase = str.toUpperCase(US);
+            Intrinsics.checkNotNullExpressionValue(upperCase, "this as java.lang.String).toUpperCase(locale)");
+            contains$default = StringsKt__StringsKt.contains$default(upperCase, "INT", false, 2, null);
+            if (contains$default) {
+                return 3;
+            }
+            contains$default2 = StringsKt__StringsKt.contains$default(upperCase, "CHAR", false, 2, null);
+            if (!contains$default2) {
+                contains$default3 = StringsKt__StringsKt.contains$default(upperCase, "CLOB", false, 2, null);
+                if (!contains$default3) {
+                    contains$default4 = StringsKt__StringsKt.contains$default(upperCase, "TEXT", false, 2, null);
+                    if (!contains$default4) {
+                        contains$default5 = StringsKt__StringsKt.contains$default(upperCase, "BLOB", false, 2, null);
+                        if (contains$default5) {
+                            return 5;
+                        }
+                        contains$default6 = StringsKt__StringsKt.contains$default(upperCase, "REAL", false, 2, null);
+                        if (contains$default6) {
+                            return 4;
+                        }
+                        contains$default7 = StringsKt__StringsKt.contains$default(upperCase, "FLOA", false, 2, null);
+                        if (contains$default7) {
+                            return 4;
+                        }
+                        contains$default8 = StringsKt__StringsKt.contains$default(upperCase, "DOUB", false, 2, null);
+                        return contains$default8 ? 4 : 1;
+                    }
+                }
+            }
+            return 2;
+        }
+
+        @SourceDebugExtension({"SMAP\nTableInfo.kt\nKotlin\n*S Kotlin\n*F\n+ 1 TableInfo.kt\nandroidx/room/util/TableInfo$Column$Companion\n+ 2 _Strings.kt\nkotlin/text/StringsKt___StringsKt\n*L\n1#1,646:1\n1183#2,3:647\n*S KotlinDebug\n*F\n+ 1 TableInfo.kt\nandroidx/room/util/TableInfo$Column$Companion\n*L\n249#1:647,3\n*E\n"})
+        public static final class Companion {
+            public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+                this();
+            }
+
+            private Companion() {
+            }
+
+            @VisibleForTesting
+            public final boolean defaultValueEquals(String current, String str) {
+                CharSequence trim;
+                Intrinsics.checkNotNullParameter(current, "current");
+                if (Intrinsics.areEqual(current, str)) {
+                    return true;
+                }
+                if (!containsSurroundingParenthesis(current)) {
+                    return false;
+                }
+                String substring = current.substring(1, current.length() - 1);
+                Intrinsics.checkNotNullExpressionValue(substring, "this as java.lang.String…ing(startIndex, endIndex)");
+                trim = StringsKt__StringsKt.trim(substring);
+                return Intrinsics.areEqual(trim.toString(), str);
+            }
+
+            private final boolean containsSurroundingParenthesis(String str) {
+                if (str.length() == 0) {
+                    return false;
+                }
+                int i = 0;
+                int i2 = 0;
+                int i3 = 0;
+                while (i < str.length()) {
+                    char charAt = str.charAt(i);
+                    int i4 = i3 + 1;
+                    if (i3 == 0 && charAt != '(') {
+                        return false;
+                    }
+                    if (charAt == '(') {
+                        i2++;
+                    } else if (charAt == ')' && i2 - 1 == 0 && i3 != str.length() - 1) {
+                        return false;
+                    }
+                    i++;
+                    i3 = i4;
+                }
+                return i2 == 0;
+            }
+        }
+
+        public boolean equals(Object obj) {
+            String str;
+            String str2;
+            String str3;
+            if (this == obj) {
+                return true;
+            }
+            if (!(obj instanceof Column) || this.primaryKeyPosition != ((Column) obj).primaryKeyPosition) {
+                return false;
+            }
+            Column column = (Column) obj;
+            if (!Intrinsics.areEqual(this.name, column.name) || this.notNull != column.notNull) {
+                return false;
+            }
+            if (this.createdFrom == 1 && column.createdFrom == 2 && (str3 = this.defaultValue) != null && !Companion.defaultValueEquals(str3, column.defaultValue)) {
+                return false;
+            }
+            if (this.createdFrom == 2 && column.createdFrom == 1 && (str2 = column.defaultValue) != null && !Companion.defaultValueEquals(str2, this.defaultValue)) {
+                return false;
+            }
+            int i = this.createdFrom;
+            return (i == 0 || i != column.createdFrom || ((str = this.defaultValue) == null ? column.defaultValue == null : Companion.defaultValueEquals(str, column.defaultValue))) && this.affinity == column.affinity;
+        }
+
+        public int hashCode() {
+            return (((((this.name.hashCode() * 31) + this.affinity) * 31) + (this.notNull ? 1231 : 1237)) * 31) + this.primaryKeyPosition;
+        }
+
+        public String toString() {
+            StringBuilder sb = new StringBuilder();
+            sb.append("Column{name='");
+            sb.append(this.name);
+            sb.append("', type='");
+            sb.append(this.type);
+            sb.append("', affinity='");
+            sb.append(this.affinity);
+            sb.append("', notNull=");
+            sb.append(this.notNull);
+            sb.append(", primaryKeyPosition=");
+            sb.append(this.primaryKeyPosition);
+            sb.append(", defaultValue='");
+            String str = this.defaultValue;
+            if (str == null) {
+                str = AdError.UNDEFINED_DOMAIN;
+            }
+            sb.append(str);
+            sb.append("'}");
+            return sb.toString();
+        }
+    }
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public static final class ForeignKey {
+        public final List<String> columnNames;
+        public final String onDelete;
+        public final String onUpdate;
+        public final List<String> referenceColumnNames;
+        public final String referenceTable;
+
+        public ForeignKey(String referenceTable, String onDelete, String onUpdate, List<String> columnNames, List<String> referenceColumnNames) {
+            Intrinsics.checkNotNullParameter(referenceTable, "referenceTable");
+            Intrinsics.checkNotNullParameter(onDelete, "onDelete");
+            Intrinsics.checkNotNullParameter(onUpdate, "onUpdate");
+            Intrinsics.checkNotNullParameter(columnNames, "columnNames");
+            Intrinsics.checkNotNullParameter(referenceColumnNames, "referenceColumnNames");
+            this.referenceTable = referenceTable;
+            this.onDelete = onDelete;
+            this.onUpdate = onUpdate;
+            this.columnNames = columnNames;
+            this.referenceColumnNames = referenceColumnNames;
+        }
+
+        public boolean equals(Object obj) {
+            if (this == obj) {
+                return true;
+            }
+            if (!(obj instanceof ForeignKey)) {
+                return false;
+            }
+            ForeignKey foreignKey = (ForeignKey) obj;
+            if (Intrinsics.areEqual(this.referenceTable, foreignKey.referenceTable) && Intrinsics.areEqual(this.onDelete, foreignKey.onDelete) && Intrinsics.areEqual(this.onUpdate, foreignKey.onUpdate) && Intrinsics.areEqual(this.columnNames, foreignKey.columnNames)) {
+                return Intrinsics.areEqual(this.referenceColumnNames, foreignKey.referenceColumnNames);
+            }
+            return false;
+        }
+
+        public int hashCode() {
+            return (((((((this.referenceTable.hashCode() * 31) + this.onDelete.hashCode()) * 31) + this.onUpdate.hashCode()) * 31) + this.columnNames.hashCode()) * 31) + this.referenceColumnNames.hashCode();
+        }
+
+        public String toString() {
+            return "ForeignKey{referenceTable='" + this.referenceTable + "', onDelete='" + this.onDelete + " +', onUpdate='" + this.onUpdate + "', columnNames=" + this.columnNames + ", referenceColumnNames=" + this.referenceColumnNames + '}';
+        }
+    }
+
+    public static final class ForeignKeyWithSequence implements Comparable<ForeignKeyWithSequence> {
+        private final String from;
+        private final int id;
+        private final int sequence;
+        private final String to;
+
+        public final String getFrom() {
+            return this.from;
+        }
+
+        public final int getId() {
+            return this.id;
+        }
+
+        public final int getSequence() {
+            return this.sequence;
+        }
+
+        public final String getTo() {
+            return this.to;
+        }
+
+        public ForeignKeyWithSequence(int i, int i2, String from, String to) {
+            Intrinsics.checkNotNullParameter(from, "from");
+            Intrinsics.checkNotNullParameter(to, "to");
+            this.id = i;
+            this.sequence = i2;
+            this.from = from;
+            this.to = to;
+        }
+
+        @Override // java.lang.Comparable
+        public int compareTo(ForeignKeyWithSequence other) {
+            Intrinsics.checkNotNullParameter(other, "other");
+            int i = this.id - other.id;
+            return i == 0 ? this.sequence - other.sequence : i;
+        }
+    }
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    @SourceDebugExtension({"SMAP\nTableInfo.kt\nKotlin\n*S Kotlin\n*F\n+ 1 TableInfo.kt\nandroidx/room/util/TableInfo$Index\n+ 2 fake.kt\nkotlin/jvm/internal/FakeKt\n*L\n1#1,646:1\n1#2:647\n*E\n"})
+    public static final class Index {
+        public static final Companion Companion = new Companion(null);
+        public static final String DEFAULT_PREFIX = "index_";
+        public final List<String> columns;
+        public final String name;
+        public List<String> orders;
+        public final boolean unique;
+
+        /* JADX WARN: Multi-variable type inference failed */
+        /* JADX WARN: Type inference failed for: r5v1, types: [java.util.Collection] */
+        /* JADX WARN: Type inference failed for: r5v2 */
+        /* JADX WARN: Type inference failed for: r5v4, types: [java.util.ArrayList] */
+        public Index(String name, boolean z, List<String> columns, List<String> orders) {
+            Intrinsics.checkNotNullParameter(name, "name");
+            Intrinsics.checkNotNullParameter(columns, "columns");
+            Intrinsics.checkNotNullParameter(orders, "orders");
+            this.name = name;
+            this.unique = z;
+            this.columns = columns;
+            this.orders = orders;
+            List<String> list = orders;
+            if (list.isEmpty()) {
+                int size = columns.size();
+                list = new ArrayList(size);
+                for (int i = 0; i < size; i++) {
+                    list.add(Index.Order.ASC.name());
+                }
+            }
+            this.orders = (List) list;
+        }
+
+        public static final class Companion {
+            public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+                this();
+            }
+
+            private Companion() {
+            }
+        }
+
+        /* 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 Index(java.lang.String r5, boolean r6, java.util.List<java.lang.String> r7) {
+            /*
+                r4 = this;
+                java.lang.String r0 = "name"
+                kotlin.jvm.internal.Intrinsics.checkNotNullParameter(r5, r0)
+                java.lang.String r0 = "columns"
+                kotlin.jvm.internal.Intrinsics.checkNotNullParameter(r7, r0)
+                int r0 = r7.size()
+                java.util.ArrayList r1 = new java.util.ArrayList
+                r1.<init>(r0)
+                r2 = 0
+            L14:
+                if (r2 >= r0) goto L22
+                androidx.room.Index$Order r3 = androidx.room.Index.Order.ASC
+                java.lang.String r3 = r3.name()
+                r1.add(r3)
+                int r2 = r2 + 1
+                goto L14
+            L22:
+                r4.<init>(r5, r6, r7, r1)
+                return
+            */
+            throw new UnsupportedOperationException("Method not decompiled: androidx.room.util.TableInfo.Index.<init>(java.lang.String, boolean, java.util.List):void");
+        }
+
+        public boolean equals(Object obj) {
+            if (this == obj) {
+                return true;
+            }
+            if (!(obj instanceof Index)) {
+                return false;
+            }
+            Index index = (Index) obj;
+            if (this.unique != index.unique || !Intrinsics.areEqual(this.columns, index.columns) || !Intrinsics.areEqual(this.orders, index.orders)) {
+                return false;
+            }
+            if (StringsKt__StringsJVMKt.startsWith$default(this.name, DEFAULT_PREFIX, false, 2, null)) {
+                return StringsKt__StringsJVMKt.startsWith$default(index.name, DEFAULT_PREFIX, false, 2, null);
+            }
+            return Intrinsics.areEqual(this.name, index.name);
+        }
+
+        public int hashCode() {
+            return ((((((StringsKt__StringsJVMKt.startsWith$default(this.name, DEFAULT_PREFIX, false, 2, null) ? -1184239155 : this.name.hashCode()) * 31) + (this.unique ? 1 : 0)) * 31) + this.columns.hashCode()) * 31) + this.orders.hashCode();
+        }
+
+        public String toString() {
+            return "Index{name='" + this.name + "', unique=" + this.unique + ", columns=" + this.columns + ", orders=" + this.orders + "'}";
+        }
+    }
+}

decompiled/sources/androidx/room/util/TableInfoKt.java

@@ -0,0 +1,211 @@
+package androidx.room.util;
+
+import android.database.Cursor;
+import androidx.room.util.TableInfo;
+import androidx.sqlite.db.SupportSQLiteDatabase;
+import com.ironsource.nb;
+import com.mbridge.msdk.foundation.entity.CampaignEx;
+import com.mbridge.msdk.mbbid.common.BidResponsedEx;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+import kotlin.collections.CollectionsKt__CollectionsJVMKt;
+import kotlin.collections.CollectionsKt___CollectionsKt;
+import kotlin.collections.MapsKt__MapsJVMKt;
+import kotlin.collections.MapsKt__MapsKt;
+import kotlin.collections.SetsKt__SetsJVMKt;
+import kotlin.io.CloseableKt;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+
+@SourceDebugExtension({"SMAP\nTableInfo.kt\nKotlin\n*S Kotlin\n*F\n+ 1 TableInfo.kt\nandroidx/room/util/TableInfoKt\n+ 2 CursorUtil.kt\nandroidx/room/util/CursorUtil\n+ 3 _Collections.kt\nkotlin/collections/CollectionsKt___CollectionsKt\n*L\n1#1,646:1\n145#2,2:647\n148#2,2:654\n151#2:660\n145#2,7:661\n145#2,7:668\n145#2,7:675\n766#3:649\n857#3,2:650\n1855#3,2:652\n857#3,2:656\n1855#3,2:658\n*S KotlinDebug\n*F\n+ 1 TableInfo.kt\nandroidx/room/util/TableInfoKt\n*L\n477#1:647,2\n477#1:654,2\n477#1:660\n542#1:661,7\n580#1:668,7\n613#1:675,7\n497#1:649\n497#1:650,2\n499#1:652,2\n497#1:656,2\n499#1:658,2\n*E\n"})
+/* loaded from: classes.dex */
+public final class TableInfoKt {
+    public static final TableInfo readTableInfo(SupportSQLiteDatabase database, String tableName) {
+        Intrinsics.checkNotNullParameter(database, "database");
+        Intrinsics.checkNotNullParameter(tableName, "tableName");
+        return new TableInfo(tableName, readColumns(database, tableName), readForeignKeys(database, tableName), readIndices(database, tableName));
+    }
+
+    private static final Set<TableInfo.ForeignKey> readForeignKeys(SupportSQLiteDatabase supportSQLiteDatabase, String str) {
+        Set createSetBuilder;
+        Set<TableInfo.ForeignKey> build;
+        Cursor query = supportSQLiteDatabase.query("PRAGMA foreign_key_list(`" + str + "`)");
+        try {
+            int columnIndex = query.getColumnIndex("id");
+            int columnIndex2 = query.getColumnIndex("seq");
+            int columnIndex3 = query.getColumnIndex(nb.Q);
+            int columnIndex4 = query.getColumnIndex("on_delete");
+            int columnIndex5 = query.getColumnIndex("on_update");
+            List<TableInfo.ForeignKeyWithSequence> readForeignKeyFieldMappings = readForeignKeyFieldMappings(query);
+            query.moveToPosition(-1);
+            createSetBuilder = SetsKt__SetsJVMKt.createSetBuilder();
+            while (query.moveToNext()) {
+                if (query.getInt(columnIndex2) == 0) {
+                    int i = query.getInt(columnIndex);
+                    ArrayList arrayList = new ArrayList();
+                    ArrayList arrayList2 = new ArrayList();
+                    ArrayList<TableInfo.ForeignKeyWithSequence> arrayList3 = new ArrayList();
+                    for (Object obj : readForeignKeyFieldMappings) {
+                        if (((TableInfo.ForeignKeyWithSequence) obj).getId() == i) {
+                            arrayList3.add(obj);
+                        }
+                    }
+                    for (TableInfo.ForeignKeyWithSequence foreignKeyWithSequence : arrayList3) {
+                        arrayList.add(foreignKeyWithSequence.getFrom());
+                        arrayList2.add(foreignKeyWithSequence.getTo());
+                    }
+                    String string = query.getString(columnIndex3);
+                    Intrinsics.checkNotNullExpressionValue(string, "cursor.getString(tableColumnIndex)");
+                    String string2 = query.getString(columnIndex4);
+                    Intrinsics.checkNotNullExpressionValue(string2, "cursor.getString(onDeleteColumnIndex)");
+                    String string3 = query.getString(columnIndex5);
+                    Intrinsics.checkNotNullExpressionValue(string3, "cursor.getString(onUpdateColumnIndex)");
+                    createSetBuilder.add(new TableInfo.ForeignKey(string, string2, string3, arrayList, arrayList2));
+                }
+            }
+            build = SetsKt__SetsJVMKt.build(createSetBuilder);
+            CloseableKt.closeFinally(query, null);
+            return build;
+        } finally {
+        }
+    }
+
+    private static final List<TableInfo.ForeignKeyWithSequence> readForeignKeyFieldMappings(Cursor cursor) {
+        List createListBuilder;
+        List build;
+        List<TableInfo.ForeignKeyWithSequence> sorted;
+        int columnIndex = cursor.getColumnIndex("id");
+        int columnIndex2 = cursor.getColumnIndex("seq");
+        int columnIndex3 = cursor.getColumnIndex("from");
+        int columnIndex4 = cursor.getColumnIndex("to");
+        createListBuilder = CollectionsKt__CollectionsJVMKt.createListBuilder();
+        while (cursor.moveToNext()) {
+            int i = cursor.getInt(columnIndex);
+            int i2 = cursor.getInt(columnIndex2);
+            String string = cursor.getString(columnIndex3);
+            Intrinsics.checkNotNullExpressionValue(string, "cursor.getString(fromColumnIndex)");
+            String string2 = cursor.getString(columnIndex4);
+            Intrinsics.checkNotNullExpressionValue(string2, "cursor.getString(toColumnIndex)");
+            createListBuilder.add(new TableInfo.ForeignKeyWithSequence(i, i2, string, string2));
+        }
+        build = CollectionsKt__CollectionsJVMKt.build(createListBuilder);
+        sorted = CollectionsKt___CollectionsKt.sorted(build);
+        return sorted;
+    }
+
+    private static final Map<String, TableInfo.Column> readColumns(SupportSQLiteDatabase supportSQLiteDatabase, String str) {
+        Map createMapBuilder;
+        Map<String, TableInfo.Column> build;
+        Map<String, TableInfo.Column> emptyMap;
+        Cursor query = supportSQLiteDatabase.query("PRAGMA table_info(`" + str + "`)");
+        try {
+            if (query.getColumnCount() <= 0) {
+                emptyMap = MapsKt__MapsKt.emptyMap();
+                CloseableKt.closeFinally(query, null);
+                return emptyMap;
+            }
+            int columnIndex = query.getColumnIndex("name");
+            int columnIndex2 = query.getColumnIndex("type");
+            int columnIndex3 = query.getColumnIndex("notnull");
+            int columnIndex4 = query.getColumnIndex("pk");
+            int columnIndex5 = query.getColumnIndex("dflt_value");
+            createMapBuilder = MapsKt__MapsJVMKt.createMapBuilder();
+            while (query.moveToNext()) {
+                String name = query.getString(columnIndex);
+                String type = query.getString(columnIndex2);
+                boolean z = query.getInt(columnIndex3) != 0;
+                int i = query.getInt(columnIndex4);
+                String string = query.getString(columnIndex5);
+                Intrinsics.checkNotNullExpressionValue(name, "name");
+                Intrinsics.checkNotNullExpressionValue(type, "type");
+                createMapBuilder.put(name, new TableInfo.Column(name, type, z, i, string, 2));
+            }
+            build = MapsKt__MapsJVMKt.build(createMapBuilder);
+            CloseableKt.closeFinally(query, null);
+            return build;
+        } catch (Throwable th) {
+            try {
+                throw th;
+            } catch (Throwable th2) {
+                CloseableKt.closeFinally(query, th);
+                throw th2;
+            }
+        }
+    }
+
+    private static final Set<TableInfo.Index> readIndices(SupportSQLiteDatabase supportSQLiteDatabase, String str) {
+        Set createSetBuilder;
+        Set<TableInfo.Index> build;
+        Cursor query = supportSQLiteDatabase.query("PRAGMA index_list(`" + str + "`)");
+        try {
+            int columnIndex = query.getColumnIndex("name");
+            int columnIndex2 = query.getColumnIndex("origin");
+            int columnIndex3 = query.getColumnIndex("unique");
+            if (columnIndex != -1 && columnIndex2 != -1 && columnIndex3 != -1) {
+                createSetBuilder = SetsKt__SetsJVMKt.createSetBuilder();
+                while (query.moveToNext()) {
+                    if (Intrinsics.areEqual("c", query.getString(columnIndex2))) {
+                        String name = query.getString(columnIndex);
+                        boolean z = true;
+                        if (query.getInt(columnIndex3) != 1) {
+                            z = false;
+                        }
+                        Intrinsics.checkNotNullExpressionValue(name, "name");
+                        TableInfo.Index readIndex = readIndex(supportSQLiteDatabase, name, z);
+                        if (readIndex == null) {
+                            CloseableKt.closeFinally(query, null);
+                            return null;
+                        }
+                        createSetBuilder.add(readIndex);
+                    }
+                }
+                build = SetsKt__SetsJVMKt.build(createSetBuilder);
+                CloseableKt.closeFinally(query, null);
+                return build;
+            }
+            CloseableKt.closeFinally(query, null);
+            return null;
+        } finally {
+        }
+    }
+
+    private static final TableInfo.Index readIndex(SupportSQLiteDatabase supportSQLiteDatabase, String str, boolean z) {
+        Cursor query = supportSQLiteDatabase.query("PRAGMA index_xinfo(`" + str + "`)");
+        try {
+            int columnIndex = query.getColumnIndex("seqno");
+            int columnIndex2 = query.getColumnIndex(BidResponsedEx.KEY_CID);
+            int columnIndex3 = query.getColumnIndex("name");
+            int columnIndex4 = query.getColumnIndex(CampaignEx.JSON_KEY_DESC);
+            if (columnIndex != -1 && columnIndex2 != -1 && columnIndex3 != -1 && columnIndex4 != -1) {
+                TreeMap treeMap = new TreeMap();
+                TreeMap treeMap2 = new TreeMap();
+                while (query.moveToNext()) {
+                    if (query.getInt(columnIndex2) >= 0) {
+                        int i = query.getInt(columnIndex);
+                        String columnName = query.getString(columnIndex3);
+                        String str2 = query.getInt(columnIndex4) > 0 ? "DESC" : "ASC";
+                        Integer valueOf = Integer.valueOf(i);
+                        Intrinsics.checkNotNullExpressionValue(columnName, "columnName");
+                        treeMap.put(valueOf, columnName);
+                        treeMap2.put(Integer.valueOf(i), str2);
+                    }
+                }
+                Collection values = treeMap.values();
+                Intrinsics.checkNotNullExpressionValue(values, "columnsMap.values");
+                List list = CollectionsKt___CollectionsKt.toList(values);
+                Collection values2 = treeMap2.values();
+                Intrinsics.checkNotNullExpressionValue(values2, "ordersMap.values");
+                TableInfo.Index index = new TableInfo.Index(str, z, list, CollectionsKt___CollectionsKt.toList(values2));
+                CloseableKt.closeFinally(query, null);
+                return index;
+            }
+            CloseableKt.closeFinally(query, null);
+            return null;
+        } finally {
+        }
+    }
+}

decompiled/sources/androidx/room/util/UUIDUtil.java

@@ -0,0 +1,26 @@
+package androidx.room.util;
+
+import androidx.annotation.RestrictTo;
+import java.nio.ByteBuffer;
+import java.util.UUID;
+import kotlin.jvm.internal.Intrinsics;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+/* loaded from: classes.dex */
+public final class UUIDUtil {
+    public static final UUID convertByteToUUID(byte[] bytes) {
+        Intrinsics.checkNotNullParameter(bytes, "bytes");
+        ByteBuffer wrap = ByteBuffer.wrap(bytes);
+        return new UUID(wrap.getLong(), wrap.getLong());
+    }
+
+    public static final byte[] convertUUIDToByte(UUID uuid) {
+        Intrinsics.checkNotNullParameter(uuid, "uuid");
+        ByteBuffer wrap = ByteBuffer.wrap(new byte[16]);
+        wrap.putLong(uuid.getMostSignificantBits());
+        wrap.putLong(uuid.getLeastSignificantBits());
+        byte[] array = wrap.array();
+        Intrinsics.checkNotNullExpressionValue(array, "buffer.array()");
+        return array;
+    }
+}

decompiled/sources/androidx/room/util/ViewInfo.java

@@ -0,0 +1,94 @@
+package androidx.room.util;
+
+import android.database.Cursor;
+import androidx.annotation.RestrictTo;
+import androidx.sqlite.db.SupportSQLiteDatabase;
+import kotlin.io.CloseableKt;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+/* loaded from: classes.dex */
+public final class ViewInfo {
+    public static final Companion Companion = new Companion(null);
+    public final String name;
+    public final String sql;
+
+    public static final ViewInfo read(SupportSQLiteDatabase supportSQLiteDatabase, String str) {
+        return Companion.read(supportSQLiteDatabase, str);
+    }
+
+    public ViewInfo(String name, String str) {
+        Intrinsics.checkNotNullParameter(name, "name");
+        this.name = name;
+        this.sql = str;
+    }
+
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof ViewInfo)) {
+            return false;
+        }
+        ViewInfo viewInfo = (ViewInfo) obj;
+        if (Intrinsics.areEqual(this.name, viewInfo.name)) {
+            String str = this.sql;
+            String str2 = viewInfo.sql;
+            if (str != null) {
+                if (Intrinsics.areEqual(str, str2)) {
+                    return true;
+                }
+            } else if (str2 == null) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public int hashCode() {
+        int hashCode = this.name.hashCode() * 31;
+        String str = this.sql;
+        return hashCode + (str != null ? str.hashCode() : 0);
+    }
+
+    public String toString() {
+        return "ViewInfo{name='" + this.name + "', sql='" + this.sql + "'}";
+    }
+
+    @SourceDebugExtension({"SMAP\nViewInfo.kt\nKotlin\n*S Kotlin\n*F\n+ 1 ViewInfo.kt\nandroidx/room/util/ViewInfo$Companion\n+ 2 CursorUtil.kt\nandroidx/room/util/CursorUtil\n*L\n1#1,83:1\n145#2,7:84\n*S KotlinDebug\n*F\n+ 1 ViewInfo.kt\nandroidx/room/util/ViewInfo$Companion\n*L\n73#1:84,7\n*E\n"})
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+
+        public final ViewInfo read(SupportSQLiteDatabase database, String viewName) {
+            ViewInfo viewInfo;
+            Intrinsics.checkNotNullParameter(database, "database");
+            Intrinsics.checkNotNullParameter(viewName, "viewName");
+            Cursor query = database.query("SELECT name, sql FROM sqlite_master WHERE type = 'view' AND name = '" + viewName + '\'');
+            try {
+                if (query.moveToFirst()) {
+                    String string = query.getString(0);
+                    Intrinsics.checkNotNullExpressionValue(string, "cursor.getString(0)");
+                    viewInfo = new ViewInfo(string, query.getString(1));
+                } else {
+                    viewInfo = new ViewInfo(viewName, null);
+                }
+                CloseableKt.closeFinally(query, null);
+                return viewInfo;
+            } catch (Throwable th) {
+                try {
+                    throw th;
+                } catch (Throwable th2) {
+                    CloseableKt.closeFinally(query, th);
+                    throw th2;
+                }
+            }
+        }
+    }
+}