Revert "Implement enter end exit animation for Dialog (#2374)" (#2537)

This reverts commit 8903902. (#2374)

Fixes: https://youtrack.jetbrains.com/issue/CMP-9179

## Release Notes
N/A

Author: ASalavei

compose/ui/ui/src/desktopTest/kotlin/androidx/compose/ui/ImageComposeSceneTest.kt

@@ -26,7 +26,6 @@ import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.material.ExtendedFloatingActionButton
-import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.setValue
@@ -39,7 +38,6 @@ import androidx.compose.ui.window.Dialog
 import kotlin.time.Duration.Companion.seconds
 import kotlin.time.ExperimentalTime
 import kotlinx.coroutines.runBlocking
-import org.jetbrains.skia.Image
 import org.jetbrains.skiko.MainUIDispatcher
 import org.junit.Ignore
 import org.junit.Rule
@@ -96,7 +94,7 @@ class ImageComposeSceneTest {
 
     @Test
     fun `run dialog in center`() {
-        val image = renderComposeSceneOnIdle(
+        val image = renderComposeScene(
             width = 80,
             height = 40,
         ) {
@@ -132,20 +130,4 @@ class ImageComposeSceneTest {
             scene.close()
         }
     }
-}
-
-@OptIn(ExperimentalTime::class)
-private fun renderComposeSceneOnIdle(
-    width: Int,
-    height: Int,
-    density: Density = Density(1f),
-    content: @Composable () -> Unit
-): Image = ImageComposeScene(
-    width = width,
-    height = height,
-    density = density,
-    content = content
-).use {
-    val time = it.runUntilIdle()
-    it.render(time)
 }

compose/ui/ui/src/desktopTest/kotlin/androidx/compose/ui/TestUtils.kt

@@ -41,9 +41,6 @@ import java.awt.image.MultiResolutionImage
 import java.text.AttributedString
 import javax.swing.Icon
 import javax.swing.ImageIcon
-import kotlin.time.Duration
-import kotlin.time.Duration.Companion.milliseconds
-import kotlin.time.ExperimentalTime
 import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.yield
 import org.jetbrains.skiko.MainUIDispatcher
@@ -275,18 +272,4 @@ internal inline fun <R> ImageComposeScene.useInUiThread(
     crossinline block: (ImageComposeScene) -> R
 ): R = runBlocking(MainUIDispatcher) {
     use(block)
-}
-
-@OptIn(ExperimentalTime::class)
-internal fun ImageComposeScene.runUntilIdle(
-    initialTime: Duration = Duration.ZERO,
-    frameDuration: Duration = 16.milliseconds
-): Duration {
-    var time = initialTime
-    render(time)
-    while (hasInvalidations()) {
-        time += frameDuration
-        render(time)
-    }
-    return time
-}
+}

compose/ui/ui/src/skikoMain/kotlin/androidx/compose/ui/ComposeUiFlags.skiko.kt

@@ -17,15 +17,12 @@
 package androidx.compose.ui
 
 import kotlin.jvm.JvmField
+import kotlin.jvm.JvmName
 
 internal object SkikoComposeUiFlags {
     @Suppress("MutableBareField")
     @JvmField
     var useLegacyRenderNodeLayers: Boolean = false
-
-    @Suppress("MutableBareField")
-    @JvmField
-    var isDialogAnimationEnabled: Boolean = true
 }
 
 /**
@@ -36,11 +33,3 @@ internal object SkikoComposeUiFlags {
  */
 @ExperimentalComposeUiApi
 var ComposeUiFlags.useLegacyRenderNodeLayers by SkikoComposeUiFlags::useLegacyRenderNodeLayers
-
-/**
- * When enabled the [androidx.compose.ui.window.Dialog] appear and disappear with animation.
- *
- * Note that it's a temporary flag, it will be removed in the future.
- */
-@ExperimentalComposeUiApi
-var ComposeUiFlags.isDialogAnimationEnabled by SkikoComposeUiFlags::isDialogAnimationEnabled

compose/ui/ui/src/skikoMain/kotlin/androidx/compose/ui/animation/Animation.skiko.kt

@@ -27,22 +27,18 @@ internal fun easeInOutTimingFunction(progress: Float): Float = if (progress < 0.
     (-2f * progress * progress) + (4f * progress) - 1f
 }
 
-internal fun easeOutTimingFunction(progress: Float): Float {
-    return -progress * (progress - 2f)
-}
-
 internal suspend fun withAnimationProgress(
     duration: Duration,
     timingFunction: (Float) -> Float = ::easeInOutTimingFunction,
     update: (Float) -> Unit
 ) {
     update(0f)
 
-    var firstFrameTime: Long? = null
+    var firstFrameTime = 0L
     var progressDuration = Duration.ZERO
     while (progressDuration < duration) {
         withFrameNanos { frameTime ->
-            if (firstFrameTime == null) {
+            if (firstFrameTime == 0L) {
                 firstFrameTime = frameTime
             }
             progressDuration = (frameTime - firstFrameTime).nanoseconds

compose/ui/ui/src/skikoMain/kotlin/androidx/compose/ui/scene/ComposeSceneLayer.skiko.kt

@@ -196,6 +196,11 @@ internal fun rememberComposeSceneLayer(
     layer.density = density
     layer.layoutDirection = layoutDirection
 
+    DisposableEffect(Unit) {
+        onDispose {
+            layer.close()
+        }
+    }
     return layer
 }
 

compose/ui/ui/src/skikoMain/kotlin/androidx/compose/ui/window/Dialog.skiko.kt

@@ -21,24 +21,14 @@ import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.Immutable
 import androidx.compose.runtime.InternalComposeApi
 import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.State
 import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCompositionContext
 import androidx.compose.runtime.rememberUpdatedState
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.ComposeUiFlags
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.MotionDurationScale
-import androidx.compose.ui.animation.easeOutTimingFunction
-import androidx.compose.ui.animation.withAnimationProgress
 import androidx.compose.ui.graphics.BlendMode
 import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.graphicsLayer
 import androidx.compose.ui.input.pointer.PointerButton
 import androidx.compose.ui.input.pointer.PointerEventType
-import androidx.compose.ui.isDialogAnimationEnabled
 import androidx.compose.ui.layout.Layout
 import androidx.compose.ui.platform.LocalPlatformWindowInsets
 import androidx.compose.ui.platform.LocalWindowInfo
@@ -54,25 +44,12 @@ import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.unit.IntRect
 import androidx.compose.ui.unit.IntSize
 import androidx.compose.ui.unit.center
-import kotlin.coroutines.CoroutineContext
-import kotlin.getValue
-import kotlin.setValue
-import kotlin.time.Duration.Companion.seconds
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.CoroutineStart
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.launch
 
 /**
  * The default scrim opacity.
  */
 private const val DefaultScrimOpacity = 0.6f
 private val DefaultScrimColor = Color.Black.copy(alpha = DefaultScrimOpacity)
-private const val AnimatedLayerOffsetDp = 10f
-private const val AnimatedLayerInitialAlpha = 0.2f
-private const val AnimatedLayerScale = 0.05f
-private const val AnimatedLayerAppearanceDuration = 0.2
-private const val AnimatedLayerDisappearanceDuration = 0.1
 
 /**
  * Properties used to customize the behavior of a [Dialog].
@@ -91,7 +68,7 @@ private const val AnimatedLayerDisappearanceDuration = 0.1
  * @property scrimColor Color of background fill.
  */
 @Immutable
-actual class DialogProperties(
+actual class DialogProperties constructor(
     actual val dismissOnBackPress: Boolean = true,
     actual val dismissOnClickOutside: Boolean = true,
     actual val usePlatformDefaultWidth: Boolean = true,
@@ -189,20 +166,13 @@ private fun DialogLayout(
     content: @Composable () -> Unit
 ) {
     val currentContent by rememberUpdatedState(content)
-    val compositionContext = rememberCompositionContext()
-    val layer = rememberComposeSceneLayer(focusable = true)
-    layer.setOutsidePointerEventListener(onOutsidePointerEvent)
-
-    val animator = remember {
-        DialogAppearanceController(layer = layer, coroutineContext = compositionContext.effectCoroutineContext)
-    }
-    animator.scrimColor = properties.scrimColor
 
+    val layer = rememberComposeSceneLayer(
+        focusable = true
+    )
+    layer.scrimColor = properties.scrimColor
+    layer.setOutsidePointerEventListener(onOutsidePointerEvent)
     layer.Content {
-        LaunchedEffect(Unit) {
-            animator.onDialogShown()
-        }
-
         val platformInsets = properties.platformInsets
         val containerSize = LocalWindowInfo.current.containerSize
         val measurePolicy = rememberDialogMeasurePolicy(
@@ -218,120 +188,11 @@ private fun DialogLayout(
         ) {
             Layout(
                 content = currentContent,
-                modifier = animator.modifier.then(modifier),
+                modifier = modifier,
                 measurePolicy = measurePolicy
             )
         }
     }
-
-    DisposableEffect(Unit) {
-        onDispose {
-            animator.hideDialog()
-        }
-    }
-}
-
-private interface DialogAppearanceController {
-    var scrimColor: Color?
-    val modifier: Modifier
-    fun onDialogShown()
-    fun hideDialog()
-}
-
-private fun DialogAppearanceController(
-    layer: ComposeSceneLayer,
-    coroutineContext: CoroutineContext
-): DialogAppearanceController =
-    if (ComposeUiFlags.isDialogAnimationEnabled) {
-        AnimatedDialogAppearanceController(layer, coroutineContext)
-    } else {
-        NonAnimatedDialogAppearanceController(layer)
-    }
-
-private class AnimatedDialogAppearanceController(
-    private val layer: ComposeSceneLayer,
-    private val coroutineContext: CoroutineContext
-) : DialogAppearanceController {
-    private val appearanceProgress = mutableStateOf(0f)
-    private var appearAnimationJob: Job? = null
-
-    override var modifier by mutableStateOf(
-        Modifier.animationLayerTransform(appearanceProgress)
-    )
-        private set
-
-    override var scrimColor: Color? = Color.Transparent
-        set(value) {
-            field = value
-            updateScrimLayerColor()
-        }
-
-    override fun onDialogShown() {
-        appearAnimationJob =
-            CoroutineScope(coroutineContext).launch(start = CoroutineStart.UNDISPATCHED) {
-                withAnimationProgress(
-                    duration = (durationScale() * AnimatedLayerAppearanceDuration).seconds,
-                    timingFunction = ::easeOutTimingFunction
-                ) { progress ->
-                    appearanceProgress.value = progress
-                    updateScrimLayerColor()
-                }
-
-                modifier = Modifier
-                layer.scrimColor = scrimColor
-            }
-    }
-
-    override fun hideDialog() {
-        appearAnimationJob?.cancel()
-        CoroutineScope(coroutineContext).launch(start = CoroutineStart.UNDISPATCHED) {
-            val initialProgress = appearanceProgress.value
-            val duration =
-                durationScale() * initialProgress * AnimatedLayerDisappearanceDuration
-            modifier = Modifier.animationLayerTransform(appearanceProgress)
-
-            withAnimationProgress(
-                duration = duration.seconds,
-                timingFunction = ::easeOutTimingFunction
-            ) { progress ->
-                appearanceProgress.value = (1f - progress) * initialProgress
-                updateScrimLayerColor()
-            }
-
-            layer.close()
-        }
-    }
-
-    private fun updateScrimLayerColor() {
-        layer.scrimColor = scrimColor?.let {
-            it.copy(it.alpha * contentAlpha(appearanceProgress.value))
-        }
-    }
-
-    private fun contentAlpha(progress: Float): Float =
-        AnimatedLayerInitialAlpha + (1f - AnimatedLayerInitialAlpha) * progress
-
-    private fun durationScale(): Float =
-        coroutineContext[MotionDurationScale]?.scaleFactor ?: 1f
-
-    private fun Modifier.animationLayerTransform(progress: State<Float>): Modifier =
-        graphicsLayer {
-            this.alpha = contentAlpha(progress.value)
-            val reversedProgress = 1f - progress.value
-            val scale = 1f - reversedProgress * AnimatedLayerScale
-            this.scaleX = scale
-            this.scaleY = scale
-            this.translationY = AnimatedLayerOffsetDp * reversedProgress * density
-        }
-}
-
-private class NonAnimatedDialogAppearanceController(
-    private val layer: ComposeSceneLayer
-) : DialogAppearanceController {
-    override var scrimColor: Color? by layer::scrimColor
-    override fun onDialogShown() {}
-    override fun hideDialog() = layer.close()
-    override val modifier = Modifier
 }
 
 private val DialogProperties.platformInsets: PlatformInsets

compose/ui/ui/src/skikoMain/kotlin/androidx/compose/ui/window/Popup.skiko.kt

@@ -472,12 +472,6 @@ private fun PopupLayout(
             )
         }
     }
-
-    DisposableEffect(Unit) {
-        onDispose {
-            layer.close()
-        }
-    }
 }
 
 private val PopupProperties.platformInsets: PlatformInsets