Revert "Updated ROOM patch"

This reverts commit b8250fe6a0.
pull/215/head
M66B 9 months ago
parent b8250fe6a0
commit 8f2bab4c48

@ -405,14 +405,10 @@ open class InvalidationTracker @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP_PREFIX
private fun checkUpdatedTable(): Set<Int> { private fun checkUpdatedTable(): Set<Int> {
val invalidatedTableIds = buildSet { val invalidatedTableIds = buildSet {
try { database.query(SimpleSQLiteQuery(SELECT_UPDATED_TABLES_SQL)).useCursor { cursor ->
database.query(SimpleSQLiteQuery(SELECT_UPDATED_TABLES_SQL)).useCursor { cursor -> while (cursor.moveToNext()) {
while (cursor.moveToNext()) { add(cursor.getInt(0))
add(cursor.getInt(0))
}
} }
} catch (ex: Throwable) {
eu.faircode.email.Log.w(ex)
} }
} }
if (invalidatedTableIds.isNotEmpty()) { if (invalidatedTableIds.isNotEmpty()) {

@ -54,79 +54,62 @@ internal class RoomTrackingLiveData<T> (
val invalid = AtomicBoolean(true) val invalid = AtomicBoolean(true)
val computing = AtomicBoolean(false) val computing = AtomicBoolean(false)
val registeredObserver = AtomicBoolean(false) val registeredObserver = AtomicBoolean(false)
val queued = eu.faircode.email.ObjectHolder<Int>(0)
val lock = Object()
val refreshRunnable = Runnable { val refreshRunnable = Runnable {
eu.faircode.email.Log.i("MMM Refresh") if (registeredObserver.compareAndSet(false, true)) {
synchronized(lock) { database.invalidationTracker.addWeakObserver(observer)
queued.value-- }
if (queued.value < 0) { var computed: Boolean
eu.faircode.email.Log.e("$computeFunction queued=$queued.value") do {
queued.value = 0 computed = false
} // compute can happen only in 1 thread but no reason to lock others.
} if (computing.compareAndSet(false, true)) {
eu.faircode.email.Log.i("MMM Refreshing") // as long as it is invalid, keep computing.
try {
if (registeredObserver.compareAndSet(false, true)) { var value: T? = null
database.invalidationTracker.addWeakObserver(observer) while (invalid.compareAndSet(true, false)) {
} computed = true
try {
var value: T? = null value = computeFunction.call()
var computed = false } catch (e: Exception) {
synchronized(computeFunction) { throw RuntimeException(
var retry = 0 "Exception while computing database live data.",
while (!computed) { e
try { )
value = computeFunction.call() }
computed = true }
} catch (e: Throwable) { if (computed) {
if (++retry > 5) { postValue(value)
eu.faircode.email.Log.e(e) }
break } finally {
} // release compute lock
eu.faircode.email.Log.w(e) computing.set(false)
try { }
Thread.sleep(2000L) }
} catch (ignored: InterruptedException) { // check invalid after releasing compute lock to avoid the following scenario.
} // Thread A runs compute()
} // Thread A checks invalid, it is false
} // Main thread sets invalid to true
} // Thread B runs, fails to acquire compute lock and skips
if (computed) { // Thread A releases compute lock
postValue(value) // We've left invalid in set state. The check below recovers.
} } while (computed && invalid.get())
eu.faircode.email.Log.i("MMM Refreshed") }
}
val invalidationRunnable = Runnable { val invalidationRunnable = Runnable {
val isActive = hasActiveObservers() val isActive = hasActiveObservers()
if (invalid.compareAndSet(false, true)) { if (invalid.compareAndSet(false, true)) {
if (isActive) { if (isActive) {
eu.faircode.email.Log.i("MMM Invalidate") queryExecutor.execute(refreshRunnable)
synchronized(lock) { }
if (queued.value > 0) { }
eu.faircode.email.Log.persist(eu.faircode.email.EntityLog.Type.Debug, "$computeFunction queued=$queued.value") }
} else {
queued.value++
queryExecutor.execute(refreshRunnable)
}
eu.faircode.email.Log.i("MMM Invalidated")
}
}
}
}
@Suppress("UNCHECKED_CAST") @Suppress("UNCHECKED_CAST")
override fun onActive() { override fun onActive() {
super.onActive() super.onActive()
container.onActive(this as LiveData<Any>) container.onActive(this as LiveData<Any>)
eu.faircode.email.Log.i("MMM Active") queryExecutor.execute(refreshRunnable)
synchronized(lock) { }
queued.value++
queryExecutor.execute(refreshRunnable)
}
eu.faircode.email.Log.i("MMM Actived")
}
@Suppress("UNCHECKED_CAST") @Suppress("UNCHECKED_CAST")
override fun onInactive() { override fun onInactive() {

@ -153,7 +153,7 @@ public abstract class LimitOffsetDataSource<T> extends androidx.paging.Positiona
@NonNull LoadInitialCallback<T> callback) { @NonNull LoadInitialCallback<T> callback) {
registerObserverIfNecessary(); registerObserverIfNecessary();
List<T> list = Collections.emptyList(); List<T> list = Collections.emptyList();
int totalCount = 0; int totalCount;
int firstLoadPosition = 0; int firstLoadPosition = 0;
RoomSQLiteQuery sqLiteQuery = null; RoomSQLiteQuery sqLiteQuery = null;
Cursor cursor = null; Cursor cursor = null;
@ -171,8 +171,6 @@ public abstract class LimitOffsetDataSource<T> extends androidx.paging.Positiona
mDb.setTransactionSuccessful(); mDb.setTransactionSuccessful();
list = rows; list = rows;
} }
} catch (Throwable ex) {
eu.faircode.email.Log.w(ex);
} finally { } finally {
if (cursor != null) { if (cursor != null) {
cursor.close(); cursor.close();

@ -1,171 +0,0 @@
diff --git a/app/src/main/java/androidx/room/InvalidationTracker.kt b/app/src/main/java/androidx/room/InvalidationTracker.kt
index 38067b702f..76cf95815c 100644
--- a/app/src/main/java/androidx/room/InvalidationTracker.kt
+++ b/app/src/main/java/androidx/room/InvalidationTracker.kt
@@ -405,10 +405,14 @@ open class InvalidationTracker @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP_PREFIX
private fun checkUpdatedTable(): Set<Int> {
val invalidatedTableIds = buildSet {
- database.query(SimpleSQLiteQuery(SELECT_UPDATED_TABLES_SQL)).useCursor { cursor ->
- while (cursor.moveToNext()) {
- add(cursor.getInt(0))
+ try {
+ database.query(SimpleSQLiteQuery(SELECT_UPDATED_TABLES_SQL)).useCursor { cursor ->
+ while (cursor.moveToNext()) {
+ add(cursor.getInt(0))
+ }
}
+ } catch (ex: Throwable) {
+ eu.faircode.email.Log.w(ex)
}
}
if (invalidatedTableIds.isNotEmpty()) {
diff --git a/app/src/main/java/androidx/room/RoomTrackingLiveData.kt b/app/src/main/java/androidx/room/RoomTrackingLiveData.kt
index 171b57d16e..e253e98eee 100644
--- a/app/src/main/java/androidx/room/RoomTrackingLiveData.kt
+++ b/app/src/main/java/androidx/room/RoomTrackingLiveData.kt
@@ -54,62 +54,72 @@ internal class RoomTrackingLiveData<T> (
val invalid = AtomicBoolean(true)
val computing = AtomicBoolean(false)
val registeredObserver = AtomicBoolean(false)
+ val queued = eu.faircode.email.ObjectHolder<Int>(0)
+ val lock = Object()
val refreshRunnable = Runnable {
- if (registeredObserver.compareAndSet(false, true)) {
- database.invalidationTracker.addWeakObserver(observer)
- }
- var computed: Boolean
- do {
- computed = false
- // compute can happen only in 1 thread but no reason to lock others.
- if (computing.compareAndSet(false, true)) {
- // as long as it is invalid, keep computing.
- try {
- var value: T? = null
- while (invalid.compareAndSet(true, false)) {
- computed = true
- try {
- value = computeFunction.call()
- } catch (e: Exception) {
- throw RuntimeException(
- "Exception while computing database live data.",
- e
- )
- }
- }
- if (computed) {
- postValue(value)
- }
- } finally {
- // release compute lock
- computing.set(false)
- }
- }
- // check invalid after releasing compute lock to avoid the following scenario.
- // Thread A runs compute()
- // Thread A checks invalid, it is false
- // Main thread sets invalid to true
- // Thread B runs, fails to acquire compute lock and skips
- // Thread A releases compute lock
- // We've left invalid in set state. The check below recovers.
- } while (computed && invalid.get())
- }
+ synchronized(lock) {
+ queued.value--
+ if (queued.value < 0) {
+ eu.faircode.email.Log.e("$computeFunction queued=$queued.value")
+ queued.value = 0
+ }
+ }
+
+ if (registeredObserver.compareAndSet(false, true)) {
+ database.invalidationTracker.addWeakObserver(observer)
+ }
+
+ var value: T? = null
+ var computed = false
+ synchronized(computeFunction) {
+ var retry = 0
+ while (!computed) {
+ try {
+ value = computeFunction.call()
+ computed = true
+ } catch (e: Throwable) {
+ if (++retry > 5) {
+ eu.faircode.email.Log.e(e)
+ break
+ }
+ eu.faircode.email.Log.w(e)
+ try {
+ Thread.sleep(2000L)
+ } catch (ignored: InterruptedException) {
+ }
+ }
+ }
+ }
+ if (computed) {
+ postValue(value)
+ }
+ }
val invalidationRunnable = Runnable {
- val isActive = hasActiveObservers()
- if (invalid.compareAndSet(false, true)) {
- if (isActive) {
- queryExecutor.execute(refreshRunnable)
- }
- }
- }
+ val isActive = hasActiveObservers()
+ if (invalid.compareAndSet(false, true)) {
+ if (isActive) {
+ synchronized(lock) {
+ if (queued.value > 0) {
+ eu.faircode.email.Log.persist(eu.faircode.email.EntityLog.Type.Debug, "$computeFunction queued=$queued.value")
+ } else {
+ queued.value++
+ queryExecutor.execute(refreshRunnable)
+ }
+ }
+ }
+ }
+ }
@Suppress("UNCHECKED_CAST")
override fun onActive() {
- super.onActive()
- container.onActive(this as LiveData<Any>)
- queryExecutor.execute(refreshRunnable)
- }
+ super.onActive()
+ container.onActive(this as LiveData<Any>)
+ synchronized(lock) {
+ queued.value++
+ queryExecutor.execute(refreshRunnable)
+ }
+ }
@Suppress("UNCHECKED_CAST")
override fun onInactive() {
diff --git a/app/src/main/java/androidx/room/paging/LimitOffsetDataSource.java b/app/src/main/java/androidx/room/paging/LimitOffsetDataSource.java
index 2b5c391dbc..077ae233e8 100644
--- a/app/src/main/java/androidx/room/paging/LimitOffsetDataSource.java
+++ b/app/src/main/java/androidx/room/paging/LimitOffsetDataSource.java
@@ -153,7 +153,7 @@ public abstract class LimitOffsetDataSource<T> extends androidx.paging.Positiona
@NonNull LoadInitialCallback<T> callback) {
registerObserverIfNecessary();
List<T> list = Collections.emptyList();
- int totalCount;
+ int totalCount = 0;
int firstLoadPosition = 0;
RoomSQLiteQuery sqLiteQuery = null;
Cursor cursor = null;
@@ -171,6 +171,8 @@ public abstract class LimitOffsetDataSource<T> extends androidx.paging.Positiona
mDb.setTransactionSuccessful();
list = rows;
}
+ } catch (Throwable ex) {
+ eu.faircode.email.Log.w(ex);
} finally {
if (cursor != null) {
cursor.close();
Loading…
Cancel
Save