project-real-resurrection-3/rr3-apk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity

Add Discord community version (64-bit only)

Browse Source 
- 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
This commit is contained in:
Daniel Elliott
2026-02-18 15:48:36 -08:00
parent c19eb3d7ff
commit c080f0d97f
26930 changed files with 2529574 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

948
decompiled-community/sources/androidx/room/InvalidationTracker.java Normal file
View File

@@ -0,0 +1,948 @@
package androidx.room;
import android.annotation.SuppressLint;
import android.content.Context;
import android.content.Intent;
import android.database.Cursor;
import android.database.sqlite.SQLiteException;
import android.util.Log;
import androidx.annotation.GuardedBy;
import androidx.annotation.RestrictTo;
import androidx.annotation.VisibleForTesting;
import androidx.annotation.WorkerThread;
import androidx.arch.core.internal.SafeIterableMap;
import androidx.lifecycle.LiveData;
import androidx.sqlite.db.SimpleSQLiteQuery;
import androidx.sqlite.db.SupportSQLiteDatabase;
import androidx.sqlite.db.SupportSQLiteStatement;
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.locks.Lock;
import kotlin.Unit;
import kotlin.collections.CollectionsKt___CollectionsKt;
import kotlin.collections.MapsKt__MapsKt;
import kotlin.collections.SetsKt__SetsJVMKt;
import kotlin.collections.SetsKt__SetsKt;
import kotlin.io.CloseableKt;
import kotlin.jvm.internal.DefaultConstructorMarker;
import kotlin.jvm.internal.Intrinsics;
import kotlin.jvm.internal.SourceDebugExtension;
import kotlin.text.StringsKt__StringsJVMKt;
import org.apache.http.client.methods.HttpDelete;
@SourceDebugExtension({"SMAP\nInvalidationTracker.kt\nKotlin\n*S Kotlin\n*F\n+ 1 InvalidationTracker.kt\nandroidx/room/InvalidationTracker\n+ 2 _Maps.kt\nkotlin/collections/MapsKt___MapsKt\n+ 3 _Arrays.kt\nkotlin/collections/ArraysKt___ArraysKt\n+ 4 ArraysJVM.kt\nkotlin/collections/ArraysKt__ArraysJVMKt\n+ 5 _Collections.kt\nkotlin/collections/CollectionsKt___CollectionsKt\n*L\n1#1,840:1\n215#2,2:841\n11335#3:843\n11670#3,3:844\n13579#3,2:847\n13579#3,2:849\n13674#3,3:855\n37#4,2:851\n1855#5,2:853\n*S KotlinDebug\n*F\n+ 1 InvalidationTracker.kt\nandroidx/room/InvalidationTracker\n*L\n102#1:841,2\n250#1:843\n250#1:844,3\n271#1:847,2\n287#1:849,2\n491#1:855,3\n294#1:851,2\n467#1:853,2\n*E\n"})
/* loaded from: classes.dex */
public class InvalidationTracker {
private static final String CREATE_TRACKING_TABLE_SQL = "CREATE TEMP TABLE room_table_modification_log (table_id INTEGER PRIMARY KEY, invalidated INTEGER NOT NULL DEFAULT 0)";
private static final String INVALIDATED_COLUMN_NAME = "invalidated";
public static final String RESET_UPDATED_TABLES_SQL = "UPDATE room_table_modification_log SET invalidated = 0 WHERE invalidated = 1";
public static final String SELECT_UPDATED_TABLES_SQL = "SELECT * FROM room_table_modification_log WHERE invalidated = 1;";
private static final String TABLE_ID_COLUMN_NAME = "table_id";
private static final String UPDATE_TABLE_NAME = "room_table_modification_log";
private AutoCloser autoCloser;
private volatile SupportSQLiteStatement cleanupStatement;
private final RoomDatabase database;
private volatile boolean initialized;
private final InvalidationLiveDataContainer invalidationLiveDataContainer;
private MultiInstanceInvalidationClient multiInstanceInvalidationClient;
private final ObservedTableTracker observedTableTracker;
@GuardedBy("observerMap")
private final SafeIterableMap<Observer, ObserverWrapper> observerMap;
@RestrictTo({RestrictTo.Scope.LIBRARY})
private final AtomicBoolean pendingRefresh;
@RestrictTo({RestrictTo.Scope.LIBRARY})
public final Runnable refreshRunnable;
private final Map<String, String> shadowTablesMap;
private final Object syncTriggersLock;
private final Map<String, Integer> tableIdLookup;
private final String[] tablesNames;
private final Object trackerLock;
private final Map<String, Set<String>> viewTables;
public static final Companion Companion = new Companion(null);
private static final String[] TRIGGERS = {"UPDATE", HttpDelete.METHOD_NAME, "INSERT"};
@VisibleForTesting
public static /* synthetic */ void getRefreshRunnable$annotations() {
}
public final SupportSQLiteStatement getCleanupStatement$room_runtime_release() {
return this.cleanupStatement;
}
public final RoomDatabase getDatabase$room_runtime_release() {
return this.database;
}
public final SafeIterableMap<Observer, ObserverWrapper> getObserverMap$room_runtime_release() {
return this.observerMap;
}
@RestrictTo({RestrictTo.Scope.LIBRARY})
public final AtomicBoolean getPendingRefresh() {
return this.pendingRefresh;
}
public final Map<String, Integer> getTableIdLookup$room_runtime_release() {
return this.tableIdLookup;
}
public final String[] getTablesNames$room_runtime_release() {
return this.tablesNames;
}
public final void setCleanupStatement$room_runtime_release(SupportSQLiteStatement supportSQLiteStatement) {
this.cleanupStatement = supportSQLiteStatement;
}
/* JADX WARN: Multi-variable type inference failed */
@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
public InvalidationTracker(RoomDatabase database, Map<String, String> shadowTablesMap, Map<String, Set<String>> viewTables, String... tableNames) {
Object value;
String str;
Intrinsics.checkNotNullParameter(database, "database");
Intrinsics.checkNotNullParameter(shadowTablesMap, "shadowTablesMap");
Intrinsics.checkNotNullParameter(viewTables, "viewTables");
Intrinsics.checkNotNullParameter(tableNames, "tableNames");
this.database = database;
this.shadowTablesMap = shadowTablesMap;
this.viewTables = viewTables;
this.pendingRefresh = new AtomicBoolean(false);
this.observedTableTracker = new ObservedTableTracker(tableNames.length);
this.invalidationLiveDataContainer = new InvalidationLiveDataContainer(database);
this.observerMap = new SafeIterableMap<>();
this.syncTriggersLock = new Object();
this.trackerLock = new Object();
this.tableIdLookup = new LinkedHashMap();
int length = tableNames.length;
String[] strArr = new String[length];
for (int i = 0; i < length; i++) {
String str2 = tableNames[i];
Locale US = Locale.US;
Intrinsics.checkNotNullExpressionValue(US, "US");
String lowerCase = str2.toLowerCase(US);
Intrinsics.checkNotNullExpressionValue(lowerCase, "this as java.lang.String).toLowerCase(locale)");
this.tableIdLookup.put(lowerCase, Integer.valueOf(i));
String str3 = this.shadowTablesMap.get(tableNames[i]);
if (str3 != null) {
Intrinsics.checkNotNullExpressionValue(US, "US");
str = str3.toLowerCase(US);
Intrinsics.checkNotNullExpressionValue(str, "this as java.lang.String).toLowerCase(locale)");
} else {
str = null;
}
if (str != null) {
lowerCase = str;
}
strArr[i] = lowerCase;
}
this.tablesNames = strArr;
for (Map.Entry<String, String> entry : this.shadowTablesMap.entrySet()) {
String value2 = entry.getValue();
Locale US2 = Locale.US;
Intrinsics.checkNotNullExpressionValue(US2, "US");
String lowerCase2 = value2.toLowerCase(US2);
Intrinsics.checkNotNullExpressionValue(lowerCase2, "this as java.lang.String).toLowerCase(locale)");
if (this.tableIdLookup.containsKey(lowerCase2)) {
String key = entry.getKey();
Intrinsics.checkNotNullExpressionValue(US2, "US");
String lowerCase3 = key.toLowerCase(US2);
Intrinsics.checkNotNullExpressionValue(lowerCase3, "this as java.lang.String).toLowerCase(locale)");
Map<String, Integer> map = this.tableIdLookup;
value = MapsKt__MapsKt.getValue(map, lowerCase2);
map.put(lowerCase3, value);
}
}
this.refreshRunnable = new Runnable() { // from class: androidx.room.InvalidationTracker$refreshRunnable$1
/* JADX WARN: Code restructure failed: missing block: B:30:0x0080, code lost:
if (r0 != null) goto L26;
*/
/* JADX WARN: Code restructure failed: missing block: B:31:0x0082, code lost:
r0.decrementCountAndScheduleClose();
*/
/* JADX WARN: Code restructure failed: missing block: B:33:0x00c5, code lost:
if ((!r3.isEmpty()) == false) goto L59;
*/
/* JADX WARN: Code restructure failed: missing block: B:34:0x00c7, code lost:
r0 = r5.this$0.getObserverMap$room_runtime_release();
r1 = r5.this$0;
*/
/* JADX WARN: Code restructure failed: missing block: B:35:0x00cf, code lost:
monitor-enter(r0);
*/
/* JADX WARN: Code restructure failed: missing block: B:37:0x00d0, code lost:
r1 = r1.getObserverMap$room_runtime_release().iterator();
*/
/* JADX WARN: Code restructure failed: missing block: B:39:0x00dc, code lost:
if (r1.hasNext() == false) goto L69;
*/
/* JADX WARN: Code restructure failed: missing block: B:40:0x00de, code lost:
((androidx.room.InvalidationTracker.ObserverWrapper) ((java.util.Map.Entry) r1.next()).getValue()).notifyByTableInvalidStatus$room_runtime_release(r3);
*/
/* JADX WARN: Code restructure failed: missing block: B:42:0x00f0, code lost:
r1 = kotlin.Unit.INSTANCE;
*/
/* JADX WARN: Code restructure failed: missing block: B:43:0x00f2, code lost:
monitor-exit(r0);
*/
/* JADX WARN: Code restructure failed: missing block: B:44:?, code lost:
return;
*/
/* JADX WARN: Code restructure failed: missing block: B:46:0x00ee, code lost:
r1 = move-exception;
*/
/* JADX WARN: Code restructure failed: missing block: B:48:0x00f5, code lost:
throw r1;
*/
/* JADX WARN: Code restructure failed: missing block: B:49:0x00f6, code lost:
return;
*/
/* JADX WARN: Code restructure failed: missing block: B:62:0x00a6, code lost:
if (r0 == null) goto L44;
*/
/* JADX WARN: Code restructure failed: missing block: B:66:0x00bd, code lost:
if (r0 == null) goto L44;
*/
@Override // java.lang.Runnable
/*
Code decompiled incorrectly, please refer to instructions dump.
To view partially-correct add '--show-bad-code' argument
*/
public void run() {
/*
Method dump skipped, instructions count: 262
To view this dump add '--comments-level debug' option
*/
throw new UnsupportedOperationException("Method not decompiled: androidx.room.InvalidationTracker$refreshRunnable$1.run():void");
}
private final Set<Integer> checkUpdatedTable() {
Set createSetBuilder;
Set<Integer> build;
InvalidationTracker invalidationTracker = InvalidationTracker.this;
createSetBuilder = SetsKt__SetsJVMKt.createSetBuilder();
Cursor query$default = RoomDatabase.query$default(invalidationTracker.getDatabase$room_runtime_release(), new SimpleSQLiteQuery(InvalidationTracker.SELECT_UPDATED_TABLES_SQL), null, 2, null);
while (query$default.moveToNext()) {
try {
createSetBuilder.add(Integer.valueOf(query$default.getInt(0)));
} finally {
}
}
Unit unit = Unit.INSTANCE;
CloseableKt.closeFinally(query$default, null);
build = SetsKt__SetsJVMKt.build(createSetBuilder);
if (!build.isEmpty()) {
if (InvalidationTracker.this.getCleanupStatement$room_runtime_release() == null) {
throw new IllegalStateException("Required value was null.".toString());
}
SupportSQLiteStatement cleanupStatement$room_runtime_release = InvalidationTracker.this.getCleanupStatement$room_runtime_release();
if (cleanupStatement$room_runtime_release == null) {
throw new IllegalArgumentException("Required value was null.".toString());
}
cleanupStatement$room_runtime_release.executeUpdateDelete();
}
return build;
}
};
}
/* JADX WARN: Illegal instructions before constructor call */
@androidx.annotation.RestrictTo({androidx.annotation.RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
/*
Code decompiled incorrectly, please refer to instructions dump.
To view partially-correct add '--show-bad-code' argument
*/
public InvalidationTracker(androidx.room.RoomDatabase r4, java.lang.String... r5) {
/*
r3 = this;
java.lang.String r0 = "database"
kotlin.jvm.internal.Intrinsics.checkNotNullParameter(r4, r0)
java.lang.String r0 = "tableNames"
kotlin.jvm.internal.Intrinsics.checkNotNullParameter(r5, r0)
java.util.Map r0 = kotlin.collections.MapsKt.emptyMap()
java.util.Map r1 = kotlin.collections.MapsKt.emptyMap()
int r2 = r5.length
java.lang.Object[] r5 = java.util.Arrays.copyOf(r5, r2)
java.lang.String[] r5 = (java.lang.String[]) r5
r3.<init>(r4, r0, r1, r5)
return
*/
throw new UnsupportedOperationException("Method not decompiled: androidx.room.InvalidationTracker.<init>(androidx.room.RoomDatabase, java.lang.String[]):void");
}
public final void setAutoCloser$room_runtime_release(AutoCloser autoCloser) {
Intrinsics.checkNotNullParameter(autoCloser, "autoCloser");
this.autoCloser = autoCloser;
autoCloser.setAutoCloseCallback(new Runnable() { // from class: androidx.room.InvalidationTracker$$ExternalSyntheticLambda0
@Override // java.lang.Runnable
public final void run() {
InvalidationTracker.this.onAutoCloseCallback();
}
});
}
public final void internalInit$room_runtime_release(SupportSQLiteDatabase database) {
Intrinsics.checkNotNullParameter(database, "database");
synchronized (this.trackerLock) {
if (this.initialized) {
Log.e(Room.LOG_TAG, "Invalidation tracker is initialized twice :/.");
return;
}
database.execSQL("PRAGMA temp_store = MEMORY;");
database.execSQL("PRAGMA recursive_triggers='ON';");
database.execSQL(CREATE_TRACKING_TABLE_SQL);
syncTriggers$room_runtime_release(database);
this.cleanupStatement = database.compileStatement(RESET_UPDATED_TABLES_SQL);
this.initialized = true;
Unit unit = Unit.INSTANCE;
}
}
/* JADX INFO: Access modifiers changed from: private */
public final void onAutoCloseCallback() {
synchronized (this.trackerLock) {
this.initialized = false;
this.observedTableTracker.resetTriggerState();
SupportSQLiteStatement supportSQLiteStatement = this.cleanupStatement;
if (supportSQLiteStatement != null) {
supportSQLiteStatement.close();
Unit unit = Unit.INSTANCE;
}
}
}
public final void startMultiInstanceInvalidation$room_runtime_release(Context context, String name, Intent serviceIntent) {
Intrinsics.checkNotNullParameter(context, "context");
Intrinsics.checkNotNullParameter(name, "name");
Intrinsics.checkNotNullParameter(serviceIntent, "serviceIntent");
this.multiInstanceInvalidationClient = new MultiInstanceInvalidationClient(context, name, serviceIntent, this, this.database.getQueryExecutor());
}
public final void stopMultiInstanceInvalidation$room_runtime_release() {
MultiInstanceInvalidationClient multiInstanceInvalidationClient = this.multiInstanceInvalidationClient;
if (multiInstanceInvalidationClient != null) {
multiInstanceInvalidationClient.stop();
}
this.multiInstanceInvalidationClient = null;
}
private final void stopTrackingTable(SupportSQLiteDatabase supportSQLiteDatabase, int i) {
String str = this.tablesNames[i];
for (String str2 : TRIGGERS) {
String str3 = "DROP TRIGGER IF EXISTS " + Companion.getTriggerName$room_runtime_release(str, str2);
Intrinsics.checkNotNullExpressionValue(str3, "StringBuilder().apply(builderAction).toString()");
supportSQLiteDatabase.execSQL(str3);
}
}
private final void startTrackingTable(SupportSQLiteDatabase supportSQLiteDatabase, int i) {
supportSQLiteDatabase.execSQL("INSERT OR IGNORE INTO room_table_modification_log VALUES(" + i + ", 0)");
String str = this.tablesNames[i];
for (String str2 : TRIGGERS) {
String str3 = "CREATE TEMP TRIGGER IF NOT EXISTS " + Companion.getTriggerName$room_runtime_release(str, str2) + " AFTER " + str2 + " ON `" + str + "` BEGIN UPDATE " + UPDATE_TABLE_NAME + " SET " + INVALIDATED_COLUMN_NAME + " = 1 WHERE " + TABLE_ID_COLUMN_NAME + " = " + i + " AND " + INVALIDATED_COLUMN_NAME + " = 0; END";
Intrinsics.checkNotNullExpressionValue(str3, "StringBuilder().apply(builderAction).toString()");
supportSQLiteDatabase.execSQL(str3);
}
}
@SuppressLint({"RestrictedApi"})
@WorkerThread
public void addObserver(Observer observer) {
int[] intArray;
ObserverWrapper putIfAbsent;
Intrinsics.checkNotNullParameter(observer, "observer");
String[] resolveViews = resolveViews(observer.getTables$room_runtime_release());
ArrayList arrayList = new ArrayList(resolveViews.length);
for (String str : resolveViews) {
Map<String, Integer> map = this.tableIdLookup;
Locale US = Locale.US;
Intrinsics.checkNotNullExpressionValue(US, "US");
String lowerCase = str.toLowerCase(US);
Intrinsics.checkNotNullExpressionValue(lowerCase, "this as java.lang.String).toLowerCase(locale)");
Integer num = map.get(lowerCase);
if (num == null) {
throw new IllegalArgumentException("There is no table with name " + str);
}
arrayList.add(Integer.valueOf(num.intValue()));
}
intArray = CollectionsKt___CollectionsKt.toIntArray(arrayList);
ObserverWrapper observerWrapper = new ObserverWrapper(observer, intArray, resolveViews);
synchronized (this.observerMap) {
putIfAbsent = this.observerMap.putIfAbsent(observer, observerWrapper);
}
if (putIfAbsent == null && this.observedTableTracker.onAdded(Arrays.copyOf(intArray, intArray.length))) {
syncTriggers$room_runtime_release();
}
}
private final String[] validateAndResolveTableNames(String[] strArr) {
String[] resolveViews = resolveViews(strArr);
for (String str : resolveViews) {
Map<String, Integer> map = this.tableIdLookup;
Locale US = Locale.US;
Intrinsics.checkNotNullExpressionValue(US, "US");
String lowerCase = str.toLowerCase(US);
Intrinsics.checkNotNullExpressionValue(lowerCase, "this as java.lang.String).toLowerCase(locale)");
if (!map.containsKey(lowerCase)) {
throw new IllegalArgumentException(("There is no table with name " + str).toString());
}
}
return resolveViews;
}
private final String[] resolveViews(String[] strArr) {
Set createSetBuilder;
Set build;
createSetBuilder = SetsKt__SetsJVMKt.createSetBuilder();
for (String str : strArr) {
Map<String, Set<String>> map = this.viewTables;
Locale US = Locale.US;
Intrinsics.checkNotNullExpressionValue(US, "US");
String lowerCase = str.toLowerCase(US);
Intrinsics.checkNotNullExpressionValue(lowerCase, "this as java.lang.String).toLowerCase(locale)");
if (map.containsKey(lowerCase)) {
Map<String, Set<String>> map2 = this.viewTables;
Intrinsics.checkNotNullExpressionValue(US, "US");
String lowerCase2 = str.toLowerCase(US);
Intrinsics.checkNotNullExpressionValue(lowerCase2, "this as java.lang.String).toLowerCase(locale)");
Set<String> set = map2.get(lowerCase2);
Intrinsics.checkNotNull(set);
createSetBuilder.addAll(set);
} else {
createSetBuilder.add(str);
}
}
build = SetsKt__SetsJVMKt.build(createSetBuilder);
return (String[]) build.toArray(new String[0]);
}
@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
public void addWeakObserver(Observer observer) {
Intrinsics.checkNotNullParameter(observer, "observer");
addObserver(new WeakObserver(this, observer));
}
@SuppressLint({"RestrictedApi"})
@WorkerThread
public void removeObserver(Observer observer) {
ObserverWrapper remove;
Intrinsics.checkNotNullParameter(observer, "observer");
synchronized (this.observerMap) {
remove = this.observerMap.remove(observer);
}
if (remove != null) {
ObservedTableTracker observedTableTracker = this.observedTableTracker;
int[] tableIds$room_runtime_release = remove.getTableIds$room_runtime_release();
if (observedTableTracker.onRemoved(Arrays.copyOf(tableIds$room_runtime_release, tableIds$room_runtime_release.length))) {
syncTriggers$room_runtime_release();
}
}
}
public final boolean ensureInitialization$room_runtime_release() {
if (!this.database.isOpenInternal()) {
return false;
}
if (!this.initialized) {
this.database.getOpenHelper().getWritableDatabase();
}
if (this.initialized) {
return true;
}
Log.e(Room.LOG_TAG, "database is not initialized even though it is open");
return false;
}
public void refreshVersionsAsync() {
if (this.pendingRefresh.compareAndSet(false, true)) {
AutoCloser autoCloser = this.autoCloser;
if (autoCloser != null) {
autoCloser.incrementCountAndEnsureDbIsOpen();
}
this.database.getQueryExecutor().execute(this.refreshRunnable);
}
}
@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
@WorkerThread
public void refreshVersionsSync() {
AutoCloser autoCloser = this.autoCloser;
if (autoCloser != null) {
autoCloser.incrementCountAndEnsureDbIsOpen();
}
syncTriggers$room_runtime_release();
this.refreshRunnable.run();
}
@RestrictTo({RestrictTo.Scope.LIBRARY})
public final void notifyObserversByTableNames(String... tables) {
Intrinsics.checkNotNullParameter(tables, "tables");
synchronized (this.observerMap) {
try {
Iterator<Map.Entry<K, V>> it = this.observerMap.iterator();
while (it.hasNext()) {
Map.Entry entry = (Map.Entry) it.next();
Intrinsics.checkNotNullExpressionValue(entry, "(observer, wrapper)");
Observer observer = (Observer) entry.getKey();
ObserverWrapper observerWrapper = (ObserverWrapper) entry.getValue();
if (!observer.isRemote$room_runtime_release()) {
observerWrapper.notifyByTableNames$room_runtime_release(tables);
}
}
Unit unit = Unit.INSTANCE;
} catch (Throwable th) {
throw th;
}
}
}
public final void syncTriggers$room_runtime_release(SupportSQLiteDatabase database) {
Intrinsics.checkNotNullParameter(database, "database");
if (database.inTransaction()) {
return;
}
try {
Lock closeLock$room_runtime_release = this.database.getCloseLock$room_runtime_release();
closeLock$room_runtime_release.lock();
try {
synchronized (this.syncTriggersLock) {
int[] tablesToSync = this.observedTableTracker.getTablesToSync();
if (tablesToSync == null) {
return;
}
Companion.beginTransactionInternal$room_runtime_release(database);
try {
int length = tablesToSync.length;
int i = 0;
int i2 = 0;
while (i < length) {
int i3 = tablesToSync[i];
int i4 = i2 + 1;
if (i3 == 1) {
startTrackingTable(database, i2);
} else if (i3 == 2) {
stopTrackingTable(database, i2);
}
i++;
i2 = i4;
}
database.setTransactionSuccessful();
database.endTransaction();
Unit unit = Unit.INSTANCE;
} catch (Throwable th) {
database.endTransaction();
throw th;
}
}
} finally {
closeLock$room_runtime_release.unlock();
}
} catch (SQLiteException e) {
Log.e(Room.LOG_TAG, "Cannot run invalidation tracker. Is the db closed?", e);
} catch (IllegalStateException e2) {
Log.e(Room.LOG_TAG, "Cannot run invalidation tracker. Is the db closed?", e2);
}
}
public final void syncTriggers$room_runtime_release() {
if (this.database.isOpenInternal()) {
syncTriggers$room_runtime_release(this.database.getOpenHelper().getWritableDatabase());
}
}
@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
public <T> LiveData<T> createLiveData(String[] tableNames, Callable<T> computeFunction) {
Intrinsics.checkNotNullParameter(tableNames, "tableNames");
Intrinsics.checkNotNullParameter(computeFunction, "computeFunction");
return createLiveData(tableNames, false, computeFunction);
}
@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
public <T> LiveData<T> createLiveData(String[] tableNames, boolean z, Callable<T> computeFunction) {
Intrinsics.checkNotNullParameter(tableNames, "tableNames");
Intrinsics.checkNotNullParameter(computeFunction, "computeFunction");
return this.invalidationLiveDataContainer.create(validateAndResolveTableNames(tableNames), z, computeFunction);
}
@SourceDebugExtension({"SMAP\nInvalidationTracker.kt\nKotlin\n*S Kotlin\n*F\n+ 1 InvalidationTracker.kt\nandroidx/room/InvalidationTracker$ObserverWrapper\n+ 2 _Arrays.kt\nkotlin/collections/ArraysKt___ArraysKt\n*L\n1#1,840:1\n13674#2,3:841\n12744#2,2:844\n13579#2:846\n13579#2,2:847\n13580#2:849\n*S KotlinDebug\n*F\n+ 1 InvalidationTracker.kt\nandroidx/room/InvalidationTracker$ObserverWrapper\n*L\n612#1:841,3\n634#1:844,2\n640#1:846\n641#1:847,2\n640#1:849\n*E\n"})
public static final class ObserverWrapper {
private final Observer observer;
private final Set<String> singleTableSet;
private final int[] tableIds;
private final String[] tableNames;
public final Observer getObserver$room_runtime_release() {
return this.observer;
}
public final int[] getTableIds$room_runtime_release() {
return this.tableIds;
}
public ObserverWrapper(Observer observer, int[] tableIds, String[] tableNames) {
Set<String> emptySet;
Intrinsics.checkNotNullParameter(observer, "observer");
Intrinsics.checkNotNullParameter(tableIds, "tableIds");
Intrinsics.checkNotNullParameter(tableNames, "tableNames");
this.observer = observer;
this.tableIds = tableIds;
this.tableNames = tableNames;
if (!(tableNames.length == 0)) {
emptySet = SetsKt__SetsJVMKt.setOf(tableNames[0]);
} else {
emptySet = SetsKt__SetsKt.emptySet();
}
this.singleTableSet = emptySet;
if (tableIds.length != tableNames.length) {
throw new IllegalStateException("Check failed.".toString());
}
}
public final void notifyByTableInvalidStatus$room_runtime_release(Set<Integer> invalidatedTablesIds) {
Set<String> emptySet;
Set createSetBuilder;
Intrinsics.checkNotNullParameter(invalidatedTablesIds, "invalidatedTablesIds");
int[] iArr = this.tableIds;
int length = iArr.length;
if (length != 0) {
int i = 0;
if (length == 1) {
emptySet = invalidatedTablesIds.contains(Integer.valueOf(iArr[0])) ? this.singleTableSet : SetsKt__SetsKt.emptySet();
} else {
createSetBuilder = SetsKt__SetsJVMKt.createSetBuilder();
int[] iArr2 = this.tableIds;
int length2 = iArr2.length;
int i2 = 0;
while (i < length2) {
int i3 = i2 + 1;
if (invalidatedTablesIds.contains(Integer.valueOf(iArr2[i]))) {
createSetBuilder.add(this.tableNames[i2]);
}
i++;
i2 = i3;
}
emptySet = SetsKt__SetsJVMKt.build(createSetBuilder);
}
} else {
emptySet = SetsKt__SetsKt.emptySet();
}
if (!emptySet.isEmpty()) {
this.observer.onInvalidated(emptySet);
}
}
public final void notifyByTableNames$room_runtime_release(String[] tables) {
Set<String> emptySet;
boolean equals;
Set createSetBuilder;
boolean equals2;
Intrinsics.checkNotNullParameter(tables, "tables");
int length = this.tableNames.length;
if (length != 0) {
if (length != 1) {
createSetBuilder = SetsKt__SetsJVMKt.createSetBuilder();
for (String str : tables) {
for (String str2 : this.tableNames) {
equals2 = StringsKt__StringsJVMKt.equals(str2, str, true);
if (equals2) {
createSetBuilder.add(str2);
}
}
}
emptySet = SetsKt__SetsJVMKt.build(createSetBuilder);
} else {
int length2 = tables.length;
int i = 0;
while (true) {
if (i < length2) {
equals = StringsKt__StringsJVMKt.equals(tables[i], this.tableNames[0], true);
if (equals) {
emptySet = this.singleTableSet;
break;
}
i++;
} else {
emptySet = SetsKt__SetsKt.emptySet();
break;
}
}
}
} else {
emptySet = SetsKt__SetsKt.emptySet();
}
if (!emptySet.isEmpty()) {
this.observer.onInvalidated(emptySet);
}
}
}
@SourceDebugExtension({"SMAP\nInvalidationTracker.kt\nKotlin\n*S Kotlin\n*F\n+ 1 InvalidationTracker.kt\nandroidx/room/InvalidationTracker$Observer\n+ 2 ArraysJVM.kt\nkotlin/collections/ArraysKt__ArraysJVMKt\n*L\n1#1,840:1\n37#2,2:841\n*S KotlinDebug\n*F\n+ 1 InvalidationTracker.kt\nandroidx/room/InvalidationTracker$Observer\n*L\n670#1:841,2\n*E\n"})
public static abstract class Observer {
private final String[] tables;
public final String[] getTables$room_runtime_release() {
return this.tables;
}
public boolean isRemote$room_runtime_release() {
return false;
}
public abstract void onInvalidated(Set<String> set);
public Observer(String[] tables) {
Intrinsics.checkNotNullParameter(tables, "tables");
this.tables = tables;
}
/* 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 Observer(java.lang.String r3, java.lang.String... r4) {
/*
r2 = this;
java.lang.String r0 = "firstTable"
kotlin.jvm.internal.Intrinsics.checkNotNullParameter(r3, r0)
java.lang.String r0 = "rest"
kotlin.jvm.internal.Intrinsics.checkNotNullParameter(r4, r0)
java.util.List r0 = kotlin.collections.CollectionsKt.createListBuilder()
r1 = r0
java.util.Collection r1 = (java.util.Collection) r1
kotlin.collections.CollectionsKt.addAll(r1, r4)
r0.add(r3)
java.util.List r3 = kotlin.collections.CollectionsKt.build(r0)
java.util.Collection r3 = (java.util.Collection) r3
r4 = 0
java.lang.String[] r4 = new java.lang.String[r4]
java.lang.Object[] r3 = r3.toArray(r4)
java.lang.String[] r3 = (java.lang.String[]) r3
r2.<init>(r3)
return
*/
throw new UnsupportedOperationException("Method not decompiled: androidx.room.InvalidationTracker.Observer.<init>(java.lang.String, java.lang.String[]):void");
}
}
@SourceDebugExtension({"SMAP\nInvalidationTracker.kt\nKotlin\n*S Kotlin\n*F\n+ 1 InvalidationTracker.kt\nandroidx/room/InvalidationTracker$ObservedTableTracker\n+ 2 _Arrays.kt\nkotlin/collections/ArraysKt___ArraysKt\n*L\n1#1,840:1\n13600#2,2:841\n13600#2,2:843\n13684#2,3:845\n*S KotlinDebug\n*F\n+ 1 InvalidationTracker.kt\nandroidx/room/InvalidationTracker$ObservedTableTracker\n*L\n711#1:841,2\n729#1:843,2\n765#1:845,3\n*E\n"})
public static final class ObservedTableTracker {
public static final int ADD = 1;
public static final Companion Companion = new Companion(null);
public static final int NO_OP = 0;
public static final int REMOVE = 2;
private boolean needsSync;
private final long[] tableObservers;
private final int[] triggerStateChanges;
private final boolean[] triggerStates;
public final boolean getNeedsSync() {
return this.needsSync;
}
public final long[] getTableObservers() {
return this.tableObservers;
}
public final void setNeedsSync(boolean z) {
this.needsSync = z;
}
public ObservedTableTracker(int i) {
this.tableObservers = new long[i];
this.triggerStates = new boolean[i];
this.triggerStateChanges = new int[i];
}
public final boolean onAdded(int... tableIds) {
boolean z;
Intrinsics.checkNotNullParameter(tableIds, "tableIds");
synchronized (this) {
try {
z = false;
for (int i : tableIds) {
long[] jArr = this.tableObservers;
long j = jArr[i];
jArr[i] = 1 + j;
if (j == 0) {
z = true;
this.needsSync = true;
}
}
Unit unit = Unit.INSTANCE;
} catch (Throwable th) {
throw th;
}
}
return z;
}
public final boolean onRemoved(int... tableIds) {
boolean z;
Intrinsics.checkNotNullParameter(tableIds, "tableIds");
synchronized (this) {
try {
z = false;
for (int i : tableIds) {
long[] jArr = this.tableObservers;
long j = jArr[i];
jArr[i] = j - 1;
if (j == 1) {
z = true;
this.needsSync = true;
}
}
Unit unit = Unit.INSTANCE;
} catch (Throwable th) {
throw th;
}
}
return z;
}
public final void resetTriggerState() {
synchronized (this) {
Arrays.fill(this.triggerStates, false);
this.needsSync = true;
Unit unit = Unit.INSTANCE;
}
}
@VisibleForTesting
public final int[] getTablesToSync() {
synchronized (this) {
try {
if (!this.needsSync) {
return null;
}
long[] jArr = this.tableObservers;
int length = jArr.length;
int i = 0;
int i2 = 0;
while (i < length) {
int i3 = i2 + 1;
int i4 = 1;
boolean z = jArr[i] > 0;
boolean[] zArr = this.triggerStates;
if (z != zArr[i2]) {
int[] iArr = this.triggerStateChanges;
if (!z) {
i4 = 2;
}
iArr[i2] = i4;
} else {
this.triggerStateChanges[i2] = 0;
}
zArr[i2] = z;
i++;
i2 = i3;
}
this.needsSync = false;
return (int[]) this.triggerStateChanges.clone();
} catch (Throwable th) {
throw th;
}
}
}
public static final class Companion {
public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
this();
}
private Companion() {
}
}
}
public static final class WeakObserver extends Observer {
private final WeakReference<Observer> delegateRef;
private final InvalidationTracker tracker;
public final WeakReference<Observer> getDelegateRef() {
return this.delegateRef;
}
public final InvalidationTracker getTracker() {
return this.tracker;
}
/* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
public WeakObserver(InvalidationTracker tracker, Observer delegate) {
super(delegate.getTables$room_runtime_release());
Intrinsics.checkNotNullParameter(tracker, "tracker");
Intrinsics.checkNotNullParameter(delegate, "delegate");
this.tracker = tracker;
this.delegateRef = new WeakReference<>(delegate);
}
@Override // androidx.room.InvalidationTracker.Observer
public void onInvalidated(Set<String> tables) {
Intrinsics.checkNotNullParameter(tables, "tables");
Observer observer = this.delegateRef.get();
if (observer == null) {
this.tracker.removeObserver(this);
} else {
observer.onInvalidated(tables);
}
}
}
public static final class Companion {
public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
this();
}
@VisibleForTesting
public static /* synthetic */ void getRESET_UPDATED_TABLES_SQL$room_runtime_release$annotations() {
}
@VisibleForTesting
public static /* synthetic */ void getSELECT_UPDATED_TABLES_SQL$room_runtime_release$annotations() {
}
private Companion() {
}
public final String getTriggerName$room_runtime_release(String tableName, String triggerType) {
Intrinsics.checkNotNullParameter(tableName, "tableName");
Intrinsics.checkNotNullParameter(triggerType, "triggerType");
return "`room_table_modification_trigger_" + tableName + '_' + triggerType + '`';
}
public final void beginTransactionInternal$room_runtime_release(SupportSQLiteDatabase database) {
Intrinsics.checkNotNullParameter(database, "database");
if (database.isWriteAheadLoggingEnabled()) {
database.beginTransactionNonExclusive();
} else {
database.beginTransaction();
}
}
}
}