Add Discord community version (64-bit only)

- Added realracing3-community.apk (71.57 MB)
- Removed 32-bit support (armeabi-v7a)
- Only includes arm64-v8a libraries
- Decompiled source code included
- Added README-community.md with analysis

decompiled-community/sources/androidx/work/impl/model/Dependency.java

@@ -0,0 +1,35 @@
+package androidx.work.impl.model;
+
+import androidx.annotation.RestrictTo;
+import androidx.room.ColumnInfo;
+import androidx.room.Entity;
+import androidx.room.ForeignKey;
+import androidx.room.Index;
+import kotlin.jvm.internal.Intrinsics;
+
+@Entity(foreignKeys = {@ForeignKey(childColumns = {"work_spec_id"}, entity = WorkSpec.class, onDelete = 5, onUpdate = 5, parentColumns = {"id"}), @ForeignKey(childColumns = {"prerequisite_id"}, entity = WorkSpec.class, onDelete = 5, onUpdate = 5, parentColumns = {"id"})}, indices = {@Index({"work_spec_id"}), @Index({"prerequisite_id"})}, primaryKeys = {"work_spec_id", "prerequisite_id"})
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+/* loaded from: classes.dex */
+public final class Dependency {
+
+    @ColumnInfo(name = "prerequisite_id")
+    private final String prerequisiteId;
+
+    @ColumnInfo(name = "work_spec_id")
+    private final String workSpecId;
+
+    public final String getPrerequisiteId() {
+        return this.prerequisiteId;
+    }
+
+    public final String getWorkSpecId() {
+        return this.workSpecId;
+    }
+
+    public Dependency(String workSpecId, String prerequisiteId) {
+        Intrinsics.checkNotNullParameter(workSpecId, "workSpecId");
+        Intrinsics.checkNotNullParameter(prerequisiteId, "prerequisiteId");
+        this.workSpecId = workSpecId;
+        this.prerequisiteId = prerequisiteId;
+    }
+}

decompiled-community/sources/androidx/work/impl/model/DependencyDao.java

@@ -0,0 +1,25 @@
+package androidx.work.impl.model;
+
+import androidx.room.Dao;
+import androidx.room.Insert;
+import androidx.room.Query;
+import java.util.List;
+
+@Dao
+/* loaded from: classes.dex */
+public interface DependencyDao {
+    @Query("SELECT work_spec_id FROM dependency WHERE prerequisite_id=:id")
+    List<String> getDependentWorkIds(String str);
+
+    @Query("SELECT prerequisite_id FROM dependency WHERE work_spec_id=:id")
+    List<String> getPrerequisites(String str);
+
+    @Query("SELECT COUNT(*)=0 FROM dependency WHERE work_spec_id=:id AND prerequisite_id IN (SELECT id FROM workspec WHERE state!=2)")
+    boolean hasCompletedAllPrerequisites(String str);
+
+    @Query("SELECT COUNT(*)>0 FROM dependency WHERE prerequisite_id=:id")
+    boolean hasDependents(String str);
+
+    @Insert(onConflict = 5)
+    void insertDependency(Dependency dependency);
+}

decompiled-community/sources/androidx/work/impl/model/DependencyDao_Impl.java

@@ -0,0 +1,124 @@
+package androidx.work.impl.model;
+
+import android.database.Cursor;
+import androidx.annotation.NonNull;
+import androidx.room.EntityInsertionAdapter;
+import androidx.room.RoomDatabase;
+import androidx.room.RoomSQLiteQuery;
+import androidx.room.util.DBUtil;
+import androidx.sqlite.db.SupportSQLiteStatement;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/* loaded from: classes.dex */
+public final class DependencyDao_Impl implements DependencyDao {
+    private final RoomDatabase __db;
+    private final EntityInsertionAdapter<Dependency> __insertionAdapterOfDependency;
+
+    public DependencyDao_Impl(@NonNull RoomDatabase roomDatabase) {
+        this.__db = roomDatabase;
+        this.__insertionAdapterOfDependency = new EntityInsertionAdapter<Dependency>(roomDatabase) { // from class: androidx.work.impl.model.DependencyDao_Impl.1
+            @Override // androidx.room.SharedSQLiteStatement
+            @NonNull
+            public String createQuery() {
+                return "INSERT OR IGNORE INTO `Dependency` (`work_spec_id`,`prerequisite_id`) VALUES (?,?)";
+            }
+
+            @Override // androidx.room.EntityInsertionAdapter
+            public void bind(@NonNull SupportSQLiteStatement supportSQLiteStatement, @NonNull Dependency dependency) {
+                supportSQLiteStatement.bindString(1, dependency.getWorkSpecId());
+                supportSQLiteStatement.bindString(2, dependency.getPrerequisiteId());
+            }
+        };
+    }
+
+    @Override // androidx.work.impl.model.DependencyDao
+    public void insertDependency(Dependency dependency) {
+        this.__db.assertNotSuspendingTransaction();
+        this.__db.beginTransaction();
+        try {
+            this.__insertionAdapterOfDependency.insert((EntityInsertionAdapter<Dependency>) dependency);
+            this.__db.setTransactionSuccessful();
+        } finally {
+            this.__db.endTransaction();
+        }
+    }
+
+    @Override // androidx.work.impl.model.DependencyDao
+    public boolean hasCompletedAllPrerequisites(String str) {
+        RoomSQLiteQuery acquire = RoomSQLiteQuery.acquire("SELECT COUNT(*)=0 FROM dependency WHERE work_spec_id=? AND prerequisite_id IN (SELECT id FROM workspec WHERE state!=2)", 1);
+        acquire.bindString(1, str);
+        this.__db.assertNotSuspendingTransaction();
+        boolean z = false;
+        Cursor query = DBUtil.query(this.__db, acquire, false, null);
+        try {
+            if (query.moveToFirst()) {
+                z = query.getInt(0) != 0;
+            }
+            return z;
+        } finally {
+            query.close();
+            acquire.release();
+        }
+    }
+
+    @Override // androidx.work.impl.model.DependencyDao
+    public List<String> getPrerequisites(String str) {
+        RoomSQLiteQuery acquire = RoomSQLiteQuery.acquire("SELECT prerequisite_id FROM dependency WHERE work_spec_id=?", 1);
+        acquire.bindString(1, str);
+        this.__db.assertNotSuspendingTransaction();
+        Cursor query = DBUtil.query(this.__db, acquire, false, null);
+        try {
+            ArrayList arrayList = new ArrayList(query.getCount());
+            while (query.moveToNext()) {
+                arrayList.add(query.getString(0));
+            }
+            return arrayList;
+        } finally {
+            query.close();
+            acquire.release();
+        }
+    }
+
+    @Override // androidx.work.impl.model.DependencyDao
+    public List<String> getDependentWorkIds(String str) {
+        RoomSQLiteQuery acquire = RoomSQLiteQuery.acquire("SELECT work_spec_id FROM dependency WHERE prerequisite_id=?", 1);
+        acquire.bindString(1, str);
+        this.__db.assertNotSuspendingTransaction();
+        Cursor query = DBUtil.query(this.__db, acquire, false, null);
+        try {
+            ArrayList arrayList = new ArrayList(query.getCount());
+            while (query.moveToNext()) {
+                arrayList.add(query.getString(0));
+            }
+            return arrayList;
+        } finally {
+            query.close();
+            acquire.release();
+        }
+    }
+
+    @Override // androidx.work.impl.model.DependencyDao
+    public boolean hasDependents(String str) {
+        RoomSQLiteQuery acquire = RoomSQLiteQuery.acquire("SELECT COUNT(*)>0 FROM dependency WHERE prerequisite_id=?", 1);
+        acquire.bindString(1, str);
+        this.__db.assertNotSuspendingTransaction();
+        boolean z = false;
+        Cursor query = DBUtil.query(this.__db, acquire, false, null);
+        try {
+            if (query.moveToFirst()) {
+                z = query.getInt(0) != 0;
+            }
+            return z;
+        } finally {
+            query.close();
+            acquire.release();
+        }
+    }
+
+    @NonNull
+    public static List<Class<?>> getRequiredConverters() {
+        return Collections.emptyList();
+    }
+}

decompiled-community/sources/androidx/work/impl/model/Preference.java

@@ -0,0 +1,84 @@
+package androidx.work.impl.model;
+
+import androidx.annotation.RestrictTo;
+import androidx.room.ColumnInfo;
+import androidx.room.Entity;
+import androidx.room.PrimaryKey;
+import kotlin.jvm.internal.Intrinsics;
+
+@Entity
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+/* loaded from: classes.dex */
+public final class Preference {
+
+    @PrimaryKey
+    @ColumnInfo(name = "key")
+    private final String key;
+
+    @ColumnInfo(name = "long_value")
+    private final Long value;
+
+    public static /* synthetic */ Preference copy$default(Preference preference, String str, Long l, int i, Object obj) {
+        if ((i & 1) != 0) {
+            str = preference.key;
+        }
+        if ((i & 2) != 0) {
+            l = preference.value;
+        }
+        return preference.copy(str, l);
+    }
+
+    public final String component1() {
+        return this.key;
+    }
+
+    public final Long component2() {
+        return this.value;
+    }
+
+    public final Preference copy(String key, Long l) {
+        Intrinsics.checkNotNullParameter(key, "key");
+        return new Preference(key, l);
+    }
+
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof Preference)) {
+            return false;
+        }
+        Preference preference = (Preference) obj;
+        return Intrinsics.areEqual(this.key, preference.key) && Intrinsics.areEqual(this.value, preference.value);
+    }
+
+    public final String getKey() {
+        return this.key;
+    }
+
+    public final Long getValue() {
+        return this.value;
+    }
+
+    public int hashCode() {
+        int hashCode = this.key.hashCode() * 31;
+        Long l = this.value;
+        return hashCode + (l == null ? 0 : l.hashCode());
+    }
+
+    public String toString() {
+        return "Preference(key=" + this.key + ", value=" + this.value + ')';
+    }
+
+    public Preference(String key, Long l) {
+        Intrinsics.checkNotNullParameter(key, "key");
+        this.key = key;
+        this.value = l;
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public Preference(String key, boolean z) {
+        this(key, Long.valueOf(z ? 1L : 0L));
+        Intrinsics.checkNotNullParameter(key, "key");
+    }
+}

decompiled-community/sources/androidx/work/impl/model/PreferenceDao.java

@@ -0,0 +1,19 @@
+package androidx.work.impl.model;
+
+import androidx.lifecycle.LiveData;
+import androidx.room.Dao;
+import androidx.room.Insert;
+import androidx.room.Query;
+
+@Dao
+/* loaded from: classes.dex */
+public interface PreferenceDao {
+    @Query("SELECT long_value FROM Preference where `key`=:key")
+    Long getLongValue(String str);
+
+    @Query("SELECT long_value FROM Preference where `key`=:key")
+    LiveData<Long> getObservableLongValue(String str);
+
+    @Insert(onConflict = 1)
+    void insertPreference(Preference preference);
+}

decompiled-community/sources/androidx/work/impl/model/PreferenceDao_Impl.java

@@ -0,0 +1,103 @@
+package androidx.work.impl.model;
+
+import android.database.Cursor;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.lifecycle.LiveData;
+import androidx.room.EntityInsertionAdapter;
+import androidx.room.RoomDatabase;
+import androidx.room.RoomSQLiteQuery;
+import androidx.room.util.DBUtil;
+import androidx.sqlite.db.SupportSQLiteStatement;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.Callable;
+
+/* loaded from: classes.dex */
+public final class PreferenceDao_Impl implements PreferenceDao {
+    private final RoomDatabase __db;
+    private final EntityInsertionAdapter<Preference> __insertionAdapterOfPreference;
+
+    public PreferenceDao_Impl(@NonNull RoomDatabase roomDatabase) {
+        this.__db = roomDatabase;
+        this.__insertionAdapterOfPreference = new EntityInsertionAdapter<Preference>(roomDatabase) { // from class: androidx.work.impl.model.PreferenceDao_Impl.1
+            @Override // androidx.room.SharedSQLiteStatement
+            @NonNull
+            public String createQuery() {
+                return "INSERT OR REPLACE INTO `Preference` (`key`,`long_value`) VALUES (?,?)";
+            }
+
+            @Override // androidx.room.EntityInsertionAdapter
+            public void bind(@NonNull SupportSQLiteStatement supportSQLiteStatement, @NonNull Preference preference) {
+                supportSQLiteStatement.bindString(1, preference.getKey());
+                if (preference.getValue() == null) {
+                    supportSQLiteStatement.bindNull(2);
+                } else {
+                    supportSQLiteStatement.bindLong(2, preference.getValue().longValue());
+                }
+            }
+        };
+    }
+
+    @Override // androidx.work.impl.model.PreferenceDao
+    public void insertPreference(Preference preference) {
+        this.__db.assertNotSuspendingTransaction();
+        this.__db.beginTransaction();
+        try {
+            this.__insertionAdapterOfPreference.insert((EntityInsertionAdapter<Preference>) preference);
+            this.__db.setTransactionSuccessful();
+        } finally {
+            this.__db.endTransaction();
+        }
+    }
+
+    @Override // androidx.work.impl.model.PreferenceDao
+    public Long getLongValue(String str) {
+        RoomSQLiteQuery acquire = RoomSQLiteQuery.acquire("SELECT long_value FROM Preference where `key`=?", 1);
+        acquire.bindString(1, str);
+        this.__db.assertNotSuspendingTransaction();
+        Long l = null;
+        Cursor query = DBUtil.query(this.__db, acquire, false, null);
+        try {
+            if (query.moveToFirst() && !query.isNull(0)) {
+                l = Long.valueOf(query.getLong(0));
+            }
+            return l;
+        } finally {
+            query.close();
+            acquire.release();
+        }
+    }
+
+    @Override // androidx.work.impl.model.PreferenceDao
+    public LiveData<Long> getObservableLongValue(String str) {
+        final RoomSQLiteQuery acquire = RoomSQLiteQuery.acquire("SELECT long_value FROM Preference where `key`=?", 1);
+        acquire.bindString(1, str);
+        return this.__db.getInvalidationTracker().createLiveData(new String[]{"Preference"}, false, new Callable<Long>() { // from class: androidx.work.impl.model.PreferenceDao_Impl.2
+            /* JADX WARN: Can't rename method to resolve collision */
+            @Override // java.util.concurrent.Callable
+            @Nullable
+            public Long call() throws Exception {
+                Long l = null;
+                Cursor query = DBUtil.query(PreferenceDao_Impl.this.__db, acquire, false, null);
+                try {
+                    if (query.moveToFirst() && !query.isNull(0)) {
+                        l = Long.valueOf(query.getLong(0));
+                    }
+                    return l;
+                } finally {
+                    query.close();
+                }
+            }
+
+            public void finalize() {
+                acquire.release();
+            }
+        });
+    }
+
+    @NonNull
+    public static List<Class<?>> getRequiredConverters() {
+        return Collections.emptyList();
+    }
+}

decompiled-community/sources/androidx/work/impl/model/RawWorkInfoDao.java

@@ -0,0 +1,22 @@
+package androidx.work.impl.model;
+
+import androidx.lifecycle.LiveData;
+import androidx.room.Dao;
+import androidx.room.RawQuery;
+import androidx.sqlite.db.SupportSQLiteQuery;
+import androidx.work.impl.model.WorkSpec;
+import java.util.List;
+import kotlinx.coroutines.flow.Flow;
+
+@Dao
+/* loaded from: classes.dex */
+public interface RawWorkInfoDao {
+    @RawQuery(observedEntities = {WorkSpec.class})
+    List<WorkSpec.WorkInfoPojo> getWorkInfoPojos(SupportSQLiteQuery supportSQLiteQuery);
+
+    @RawQuery(observedEntities = {WorkSpec.class})
+    Flow getWorkInfoPojosFlow(SupportSQLiteQuery supportSQLiteQuery);
+
+    @RawQuery(observedEntities = {WorkSpec.class})
+    LiveData<List<WorkSpec.WorkInfoPojo>> getWorkInfoPojosLiveData(SupportSQLiteQuery supportSQLiteQuery);
+}

decompiled-community/sources/androidx/work/impl/model/RawWorkInfoDaoKt.java

@@ -0,0 +1,16 @@
+package androidx.work.impl.model;
+
+import androidx.sqlite.db.SupportSQLiteQuery;
+import kotlin.jvm.internal.Intrinsics;
+import kotlinx.coroutines.CoroutineDispatcher;
+import kotlinx.coroutines.flow.Flow;
+
+/* loaded from: classes.dex */
+public final class RawWorkInfoDaoKt {
+    public static final Flow getWorkInfoPojosFlow(RawWorkInfoDao rawWorkInfoDao, CoroutineDispatcher dispatcher, SupportSQLiteQuery query) {
+        Intrinsics.checkNotNullParameter(rawWorkInfoDao, "<this>");
+        Intrinsics.checkNotNullParameter(dispatcher, "dispatcher");
+        Intrinsics.checkNotNullParameter(query, "query");
+        return WorkSpecDaoKt.dedup(rawWorkInfoDao.getWorkInfoPojosFlow(query), dispatcher);
+    }
+}

decompiled-community/sources/androidx/work/impl/model/RawWorkInfoDao_Impl.java

@@ -0,0 +1,769 @@
+package androidx.work.impl.model;
+
+import android.database.Cursor;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.lifecycle.LiveData;
+import androidx.room.CoroutinesRoom;
+import androidx.room.RoomDatabase;
+import androidx.room.RoomSQLiteQuery;
+import androidx.room.util.CursorUtil;
+import androidx.room.util.DBUtil;
+import androidx.room.util.RelationUtil;
+import androidx.room.util.StringUtil;
+import androidx.sqlite.db.SupportSQLiteQuery;
+import androidx.work.BackoffPolicy;
+import androidx.work.Constraints;
+import androidx.work.Data;
+import androidx.work.NetworkType;
+import androidx.work.WorkInfo;
+import androidx.work.impl.model.WorkSpec;
+import androidx.work.impl.utils.NetworkRequestCompat;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.Callable;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function1;
+import kotlinx.coroutines.flow.Flow;
+
+/* loaded from: classes.dex */
+public final class RawWorkInfoDao_Impl implements RawWorkInfoDao {
+    private final RoomDatabase __db;
+
+    public RawWorkInfoDao_Impl(@NonNull RoomDatabase roomDatabase) {
+        this.__db = roomDatabase;
+    }
+
+    @Override // androidx.work.impl.model.RawWorkInfoDao
+    public List<WorkSpec.WorkInfoPojo> getWorkInfoPojos(SupportSQLiteQuery supportSQLiteQuery) {
+        long j;
+        int i;
+        int i2;
+        int i3;
+        int i4;
+        int i5;
+        long j2;
+        int i6;
+        int i7;
+        NetworkType intToNetworkType;
+        int i8;
+        NetworkRequestCompat networkRequest$work_runtime_release;
+        int i9;
+        boolean z;
+        int i10;
+        boolean z2;
+        int i11;
+        boolean z3;
+        int i12;
+        long j3;
+        int i13;
+        int i14;
+        this.__db.assertNotSuspendingTransaction();
+        Cursor query = DBUtil.query(this.__db, supportSQLiteQuery, true, null);
+        try {
+            int columnIndex = CursorUtil.getColumnIndex(query, "id");
+            int columnIndex2 = CursorUtil.getColumnIndex(query, "state");
+            int columnIndex3 = CursorUtil.getColumnIndex(query, "output");
+            int columnIndex4 = CursorUtil.getColumnIndex(query, "initial_delay");
+            int columnIndex5 = CursorUtil.getColumnIndex(query, "interval_duration");
+            int columnIndex6 = CursorUtil.getColumnIndex(query, "flex_duration");
+            int columnIndex7 = CursorUtil.getColumnIndex(query, "run_attempt_count");
+            int columnIndex8 = CursorUtil.getColumnIndex(query, "backoff_policy");
+            int columnIndex9 = CursorUtil.getColumnIndex(query, "backoff_delay_duration");
+            int columnIndex10 = CursorUtil.getColumnIndex(query, "last_enqueue_time");
+            int columnIndex11 = CursorUtil.getColumnIndex(query, "period_count");
+            int columnIndex12 = CursorUtil.getColumnIndex(query, "generation");
+            int columnIndex13 = CursorUtil.getColumnIndex(query, "next_schedule_time_override");
+            int columnIndex14 = CursorUtil.getColumnIndex(query, "stop_reason");
+            int columnIndex15 = CursorUtil.getColumnIndex(query, "required_network_type");
+            int columnIndex16 = CursorUtil.getColumnIndex(query, "required_network_request");
+            int columnIndex17 = CursorUtil.getColumnIndex(query, "requires_charging");
+            int columnIndex18 = CursorUtil.getColumnIndex(query, "requires_device_idle");
+            int columnIndex19 = CursorUtil.getColumnIndex(query, "requires_battery_not_low");
+            int columnIndex20 = CursorUtil.getColumnIndex(query, "requires_storage_not_low");
+            int columnIndex21 = CursorUtil.getColumnIndex(query, "trigger_content_update_delay");
+            int columnIndex22 = CursorUtil.getColumnIndex(query, "trigger_max_content_delay");
+            int columnIndex23 = CursorUtil.getColumnIndex(query, "content_uri_triggers");
+            HashMap<String, ArrayList<String>> hashMap = new HashMap<>();
+            int i15 = columnIndex13;
+            HashMap<String, ArrayList<Data>> hashMap2 = new HashMap<>();
+            while (query.moveToNext()) {
+                int i16 = columnIndex12;
+                String string = query.getString(columnIndex);
+                if (hashMap.containsKey(string)) {
+                    i14 = columnIndex11;
+                } else {
+                    i14 = columnIndex11;
+                    hashMap.put(string, new ArrayList<>());
+                }
+                String string2 = query.getString(columnIndex);
+                if (!hashMap2.containsKey(string2)) {
+                    hashMap2.put(string2, new ArrayList<>());
+                }
+                columnIndex12 = i16;
+                columnIndex11 = i14;
+            }
+            int i17 = columnIndex11;
+            int i18 = columnIndex12;
+            query.moveToPosition(-1);
+            __fetchRelationshipWorkTagAsjavaLangString(hashMap);
+            __fetchRelationshipWorkProgressAsandroidxWorkData(hashMap2);
+            ArrayList arrayList = new ArrayList(query.getCount());
+            while (query.moveToNext()) {
+                String string3 = columnIndex == -1 ? null : query.getString(columnIndex);
+                WorkInfo.State intToState = columnIndex2 == -1 ? null : WorkTypeConverters.intToState(query.getInt(columnIndex2));
+                Data fromByteArray = columnIndex3 == -1 ? null : Data.fromByteArray(query.getBlob(columnIndex3));
+                long j4 = columnIndex4 == -1 ? 0L : query.getLong(columnIndex4);
+                long j5 = columnIndex5 == -1 ? 0L : query.getLong(columnIndex5);
+                long j6 = columnIndex6 == -1 ? 0L : query.getLong(columnIndex6);
+                boolean z4 = false;
+                int i19 = columnIndex7 == -1 ? 0 : query.getInt(columnIndex7);
+                BackoffPolicy intToBackoffPolicy = columnIndex8 == -1 ? null : WorkTypeConverters.intToBackoffPolicy(query.getInt(columnIndex8));
+                long j7 = columnIndex9 == -1 ? 0L : query.getLong(columnIndex9);
+                if (columnIndex10 == -1) {
+                    i = i17;
+                    j = 0;
+                } else {
+                    j = query.getLong(columnIndex10);
+                    i = i17;
+                }
+                if (i == -1) {
+                    i17 = i;
+                    i3 = i18;
+                    i2 = 0;
+                } else {
+                    i2 = query.getInt(i);
+                    i17 = i;
+                    i3 = i18;
+                }
+                if (i3 == -1) {
+                    i18 = i3;
+                    i5 = i15;
+                    i4 = 0;
+                } else {
+                    i4 = query.getInt(i3);
+                    i18 = i3;
+                    i5 = i15;
+                }
+                if (i5 == -1) {
+                    i15 = i5;
+                    j2 = 0;
+                } else {
+                    j2 = query.getLong(i5);
+                    i15 = i5;
+                }
+                int i20 = columnIndex14;
+                if (i20 == -1) {
+                    columnIndex14 = i20;
+                    i7 = columnIndex15;
+                    i6 = 0;
+                } else {
+                    i6 = query.getInt(i20);
+                    columnIndex14 = i20;
+                    i7 = columnIndex15;
+                }
+                if (i7 == -1) {
+                    columnIndex15 = i7;
+                    i8 = columnIndex16;
+                    intToNetworkType = null;
+                } else {
+                    intToNetworkType = WorkTypeConverters.intToNetworkType(query.getInt(i7));
+                    columnIndex15 = i7;
+                    i8 = columnIndex16;
+                }
+                if (i8 == -1) {
+                    columnIndex16 = i8;
+                    i9 = columnIndex17;
+                    networkRequest$work_runtime_release = null;
+                } else {
+                    networkRequest$work_runtime_release = WorkTypeConverters.toNetworkRequest$work_runtime_release(query.getBlob(i8));
+                    columnIndex16 = i8;
+                    i9 = columnIndex17;
+                }
+                if (i9 == -1) {
+                    columnIndex17 = i9;
+                    i10 = columnIndex18;
+                    z = false;
+                } else {
+                    z = query.getInt(i9) != 0;
+                    columnIndex17 = i9;
+                    i10 = columnIndex18;
+                }
+                if (i10 == -1) {
+                    columnIndex18 = i10;
+                    i11 = columnIndex19;
+                    z2 = false;
+                } else {
+                    z2 = query.getInt(i10) != 0;
+                    columnIndex18 = i10;
+                    i11 = columnIndex19;
+                }
+                if (i11 == -1) {
+                    columnIndex19 = i11;
+                    i12 = columnIndex20;
+                    z3 = false;
+                } else {
+                    z3 = query.getInt(i11) != 0;
+                    columnIndex19 = i11;
+                    i12 = columnIndex20;
+                }
+                if (i12 != -1 && query.getInt(i12) != 0) {
+                    z4 = true;
+                }
+                columnIndex20 = i12;
+                int i21 = columnIndex21;
+                boolean z5 = z4;
+                if (i21 == -1) {
+                    columnIndex21 = i21;
+                    i13 = columnIndex22;
+                    j3 = 0;
+                } else {
+                    j3 = query.getLong(i21);
+                    columnIndex21 = i21;
+                    i13 = columnIndex22;
+                }
+                long j8 = i13 != -1 ? query.getLong(i13) : 0L;
+                columnIndex22 = i13;
+                int i22 = columnIndex23;
+                arrayList.add(new WorkSpec.WorkInfoPojo(string3, intToState, fromByteArray, j4, j5, j6, new Constraints(networkRequest$work_runtime_release, intToNetworkType, z, z2, z3, z5, j3, j8, i22 == -1 ? null : WorkTypeConverters.byteArrayToSetOfTriggers(query.getBlob(i22))), i19, intToBackoffPolicy, j7, j, i2, i4, j2, i6, hashMap.get(query.getString(columnIndex)), hashMap2.get(query.getString(columnIndex))));
+                columnIndex23 = i22;
+            }
+            query.close();
+            return arrayList;
+        } catch (Throwable th) {
+            query.close();
+            throw th;
+        }
+    }
+
+    @Override // androidx.work.impl.model.RawWorkInfoDao
+    public LiveData<List<WorkSpec.WorkInfoPojo>> getWorkInfoPojosLiveData(final SupportSQLiteQuery supportSQLiteQuery) {
+        return this.__db.getInvalidationTracker().createLiveData(new String[]{"WorkTag", "WorkProgress", "WorkSpec"}, false, new Callable<List<WorkSpec.WorkInfoPojo>>() { // from class: androidx.work.impl.model.RawWorkInfoDao_Impl.1
+            @Override // java.util.concurrent.Callable
+            @Nullable
+            public List<WorkSpec.WorkInfoPojo> call() throws Exception {
+                long j;
+                int i;
+                int i2;
+                int i3;
+                int i4;
+                int i5;
+                long j2;
+                int i6;
+                int i7;
+                int i8;
+                NetworkType intToNetworkType;
+                int i9;
+                NetworkRequestCompat networkRequest$work_runtime_release;
+                int i10;
+                boolean z;
+                int i11;
+                boolean z2;
+                int i12;
+                boolean z3;
+                int i13;
+                long j3;
+                int i14;
+                int i15;
+                Cursor query = DBUtil.query(RawWorkInfoDao_Impl.this.__db, supportSQLiteQuery, true, null);
+                try {
+                    int columnIndex = CursorUtil.getColumnIndex(query, "id");
+                    int columnIndex2 = CursorUtil.getColumnIndex(query, "state");
+                    int columnIndex3 = CursorUtil.getColumnIndex(query, "output");
+                    int columnIndex4 = CursorUtil.getColumnIndex(query, "initial_delay");
+                    int columnIndex5 = CursorUtil.getColumnIndex(query, "interval_duration");
+                    int columnIndex6 = CursorUtil.getColumnIndex(query, "flex_duration");
+                    int columnIndex7 = CursorUtil.getColumnIndex(query, "run_attempt_count");
+                    int columnIndex8 = CursorUtil.getColumnIndex(query, "backoff_policy");
+                    int columnIndex9 = CursorUtil.getColumnIndex(query, "backoff_delay_duration");
+                    int columnIndex10 = CursorUtil.getColumnIndex(query, "last_enqueue_time");
+                    int columnIndex11 = CursorUtil.getColumnIndex(query, "period_count");
+                    int columnIndex12 = CursorUtil.getColumnIndex(query, "generation");
+                    int columnIndex13 = CursorUtil.getColumnIndex(query, "next_schedule_time_override");
+                    int columnIndex14 = CursorUtil.getColumnIndex(query, "stop_reason");
+                    int columnIndex15 = CursorUtil.getColumnIndex(query, "required_network_type");
+                    int columnIndex16 = CursorUtil.getColumnIndex(query, "required_network_request");
+                    int columnIndex17 = CursorUtil.getColumnIndex(query, "requires_charging");
+                    int columnIndex18 = CursorUtil.getColumnIndex(query, "requires_device_idle");
+                    int columnIndex19 = CursorUtil.getColumnIndex(query, "requires_battery_not_low");
+                    int columnIndex20 = CursorUtil.getColumnIndex(query, "requires_storage_not_low");
+                    int columnIndex21 = CursorUtil.getColumnIndex(query, "trigger_content_update_delay");
+                    int columnIndex22 = CursorUtil.getColumnIndex(query, "trigger_max_content_delay");
+                    int columnIndex23 = CursorUtil.getColumnIndex(query, "content_uri_triggers");
+                    HashMap hashMap = new HashMap();
+                    int i16 = columnIndex13;
+                    HashMap hashMap2 = new HashMap();
+                    while (query.moveToNext()) {
+                        int i17 = columnIndex12;
+                        String string = query.getString(columnIndex);
+                        if (hashMap.containsKey(string)) {
+                            i15 = columnIndex11;
+                        } else {
+                            i15 = columnIndex11;
+                            hashMap.put(string, new ArrayList());
+                        }
+                        String string2 = query.getString(columnIndex);
+                        if (!hashMap2.containsKey(string2)) {
+                            hashMap2.put(string2, new ArrayList());
+                        }
+                        columnIndex12 = i17;
+                        columnIndex11 = i15;
+                    }
+                    int i18 = columnIndex11;
+                    int i19 = columnIndex12;
+                    query.moveToPosition(-1);
+                    RawWorkInfoDao_Impl.this.__fetchRelationshipWorkTagAsjavaLangString(hashMap);
+                    RawWorkInfoDao_Impl.this.__fetchRelationshipWorkProgressAsandroidxWorkData(hashMap2);
+                    ArrayList arrayList = new ArrayList(query.getCount());
+                    while (query.moveToNext()) {
+                        String string3 = columnIndex == -1 ? null : query.getString(columnIndex);
+                        WorkInfo.State intToState = columnIndex2 == -1 ? null : WorkTypeConverters.intToState(query.getInt(columnIndex2));
+                        Data fromByteArray = columnIndex3 == -1 ? null : Data.fromByteArray(query.getBlob(columnIndex3));
+                        long j4 = columnIndex4 == -1 ? 0L : query.getLong(columnIndex4);
+                        long j5 = columnIndex5 == -1 ? 0L : query.getLong(columnIndex5);
+                        long j6 = columnIndex6 == -1 ? 0L : query.getLong(columnIndex6);
+                        boolean z4 = false;
+                        int i20 = columnIndex7 == -1 ? 0 : query.getInt(columnIndex7);
+                        BackoffPolicy intToBackoffPolicy = columnIndex8 == -1 ? null : WorkTypeConverters.intToBackoffPolicy(query.getInt(columnIndex8));
+                        long j7 = columnIndex9 == -1 ? 0L : query.getLong(columnIndex9);
+                        if (columnIndex10 == -1) {
+                            i = i18;
+                            j = 0;
+                        } else {
+                            j = query.getLong(columnIndex10);
+                            i = i18;
+                        }
+                        if (i == -1) {
+                            i18 = i;
+                            i3 = i19;
+                            i2 = 0;
+                        } else {
+                            i2 = query.getInt(i);
+                            i18 = i;
+                            i3 = i19;
+                        }
+                        if (i3 == -1) {
+                            i19 = i3;
+                            i5 = i16;
+                            i4 = 0;
+                        } else {
+                            i4 = query.getInt(i3);
+                            i19 = i3;
+                            i5 = i16;
+                        }
+                        if (i5 == -1) {
+                            i16 = i5;
+                            i6 = columnIndex14;
+                            j2 = 0;
+                        } else {
+                            j2 = query.getLong(i5);
+                            i16 = i5;
+                            i6 = columnIndex14;
+                        }
+                        if (i6 == -1) {
+                            columnIndex14 = i6;
+                            i8 = columnIndex15;
+                            i7 = 0;
+                        } else {
+                            i7 = query.getInt(i6);
+                            columnIndex14 = i6;
+                            i8 = columnIndex15;
+                        }
+                        if (i8 == -1) {
+                            columnIndex15 = i8;
+                            i9 = columnIndex16;
+                            intToNetworkType = null;
+                        } else {
+                            intToNetworkType = WorkTypeConverters.intToNetworkType(query.getInt(i8));
+                            columnIndex15 = i8;
+                            i9 = columnIndex16;
+                        }
+                        if (i9 == -1) {
+                            columnIndex16 = i9;
+                            i10 = columnIndex17;
+                            networkRequest$work_runtime_release = null;
+                        } else {
+                            networkRequest$work_runtime_release = WorkTypeConverters.toNetworkRequest$work_runtime_release(query.getBlob(i9));
+                            columnIndex16 = i9;
+                            i10 = columnIndex17;
+                        }
+                        if (i10 == -1) {
+                            columnIndex17 = i10;
+                            i11 = columnIndex18;
+                            z = false;
+                        } else {
+                            z = query.getInt(i10) != 0;
+                            columnIndex17 = i10;
+                            i11 = columnIndex18;
+                        }
+                        if (i11 == -1) {
+                            columnIndex18 = i11;
+                            i12 = columnIndex19;
+                            z2 = false;
+                        } else {
+                            z2 = query.getInt(i11) != 0;
+                            columnIndex18 = i11;
+                            i12 = columnIndex19;
+                        }
+                        if (i12 == -1) {
+                            columnIndex19 = i12;
+                            i13 = columnIndex20;
+                            z3 = false;
+                        } else {
+                            z3 = query.getInt(i12) != 0;
+                            columnIndex19 = i12;
+                            i13 = columnIndex20;
+                        }
+                        if (i13 != -1 && query.getInt(i13) != 0) {
+                            z4 = true;
+                        }
+                        columnIndex20 = i13;
+                        int i21 = columnIndex21;
+                        boolean z5 = z4;
+                        if (i21 == -1) {
+                            columnIndex21 = i21;
+                            i14 = columnIndex22;
+                            j3 = 0;
+                        } else {
+                            j3 = query.getLong(i21);
+                            columnIndex21 = i21;
+                            i14 = columnIndex22;
+                        }
+                        long j8 = i14 != -1 ? query.getLong(i14) : 0L;
+                        columnIndex22 = i14;
+                        int i22 = columnIndex23;
+                        arrayList.add(new WorkSpec.WorkInfoPojo(string3, intToState, fromByteArray, j4, j5, j6, new Constraints(networkRequest$work_runtime_release, intToNetworkType, z, z2, z3, z5, j3, j8, i22 == -1 ? null : WorkTypeConverters.byteArrayToSetOfTriggers(query.getBlob(i22))), i20, intToBackoffPolicy, j7, j, i2, i4, j2, i7, (ArrayList) hashMap.get(query.getString(columnIndex)), (ArrayList) hashMap2.get(query.getString(columnIndex))));
+                        columnIndex23 = i22;
+                    }
+                    query.close();
+                    return arrayList;
+                } catch (Throwable th) {
+                    query.close();
+                    throw th;
+                }
+            }
+        });
+    }
+
+    @Override // androidx.work.impl.model.RawWorkInfoDao
+    public Flow getWorkInfoPojosFlow(final SupportSQLiteQuery supportSQLiteQuery) {
+        return CoroutinesRoom.createFlow(this.__db, false, new String[]{"WorkTag", "WorkProgress", "WorkSpec"}, new Callable<List<WorkSpec.WorkInfoPojo>>() { // from class: androidx.work.impl.model.RawWorkInfoDao_Impl.2
+            @Override // java.util.concurrent.Callable
+            @NonNull
+            public List<WorkSpec.WorkInfoPojo> call() throws Exception {
+                long j;
+                int i;
+                int i2;
+                int i3;
+                int i4;
+                int i5;
+                long j2;
+                int i6;
+                int i7;
+                int i8;
+                NetworkType intToNetworkType;
+                int i9;
+                NetworkRequestCompat networkRequest$work_runtime_release;
+                int i10;
+                boolean z;
+                int i11;
+                boolean z2;
+                int i12;
+                boolean z3;
+                int i13;
+                long j3;
+                int i14;
+                int i15;
+                Cursor query = DBUtil.query(RawWorkInfoDao_Impl.this.__db, supportSQLiteQuery, true, null);
+                try {
+                    int columnIndex = CursorUtil.getColumnIndex(query, "id");
+                    int columnIndex2 = CursorUtil.getColumnIndex(query, "state");
+                    int columnIndex3 = CursorUtil.getColumnIndex(query, "output");
+                    int columnIndex4 = CursorUtil.getColumnIndex(query, "initial_delay");
+                    int columnIndex5 = CursorUtil.getColumnIndex(query, "interval_duration");
+                    int columnIndex6 = CursorUtil.getColumnIndex(query, "flex_duration");
+                    int columnIndex7 = CursorUtil.getColumnIndex(query, "run_attempt_count");
+                    int columnIndex8 = CursorUtil.getColumnIndex(query, "backoff_policy");
+                    int columnIndex9 = CursorUtil.getColumnIndex(query, "backoff_delay_duration");
+                    int columnIndex10 = CursorUtil.getColumnIndex(query, "last_enqueue_time");
+                    int columnIndex11 = CursorUtil.getColumnIndex(query, "period_count");
+                    int columnIndex12 = CursorUtil.getColumnIndex(query, "generation");
+                    int columnIndex13 = CursorUtil.getColumnIndex(query, "next_schedule_time_override");
+                    int columnIndex14 = CursorUtil.getColumnIndex(query, "stop_reason");
+                    int columnIndex15 = CursorUtil.getColumnIndex(query, "required_network_type");
+                    int columnIndex16 = CursorUtil.getColumnIndex(query, "required_network_request");
+                    int columnIndex17 = CursorUtil.getColumnIndex(query, "requires_charging");
+                    int columnIndex18 = CursorUtil.getColumnIndex(query, "requires_device_idle");
+                    int columnIndex19 = CursorUtil.getColumnIndex(query, "requires_battery_not_low");
+                    int columnIndex20 = CursorUtil.getColumnIndex(query, "requires_storage_not_low");
+                    int columnIndex21 = CursorUtil.getColumnIndex(query, "trigger_content_update_delay");
+                    int columnIndex22 = CursorUtil.getColumnIndex(query, "trigger_max_content_delay");
+                    int columnIndex23 = CursorUtil.getColumnIndex(query, "content_uri_triggers");
+                    HashMap hashMap = new HashMap();
+                    int i16 = columnIndex13;
+                    HashMap hashMap2 = new HashMap();
+                    while (query.moveToNext()) {
+                        int i17 = columnIndex12;
+                        String string = query.getString(columnIndex);
+                        if (hashMap.containsKey(string)) {
+                            i15 = columnIndex11;
+                        } else {
+                            i15 = columnIndex11;
+                            hashMap.put(string, new ArrayList());
+                        }
+                        String string2 = query.getString(columnIndex);
+                        if (!hashMap2.containsKey(string2)) {
+                            hashMap2.put(string2, new ArrayList());
+                        }
+                        columnIndex12 = i17;
+                        columnIndex11 = i15;
+                    }
+                    int i18 = columnIndex11;
+                    int i19 = columnIndex12;
+                    query.moveToPosition(-1);
+                    RawWorkInfoDao_Impl.this.__fetchRelationshipWorkTagAsjavaLangString(hashMap);
+                    RawWorkInfoDao_Impl.this.__fetchRelationshipWorkProgressAsandroidxWorkData(hashMap2);
+                    ArrayList arrayList = new ArrayList(query.getCount());
+                    while (query.moveToNext()) {
+                        String string3 = columnIndex == -1 ? null : query.getString(columnIndex);
+                        WorkInfo.State intToState = columnIndex2 == -1 ? null : WorkTypeConverters.intToState(query.getInt(columnIndex2));
+                        Data fromByteArray = columnIndex3 == -1 ? null : Data.fromByteArray(query.getBlob(columnIndex3));
+                        long j4 = columnIndex4 == -1 ? 0L : query.getLong(columnIndex4);
+                        long j5 = columnIndex5 == -1 ? 0L : query.getLong(columnIndex5);
+                        long j6 = columnIndex6 == -1 ? 0L : query.getLong(columnIndex6);
+                        boolean z4 = false;
+                        int i20 = columnIndex7 == -1 ? 0 : query.getInt(columnIndex7);
+                        BackoffPolicy intToBackoffPolicy = columnIndex8 == -1 ? null : WorkTypeConverters.intToBackoffPolicy(query.getInt(columnIndex8));
+                        long j7 = columnIndex9 == -1 ? 0L : query.getLong(columnIndex9);
+                        if (columnIndex10 == -1) {
+                            i = i18;
+                            j = 0;
+                        } else {
+                            j = query.getLong(columnIndex10);
+                            i = i18;
+                        }
+                        if (i == -1) {
+                            i18 = i;
+                            i3 = i19;
+                            i2 = 0;
+                        } else {
+                            i2 = query.getInt(i);
+                            i18 = i;
+                            i3 = i19;
+                        }
+                        if (i3 == -1) {
+                            i19 = i3;
+                            i5 = i16;
+                            i4 = 0;
+                        } else {
+                            i4 = query.getInt(i3);
+                            i19 = i3;
+                            i5 = i16;
+                        }
+                        if (i5 == -1) {
+                            i16 = i5;
+                            i6 = columnIndex14;
+                            j2 = 0;
+                        } else {
+                            j2 = query.getLong(i5);
+                            i16 = i5;
+                            i6 = columnIndex14;
+                        }
+                        if (i6 == -1) {
+                            columnIndex14 = i6;
+                            i8 = columnIndex15;
+                            i7 = 0;
+                        } else {
+                            i7 = query.getInt(i6);
+                            columnIndex14 = i6;
+                            i8 = columnIndex15;
+                        }
+                        if (i8 == -1) {
+                            columnIndex15 = i8;
+                            i9 = columnIndex16;
+                            intToNetworkType = null;
+                        } else {
+                            intToNetworkType = WorkTypeConverters.intToNetworkType(query.getInt(i8));
+                            columnIndex15 = i8;
+                            i9 = columnIndex16;
+                        }
+                        if (i9 == -1) {
+                            columnIndex16 = i9;
+                            i10 = columnIndex17;
+                            networkRequest$work_runtime_release = null;
+                        } else {
+                            networkRequest$work_runtime_release = WorkTypeConverters.toNetworkRequest$work_runtime_release(query.getBlob(i9));
+                            columnIndex16 = i9;
+                            i10 = columnIndex17;
+                        }
+                        if (i10 == -1) {
+                            columnIndex17 = i10;
+                            i11 = columnIndex18;
+                            z = false;
+                        } else {
+                            z = query.getInt(i10) != 0;
+                            columnIndex17 = i10;
+                            i11 = columnIndex18;
+                        }
+                        if (i11 == -1) {
+                            columnIndex18 = i11;
+                            i12 = columnIndex19;
+                            z2 = false;
+                        } else {
+                            z2 = query.getInt(i11) != 0;
+                            columnIndex18 = i11;
+                            i12 = columnIndex19;
+                        }
+                        if (i12 == -1) {
+                            columnIndex19 = i12;
+                            i13 = columnIndex20;
+                            z3 = false;
+                        } else {
+                            z3 = query.getInt(i12) != 0;
+                            columnIndex19 = i12;
+                            i13 = columnIndex20;
+                        }
+                        if (i13 != -1 && query.getInt(i13) != 0) {
+                            z4 = true;
+                        }
+                        columnIndex20 = i13;
+                        int i21 = columnIndex21;
+                        boolean z5 = z4;
+                        if (i21 == -1) {
+                            columnIndex21 = i21;
+                            i14 = columnIndex22;
+                            j3 = 0;
+                        } else {
+                            j3 = query.getLong(i21);
+                            columnIndex21 = i21;
+                            i14 = columnIndex22;
+                        }
+                        long j8 = i14 != -1 ? query.getLong(i14) : 0L;
+                        columnIndex22 = i14;
+                        int i22 = columnIndex23;
+                        arrayList.add(new WorkSpec.WorkInfoPojo(string3, intToState, fromByteArray, j4, j5, j6, new Constraints(networkRequest$work_runtime_release, intToNetworkType, z, z2, z3, z5, j3, j8, i22 == -1 ? null : WorkTypeConverters.byteArrayToSetOfTriggers(query.getBlob(i22))), i20, intToBackoffPolicy, j7, j, i2, i4, j2, i7, (ArrayList) hashMap.get(query.getString(columnIndex)), (ArrayList) hashMap2.get(query.getString(columnIndex))));
+                        columnIndex23 = i22;
+                    }
+                    query.close();
+                    return arrayList;
+                } catch (Throwable th) {
+                    query.close();
+                    throw th;
+                }
+            }
+        });
+    }
+
+    @NonNull
+    public static List<Class<?>> getRequiredConverters() {
+        return Collections.emptyList();
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void __fetchRelationshipWorkTagAsjavaLangString(@NonNull HashMap<String, ArrayList<String>> hashMap) {
+        Set<String> keySet = hashMap.keySet();
+        if (keySet.isEmpty()) {
+            return;
+        }
+        if (hashMap.size() > 999) {
+            RelationUtil.recursiveFetchHashMap(hashMap, true, new Function1() { // from class: androidx.work.impl.model.RawWorkInfoDao_Impl$$ExternalSyntheticLambda1
+                @Override // kotlin.jvm.functions.Function1
+                public final Object invoke(Object obj) {
+                    Unit lambda$__fetchRelationshipWorkTagAsjavaLangString$0;
+                    lambda$__fetchRelationshipWorkTagAsjavaLangString$0 = RawWorkInfoDao_Impl.this.lambda$__fetchRelationshipWorkTagAsjavaLangString$0((HashMap) obj);
+                    return lambda$__fetchRelationshipWorkTagAsjavaLangString$0;
+                }
+            });
+            return;
+        }
+        StringBuilder newStringBuilder = StringUtil.newStringBuilder();
+        newStringBuilder.append("SELECT `tag`,`work_spec_id` FROM `WorkTag` WHERE `work_spec_id` IN (");
+        int size = keySet.size();
+        StringUtil.appendPlaceholders(newStringBuilder, size);
+        newStringBuilder.append(")");
+        RoomSQLiteQuery acquire = RoomSQLiteQuery.acquire(newStringBuilder.toString(), size);
+        Iterator<String> it = keySet.iterator();
+        int i = 1;
+        while (it.hasNext()) {
+            acquire.bindString(i, it.next());
+            i++;
+        }
+        Cursor query = DBUtil.query(this.__db, acquire, false, null);
+        try {
+            int columnIndex = CursorUtil.getColumnIndex(query, "work_spec_id");
+            if (columnIndex == -1) {
+                return;
+            }
+            while (query.moveToNext()) {
+                ArrayList<String> arrayList = hashMap.get(query.getString(columnIndex));
+                if (arrayList != null) {
+                    arrayList.add(query.getString(0));
+                }
+            }
+        } finally {
+            query.close();
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public /* synthetic */ Unit lambda$__fetchRelationshipWorkTagAsjavaLangString$0(HashMap hashMap) {
+        __fetchRelationshipWorkTagAsjavaLangString(hashMap);
+        return Unit.INSTANCE;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void __fetchRelationshipWorkProgressAsandroidxWorkData(@NonNull HashMap<String, ArrayList<Data>> hashMap) {
+        Set<String> keySet = hashMap.keySet();
+        if (keySet.isEmpty()) {
+            return;
+        }
+        if (hashMap.size() > 999) {
+            RelationUtil.recursiveFetchHashMap(hashMap, true, new Function1() { // from class: androidx.work.impl.model.RawWorkInfoDao_Impl$$ExternalSyntheticLambda0
+                @Override // kotlin.jvm.functions.Function1
+                public final Object invoke(Object obj) {
+                    Unit lambda$__fetchRelationshipWorkProgressAsandroidxWorkData$1;
+                    lambda$__fetchRelationshipWorkProgressAsandroidxWorkData$1 = RawWorkInfoDao_Impl.this.lambda$__fetchRelationshipWorkProgressAsandroidxWorkData$1((HashMap) obj);
+                    return lambda$__fetchRelationshipWorkProgressAsandroidxWorkData$1;
+                }
+            });
+            return;
+        }
+        StringBuilder newStringBuilder = StringUtil.newStringBuilder();
+        newStringBuilder.append("SELECT `progress`,`work_spec_id` FROM `WorkProgress` WHERE `work_spec_id` IN (");
+        int size = keySet.size();
+        StringUtil.appendPlaceholders(newStringBuilder, size);
+        newStringBuilder.append(")");
+        RoomSQLiteQuery acquire = RoomSQLiteQuery.acquire(newStringBuilder.toString(), size);
+        Iterator<String> it = keySet.iterator();
+        int i = 1;
+        while (it.hasNext()) {
+            acquire.bindString(i, it.next());
+            i++;
+        }
+        Cursor query = DBUtil.query(this.__db, acquire, false, null);
+        try {
+            int columnIndex = CursorUtil.getColumnIndex(query, "work_spec_id");
+            if (columnIndex == -1) {
+                return;
+            }
+            while (query.moveToNext()) {
+                ArrayList<Data> arrayList = hashMap.get(query.getString(columnIndex));
+                if (arrayList != null) {
+                    arrayList.add(Data.fromByteArray(query.getBlob(0)));
+                }
+            }
+        } finally {
+            query.close();
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public /* synthetic */ Unit lambda$__fetchRelationshipWorkProgressAsandroidxWorkData$1(HashMap hashMap) {
+        __fetchRelationshipWorkProgressAsandroidxWorkData(hashMap);
+        return Unit.INSTANCE;
+    }
+}

decompiled-community/sources/androidx/work/impl/model/SystemIdInfo.java

@@ -0,0 +1,82 @@
+package androidx.work.impl.model;
+
+import androidx.annotation.RestrictTo;
+import androidx.room.ColumnInfo;
+import androidx.room.Entity;
+import androidx.room.ForeignKey;
+import kotlin.jvm.internal.Intrinsics;
+
+@Entity(foreignKeys = {@ForeignKey(childColumns = {"work_spec_id"}, entity = WorkSpec.class, onDelete = 5, onUpdate = 5, parentColumns = {"id"})}, primaryKeys = {"work_spec_id", "generation"})
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+/* loaded from: classes.dex */
+public final class SystemIdInfo {
+
+    @ColumnInfo(defaultValue = "0")
+    private final int generation;
+
+    @ColumnInfo(name = "system_id")
+    public final int systemId;
+
+    @ColumnInfo(name = "work_spec_id")
+    public final String workSpecId;
+
+    public static /* synthetic */ SystemIdInfo copy$default(SystemIdInfo systemIdInfo, String str, int i, int i2, int i3, Object obj) {
+        if ((i3 & 1) != 0) {
+            str = systemIdInfo.workSpecId;
+        }
+        if ((i3 & 2) != 0) {
+            i = systemIdInfo.generation;
+        }
+        if ((i3 & 4) != 0) {
+            i2 = systemIdInfo.systemId;
+        }
+        return systemIdInfo.copy(str, i, i2);
+    }
+
+    public final String component1() {
+        return this.workSpecId;
+    }
+
+    public final int component2() {
+        return this.generation;
+    }
+
+    public final int component3() {
+        return this.systemId;
+    }
+
+    public final SystemIdInfo copy(String workSpecId, int i, int i2) {
+        Intrinsics.checkNotNullParameter(workSpecId, "workSpecId");
+        return new SystemIdInfo(workSpecId, i, i2);
+    }
+
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof SystemIdInfo)) {
+            return false;
+        }
+        SystemIdInfo systemIdInfo = (SystemIdInfo) obj;
+        return Intrinsics.areEqual(this.workSpecId, systemIdInfo.workSpecId) && this.generation == systemIdInfo.generation && this.systemId == systemIdInfo.systemId;
+    }
+
+    public final int getGeneration() {
+        return this.generation;
+    }
+
+    public int hashCode() {
+        return (((this.workSpecId.hashCode() * 31) + Integer.hashCode(this.generation)) * 31) + Integer.hashCode(this.systemId);
+    }
+
+    public String toString() {
+        return "SystemIdInfo(workSpecId=" + this.workSpecId + ", generation=" + this.generation + ", systemId=" + this.systemId + ')';
+    }
+
+    public SystemIdInfo(String workSpecId, int i, int i2) {
+        Intrinsics.checkNotNullParameter(workSpecId, "workSpecId");
+        this.workSpecId = workSpecId;
+        this.generation = i;
+        this.systemId = i2;
+    }
+}

decompiled-community/sources/androidx/work/impl/model/SystemIdInfoDao.java

@@ -0,0 +1,50 @@
+package androidx.work.impl.model;
+
+import androidx.room.Dao;
+import androidx.room.Insert;
+import androidx.room.Query;
+import java.util.List;
+import kotlin.jvm.internal.Intrinsics;
+
+@Dao
+/* loaded from: classes.dex */
+public interface SystemIdInfoDao {
+    @Query("SELECT * FROM SystemIdInfo WHERE work_spec_id=:workSpecId AND generation=:generation")
+    SystemIdInfo getSystemIdInfo(String str, int i);
+
+    @Query("SELECT DISTINCT work_spec_id FROM SystemIdInfo")
+    List<String> getWorkSpecIds();
+
+    @Insert(onConflict = 1)
+    void insertSystemIdInfo(SystemIdInfo systemIdInfo);
+
+    @Query("DELETE FROM SystemIdInfo where work_spec_id=:workSpecId")
+    void removeSystemIdInfo(String str);
+
+    @Query("DELETE FROM SystemIdInfo where work_spec_id=:workSpecId AND generation=:generation")
+    void removeSystemIdInfo(String str, int i);
+
+    public static final class DefaultImpls {
+        @Deprecated
+        public static SystemIdInfo getSystemIdInfo(SystemIdInfoDao systemIdInfoDao, WorkGenerationalId id) {
+            Intrinsics.checkNotNullParameter(id, "id");
+            return SystemIdInfoDao.super.getSystemIdInfo(id);
+        }
+
+        @Deprecated
+        public static void removeSystemIdInfo(SystemIdInfoDao systemIdInfoDao, WorkGenerationalId id) {
+            Intrinsics.checkNotNullParameter(id, "id");
+            SystemIdInfoDao.super.removeSystemIdInfo(id);
+        }
+    }
+
+    default SystemIdInfo getSystemIdInfo(WorkGenerationalId id) {
+        Intrinsics.checkNotNullParameter(id, "id");
+        return getSystemIdInfo(id.getWorkSpecId(), id.getGeneration());
+    }
+
+    default void removeSystemIdInfo(WorkGenerationalId id) {
+        Intrinsics.checkNotNullParameter(id, "id");
+        removeSystemIdInfo(id.getWorkSpecId(), id.getGeneration());
+    }
+}

decompiled-community/sources/androidx/work/impl/model/SystemIdInfoDao_Impl.java

@@ -0,0 +1,140 @@
+package androidx.work.impl.model;
+
+import android.database.Cursor;
+import androidx.annotation.NonNull;
+import androidx.room.EntityInsertionAdapter;
+import androidx.room.RoomDatabase;
+import androidx.room.RoomSQLiteQuery;
+import androidx.room.SharedSQLiteStatement;
+import androidx.room.util.CursorUtil;
+import androidx.room.util.DBUtil;
+import androidx.sqlite.db.SupportSQLiteStatement;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/* loaded from: classes.dex */
+public final class SystemIdInfoDao_Impl implements SystemIdInfoDao {
+    private final RoomDatabase __db;
+    private final EntityInsertionAdapter<SystemIdInfo> __insertionAdapterOfSystemIdInfo;
+    private final SharedSQLiteStatement __preparedStmtOfRemoveSystemIdInfo;
+    private final SharedSQLiteStatement __preparedStmtOfRemoveSystemIdInfo_1;
+
+    public SystemIdInfoDao_Impl(@NonNull RoomDatabase roomDatabase) {
+        this.__db = roomDatabase;
+        this.__insertionAdapterOfSystemIdInfo = new EntityInsertionAdapter<SystemIdInfo>(roomDatabase) { // from class: androidx.work.impl.model.SystemIdInfoDao_Impl.1
+            @Override // androidx.room.SharedSQLiteStatement
+            @NonNull
+            public String createQuery() {
+                return "INSERT OR REPLACE INTO `SystemIdInfo` (`work_spec_id`,`generation`,`system_id`) VALUES (?,?,?)";
+            }
+
+            @Override // androidx.room.EntityInsertionAdapter
+            public void bind(@NonNull SupportSQLiteStatement supportSQLiteStatement, @NonNull SystemIdInfo systemIdInfo) {
+                supportSQLiteStatement.bindString(1, systemIdInfo.workSpecId);
+                supportSQLiteStatement.bindLong(2, systemIdInfo.getGeneration());
+                supportSQLiteStatement.bindLong(3, systemIdInfo.systemId);
+            }
+        };
+        this.__preparedStmtOfRemoveSystemIdInfo = new SharedSQLiteStatement(roomDatabase) { // from class: androidx.work.impl.model.SystemIdInfoDao_Impl.2
+            @Override // androidx.room.SharedSQLiteStatement
+            @NonNull
+            public String createQuery() {
+                return "DELETE FROM SystemIdInfo where work_spec_id=? AND generation=?";
+            }
+        };
+        this.__preparedStmtOfRemoveSystemIdInfo_1 = new SharedSQLiteStatement(roomDatabase) { // from class: androidx.work.impl.model.SystemIdInfoDao_Impl.3
+            @Override // androidx.room.SharedSQLiteStatement
+            @NonNull
+            public String createQuery() {
+                return "DELETE FROM SystemIdInfo where work_spec_id=?";
+            }
+        };
+    }
+
+    @Override // androidx.work.impl.model.SystemIdInfoDao
+    public void insertSystemIdInfo(SystemIdInfo systemIdInfo) {
+        this.__db.assertNotSuspendingTransaction();
+        this.__db.beginTransaction();
+        try {
+            this.__insertionAdapterOfSystemIdInfo.insert((EntityInsertionAdapter<SystemIdInfo>) systemIdInfo);
+            this.__db.setTransactionSuccessful();
+        } finally {
+            this.__db.endTransaction();
+        }
+    }
+
+    @Override // androidx.work.impl.model.SystemIdInfoDao
+    public void removeSystemIdInfo(String str, int i) {
+        this.__db.assertNotSuspendingTransaction();
+        SupportSQLiteStatement acquire = this.__preparedStmtOfRemoveSystemIdInfo.acquire();
+        acquire.bindString(1, str);
+        acquire.bindLong(2, i);
+        try {
+            this.__db.beginTransaction();
+            try {
+                acquire.executeUpdateDelete();
+                this.__db.setTransactionSuccessful();
+            } finally {
+                this.__db.endTransaction();
+            }
+        } finally {
+            this.__preparedStmtOfRemoveSystemIdInfo.release(acquire);
+        }
+    }
+
+    @Override // androidx.work.impl.model.SystemIdInfoDao
+    public void removeSystemIdInfo(String str) {
+        this.__db.assertNotSuspendingTransaction();
+        SupportSQLiteStatement acquire = this.__preparedStmtOfRemoveSystemIdInfo_1.acquire();
+        acquire.bindString(1, str);
+        try {
+            this.__db.beginTransaction();
+            try {
+                acquire.executeUpdateDelete();
+                this.__db.setTransactionSuccessful();
+            } finally {
+                this.__db.endTransaction();
+            }
+        } finally {
+            this.__preparedStmtOfRemoveSystemIdInfo_1.release(acquire);
+        }
+    }
+
+    @Override // androidx.work.impl.model.SystemIdInfoDao
+    public SystemIdInfo getSystemIdInfo(String str, int i) {
+        RoomSQLiteQuery acquire = RoomSQLiteQuery.acquire("SELECT * FROM SystemIdInfo WHERE work_spec_id=? AND generation=?", 2);
+        acquire.bindString(1, str);
+        acquire.bindLong(2, i);
+        this.__db.assertNotSuspendingTransaction();
+        Cursor query = DBUtil.query(this.__db, acquire, false, null);
+        try {
+            return query.moveToFirst() ? new SystemIdInfo(query.getString(CursorUtil.getColumnIndexOrThrow(query, "work_spec_id")), query.getInt(CursorUtil.getColumnIndexOrThrow(query, "generation")), query.getInt(CursorUtil.getColumnIndexOrThrow(query, "system_id"))) : null;
+        } finally {
+            query.close();
+            acquire.release();
+        }
+    }
+
+    @Override // androidx.work.impl.model.SystemIdInfoDao
+    public List<String> getWorkSpecIds() {
+        RoomSQLiteQuery acquire = RoomSQLiteQuery.acquire("SELECT DISTINCT work_spec_id FROM SystemIdInfo", 0);
+        this.__db.assertNotSuspendingTransaction();
+        Cursor query = DBUtil.query(this.__db, acquire, false, null);
+        try {
+            ArrayList arrayList = new ArrayList(query.getCount());
+            while (query.moveToNext()) {
+                arrayList.add(query.getString(0));
+            }
+            return arrayList;
+        } finally {
+            query.close();
+            acquire.release();
+        }
+    }
+
+    @NonNull
+    public static List<Class<?>> getRequiredConverters() {
+        return Collections.emptyList();
+    }
+}

decompiled-community/sources/androidx/work/impl/model/SystemIdInfoKt.java

@@ -0,0 +1,11 @@
+package androidx.work.impl.model;
+
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class SystemIdInfoKt {
+    public static final SystemIdInfo systemIdInfo(WorkGenerationalId generationalId, int i) {
+        Intrinsics.checkNotNullParameter(generationalId, "generationalId");
+        return new SystemIdInfo(generationalId.getWorkSpecId(), generationalId.getGeneration(), i);
+    }
+}

decompiled-community/sources/androidx/work/impl/model/WorkGenerationalId.java

@@ -0,0 +1,65 @@
+package androidx.work.impl.model;
+
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class WorkGenerationalId {
+    private final int generation;
+    private final String workSpecId;
+
+    public static /* synthetic */ WorkGenerationalId copy$default(WorkGenerationalId workGenerationalId, String str, int i, int i2, Object obj) {
+        if ((i2 & 1) != 0) {
+            str = workGenerationalId.workSpecId;
+        }
+        if ((i2 & 2) != 0) {
+            i = workGenerationalId.generation;
+        }
+        return workGenerationalId.copy(str, i);
+    }
+
+    public final String component1() {
+        return this.workSpecId;
+    }
+
+    public final int component2() {
+        return this.generation;
+    }
+
+    public final WorkGenerationalId copy(String workSpecId, int i) {
+        Intrinsics.checkNotNullParameter(workSpecId, "workSpecId");
+        return new WorkGenerationalId(workSpecId, i);
+    }
+
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof WorkGenerationalId)) {
+            return false;
+        }
+        WorkGenerationalId workGenerationalId = (WorkGenerationalId) obj;
+        return Intrinsics.areEqual(this.workSpecId, workGenerationalId.workSpecId) && this.generation == workGenerationalId.generation;
+    }
+
+    public final int getGeneration() {
+        return this.generation;
+    }
+
+    public final String getWorkSpecId() {
+        return this.workSpecId;
+    }
+
+    public int hashCode() {
+        return (this.workSpecId.hashCode() * 31) + Integer.hashCode(this.generation);
+    }
+
+    public String toString() {
+        return "WorkGenerationalId(workSpecId=" + this.workSpecId + ", generation=" + this.generation + ')';
+    }
+
+    public WorkGenerationalId(String workSpecId, int i) {
+        Intrinsics.checkNotNullParameter(workSpecId, "workSpecId");
+        this.workSpecId = workSpecId;
+        this.generation = i;
+    }
+}

decompiled-community/sources/androidx/work/impl/model/WorkName.java

@@ -0,0 +1,35 @@
+package androidx.work.impl.model;
+
+import androidx.annotation.RestrictTo;
+import androidx.room.ColumnInfo;
+import androidx.room.Entity;
+import androidx.room.ForeignKey;
+import androidx.room.Index;
+import kotlin.jvm.internal.Intrinsics;
+
+@Entity(foreignKeys = {@ForeignKey(childColumns = {"work_spec_id"}, entity = WorkSpec.class, onDelete = 5, onUpdate = 5, parentColumns = {"id"})}, indices = {@Index({"work_spec_id"})}, primaryKeys = {"name", "work_spec_id"})
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+/* loaded from: classes.dex */
+public final class WorkName {
+
+    @ColumnInfo(name = "name")
+    private final String name;
+
+    @ColumnInfo(name = "work_spec_id")
+    private final String workSpecId;
+
+    public final String getName() {
+        return this.name;
+    }
+
+    public final String getWorkSpecId() {
+        return this.workSpecId;
+    }
+
+    public WorkName(String name, String workSpecId) {
+        Intrinsics.checkNotNullParameter(name, "name");
+        Intrinsics.checkNotNullParameter(workSpecId, "workSpecId");
+        this.name = name;
+        this.workSpecId = workSpecId;
+    }
+}

decompiled-community/sources/androidx/work/impl/model/WorkNameDao.java

@@ -0,0 +1,19 @@
+package androidx.work.impl.model;
+
+import androidx.room.Dao;
+import androidx.room.Insert;
+import androidx.room.Query;
+import java.util.List;
+
+@Dao
+/* loaded from: classes.dex */
+public interface WorkNameDao {
+    @Query("SELECT name FROM workname WHERE work_spec_id=:workSpecId")
+    List<String> getNamesForWorkSpecId(String str);
+
+    @Query("SELECT work_spec_id FROM workname WHERE name=:name")
+    List<String> getWorkSpecIdsWithName(String str);
+
+    @Insert(onConflict = 5)
+    void insert(WorkName workName);
+}

decompiled-community/sources/androidx/work/impl/model/WorkNameDao_Impl.java

@@ -0,0 +1,88 @@
+package androidx.work.impl.model;
+
+import android.database.Cursor;
+import androidx.annotation.NonNull;
+import androidx.room.EntityInsertionAdapter;
+import androidx.room.RoomDatabase;
+import androidx.room.RoomSQLiteQuery;
+import androidx.room.util.DBUtil;
+import androidx.sqlite.db.SupportSQLiteStatement;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/* loaded from: classes.dex */
+public final class WorkNameDao_Impl implements WorkNameDao {
+    private final RoomDatabase __db;
+    private final EntityInsertionAdapter<WorkName> __insertionAdapterOfWorkName;
+
+    public WorkNameDao_Impl(@NonNull RoomDatabase roomDatabase) {
+        this.__db = roomDatabase;
+        this.__insertionAdapterOfWorkName = new EntityInsertionAdapter<WorkName>(roomDatabase) { // from class: androidx.work.impl.model.WorkNameDao_Impl.1
+            @Override // androidx.room.SharedSQLiteStatement
+            @NonNull
+            public String createQuery() {
+                return "INSERT OR IGNORE INTO `WorkName` (`name`,`work_spec_id`) VALUES (?,?)";
+            }
+
+            @Override // androidx.room.EntityInsertionAdapter
+            public void bind(@NonNull SupportSQLiteStatement supportSQLiteStatement, @NonNull WorkName workName) {
+                supportSQLiteStatement.bindString(1, workName.getName());
+                supportSQLiteStatement.bindString(2, workName.getWorkSpecId());
+            }
+        };
+    }
+
+    @Override // androidx.work.impl.model.WorkNameDao
+    public void insert(WorkName workName) {
+        this.__db.assertNotSuspendingTransaction();
+        this.__db.beginTransaction();
+        try {
+            this.__insertionAdapterOfWorkName.insert((EntityInsertionAdapter<WorkName>) workName);
+            this.__db.setTransactionSuccessful();
+        } finally {
+            this.__db.endTransaction();
+        }
+    }
+
+    @Override // androidx.work.impl.model.WorkNameDao
+    public List<String> getWorkSpecIdsWithName(String str) {
+        RoomSQLiteQuery acquire = RoomSQLiteQuery.acquire("SELECT work_spec_id FROM workname WHERE name=?", 1);
+        acquire.bindString(1, str);
+        this.__db.assertNotSuspendingTransaction();
+        Cursor query = DBUtil.query(this.__db, acquire, false, null);
+        try {
+            ArrayList arrayList = new ArrayList(query.getCount());
+            while (query.moveToNext()) {
+                arrayList.add(query.getString(0));
+            }
+            return arrayList;
+        } finally {
+            query.close();
+            acquire.release();
+        }
+    }
+
+    @Override // androidx.work.impl.model.WorkNameDao
+    public List<String> getNamesForWorkSpecId(String str) {
+        RoomSQLiteQuery acquire = RoomSQLiteQuery.acquire("SELECT name FROM workname WHERE work_spec_id=?", 1);
+        acquire.bindString(1, str);
+        this.__db.assertNotSuspendingTransaction();
+        Cursor query = DBUtil.query(this.__db, acquire, false, null);
+        try {
+            ArrayList arrayList = new ArrayList(query.getCount());
+            while (query.moveToNext()) {
+                arrayList.add(query.getString(0));
+            }
+            return arrayList;
+        } finally {
+            query.close();
+            acquire.release();
+        }
+    }
+
+    @NonNull
+    public static List<Class<?>> getRequiredConverters() {
+        return Collections.emptyList();
+    }
+}

decompiled-community/sources/androidx/work/impl/model/WorkProgress.java

@@ -0,0 +1,38 @@
+package androidx.work.impl.model;
+
+import androidx.annotation.RestrictTo;
+import androidx.core.app.NotificationCompat;
+import androidx.room.ColumnInfo;
+import androidx.room.Entity;
+import androidx.room.ForeignKey;
+import androidx.room.PrimaryKey;
+import androidx.work.Data;
+import kotlin.jvm.internal.Intrinsics;
+
+@Entity(foreignKeys = {@ForeignKey(childColumns = {"work_spec_id"}, entity = WorkSpec.class, onDelete = 5, onUpdate = 5, parentColumns = {"id"})})
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+/* loaded from: classes.dex */
+public final class WorkProgress {
+
+    @ColumnInfo(name = NotificationCompat.CATEGORY_PROGRESS)
+    private final Data progress;
+
+    @PrimaryKey
+    @ColumnInfo(name = "work_spec_id")
+    private final String workSpecId;
+
+    public final Data getProgress() {
+        return this.progress;
+    }
+
+    public final String getWorkSpecId() {
+        return this.workSpecId;
+    }
+
+    public WorkProgress(String workSpecId, Data progress) {
+        Intrinsics.checkNotNullParameter(workSpecId, "workSpecId");
+        Intrinsics.checkNotNullParameter(progress, "progress");
+        this.workSpecId = workSpecId;
+        this.progress = progress;
+    }
+}

decompiled-community/sources/androidx/work/impl/model/WorkProgressDao.java

@@ -0,0 +1,24 @@
+package androidx.work.impl.model;
+
+import androidx.annotation.RestrictTo;
+import androidx.room.Dao;
+import androidx.room.Insert;
+import androidx.room.Query;
+import androidx.work.Data;
+
+@Dao
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+/* loaded from: classes.dex */
+public interface WorkProgressDao {
+    @Query("DELETE from WorkProgress where work_spec_id=:workSpecId")
+    void delete(String str);
+
+    @Query("DELETE FROM WorkProgress")
+    void deleteAll();
+
+    @Query("SELECT progress FROM WorkProgress WHERE work_spec_id=:workSpecId")
+    Data getProgressForWorkSpecId(String str);
+
+    @Insert(onConflict = 1)
+    void insert(WorkProgress workProgress);
+}

decompiled-community/sources/androidx/work/impl/model/WorkProgressDao_Impl.java

@@ -0,0 +1,125 @@
+package androidx.work.impl.model;
+
+import android.database.Cursor;
+import androidx.annotation.NonNull;
+import androidx.room.EntityInsertionAdapter;
+import androidx.room.RoomDatabase;
+import androidx.room.RoomSQLiteQuery;
+import androidx.room.SharedSQLiteStatement;
+import androidx.room.util.DBUtil;
+import androidx.sqlite.db.SupportSQLiteStatement;
+import androidx.work.Data;
+import java.util.Collections;
+import java.util.List;
+
+/* loaded from: classes.dex */
+public final class WorkProgressDao_Impl implements WorkProgressDao {
+    private final RoomDatabase __db;
+    private final EntityInsertionAdapter<WorkProgress> __insertionAdapterOfWorkProgress;
+    private final SharedSQLiteStatement __preparedStmtOfDelete;
+    private final SharedSQLiteStatement __preparedStmtOfDeleteAll;
+
+    public WorkProgressDao_Impl(@NonNull RoomDatabase roomDatabase) {
+        this.__db = roomDatabase;
+        this.__insertionAdapterOfWorkProgress = new EntityInsertionAdapter<WorkProgress>(roomDatabase) { // from class: androidx.work.impl.model.WorkProgressDao_Impl.1
+            @Override // androidx.room.SharedSQLiteStatement
+            @NonNull
+            public String createQuery() {
+                return "INSERT OR REPLACE INTO `WorkProgress` (`work_spec_id`,`progress`) VALUES (?,?)";
+            }
+
+            @Override // androidx.room.EntityInsertionAdapter
+            public void bind(@NonNull SupportSQLiteStatement supportSQLiteStatement, @NonNull WorkProgress workProgress) {
+                supportSQLiteStatement.bindString(1, workProgress.getWorkSpecId());
+                supportSQLiteStatement.bindBlob(2, Data.toByteArrayInternalV1(workProgress.getProgress()));
+            }
+        };
+        this.__preparedStmtOfDelete = new SharedSQLiteStatement(roomDatabase) { // from class: androidx.work.impl.model.WorkProgressDao_Impl.2
+            @Override // androidx.room.SharedSQLiteStatement
+            @NonNull
+            public String createQuery() {
+                return "DELETE from WorkProgress where work_spec_id=?";
+            }
+        };
+        this.__preparedStmtOfDeleteAll = new SharedSQLiteStatement(roomDatabase) { // from class: androidx.work.impl.model.WorkProgressDao_Impl.3
+            @Override // androidx.room.SharedSQLiteStatement
+            @NonNull
+            public String createQuery() {
+                return "DELETE FROM WorkProgress";
+            }
+        };
+    }
+
+    @Override // androidx.work.impl.model.WorkProgressDao
+    public void insert(WorkProgress workProgress) {
+        this.__db.assertNotSuspendingTransaction();
+        this.__db.beginTransaction();
+        try {
+            this.__insertionAdapterOfWorkProgress.insert((EntityInsertionAdapter<WorkProgress>) workProgress);
+            this.__db.setTransactionSuccessful();
+        } finally {
+            this.__db.endTransaction();
+        }
+    }
+
+    @Override // androidx.work.impl.model.WorkProgressDao
+    public void delete(String str) {
+        this.__db.assertNotSuspendingTransaction();
+        SupportSQLiteStatement acquire = this.__preparedStmtOfDelete.acquire();
+        acquire.bindString(1, str);
+        try {
+            this.__db.beginTransaction();
+            try {
+                acquire.executeUpdateDelete();
+                this.__db.setTransactionSuccessful();
+            } finally {
+                this.__db.endTransaction();
+            }
+        } finally {
+            this.__preparedStmtOfDelete.release(acquire);
+        }
+    }
+
+    @Override // androidx.work.impl.model.WorkProgressDao
+    public void deleteAll() {
+        this.__db.assertNotSuspendingTransaction();
+        SupportSQLiteStatement acquire = this.__preparedStmtOfDeleteAll.acquire();
+        try {
+            this.__db.beginTransaction();
+            try {
+                acquire.executeUpdateDelete();
+                this.__db.setTransactionSuccessful();
+            } finally {
+                this.__db.endTransaction();
+            }
+        } finally {
+            this.__preparedStmtOfDeleteAll.release(acquire);
+        }
+    }
+
+    @Override // androidx.work.impl.model.WorkProgressDao
+    public Data getProgressForWorkSpecId(String str) {
+        RoomSQLiteQuery acquire = RoomSQLiteQuery.acquire("SELECT progress FROM WorkProgress WHERE work_spec_id=?", 1);
+        acquire.bindString(1, str);
+        this.__db.assertNotSuspendingTransaction();
+        Data data = null;
+        Cursor query = DBUtil.query(this.__db, acquire, false, null);
+        try {
+            if (query.moveToFirst()) {
+                byte[] blob = query.isNull(0) ? null : query.getBlob(0);
+                if (blob != null) {
+                    data = Data.fromByteArray(blob);
+                }
+            }
+            return data;
+        } finally {
+            query.close();
+            acquire.release();
+        }
+    }
+
+    @NonNull
+    public static List<Class<?>> getRequiredConverters() {
+        return Collections.emptyList();
+    }
+}

decompiled-community/sources/androidx/work/impl/model/WorkSpec.java

@@ -0,0 +1,840 @@
+package androidx.work.impl.model;
+
+import androidx.annotation.IntRange;
+import androidx.annotation.RestrictTo;
+import androidx.arch.core.util.Function;
+import androidx.core.app.NotificationCompat;
+import androidx.room.ColumnInfo;
+import androidx.room.Embedded;
+import androidx.room.Entity;
+import androidx.room.Index;
+import androidx.room.PrimaryKey;
+import androidx.room.Relation;
+import androidx.work.BackoffPolicy;
+import androidx.work.Constraints;
+import androidx.work.Data;
+import androidx.work.Logger;
+import androidx.work.OutOfQuotaPolicy;
+import androidx.work.PeriodicWorkRequest;
+import androidx.work.WorkInfo;
+import androidx.work.WorkRequest;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.UUID;
+import kotlin.collections.CollectionsKt__IterablesKt;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+import kotlin.ranges.RangesKt___RangesKt;
+
+@Entity(indices = {@Index({"schedule_requested_at"}), @Index({"last_enqueue_time"})})
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+@SourceDebugExtension({"SMAP\nWorkSpec.kt\nKotlin\n*S Kotlin\n*F\n+ 1 WorkSpec.kt\nandroidx/work/impl/model/WorkSpec\n+ 2 _Collections.kt\nkotlin/collections/CollectionsKt___CollectionsKt\n*L\n1#1,463:1\n1549#2:464\n1620#2,3:465\n*S KotlinDebug\n*F\n+ 1 WorkSpec.kt\nandroidx/work/impl/model/WorkSpec\n*L\n402#1:464\n402#1:465,3\n*E\n"})
+/* loaded from: classes.dex */
+public final class WorkSpec {
+    public static final Companion Companion = new Companion(null);
+    public static final long SCHEDULE_NOT_REQUESTED_YET = -1;
+    private static final String TAG;
+    public static final Function<List<WorkInfoPojo>, List<WorkInfo>> WORK_INFO_MAPPER;
+
+    @ColumnInfo(name = "backoff_delay_duration")
+    public long backoffDelayDuration;
+
+    @ColumnInfo(name = "backoff_policy")
+    public BackoffPolicy backoffPolicy;
+
+    @Embedded
+    public Constraints constraints;
+
+    @ColumnInfo(name = "run_in_foreground")
+    public boolean expedited;
+
+    @ColumnInfo(name = "flex_duration")
+    public long flexDuration;
+
+    @ColumnInfo(defaultValue = "0")
+    private final int generation;
+
+    @PrimaryKey
+    @ColumnInfo(name = "id")
+    public final String id;
+
+    @ColumnInfo(name = "initial_delay")
+    public long initialDelay;
+
+    @ColumnInfo(name = "input")
+    public Data input;
+
+    @ColumnInfo(name = "input_merger_class_name")
+    public String inputMergerClassName;
+
+    @ColumnInfo(name = "interval_duration")
+    public long intervalDuration;
+
+    @ColumnInfo(defaultValue = "-1", name = "last_enqueue_time")
+    public long lastEnqueueTime;
+
+    @ColumnInfo(name = "minimum_retention_duration")
+    public long minimumRetentionDuration;
+
+    @ColumnInfo(defaultValue = "9223372036854775807", name = "next_schedule_time_override")
+    private long nextScheduleTimeOverride;
+
+    @ColumnInfo(defaultValue = "0", name = "next_schedule_time_override_generation")
+    private int nextScheduleTimeOverrideGeneration;
+
+    @ColumnInfo(name = "out_of_quota_policy")
+    public OutOfQuotaPolicy outOfQuotaPolicy;
+
+    @ColumnInfo(name = "output")
+    public Data output;
+
+    @ColumnInfo(defaultValue = "0", name = "period_count")
+    private int periodCount;
+
+    @ColumnInfo(name = "run_attempt_count")
+    public int runAttemptCount;
+
+    @ColumnInfo(name = "schedule_requested_at")
+    public long scheduleRequestedAt;
+
+    @ColumnInfo(name = "state")
+    public WorkInfo.State state;
+
+    @ColumnInfo(defaultValue = "-256", name = "stop_reason")
+    private final int stopReason;
+
+    @ColumnInfo(name = "trace_tag")
+    private String traceTag;
+
+    @ColumnInfo(name = "worker_class_name")
+    public String workerClassName;
+
+    public static /* synthetic */ WorkSpec copy$default(WorkSpec workSpec, String str, WorkInfo.State state, String str2, String str3, Data data, Data data2, long j, long j2, long j3, Constraints constraints, int i, BackoffPolicy backoffPolicy, long j4, long j5, long j6, long j7, boolean z, OutOfQuotaPolicy outOfQuotaPolicy, int i2, int i3, long j8, int i4, int i5, String str4, int i6, Object obj) {
+        String str5 = (i6 & 1) != 0 ? workSpec.id : str;
+        WorkInfo.State state2 = (i6 & 2) != 0 ? workSpec.state : state;
+        String str6 = (i6 & 4) != 0 ? workSpec.workerClassName : str2;
+        String str7 = (i6 & 8) != 0 ? workSpec.inputMergerClassName : str3;
+        Data data3 = (i6 & 16) != 0 ? workSpec.input : data;
+        Data data4 = (i6 & 32) != 0 ? workSpec.output : data2;
+        long j9 = (i6 & 64) != 0 ? workSpec.initialDelay : j;
+        long j10 = (i6 & 128) != 0 ? workSpec.intervalDuration : j2;
+        long j11 = (i6 & 256) != 0 ? workSpec.flexDuration : j3;
+        Constraints constraints2 = (i6 & 512) != 0 ? workSpec.constraints : constraints;
+        return workSpec.copy(str5, state2, str6, str7, data3, data4, j9, j10, j11, constraints2, (i6 & 1024) != 0 ? workSpec.runAttemptCount : i, (i6 & 2048) != 0 ? workSpec.backoffPolicy : backoffPolicy, (i6 & 4096) != 0 ? workSpec.backoffDelayDuration : j4, (i6 & 8192) != 0 ? workSpec.lastEnqueueTime : j5, (i6 & 16384) != 0 ? workSpec.minimumRetentionDuration : j6, (i6 & 32768) != 0 ? workSpec.scheduleRequestedAt : j7, (i6 & 65536) != 0 ? workSpec.expedited : z, (131072 & i6) != 0 ? workSpec.outOfQuotaPolicy : outOfQuotaPolicy, (i6 & 262144) != 0 ? workSpec.periodCount : i2, (i6 & 524288) != 0 ? workSpec.generation : i3, (i6 & 1048576) != 0 ? workSpec.nextScheduleTimeOverride : j8, (i6 & 2097152) != 0 ? workSpec.nextScheduleTimeOverrideGeneration : i4, (4194304 & i6) != 0 ? workSpec.stopReason : i5, (i6 & 8388608) != 0 ? workSpec.traceTag : str4);
+    }
+
+    public final String component1() {
+        return this.id;
+    }
+
+    public final Constraints component10() {
+        return this.constraints;
+    }
+
+    public final int component11() {
+        return this.runAttemptCount;
+    }
+
+    public final BackoffPolicy component12() {
+        return this.backoffPolicy;
+    }
+
+    public final long component13() {
+        return this.backoffDelayDuration;
+    }
+
+    public final long component14() {
+        return this.lastEnqueueTime;
+    }
+
+    public final long component15() {
+        return this.minimumRetentionDuration;
+    }
+
+    public final long component16() {
+        return this.scheduleRequestedAt;
+    }
+
+    public final boolean component17() {
+        return this.expedited;
+    }
+
+    public final OutOfQuotaPolicy component18() {
+        return this.outOfQuotaPolicy;
+    }
+
+    public final int component19() {
+        return this.periodCount;
+    }
+
+    public final WorkInfo.State component2() {
+        return this.state;
+    }
+
+    public final int component20() {
+        return this.generation;
+    }
+
+    public final long component21() {
+        return this.nextScheduleTimeOverride;
+    }
+
+    public final int component22() {
+        return this.nextScheduleTimeOverrideGeneration;
+    }
+
+    public final int component23() {
+        return this.stopReason;
+    }
+
+    public final String component24() {
+        return this.traceTag;
+    }
+
+    public final String component3() {
+        return this.workerClassName;
+    }
+
+    public final String component4() {
+        return this.inputMergerClassName;
+    }
+
+    public final Data component5() {
+        return this.input;
+    }
+
+    public final Data component6() {
+        return this.output;
+    }
+
+    public final long component7() {
+        return this.initialDelay;
+    }
+
+    public final long component8() {
+        return this.intervalDuration;
+    }
+
+    public final long component9() {
+        return this.flexDuration;
+    }
+
+    public final WorkSpec copy(String id, WorkInfo.State state, String workerClassName, String inputMergerClassName, Data input, Data output, long j, long j2, long j3, Constraints constraints, @IntRange(from = 0) int i, BackoffPolicy backoffPolicy, long j4, long j5, long j6, long j7, boolean z, OutOfQuotaPolicy outOfQuotaPolicy, int i2, int i3, long j8, int i4, int i5, String str) {
+        Intrinsics.checkNotNullParameter(id, "id");
+        Intrinsics.checkNotNullParameter(state, "state");
+        Intrinsics.checkNotNullParameter(workerClassName, "workerClassName");
+        Intrinsics.checkNotNullParameter(inputMergerClassName, "inputMergerClassName");
+        Intrinsics.checkNotNullParameter(input, "input");
+        Intrinsics.checkNotNullParameter(output, "output");
+        Intrinsics.checkNotNullParameter(constraints, "constraints");
+        Intrinsics.checkNotNullParameter(backoffPolicy, "backoffPolicy");
+        Intrinsics.checkNotNullParameter(outOfQuotaPolicy, "outOfQuotaPolicy");
+        return new WorkSpec(id, state, workerClassName, inputMergerClassName, input, output, j, j2, j3, constraints, i, backoffPolicy, j4, j5, j6, j7, z, outOfQuotaPolicy, i2, i3, j8, i4, i5, str);
+    }
+
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof WorkSpec)) {
+            return false;
+        }
+        WorkSpec workSpec = (WorkSpec) obj;
+        return Intrinsics.areEqual(this.id, workSpec.id) && this.state == workSpec.state && Intrinsics.areEqual(this.workerClassName, workSpec.workerClassName) && Intrinsics.areEqual(this.inputMergerClassName, workSpec.inputMergerClassName) && Intrinsics.areEqual(this.input, workSpec.input) && Intrinsics.areEqual(this.output, workSpec.output) && this.initialDelay == workSpec.initialDelay && this.intervalDuration == workSpec.intervalDuration && this.flexDuration == workSpec.flexDuration && Intrinsics.areEqual(this.constraints, workSpec.constraints) && this.runAttemptCount == workSpec.runAttemptCount && this.backoffPolicy == workSpec.backoffPolicy && this.backoffDelayDuration == workSpec.backoffDelayDuration && this.lastEnqueueTime == workSpec.lastEnqueueTime && this.minimumRetentionDuration == workSpec.minimumRetentionDuration && this.scheduleRequestedAt == workSpec.scheduleRequestedAt && this.expedited == workSpec.expedited && this.outOfQuotaPolicy == workSpec.outOfQuotaPolicy && this.periodCount == workSpec.periodCount && this.generation == workSpec.generation && this.nextScheduleTimeOverride == workSpec.nextScheduleTimeOverride && this.nextScheduleTimeOverrideGeneration == workSpec.nextScheduleTimeOverrideGeneration && this.stopReason == workSpec.stopReason && Intrinsics.areEqual(this.traceTag, workSpec.traceTag);
+    }
+
+    public final int getGeneration() {
+        return this.generation;
+    }
+
+    public final long getNextScheduleTimeOverride() {
+        return this.nextScheduleTimeOverride;
+    }
+
+    public final int getNextScheduleTimeOverrideGeneration() {
+        return this.nextScheduleTimeOverrideGeneration;
+    }
+
+    public final int getPeriodCount() {
+        return this.periodCount;
+    }
+
+    public final int getStopReason() {
+        return this.stopReason;
+    }
+
+    public final String getTraceTag() {
+        return this.traceTag;
+    }
+
+    public int hashCode() {
+        int hashCode = ((((((((((((((((((((((((((((((((((((((((((((this.id.hashCode() * 31) + this.state.hashCode()) * 31) + this.workerClassName.hashCode()) * 31) + this.inputMergerClassName.hashCode()) * 31) + this.input.hashCode()) * 31) + this.output.hashCode()) * 31) + Long.hashCode(this.initialDelay)) * 31) + Long.hashCode(this.intervalDuration)) * 31) + Long.hashCode(this.flexDuration)) * 31) + this.constraints.hashCode()) * 31) + Integer.hashCode(this.runAttemptCount)) * 31) + this.backoffPolicy.hashCode()) * 31) + Long.hashCode(this.backoffDelayDuration)) * 31) + Long.hashCode(this.lastEnqueueTime)) * 31) + Long.hashCode(this.minimumRetentionDuration)) * 31) + Long.hashCode(this.scheduleRequestedAt)) * 31) + Boolean.hashCode(this.expedited)) * 31) + this.outOfQuotaPolicy.hashCode()) * 31) + Integer.hashCode(this.periodCount)) * 31) + Integer.hashCode(this.generation)) * 31) + Long.hashCode(this.nextScheduleTimeOverride)) * 31) + Integer.hashCode(this.nextScheduleTimeOverrideGeneration)) * 31) + Integer.hashCode(this.stopReason)) * 31;
+        String str = this.traceTag;
+        return hashCode + (str == null ? 0 : str.hashCode());
+    }
+
+    public final boolean isPeriodic() {
+        return this.intervalDuration != 0;
+    }
+
+    public final void setNextScheduleTimeOverride(long j) {
+        this.nextScheduleTimeOverride = j;
+    }
+
+    public final void setNextScheduleTimeOverrideGeneration(int i) {
+        this.nextScheduleTimeOverrideGeneration = i;
+    }
+
+    public final void setPeriodCount(int i) {
+        this.periodCount = i;
+    }
+
+    public final void setTraceTag(String str) {
+        this.traceTag = str;
+    }
+
+    public WorkSpec(String id, WorkInfo.State state, String workerClassName, String inputMergerClassName, Data input, Data output, long j, long j2, long j3, Constraints constraints, @IntRange(from = 0) int i, BackoffPolicy backoffPolicy, long j4, long j5, long j6, long j7, boolean z, OutOfQuotaPolicy outOfQuotaPolicy, int i2, int i3, long j8, int i4, int i5, String str) {
+        Intrinsics.checkNotNullParameter(id, "id");
+        Intrinsics.checkNotNullParameter(state, "state");
+        Intrinsics.checkNotNullParameter(workerClassName, "workerClassName");
+        Intrinsics.checkNotNullParameter(inputMergerClassName, "inputMergerClassName");
+        Intrinsics.checkNotNullParameter(input, "input");
+        Intrinsics.checkNotNullParameter(output, "output");
+        Intrinsics.checkNotNullParameter(constraints, "constraints");
+        Intrinsics.checkNotNullParameter(backoffPolicy, "backoffPolicy");
+        Intrinsics.checkNotNullParameter(outOfQuotaPolicy, "outOfQuotaPolicy");
+        this.id = id;
+        this.state = state;
+        this.workerClassName = workerClassName;
+        this.inputMergerClassName = inputMergerClassName;
+        this.input = input;
+        this.output = output;
+        this.initialDelay = j;
+        this.intervalDuration = j2;
+        this.flexDuration = j3;
+        this.constraints = constraints;
+        this.runAttemptCount = i;
+        this.backoffPolicy = backoffPolicy;
+        this.backoffDelayDuration = j4;
+        this.lastEnqueueTime = j5;
+        this.minimumRetentionDuration = j6;
+        this.scheduleRequestedAt = j7;
+        this.expedited = z;
+        this.outOfQuotaPolicy = outOfQuotaPolicy;
+        this.periodCount = i2;
+        this.generation = i3;
+        this.nextScheduleTimeOverride = j8;
+        this.nextScheduleTimeOverrideGeneration = i4;
+        this.stopReason = i5;
+        this.traceTag = str;
+    }
+
+    /* 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 /* synthetic */ WorkSpec(java.lang.String r36, androidx.work.WorkInfo.State r37, java.lang.String r38, java.lang.String r39, androidx.work.Data r40, androidx.work.Data r41, long r42, long r44, long r46, androidx.work.Constraints r48, int r49, androidx.work.BackoffPolicy r50, long r51, long r53, long r55, long r57, boolean r59, androidx.work.OutOfQuotaPolicy r60, int r61, int r62, long r63, int r65, int r66, java.lang.String r67, int r68, kotlin.jvm.internal.DefaultConstructorMarker r69) {
+        /*
+            Method dump skipped, instructions count: 267
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.work.impl.model.WorkSpec.<init>(java.lang.String, androidx.work.WorkInfo$State, java.lang.String, java.lang.String, androidx.work.Data, androidx.work.Data, long, long, long, androidx.work.Constraints, int, androidx.work.BackoffPolicy, long, long, long, long, boolean, androidx.work.OutOfQuotaPolicy, int, int, long, int, int, java.lang.String, int, kotlin.jvm.internal.DefaultConstructorMarker):void");
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public WorkSpec(String id, String workerClassName_) {
+        this(id, null, workerClassName_, null, null, null, 0L, 0L, 0L, null, 0, null, 0L, 0L, 0L, 0L, false, null, 0, 0, 0L, 0, 0, null, 16777210, null);
+        Intrinsics.checkNotNullParameter(id, "id");
+        Intrinsics.checkNotNullParameter(workerClassName_, "workerClassName_");
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public WorkSpec(String newId, WorkSpec other) {
+        this(newId, other.state, other.workerClassName, other.inputMergerClassName, new Data(other.input), new Data(other.output), other.initialDelay, other.intervalDuration, other.flexDuration, new Constraints(other.constraints), other.runAttemptCount, other.backoffPolicy, other.backoffDelayDuration, other.lastEnqueueTime, other.minimumRetentionDuration, other.scheduleRequestedAt, other.expedited, other.outOfQuotaPolicy, other.periodCount, 0, other.nextScheduleTimeOverride, other.nextScheduleTimeOverrideGeneration, other.stopReason, other.traceTag, 524288, null);
+        Intrinsics.checkNotNullParameter(newId, "newId");
+        Intrinsics.checkNotNullParameter(other, "other");
+    }
+
+    public final void setBackoffDelayDuration(long j) {
+        long coerceIn;
+        if (j > WorkRequest.MAX_BACKOFF_MILLIS) {
+            Logger.get().warning(TAG, "Backoff delay duration exceeds maximum value");
+        }
+        if (j < WorkRequest.MIN_BACKOFF_MILLIS) {
+            Logger.get().warning(TAG, "Backoff delay duration less than minimum value");
+        }
+        coerceIn = RangesKt___RangesKt.coerceIn(j, WorkRequest.MIN_BACKOFF_MILLIS, WorkRequest.MAX_BACKOFF_MILLIS);
+        this.backoffDelayDuration = coerceIn;
+    }
+
+    public final boolean isBackedOff() {
+        return this.state == WorkInfo.State.ENQUEUED && this.runAttemptCount > 0;
+    }
+
+    public final void setPeriodic(long j) {
+        long coerceAtLeast;
+        long coerceAtLeast2;
+        if (j < PeriodicWorkRequest.MIN_PERIODIC_INTERVAL_MILLIS) {
+            Logger.get().warning(TAG, "Interval duration lesser than minimum allowed value; Changed to 900000");
+        }
+        coerceAtLeast = RangesKt___RangesKt.coerceAtLeast(j, PeriodicWorkRequest.MIN_PERIODIC_INTERVAL_MILLIS);
+        coerceAtLeast2 = RangesKt___RangesKt.coerceAtLeast(j, PeriodicWorkRequest.MIN_PERIODIC_INTERVAL_MILLIS);
+        setPeriodic(coerceAtLeast, coerceAtLeast2);
+    }
+
+    public final void setPeriodic(long j, long j2) {
+        long coerceAtLeast;
+        long coerceIn;
+        if (j < PeriodicWorkRequest.MIN_PERIODIC_INTERVAL_MILLIS) {
+            Logger.get().warning(TAG, "Interval duration lesser than minimum allowed value; Changed to 900000");
+        }
+        coerceAtLeast = RangesKt___RangesKt.coerceAtLeast(j, PeriodicWorkRequest.MIN_PERIODIC_INTERVAL_MILLIS);
+        this.intervalDuration = coerceAtLeast;
+        if (j2 < PeriodicWorkRequest.MIN_PERIODIC_FLEX_MILLIS) {
+            Logger.get().warning(TAG, "Flex duration lesser than minimum allowed value; Changed to 300000");
+        }
+        if (j2 > this.intervalDuration) {
+            Logger.get().warning(TAG, "Flex duration greater than interval duration; Changed to " + j);
+        }
+        coerceIn = RangesKt___RangesKt.coerceIn(j2, PeriodicWorkRequest.MIN_PERIODIC_FLEX_MILLIS, this.intervalDuration);
+        this.flexDuration = coerceIn;
+    }
+
+    public final long calculateNextRunTime() {
+        return Companion.calculateNextRunTime(isBackedOff(), this.runAttemptCount, this.backoffPolicy, this.backoffDelayDuration, this.lastEnqueueTime, this.periodCount, isPeriodic(), this.initialDelay, this.flexDuration, this.intervalDuration, this.nextScheduleTimeOverride);
+    }
+
+    public final boolean hasConstraints() {
+        return !Intrinsics.areEqual(Constraints.NONE, this.constraints);
+    }
+
+    public String toString() {
+        return "{WorkSpec: " + this.id + '}';
+    }
+
+    public static final class IdAndState {
+
+        @ColumnInfo(name = "id")
+        public String id;
+
+        @ColumnInfo(name = "state")
+        public WorkInfo.State state;
+
+        public static /* synthetic */ IdAndState copy$default(IdAndState idAndState, String str, WorkInfo.State state, int i, Object obj) {
+            if ((i & 1) != 0) {
+                str = idAndState.id;
+            }
+            if ((i & 2) != 0) {
+                state = idAndState.state;
+            }
+            return idAndState.copy(str, state);
+        }
+
+        public final String component1() {
+            return this.id;
+        }
+
+        public final WorkInfo.State component2() {
+            return this.state;
+        }
+
+        public final IdAndState copy(String id, WorkInfo.State state) {
+            Intrinsics.checkNotNullParameter(id, "id");
+            Intrinsics.checkNotNullParameter(state, "state");
+            return new IdAndState(id, state);
+        }
+
+        public boolean equals(Object obj) {
+            if (this == obj) {
+                return true;
+            }
+            if (!(obj instanceof IdAndState)) {
+                return false;
+            }
+            IdAndState idAndState = (IdAndState) obj;
+            return Intrinsics.areEqual(this.id, idAndState.id) && this.state == idAndState.state;
+        }
+
+        public int hashCode() {
+            return (this.id.hashCode() * 31) + this.state.hashCode();
+        }
+
+        public String toString() {
+            return "IdAndState(id=" + this.id + ", state=" + this.state + ')';
+        }
+
+        public IdAndState(String id, WorkInfo.State state) {
+            Intrinsics.checkNotNullParameter(id, "id");
+            Intrinsics.checkNotNullParameter(state, "state");
+            this.id = id;
+            this.state = state;
+        }
+    }
+
+    public static final class WorkInfoPojo {
+
+        @ColumnInfo(name = "backoff_delay_duration")
+        private long backoffDelayDuration;
+
+        @ColumnInfo(name = "backoff_policy")
+        private BackoffPolicy backoffPolicy;
+
+        @Embedded
+        private final Constraints constraints;
+
+        @ColumnInfo(name = "flex_duration")
+        private final long flexDuration;
+
+        @ColumnInfo(name = "generation")
+        private final int generation;
+
+        @ColumnInfo(name = "id")
+        private final String id;
+
+        @ColumnInfo(name = "initial_delay")
+        private final long initialDelay;
+
+        @ColumnInfo(name = "interval_duration")
+        private final long intervalDuration;
+
+        @ColumnInfo(name = "last_enqueue_time")
+        private long lastEnqueueTime;
+
+        @ColumnInfo(name = "next_schedule_time_override")
+        private final long nextScheduleTimeOverride;
+
+        @ColumnInfo(name = "output")
+        private final Data output;
+
+        @ColumnInfo(defaultValue = "0", name = "period_count")
+        private int periodCount;
+
+        @Relation(entity = WorkProgress.class, entityColumn = "work_spec_id", parentColumn = "id", projection = {NotificationCompat.CATEGORY_PROGRESS})
+        private final List<Data> progress;
+
+        @ColumnInfo(name = "run_attempt_count")
+        private final int runAttemptCount;
+
+        @ColumnInfo(name = "state")
+        private final WorkInfo.State state;
+
+        @ColumnInfo(name = "stop_reason")
+        private final int stopReason;
+
+        @Relation(entity = WorkTag.class, entityColumn = "work_spec_id", parentColumn = "id", projection = {"tag"})
+        private final List<String> tags;
+
+        public final String component1() {
+            return this.id;
+        }
+
+        public final long component10() {
+            return this.backoffDelayDuration;
+        }
+
+        public final long component11() {
+            return this.lastEnqueueTime;
+        }
+
+        public final int component12() {
+            return this.periodCount;
+        }
+
+        public final int component13() {
+            return this.generation;
+        }
+
+        public final long component14() {
+            return this.nextScheduleTimeOverride;
+        }
+
+        public final int component15() {
+            return this.stopReason;
+        }
+
+        public final List<String> component16() {
+            return this.tags;
+        }
+
+        public final List<Data> component17() {
+            return this.progress;
+        }
+
+        public final WorkInfo.State component2() {
+            return this.state;
+        }
+
+        public final Data component3() {
+            return this.output;
+        }
+
+        public final long component4() {
+            return this.initialDelay;
+        }
+
+        public final long component5() {
+            return this.intervalDuration;
+        }
+
+        public final long component6() {
+            return this.flexDuration;
+        }
+
+        public final Constraints component7() {
+            return this.constraints;
+        }
+
+        public final int component8() {
+            return this.runAttemptCount;
+        }
+
+        public final BackoffPolicy component9() {
+            return this.backoffPolicy;
+        }
+
+        public final WorkInfoPojo copy(String id, WorkInfo.State state, Data output, long j, long j2, long j3, Constraints constraints, int i, BackoffPolicy backoffPolicy, long j4, long j5, int i2, int i3, long j6, int i4, List<String> tags, List<Data> progress) {
+            Intrinsics.checkNotNullParameter(id, "id");
+            Intrinsics.checkNotNullParameter(state, "state");
+            Intrinsics.checkNotNullParameter(output, "output");
+            Intrinsics.checkNotNullParameter(constraints, "constraints");
+            Intrinsics.checkNotNullParameter(backoffPolicy, "backoffPolicy");
+            Intrinsics.checkNotNullParameter(tags, "tags");
+            Intrinsics.checkNotNullParameter(progress, "progress");
+            return new WorkInfoPojo(id, state, output, j, j2, j3, constraints, i, backoffPolicy, j4, j5, i2, i3, j6, i4, tags, progress);
+        }
+
+        public boolean equals(Object obj) {
+            if (this == obj) {
+                return true;
+            }
+            if (!(obj instanceof WorkInfoPojo)) {
+                return false;
+            }
+            WorkInfoPojo workInfoPojo = (WorkInfoPojo) obj;
+            return Intrinsics.areEqual(this.id, workInfoPojo.id) && this.state == workInfoPojo.state && Intrinsics.areEqual(this.output, workInfoPojo.output) && this.initialDelay == workInfoPojo.initialDelay && this.intervalDuration == workInfoPojo.intervalDuration && this.flexDuration == workInfoPojo.flexDuration && Intrinsics.areEqual(this.constraints, workInfoPojo.constraints) && this.runAttemptCount == workInfoPojo.runAttemptCount && this.backoffPolicy == workInfoPojo.backoffPolicy && this.backoffDelayDuration == workInfoPojo.backoffDelayDuration && this.lastEnqueueTime == workInfoPojo.lastEnqueueTime && this.periodCount == workInfoPojo.periodCount && this.generation == workInfoPojo.generation && this.nextScheduleTimeOverride == workInfoPojo.nextScheduleTimeOverride && this.stopReason == workInfoPojo.stopReason && Intrinsics.areEqual(this.tags, workInfoPojo.tags) && Intrinsics.areEqual(this.progress, workInfoPojo.progress);
+        }
+
+        public final long getBackoffDelayDuration() {
+            return this.backoffDelayDuration;
+        }
+
+        public final BackoffPolicy getBackoffPolicy() {
+            return this.backoffPolicy;
+        }
+
+        public final Constraints getConstraints() {
+            return this.constraints;
+        }
+
+        public final long getFlexDuration() {
+            return this.flexDuration;
+        }
+
+        public final int getGeneration() {
+            return this.generation;
+        }
+
+        public final String getId() {
+            return this.id;
+        }
+
+        public final long getInitialDelay() {
+            return this.initialDelay;
+        }
+
+        public final long getIntervalDuration() {
+            return this.intervalDuration;
+        }
+
+        public final long getLastEnqueueTime() {
+            return this.lastEnqueueTime;
+        }
+
+        public final long getNextScheduleTimeOverride() {
+            return this.nextScheduleTimeOverride;
+        }
+
+        public final Data getOutput() {
+            return this.output;
+        }
+
+        public final int getPeriodCount() {
+            return this.periodCount;
+        }
+
+        public final List<Data> getProgress() {
+            return this.progress;
+        }
+
+        public final int getRunAttemptCount() {
+            return this.runAttemptCount;
+        }
+
+        public final WorkInfo.State getState() {
+            return this.state;
+        }
+
+        public final int getStopReason() {
+            return this.stopReason;
+        }
+
+        public final List<String> getTags() {
+            return this.tags;
+        }
+
+        public int hashCode() {
+            return (((((((((((((((((((((((((((((((this.id.hashCode() * 31) + this.state.hashCode()) * 31) + this.output.hashCode()) * 31) + Long.hashCode(this.initialDelay)) * 31) + Long.hashCode(this.intervalDuration)) * 31) + Long.hashCode(this.flexDuration)) * 31) + this.constraints.hashCode()) * 31) + Integer.hashCode(this.runAttemptCount)) * 31) + this.backoffPolicy.hashCode()) * 31) + Long.hashCode(this.backoffDelayDuration)) * 31) + Long.hashCode(this.lastEnqueueTime)) * 31) + Integer.hashCode(this.periodCount)) * 31) + Integer.hashCode(this.generation)) * 31) + Long.hashCode(this.nextScheduleTimeOverride)) * 31) + Integer.hashCode(this.stopReason)) * 31) + this.tags.hashCode()) * 31) + this.progress.hashCode();
+        }
+
+        public final boolean isPeriodic() {
+            return this.intervalDuration != 0;
+        }
+
+        public final void setBackoffDelayDuration(long j) {
+            this.backoffDelayDuration = j;
+        }
+
+        public final void setBackoffPolicy(BackoffPolicy backoffPolicy) {
+            Intrinsics.checkNotNullParameter(backoffPolicy, "<set-?>");
+            this.backoffPolicy = backoffPolicy;
+        }
+
+        public final void setLastEnqueueTime(long j) {
+            this.lastEnqueueTime = j;
+        }
+
+        public final void setPeriodCount(int i) {
+            this.periodCount = i;
+        }
+
+        public String toString() {
+            return "WorkInfoPojo(id=" + this.id + ", state=" + this.state + ", output=" + this.output + ", initialDelay=" + this.initialDelay + ", intervalDuration=" + this.intervalDuration + ", flexDuration=" + this.flexDuration + ", constraints=" + this.constraints + ", runAttemptCount=" + this.runAttemptCount + ", backoffPolicy=" + this.backoffPolicy + ", backoffDelayDuration=" + this.backoffDelayDuration + ", lastEnqueueTime=" + this.lastEnqueueTime + ", periodCount=" + this.periodCount + ", generation=" + this.generation + ", nextScheduleTimeOverride=" + this.nextScheduleTimeOverride + ", stopReason=" + this.stopReason + ", tags=" + this.tags + ", progress=" + this.progress + ')';
+        }
+
+        public WorkInfoPojo(String id, WorkInfo.State state, Data output, long j, long j2, long j3, Constraints constraints, int i, BackoffPolicy backoffPolicy, long j4, long j5, int i2, int i3, long j6, int i4, List<String> tags, List<Data> progress) {
+            Intrinsics.checkNotNullParameter(id, "id");
+            Intrinsics.checkNotNullParameter(state, "state");
+            Intrinsics.checkNotNullParameter(output, "output");
+            Intrinsics.checkNotNullParameter(constraints, "constraints");
+            Intrinsics.checkNotNullParameter(backoffPolicy, "backoffPolicy");
+            Intrinsics.checkNotNullParameter(tags, "tags");
+            Intrinsics.checkNotNullParameter(progress, "progress");
+            this.id = id;
+            this.state = state;
+            this.output = output;
+            this.initialDelay = j;
+            this.intervalDuration = j2;
+            this.flexDuration = j3;
+            this.constraints = constraints;
+            this.runAttemptCount = i;
+            this.backoffPolicy = backoffPolicy;
+            this.backoffDelayDuration = j4;
+            this.lastEnqueueTime = j5;
+            this.periodCount = i2;
+            this.generation = i3;
+            this.nextScheduleTimeOverride = j6;
+            this.stopReason = i4;
+            this.tags = tags;
+            this.progress = progress;
+        }
+
+        public /* synthetic */ WorkInfoPojo(String str, WorkInfo.State state, Data data, long j, long j2, long j3, Constraints constraints, int i, BackoffPolicy backoffPolicy, long j4, long j5, int i2, int i3, long j6, int i4, List list, List list2, int i5, DefaultConstructorMarker defaultConstructorMarker) {
+            this(str, state, data, (i5 & 8) != 0 ? 0L : j, (i5 & 16) != 0 ? 0L : j2, (i5 & 32) != 0 ? 0L : j3, constraints, i, (i5 & 256) != 0 ? BackoffPolicy.EXPONENTIAL : backoffPolicy, (i5 & 512) != 0 ? 30000L : j4, (i5 & 1024) != 0 ? 0L : j5, (i5 & 2048) != 0 ? 0 : i2, i3, j6, i4, list, list2);
+        }
+
+        public final boolean isBackedOff() {
+            return this.state == WorkInfo.State.ENQUEUED && this.runAttemptCount > 0;
+        }
+
+        public final WorkInfo toWorkInfo() {
+            Data data = this.progress.isEmpty() ^ true ? this.progress.get(0) : Data.EMPTY;
+            UUID fromString = UUID.fromString(this.id);
+            Intrinsics.checkNotNullExpressionValue(fromString, "fromString(id)");
+            return new WorkInfo(fromString, this.state, new HashSet(this.tags), this.output, data, this.runAttemptCount, this.generation, this.constraints, this.initialDelay, getPeriodicityOrNull(), calculateNextRunTimeMillis(), this.stopReason);
+        }
+
+        private final WorkInfo.PeriodicityInfo getPeriodicityOrNull() {
+            long j = this.intervalDuration;
+            if (j != 0) {
+                return new WorkInfo.PeriodicityInfo(j, this.flexDuration);
+            }
+            return null;
+        }
+
+        private final long calculateNextRunTimeMillis() {
+            if (this.state == WorkInfo.State.ENQUEUED) {
+                return WorkSpec.Companion.calculateNextRunTime(isBackedOff(), this.runAttemptCount, this.backoffPolicy, this.backoffDelayDuration, this.lastEnqueueTime, this.periodCount, isPeriodic(), this.initialDelay, this.flexDuration, this.intervalDuration, this.nextScheduleTimeOverride);
+            }
+            return Long.MAX_VALUE;
+        }
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+
+        public final long calculateNextRunTime(boolean z, int i, BackoffPolicy backoffPolicy, long j, long j2, int i2, boolean z2, long j3, long j4, long j5, long j6) {
+            long coerceAtMost;
+            long coerceAtLeast;
+            Intrinsics.checkNotNullParameter(backoffPolicy, "backoffPolicy");
+            if (j6 != Long.MAX_VALUE && z2) {
+                if (i2 == 0) {
+                    return j6;
+                }
+                coerceAtLeast = RangesKt___RangesKt.coerceAtLeast(j6, PeriodicWorkRequest.MIN_PERIODIC_INTERVAL_MILLIS + j2);
+                return coerceAtLeast;
+            }
+            if (z) {
+                coerceAtMost = RangesKt___RangesKt.coerceAtMost(backoffPolicy == BackoffPolicy.LINEAR ? i * j : (long) Math.scalb(j, i - 1), WorkRequest.MAX_BACKOFF_MILLIS);
+                return j2 + coerceAtMost;
+            }
+            if (!z2) {
+                if (j2 == -1) {
+                    return Long.MAX_VALUE;
+                }
+                return j2 + j3;
+            }
+            long j7 = i2 == 0 ? j2 + j3 : j2 + j5;
+            if (j4 != j5 && i2 == 0) {
+                j7 += j5 - j4;
+            }
+            return j7;
+        }
+    }
+
+    static {
+        String tagWithPrefix = Logger.tagWithPrefix("WorkSpec");
+        Intrinsics.checkNotNullExpressionValue(tagWithPrefix, "tagWithPrefix(\"WorkSpec\")");
+        TAG = tagWithPrefix;
+        WORK_INFO_MAPPER = new Function() { // from class: androidx.work.impl.model.WorkSpec$$ExternalSyntheticLambda0
+            @Override // androidx.arch.core.util.Function
+            public final Object apply(Object obj) {
+                List WORK_INFO_MAPPER$lambda$1;
+                WORK_INFO_MAPPER$lambda$1 = WorkSpec.WORK_INFO_MAPPER$lambda$1((List) obj);
+                return WORK_INFO_MAPPER$lambda$1;
+            }
+        };
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static final List WORK_INFO_MAPPER$lambda$1(List list) {
+        if (list == null) {
+            return null;
+        }
+        List list2 = list;
+        ArrayList arrayList = new ArrayList(CollectionsKt__IterablesKt.collectionSizeOrDefault(list2, 10));
+        Iterator it = list2.iterator();
+        while (it.hasNext()) {
+            arrayList.add(((WorkInfoPojo) it.next()).toWorkInfo());
+        }
+        return arrayList;
+    }
+}

decompiled-community/sources/androidx/work/impl/model/WorkSpecDao.java

@@ -0,0 +1,165 @@
+package androidx.work.impl.model;
+
+import android.annotation.SuppressLint;
+import androidx.lifecycle.LiveData;
+import androidx.room.Dao;
+import androidx.room.Insert;
+import androidx.room.Query;
+import androidx.room.Transaction;
+import androidx.room.Update;
+import androidx.work.Data;
+import androidx.work.WorkInfo;
+import androidx.work.impl.model.WorkSpec;
+import java.util.List;
+import kotlinx.coroutines.flow.Flow;
+
+@Dao
+@SuppressLint({"UnknownNullness"})
+/* loaded from: classes.dex */
+public interface WorkSpecDao {
+    @Query("Select COUNT(*) FROM workspec WHERE LENGTH(content_uri_triggers)<>0 AND state NOT IN (2, 3, 5)")
+    int countNonFinishedContentUriTriggerWorkers();
+
+    @Query("DELETE FROM workspec WHERE id=:id")
+    void delete(String str);
+
+    @Query("SELECT * FROM workspec WHERE state=0 ORDER BY last_enqueue_time LIMIT :maxLimit")
+    List<WorkSpec> getAllEligibleWorkSpecsForScheduling(int i);
+
+    @Query("SELECT id FROM workspec WHERE state NOT IN (2, 3, 5)")
+    List<String> getAllUnfinishedWork();
+
+    @Query("SELECT id FROM workspec")
+    List<String> getAllWorkSpecIds();
+
+    @Query("SELECT id FROM workspec")
+    @Transaction
+    LiveData<List<String>> getAllWorkSpecIdsLiveData();
+
+    @Query("SELECT * FROM workspec WHERE state=0 AND schedule_requested_at=-1 ORDER BY last_enqueue_time LIMIT (SELECT MAX(:schedulerLimit-COUNT(*), 0) FROM workspec WHERE schedule_requested_at<>-1 AND LENGTH(content_uri_triggers)=0 AND state NOT IN (2, 3, 5))")
+    List<WorkSpec> getEligibleWorkForScheduling(int i);
+
+    @Query("SELECT * FROM workspec WHERE state=0 AND schedule_requested_at=-1 AND LENGTH(content_uri_triggers)<>0 ORDER BY last_enqueue_time")
+    List<WorkSpec> getEligibleWorkForSchedulingWithContentUris();
+
+    @Query("SELECT output FROM workspec WHERE id IN\n             (SELECT prerequisite_id FROM dependency WHERE work_spec_id=:id)")
+    List<Data> getInputsFromPrerequisites(String str);
+
+    @Query("SELECT * FROM workspec WHERE last_enqueue_time >= :startingAt AND state IN (2, 3, 5) ORDER BY last_enqueue_time DESC")
+    List<WorkSpec> getRecentlyCompletedWork(long j);
+
+    @Query("SELECT * FROM workspec WHERE state=1")
+    List<WorkSpec> getRunningWork();
+
+    @Query("SELECT schedule_requested_at FROM workspec WHERE id=:id")
+    LiveData<Long> getScheduleRequestedAtLiveData(String str);
+
+    @Query("SELECT * FROM workspec WHERE state=0 AND schedule_requested_at<>-1")
+    List<WorkSpec> getScheduledWork();
+
+    @Query("SELECT state FROM workspec WHERE id=:id")
+    WorkInfo.State getState(String str);
+
+    @Query("SELECT id FROM workspec WHERE state NOT IN (2, 3, 5) AND id IN (SELECT work_spec_id FROM workname WHERE name=:name)")
+    List<String> getUnfinishedWorkWithName(String str);
+
+    @Query("SELECT id FROM workspec WHERE state NOT IN (2, 3, 5) AND id IN (SELECT work_spec_id FROM worktag WHERE tag=:tag)")
+    List<String> getUnfinishedWorkWithTag(String str);
+
+    @Query("SELECT * FROM workspec WHERE id=:id")
+    WorkSpec getWorkSpec(String str);
+
+    @Query("SELECT id, state FROM workspec WHERE id IN (SELECT work_spec_id FROM workname WHERE name=:name)")
+    List<WorkSpec.IdAndState> getWorkSpecIdAndStatesForName(String str);
+
+    @Query("SELECT id, state, output, run_attempt_count, generation, required_network_type, required_network_request, requires_charging, requires_device_idle, requires_battery_not_low, requires_storage_not_low, trigger_content_update_delay, trigger_max_content_delay, content_uri_triggers, initial_delay, interval_duration, flex_duration, backoff_policy, backoff_delay_duration, last_enqueue_time, period_count, next_schedule_time_override, stop_reason FROM workspec WHERE id IN (:ids)")
+    @Transaction
+    Flow getWorkStatusPojoFlowDataForIds(List<String> list);
+
+    @Query("SELECT id, state, output, run_attempt_count, generation, required_network_type, required_network_request, requires_charging, requires_device_idle, requires_battery_not_low, requires_storage_not_low, trigger_content_update_delay, trigger_max_content_delay, content_uri_triggers, initial_delay, interval_duration, flex_duration, backoff_policy, backoff_delay_duration, last_enqueue_time, period_count, next_schedule_time_override, stop_reason FROM workspec WHERE id IN (SELECT work_spec_id FROM workname WHERE name=:name)")
+    @Transaction
+    Flow getWorkStatusPojoFlowForName(String str);
+
+    @Query("SELECT id, state, output, run_attempt_count, generation, required_network_type, required_network_request, requires_charging, requires_device_idle, requires_battery_not_low, requires_storage_not_low, trigger_content_update_delay, trigger_max_content_delay, content_uri_triggers, initial_delay, interval_duration, flex_duration, backoff_policy, backoff_delay_duration, last_enqueue_time, period_count, next_schedule_time_override, stop_reason FROM workspec WHERE id IN\n            (SELECT work_spec_id FROM worktag WHERE tag=:tag)")
+    @Transaction
+    Flow getWorkStatusPojoFlowForTag(String str);
+
+    @Query("SELECT id, state, output, run_attempt_count, generation, required_network_type, required_network_request, requires_charging, requires_device_idle, requires_battery_not_low, requires_storage_not_low, trigger_content_update_delay, trigger_max_content_delay, content_uri_triggers, initial_delay, interval_duration, flex_duration, backoff_policy, backoff_delay_duration, last_enqueue_time, period_count, next_schedule_time_override, stop_reason FROM workspec WHERE id=:id")
+    @Transaction
+    WorkSpec.WorkInfoPojo getWorkStatusPojoForId(String str);
+
+    @Query("SELECT id, state, output, run_attempt_count, generation, required_network_type, required_network_request, requires_charging, requires_device_idle, requires_battery_not_low, requires_storage_not_low, trigger_content_update_delay, trigger_max_content_delay, content_uri_triggers, initial_delay, interval_duration, flex_duration, backoff_policy, backoff_delay_duration, last_enqueue_time, period_count, next_schedule_time_override, stop_reason FROM workspec WHERE id IN (:ids)")
+    @Transaction
+    List<WorkSpec.WorkInfoPojo> getWorkStatusPojoForIds(List<String> list);
+
+    @Query("SELECT id, state, output, run_attempt_count, generation, required_network_type, required_network_request, requires_charging, requires_device_idle, requires_battery_not_low, requires_storage_not_low, trigger_content_update_delay, trigger_max_content_delay, content_uri_triggers, initial_delay, interval_duration, flex_duration, backoff_policy, backoff_delay_duration, last_enqueue_time, period_count, next_schedule_time_override, stop_reason FROM workspec WHERE id IN (SELECT work_spec_id FROM workname WHERE name=:name)")
+    @Transaction
+    List<WorkSpec.WorkInfoPojo> getWorkStatusPojoForName(String str);
+
+    @Query("SELECT id, state, output, run_attempt_count, generation, required_network_type, required_network_request, requires_charging, requires_device_idle, requires_battery_not_low, requires_storage_not_low, trigger_content_update_delay, trigger_max_content_delay, content_uri_triggers, initial_delay, interval_duration, flex_duration, backoff_policy, backoff_delay_duration, last_enqueue_time, period_count, next_schedule_time_override, stop_reason FROM workspec WHERE id IN\n            (SELECT work_spec_id FROM worktag WHERE tag=:tag)")
+    @Transaction
+    List<WorkSpec.WorkInfoPojo> getWorkStatusPojoForTag(String str);
+
+    @Query("SELECT id, state, output, run_attempt_count, generation, required_network_type, required_network_request, requires_charging, requires_device_idle, requires_battery_not_low, requires_storage_not_low, trigger_content_update_delay, trigger_max_content_delay, content_uri_triggers, initial_delay, interval_duration, flex_duration, backoff_policy, backoff_delay_duration, last_enqueue_time, period_count, next_schedule_time_override, stop_reason FROM workspec WHERE id IN (:ids)")
+    @Transaction
+    LiveData<List<WorkSpec.WorkInfoPojo>> getWorkStatusPojoLiveDataForIds(List<String> list);
+
+    @Query("SELECT id, state, output, run_attempt_count, generation, required_network_type, required_network_request, requires_charging, requires_device_idle, requires_battery_not_low, requires_storage_not_low, trigger_content_update_delay, trigger_max_content_delay, content_uri_triggers, initial_delay, interval_duration, flex_duration, backoff_policy, backoff_delay_duration, last_enqueue_time, period_count, next_schedule_time_override, stop_reason FROM workspec WHERE id IN (SELECT work_spec_id FROM workname WHERE name=:name)")
+    @Transaction
+    LiveData<List<WorkSpec.WorkInfoPojo>> getWorkStatusPojoLiveDataForName(String str);
+
+    @Query("SELECT id, state, output, run_attempt_count, generation, required_network_type, required_network_request, requires_charging, requires_device_idle, requires_battery_not_low, requires_storage_not_low, trigger_content_update_delay, trigger_max_content_delay, content_uri_triggers, initial_delay, interval_duration, flex_duration, backoff_policy, backoff_delay_duration, last_enqueue_time, period_count, next_schedule_time_override, stop_reason FROM workspec WHERE id IN\n            (SELECT work_spec_id FROM worktag WHERE tag=:tag)")
+    @Transaction
+    LiveData<List<WorkSpec.WorkInfoPojo>> getWorkStatusPojoLiveDataForTag(String str);
+
+    @Query("SELECT COUNT(*) > 0 FROM workspec WHERE state NOT IN (2, 3, 5) LIMIT 1")
+    Flow hasUnfinishedWorkFlow();
+
+    @Query("UPDATE workspec SET generation=generation+1 WHERE id=:id")
+    void incrementGeneration(String str);
+
+    @Query("UPDATE workspec SET period_count=period_count+1 WHERE id=:id")
+    void incrementPeriodCount(String str);
+
+    @Query("UPDATE workspec SET run_attempt_count=run_attempt_count+1 WHERE id=:id")
+    int incrementWorkSpecRunAttemptCount(String str);
+
+    @Insert(onConflict = 5)
+    void insertWorkSpec(WorkSpec workSpec);
+
+    @Query("UPDATE workspec SET schedule_requested_at=:startTime WHERE id=:id")
+    int markWorkSpecScheduled(String str, long j);
+
+    @Query("DELETE FROM workspec WHERE state IN (2, 3, 5) AND (SELECT COUNT(*)=0 FROM dependency WHERE     prerequisite_id=id AND     work_spec_id NOT IN         (SELECT id FROM workspec WHERE state IN (2, 3, 5)))")
+    void pruneFinishedWorkWithZeroDependentsIgnoringKeepForAtLeast();
+
+    @Query("UPDATE workspec SET schedule_requested_at=-1 WHERE state NOT IN (2, 3, 5)")
+    int resetScheduledState();
+
+    @Query("UPDATE workspec SET next_schedule_time_override=9223372036854775807 WHERE (id=:id AND next_schedule_time_override_generation=:overrideGeneration)")
+    void resetWorkSpecNextScheduleTimeOverride(String str, int i);
+
+    @Query("UPDATE workspec SET run_attempt_count=0 WHERE id=:id")
+    int resetWorkSpecRunAttemptCount(String str);
+
+    @Query("UPDATE workspec SET stop_reason = CASE WHEN state=1 THEN 1 ELSE -256 END, state=5 WHERE id=:id")
+    int setCancelledState(String str);
+
+    @Query("UPDATE workspec SET last_enqueue_time=:enqueueTime WHERE id=:id")
+    void setLastEnqueueTime(String str, long j);
+
+    @Query("UPDATE workspec SET next_schedule_time_override=:nextScheduleTimeOverrideMillis WHERE id=:id")
+    void setNextScheduleTimeOverride(String str, long j);
+
+    @Query("UPDATE workspec SET output=:output WHERE id=:id")
+    void setOutput(String str, Data data);
+
+    @Query("UPDATE workspec SET state=:state WHERE id=:id")
+    int setState(WorkInfo.State state, String str);
+
+    @Query("UPDATE workspec SET stop_reason=:stopReason WHERE id=:id")
+    void setStopReason(String str, int i);
+
+    @Update
+    void updateWorkSpec(WorkSpec workSpec);
+}

decompiled-community/sources/androidx/work/impl/model/WorkSpecDaoKt.java

@@ -0,0 +1,255 @@
+package androidx.work.impl.model;
+
+import com.vungle.ads.internal.protos.Sdk;
+import java.util.UUID;
+import kotlin.Unit;
+import kotlin.collections.CollectionsKt__CollectionsJVMKt;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.ContinuationImpl;
+import kotlin.coroutines.jvm.internal.DebugMetadata;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+import kotlinx.coroutines.CoroutineDispatcher;
+import kotlinx.coroutines.flow.Flow;
+import kotlinx.coroutines.flow.FlowCollector;
+import kotlinx.coroutines.flow.FlowKt;
+
+@SourceDebugExtension({"SMAP\nWorkSpecDao.kt\nKotlin\n*S Kotlin\n*F\n+ 1 WorkSpecDao.kt\nandroidx/work/impl/model/WorkSpecDaoKt\n+ 2 Transform.kt\nkotlinx/coroutines/flow/FlowKt__TransformKt\n+ 3 Emitters.kt\nkotlinx/coroutines/flow/FlowKt__EmittersKt\n+ 4 SafeCollector.common.kt\nkotlinx/coroutines/flow/internal/SafeCollector_commonKt\n*L\n1#1,511:1\n53#2:512\n55#2:516\n53#2:517\n55#2:521\n50#3:513\n55#3:515\n50#3:518\n55#3:520\n107#4:514\n107#4:519\n*S KotlinDebug\n*F\n+ 1 WorkSpecDao.kt\nandroidx/work/impl/model/WorkSpecDaoKt\n*L\n475#1:512\n475#1:516\n491#1:517\n491#1:521\n475#1:513\n475#1:515\n491#1:518\n491#1:520\n475#1:514\n491#1:519\n*E\n"})
+/* loaded from: classes.dex */
+public final class WorkSpecDaoKt {
+    private static final String WORK_INFO_BY_IDS = "SELECT id, state, output, run_attempt_count, generation, required_network_type, required_network_request, requires_charging, requires_device_idle, requires_battery_not_low, requires_storage_not_low, trigger_content_update_delay, trigger_max_content_delay, content_uri_triggers, initial_delay, interval_duration, flex_duration, backoff_policy, backoff_delay_duration, last_enqueue_time, period_count, next_schedule_time_override, stop_reason FROM workspec WHERE id IN (:ids)";
+    private static final String WORK_INFO_BY_NAME = "SELECT id, state, output, run_attempt_count, generation, required_network_type, required_network_request, requires_charging, requires_device_idle, requires_battery_not_low, requires_storage_not_low, trigger_content_update_delay, trigger_max_content_delay, content_uri_triggers, initial_delay, interval_duration, flex_duration, backoff_policy, backoff_delay_duration, last_enqueue_time, period_count, next_schedule_time_override, stop_reason FROM workspec WHERE id IN (SELECT work_spec_id FROM workname WHERE name=:name)";
+    private static final String WORK_INFO_BY_TAG = "SELECT id, state, output, run_attempt_count, generation, required_network_type, required_network_request, requires_charging, requires_device_idle, requires_battery_not_low, requires_storage_not_low, trigger_content_update_delay, trigger_max_content_delay, content_uri_triggers, initial_delay, interval_duration, flex_duration, backoff_policy, backoff_delay_duration, last_enqueue_time, period_count, next_schedule_time_override, stop_reason FROM workspec WHERE id IN\n            (SELECT work_spec_id FROM worktag WHERE tag=:tag)";
+    private static final String WORK_INFO_COLUMNS = "id, state, output, run_attempt_count, generation, required_network_type, required_network_request, requires_charging, requires_device_idle, requires_battery_not_low, requires_storage_not_low, trigger_content_update_delay, trigger_max_content_delay, content_uri_triggers, initial_delay, interval_duration, flex_duration, backoff_policy, backoff_delay_duration, last_enqueue_time, period_count, next_schedule_time_override, stop_reason";
+
+    public static final Flow dedup(final Flow flow, CoroutineDispatcher dispatcher) {
+        Intrinsics.checkNotNullParameter(flow, "<this>");
+        Intrinsics.checkNotNullParameter(dispatcher, "dispatcher");
+        return FlowKt.flowOn(FlowKt.distinctUntilChanged(new Flow() { // from class: androidx.work.impl.model.WorkSpecDaoKt$dedup$$inlined$map$1
+            @Override // kotlinx.coroutines.flow.Flow
+            public Object collect(FlowCollector flowCollector, Continuation continuation) {
+                Object coroutine_suspended;
+                Object collect = Flow.this.collect(new AnonymousClass2(flowCollector), continuation);
+                coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+                return collect == coroutine_suspended ? collect : Unit.INSTANCE;
+            }
+
+            @SourceDebugExtension({"SMAP\nEmitters.kt\nKotlin\n*S Kotlin\n*F\n+ 1 Emitters.kt\nkotlinx/coroutines/flow/FlowKt__EmittersKt$unsafeTransform$1$1\n+ 2 Transform.kt\nkotlinx/coroutines/flow/FlowKt__TransformKt\n+ 3 WorkSpecDao.kt\nandroidx/work/impl/model/WorkSpecDaoKt\n+ 4 _Collections.kt\nkotlin/collections/CollectionsKt___CollectionsKt\n*L\n1#1,222:1\n54#2:223\n491#3:224\n1549#4:225\n1620#4,3:226\n*S KotlinDebug\n*F\n+ 1 WorkSpecDao.kt\nandroidx/work/impl/model/WorkSpecDaoKt\n*L\n491#1:225\n491#1:226,3\n*E\n"})
+            /* renamed from: androidx.work.impl.model.WorkSpecDaoKt$dedup$$inlined$map$1$2, reason: invalid class name */
+            public static final class AnonymousClass2<T> implements FlowCollector {
+                final /* synthetic */ FlowCollector $this_unsafeFlow;
+
+                @DebugMetadata(c = "androidx.work.impl.model.WorkSpecDaoKt$dedup$$inlined$map$1$2", f = "WorkSpecDao.kt", l = {Sdk.SDKError.Reason.STALE_CACHED_RESPONSE_VALUE}, m = "emit")
+                /* renamed from: androidx.work.impl.model.WorkSpecDaoKt$dedup$$inlined$map$1$2$1, reason: invalid class name */
+                public static final class AnonymousClass1 extends ContinuationImpl {
+                    Object L$0;
+                    int label;
+                    /* synthetic */ Object result;
+
+                    public AnonymousClass1(Continuation continuation) {
+                        super(continuation);
+                    }
+
+                    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+                    public final Object invokeSuspend(Object obj) {
+                        this.result = obj;
+                        this.label |= Integer.MIN_VALUE;
+                        return AnonymousClass2.this.emit(null, this);
+                    }
+                }
+
+                public AnonymousClass2(FlowCollector flowCollector) {
+                    this.$this_unsafeFlow = flowCollector;
+                }
+
+                /* JADX WARN: Removed duplicated region for block: B:15:0x0031  */
+                /* JADX WARN: Removed duplicated region for block: B:8:0x0023  */
+                @Override // kotlinx.coroutines.flow.FlowCollector
+                /*
+                    Code decompiled incorrectly, please refer to instructions dump.
+                    To view partially-correct add '--show-bad-code' argument
+                */
+                public final java.lang.Object emit(java.lang.Object r6, kotlin.coroutines.Continuation r7) {
+                    /*
+                        r5 = this;
+                        boolean r0 = r7 instanceof androidx.work.impl.model.WorkSpecDaoKt$dedup$$inlined$map$1.AnonymousClass2.AnonymousClass1
+                        if (r0 == 0) goto L13
+                        r0 = r7
+                        androidx.work.impl.model.WorkSpecDaoKt$dedup$$inlined$map$1$2$1 r0 = (androidx.work.impl.model.WorkSpecDaoKt$dedup$$inlined$map$1.AnonymousClass2.AnonymousClass1) 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:
+                        androidx.work.impl.model.WorkSpecDaoKt$dedup$$inlined$map$1$2$1 r0 = new androidx.work.impl.model.WorkSpecDaoKt$dedup$$inlined$map$1$2$1
+                        r0.<init>(r7)
+                    L18:
+                        java.lang.Object r7 = r0.result
+                        java.lang.Object r1 = kotlin.coroutines.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED()
+                        int r2 = r0.label
+                        r3 = 1
+                        if (r2 == 0) goto L31
+                        if (r2 != r3) goto L29
+                        kotlin.ResultKt.throwOnFailure(r7)
+                        goto L66
+                    L29:
+                        java.lang.IllegalStateException r6 = new java.lang.IllegalStateException
+                        java.lang.String r7 = "call to 'resume' before 'invoke' with coroutine"
+                        r6.<init>(r7)
+                        throw r6
+                    L31:
+                        kotlin.ResultKt.throwOnFailure(r7)
+                        kotlinx.coroutines.flow.FlowCollector r7 = r5.$this_unsafeFlow
+                        java.util.List r6 = (java.util.List) r6
+                        java.lang.Iterable r6 = (java.lang.Iterable) r6
+                        java.util.ArrayList r2 = new java.util.ArrayList
+                        r4 = 10
+                        int r4 = kotlin.collections.CollectionsKt.collectionSizeOrDefault(r6, r4)
+                        r2.<init>(r4)
+                        java.util.Iterator r6 = r6.iterator()
+                    L49:
+                        boolean r4 = r6.hasNext()
+                        if (r4 == 0) goto L5d
+                        java.lang.Object r4 = r6.next()
+                        androidx.work.impl.model.WorkSpec$WorkInfoPojo r4 = (androidx.work.impl.model.WorkSpec.WorkInfoPojo) r4
+                        androidx.work.WorkInfo r4 = r4.toWorkInfo()
+                        r2.add(r4)
+                        goto L49
+                    L5d:
+                        r0.label = r3
+                        java.lang.Object r6 = r7.emit(r2, r0)
+                        if (r6 != r1) goto L66
+                        return r1
+                    L66:
+                        kotlin.Unit r6 = kotlin.Unit.INSTANCE
+                        return r6
+                    */
+                    throw new UnsupportedOperationException("Method not decompiled: androidx.work.impl.model.WorkSpecDaoKt$dedup$$inlined$map$1.AnonymousClass2.emit(java.lang.Object, kotlin.coroutines.Continuation):java.lang.Object");
+                }
+            }
+        }), dispatcher);
+    }
+
+    public static final Flow getWorkStatusPojoFlowDataForIds(WorkSpecDao workSpecDao, UUID id) {
+        Intrinsics.checkNotNullParameter(workSpecDao, "<this>");
+        Intrinsics.checkNotNullParameter(id, "id");
+        final Flow workStatusPojoFlowDataForIds = workSpecDao.getWorkStatusPojoFlowDataForIds(CollectionsKt__CollectionsJVMKt.listOf(String.valueOf(id)));
+        return FlowKt.distinctUntilChanged(new Flow() { // from class: androidx.work.impl.model.WorkSpecDaoKt$getWorkStatusPojoFlowDataForIds$$inlined$map$1
+            @Override // kotlinx.coroutines.flow.Flow
+            public Object collect(FlowCollector flowCollector, Continuation continuation) {
+                Object coroutine_suspended;
+                Object collect = Flow.this.collect(new AnonymousClass2(flowCollector), continuation);
+                coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+                return collect == coroutine_suspended ? collect : Unit.INSTANCE;
+            }
+
+            @SourceDebugExtension({"SMAP\nEmitters.kt\nKotlin\n*S Kotlin\n*F\n+ 1 Emitters.kt\nkotlinx/coroutines/flow/FlowKt__EmittersKt$unsafeTransform$1$1\n+ 2 Transform.kt\nkotlinx/coroutines/flow/FlowKt__TransformKt\n+ 3 WorkSpecDao.kt\nandroidx/work/impl/model/WorkSpecDaoKt\n*L\n1#1,222:1\n54#2:223\n475#3:224\n*E\n"})
+            /* renamed from: androidx.work.impl.model.WorkSpecDaoKt$getWorkStatusPojoFlowDataForIds$$inlined$map$1$2, reason: invalid class name */
+            public static final class AnonymousClass2<T> implements FlowCollector {
+                final /* synthetic */ FlowCollector $this_unsafeFlow;
+
+                @DebugMetadata(c = "androidx.work.impl.model.WorkSpecDaoKt$getWorkStatusPojoFlowDataForIds$$inlined$map$1$2", f = "WorkSpecDao.kt", l = {Sdk.SDKError.Reason.STALE_CACHED_RESPONSE_VALUE}, m = "emit")
+                /* renamed from: androidx.work.impl.model.WorkSpecDaoKt$getWorkStatusPojoFlowDataForIds$$inlined$map$1$2$1, reason: invalid class name */
+                public static final class AnonymousClass1 extends ContinuationImpl {
+                    Object L$0;
+                    int label;
+                    /* synthetic */ Object result;
+
+                    public AnonymousClass1(Continuation continuation) {
+                        super(continuation);
+                    }
+
+                    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+                    public final Object invokeSuspend(Object obj) {
+                        this.result = obj;
+                        this.label |= Integer.MIN_VALUE;
+                        return AnonymousClass2.this.emit(null, this);
+                    }
+                }
+
+                public AnonymousClass2(FlowCollector flowCollector) {
+                    this.$this_unsafeFlow = flowCollector;
+                }
+
+                /* JADX WARN: Removed duplicated region for block: B:15:0x0031  */
+                /* JADX WARN: Removed duplicated region for block: B:8:0x0023  */
+                @Override // kotlinx.coroutines.flow.FlowCollector
+                /*
+                    Code decompiled incorrectly, please refer to instructions dump.
+                    To view partially-correct add '--show-bad-code' argument
+                */
+                public final java.lang.Object emit(java.lang.Object r5, kotlin.coroutines.Continuation r6) {
+                    /*
+                        r4 = this;
+                        boolean r0 = r6 instanceof androidx.work.impl.model.WorkSpecDaoKt$getWorkStatusPojoFlowDataForIds$$inlined$map$1.AnonymousClass2.AnonymousClass1
+                        if (r0 == 0) goto L13
+                        r0 = r6
+                        androidx.work.impl.model.WorkSpecDaoKt$getWorkStatusPojoFlowDataForIds$$inlined$map$1$2$1 r0 = (androidx.work.impl.model.WorkSpecDaoKt$getWorkStatusPojoFlowDataForIds$$inlined$map$1.AnonymousClass2.AnonymousClass1) 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:
+                        androidx.work.impl.model.WorkSpecDaoKt$getWorkStatusPojoFlowDataForIds$$inlined$map$1$2$1 r0 = new androidx.work.impl.model.WorkSpecDaoKt$getWorkStatusPojoFlowDataForIds$$inlined$map$1$2$1
+                        r0.<init>(r6)
+                    L18:
+                        java.lang.Object r6 = r0.result
+                        java.lang.Object r1 = kotlin.coroutines.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED()
+                        int r2 = r0.label
+                        r3 = 1
+                        if (r2 == 0) goto L31
+                        if (r2 != r3) goto L29
+                        kotlin.ResultKt.throwOnFailure(r6)
+                        goto L4f
+                    L29:
+                        java.lang.IllegalStateException r5 = new java.lang.IllegalStateException
+                        java.lang.String r6 = "call to 'resume' before 'invoke' with coroutine"
+                        r5.<init>(r6)
+                        throw r5
+                    L31:
+                        kotlin.ResultKt.throwOnFailure(r6)
+                        kotlinx.coroutines.flow.FlowCollector r6 = r4.$this_unsafeFlow
+                        java.util.List r5 = (java.util.List) r5
+                        java.lang.Object r5 = kotlin.collections.CollectionsKt.firstOrNull(r5)
+                        androidx.work.impl.model.WorkSpec$WorkInfoPojo r5 = (androidx.work.impl.model.WorkSpec.WorkInfoPojo) r5
+                        if (r5 == 0) goto L45
+                        androidx.work.WorkInfo r5 = r5.toWorkInfo()
+                        goto L46
+                    L45:
+                        r5 = 0
+                    L46:
+                        r0.label = r3
+                        java.lang.Object r5 = r6.emit(r5, r0)
+                        if (r5 != r1) goto L4f
+                        return r1
+                    L4f:
+                        kotlin.Unit r5 = kotlin.Unit.INSTANCE
+                        return r5
+                    */
+                    throw new UnsupportedOperationException("Method not decompiled: androidx.work.impl.model.WorkSpecDaoKt$getWorkStatusPojoFlowDataForIds$$inlined$map$1.AnonymousClass2.emit(java.lang.Object, kotlin.coroutines.Continuation):java.lang.Object");
+                }
+            }
+        });
+    }
+
+    public static final Flow getWorkStatusPojoFlowForName(WorkSpecDao workSpecDao, CoroutineDispatcher dispatcher, String name) {
+        Intrinsics.checkNotNullParameter(workSpecDao, "<this>");
+        Intrinsics.checkNotNullParameter(dispatcher, "dispatcher");
+        Intrinsics.checkNotNullParameter(name, "name");
+        return dedup(workSpecDao.getWorkStatusPojoFlowForName(name), dispatcher);
+    }
+
+    public static final Flow getWorkStatusPojoFlowForTag(WorkSpecDao workSpecDao, CoroutineDispatcher dispatcher, String tag) {
+        Intrinsics.checkNotNullParameter(workSpecDao, "<this>");
+        Intrinsics.checkNotNullParameter(dispatcher, "dispatcher");
+        Intrinsics.checkNotNullParameter(tag, "tag");
+        return dedup(workSpecDao.getWorkStatusPojoFlowForTag(tag), dispatcher);
+    }
+}

decompiled-community/sources/androidx/work/impl/model/WorkSpecKt.java

@@ -0,0 +1,13 @@
+package androidx.work.impl.model;
+
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes.dex */
+public final class WorkSpecKt {
+    private static final long NOT_ENQUEUED = -1;
+
+    public static final WorkGenerationalId generationalId(WorkSpec workSpec) {
+        Intrinsics.checkNotNullParameter(workSpec, "<this>");
+        return new WorkGenerationalId(workSpec.id, workSpec.getGeneration());
+    }
+}

decompiled-community/sources/androidx/work/impl/model/WorkTag.java

@@ -0,0 +1,35 @@
+package androidx.work.impl.model;
+
+import androidx.annotation.RestrictTo;
+import androidx.room.ColumnInfo;
+import androidx.room.Entity;
+import androidx.room.ForeignKey;
+import androidx.room.Index;
+import kotlin.jvm.internal.Intrinsics;
+
+@Entity(foreignKeys = {@ForeignKey(childColumns = {"work_spec_id"}, entity = WorkSpec.class, onDelete = 5, onUpdate = 5, parentColumns = {"id"})}, indices = {@Index({"work_spec_id"})}, primaryKeys = {"tag", "work_spec_id"})
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+/* loaded from: classes.dex */
+public final class WorkTag {
+
+    @ColumnInfo(name = "tag")
+    private final String tag;
+
+    @ColumnInfo(name = "work_spec_id")
+    private final String workSpecId;
+
+    public final String getTag() {
+        return this.tag;
+    }
+
+    public final String getWorkSpecId() {
+        return this.workSpecId;
+    }
+
+    public WorkTag(String tag, String workSpecId) {
+        Intrinsics.checkNotNullParameter(tag, "tag");
+        Intrinsics.checkNotNullParameter(workSpecId, "workSpecId");
+        this.tag = tag;
+        this.workSpecId = workSpecId;
+    }
+}

decompiled-community/sources/androidx/work/impl/model/WorkTagDao.java

@@ -0,0 +1,45 @@
+package androidx.work.impl.model;
+
+import androidx.room.Dao;
+import androidx.room.Insert;
+import androidx.room.Query;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+
+@Dao
+@SourceDebugExtension({"SMAP\nWorkTagDao.kt\nKotlin\n*S Kotlin\n*F\n+ 1 WorkTagDao.kt\nandroidx/work/impl/model/WorkTagDao\n+ 2 _Collections.kt\nkotlin/collections/CollectionsKt___CollectionsKt\n*L\n1#1,63:1\n1855#2,2:64\n*S KotlinDebug\n*F\n+ 1 WorkTagDao.kt\nandroidx/work/impl/model/WorkTagDao\n*L\n60#1:64,2\n*E\n"})
+/* loaded from: classes.dex */
+public interface WorkTagDao {
+    @Query("DELETE FROM worktag WHERE work_spec_id=:id")
+    void deleteByWorkSpecId(String str);
+
+    @Query("SELECT DISTINCT tag FROM worktag WHERE work_spec_id=:id")
+    List<String> getTagsForWorkSpecId(String str);
+
+    @Query("SELECT work_spec_id FROM worktag WHERE tag=:tag")
+    List<String> getWorkSpecIdsWithTag(String str);
+
+    @Insert(onConflict = 5)
+    void insert(WorkTag workTag);
+
+    public static final class DefaultImpls {
+        @Deprecated
+        public static void insertTags(WorkTagDao workTagDao, String id, Set<String> tags) {
+            Intrinsics.checkNotNullParameter(id, "id");
+            Intrinsics.checkNotNullParameter(tags, "tags");
+            WorkTagDao.super.insertTags(id, tags);
+        }
+    }
+
+    default void insertTags(String id, Set<String> tags) {
+        Intrinsics.checkNotNullParameter(id, "id");
+        Intrinsics.checkNotNullParameter(tags, "tags");
+        Iterator<T> it = tags.iterator();
+        while (it.hasNext()) {
+            insert(new WorkTag((String) it.next(), id));
+        }
+    }
+}

decompiled-community/sources/androidx/work/impl/model/WorkTagDao_Impl.java

@@ -0,0 +1,115 @@
+package androidx.work.impl.model;
+
+import android.database.Cursor;
+import androidx.annotation.NonNull;
+import androidx.room.EntityInsertionAdapter;
+import androidx.room.RoomDatabase;
+import androidx.room.RoomSQLiteQuery;
+import androidx.room.SharedSQLiteStatement;
+import androidx.room.util.DBUtil;
+import androidx.sqlite.db.SupportSQLiteStatement;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/* loaded from: classes.dex */
+public final class WorkTagDao_Impl implements WorkTagDao {
+    private final RoomDatabase __db;
+    private final EntityInsertionAdapter<WorkTag> __insertionAdapterOfWorkTag;
+    private final SharedSQLiteStatement __preparedStmtOfDeleteByWorkSpecId;
+
+    public WorkTagDao_Impl(@NonNull RoomDatabase roomDatabase) {
+        this.__db = roomDatabase;
+        this.__insertionAdapterOfWorkTag = new EntityInsertionAdapter<WorkTag>(roomDatabase) { // from class: androidx.work.impl.model.WorkTagDao_Impl.1
+            @Override // androidx.room.SharedSQLiteStatement
+            @NonNull
+            public String createQuery() {
+                return "INSERT OR IGNORE INTO `WorkTag` (`tag`,`work_spec_id`) VALUES (?,?)";
+            }
+
+            @Override // androidx.room.EntityInsertionAdapter
+            public void bind(@NonNull SupportSQLiteStatement supportSQLiteStatement, @NonNull WorkTag workTag) {
+                supportSQLiteStatement.bindString(1, workTag.getTag());
+                supportSQLiteStatement.bindString(2, workTag.getWorkSpecId());
+            }
+        };
+        this.__preparedStmtOfDeleteByWorkSpecId = new SharedSQLiteStatement(roomDatabase) { // from class: androidx.work.impl.model.WorkTagDao_Impl.2
+            @Override // androidx.room.SharedSQLiteStatement
+            @NonNull
+            public String createQuery() {
+                return "DELETE FROM worktag WHERE work_spec_id=?";
+            }
+        };
+    }
+
+    @Override // androidx.work.impl.model.WorkTagDao
+    public void insert(WorkTag workTag) {
+        this.__db.assertNotSuspendingTransaction();
+        this.__db.beginTransaction();
+        try {
+            this.__insertionAdapterOfWorkTag.insert((EntityInsertionAdapter<WorkTag>) workTag);
+            this.__db.setTransactionSuccessful();
+        } finally {
+            this.__db.endTransaction();
+        }
+    }
+
+    @Override // androidx.work.impl.model.WorkTagDao
+    public void deleteByWorkSpecId(String str) {
+        this.__db.assertNotSuspendingTransaction();
+        SupportSQLiteStatement acquire = this.__preparedStmtOfDeleteByWorkSpecId.acquire();
+        acquire.bindString(1, str);
+        try {
+            this.__db.beginTransaction();
+            try {
+                acquire.executeUpdateDelete();
+                this.__db.setTransactionSuccessful();
+            } finally {
+                this.__db.endTransaction();
+            }
+        } finally {
+            this.__preparedStmtOfDeleteByWorkSpecId.release(acquire);
+        }
+    }
+
+    @Override // androidx.work.impl.model.WorkTagDao
+    public List<String> getWorkSpecIdsWithTag(String str) {
+        RoomSQLiteQuery acquire = RoomSQLiteQuery.acquire("SELECT work_spec_id FROM worktag WHERE tag=?", 1);
+        acquire.bindString(1, str);
+        this.__db.assertNotSuspendingTransaction();
+        Cursor query = DBUtil.query(this.__db, acquire, false, null);
+        try {
+            ArrayList arrayList = new ArrayList(query.getCount());
+            while (query.moveToNext()) {
+                arrayList.add(query.getString(0));
+            }
+            return arrayList;
+        } finally {
+            query.close();
+            acquire.release();
+        }
+    }
+
+    @Override // androidx.work.impl.model.WorkTagDao
+    public List<String> getTagsForWorkSpecId(String str) {
+        RoomSQLiteQuery acquire = RoomSQLiteQuery.acquire("SELECT DISTINCT tag FROM worktag WHERE work_spec_id=?", 1);
+        acquire.bindString(1, str);
+        this.__db.assertNotSuspendingTransaction();
+        Cursor query = DBUtil.query(this.__db, acquire, false, null);
+        try {
+            ArrayList arrayList = new ArrayList(query.getCount());
+            while (query.moveToNext()) {
+                arrayList.add(query.getString(0));
+            }
+            return arrayList;
+        } finally {
+            query.close();
+            acquire.release();
+        }
+    }
+
+    @NonNull
+    public static List<Class<?>> getRequiredConverters() {
+        return Collections.emptyList();
+    }
+}

decompiled-community/sources/androidx/work/impl/model/WorkTypeConverters.java

@@ -0,0 +1,426 @@
+package androidx.work.impl.model;
+
+import android.net.NetworkRequest;
+import android.net.Uri;
+import android.os.Build;
+import androidx.room.TypeConverter;
+import androidx.work.BackoffPolicy;
+import androidx.work.Constraints;
+import androidx.work.NetworkType;
+import androidx.work.OutOfQuotaPolicy;
+import androidx.work.WorkInfo;
+import androidx.work.impl.utils.NetworkRequest28;
+import androidx.work.impl.utils.NetworkRequestCompat;
+import androidx.work.impl.utils.NetworkRequestCompatKt;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.util.LinkedHashSet;
+import java.util.Set;
+import kotlin.NoWhenBranchMatchedException;
+import kotlin.Unit;
+import kotlin.io.CloseableKt;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+
+@SourceDebugExtension({"SMAP\nWorkTypeConverters.kt\nKotlin\n*S Kotlin\n*F\n+ 1 WorkTypeConverters.kt\nandroidx/work/impl/model/WorkTypeConverters\n+ 2 fake.kt\nkotlin/jvm/internal/FakeKt\n+ 3 _Arrays.kt\nkotlin/collections/ArraysKt___ArraysKt\n*L\n1#1,315:1\n1#2:316\n13600#3,2:317\n13600#3,2:319\n*S KotlinDebug\n*F\n+ 1 WorkTypeConverters.kt\nandroidx/work/impl/model/WorkTypeConverters\n*L\n307#1:317,2\n309#1:319,2\n*E\n"})
+/* loaded from: classes.dex */
+public final class WorkTypeConverters {
+    public static final WorkTypeConverters INSTANCE = new WorkTypeConverters();
+
+    public /* synthetic */ class WhenMappings {
+        public static final /* synthetic */ int[] $EnumSwitchMapping$0;
+        public static final /* synthetic */ int[] $EnumSwitchMapping$1;
+        public static final /* synthetic */ int[] $EnumSwitchMapping$2;
+        public static final /* synthetic */ int[] $EnumSwitchMapping$3;
+
+        static {
+            int[] iArr = new int[WorkInfo.State.values().length];
+            try {
+                iArr[WorkInfo.State.ENQUEUED.ordinal()] = 1;
+            } catch (NoSuchFieldError unused) {
+            }
+            try {
+                iArr[WorkInfo.State.RUNNING.ordinal()] = 2;
+            } catch (NoSuchFieldError unused2) {
+            }
+            try {
+                iArr[WorkInfo.State.SUCCEEDED.ordinal()] = 3;
+            } catch (NoSuchFieldError unused3) {
+            }
+            try {
+                iArr[WorkInfo.State.FAILED.ordinal()] = 4;
+            } catch (NoSuchFieldError unused4) {
+            }
+            try {
+                iArr[WorkInfo.State.BLOCKED.ordinal()] = 5;
+            } catch (NoSuchFieldError unused5) {
+            }
+            try {
+                iArr[WorkInfo.State.CANCELLED.ordinal()] = 6;
+            } catch (NoSuchFieldError unused6) {
+            }
+            $EnumSwitchMapping$0 = iArr;
+            int[] iArr2 = new int[BackoffPolicy.values().length];
+            try {
+                iArr2[BackoffPolicy.EXPONENTIAL.ordinal()] = 1;
+            } catch (NoSuchFieldError unused7) {
+            }
+            try {
+                iArr2[BackoffPolicy.LINEAR.ordinal()] = 2;
+            } catch (NoSuchFieldError unused8) {
+            }
+            $EnumSwitchMapping$1 = iArr2;
+            int[] iArr3 = new int[NetworkType.values().length];
+            try {
+                iArr3[NetworkType.NOT_REQUIRED.ordinal()] = 1;
+            } catch (NoSuchFieldError unused9) {
+            }
+            try {
+                iArr3[NetworkType.CONNECTED.ordinal()] = 2;
+            } catch (NoSuchFieldError unused10) {
+            }
+            try {
+                iArr3[NetworkType.UNMETERED.ordinal()] = 3;
+            } catch (NoSuchFieldError unused11) {
+            }
+            try {
+                iArr3[NetworkType.NOT_ROAMING.ordinal()] = 4;
+            } catch (NoSuchFieldError unused12) {
+            }
+            try {
+                iArr3[NetworkType.METERED.ordinal()] = 5;
+            } catch (NoSuchFieldError unused13) {
+            }
+            $EnumSwitchMapping$2 = iArr3;
+            int[] iArr4 = new int[OutOfQuotaPolicy.values().length];
+            try {
+                iArr4[OutOfQuotaPolicy.RUN_AS_NON_EXPEDITED_WORK_REQUEST.ordinal()] = 1;
+            } catch (NoSuchFieldError unused14) {
+            }
+            try {
+                iArr4[OutOfQuotaPolicy.DROP_WORK_REQUEST.ordinal()] = 2;
+            } catch (NoSuchFieldError unused15) {
+            }
+            $EnumSwitchMapping$3 = iArr4;
+        }
+    }
+
+    private WorkTypeConverters() {
+    }
+
+    public static final class StateIds {
+        public static final int BLOCKED = 4;
+        public static final int CANCELLED = 5;
+        public static final String COMPLETED_STATES = "(2, 3, 5)";
+        public static final int ENQUEUED = 0;
+        public static final int FAILED = 3;
+        public static final StateIds INSTANCE = new StateIds();
+        public static final int RUNNING = 1;
+        public static final int SUCCEEDED = 2;
+
+        private StateIds() {
+        }
+    }
+
+    public static final class BackoffPolicyIds {
+        public static final int EXPONENTIAL = 0;
+        public static final BackoffPolicyIds INSTANCE = new BackoffPolicyIds();
+        public static final int LINEAR = 1;
+
+        private BackoffPolicyIds() {
+        }
+    }
+
+    public static final class NetworkTypeIds {
+        public static final int CONNECTED = 1;
+        public static final NetworkTypeIds INSTANCE = new NetworkTypeIds();
+        public static final int METERED = 4;
+        public static final int NOT_REQUIRED = 0;
+        public static final int NOT_ROAMING = 3;
+        public static final int TEMPORARILY_UNMETERED = 5;
+        public static final int UNMETERED = 2;
+
+        private NetworkTypeIds() {
+        }
+    }
+
+    public static final class OutOfPolicyIds {
+        public static final int DROP_WORK_REQUEST = 1;
+        public static final OutOfPolicyIds INSTANCE = new OutOfPolicyIds();
+        public static final int RUN_AS_NON_EXPEDITED_WORK_REQUEST = 0;
+
+        private OutOfPolicyIds() {
+        }
+    }
+
+    @TypeConverter
+    public static final int stateToInt(WorkInfo.State state) {
+        Intrinsics.checkNotNullParameter(state, "state");
+        switch (WhenMappings.$EnumSwitchMapping$0[state.ordinal()]) {
+            case 1:
+                return 0;
+            case 2:
+                return 1;
+            case 3:
+                return 2;
+            case 4:
+                return 3;
+            case 5:
+                return 4;
+            case 6:
+                return 5;
+            default:
+                throw new NoWhenBranchMatchedException();
+        }
+    }
+
+    @TypeConverter
+    public static final WorkInfo.State intToState(int i) {
+        if (i == 0) {
+            return WorkInfo.State.ENQUEUED;
+        }
+        if (i == 1) {
+            return WorkInfo.State.RUNNING;
+        }
+        if (i == 2) {
+            return WorkInfo.State.SUCCEEDED;
+        }
+        if (i == 3) {
+            return WorkInfo.State.FAILED;
+        }
+        if (i == 4) {
+            return WorkInfo.State.BLOCKED;
+        }
+        if (i == 5) {
+            return WorkInfo.State.CANCELLED;
+        }
+        throw new IllegalArgumentException("Could not convert " + i + " to State");
+    }
+
+    @TypeConverter
+    public static final int backoffPolicyToInt(BackoffPolicy backoffPolicy) {
+        Intrinsics.checkNotNullParameter(backoffPolicy, "backoffPolicy");
+        int i = WhenMappings.$EnumSwitchMapping$1[backoffPolicy.ordinal()];
+        if (i == 1) {
+            return 0;
+        }
+        if (i == 2) {
+            return 1;
+        }
+        throw new NoWhenBranchMatchedException();
+    }
+
+    @TypeConverter
+    public static final BackoffPolicy intToBackoffPolicy(int i) {
+        if (i == 0) {
+            return BackoffPolicy.EXPONENTIAL;
+        }
+        if (i == 1) {
+            return BackoffPolicy.LINEAR;
+        }
+        throw new IllegalArgumentException("Could not convert " + i + " to BackoffPolicy");
+    }
+
+    @TypeConverter
+    public static final int networkTypeToInt(NetworkType networkType) {
+        Intrinsics.checkNotNullParameter(networkType, "networkType");
+        int i = WhenMappings.$EnumSwitchMapping$2[networkType.ordinal()];
+        if (i == 1) {
+            return 0;
+        }
+        int i2 = 2;
+        if (i == 2) {
+            return 1;
+        }
+        if (i != 3) {
+            i2 = 4;
+            if (i == 4) {
+                return 3;
+            }
+            if (i != 5) {
+                if (Build.VERSION.SDK_INT >= 30 && networkType == NetworkType.TEMPORARILY_UNMETERED) {
+                    return 5;
+                }
+                throw new IllegalArgumentException("Could not convert " + networkType + " to int");
+            }
+        }
+        return i2;
+    }
+
+    @TypeConverter
+    public static final NetworkType intToNetworkType(int i) {
+        if (i == 0) {
+            return NetworkType.NOT_REQUIRED;
+        }
+        if (i == 1) {
+            return NetworkType.CONNECTED;
+        }
+        if (i == 2) {
+            return NetworkType.UNMETERED;
+        }
+        if (i == 3) {
+            return NetworkType.NOT_ROAMING;
+        }
+        if (i == 4) {
+            return NetworkType.METERED;
+        }
+        if (Build.VERSION.SDK_INT >= 30 && i == 5) {
+            return NetworkType.TEMPORARILY_UNMETERED;
+        }
+        throw new IllegalArgumentException("Could not convert " + i + " to NetworkType");
+    }
+
+    @TypeConverter
+    public static final int outOfQuotaPolicyToInt(OutOfQuotaPolicy policy) {
+        Intrinsics.checkNotNullParameter(policy, "policy");
+        int i = WhenMappings.$EnumSwitchMapping$3[policy.ordinal()];
+        if (i == 1) {
+            return 0;
+        }
+        if (i == 2) {
+            return 1;
+        }
+        throw new NoWhenBranchMatchedException();
+    }
+
+    @TypeConverter
+    public static final OutOfQuotaPolicy intToOutOfQuotaPolicy(int i) {
+        if (i == 0) {
+            return OutOfQuotaPolicy.RUN_AS_NON_EXPEDITED_WORK_REQUEST;
+        }
+        if (i == 1) {
+            return OutOfQuotaPolicy.DROP_WORK_REQUEST;
+        }
+        throw new IllegalArgumentException("Could not convert " + i + " to OutOfQuotaPolicy");
+    }
+
+    @TypeConverter
+    public static final byte[] setOfTriggersToByteArray(Set<Constraints.ContentUriTrigger> triggers) {
+        Intrinsics.checkNotNullParameter(triggers, "triggers");
+        if (triggers.isEmpty()) {
+            return new byte[0];
+        }
+        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+        try {
+            ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
+            try {
+                objectOutputStream.writeInt(triggers.size());
+                for (Constraints.ContentUriTrigger contentUriTrigger : triggers) {
+                    objectOutputStream.writeUTF(contentUriTrigger.getUri().toString());
+                    objectOutputStream.writeBoolean(contentUriTrigger.isTriggeredForDescendants());
+                }
+                Unit unit = Unit.INSTANCE;
+                CloseableKt.closeFinally(objectOutputStream, null);
+                CloseableKt.closeFinally(byteArrayOutputStream, null);
+                byte[] byteArray = byteArrayOutputStream.toByteArray();
+                Intrinsics.checkNotNullExpressionValue(byteArray, "outputStream.toByteArray()");
+                return byteArray;
+            } finally {
+            }
+        } finally {
+        }
+    }
+
+    @TypeConverter
+    public static final Set<Constraints.ContentUriTrigger> byteArrayToSetOfTriggers(byte[] bytes) {
+        ObjectInputStream objectInputStream;
+        Intrinsics.checkNotNullParameter(bytes, "bytes");
+        LinkedHashSet linkedHashSet = new LinkedHashSet();
+        if (bytes.length == 0) {
+            return linkedHashSet;
+        }
+        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);
+        try {
+            try {
+                objectInputStream = new ObjectInputStream(byteArrayInputStream);
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            try {
+                int readInt = objectInputStream.readInt();
+                for (int i = 0; i < readInt; i++) {
+                    Uri uri = Uri.parse(objectInputStream.readUTF());
+                    boolean readBoolean = objectInputStream.readBoolean();
+                    Intrinsics.checkNotNullExpressionValue(uri, "uri");
+                    linkedHashSet.add(new Constraints.ContentUriTrigger(uri, readBoolean));
+                }
+                Unit unit = Unit.INSTANCE;
+                CloseableKt.closeFinally(objectInputStream, null);
+                Unit unit2 = Unit.INSTANCE;
+                CloseableKt.closeFinally(byteArrayInputStream, null);
+                return linkedHashSet;
+            } finally {
+            }
+        } finally {
+        }
+    }
+
+    @TypeConverter
+    public static final NetworkRequestCompat toNetworkRequest$work_runtime_release(byte[] bytes) {
+        Intrinsics.checkNotNullParameter(bytes, "bytes");
+        if (Build.VERSION.SDK_INT < 28 || bytes.length == 0) {
+            return new NetworkRequestCompat(null);
+        }
+        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);
+        try {
+            ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
+            try {
+                int readInt = objectInputStream.readInt();
+                int[] iArr = new int[readInt];
+                for (int i = 0; i < readInt; i++) {
+                    iArr[i] = objectInputStream.readInt();
+                }
+                int readInt2 = objectInputStream.readInt();
+                int[] iArr2 = new int[readInt2];
+                for (int i2 = 0; i2 < readInt2; i2++) {
+                    iArr2[i2] = objectInputStream.readInt();
+                }
+                NetworkRequestCompat createNetworkRequestCompat$work_runtime_release = NetworkRequest28.INSTANCE.createNetworkRequestCompat$work_runtime_release(iArr2, iArr);
+                CloseableKt.closeFinally(objectInputStream, null);
+                CloseableKt.closeFinally(byteArrayInputStream, null);
+                return createNetworkRequestCompat$work_runtime_release;
+            } finally {
+            }
+        } finally {
+        }
+    }
+
+    @TypeConverter
+    public static final byte[] fromNetworkRequest$work_runtime_release(NetworkRequestCompat requestCompat) {
+        Intrinsics.checkNotNullParameter(requestCompat, "requestCompat");
+        if (Build.VERSION.SDK_INT < 28) {
+            return new byte[0];
+        }
+        NetworkRequest networkRequest = requestCompat.getNetworkRequest();
+        if (networkRequest == null) {
+            return new byte[0];
+        }
+        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+        try {
+            ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
+            try {
+                int[] transportTypesCompat = NetworkRequestCompatKt.getTransportTypesCompat(networkRequest);
+                int[] capabilitiesCompat = NetworkRequestCompatKt.getCapabilitiesCompat(networkRequest);
+                objectOutputStream.writeInt(transportTypesCompat.length);
+                for (int i : transportTypesCompat) {
+                    objectOutputStream.writeInt(i);
+                }
+                objectOutputStream.writeInt(capabilitiesCompat.length);
+                for (int i2 : capabilitiesCompat) {
+                    objectOutputStream.writeInt(i2);
+                }
+                Unit unit = Unit.INSTANCE;
+                CloseableKt.closeFinally(objectOutputStream, null);
+                CloseableKt.closeFinally(byteArrayOutputStream, null);
+                byte[] byteArray = byteArrayOutputStream.toByteArray();
+                Intrinsics.checkNotNullExpressionValue(byteArray, "outputStream.toByteArray()");
+                return byteArray;
+            } finally {
+            }
+        } finally {
+        }
+    }
+}

decompiled-community/sources/androidx/work/impl/model/package-info.java

@@ -0,0 +1,5 @@
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+package androidx.work.impl.model;
+
+import androidx.annotation.RestrictTo;
+