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)

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

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.GlobalScope
-import kotlinx.coroutines.awaitCancellation
+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 {
+    awaitClose {
-        awaitCancellation()
+        GlobalScope.launch(Dispatchers.Main.immediate) {
-    } finally {
-        withContext(Dispatchers.Main.immediate + NonCancellable) {
             removeObserver(observer)
         }
     }

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
-}

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) {
+    val result = MediatorLiveData<Y>()
-        MediatorLiveData(transform(value as X))
+    if (isInitialized) {
-    } else {
+        result.value = transform(value as X)
-        MediatorLiveData()
     }
     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)
+            result.value = initialLiveData.value
-        } else {
-            MediatorLiveData<Y>()
         }
-    } 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