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

package/android/src/main/java/dev/apexnative/navigation/utils/MaterialTheme.kt

@@ -0,0 +1,148 @@
+package dev.apexnative.navigation.utils
+
+import android.app.Activity
+import android.content.Context
+import android.content.ContextWrapper
+import android.content.pm.PackageManager
+import android.content.res.Configuration
+import android.content.res.Resources
+import android.os.Build
+import android.util.TypedValue
+import android.view.ContextThemeWrapper
+import androidx.appcompat.R as AppCompatR
+import androidx.appcompat.view.ContextThemeWrapper as AppCompatThemeWrapper
+import com.google.android.material.R as MaterialR
+import dev.apexnative.navigation.R
+import dev.apexnative.navigation.splash.SplashTheme
+import java.lang.ref.WeakReference
+import java.util.WeakHashMap
+
+/**
+ * Where the navigation's Material 3 views and default colors come from: the app's theme when it is a Material 3 one
+ * (`Theme.ApexNavigation` or the app's own), otherwise the navigation's neutral `Theme.ApexNavigation` over it, light or
+ * dark with the app. Main thread only.
+ */
+internal object MaterialTheme {
+    // A theme is costly to build and the top bar asks for its colors several times an update. The wrapper is held
+    // weakly: it holds its base context, which a strong value would keep from ever going.
+    private val wrappers = WeakHashMap<Context, WeakReference<Context>>()
+    // Themes of the navigation's own views, each made once over the activity's with a style of its own.
+    private val followers = WeakHashMap<Context, Int>()
+    // The popup theme of the bar's toolbars per activity: the app's theme doesn't change while the activity lives.
+    private val popupThemes = WeakHashMap<Activity, Int>()
+
+    fun context(context: Context): Context {
+        if (isMaterial3(context)) return context
+        wrappers[context]?.get()?.let { return it }
+        return ContextThemeWrapper(context, R.style.Theme_ApexNavigation).also { wrappers[context] = WeakReference(it) }
+    }
+
+    /**
+     * The popup theme of the top bar's toolbars, for "⋮", set on them before their menu is made. None when the app's
+     * theme follows light and dark: the menu takes the bar's own theme, which [rebase] keeps in the current mode, with
+     * the app's colors. With a Material 3 theme fixed to light or to dark, a day/night overlay that gives the menu the
+     * current mode's colors where the theme shows the other mode. Android makes the menu's theme from it at the menu's
+     * first opening, in the mode of that moment, and no public API makes it again for a later switch.
+     */
+    fun popupTheme(context: Context): Int {
+        val activity = activityOf(context) ?: return 0
+        popupThemes[activity]?.let { return it }
+        return fixedPopupTheme(activity).also { popupThemes[activity] = it }
+    }
+
+    /**
+     * A theme made once over the activity's, with [style] over it: [rebase] applies it again too. With no style (0), as
+     * for Material's own theme overlays, only from Android 10 on, where a theme can be rebased as it is.
+     */
+    @JvmStatic
+    fun follow(wrapper: Context, style: Int) {
+        followers[wrapper] = style
+    }
+
+    /**
+     * A Material view's own copy of the theme ([wrapper], the view's context), made with the overlay its style names
+     * (`materialThemeOverlay`): followed with that overlay, so before Android 10 it is applied again too and the view
+     * takes the new mode's colors; from Android 10 the copy is rebased as it is. A context without an overlay of its
+     * own is followed as it is.
+     */
+    fun followOverlay(wrapper: Context) = follow(wrapper, (wrapper as? AppCompatThemeWrapper)?.themeResId ?: 0)
+
+    /**
+     * A light/dark switch the activity takes itself (`configChanges` with `uiMode`, the activity isn't recreated):
+     * Android updates the resources in place but not the themes made from them, and every color read from those stays
+     * the old mode's. The activity's theme and the navigation's own are applied again, before the controllers and the
+     * views read their colors again.
+     */
+    @JvmStatic
+    fun rebase(activity: Activity) {
+        val activityTheme = activityTheme(activity)
+        rebase(activity.theme, activityTheme)
+        // A follower made over the navigation's own theme (the app's isn't Material 3) takes that theme again too, or
+        // before Android 10 it keeps the old mode's colors of it.
+        val neutral = if (isMaterial3(activity)) 0 else R.style.Theme_ApexNavigation
+        followers.forEach { (wrapper, style) ->
+            if (style != 0 || Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                rebase(wrapper.theme, activityTheme, neutral, style)
+            }
+        }
+        wrappers.values.forEach { wrapper ->
+            wrapper.get()?.let { rebase(it.theme, activityTheme, R.style.Theme_ApexNavigation) }
+        }
+    }
+
+    // Before Android 10, which has Theme.rebase, the styles are applied again over the theme, as AppCompat does.
+    private fun rebase(theme: Resources.Theme, vararg styles: Int) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            theme.rebase()
+        } else {
+            styles.filter { it != 0 }.forEach { theme.applyStyle(it, true) }
+        }
+    }
+
+    // The theme the activity runs with: the manifest's, or the app's theme that a splash theme there names, which the
+    // activity took in onCreate.
+    private fun activityTheme(activity: Activity): Int = try {
+        SplashTheme.appTheme(activity, activity.packageManager.getActivityInfo(activity.componentName, 0).themeResource)
+    } catch (e: PackageManager.NameNotFoundException) {
+        0
+    }
+
+    // The overlay for the menu of an app's Material 3 theme that shows one mode in both; none for a theme that follows
+    // the mode, as the navigation's own does, which an app's theme that isn't Material 3 gets.
+    private fun fixedPopupTheme(activity: Activity): Int {
+        val style = activityTheme(activity)
+        if (style == 0 || !isMaterial3(activity)) return 0
+        val light = isLight(activity.theme) ?: return 0
+        val config = Configuration(activity.resources.configuration)
+        val night = config.uiMode and Configuration.UI_MODE_NIGHT_MASK == Configuration.UI_MODE_NIGHT_YES
+        val other = if (night) Configuration.UI_MODE_NIGHT_NO else Configuration.UI_MODE_NIGHT_YES
+        config.uiMode = (config.uiMode and Configuration.UI_MODE_NIGHT_MASK.inv()) or other
+        val otherTheme = activity.createConfigurationContext(config).resources.newTheme()
+        otherTheme.applyStyle(style, true)
+        if (isLight(otherTheme) != light) return 0
+        return if (light) {
+            R.style.ThemeOverlay_ApexNavigation_TopBar_PopupOverLight
+        } else {
+            R.style.ThemeOverlay_ApexNavigation_TopBar_PopupOverDark
+        }
+    }
+
+    private fun isLight(theme: Resources.Theme): Boolean? {
+        val value = TypedValue()
+        if (!theme.resolveAttribute(AppCompatR.attr.isLightTheme, value, true)) return null
+        return value.data != 0
+    }
+
+    private fun activityOf(context: Context): Activity? {
+        var current: Context? = context
+        while (current is ContextWrapper) {
+            if (current is Activity) return current
+            current = current.baseContext
+        }
+        return null
+    }
+
+    // A role only Material 3 themes have.
+    private fun isMaterial3(context: Context) =
+        context.theme.resolveAttribute(MaterialR.attr.colorSurfaceContainerHigh, TypedValue(), true)
+}

package/android/src/main/java/dev/apexnative/navigation/utils/NavigationLog.kt

@@ -0,0 +1,6 @@
+package dev.apexnative.navigation.utils
+
+/** The tag of every log line of the library: `adb logcat -s ApexNavigation` shows them all. */
+internal object NavigationLog {
+    const val TAG = "ApexNavigation"
+}

package/android/src/main/java/dev/apexnative/navigation/utils/ScrollToTop.kt

@@ -0,0 +1,33 @@
+package dev.apexnative.navigation.utils
+
+import android.view.View
+import android.view.ViewGroup
+import android.widget.AbsListView
+import android.widget.ScrollView
+import androidx.core.widget.NestedScrollView
+
+/**
+ * Scrolls the first view under [root] that scrolls up and down back to its top, depth first: a screen's list. A
+ * React Native list is a [ScrollView]; a RecyclerView is told by its name, so the module doesn't depend on it.
+ */
+fun scrollToTop(root: View): Boolean {
+    val view = firstVerticalScroller(root) ?: return false
+    when (view) {
+        is ScrollView -> view.smoothScrollTo(view.scrollX, 0)
+        is NestedScrollView -> view.smoothScrollTo(view.scrollX, 0)
+        is AbsListView -> view.smoothScrollToPosition(0)
+        else -> runCatching {
+            view.javaClass.getMethod("smoothScrollToPosition", Int::class.javaPrimitiveType).invoke(view, 0)
+        }
+    }
+    return true
+}
+
+private fun firstVerticalScroller(view: View): View? {
+    if (view.visibility != View.VISIBLE) return null
+    if (view.canScrollVertically(-1)) return view
+    if (view is ViewGroup) {
+        for (index in 0 until view.childCount) firstVerticalScroller(view.getChildAt(index))?.let { return it }
+    }
+    return null
+}

package/android/src/main/java/dev/apexnative/navigation/utils/SystemUiUtils.kt

@@ -0,0 +1,41 @@
+package dev.apexnative.navigation.utils
+
+import android.app.Activity
+import android.content.res.Resources
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsCompat
+import kotlin.math.roundToInt
+
+/** The system bars of an activity's window. */
+object SystemUiUtils {
+    private const val FALLBACK_STATUS_BAR_DP = 24f
+
+    /**
+     * The height of the status bar over the window of [activity], in pixels: the window's status bar inset, shown or
+     * not, so it follows a rotation, a cutout, a split screen and a window of any size; before the window has insets
+     * the system's `status_bar_height`, without it 24 dp.
+     */
+    @JvmStatic
+    fun getStatusBarHeight(activity: Activity): Int {
+        val decor = activity.window?.peekDecorView()
+        val insets = decor?.let(ViewCompat::getRootWindowInsets)
+        val inset = insets?.getInsetsIgnoringVisibility(WindowInsetsCompat.Type.statusBars())?.top
+        if (inset != null) return inset
+        val density = activity.resources?.displayMetrics?.density ?: 1f
+        return statusBarHeight(null, systemStatusBarHeight(), density)
+    }
+
+    /**
+     * As a rule: the window's [inset] when it has one; else the system's dimension ([systemDimension], 0 when it has
+     * none); else 24 dp at [density].
+     */
+    internal fun statusBarHeight(inset: Int?, systemDimension: Int, density: Float): Int =
+        inset ?: systemDimension.takeIf { it > 0 } ?: (FALLBACK_STATUS_BAR_DP * density).roundToInt()
+
+    // The `android` package's `status_bar_height`: the platform's default, without a cutout; 0 without it.
+    private fun systemStatusBarHeight(): Int {
+        val resources: Resources = Resources.getSystem() ?: return 0
+        val id = resources.getIdentifier("status_bar_height", "dimen", "android")
+        return if (id != 0) resources.getDimensionPixelSize(id) else 0
+    }
+}

package/android/src/main/java/dev/apexnative/navigation/utils/TestIds.kt

@@ -0,0 +1,89 @@
+package dev.apexnative.navigation.utils
+
+import android.os.Build
+import android.os.Bundle
+import android.view.View
+import android.view.ViewGroup
+import android.view.accessibility.AccessibilityEvent
+import android.view.accessibility.AccessibilityNodeInfo
+import android.view.accessibility.AccessibilityNodeProvider
+import androidx.annotation.RequiresApi
+import androidx.core.view.AccessibilityDelegateCompat
+import androidx.core.view.ViewCompat
+import androidx.core.view.accessibility.AccessibilityNodeInfoCompat
+
+/**
+ * The `testID` of a view the core draws: the view's tag and the `resource-id` of its accessibility node
+ * (`viewIdResourceName`), which UiAutomator, Appium and Maestro read. A view without one has none: a view used again
+ * loses the one it had. Main thread only.
+ */
+internal object TestIds {
+    fun apply(view: View, testId: String?) {
+        val id = testId?.ifEmpty { null }
+        view.tag = id
+        ViewCompat.setAccessibilityDelegate(view, id?.let(::IdDelegate))
+    }
+
+    /**
+     * As [apply], for a view with an accessibility delegate of its own (Material's sheet drag handle: its clicks and
+     * the sheet's state): the delegate stays and the id comes over it. Android 10+ gives the view's delegate
+     * (`View.getAccessibilityDelegate`); before that only the tag is set, and the delegate isn't replaced.
+     */
+    fun applyOver(view: View, testId: String?) {
+        val id = testId?.ifEmpty { null }
+        view.tag = id
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) return
+        val current = view.accessibilityDelegate
+        val own = (current as? OverDelegate)?.own ?: current
+        view.accessibilityDelegate = if (id == null) own else OverDelegate(id, own)
+    }
+
+    private class IdDelegate(private val id: String) : AccessibilityDelegateCompat() {
+        override fun onInitializeAccessibilityNodeInfo(host: View, info: AccessibilityNodeInfoCompat) {
+            super.onInitializeAccessibilityNodeInfo(host, info)
+            info.viewIdResourceName = id
+        }
+    }
+
+    // The view's own delegate answers everything; the node gets the id after it.
+    @RequiresApi(Build.VERSION_CODES.Q)
+    private class OverDelegate(private val id: String, val own: View.AccessibilityDelegate?) :
+        View.AccessibilityDelegate() {
+        private val inner = own ?: View.AccessibilityDelegate()
+
+        override fun onInitializeAccessibilityNodeInfo(host: View, info: AccessibilityNodeInfo) {
+            inner.onInitializeAccessibilityNodeInfo(host, info)
+            info.viewIdResourceName = id
+        }
+
+        override fun sendAccessibilityEvent(host: View, eventType: Int) = inner.sendAccessibilityEvent(host, eventType)
+
+        override fun performAccessibilityAction(host: View, action: Int, args: Bundle?): Boolean =
+            inner.performAccessibilityAction(host, action, args)
+
+        override fun sendAccessibilityEventUnchecked(host: View, event: AccessibilityEvent) =
+            inner.sendAccessibilityEventUnchecked(host, event)
+
+        override fun dispatchPopulateAccessibilityEvent(host: View, event: AccessibilityEvent): Boolean =
+            inner.dispatchPopulateAccessibilityEvent(host, event)
+
+        override fun onPopulateAccessibilityEvent(host: View, event: AccessibilityEvent) =
+            inner.onPopulateAccessibilityEvent(host, event)
+
+        override fun onInitializeAccessibilityEvent(host: View, event: AccessibilityEvent) =
+            inner.onInitializeAccessibilityEvent(host, event)
+
+        override fun addExtraDataToAccessibilityNodeInfo(
+            host: View,
+            info: AccessibilityNodeInfo,
+            extraDataKey: String,
+            arguments: Bundle?,
+        ) = inner.addExtraDataToAccessibilityNodeInfo(host, info, extraDataKey, arguments)
+
+        override fun onRequestSendAccessibilityEvent(host: ViewGroup, child: View, event: AccessibilityEvent): Boolean =
+            inner.onRequestSendAccessibilityEvent(host, child, event)
+
+        override fun getAccessibilityNodeProvider(host: View): AccessibilityNodeProvider? =
+            inner.getAccessibilityNodeProvider(host)
+    }
+}

package/android/src/main/java/dev/apexnative/navigation/utils/TextViewUtils.kt

@@ -0,0 +1,10 @@
+package dev.apexnative.navigation.utils
+
+import android.widget.TextView
+
+/** What texts show. */
+object TextViewUtils {
+    /** The size of the text of [view], in pixels; 0 without one. */
+    @JvmStatic
+    fun getTextSize(view: TextView): Float = view.textSize
+}

package/android/src/main/java/dev/apexnative/navigation/utils/UiThread.kt

@@ -0,0 +1,31 @@
+package dev.apexnative.navigation.utils
+
+import android.os.Handler
+import android.os.Looper
+
+/** The main thread, where the navigation changes its views and its state. */
+object UiThread {
+    private val handler = Handler(Looper.getMainLooper())
+
+    /** Runs [task] on the main thread on a later pass of its loop. */
+    @JvmStatic
+    fun post(task: Runnable) {
+        handler.post(task)
+    }
+
+    /** Runs [task] at once when the caller is on the main thread, else on a later pass of its loop. */
+    @JvmStatic
+    fun runOnMain(task: Runnable) {
+        if (isMainThread()) task.run() else handler.post(task)
+    }
+
+    /** Runs [task] on the main thread after [delay] milliseconds. */
+    @JvmStatic
+    fun postDelayed(task: Runnable, delay: Long) {
+        handler.postDelayed(task, delay)
+    }
+
+    /** Whether the caller runs on the main thread. */
+    @JvmStatic
+    fun isMainThread(): Boolean = Looper.myLooper() == Looper.getMainLooper()
+}

package/android/src/main/java/dev/apexnative/navigation/utils/UiUtils.kt

@@ -0,0 +1,43 @@
+package dev.apexnative.navigation.utils
+
+import android.content.Context
+import android.util.TypedValue
+import kotlin.math.roundToInt
+
+/** Sizes on the screen: dp and sp of the options into pixels of the views. */
+object UiUtils {
+    private const val BASE_DENSITY_DPI = 160
+
+    /** [dp] in pixels on the screen of [context]. */
+    @JvmStatic
+    fun dpToPx(context: Context, dp: Float): Float =
+        TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, dp, context.resources.displayMetrics)
+
+    /** [dp] in whole pixels on the screen of [context]. */
+    @JvmStatic
+    fun dpToPx(context: Context, dp: Int): Int = dpToPx(context, dp.toFloat()).roundToInt()
+
+    /** [px] pixels in dp on the screen of [context]. */
+    @JvmStatic
+    fun pxToDp(context: Context, px: Float): Float = px / context.resources.displayMetrics.density
+
+    /**
+     * A size of the options in dp, in whole pixels of the screen of [context]: times `densityDpi / 160`, the fraction
+     * of a pixel dropped; a size of 0 or less is not converted.
+     */
+    @JvmStatic
+    fun dpToPixels(context: Context, dp: Double): Int = dpToPixels(dp, context.resources.displayMetrics.densityDpi)
+
+    /** [dp] in whole pixels at [densityDpi], as [dpToPixels] converts it. */
+    @JvmStatic
+    fun dpToPixels(dp: Double, densityDpi: Int): Int =
+        if (dp <= 0) dp.toInt() else (dp * densityDpi / BASE_DENSITY_DPI).toInt()
+
+    /**
+     * A font size of the options in sp, in pixels of the screen of [context]: it follows the system's text scale,
+     * non-linearly where the system scales so.
+     */
+    @JvmStatic
+    fun spToPixels(context: Context, sp: Double): Float =
+        TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_SP, sp.toFloat(), context.resources.displayMetrics)
+}

package/android/src/main/java/dev/apexnative/navigation/utils/ViewController.kt

@@ -0,0 +1,124 @@
+package dev.apexnative.navigation.utils
+
+import android.os.SystemClock
+import android.view.Choreographer
+import android.view.View
+import androidx.core.view.OneShotPreDrawListener
+import dev.apexnative.navigation.options.params.Bool
+import dev.apexnative.navigation.viewcontrollers.parent.ParentController
+import dev.apexnative.navigation.viewcontrollers.stack.StackController
+import dev.apexnative.navigation.viewcontrollers.viewcontroller.ViewController
+import dev.apexnative.navigation.views.component.ComponentLayout
+import dev.apexnative.navigation.views.component.Renderable
+
+/**
+ * How long a modal, a root or a stack's new root waits for its screen and the components of its bar to draw, unless
+ * waitForRender is set; how long the push of a prepared screen waits for its slot's content to mount.
+ */
+const val DRAW_WAIT_LIMIT = 500L
+
+/**
+ * Runs [start] on a frame once the components of the bar over this screen (title, buttons, background) have drawn, or
+ * at [deadline] (uptime millis), while [waiting] holds. A stack waits for those of its screen on top.
+ */
+fun ViewController<*>.awaitBarComponents(deadline: Long, waiting: () -> Boolean, start: Runnable) {
+    // A root of tabs or of a side menu waits for the bar of the stack it shows, as a stack for that of its top screen.
+    val parentStack = findParentStack()
+    val stack = parentStack ?: shownStack()
+    val screen: ViewController<*>? = when {
+        this is StackController -> currentChild
+        parentStack == null -> stack?.currentChild
+        else -> this
+    }
+    Choreographer.getInstance().postFrameCallback(object : Choreographer.FrameCallback {
+        override fun doFrame(frameTimeNanos: Long) {
+            if (!waiting() || isDestroyed) return
+            if (stack == null || screen == null || stack.areBarComponentsDrawn(screen) ||
+                    SystemClock.uptimeMillis() >= deadline) {
+                start.run()
+            } else {
+                Choreographer.getInstance().postFrameCallback(this)
+            }
+        }
+    })
+}
+private fun ViewController<*>.shownStack(): StackController? {
+    var controller: ViewController<*>? = this
+    while (controller is ParentController<*> && controller !is StackController) controller = controller.currentChild
+    return controller as? StackController
+}
+
+// Whether where it goes shows: a stack in a tab that is not selected, or a root under a modal, does not. There it would
+// never appear and the wait would never end: it starts at once, and is drawn by the time it comes on screen.
+private fun ViewController<*>.hostIsShown(): Boolean {
+    val host = parentController?.view ?: view.parent as? View ?: return true
+    return host.isShown
+}
+
+/**
+ * Runs [mounted] as the content of this screen's slot mounts into its container, and [start] on the pre-draw of that
+ * frame: after React Native applied the whole mount, before the frame is drawn. At once if the content has mounted,
+ * after [DRAW_WAIT_LIMIT] if it never does; while [waiting] holds. A screen prepared for its push was rendered at its
+ * size and insets before: in that frame it is whole.
+ */
+fun ViewController<*>.whenContentMounted(waiting: () -> Boolean, mounted: () -> Unit, start: () -> Unit) {
+    var done = false
+    val run = Runnable {
+        if (done || !waiting() || isDestroyed) return@Runnable
+        done = true
+        mounted()
+        // Out of the window no frame comes to draw it. The listener goes with the view's window: a screen destroyed
+        // before that frame leaves nothing in it.
+        if (!view.isAttachedToWindow) return@Runnable start()
+        OneShotPreDrawListener.add(view) { if (waiting() && !isDestroyed) start() }
+    }
+    val container = (view as? ComponentLayout)?.reactView ?: return run.run()
+    UiThread.postDelayed(run, DRAW_WAIT_LIMIT)
+    container.whenSlotContentMounted(run)
+}
+
+/**
+ * waitForRender unset: the screen (or a root) waits, hidden, for its content to draw, then for the components of its
+ * bar, half a second at most in all: it comes in drawn, not filled in after. true waits for the content as long as it
+ * takes, false starts at once. It appears (its options go to the bars) once its content is drawn.
+ */
+fun ViewController<*>.whenDrawn(waitForRender: Bool, waiting: () -> Boolean, start: Runnable) {
+    if (waitForRender.isFalse || !hostIsShown()) return start.run()
+    val limited = !waitForRender.hasValue()
+    val deadline = SystemClock.uptimeMillis() + DRAW_WAIT_LIMIT
+    view.alpha = 0f
+    if (limited) {
+        setWaitForRender(Bool(true))
+        UiThread.postDelayed({
+            if (!waiting() || isDestroyed) return@postDelayed
+            // Not drawn in time: it appears as it is.
+            setWaitForRender(Bool(false))
+            view.requestLayout()
+        }, DRAW_WAIT_LIMIT)
+    }
+    addOnAppearedListener {
+        // A pop may have completed it while it waited.
+        if (!waiting()) return@addOnAppearedListener
+        if (limited) setWaitForRender(waitForRender)
+        val barDeadline = if (limited) deadline else SystemClock.uptimeMillis() + DRAW_WAIT_LIMIT
+        awaitBarComponents(barDeadline, waiting) {
+            view.alpha = 1f
+            start.run()
+        }
+    }
+}
+
+/**
+ * Whether what this root shows has drawn: the content of its screen (a native screen has none to wait for) and the
+ * components of the bar over it, which [whenDrawn] waits for.
+ */
+fun ViewController<*>.isContentDrawn(): Boolean {
+    var screen: ViewController<*> = this
+    while (screen is ParentController<*>) {
+        if (!screen.isViewCreated) return false
+        screen = screen.currentChild ?: return false
+    }
+    if (screen.isDestroyed || !screen.isViewCreated) return false
+    if ((screen.view as? Renderable)?.isRendered == false) return false
+    return screen.findParentStack()?.areBarComponentsDrawn(screen) ?: true
+}

package/android/src/main/java/dev/apexnative/navigation/utils/ViewExtensions.kt

@@ -0,0 +1,41 @@
+package dev.apexnative.navigation.utils
+
+import android.view.View
+import com.facebook.react.uimanager.BackgroundStyleApplicator
+import com.facebook.react.uimanager.LengthPercentage
+import com.facebook.react.uimanager.style.BorderRadiusProp
+
+/**
+ * The corner radius of the view's background, in pixels, as an element transition takes it from one view to another;
+ * 0 without rounded corners. React Native keeps it in its own background (`BackgroundStyleApplicator`), in dp or as a
+ * part of the view's width: one radius for all corners.
+ */
+val View.borderRadius: Float
+    get() {
+        val radius = try {
+            BackgroundStyleApplicator.getBorderRadius(this, BorderRadiusProp.BORDER_RADIUS)
+        } catch (e: RuntimeException) {
+            null
+        } ?: return 0f
+        return resolveBorderRadius(radius, width, resources?.displayMetrics?.density ?: 1f)
+    }
+
+/**
+ * A radius of React Native's background in pixels: in dp, or in percent of the view's [width] (pixels); [density] is
+ * the pixels of a dp.
+ */
+internal fun resolveBorderRadius(radius: LengthPercentage, width: Int, density: Float): Float =
+    (radius.resolve(width / density) * density).coerceAtLeast(0f)
+
+/** The scale the parents of [view] give it, along x and along y: a view in a scaled parent shows smaller. */
+fun computeInheritedScale(view: View): Pair<Float, Float> {
+    var scaleX = 1f
+    var scaleY = 1f
+    var parent = view.parent as? View
+    while (parent != null) {
+        scaleX *= parent.scaleX
+        scaleY *= parent.scaleY
+        parent = parent.parent as? View
+    }
+    return scaleX to scaleY
+}

package/android/src/main/java/dev/apexnative/navigation/utils/ViewUtils.kt

@@ -0,0 +1,15 @@
+package dev.apexnative.navigation.utils
+
+import android.graphics.Point
+import android.view.View
+
+/** Where views are. */
+object ViewUtils {
+    /** The top left corner of [view] on the screen, in pixels. */
+    @JvmStatic
+    fun getLocationOnScreen(view: View): Point {
+        val location = IntArray(2)
+        view.getLocationOnScreen(location)
+        return Point(location[0], location[1])
+    }
+}