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

package/android/src/main/java/dev/apexnative/navigation/slots/SlotHost.kt

@@ -0,0 +1,91 @@
+package dev.apexnative.navigation.slots
+
+import android.app.Activity
+import android.content.Context
+import android.content.ContextWrapper
+import android.content.MutableContextWrapper
+import android.os.Handler
+import android.os.Looper
+import android.view.View
+import android.view.ViewGroup
+import com.facebook.react.ReactApplication
+import com.facebook.react.ReactHost
+import com.facebook.react.interfaces.fabric.ReactSurface
+import java.lang.ref.WeakReference
+
+/**
+ * The hidden host of the app's React tree: one React surface for the process, so the app's providers outlive what
+ * Android does to activities (back on the first screen finishes the activity, the system recreates it). It starts with
+ * the first slot screen, when JavaScript runs; each activity takes its view over.
+ */
+object SlotHost {
+    const val MODULE_NAME = "apexnative.slots"
+
+    private var reactHost: ReactHost? = null
+    private var surface: ReactSurface? = null
+    // The host's views find their context through this wrapper, which always points at the current activity.
+    private var context: MutableContextWrapper? = null
+    private var activity: WeakReference<Activity>? = null
+    private val main = Handler(Looper.getMainLooper())
+
+    /** A slot screen exists, so the host must run: starts it the first time, starts it again when React dropped it. */
+    fun ensureStarted(viewContext: Context) {
+        val activity = activityOf(viewContext) ?: return
+        if (reactHost == null) reactHost = (activity.application as ReactApplication).reactHost
+        if (surface == null) {
+            attach(activity)
+            return
+        }
+        // React Native forgets every surface when it destroys its instance (a failed bundle load). A surface asked for
+        // before the instance was ready starts a little later, so the check waits a moment.
+        main.postDelayed({
+            val current = surface ?: return@postDelayed
+            if (current.isRunning) return@postDelayed
+            (current.view?.parent as? ViewGroup)?.removeView(current.view)
+            current.detach()
+            surface = null
+            this.activity?.get()?.let(::attach)
+        }, 500)
+    }
+
+    /** The activity the user sees takes the host's view; the first slot screen starts the host. */
+    fun attach(activity: Activity) {
+        this.activity = WeakReference(activity)
+        val wrapper = context ?: MutableContextWrapper(activity).also { context = it }
+        wrapper.baseContext = activity
+        if (surface == null) {
+            val host = reactHost ?: return
+            surface = host.createSurface(wrapper, MODULE_NAME, null).also { it.start() }
+        }
+        placeView(activity)
+    }
+
+    /** A new activity takes the view of a host that runs; without slot screens there is no host. */
+    fun attachIfStarted(activity: Activity) {
+        if (surface != null) attach(activity)
+    }
+
+    fun detach(activity: Activity) {
+        if (this.activity?.get() !== activity) return
+        val view = surface?.view
+        (view?.parent as? ViewGroup)?.removeView(view)
+        // The finished activity must not stay alive through the wrapper.
+        context?.baseContext = activity.applicationContext
+    }
+
+    private fun placeView(activity: Activity) {
+        val view = surface?.view ?: return
+        (view.parent as? ViewGroup)?.removeView(view)
+        view.visibility = View.INVISIBLE
+        activity.findViewById<ViewGroup>(android.R.id.content).addView(view, 0, ViewGroup.LayoutParams(1, 1))
+    }
+
+    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
+    }
+}

package/android/src/main/java/dev/apexnative/navigation/slots/SlotScreenView.kt

@@ -0,0 +1,158 @@
+package dev.apexnative.navigation.slots
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.view.MotionEvent
+import android.view.ViewGroup
+import android.widget.FrameLayout
+import dev.apexnative.navigation.react.events.AppearanceDispatcher
+import dev.apexnative.navigation.react.events.ComponentType
+import dev.apexnative.navigation.react.events.ScreenAppearance
+import dev.apexnative.navigation.viewcontrollers.component.ScreenReadiness
+import dev.apexnative.navigation.viewcontrollers.viewcontroller.IReactView
+import dev.apexnative.navigation.viewcontrollers.viewcontroller.ScrollEventListener
+
+/**
+ * What a slot screen (`slot:<Name>`) shows: the empty container its slot of the app's React tree moves its children
+ * into, under the screen's id ([SlotContainers]), told of each change of its size. It is the screen's content for the
+ * core: ready once the slot's content has mounted into it and, when the screen has a safe area view, the screen
+ * rendered into that view; its mounted handlers run at each mount. Its appearance events go through its record to the
+ * core's dispatcher (`AppearanceDispatcher`), which holds them until it is ready or the hold limit. Destroyed while the
+ * id is still its own, it tells JavaScript to take the slot's content away (`ANN.SlotDestroyed`).
+ */
+@SuppressLint("ViewConstructor")
+class SlotScreenView(
+    context: Context,
+    override val componentId: String,
+    /** The screen's name without `slot:`, as the events give it. */
+    override val componentName: String,
+) : FrameLayout(context), IReactView, SlotContainer {
+    private val scrollEventListener = ScrollEventListener()
+    private val whenMounted = mutableListOf<Runnable>()
+    private val whenRendered = mutableListOf<Runnable>()
+    private val mountedHandlers = LinkedHashMap<String, Runnable>()
+    private var readinessListener: ScreenReadiness.Listener? = null
+    private var mounted = false
+    private var readyTold = false
+    private var destroyed = false
+
+    /**
+     * The appearance of the screen: ready with the slot's mount and its render ([whenReady]), or when a command's
+     * readiness wait ended ([ScreenAppearance.markReady]).
+     */
+    internal val appearance = ScreenAppearance(componentId, componentName, ComponentType.Component, this)
+
+    /**
+     * The screen was prepared for a push (`preparePush`) and isn't shown yet: destroyed so, it sends no
+     * `ANN.SlotDestroyed`, as JavaScript decides about the slot itself.
+     */
+    var isPreparedPush = false
+
+    init {
+        SlotContainers.put(componentId, this)
+    }
+
+    override fun asView(): ViewGroup = this
+
+    // The slot's content the slot moved in here: React Native's touch target search starts there.
+    override val touchRoot: ViewGroup?
+        get() = if (childCount > 0) getChildAt(0) as? ViewGroup else null
+
+    // Mounted, and rendered into the screen's safe area view; a screen without one (nothing told of its id) once
+    // mounted. Ready once, ready for good.
+    override fun isReady(): Boolean =
+        readyTold || (mounted && ScreenReadiness.isContentRendered(componentId) != false)
+
+    override fun isRendered(): Boolean = isReady()
+
+    // The slot lays its children out at the container's size: each change of it goes to the slot.
+    override fun onSizeChanged(width: Int, height: Int, oldWidth: Int, oldHeight: Int) {
+        super.onSizeChanged(width, height, oldWidth, oldHeight)
+        if (destroyed || SlotContainers.get(componentId) !== this) return
+        SlotContainers.changed(componentId)
+    }
+
+    override fun destroy() {
+        if (destroyed) return
+        // Its appearance ends with it: DidDisappear if its WillAppear went, else nothing held goes later.
+        AppearanceDispatcher.didDisappear(appearance)
+        destroyed = true
+        whenMounted.clear()
+        whenRendered.clear()
+        mountedHandlers.clear()
+        stopListening()
+        // A later screen with the same id keeps the slot.
+        if (SlotContainers.get(componentId) !== this) return
+        SlotContainers.remove(componentId)
+        if (!isPreparedPush) AppearanceDispatcher.slotDestroyed(componentId, appearance.generation)
+    }
+
+    override fun sendOnNavigationButtonPressed(buttonId: String) = Unit
+
+    override fun getScrollEventListener(): ScrollEventListener = scrollEventListener
+
+    override fun dispatchTouchEventToJs(event: MotionEvent) = Unit
+
+    override fun sendComponentWillStart(type: ComponentType) = AppearanceDispatcher.willAppear(appearance)
+
+    override fun sendComponentStart(type: ComponentType) = AppearanceDispatcher.didAppear(appearance)
+
+    override fun sendComponentStop(type: ComponentType) = AppearanceDispatcher.didDisappear(appearance)
+
+    /** Runs [listener] once the content has mounted and rendered ([isReady]); at once when it has. */
+    override fun whenReady(listener: Runnable) {
+        if (destroyed) return
+        if (readyTold) return listener.run()
+        whenRendered += listener
+        if (isReady()) return checkReadiness()
+        if (readinessListener != null) return
+        val readiness = object : ScreenReadiness.Listener {
+            override fun onLaidOut() = Unit
+
+            override fun onContentRendered() = checkReadiness()
+        }
+        readinessListener = readiness
+        ScreenReadiness.setListener(componentId, readiness)
+    }
+
+    override fun whenSlotContentMounted(listener: Runnable) {
+        if (mounted) listener.run() else whenMounted += listener
+    }
+
+    override fun setOnContentMounted(key: String, handler: Runnable?) {
+        if (handler == null) mountedHandlers.remove(key) else mountedHandlers[key] = handler
+    }
+
+    // Only the container that holds the slot of the id: a destroyed one, or one a later screen replaced, takes no
+    // slot back.
+    override fun setPassThroughTouches(passThrough: Boolean) {
+        if (destroyed || SlotContainers.get(componentId) !== this) return
+        SlotContainers.put(componentId, this, passThrough)
+    }
+
+    override fun slotContentDidMount() {
+        if (destroyed) return
+        mounted = true
+        val waiting = whenMounted.toList()
+        whenMounted.clear()
+        waiting.forEach { it.run() }
+        mountedHandlers.values.toList().forEach { it.run() }
+        checkReadiness()
+    }
+
+    // Both signals are in: what waits for the readiness runs, once.
+    private fun checkReadiness() {
+        if (destroyed || readyTold || !isReady()) return
+        readyTold = true
+        stopListening()
+        val waiting = whenRendered.toList()
+        whenRendered.clear()
+        waiting.forEach { it.run() }
+    }
+
+    private fun stopListening() {
+        val readiness = readinessListener ?: return
+        readinessListener = null
+        ScreenReadiness.removeListener(componentId, readiness)
+    }
+}

package/android/src/main/java/dev/apexnative/navigation/slots/SlotView.kt

@@ -0,0 +1,141 @@
+package dev.apexnative.navigation.slots
+
+import android.annotation.SuppressLint
+import android.view.MotionEvent
+import android.view.View
+import android.view.ViewGroup
+import com.facebook.react.R
+import com.facebook.react.bridge.WritableNativeMap
+import com.facebook.react.common.annotations.UnstableReactNativeAPI
+import com.facebook.react.uimanager.JSTouchDispatcher
+import com.facebook.react.uimanager.PixelUtil.pxToDp
+import com.facebook.react.uimanager.RootView
+import com.facebook.react.uimanager.StateWrapper
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.events.EventDispatcher
+import com.facebook.react.views.view.ReactViewGroup
+
+/**
+ * The React children of a slot. They live outside the views of the host's surface, in the container of a screen, so
+ * this view dispatches their touches itself, as React Native's Modal does.
+ */
+@SuppressLint("ViewConstructor")
+class SlotContentView(private val reactContext: ThemedReactContext) : ReactViewGroup(reactContext), RootView {
+    private val touchDispatcher = JSTouchDispatcher(this)
+    var passThrough = false
+
+    private val eventDispatcher: EventDispatcher?
+        get() = UIManagerHelper.getEventDispatcher(reactContext)
+
+    override fun onInterceptTouchEvent(event: MotionEvent): Boolean {
+        if (!passThrough) eventDispatcher?.let { touchDispatcher.handleTouchEvent(event, it, reactContext) }
+        return super.onInterceptTouchEvent(event)
+    }
+
+    @SuppressLint("ClickableViewAccessibility")
+    override fun onTouchEvent(event: MotionEvent): Boolean {
+        // A pass-through container leaves every touch outside the content to the screens below.
+        if (passThrough) return false
+        eventDispatcher?.let { touchDispatcher.handleTouchEvent(event, it, reactContext) }
+        super.onTouchEvent(event)
+        return true
+    }
+
+    @OptIn(UnstableReactNativeAPI::class)
+    override fun onChildStartedNativeGesture(childView: View?, ev: MotionEvent) {
+        eventDispatcher?.let { touchDispatcher.onChildStartedNativeGesture(ev, it, reactContext) }
+    }
+
+    override fun onChildEndedNativeGesture(childView: View, ev: MotionEvent) {
+        eventDispatcher?.let { touchDispatcher.onChildEndedNativeGesture(ev, it) }
+    }
+
+    override fun handleException(t: Throwable) {
+        reactContext.reactApplicationContext.handleException(RuntimeException(t))
+    }
+
+    // Keep getting onInterceptTouchEvent when a child asks to stop it.
+    override fun requestDisallowInterceptTouchEvent(disallowIntercept: Boolean) = Unit
+}
+
+/**
+ * A slot of the app's React tree. It stays in the hidden host with nothing of its own; its children move into the
+ * container with the same slot id (`nativeID`), and lay out at the container's size, which goes to the slot's state.
+ */
+@SuppressLint("ViewConstructor")
+class SlotView(reactContext: ThemedReactContext) : ReactViewGroup(reactContext) {
+    val content = SlotContentView(reactContext)
+    var stateWrapper: StateWrapper? = null
+        set(value) {
+            field = value
+            // The size the state holds: the one this view sent last, or the one the slot started with (`initialSize`, a
+            // screen rendered before it is shown). The same size isn't sent again: the state has it.
+            val data = value?.stateData ?: return
+            if (data.hasKey("width") && data.hasKey("height")) {
+                lastWidth = data.getDouble("width").toFloat()
+                lastHeight = data.getDouble("height").toFloat()
+            }
+        }
+    private var lastWidth = -1f
+    private var lastHeight = -1f
+
+    private val slotId: String?
+        get() = getTag(R.id.view_tag_native_id) as? String
+
+    init {
+        content.visibility = INVISIBLE
+        addView(content)
+        SlotContainers.listen(this)
+    }
+
+    override fun setId(id: Int) {
+        super.setId(id)
+        // Touches that hit no child go to the slot, as on an empty screen.
+        content.id = id
+    }
+
+    fun containerChanged(changedSlotId: String) {
+        if (changedSlotId == slotId) attachContent()
+    }
+
+    fun attachContent() {
+        val id = slotId ?: return
+        val container = SlotContainers.get(id)
+        val target: ViewGroup = container ?: this
+        if (content.parent !== target) {
+            (content.parent as? ViewGroup)?.removeView(content)
+            target.addView(content, ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT))
+        }
+        content.visibility = if (container != null) VISIBLE else INVISIBLE
+        content.passThrough = SlotContainers.passesTouchesThrough(id)
+        contentChanged()
+
+        val state = stateWrapper
+        if (container != null && state != null && container.width > 0 && container.height > 0) {
+            val width = container.width.toFloat().pxToDp()
+            val height = container.height.toFloat().pxToDp()
+            if (width != lastWidth || height != lastHeight) {
+                lastWidth = width
+                lastHeight = height
+                state.updateState(
+                    WritableNativeMap().apply {
+                        putDouble("width", width.toDouble())
+                        putDouble("height", height.toDouble())
+                    }
+                )
+            }
+        }
+    }
+
+    /** The content got children: the container learns once it shows them. */
+    fun contentChanged() {
+        val container = slotId?.let(SlotContainers::get) ?: return
+        if (content.parent === container && content.childCount > 0) (container as? SlotContainer)?.slotContentDidMount()
+    }
+
+    fun drop() {
+        SlotContainers.stopListening(this)
+        (content.parent as? ViewGroup)?.removeView(content)
+    }
+}

package/android/src/main/java/dev/apexnative/navigation/slots/SlotViewManager.kt

@@ -0,0 +1,50 @@
+package dev.apexnative.navigation.slots
+
+import android.view.View
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.ReactStylesDiffMap
+import com.facebook.react.uimanager.StateWrapper
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+
+/** The slot component (`ANNSlot`): React children go into its content view, wherever that view is. */
+@ReactModule(name = SlotViewManager.NAME)
+class SlotViewManager : ViewGroupManager<SlotView>() {
+    override fun getName(): String = NAME
+
+    override fun createViewInstance(reactContext: ThemedReactContext): SlotView = SlotView(reactContext)
+
+    override fun updateState(view: SlotView, props: ReactStylesDiffMap, stateWrapper: StateWrapper): Any? {
+        view.stateWrapper = stateWrapper
+        view.attachContent()
+        return null
+    }
+
+    // The slot id (nativeID) comes with the props.
+    override fun onAfterUpdateTransaction(view: SlotView) {
+        super.onAfterUpdateTransaction(view)
+        view.attachContent()
+    }
+
+    override fun addView(parent: SlotView, child: View, index: Int) {
+        parent.content.addView(child, index)
+        parent.contentChanged()
+    }
+
+    override fun getChildCount(parent: SlotView): Int = parent.content.childCount
+
+    override fun getChildAt(parent: SlotView, index: Int): View? = parent.content.getChildAt(index)
+
+    override fun removeViewAt(parent: SlotView, index: Int) = parent.content.removeViewAt(index)
+
+    override fun removeView(parent: SlotView, view: View) = parent.content.removeView(view)
+
+    override fun onDropViewInstance(view: SlotView) {
+        super.onDropViewInstance(view)
+        view.drop()
+    }
+
+    companion object {
+        const val NAME = "ANNSlot"
+    }
+}

package/android/src/main/java/dev/apexnative/navigation/splash/SplashHold.kt

@@ -0,0 +1,67 @@
+package dev.apexnative.navigation.splash
+
+import android.os.Build
+import android.view.View
+import android.view.ViewTreeObserver
+import android.view.WindowManager
+import android.view.inspector.WindowInspector
+import androidx.annotation.RequiresApi
+import dev.apexnative.navigation.NavigationActivity
+
+/**
+ * Keeps the splash on screen until the activity's first root has drawn: the system splash (Android 12+) or the
+ * starting window leaves with the activity's first frame, and the activity's window doesn't draw until then. An
+ * activity holds from its onCreate, unless it is recreated from saved state: it has no starting window then, and while
+ * the start still runs its root doesn't come at once.
+ *
+ * Another window of the activity ends the hold at once. A dialog (React Native's red box and LogBox, an alert shown
+ * during `willMount`, the developer menu) would stay hidden behind the splash, which stays above the activity's windows
+ * until the activity has drawn. A popup (React Native's "Loading from Metro" banner in a debug build) counts as the
+ * activity's first frame: the system splash leaves when it draws, and the held window would show black until the
+ * first root. The app sees its windows from Android 10 on (`WindowInspector`); before, the window isn't held.
+ */
+internal class SplashHold private constructor(private val activity: NavigationActivity) :
+    ViewTreeObserver.OnPreDrawListener {
+    private val content: View = activity.findViewById(android.R.id.content)
+    private var held = true
+
+    // Before each frame of the window. A frame held back is tried again on the next one.
+    override fun onPreDraw(): Boolean {
+        if (!held) return true
+        val done = activity.navigator?.isFirstRootDrawn == true ||
+            (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q && otherWindowShown())
+        if (!done) return false
+        release()
+        return true
+    }
+
+    /** The window draws from its next frame on. Main thread only. */
+    fun release() {
+        if (!held) return
+        held = false
+        val observer = content.viewTreeObserver
+        if (observer.isAlive) observer.removeOnPreDrawListener(this)
+    }
+
+    // A dialog of the activity is a window with the activity's token; a popup or a panel has the token of the
+    // activity's window, which it belongs to.
+    @RequiresApi(Build.VERSION_CODES.Q)
+    private fun otherWindowShown(): Boolean {
+        val decor = activity.window.decorView
+        val activityToken = (decor.layoutParams as? WindowManager.LayoutParams)?.token ?: return false
+        val windowToken = decor.windowToken
+        return WindowInspector.getGlobalWindowViews().any { view ->
+            val token = (view.layoutParams as? WindowManager.LayoutParams)?.token
+            view !== decor && view.isShown && token != null && (token == activityToken || token == windowToken)
+        }
+    }
+
+    companion object {
+        /** Holds the window of [activity] from now on, from Android 10; null before. In onCreate, after the content. */
+        @JvmStatic
+        fun start(activity: NavigationActivity): SplashHold? {
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) return null
+            return SplashHold(activity).also { it.content.viewTreeObserver.addOnPreDrawListener(it) }
+        }
+    }
+}

package/android/src/main/java/dev/apexnative/navigation/splash/SplashTheme.kt

@@ -0,0 +1,81 @@
+package dev.apexnative.navigation.splash
+
+import android.app.Activity
+import android.content.Context
+import android.content.res.TypedArray
+import android.graphics.drawable.Drawable
+import androidx.annotation.ColorInt
+import androidx.annotation.StyleRes
+import androidx.annotation.VisibleForTesting
+import androidx.core.content.ContextCompat
+import dev.apexnative.navigation.R
+
+/**
+ * What a splash theme sets: the one `npx apex-navigation splash` writes, the main activity's theme in the manifest.
+ * The app's theme, which the activity takes in onCreate, and the splash's background and logo, which the copy of the
+ * splash draws. They are kept by resource id, so each read gives the current light or dark mode.
+ */
+internal class SplashTheme private constructor(
+    /** The app's theme (a style resource); 0 when the theme names none. */
+    val postSplashTheme: Int,
+    // The background as a color resource, or as a color value; the logo as a drawable resource. 0 or null: none.
+    private val backgroundRes: Int,
+    private val backgroundValue: Int?,
+    private val logoRes: Int,
+) {
+    /** Whether there is a picture to copy: a background or a logo. */
+    val hasPicture: Boolean
+        get() = backgroundRes != 0 || backgroundValue != null || logoRes != 0
+
+    /** The background color in the current mode; null without one. */
+    @ColorInt
+    fun background(context: Context): Int? =
+        if (backgroundRes != 0) ContextCompat.getColor(context, backgroundRes) else backgroundValue
+
+    /** The logo on its 288 dp canvas in the current mode; null without one. */
+    fun logo(context: Context): Drawable? = if (logoRes != 0) ContextCompat.getDrawable(context, logoRes) else null
+
+    companion object {
+        /**
+         * What the activity's theme sets for the splash; null when it sets none of it. Read before the activity takes
+         * the app's theme, which doesn't set them.
+         */
+        @JvmStatic
+        fun read(activity: Activity): SplashTheme? {
+            val attributes = activity.theme.obtainStyledAttributes(R.styleable.ApexNavigationSplash)
+            return try {
+                from(attributes)
+            } finally {
+                attributes.recycle()
+            }
+        }
+
+        /**
+         * The theme an activity runs with when the manifest gives it [manifestTheme]: the app's theme it names when it
+         * is a splash theme, else [manifestTheme] itself.
+         */
+        @JvmStatic
+        fun appTheme(context: Context, @StyleRes manifestTheme: Int): Int {
+            if (manifestTheme == 0) return 0
+            val names = intArrayOf(R.attr.apexNavigationPostSplashTheme)
+            val attributes = context.obtainStyledAttributes(manifestTheme, names)
+            return try {
+                attributes.getResourceId(0, 0).takeIf { it != 0 } ?: manifestTheme
+            } finally {
+                attributes.recycle()
+            }
+        }
+
+        @VisibleForTesting
+        fun from(attributes: TypedArray): SplashTheme? {
+            val theme = attributes.getResourceId(R.styleable.ApexNavigationSplash_apexNavigationPostSplashTheme, 0)
+            val background = R.styleable.ApexNavigationSplash_apexNavigationSplashBackground
+            val backgroundRes = attributes.getResourceId(background, 0)
+            val backgroundValue =
+                if (backgroundRes == 0 && attributes.hasValue(background)) attributes.getColor(background, 0) else null
+            val logo = attributes.getResourceId(R.styleable.ApexNavigationSplash_apexNavigationSplashLogo, 0)
+            val splash = SplashTheme(theme, backgroundRes, backgroundValue, logo)
+            return splash.takeIf { it.postSplashTheme != 0 || it.hasPicture }
+        }
+    }
+}

package/android/src/main/java/dev/apexnative/navigation/splash/SplashView.kt

@@ -0,0 +1,77 @@
+package dev.apexnative.navigation.splash
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.content.res.Configuration
+import android.graphics.Canvas
+import android.graphics.drawable.ColorDrawable
+import android.graphics.drawable.Drawable
+import android.view.View
+import android.view.ViewTreeObserver
+
+/**
+ * The copy of the splash at the bottom of the activity's content, under the navigation until its first root shows: the
+ * splash's background, and its logo at its own size centered in the whole window, as the system splash (Android 12+)
+ * and the starting window (the splash theme's `windowBackground`) center it. The splash leaving shows the same
+ * picture, and the first root comes in over it.
+ */
+@SuppressLint("ViewConstructor")
+internal class SplashView(context: Context, private val splash: SplashTheme) : View(context) {
+    private var logo: Drawable? = null
+    private val location = IntArray(2)
+    // The content can sit inset in the window (not edge-to-edge) and move with the insets: the logo is placed again
+    // after each layout of the window.
+    private val placeLogo = ViewTreeObserver.OnGlobalLayoutListener { invalidate() }
+
+    init {
+        importantForAccessibility = IMPORTANT_FOR_ACCESSIBILITY_NO
+        loadResources()
+    }
+
+    override fun onAttachedToWindow() {
+        super.onAttachedToWindow()
+        viewTreeObserver.addOnGlobalLayoutListener(placeLogo)
+    }
+
+    override fun onDetachedFromWindow() {
+        viewTreeObserver.removeOnGlobalLayoutListener(placeLogo)
+        super.onDetachedFromWindow()
+    }
+
+    // A light/dark switch the activity takes itself: Android updates the resources before it tells the views, and the
+    // same ids give the other mode's color and logo.
+    override fun onConfigurationChanged(newConfig: Configuration) {
+        super.onConfigurationChanged(newConfig)
+        loadResources()
+    }
+
+    override fun onDraw(canvas: Canvas) {
+        super.onDraw(canvas)
+        val logo = logo ?: return
+        val width = logo.intrinsicWidth
+        val height = logo.intrinsicHeight
+        if (width <= 0 || height <= 0) return
+        val window = rootView
+        getLocationInWindow(location)
+        val left = (window.width - width) / 2 - location[0]
+        val top = (window.height - height) / 2 - location[1]
+        logo.setBounds(left, top, left + width, top + height)
+        logo.draw(canvas)
+    }
+
+    private fun loadResources() {
+        background = splash.background(context)?.let(::ColorDrawable)
+        logo = splash.logo(context)
+        invalidate()
+    }
+
+    companion object {
+        /**
+         * The view of `NavigationActivity.addDefaultSplashLayout`: the copy when [splash] has a background or a logo,
+         * else an empty view.
+         */
+        @JvmStatic
+        fun create(context: Context, splash: SplashTheme?): View =
+            if (splash != null && splash.hasPicture) SplashView(context, splash) else View(context)
+    }
+}