Merge branch 'github/master'

Author: kokoro-team

PlayCoreKtx/app/src/main/java/com/google/android/samples/dynamicfeatures/state/UpdateViewModel.kt

@@ -21,6 +21,7 @@ import androidx.lifecycle.ViewModel
 import androidx.lifecycle.ViewModelProvider
 import androidx.lifecycle.asLiveData
 import androidx.lifecycle.viewModelScope
+import com.google.android.play.core.appupdate.AppUpdateInfo
 import com.google.android.play.core.appupdate.AppUpdateManager
 import com.google.android.play.core.ktx.AppUpdateResult
 import com.google.android.play.core.ktx.clientVersionStalenessDays
@@ -34,20 +35,32 @@ import kotlinx.coroutines.channels.BroadcastChannel
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.flow.asFlow
 import kotlinx.coroutines.flow.catch
+import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.launch
 
 /**
  * ViewModel for InAppUpdates.
  */
 @OptIn(ExperimentalCoroutinesApi::class, FlowPreview::class)
 class UpdateViewModel @Keep constructor(manager: AppUpdateManager) : ViewModel() {
-    val updateStatus = manager.requestUpdateFlow().catch {
-        _events.send(Event.ToastEvent("Update info not available"))
-    }.asLiveData()
+    val updateStatus = manager.requestUpdateFlow()
+            .catch {
+                _events.send(Event.ToastEvent("Update info not available"))
+            }
+            .asLiveData()
 
     private val _events = BroadcastChannel<Event>(Channel.BUFFERED)
     val events = _events.asFlow()
 
+    fun shouldLaunchImmediateUpdate(updateInfo: AppUpdateInfo): Boolean {
+        with(updateInfo) {
+            return isImmediateUpdateAllowed
+                    &&
+                    (clientVersionStalenessDays ?: 0 > 30
+                            || updatePriority > 4)
+        }
+    }
+
     fun invokeUpdate() {
         when (val updateResult = updateStatus.value) {
             AppUpdateResult.NotAvailable -> viewModelScope.launch {
@@ -56,20 +69,20 @@ class UpdateViewModel @Keep constructor(manager: AppUpdateManager) : ViewModel()
             is AppUpdateResult.Available -> {
                 with(updateResult.updateInfo) {
                     Log.d(TAG, "Update priority: $updatePriority")
-                    if (isImmediateUpdateAllowed
-                            &&
-                            (clientVersionStalenessDays ?: 0 > 7
-                                    || updatePriority > 4)
-                    ) {
-                        viewModelScope.launch {
-                            _events.send(Event.StartUpdateEvent(updateResult.updateInfo, true))
+                    when {
+                        shouldLaunchImmediateUpdate(this) -> {
+                            viewModelScope.launch {
+                                _events.send(Event.StartUpdateEvent(updateResult.updateInfo, true))
+                            }
+                        }
+                        isFlexibleUpdateAllowed -> {
+                            viewModelScope.launch {
+                                _events.send(Event.StartUpdateEvent(updateResult.updateInfo, false))
+                            }
                         }
-                    } else if (isFlexibleUpdateAllowed) {
-                        viewModelScope.launch {
-                            _events.send(Event.StartUpdateEvent(updateResult.updateInfo, false))
+                        else -> {
+                            throw IllegalStateException("Not implemented: Handling for $this")
                         }
-                    } else {
-                        throw IllegalStateException("Not implemented: Handling for $this")
                     }
                 }
             }

PlayCoreKtx/app/src/main/java/com/google/android/samples/dynamicfeatures/ui/MainFragment.kt

@@ -28,6 +28,7 @@ import androidx.fragment.app.activityViewModels
 import androidx.fragment.app.viewModels
 import androidx.lifecycle.Observer
 import androidx.lifecycle.lifecycleScope
+import androidx.lifecycle.viewModelScope
 import com.google.android.material.snackbar.Snackbar
 import com.google.android.play.core.appupdate.AppUpdateManager
 import com.google.android.play.core.appupdate.AppUpdateManagerFactory
@@ -63,6 +64,7 @@ import kotlinx.coroutines.flow.collect
 import kotlinx.coroutines.flow.drop
 import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.launch
 
 @OptIn(ExperimentalCoroutinesApi::class)
 @Keep
@@ -184,9 +186,27 @@ class MainFragment : Fragment(R.layout.fragment_main) {
     private fun addUpdateViewModelObservers() {
         with(updateViewModel) {
             updateStatus.observe(
-                    viewLifecycleOwner, Observer { updateResult: AppUpdateResult ->
-                updateUpdateButton(updateResult)
-            })
+                    viewLifecycleOwner,
+                    { updateResult: AppUpdateResult ->
+                        updateUpdateButton(updateResult)
+
+                        // If it's an immediate update, launch it immediately and finish Activity
+                        // to prevent the user from using the app until they update.
+                        if (updateResult is Available) {
+                            if (shouldLaunchImmediateUpdate(updateResult.updateInfo)) {
+                                if (appUpdateManager.startUpdateFlowForResult(
+                                        updateResult.updateInfo,
+                                        AppUpdateType.IMMEDIATE,
+                                        this@MainFragment,
+                                        UPDATE_CONFIRMATION_REQ_CODE
+                                )) {
+                                    // only exit if update flow really started
+                                    requireActivity().finish()
+                                }
+                            }
+                        }
+                    }
+            )
             events.onEach { event ->
                 when (event) {
                     is Event.ToastEvent -> toastAndLog(event.message)