Updated lifecycle to 2.8.3

https://developer.android.com/jetpack/androidx/releases/lifecycle#2.8.3

Revert "Revert "Updated AndroidX" / Lifecycle"

This reverts commit 85342c2baf.

app/src/main/java/androidx/lifecycle/FlowLiveData.kt

@@ -18,22 +18,19 @@
 
 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.GlobalScope
-import kotlinx.coroutines.channels.awaitClose
+import kotlinx.coroutines.NonCancellable
+import kotlinx.coroutines.awaitCancellation
 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
 
 /**
@@ -84,7 +81,6 @@ 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 {
@@ -104,7 +100,6 @@ 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)
@@ -113,8 +108,10 @@ public fun <T> LiveData<T>.asFlow(): Flow<T> = callbackFlow {
         observeForever(observer)
     }
 
-    awaitClose {
-        GlobalScope.launch(Dispatchers.Main.immediate) {
+    try {
+        awaitCancellation()
+    } finally {
+        withContext(Dispatchers.Main.immediate + NonCancellable) {
             removeObserver(observer)
         }
     }

app/src/main/java/androidx/lifecycle/LiveData.kt

@@ -0,0 +1,55 @@
+/*
+ * 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,9 +49,10 @@ import androidx.arch.core.util.Function
 fun <X, Y> LiveData<X>.map(
     transform: (@JvmSuppressWildcards X) -> (@JvmSuppressWildcards Y)
 ): LiveData<Y> {
-    val result = MediatorLiveData<Y>()
-    if (isInitialized) {
-        result.value = transform(value as X)
+    val result = if (isInitialized) {
+        MediatorLiveData(transform(value as X))
+    } else {
+        MediatorLiveData()
     }
     result.addSource(this) { x -> result.value = transform(x) }
     return result
@@ -121,13 +122,16 @@ 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
-    if (isInitialized) {
+    val result = if (isInitialized) {
         val initialLiveData = transform(value as X)
         if (initialLiveData != null && initialLiveData.isInitialized) {
-            result.value = initialLiveData.value
+            MediatorLiveData<Y>(initialLiveData.value)
+        } else {
+            MediatorLiveData<Y>()
         }
+    } else {
+        MediatorLiveData<Y>()
     }
     result.addSource(this) { value: X ->
         val newLiveData = transform(value)
@@ -183,11 +187,12 @@ 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
-    if (isInitialized) {
-        outputLiveData.value = value
+    val outputLiveData = if (isInitialized) {
         firstTime = false
+        MediatorLiveData<X>(value)
+    } else {
+        MediatorLiveData<X>()
     }
     outputLiveData.addSource(this) { value ->
         val previousValue = outputLiveData.value