Revert "Updated AndroidX" / Lifecycle

This reverts commit eebdff9fda. java.lang.AbstractMethodError: abstract method "androidx.lifecycle.ViewModel androidx.lifecycle.ViewModelProvider$Factory.create(kotlin.reflect.KClass, androidx.lifecycle.viewmodel.CreationExtras)" at androidx.lifecycle.viewmodel.ViewModelProviderImpl.getViewModel$lifecycle_viewmodel_release(ViewModelProviderImpl.kt:69) at androidx.lifecycle.viewmodel.ViewModelProviderImpl.getViewModel$lifecycle_viewmodel_release$default(ViewModelProviderImpl.kt:47) at androidx.lifecycle.ViewModelProvider.get(ViewModelProvider.android.kt:91) at androidx.lifecycle.ViewModelProvider.get(ViewModelProvider.android.kt:109) at leakcanary.internal.ViewModelClearedWatcher$Companion.install(ViewModelClearedWatcher.kt:61) at leakcanary.internal.AndroidXFragmentDestroyWatcher.invoke(AndroidXFragmentDestroyWatcher.kt:66) at leakcanary.internal.AndroidXFragmentDestroyWatcher.invoke(AndroidXFragmentDestroyWatcher.kt:25) at leakcanary.FragmentAndViewModelWatcher$lifecycleCallbacks$1.onActivityCreated(FragmentAndViewModelWatcher.kt:59) at android.app.Application.dispatchActivityCreated(Application.java:189) at android.app.Activity.onCreate(Activity.java:936) at androidx.core.app.ComponentActivity.onCreate(ComponentActivity.kt:73) at androidx.activity.ComponentActivity.onCreate(ComponentActivity.java:359) at androidx.fragment.app.FragmentActivity.onCreate(FragmentActivity.java:216) at eu.faircode.email.ActivityBase.onCreate(ActivityBase.java:421) at eu.faircode.email.ActivityMain.onCreate(ActivityMain.java:200) at android.app.Activity.performCreate(Activity.java:5937) at android.app.Instrumentation.callActivityOnCreate(Instrumentation.java:1105)
2 weeks ago · 85342c2baf
parent 07bfd8d6ef
commit 85342c2baf
4 changed files with 20 additions and 77 deletions
--- a/app/build.gradle
+++ b/app/build.gradle
@ -526,7 +526,7 @@ configurations.configureEach {
        } else if (details.requested.group == "androidx.lifecycle" &&
                details.requested.name != "lifecycle-extensions") {
            //print("Pinning " + details.requested.group + ":" + details.requested.name + "\n")
-            details.useVersion "2.8.1"
+            details.useVersion "2.7.0"
        } else if (details.requested.group == "org.apache.poi") {
            //print("Pinning " + details.requested.group + ":" + details.requested.name + "\n")
            details.useVersion "3.17"
@ -562,7 +562,7 @@ dependencies {
    def lbm_version = "1.1.0"
    def swiperefresh_version = "1.2.0-alpha01"
    def documentfile_version = "1.1.0-alpha01"
-    def lifecycle_version = "2.8.1"
+    def lifecycle_version = "2.7.0" // 2.8.1
    def lifecycle_extensions_version = "2.2.0"
    def room_version = "2.4.3" // 2.5.2/2.6.1/2.7.0-alpha04
    def sqlite_version = "2.4.0" // 2.5.0-alpha04
--- a/app/src/main/java/androidx/lifecycle/FlowLiveData.kt
+++ b/app/src/main/java/androidx/lifecycle/FlowLiveData.kt
@ -18,19 +18,22 @@

 package androidx.lifecycle

+import android.annotation.SuppressLint
 import android.os.Build
 import androidx.annotation.RequiresApi
 import androidx.arch.core.executor.ArchTaskExecutor
 import java.time.Duration
 import kotlin.coroutines.CoroutineContext
 import kotlin.coroutines.EmptyCoroutineContext
+import kotlinx.coroutines.DelicateCoroutinesApi
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.NonCancellable
-import kotlinx.coroutines.awaitCancellation
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.channels.awaitClose
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.callbackFlow
 import kotlinx.coroutines.flow.conflate
+import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext

 /**
@ -81,6 +84,7 @@ public fun <T> Flow<T>.asLiveData(
 }.also { liveData ->
    val flow = this
    if (flow is StateFlow<T>) {
+        @SuppressLint("RestrictedApi")
        if (ArchTaskExecutor.getInstance().isMainThread) {
            liveData.value = flow.value
        } else {
@ -100,6 +104,7 @@ public fun <T> Flow<T>.asLiveData(
 * BackPressure: the returned flow is conflated. There is no mechanism to suspend an emission by
 * LiveData due to a slow collector, so collector always gets the most recent value emitted.
 */
+@OptIn(DelicateCoroutinesApi::class)
 public fun <T> LiveData<T>.asFlow(): Flow<T> = callbackFlow {
    val observer = Observer<T> {
        trySend(it)
@ -108,10 +113,8 @@ public fun <T> LiveData<T>.asFlow(): Flow<T> = callbackFlow {
        observeForever(observer)
    }

-    try {
-        awaitCancellation()
-    } finally {
-        withContext(Dispatchers.Main.immediate + NonCancellable) {
+    awaitClose {
+        GlobalScope.launch(Dispatchers.Main.immediate) {
            removeObserver(observer)
        }
    }
--- a/app/src/main/java/androidx/lifecycle/LiveData.kt
+++ b/app/src/main/java/androidx/lifecycle/LiveData.kt
@ -1,55 +0,0 @@
-/*
- * Copyright 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package androidx.lifecycle
-
-import androidx.annotation.MainThread
-
-/**
- * Adds the given [onChanged] lambda as an observer within the lifespan of the given
- * [owner] and returns a reference to observer.
- * The events are dispatched on the main thread. If LiveData already has data
- * set, it will be delivered to the onChanged.
- *
- * The observer will only receive events if the owner is in [Lifecycle.State.STARTED]
- * or [Lifecycle.State.RESUMED] state (active).
- *
- * If the owner moves to the [Lifecycle.State.DESTROYED] state, the observer will
- * automatically be removed.
- *
- * When data changes while the [owner] is not active, it will not receive any updates.
- * If it becomes active again, it will receive the last available data automatically.
- *
- * LiveData keeps a strong reference to the observer and the owner as long as the
- * given LifecycleOwner is not destroyed. When it is destroyed, LiveData removes references to
- * the observer and the owner.
- *
- * If the given owner is already in [Lifecycle.State.DESTROYED] state, LiveData
- * ignores the call.
- */
-@Deprecated(
-    "This extension method is not required when using Kotlin 1.4. " +
-        "You should remove \"import androidx.lifecycle.observe\""
-)
-@MainThread
-public inline fun <T> LiveData<T>.observe(
-    owner: LifecycleOwner,
-    crossinline onChanged: (T) -> Unit
-): Observer<T> {
-    val wrappedObserver = Observer<T> { t -> onChanged.invoke(t) }
-    observe(owner, wrappedObserver)
-    return wrappedObserver
-}
--- a/app/src/main/java/androidx/lifecycle/Transformations.kt
+++ b/app/src/main/java/androidx/lifecycle/Transformations.kt
@ -49,10 +49,9 @@ import androidx.arch.core.util.Function
 fun <X, Y> LiveData<X>.map(
    transform: (@JvmSuppressWildcards X) -> (@JvmSuppressWildcards Y)
 ): LiveData<Y> {
-    val result = if (isInitialized) {
-        MediatorLiveData(transform(value as X))
-    } else {
-        MediatorLiveData()
+    val result = MediatorLiveData<Y>()
+    if (isInitialized) {
+        result.value = transform(value as X)
    }
    result.addSource(this) { x -> result.value = transform(x) }
    return result
@ -122,16 +121,13 @@ fun <X, Y> LiveData<X>.map(mapFunction: Function<X, Y>): LiveData<Y> {
 fun <X, Y> LiveData<X>.switchMap(
    transform: (@JvmSuppressWildcards X) -> (@JvmSuppressWildcards LiveData<Y>)?
 ): LiveData<Y> {
+    val result = MediatorLiveData<Y>()
    var liveData: LiveData<Y>? = null
-    val result = if (isInitialized) {
+    if (isInitialized) {
        val initialLiveData = transform(value as X)
        if (initialLiveData != null && initialLiveData.isInitialized) {
-            MediatorLiveData<Y>(initialLiveData.value)
-        } else {
-            MediatorLiveData<Y>()
+            result.value = initialLiveData.value
        }
-    } else {
-        MediatorLiveData<Y>()
    }
    result.addSource(this) { value: X ->
        val newLiveData = transform(value)
@ -187,12 +183,11 @@ fun <X, Y> LiveData<X>.switchMap(switchMapFunction: Function<X, LiveData<Y>>): L
@MainThread
@CheckResult
 fun <X> LiveData<X>.distinctUntilChanged(): LiveData<X> {
+    val outputLiveData = MediatorLiveData<X>()
    var firstTime = true
-    val outputLiveData = if (isInitialized) {
+    if (isInitialized) {
+        outputLiveData.value = value
        firstTime = false
-        MediatorLiveData<X>(value)
-    } else {
-        MediatorLiveData<X>()
    }
    outputLiveData.addSource(this) { value ->
        val previousValue = outputLiveData.value