@apexnative/navigation 0.0.0-stage → 1.0.0-alpha.0

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/externalcomponent/NativeScreens.kt

@@ -0,0 +1,25 @@
+package dev.apexnative.navigation.viewcontrollers.externalcomponent
+
+import dev.apexnative.navigation.nativescreen.NativeScreenContext
+import dev.apexnative.navigation.viewcontrollers.navigator.Navigators
+import dev.apexnative.navigation.viewcontrollers.viewcontroller.ViewController
+
+/** The core's side of the commands of native screens (`updateNativeScreenProps`). Main thread only. */
+internal object NativeScreens {
+    /**
+     * The node with [componentId]: in the navigation of the activity commands run in first, then in the others, newest
+     * first (an activity going while a new one shows the same ids); none when there is none.
+     */
+    fun find(componentId: String): ViewController<*>? =
+        Navigators.current()?.navigator?.registry?.find(componentId)
+            ?: Navigators.all().asReversed().firstNotNullOfOrNull { it.navigator?.registry?.find(componentId) }
+
+    /**
+     * The context that takes new props for [node]: a native screen's, at once, during a transition too; none for any
+     * other node, for none, and for a screen that left the layout.
+     */
+    fun contextOf(node: ViewController<*>?): NativeScreenContext? {
+        val screen = node as? ExternalComponentViewController ?: return null
+        return if (screen.isDestroyed) null else screen.context
+    }
+}

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/modal/ModalAnimations.kt

@@ -0,0 +1,40 @@
+package dev.apexnative.navigation.viewcontrollers.modal
+
+import kotlin.math.PI
+import kotlin.math.cos
+
+/**
+ * The default animations of a modal on Android, as values: it comes up from the bottom of the window by the window's
+ * height (in a split screen or a window, the window's, not the display's) and fades in, [DURATION] with a deceleration
+ * at the end; it goes down and fades out in the same time, accelerating and decelerating (the system's cosine, not the
+ * option's `accelerateDecelerate`). A sheet moves only by the Material sheet's own motion. Pure arithmetic.
+ */
+internal object ModalAnimations {
+    /** How long the default show and the default dismissal last (ms). */
+    const val DURATION = 300L
+
+    /** How far a modal comes up and goes down: the window's height ([windowHeight]), or the display's while it is 0. */
+    fun distance(windowHeight: Int, displayHeight: Int): Float =
+        (if (windowHeight > 0) windowHeight else displayHeight).toFloat()
+
+    /** The curve of the show: a deceleration, 1 − (1 − p)². */
+    fun decelerate(progress: Float): Float = 1f - (1f - progress) * (1f - progress)
+
+    /** The curve of the dismissal: an acceleration then a deceleration, cos((p + 1)π) / 2 + 0.5. */
+    fun accelerateDecelerate(progress: Float): Float = (cos((progress + 1) * PI) / 2 + 0.5).toFloat()
+
+    /** Where a modal is at [progress] (0 … 1, in time) of its show over [distance]: its translation and its alpha. */
+    fun show(progress: Float, distance: Float): Frame {
+        val value = decelerate(progress)
+        return Frame(translationY = distance * (1f - value), alpha = value)
+    }
+
+    /** Where a modal is at [progress] of its dismissal over [distance], from where it rests. */
+    fun dismiss(progress: Float, distance: Float): Frame {
+        val value = accelerateDecelerate(progress)
+        return Frame(translationY = distance * value, alpha = 1f - value)
+    }
+
+    /** A modal's place in its animation. */
+    data class Frame(val translationY: Float, val alpha: Float)
+}

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/modal/ModalContainer.kt

@@ -0,0 +1,20 @@
+package dev.apexnative.navigation.viewcontrollers.modal
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.view.MotionEvent
+import androidx.coordinatorlayout.widget.CoordinatorLayout
+
+/**
+ * The view of one modal in the modals layer: full size, newer above older; the modal's root
+ * view is its child, or, for a sheet, the scrim and the container of its Material sheet, whose behavior needs a
+ * `CoordinatorLayout` and sees only this modal's touches. While the modal waits to show it is transparent and gives
+ * every touch away, so the screen under keeps them ([isWaiting]).
+ */
+@SuppressLint("ViewConstructor")
+internal class ModalContainer(context: Context) : CoordinatorLayout(context) {
+    /** The modal waits to show: touches go to the layers under it. */
+    var isWaiting = true
+
+    override fun dispatchTouchEvent(event: MotionEvent): Boolean = !isWaiting && super.dispatchTouchEvent(event)
+}