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

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

@@ -0,0 +1,398 @@
+package dev.apexnative.navigation.viewcontrollers.modal
+
+import android.animation.Animator
+import android.animation.AnimatorListenerAdapter
+import android.animation.AnimatorSet
+import android.animation.ObjectAnimator
+import android.animation.PropertyValuesHolder
+import android.animation.TimeInterpolator
+import android.content.Context
+import android.view.View
+import android.view.ViewGroup
+import android.view.animation.LinearInterpolator
+import android.widget.FrameLayout
+import androidx.coordinatorlayout.widget.CoordinatorLayout
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsCompat
+import dev.apexnative.navigation.options.ModalAnimationOptions
+import dev.apexnative.navigation.options.Options
+import dev.apexnative.navigation.utils.TestIds
+import dev.apexnative.navigation.viewcontrollers.viewcontroller.ViewController
+import dev.apexnative.navigation.views.animations.AnimationRules
+import dev.apexnative.navigation.views.animations.SideAnimator
+import dev.apexnative.navigation.views.element.ElementTransition
+import dev.apexnative.navigation.views.element.TargetsWait
+import java.util.WeakHashMap
+
+/**
+ * The views of the modals of one activity ([ModalCoordinator.Views]): a [ModalContainer] per modal in the modals
+ * layer, newer above older; the default slide ([ModalAnimations]) or the options' own animation with its elements; the
+ * Material sheet of a modal shown as one (`ModalSheet`); the layer under a modal out of its layer and back; the modals
+ * of an old root carried into the root layer for its transition. The modals layer is visible only while it holds a
+ * modal. Main thread only.
+ */
+internal class ModalViews(
+    // The activity's context: the containers' views are made with it.
+    private val context: Context,
+    private val modalsLayer: FrameLayout,
+    private val rootLayer: FrameLayout,
+) : ModalCoordinator.Views {
+    // The views of one modal; what goes back when its animation of its own ends or stops (its elements).
+    private class Parts(val container: ModalContainer) {
+        var sheet: ModalSheet? = null
+        var animator: Animator? = null
+        var cleanup: (() -> Unit)? = null
+    }
+
+    private val parts = HashMap<ModalRecord, Parts>()
+    private val carried = mutableListOf<ModalRecord>()
+    // The views under a modal that its show's own `exit` moved, and the modal: they go back to rest as they leave the
+    // layout, when the show stops, and when that modal goes unless its dismissal's `enter` took them.
+    private val moved: MutableMap<View, ModalRecord> = WeakHashMap()
+
+    /** The containers of the old root's modals in the root layer: they leave with the old root's transition. */
+    val carriedViews: List<View>
+        get() = carried.mapNotNull { parts[it]?.container }
+
+    override fun place(record: ModalRecord) {
+        val container = ModalContainer(context)
+        container.isWaiting = true
+        container.alpha = 0f
+        container.importantForAccessibility = View.IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS
+        try {
+            val view = record.root.view
+            (view.parent as? ViewGroup)?.removeView(view)
+            // A sheet's content waits at the sheet's full height, under the status bar.
+            val params = CoordinatorLayout.LayoutParams(MATCH, MATCH)
+            if (record.isSheet) params.topMargin = statusBarTop()
+            container.addView(view, params)
+            modalsLayer.addView(container, FrameLayout.LayoutParams(MATCH, MATCH))
+        } catch (e: Throwable) {
+            (container.parent as? ViewGroup)?.removeView(container)
+            throw e
+        }
+        parts[record] = Parts(container)
+        modalsLayer.visibility = View.VISIBLE
+    }
+
+    override fun present(
+        record: ModalRecord,
+        options: Options,
+        animated: Boolean,
+        seen: Boolean,
+        events: ModalSheet.Events,
+        onEnd: () -> Unit,
+        motion: ModalCoordinator.Motion?,
+    ): () -> Unit {
+        val parts = parts[record] ?: return none(onEnd)
+        val container = parts.container
+        container.isWaiting = false
+        container.importantForAccessibility = View.IMPORTANT_FOR_ACCESSIBILITY_AUTO
+        if (record.isSheet) return presentSheet(record, parts, options, seen, events, onEnd)
+        applyTestIds(record, parts, options)
+        if (!animated || !seen) {
+            SideAnimator.rest(container)
+            return none(onEnd)
+        }
+        if (motion != null) {
+            // The modal shows with its alpha at rest; its side writes its own start values.
+            container.alpha = 1f
+            container.translationY = 0f
+            return playOwn(record, parts, motion, showing = true, onEnd)
+        }
+        val distance = distanceOf(container)
+        val animator = ObjectAnimator.ofPropertyValuesHolder(
+            container,
+            PropertyValuesHolder.ofFloat(View.TRANSLATION_Y, distance, 0f),
+            PropertyValuesHolder.ofFloat(View.ALPHA, 0f, 1f),
+        )
+        animator.interpolator = TimeInterpolator { ModalAnimations.decelerate(it) }
+        return play(parts, animator, onEnd)
+    }
+
+    // The root's view leaves the container and goes into the sheet's, in one turn; the sheet slides to its first
+    // detent. Nobody sees the activity: the show counts as done now, the sheet's later end does nothing.
+    private fun presentSheet(
+        record: ModalRecord,
+        parts: Parts,
+        options: Options,
+        seen: Boolean,
+        events: ModalSheet.Events,
+        onEnd: () -> Unit,
+    ): () -> Unit {
+        val container = parts.container
+        val view = record.root.view
+        container.removeView(view)
+        val sheet = ModalSheet(container, view, events)
+        parts.sheet = sheet
+        container.alpha = 1f
+        applyTestIds(record, parts, options)
+        var told = false
+        val shown = {
+            if (!told) {
+                told = true
+                onEnd()
+            }
+        }
+        sheet.show(options.modal.sheet, swipeToDismissOf(options)) { shown() }
+        if (!seen) shown()
+        return { told = true }
+    }
+
+    override fun dismiss(
+        record: ModalRecord,
+        animated: Boolean,
+        seen: Boolean,
+        onEnd: () -> Unit,
+        motion: ModalCoordinator.Motion?,
+    ): () -> Unit {
+        val parts = parts[record] ?: return none(onEnd)
+        stopAnimation(parts)
+        val sheet = parts.sheet
+        if (sheet != null) {
+            if (!seen) return none(onEnd)
+            var told = false
+            sheet.close {
+                if (!told) {
+                    told = true
+                    onEnd()
+                }
+            }
+            return { told = true }
+        }
+        if (!animated || !seen) return none(onEnd)
+        if (motion != null) return playOwn(record, parts, motion, showing = false, onEnd)
+        val container = parts.container
+        val animator = ObjectAnimator.ofPropertyValuesHolder(
+            container,
+            PropertyValuesHolder.ofFloat(View.TRANSLATION_Y, container.translationY, distanceOf(container)),
+            PropertyValuesHolder.ofFloat(View.ALPHA, container.alpha, 0f),
+        )
+        animator.interpolator = TimeInterpolator { ModalAnimations.accelerateDecelerate(it) }
+        return play(parts, animator, onEnd)
+    }
+
+    override fun awaitTargets(
+        record: ModalRecord,
+        animation: ModalAnimationOptions,
+        under: ViewController<*>?,
+        waiting: () -> Boolean,
+        done: () -> Unit,
+    ): () -> Unit = TargetsWait.start(animation, under, record.root, waiting, done)
+
+    override fun remove(record: ModalRecord) {
+        carried -= record
+        val parts = parts.remove(record) ?: return
+        stopAnimation(parts)
+        // What its show's `exit` moved and no dismissal's `enter` took goes back to rest with it.
+        moved.entries.filter { it.value === record }.forEach {
+            moved.remove(it.key)
+            SideAnimator.rest(it.key)
+        }
+        val container = parts.container
+        parts.sheet?.let { sheet ->
+            // The sheet lets go of the window's layout listener through its container's observer: a container out of
+            // the window (under a covering modal) joins the layer for it, unseen, so the observer is the window's.
+            if (container.parent == null) {
+                container.visibility = View.GONE
+                modalsLayer.addView(container, FrameLayout.LayoutParams(MATCH, MATCH))
+            }
+            sheet.remove()
+        }
+        (container.parent as? ViewGroup)?.removeView(container)
+        hideEmptyLayer()
+    }
+
+    override fun settle(record: ModalRecord) {
+        val container = parts[record]?.container ?: return
+        SideAnimator.rest(container)
+    }
+
+    override fun takeOut(record: ModalRecord) {
+        val container = parts[record]?.container ?: return
+        if (moved.remove(container) != null) SideAnimator.rest(container)
+        if (container.parent === modalsLayer) modalsLayer.removeView(container)
+    }
+
+    override fun putBack(record: ModalRecord, at: ModalRecord?) {
+        val container = parts[record]?.container ?: return
+        if (container.parent != null) return
+        val index = at?.let { parts[it]?.container }?.let(modalsLayer::indexOfChild)?.takeIf { it >= 0 }
+        modalsLayer.addView(container, index ?: modalsLayer.childCount, FrameLayout.LayoutParams(MATCH, MATCH))
+        modalsLayer.visibility = View.VISIBLE
+    }
+
+    override fun takeOutRoot(root: ViewController<*>) {
+        val view = root.peekView() ?: return
+        if (moved.remove(view) != null) SideAnimator.rest(view)
+        if (view.parent === rootLayer) rootLayer.removeView(view)
+    }
+
+    override fun putBackRoot(root: ViewController<*>) {
+        val view = root.peekView() ?: return
+        if (view.parent != null) return
+        rootLayer.addView(view, FrameLayout.LayoutParams(MATCH, MATCH))
+    }
+
+    override fun carry(record: ModalRecord, oldRoot: ViewController<*>?) {
+        val container = parts[record]?.container ?: return
+        (container.parent as? ViewGroup)?.removeView(container)
+        // Right above the old root's view and the modals carried before, bottom to top.
+        val below = carriedViews.lastOrNull() ?: oldRoot?.peekView()
+        val index = below?.let(rootLayer::indexOfChild)?.takeIf { it >= 0 }?.plus(1) ?: rootLayer.childCount
+        rootLayer.addView(container, index, FrameLayout.LayoutParams(MATCH, MATCH))
+        carried += record
+        hideEmptyLayer()
+    }
+
+    override fun update(record: ModalRecord, options: Options, move: Boolean) {
+        val parts = parts[record] ?: return
+        applyTestIds(record, parts, options)
+        parts.sheet?.update(options.modal.sheet, swipeToDismissOf(options), move)
+    }
+
+    override fun repaint(record: ModalRecord) {
+        (record.root.peekView()?.parent as? SheetContainer)?.applyBackground()
+    }
+
+    override fun requestLayout(record: ModalRecord) {
+        parts[record]?.container?.requestLayout()
+    }
+
+    // `modal.testID` on the modal's view; a sheet's on the sheet's container, `modal.sheet.testID` first, and its
+    // grabber and scrim after it.
+    private fun applyTestIds(record: ModalRecord, parts: Parts, options: Options) {
+        val modalId = options.modal.testID.value?.ifEmpty { null }
+        if (!record.isSheet) return TestIds.apply(parts.container, modalId)
+        TestIds.apply(parts.container, null)
+        parts.sheet?.setTestIds(options.modal.sheet.testID.value?.ifEmpty { null } ?: modalId)
+    }
+
+    // The modal's own show or dismissal: its side or its fade on its container, the side of the layer under it on that
+    // layer's view, and the elements in a layer between the modals and the overlays. They end together; a stop puts the
+    // elements back and the layer under at rest.
+    private fun playOwn(
+        record: ModalRecord,
+        parts: Parts,
+        motion: ModalCoordinator.Motion,
+        showing: Boolean,
+        onEnd: () -> Unit,
+    ): () -> Unit {
+        val container = parts.container
+        val side = motion.side?.let {
+            SideAnimator.build(container, it, SideAnimator.Base(alpha = if (showing) 1f else null))
+        }
+        val fade = if (side == null && motion.fades) fade(container, showing) else null
+        val underView = motion.under?.let(::viewOf)
+        // The layer a dismissal reveals comes back to its alpha at rest, whatever the show's `exit` left.
+        val underBase = SideAnimator.Base(alpha = if (showing) null else 1f)
+        val under = motion.underSide?.let { side -> underView?.let { SideAnimator.build(it, side, underBase) } }
+        if (under != null && underView != null) {
+            if (showing) moved[underView] = record else moved.remove(underView)
+        }
+        val fadeLength = motion.side?.takeIf(AnimationRules::isSingleAlpha)?.let(AnimationRules::lengthOf)
+        val elements = motion.elements?.let { animation ->
+            val content = modalsLayer.parent as? ViewGroup ?: return@let null
+            val to = motion.to ?: return@let null
+            ElementTransition.startOrLog(
+                animation, motion.from, to, content, content.indexOfChild(modalsLayer) + 1,
+                fadeLength ?: AnimationRules.SCREEN_FADE,
+            )
+        }
+        val animators = listOfNotNull(side, fade, under) + elements?.animators.orEmpty()
+        if (animators.isEmpty()) {
+            elements?.finish()
+            return none(onEnd)
+        }
+        val set = AnimatorSet().apply { playTogether(animators) }
+        parts.cleanup = {
+            elements?.finish()
+            if (showing && underView != null && moved[underView] === record) {
+                moved.remove(underView)
+                SideAnimator.rest(underView)
+            }
+        }
+        set.addListener(object : AnimatorListenerAdapter() {
+            override fun onAnimationEnd(animation: Animator) {
+                if (parts.animator === animation) {
+                    parts.animator = null
+                    // Ended: the elements go back; the layer under stays where its side took it until it leaves.
+                    elements?.finish()
+                    parts.cleanup = null
+                }
+                onEnd()
+            }
+        })
+        parts.animator = set
+        set.start()
+        return {
+            if (parts.animator === set) stopAnimation(parts)
+        }
+    }
+
+    // A modal's animator stops where it is, without its end; what its own animation moved goes back.
+    private fun stopAnimation(parts: Parts) {
+        parts.animator?.let {
+            parts.animator = null
+            it.removeAllListeners()
+            it.cancel()
+        }
+        parts.cleanup?.invoke()
+        parts.cleanup = null
+    }
+
+    // The fade of a modal around elements: in from 0, out from where it is, 300 ms, linearly.
+    private fun fade(view: View, showing: Boolean): Animator {
+        val from = if (showing) 0f else view.alpha
+        view.alpha = from
+        return ObjectAnimator.ofFloat(view, View.ALPHA, from, if (showing) 1f else 0f).apply {
+            duration = AnimationRules.SCREEN_FADE
+            interpolator = LinearInterpolator()
+        }
+    }
+
+    // The view a layer under a modal shows: a modal's container, or the root's view.
+    private fun viewOf(node: ViewController<*>): View? =
+        parts.entries.firstOrNull { it.key.root === node }?.value?.container ?: node.peekView()
+
+    private fun play(parts: Parts, animator: Animator, onEnd: () -> Unit): () -> Unit {
+        animator.duration = ModalAnimations.DURATION
+        animator.addListener(object : AnimatorListenerAdapter() {
+            override fun onAnimationEnd(animation: Animator) {
+                if (parts.animator === animation) parts.animator = null
+                onEnd()
+            }
+        })
+        parts.animator = animator
+        animator.start()
+        return {
+            if (parts.animator === animator) parts.animator = null
+            animator.removeAllListeners()
+            animator.cancel()
+        }
+    }
+
+    // An end at once, and nothing to stop.
+    private fun none(onEnd: () -> Unit): () -> Unit {
+        onEnd()
+        return {}
+    }
+
+    private fun hideEmptyLayer() {
+        if (modalsLayer.childCount == 0) modalsLayer.visibility = View.GONE
+    }
+
+    // The window's height at the start, the display's while the window has none.
+    private fun distanceOf(view: View): Float =
+        ModalAnimations.distance(view.rootView?.height ?: 0, view.resources.displayMetrics.heightPixels)
+
+    private fun statusBarTop(): Int =
+        ViewCompat.getRootWindowInsets(modalsLayer)?.getInsets(WindowInsetsCompat.Type.systemBars())?.top ?: 0
+
+    private companion object {
+        const val MATCH = ViewGroup.LayoutParams.MATCH_PARENT
+
+        // `modal.swipeToDismiss`, `true` by default.
+        fun swipeToDismissOf(options: Options): Boolean = !options.modal.swipeToDismiss.isFalse
+    }
+}

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

@@ -0,0 +1,67 @@
+package dev.apexnative.navigation.viewcontrollers.modal
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.content.res.Configuration
+import android.graphics.Color
+import android.view.View
+import android.widget.FrameLayout
+import com.google.android.material.R as MaterialR
+import com.google.android.material.color.MaterialColors
+
+/**
+ * The container of a modal shown as a sheet (`ModalSheet`), which its bottom sheet behavior moves. Its background is
+ * Material 3's "surface container low" of its context (the app's Material 3 theme, else the navigation's neutral one),
+ * read again after a light/dark switch. A view in it that measures where it is in the window counts the sheet where it
+ * rests, not where a drag took it ([shift]).
+ */
+@SuppressLint("ViewConstructor")
+class SheetContainer(context: Context) : FrameLayout(context) {
+    /**
+     * How far the sheet is below where it rests, in pixels: fully raised, its bottom at the bottom of its layout. The
+     * behavior moves the sheet only by `offsetTopAndBottom` and lays it out again in `onLayout`; both keep it up to
+     * date, so a drag moves the sheet and the place of rest stays.
+     */
+    var shift = 0
+        private set
+
+    init {
+        applyBackground()
+    }
+
+    /** The background of the sheet in the colors of its theme now: after a light/dark switch too. */
+    fun applyBackground() {
+        setBackgroundColor(MaterialColors.getColor(context, MaterialR.attr.colorSurfaceContainerLow, Color.WHITE))
+    }
+
+    override fun onConfigurationChanged(newConfig: Configuration?) {
+        super.onConfigurationChanged(newConfig)
+        applyBackground()
+    }
+
+    override fun offsetTopAndBottom(offset: Int) {
+        super.offsetTopAndBottom(offset)
+        updateShift()
+    }
+
+    override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
+        super.onLayout(changed, left, top, right, bottom)
+        updateShift()
+    }
+
+    private fun updateShift() {
+        val parent = parent as? View ?: return
+        shift = shiftOf(top, height, parent.height)
+    }
+
+    companion object {
+        /**
+         * How far a sheet whose top is at [top], [height] tall, is below its place of rest in a layout [parentHeight]
+         * tall: its rest is fully raised, its bottom at the layout's bottom.
+         */
+        fun shiftOf(top: Int, height: Int, parentHeight: Int): Int = top - (parentHeight - height)
+
+        /** Where a sheet whose top is at [top] and that is [shift] below its rest has its top at rest. */
+        fun restTop(top: Int, shift: Int): Int = top - shift
+    }
+}

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/navigator/BackCallbackState.kt

@@ -0,0 +1,78 @@
+package dev.apexnative.navigation.viewcontrollers.navigator
+
+import android.util.Log
+import androidx.activity.OnBackPressedCallback
+import dev.apexnative.navigation.utils.NavigationLog
+import java.lang.ref.WeakReference
+
+/**
+ * Keeps the back callback of each navigation activity enabled only while back has something to do in the app: its
+ * navigation can go back ([Navigator.canHandleBack]), or JavaScript listens to it (`BackHandler`). Otherwise the
+ * callback is disabled and the system does its own back. The system plays its back animation (to the home screen, to
+ * another task) only when no callback of the app is enabled as the gesture starts, and it decides that before the app
+ * hears of the gesture.
+ *
+ * A stale "enabled" only loses that animation; a stale "disabled" would leave the app where back has to go back. So
+ * the value is computed again whenever what back does can have changed: before each frame of the activity's window,
+ * when a command is done, when JavaScript reports its listeners, and when a side menu, the panes of a split view or a
+ * search open or close (the first two after their last frame). Each activity has its own navigator and callback; the
+ * listeners of JavaScript count for all of them. Main thread only.
+ */
+internal object BackCallbackState {
+    private class Entry(navigator: Navigator, callback: OnBackPressedCallback) {
+        val navigator = WeakReference(navigator)
+        val callback = WeakReference(callback)
+    }
+
+    private val entries = mutableListOf<Entry>()
+    // JavaScript has `BackHandler` listeners. New JavaScript (a reload) starts without them and reports its own.
+    private var jsListeners = false
+    private var failureLogged = false
+
+    /** The navigator and the back callback of an activity, until [detach]. */
+    fun attach(navigator: Navigator, callback: OnBackPressedCallback) {
+        detach(navigator)
+        val entry = Entry(navigator, callback)
+        entries += entry
+        update(entry)
+    }
+
+    fun detach(navigator: Navigator) {
+        entries.removeAll { it.navigator.get().let { attached -> attached == null || attached === navigator } }
+    }
+
+    /** `setBackListeners` of JavaScript; false again when its JavaScript goes. */
+    fun setJsListeners(active: Boolean) {
+        jsListeners = active
+        update()
+    }
+
+    /** The callback of every activity: after a change that can be in any of them. */
+    fun update() {
+        for (entry in entries.toList()) update(entry)
+    }
+
+    /** The callback of the activity of [navigator]: before its frames and at its back presses. */
+    fun update(navigator: Navigator) {
+        entries.firstOrNull { it.navigator.get() === navigator }?.let(::update)
+    }
+
+    // Enables or disables the callback when what back does changed.
+    private fun update(entry: Entry) {
+        val callback = entry.callback.get() ?: return
+        val enabled = jsListeners || canHandleBack(entry.navigator.get())
+        if (callback.isEnabled != enabled) callback.isEnabled = enabled
+    }
+
+    // A layout that fails to answer leaves back to the navigation, as before: this runs before each frame, and an
+    // exception here would end the app.
+    private fun canHandleBack(navigator: Navigator?): Boolean = try {
+        navigator?.canHandleBack() == true
+    } catch (e: RuntimeException) {
+        if (!failureLogged) {
+            failureLogged = true
+            Log.e(NavigationLog.TAG, "canHandleBack failed: the back callback stays enabled", e)
+        }
+        true
+    }
+}

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/navigator/FirstRootDraw.kt

@@ -0,0 +1,58 @@
+package dev.apexnative.navigation.viewcontrollers.navigator
+
+import dev.apexnative.navigation.options.params.Bool
+import dev.apexnative.navigation.react.events.AppearanceDispatcher
+
+/**
+ * When an activity's first root counts as drawn: the splash's hold of the window (`SplashHold`) lets frames through
+ * from then on. Drawn when the first root is up and opaque — it goes up once its screens rendered, or at the limit of
+ * its wait —; or [LIMIT_MILLIS] after the first `setRoot` whose root's `animations.setRoot.enter.waitForRender` isn't
+ * `true`; at once with `false`; at once when a root that was on its way is destroyed. Drawn once, drawn for good:
+ * [onDrawn] runs once. Main thread only.
+ */
+internal class FirstRootDraw(
+    private val scheduler: AppearanceDispatcher.Scheduler,
+    private val onDrawn: () -> Unit,
+) {
+    /** The first root has drawn, or the hold may end anyway. */
+    var isDrawn = false
+        private set
+
+    private var cancelLimit: (() -> Unit)? = null
+
+    /** A `setRoot` of this activity starts, with its root's `enter.waitForRender`. */
+    fun rootSet(waitForRender: Bool) {
+        if (isDrawn) return
+        if (waitForRender.isFalse) return drawn()
+        if (waitForRender.isTrue || cancelLimit != null) return
+        cancelLimit = scheduler.schedule(LIMIT_MILLIS) {
+            cancelLimit = null
+            drawn()
+        }
+    }
+
+    /** A root went up, opaque. */
+    fun rootUp() = drawn()
+
+    /** A root on its way was destroyed before it went up. */
+    fun rootDestroyed() = drawn()
+
+    /** The activity goes: nothing runs later. */
+    fun cancel() {
+        val cancel = cancelLimit ?: return
+        cancelLimit = null
+        cancel()
+    }
+
+    private fun drawn() {
+        if (isDrawn) return
+        isDrawn = true
+        cancel()
+        onDrawn()
+    }
+
+    companion object {
+        /** How long after the first `setRoot` the hold lasts at most, unless its root waits for its render. */
+        const val LIMIT_MILLIS = 500L
+    }
+}