modalsheet: fix handling custom BackHandler in modalsheet

Author: hrach

demo/src/main/kotlin/dev/hrach/navigation/demo/screens/Modal1.kt

@@ -1,22 +1,30 @@
 package dev.hrach.navigation.demo.screens
 
 import android.annotation.SuppressLint
+import androidx.activity.compose.BackHandler
 import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.WindowInsets
 import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.systemBars
 import androidx.compose.foundation.layout.windowInsetsPadding
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.OutlinedButton
 import androidx.compose.material3.Surface
+import androidx.compose.material3.Switch
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
 import androidx.navigation.NavController
 import dev.hrach.navigation.demo.Destinations
 import dev.hrach.navigation.results.NavigationResultEffect
@@ -42,6 +50,11 @@ private fun Modal1(
 	navigate: (Any) -> Unit,
 	bottomSheetResult: Int,
 ) {
+	var disableBackHandling by rememberSaveable { mutableStateOf(false) }
+	BackHandler(disableBackHandling) {
+		// no-op
+	}
+
 	Surface(
 		color = MaterialTheme.colorScheme.inverseSurface,
 	) {
@@ -58,6 +71,13 @@ private fun Modal1(
 				Text("BottomSheet")
 			}
 			Text("BottomSheetResult: $bottomSheetResult")
+
+			Spacer(Modifier.height(32.dp))
+
+			Row(verticalAlignment = Alignment.CenterVertically) {
+				Text("Disable back handling")
+				Switch(disableBackHandling, onCheckedChange = { disableBackHandling = it })
+			}
 		}
 	}
 }

modalsheet/src/main/kotlin/dev/hrach/navigation/modalsheet/ModalSheetDialog.kt

@@ -7,16 +7,10 @@ import android.view.View
 import android.view.ViewOutlineProvider
 import android.view.Window
 import android.view.WindowManager
-import android.window.BackEvent
-import android.window.OnBackAnimationCallback
-import android.window.OnBackInvokedCallback
-import android.window.OnBackInvokedDispatcher
 import androidx.activity.BackEventCompat
 import androidx.activity.ComponentDialog
-import androidx.activity.addCallback
+import androidx.activity.compose.PredictiveBackHandler
 import androidx.activity.setViewTreeOnBackPressedDispatcherOwner
-import androidx.annotation.DoNotInline
-import androidx.annotation.RequiresApi
 import androidx.appcompat.view.ContextThemeWrapper
 import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.Box
@@ -29,7 +23,6 @@ import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCompositionContext
-import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.rememberUpdatedState
 import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.setValue
@@ -54,16 +47,7 @@ import androidx.lifecycle.setViewTreeViewModelStoreOwner
 import androidx.savedstate.findViewTreeSavedStateRegistryOwner
 import androidx.savedstate.setViewTreeSavedStateRegistryOwner
 import java.util.UUID
-import java.util.concurrent.CancellationException
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.channels.BufferOverflow.SUSPEND
-import kotlinx.coroutines.channels.Channel
-import kotlinx.coroutines.channels.Channel.Factory.BUFFERED
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.consumeAsFlow
-import kotlinx.coroutines.flow.flowOf
-import kotlinx.coroutines.flow.onCompletion
-import kotlinx.coroutines.launch
 
 @Composable
 internal fun ModalSheetDialog(
@@ -79,18 +63,16 @@ internal fun ModalSheetDialog(
 	val dialogId = rememberSaveable { UUID.randomUUID() }
 	val darkThemeEnabled = isSystemInDarkTheme()
 	val currentOnPredictiveBack = rememberUpdatedState(onPredictiveBack)
-	val scope = rememberCoroutineScope()
 
 	val dialog = remember(view, density) {
 		ModalSheetDialogWrapper(
-			currentOnPredictiveBack,
-			view,
-			scope,
-			securePolicy,
-			layoutDirection,
-			density,
-			dialogId,
-			darkThemeEnabled,
+			onPredictiveBack = currentOnPredictiveBack,
+			composeView = view,
+			securePolicy = securePolicy,
+			layoutDirection = layoutDirection,
+			density = density,
+			dialogId = dialogId,
+			darkThemeEnabled = darkThemeEnabled,
 		).apply {
 			setContent(composition) {
 				Box(
@@ -124,10 +106,8 @@ private class ModalSheetDialogLayout(
 	context: Context,
 	override val window: Window,
 	private val onPredictiveBack: State<suspend (Flow<BackEventCompat>) -> Unit>,
-	private val scope: CoroutineScope,
 ) : AbstractComposeView(context), DialogWindowProvider {
 	private var content: @Composable () -> Unit by mutableStateOf({})
-	private var backCallback: Any? = null
 	override var shouldCreateCompositionOnAttachedToWindow: Boolean = false
 		private set
 
@@ -140,111 +120,9 @@ private class ModalSheetDialogLayout(
 
 	@Composable
 	override fun Content() {
+		PredictiveBackHandler(onBack = onPredictiveBack.value)
 		content()
 	}
-
-	override fun onAttachedToWindow() {
-		super.onAttachedToWindow()
-		maybeRegisterBackCallback()
-	}
-
-	override fun onDetachedFromWindow() {
-		super.onDetachedFromWindow()
-		maybeUnregisterBackCallback()
-	}
-
-	private fun maybeRegisterBackCallback() {
-		if (Build.VERSION.SDK_INT < 33) return
-		if (backCallback == null) {
-			backCallback = when {
-				Build.VERSION.SDK_INT >= 34 -> Api34Impl.createBackCallback(onPredictiveBack, scope)
-				else -> Api33Impl.createBackCallback(onPredictiveBack, scope)
-			}
-		}
-		Api33Impl.maybeRegisterBackCallback(this, backCallback)
-	}
-
-	private fun maybeUnregisterBackCallback() {
-		if (Build.VERSION.SDK_INT >= 33) {
-			Api33Impl.maybeUnregisterBackCallback(this, backCallback)
-		}
-		backCallback = null
-	}
-
-	@RequiresApi(34)
-	private object Api34Impl {
-		@JvmStatic
-		@DoNotInline
-		fun createBackCallback(
-			currentOnBack: State<suspend (Flow<BackEventCompat>) -> Unit>,
-			scope: CoroutineScope,
-		) = object : OnBackAnimationCallback {
-			var onBackInstance: OnBackInstance? = null
-
-			override fun onBackStarted(backEvent: BackEvent) {
-				onBackInstance?.cancel()
-				onBackInstance = OnBackInstance(scope, true, currentOnBack.value)
-			}
-
-			override fun onBackProgressed(backEvent: BackEvent) {
-				onBackInstance?.send(BackEventCompat(backEvent))
-			}
-
-			override fun onBackInvoked() {
-				onBackInstance?.apply {
-					if (!isPredictiveBack) {
-						cancel()
-						onBackInstance = null
-					}
-				}
-				if (onBackInstance == null) {
-					onBackInstance = OnBackInstance(scope, false, currentOnBack.value)
-				}
-				onBackInstance?.close()
-				onBackInstance?.isPredictiveBack = false
-			}
-
-			override fun onBackCancelled() {
-				onBackInstance?.cancel()
-				onBackInstance = null
-				onBackInstance?.isPredictiveBack = false
-			}
-		}
-	}
-
-	@RequiresApi(33)
-	private object Api33Impl {
-		@JvmStatic
-		@DoNotInline
-		fun createBackCallback(
-			currentOnBack: State<suspend (Flow<BackEventCompat>) -> Unit>,
-			scope: CoroutineScope,
-		) {
-			OnBackInvokedCallback {
-				scope.launch {
-					currentOnBack.value.invoke(flowOf())
-				}
-			}
-		}
-
-		@JvmStatic
-		@DoNotInline
-		fun maybeRegisterBackCallback(view: View, backCallback: Any?) {
-			if (backCallback !is OnBackInvokedCallback) return
-			val dispatcher = view.findOnBackInvokedDispatcher() ?: return
-			dispatcher.registerOnBackInvokedCallback(
-				OnBackInvokedDispatcher.PRIORITY_OVERLAY,
-				backCallback,
-			)
-		}
-
-		@JvmStatic
-		@DoNotInline
-		fun maybeUnregisterBackCallback(view: View, backCallback: Any?) {
-			if (backCallback !is OnBackInvokedCallback) return
-			view.findOnBackInvokedDispatcher()?.unregisterOnBackInvokedCallback(backCallback)
-		}
-	}
 }
 
 // Fork of androidx.compose.ui.window.DialogWrapper.
@@ -253,7 +131,6 @@ private class ModalSheetDialogLayout(
 internal class ModalSheetDialogWrapper(
 	onPredictiveBack: State<suspend (Flow<BackEventCompat>) -> Unit>,
 	private val composeView: View,
-	scope: CoroutineScope,
 	securePolicy: SecureFlagPolicy,
 	layoutDirection: LayoutDirection,
 	density: Density,
@@ -274,10 +151,9 @@ internal class ModalSheetDialogWrapper(
 		window.setBackgroundDrawableResource(android.R.color.transparent)
 		WindowCompat.setDecorFitsSystemWindows(window, false)
 		dialogLayout = ModalSheetDialogLayout(
-			context,
-			window,
-			onPredictiveBack,
-			scope,
+			context = context,
+			window = window,
+			onPredictiveBack = onPredictiveBack,
 		).apply {
 			// Set unique id for AbstractComposeView. This allows state restoration for the state
 			// defined inside the Dialog via rememberSaveable()
@@ -310,17 +186,6 @@ internal class ModalSheetDialogWrapper(
 		dialogLayout.setViewTreeOnBackPressedDispatcherOwner(this)
 		// Initial setup
 		updateParameters(securePolicy, layoutDirection, darkThemeEnabled)
-
-		// Due to how the onDismissRequest callback works
-		// (it enforces a just-in-time decision on whether to update the state to hide the dialog)
-		// we need to unconditionally add a callback here that is always enabled,
-		// meaning we'll never get a system UI controlled predictive back animation
-		// for these dialogs
-		onBackPressedDispatcher.addCallback(this) {
-			scope.launch {
-				onPredictiveBack.value.invoke(flowOf())
-			}
-		}
 	}
 
 	private fun setLayoutDirection(layoutDirection: LayoutDirection) {
@@ -383,35 +248,6 @@ internal class ModalSheetDialogWrapper(
 	}
 }
 
-private class OnBackInstance(
-	scope: CoroutineScope,
-	var isPredictiveBack: Boolean,
-	onBack: suspend (progress: Flow<BackEventCompat>) -> Unit,
-) {
-	val channel = Channel<BackEventCompat>(capacity = BUFFERED, onBufferOverflow = SUSPEND)
-	val job = scope.launch {
-		var completed = false
-		onBack(
-			channel.consumeAsFlow().onCompletion {
-				completed = true
-			},
-		)
-		check(completed) {
-			"You must collect the progress flow"
-		}
-	}
-
-	fun send(backEvent: BackEventCompat) = channel.trySend(backEvent)
-
-	// idempotent if invoked more than once
-	fun close() = channel.close()
-
-	fun cancel() {
-		channel.cancel(CancellationException("onBack cancelled"))
-		job.cancel()
-	}
-}
-
 internal fun View.isFlagSecureEnabled(): Boolean {
 	val windowParams = rootView.layoutParams as? WindowManager.LayoutParams
 	if (windowParams != null) {