craft-native 0.0.172 → 0.0.174

package/dist/android/templates/MainActivityNative.kt.template

@@ -86,6 +86,17 @@ import androidx.javascriptengine.Message
 import androidx.javascriptengine.MessagePort
 import androidx.javascriptengine.MessagePortClient
 import com.craft.runtime.CraftNative
+import com.google.android.gms.maps.CameraUpdateFactory
+import com.google.android.gms.maps.GoogleMap
+import com.google.android.gms.maps.MapView
+import com.google.android.gms.maps.OnMapReadyCallback
+import com.google.android.gms.maps.model.BitmapDescriptorFactory
+import com.google.android.gms.maps.model.LatLng
+import com.google.android.gms.maps.model.LatLngBounds
+import com.google.android.gms.maps.model.Marker
+import com.google.android.gms.maps.model.MarkerOptions
+import com.google.android.gms.maps.model.Polyline
+import com.google.android.gms.maps.model.PolylineOptions
 import org.json.JSONArray
 import org.json.JSONObject
 import java.net.URL
@@ -459,6 +470,145 @@ private class CraftNativeSvgView(context: Context) : View(context) {
     private data class Quadruple<T1, T2, T3, T4>(val first: T1, val second: T2, val third: T3, val fourth: T4)
 }
 
+/** The Android host for the small, host-neutral native trail map contract. */
+private class CraftNativeMapView(context: Context) : FrameLayout(context), OnMapReadyCallback {
+    private val mapView = MapView(context)
+    private var googleMap: GoogleMap? = null
+    private var pendingProps = JSONObject()
+    private var pendingChildren = JSONArray()
+    private val markers = mutableMapOf<String, Marker>()
+    private val polylines = mutableMapOf<String, Polyline>()
+    private val markerHandlers = mutableMapOf<String, String>()
+    private var onMarkerTap: ((String) -> Unit)? = null
+
+    init {
+        addView(mapView, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT))
+        mapView.onCreate(null)
+        mapView.getMapAsync(this)
+    }
+
+    override fun onMapReady(map: GoogleMap) {
+        googleMap = map
+        map.setOnMarkerClickListener { marker ->
+            val id = markers.entries.firstOrNull { it.value == marker }?.key ?: return@setOnMarkerClickListener false
+            onMarkerTap?.invoke(id)
+            false
+        }
+        applyPending()
+    }
+
+    fun configure(props: JSONObject, children: JSONArray, markerHandler: (String) -> Unit) {
+        pendingProps = props
+        pendingChildren = children
+        onMarkerTap = markerHandler
+        applyPending()
+    }
+
+    fun markerHandler(id: String): String? = markerHandlers[id]
+
+    private fun applyPending() {
+        val map = googleMap ?: return
+        map.uiSettings.isScrollGesturesEnabled = pendingProps.optBoolean("scrollEnabled", true)
+        map.uiSettings.isZoomGesturesEnabled = pendingProps.optBoolean("zoomEnabled", true)
+        map.uiSettings.isRotateGesturesEnabled = pendingProps.optBoolean("rotateEnabled", false)
+        map.mapType = when (pendingProps.optString("mapType").lowercase()) {
+            "satellite" -> GoogleMap.MAP_TYPE_SATELLITE
+            "hybrid" -> GoogleMap.MAP_TYPE_HYBRID
+            "terrain" -> GoogleMap.MAP_TYPE_TERRAIN
+            else -> GoogleMap.MAP_TYPE_NORMAL
+        }
+        val nextMarkers = mutableMapOf<String, Pair<LatLng, String?>>()
+        val nextHandlers = mutableMapOf<String, String>()
+        val nextPolylines = mutableMapOf<String, Pair<List<LatLng>, Int>>()
+        for (index in 0 until pendingChildren.length()) {
+            val child = pendingChildren.optJSONObject(index) ?: continue
+            val type = child.optString("type").lowercase()
+            val props = child.optJSONObject("props") ?: JSONObject()
+            val events = child.optJSONObject("events") ?: JSONObject()
+            val id = props.opt("id")?.takeUnless { it == JSONObject.NULL }?.toString()
+                ?: child.optString("id").takeIf { it.isNotBlank() }
+                ?: "overlay-$index"
+            val points = coordinates(props.optJSONArray("geometry"))
+            if (type == "mapmarker" || type == "marker") {
+                points.firstOrNull()?.let { point ->
+                    nextMarkers[id] = point to props.optString("title").takeIf { it.isNotBlank() }
+                    events.optString("onPress").ifBlank { events.optString("onMarkerPress") }
+                        .takeIf { it.isNotBlank() }?.let { nextHandlers[id] = it }
+                }
+            } else if (type == "mappolyline" || type == "polyline") {
+                if (points.size > 1) nextPolylines[id] = points to color(props.optString("strokeColor"))
+            }
+        }
+        markers.keys.filter { nextMarkers[it] == null }.forEach { markers.remove(it)?.remove() }
+        for ((id, value) in nextMarkers) {
+            val marker = markers[id]
+            if (marker != null) {
+                marker.position = value.first
+                marker.title = value.second
+            } else {
+                map.addMarker(MarkerOptions().position(value.first).title(value.second).icon(BitmapDescriptorFactory.defaultMarker()))?.let { markers[id] = it }
+            }
+        }
+        markerHandlers.clear()
+        markerHandlers.putAll(nextHandlers)
+        polylines.values.forEach { it.remove() }
+        polylines.clear()
+        for ((id, value) in nextPolylines) {
+            polylines[id] = map.addPolyline(PolylineOptions().addAll(value.first).color(value.second).width(3f))
+        }
+        if (pendingProps.optBoolean("fitToBounds", false)) fitToBounds()
+        region(pendingProps.optJSONObject("region") ?: pendingProps.optJSONObject("initialRegion"))?.let { bounds ->
+            post {
+                if (width > 0 && height > 0) map.moveCamera(CameraUpdateFactory.newLatLngBounds(bounds, 24))
+            }
+        }
+    }
+
+    private fun fitToBounds() {
+        val map = googleMap ?: return
+        val builder = LatLngBounds.Builder()
+        var count = 0
+        markers.values.forEach { builder.include(it.position); count++ }
+        polylines.values.flatMap { it.points }.forEach { builder.include(it); count++ }
+        if (count == 0) return
+        post {
+            if (width > 0 && height > 0) map.moveCamera(CameraUpdateFactory.newLatLngBounds(builder.build(), 24))
+        }
+    }
+
+    override fun onAttachedToWindow() {
+        super.onAttachedToWindow()
+        mapView.onResume()
+    }
+
+    override fun onDetachedFromWindow() {
+        mapView.onPause()
+        super.onDetachedFromWindow()
+    }
+
+    private fun coordinates(geometry: JSONArray?): List<LatLng> {
+        if (geometry == null) return emptyList()
+        return (0 until geometry.length() - 1 step 2).mapNotNull { index ->
+            val latitude = geometry.optDouble(index, Double.NaN)
+            val longitude = geometry.optDouble(index + 1, Double.NaN)
+            if (latitude.isFinite() && longitude.isFinite()) LatLng(latitude, longitude) else null
+        }
+    }
+
+    private fun region(value: JSONObject?): LatLngBounds? {
+        val center = value?.optJSONObject("center") ?: return null
+        val span = value.optJSONObject("span") ?: return null
+        val latitude = center.optDouble("latitude", Double.NaN)
+        val longitude = center.optDouble("longitude", Double.NaN)
+        val latitudeDelta = span.optDouble("latitudeDelta", span.optDouble("latitude_delta", Double.NaN))
+        val longitudeDelta = span.optDouble("longitudeDelta", span.optDouble("longitude_delta", Double.NaN))
+        if (!latitude.isFinite() || !longitude.isFinite() || !latitudeDelta.isFinite() || !longitudeDelta.isFinite()) return null
+        return LatLngBounds(LatLng(latitude - latitudeDelta / 2, longitude - longitudeDelta / 2), LatLng(latitude + latitudeDelta / 2, longitude + longitudeDelta / 2))
+    }
+
+    private fun color(value: String): Int = runCatching { Color.parseColor(value) }.getOrDefault(Color.BLUE)
+}
+
 /** A deterministic flex-shaped container shared by normal views and scroll content. */
 private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
     var onLayoutChanged: (() -> Unit)? = null
@@ -474,6 +624,46 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
     private var gridAutoRows: CraftNativeLength? = null
     private var reverse = false
     private var wrapReverse = false
+    private var authoredPadding = intArrayOf(0, 0, 0, 0)
+    private var safeAreaPadding = intArrayOf(0, 0, 0, 0)
+    private var applyingPadding = false
+    private var safeAreaEdges = setOf("top", "right", "bottom", "left")
+
+    override fun setPadding(left: Int, top: Int, right: Int, bottom: Int) {
+        if (!applyingPadding) authoredPadding = intArrayOf(left, top, right, bottom)
+        applyingPadding = true
+        super.setPadding(
+            left + safeAreaPadding[0],
+            top + safeAreaPadding[1],
+            right + safeAreaPadding[2],
+            bottom + safeAreaPadding[3],
+        )
+        applyingPadding = false
+    }
+
+    fun setSafeAreaEdges(raw: JSONArray?) {
+        safeAreaEdges = if (raw == null) {
+            setOf("top", "right", "bottom", "left")
+        } else {
+            (0 until raw.length()).mapNotNull { raw.optString(it).takeIf { edge -> edge in setOf("top", "right", "bottom", "left") } }.toSet()
+        }
+        applySafeAreaPadding()
+    }
+
+    fun setWindowSafeInsets(left: Int, top: Int, right: Int, bottom: Int) {
+        val insets = intArrayOf(left, top, right, bottom)
+        safeAreaPadding = intArrayOf(
+            if ("left" in safeAreaEdges) insets[0] else 0,
+            if ("top" in safeAreaEdges) insets[1] else 0,
+            if ("right" in safeAreaEdges) insets[2] else 0,
+            if ("bottom" in safeAreaEdges) insets[3] else 0,
+        )
+        applySafeAreaPadding()
+    }
+
+    private fun applySafeAreaPadding() {
+        setPadding(authoredPadding[0], authoredPadding[1], authoredPadding[2], authoredPadding[3])
+    }
 
     /**
      * What a child measures at a pair of specs, remembered for the frame.
@@ -643,7 +833,11 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
                 if (index > 0 && lineIds != null && lineIds[index] != lineIds[index - 1]) {
                     lines += line
                     line = Line()
-                } else if (index > 0 && lineIds == null && wrap && line.entries.isNotEmpty() && line.main + gap + childMain > availableMain) {
+                } else if (index > 0 && lineIds == null && wrap && line.entries.isNotEmpty() && line.main + gap + childMain > availableMain + 0.5f * (line.entries.size + 1)) {
+                    // Each size is rounded to whole pixels, up to half a pixel
+                    // over: two 60-point items fill a 120-point row exactly
+                    // in points, and at 2.625 pixels per point (157.5 + 157.5
+                    // in 315) rounding alone must not wrap the second.
                     lines += line
                     line = Line()
                 }
@@ -1343,6 +1537,18 @@ private class CraftNativeScrollView(context: Context) : SwipeRefreshLayout(conte
         if (handler == null) isRefreshing = false
     }
 
+    fun setRefreshAppearance(props: JSONObject, density: Float) {
+        val tint = props.optString("tintColor").takeIf { it.isNotBlank() }
+        if (tint != null) setColorSchemeColors(craftNativeColor(tint))
+        else setColorSchemeColors(Color.WHITE)
+        val background = props.optString("progressBackgroundColor").takeIf { it.isNotBlank() }
+        if (background != null) setProgressBackgroundColorSchemeColor(craftNativeColor(background))
+        else setProgressBackgroundColorSchemeColor(Color.TRANSPARENT)
+        val offset = props.optDouble("progressViewOffset", Double.NaN)
+        if (offset.isFinite()) setProgressViewOffset(true, 0, (offset * density).roundToInt())
+        else setProgressViewOffset(false, 0, 0)
+    }
+
     override fun onDetachedFromWindow() {
         refreshHandler = null
         isRefreshing = false
@@ -1783,12 +1989,15 @@ private class CraftNativeDatePickerView(context: Context) : FrameLayout(context)
 
     private fun changed() {
         if (suppressChanges) return
-        val picker = timePicker ?: return
-        val snapped = ((picker.minute + minuteInterval / 2) / minuteInterval * minuteInterval).coerceAtMost(59)
-        if (snapped != picker.minute) {
-            suppressChanges = true
-            picker.minute = snapped
-            suppressChanges = false
+        // A date-only picker has no time half to snap, but its change is
+        // still the screen's to hear.
+        timePicker?.let { picker ->
+            val snapped = ((picker.minute + minuteInterval / 2) / minuteInterval * minuteInterval).coerceAtMost(59)
+            if (snapped != picker.minute) {
+                suppressChanges = true
+                picker.minute = snapped
+                suppressChanges = false
+            }
         }
         onValueChanged?.invoke()
     }
@@ -2182,6 +2391,9 @@ class MainActivity : AppCompatActivity() {
     ) {
         /** What the screen set with `craft.navigation.setOptions`, merged. */
         var options = JSONObject()
+        /** Overrides from a native `<StatusBar>` node, reset on each render. */
+        var statusBarStyle: String? = null
+        var statusBarHidden: Boolean? = null
         /** Shown before: its next showing is a `SCREEN_FOCUS`. */
         var shown = false
         /** The app path it was opened for (`/m/workout/42`), to find it again. */
@@ -2209,6 +2421,7 @@ class MainActivity : AppCompatActivity() {
         val nodeViews = mutableMapOf<String, View>()
         val nodePaths = mutableMapOf<String, String>()
         val handlers = mutableMapOf<View, String>()
+        val linkTargets = mutableMapOf<View, String>()
         val pressInHandlers = mutableMapOf<View, String>()
         val pressOutHandlers = mutableMapOf<View, String>()
         val longPressHandlers = mutableMapOf<View, String>()
@@ -2279,6 +2492,9 @@ class MainActivity : AppCompatActivity() {
     private val tabStacks = mutableListOf<MutableList<Screen>>()
     private var currentTab = 0
     private var visibleScreen: Screen? = null
+    private var tabSwipeTarget: Screen? = null
+    private var tabSwipeTargetIndex = -1
+    private var tabSwipeDirection = 0
     /** The app script's isolate (`nativeApp`), when the app has one. */
     private var appScreen: Screen? = null
     private val urlSchemes = mutableSetOf<String>()
@@ -2298,6 +2514,7 @@ class MainActivity : AppCompatActivity() {
     private var initialDeepLink: Uri? = null
     private var initialDeepLinkClaimed = false
     private var defaultTextColor = Color.WHITE
+    private var windowSafeInsets = intArrayOf(0, 0, 0, 0)
     private var useMessagePorts = false
     private val imageExecutor = Executors.newFixedThreadPool(2)
     /** Lays out each isolate's prelude (the synchronous stores) off the main thread. */
@@ -2330,8 +2547,9 @@ class MainActivity : AppCompatActivity() {
         ViewCompat.setOnApplyWindowInsetsListener(root) { view, insets ->
             val safe = insets.getInsets(WindowInsetsCompat.Type.systemBars() or WindowInsetsCompat.Type.displayCutout())
             val ime = insets.getInsets(WindowInsetsCompat.Type.ime())
+            windowSafeInsets = intArrayOf(safe.left, safe.top, safe.right, safe.bottom)
             keyboardInset = max(0, ime.bottom - safe.bottom)
-            view.setPadding(safe.left, safe.top, safe.right, safe.bottom)
+            updateSafeAreaViews()
             updateKeyboardAvoidingViews()
             view.requestLayout()
             view.post { screens.lastOrNull()?.takeIf { it.active }?.let(::emitLayoutEvents) }
@@ -2443,6 +2661,9 @@ class MainActivity : AppCompatActivity() {
             haptic()
             if (index == currentTab) popToRoot() else selectTab(index)
         }
+        bars.onTabSwipeStart = { dx, x, y -> beginTabSwipe(dx, x, y) }
+        bars.onTabSwipeMove = { dx -> updateTabSwipe(dx) }
+        bars.onTabSwipeEnd = { dx, cancelled -> finishTabSwipe(dx, cancelled) }
         root.addView(bars)
         chrome = bars
         tabStacks.clear()
@@ -2466,12 +2687,97 @@ class MainActivity : AppCompatActivity() {
         currentTab = index
         screens = tabStacks[index]
         chrome?.selectTab(index)
-        if (screens.isEmpty()) {
-            val match = routes.tabs.getOrNull(index)?.let { routes.match(it.id) }
-            if (match != null) openScreen(match.screen, match.params)?.path = match.path else openScreen(null)
-        } else {
-            show(screens.last())
+        ensureTabRoot(index)?.let(::show)
+    }
+
+    /** Mount a tab's root without stealing focus, for an interactive swipe. */
+    private fun ensureTabRoot(index: Int): Screen? {
+        if (index !in tabStacks.indices) return null
+        tabStacks[index].lastOrNull()?.let { return it }
+        val previous = screens
+        screens = tabStacks[index]
+        val match = routes.tabs.getOrNull(index)?.let { routes.match(it.id) }
+        val screen = if (match != null) openScreen(match.screen, match.params, showImmediately = false) else openScreen(null, showImmediately = false)
+        screen?.path = match?.path
+        screens = previous
+        return screen
+    }
+
+    /** Start an interactive horizontal transition to the adjacent tab. */
+    private fun beginTabSwipe(dx: Float, x: Float, y: Float): Boolean {
+        if (tabSwipeTarget != null || screens.size != 1 || chrome?.tabSwipeEnabled != true) return false
+        val direction = if (dx < 0) 1 else -1
+        val targetIndex = currentTab + direction
+        val current = visibleScreen ?: return false
+        val target = ensureTabRoot(targetIndex) ?: return false
+        val host = chrome?.content ?: return false
+        if (target === current || host.width <= 0) return false
+        if (horizontalScrollCanConsume(current.view, host, x, y, dx)) return false
+        (target.view.parent as? ViewGroup)?.removeView(target.view)
+        host.addView(target.view, FrameLayout.LayoutParams(-1, -1))
+        target.view.translationX = if (direction > 0) host.width.toFloat() else -host.width.toFloat()
+        current.view.translationX = 0f
+        host.bringChildToFront(target.view)
+        tabSwipeTarget = target
+        tabSwipeTargetIndex = targetIndex
+        tabSwipeDirection = direction
+        chrome?.selectTab(targetIndex)
+        return true
+    }
+
+    private fun updateTabSwipe(dx: Float) {
+        val current = visibleScreen ?: return
+        val target = tabSwipeTarget ?: return
+        val width = (chrome?.content?.width ?: return).toFloat().coerceAtLeast(1f)
+        val offset = dx.coerceIn(-width, width)
+        target.view.translationX = (if (tabSwipeDirection > 0) width else -width) + offset
+        current.view.translationX = offset
+    }
+
+    private fun finishTabSwipe(dx: Float, cancelled: Boolean) {
+        val current = visibleScreen ?: return
+        val target = tabSwipeTarget ?: return
+        val host = chrome?.content ?: return
+        val width = host.width.toFloat().coerceAtLeast(1f)
+        val complete = !cancelled && kotlin.math.abs(dx) >= width * 0.28f
+        val endOffset = if (complete) {
+            if (tabSwipeDirection > 0) -width else width
+        } else 0f
+        val targetOffset = if (complete) 0f else if (tabSwipeDirection > 0) width else -width
+        current.view.animate().translationX(endOffset).setDuration(180).start()
+        target.view.animate().translationX(targetOffset).setDuration(180).withEndAction {
+            target.view.animate().setListener(null)
+            if (complete) {
+                current.view.translationX = 0f
+                currentTab = tabSwipeTargetIndex
+                screens = tabStacks[currentTab]
+                tabSwipeTarget = null
+                tabSwipeTargetIndex = -1
+                tabSwipeDirection = 0
+                haptic()
+                show(target)
+            } else {
+                host.removeView(target.view)
+                current.view.translationX = 0f
+                chrome?.selectTab(currentTab)
+                tabSwipeTarget = null
+                tabSwipeTargetIndex = -1
+                tabSwipeDirection = 0
+            }
+        }.start()
+    }
+
+    private fun horizontalScrollCanConsume(view: View, host: ViewGroup, x: Float, y: Float, dx: Float): Boolean {
+        val localX = x - view.left
+        val localY = y - host.top - view.top
+        if (view !is ViewGroup || localX < 0 || localY < 0 || localX > view.width || localY > view.height) return false
+        for (index in view.childCount - 1 downTo 0) {
+            val child = view.getChildAt(index)
+            if (!child.isShown || localX < child.left || localX > child.right || localY < child.top || localY > child.bottom) continue
+            if (child is android.widget.HorizontalScrollView && child.canScrollHorizontally(if (dx < 0) 1 else -1)) return true
+            if (horizontalScrollCanConsume(child, host, localX - child.left, localY - child.top, dx)) return true
         }
+        return false
     }
 
     /**
@@ -2523,7 +2829,7 @@ class MainActivity : AppCompatActivity() {
         services.perform("Browser", "open", JSONArray().put(url), {})
     }
 
-    private fun openScreen(route: String?, params: JSONObject = JSONObject(), headless: Boolean = false): Screen? {
+    private fun openScreen(route: String?, params: JSONObject = JSONObject(), headless: Boolean = false, showImmediately: Boolean = true): Screen? {
         val engine = sandbox ?: return null
         val isolate = engine.createIsolate()
         val view = CraftNativeFlexLayout(this).apply {
@@ -2560,7 +2866,7 @@ class MainActivity : AppCompatActivity() {
         }
         if (!headless) {
             screens.add(activeScreen)
-            show(activeScreen)
+            if (showImmediately) show(activeScreen)
         }
         val routePrelude = """
             globalThis.__stxNativeRoute = ${route?.let { JSONObject.quote(it) } ?: "undefined"};
@@ -2844,6 +3150,23 @@ class MainActivity : AppCompatActivity() {
                 else -> null
             }
         }.forEach { it.refreshThemeDefaults() }
+        updateSafeAreaViews()
+    }
+
+    private fun updateSafeAreaViews() {
+        if (!::root.isInitialized) return
+        val active = visibleScreen ?: screens.lastOrNull { it.active }
+        val rootNode = active?.mutations?.node("root")
+        val safeRoot = rootNode?.let { canonicalType(it.optString("type")) == "SafeAreaView" } == true
+        root.setPadding(
+            if (safeRoot) 0 else windowSafeInsets[0],
+            if (safeRoot) 0 else windowSafeInsets[1],
+            if (safeRoot) 0 else windowSafeInsets[2],
+            if (safeRoot) 0 else windowSafeInsets[3],
+        )
+        val tree = active?.view?.getChildAt(0) as? CraftNativeFlexLayout
+        if (safeRoot) tree?.setWindowSafeInsets(windowSafeInsets[0], windowSafeInsets[1], windowSafeInsets[2], windowSafeInsets[3])
+        else tree?.setWindowSafeInsets(0, 0, 0, 0)
     }
 
     private fun refreshThemeDefaults() {
@@ -3061,6 +3384,8 @@ class MainActivity : AppCompatActivity() {
 
     private fun renderCommitted(screen: Screen, document: JSONObject) {
         // Keep live controls (especially the focused EditText) across renders.
+        screen.statusBarStyle = null
+        screen.statusBarHidden = null
         val next = mutableMapOf<String, View>()
         screen.nodeViews.clear()
         screen.nodePaths.clear()
@@ -3075,10 +3400,24 @@ class MainActivity : AppCompatActivity() {
         screen.controls.putAll(next)
         screen.handlers.keys.retainAll(retainedViews(screen))
         screen.view.setChildStyle(tree, document.optJSONObject("style") ?: JSONObject(), resources.displayMetrics.density)
+        updateSafeAreaViews()
         // A full render can change a view's custom layout style without
         // changing the root bounds. Ensure native @layout observers still see
         // the settled child frame after the next traversal.
         scheduleLayoutEvents(screen)
+        if (visibleScreen === screen) applyStatusBar(screen)
+    }
+
+    private fun applyStatusBar(screen: Screen) {
+        val controller = WindowCompat.getInsetsController(window, window.decorView)
+        val night = (resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK) == Configuration.UI_MODE_NIGHT_YES
+        controller.isAppearanceLightStatusBars = when (screen.statusBarStyle?.lowercase()) {
+            "light-content", "light" -> false
+            "dark-content", "dark" -> true
+            else -> !night
+        }
+        if (screen.statusBarHidden == true) controller.hide(WindowInsetsCompat.Type.statusBars())
+        else controller.show(WindowInsetsCompat.Type.statusBars())
     }
 
     private fun clearRenderedTree(screen: Screen) {
@@ -3088,6 +3427,7 @@ class MainActivity : AppCompatActivity() {
         screen.nodeViews.clear()
         screen.nodePaths.clear()
         screen.handlers.clear()
+        screen.linkTargets.clear()
         screen.flatListRows.clear()
         screen.flatListOwners.clear()
         screen.flatListOwnerByView.clear()
@@ -3124,6 +3464,14 @@ class MainActivity : AppCompatActivity() {
                 }
                 configureText(this, childText(children), style)
             }
+            "StatusBar" -> (previous as? CraftNativeFlexLayout ?: CraftNativeFlexLayout(this)).apply {
+                screen.statusBarStyle = props.optString("barStyle").takeIf { it.isNotBlank() }
+                screen.statusBarHidden = if (props.has("hidden")) props.optBoolean("hidden") else null
+                visibility = View.GONE
+            }
+            "RefreshControl" -> (previous as? CraftNativeFlexLayout ?: CraftNativeFlexLayout(this)).apply {
+                visibility = View.GONE
+            }
             "Link" -> ((previous as? TextView)?.takeUnless { it is Button } ?: TextView(this)).apply {
                 includeFontPadding = false
                 configureText(this, props.optString("title").ifBlank { childText(children) }, style)
@@ -3133,9 +3481,15 @@ class MainActivity : AppCompatActivity() {
                 isEnabled = !props.optBoolean("disabled", false)
                 isClickable = true
                 isFocusable = true
+                val target = listOf(props.optString("href"), props.optString("to"))
+                    .firstOrNull { it.isNotBlank() }
+                    ?.trim()
+                    ?.takeIf { !props.optBoolean("disabled", false) }
+                if (target != null) screen.linkTargets[this] = target else screen.linkTargets.remove(this)
                 val handler = events.optString("onPress").ifBlank { events.optString("onClick") }
                 if (handler.isNotBlank()) screen.handlers[this] = handler else screen.handlers.remove(this)
                 setOnClickListener {
+                    screen.linkTargets[it]?.let { target -> navigateOpen(target); return@setOnClickListener }
                     val current = screen.handlers[this] ?: return@setOnClickListener
                     send(screen, "EVENT", JSONObject().put("handlerName", current).put("nativeEvent", JSONObject()))
                 }
@@ -3540,7 +3894,7 @@ class MainActivity : AppCompatActivity() {
                 if (onLoadEnd.isNotBlank()) screen.imageLoadEndHandlers[this] = onLoadEnd else screen.imageLoadEndHandlers.remove(this)
                 val onError = events.optString("onError")
                 if (onError.isNotBlank()) screen.imageErrorHandlers[this] = onError else screen.imageErrorHandlers.remove(this)
-                updateImage(screen, this, props.opt("source"))
+                updateImage(screen, this, props.opt("source"), props.opt("defaultSource"))
             }
             "ImageBackground" -> (previous as? CraftNativeImageBackgroundView ?: CraftNativeImageBackgroundView(this)).apply {
                 image.scaleType = when (style.optString("resizeMode").ifBlank { props.optString("resizeMode") }) {
@@ -3557,7 +3911,7 @@ class MainActivity : AppCompatActivity() {
                 if (onLoadEnd.isNotBlank()) screen.imageLoadEndHandlers[image] = onLoadEnd else screen.imageLoadEndHandlers.remove(image)
                 val onError = events.optString("onError")
                 if (onError.isNotBlank()) screen.imageErrorHandlers[image] = onError else screen.imageErrorHandlers.remove(image)
-                updateImage(screen, image, props.opt("source"))
+                updateImage(screen, image, props.opt("source"), props.opt("defaultSource"))
                 configureContainer(content, style)
                 reconcileChildren(screen, content, children, path, next, style, previousControls)
             }
@@ -3571,6 +3925,13 @@ class MainActivity : AppCompatActivity() {
                     controls = props.optBoolean("controls", false),
                 )
             }
+            "Map" -> (previous as? CraftNativeMapView ?: CraftNativeMapView(this)).apply {
+                configure(props, children) { markerId ->
+                    markerHandler(markerId)?.let { handler ->
+                        send(screen, "EVENT", JSONObject().put("handlerName", handler).put("nativeEvent", JSONObject().put("id", markerId)))
+                    }
+                }
+            }
             "Svg" -> (previous as? CraftNativeSvgView ?: CraftNativeSvgView(this)).apply {
                 drawing = node
             }
@@ -3590,10 +3951,18 @@ class MainActivity : AppCompatActivity() {
                     props.optBoolean("alwaysBounceHorizontal", horizontal),
                 )
                 setPagingEnabled(props.optBoolean("pagingEnabled", false))
-                val refreshHandler = events.optString("onRefresh").takeIf { it.isNotBlank() }?.let { handler ->
+                val refreshNode = (0 until children.length()).asSequence()
+                    .mapNotNull { children.optJSONObject(it) }
+                    .firstOrNull { canonicalType(it.optString("type")) == "RefreshControl" }
+                val refreshProps = refreshNode?.optJSONObject("props") ?: JSONObject()
+                val refreshEvents = refreshNode?.optJSONObject("events") ?: JSONObject()
+                val refreshHandlerName = refreshEvents.optString("onRefresh").takeIf { it.isNotBlank() }
+                    ?: events.optString("onRefresh").takeIf { it.isNotBlank() }
+                val refreshHandler = refreshHandlerName?.let { handler ->
                     { send(screen, "EVENT", JSONObject().put("handlerName", handler).put("nativeEvent", JSONObject())) }
                 }
-                setRefreshHandler(refreshHandler, props.optBoolean("refreshing", false))
+                setRefreshHandler(refreshHandler, if (refreshNode == null) props.optBoolean("refreshing", false) else refreshProps.optBoolean("refreshing", false))
+                setRefreshAppearance(refreshProps, resources.displayMetrics.density)
                 val onScroll = events.optString("onScroll")
                 if (onScroll.isNotBlank()) screen.scrollHandlers[this] = onScroll else screen.scrollHandlers.remove(this)
                 val onBegin = events.optString("onScrollBeginDrag")
@@ -3647,7 +4016,12 @@ class MainActivity : AppCompatActivity() {
                     }
                 }
                 configureContainer(content, contentStyle)
-                reconcileChildren(screen, content, children, path, next, contentStyle, previousControls)
+                val contentChildren = JSONArray()
+                for (index in 0 until children.length()) {
+                    val child = children.opt(index)
+                    if (child !is JSONObject || canonicalType(child.optString("type")) != "RefreshControl") contentChildren.put(child)
+                }
+                reconcileChildren(screen, content, contentChildren, path, next, contentStyle, previousControls)
             }
             "FlatList" -> (previous as? CraftNativeRefreshableFlatList ?: CraftNativeRefreshableFlatList(this)).apply {
                 val nativeList = list
@@ -3665,6 +4039,7 @@ class MainActivity : AppCompatActivity() {
             }
             "View", "SafeAreaView" -> (previous as? CraftNativeFlexLayout ?: CraftNativeFlexLayout(this)).apply {
                 configureContainer(this, style)
+                if (type == "SafeAreaView") setSafeAreaEdges(props.optJSONArray("edges"))
                 reconcileChildren(screen, this, children, path, next, style, previousControls)
             }
             "KeyboardAvoidingView" -> (previous as? CraftNativeKeyboardAvoidingView ?: CraftNativeKeyboardAvoidingView(this)).apply {
@@ -3686,15 +4061,21 @@ class MainActivity : AppCompatActivity() {
         val pressOutHandler = events.optString("onPressOut").takeIf { it.isNotBlank() }
         if (pressInHandler != null) screen.pressInHandlers[control] = pressInHandler else screen.pressInHandlers.remove(control)
         if (pressOutHandler != null) screen.pressOutHandlers[control] = pressOutHandler else screen.pressOutHandlers.remove(control)
-        if (type != "Button" && type != "Link" && type != "TextInput" && type != "Picker" && type != "DatePicker" && type != "Modal" && type != "Switch" && type != "Slider" && type != "ActivityIndicator" && type != "KeyboardAvoidingView") {
+        if (type != "Button" && type != "Link" && type != "TextInput" && type != "Picker" && type != "DatePicker" && type != "Modal" && type != "Switch" && type != "Slider" && type != "ActivityIndicator" && type != "KeyboardAvoidingView" && type != "StatusBar" && type != "RefreshControl" && type != "Map") {
             val handler = events.optString("onPress").ifBlank { events.optString("onClick") }
             val disabled = props.optBoolean("disabled", false)
+            val target = listOf(props.optString("href"), props.optString("to"))
+                .firstOrNull { it.isNotBlank() }
+                ?.trim()
+                ?.takeIf { !disabled && type in setOf("TouchableOpacity", "TouchableHighlight", "Pressable") }
+            if (target != null) screen.linkTargets[control] = target else screen.linkTargets.remove(control)
             val hasPressLifecycle = pressInHandler != null || pressOutHandler != null
-            if ((handler.isNotBlank() || (type in setOf("TouchableOpacity", "TouchableHighlight", "Pressable") && hasPressLifecycle)) && !disabled) {
+            if ((handler.isNotBlank() || target != null || (type in setOf("TouchableOpacity", "TouchableHighlight", "Pressable") && hasPressLifecycle)) && !disabled) {
                 if (handler.isNotBlank()) screen.handlers[control] = handler else screen.handlers.remove(control)
                 control.isClickable = true
                 if (type in setOf("TouchableOpacity", "TouchableHighlight", "Pressable")) {
                     control.setOnClickListener {
+                        screen.linkTargets[it]?.let { target -> navigateOpen(target); return@setOnClickListener }
                         val current = screen.handlers[it] ?: return@setOnClickListener
                         send(screen, "EVENT", JSONObject().put("handlerName", current).put("nativeEvent", JSONObject()))
                     }
@@ -3715,6 +4096,7 @@ class MainActivity : AppCompatActivity() {
                                     send(screen, "EVENT", JSONObject().put("handlerName", current).put("nativeEvent", JSONObject()))
                                 }
                                 if (event.actionMasked == android.view.MotionEvent.ACTION_UP) {
+                                    screen.linkTargets[view]?.let { target -> navigateOpen(target); return@setOnTouchListener true }
                                     val current = screen.handlers[view] ?: return@setOnTouchListener true
                                     send(screen, "EVENT", JSONObject().put("handlerName", current).put("nativeEvent", JSONObject()))
                                 }
@@ -3726,6 +4108,7 @@ class MainActivity : AppCompatActivity() {
                 } else {
                     control.setOnTouchListener(null)
                     control.setOnClickListener {
+                        screen.linkTargets[control]?.let { target -> navigateOpen(target); return@setOnClickListener }
                         val current = screen.handlers[control] ?: return@setOnClickListener
                         send(screen, "EVENT", JSONObject().put("handlerName", current).put("nativeEvent", JSONObject()))
                     }
@@ -3833,10 +4216,13 @@ class MainActivity : AppCompatActivity() {
         "switch" -> "Switch"
         "slider" -> "Slider"
         "activityindicator" -> "ActivityIndicator"
+        "statusbar" -> "StatusBar"
+        "refreshcontrol" -> "RefreshControl"
         "image" -> "Image"
         "imagebackground" -> "ImageBackground"
         "keyboardavoidingview" -> "KeyboardAvoidingView"
         "video" -> "Video"
+        "map" -> "Map"
         "icon" -> "Icon"
         "scrollview" -> "ScrollView"
         "sectionlist" -> "SectionList"
@@ -4274,6 +4660,21 @@ class MainActivity : AppCompatActivity() {
 
     private fun applyTextDecoration(view: TextView, style: JSONObject) {
         val line = style.optString("textDecorationLine")
+        if (view is EditText) {
+            // A field's own text, spanned in place: replacing it would move
+            // the caret to the start and tell the screen the text changed.
+            val editable = view.text ?: return
+            editable.getSpans(0, editable.length, CraftTextDecorationSpan::class.java).forEach(editable::removeSpan)
+            if (line.isBlank() || line == "none" || editable.isEmpty()) return
+            val fieldColor = style.optString("textDecorationColor").takeIf { it.isNotBlank() }?.let { color(it, Color.TRANSPARENT) }
+            editable.setSpan(
+                CraftTextDecorationSpan(line, style.optString("textDecorationStyle").ifBlank { "solid" }, fieldColor),
+                0,
+                editable.length,
+                Spannable.SPAN_INCLUSIVE_INCLUSIVE,
+            )
+            return
+        }
         val text = view.text?.toString() ?: return
         if (line.isBlank() || line == "none" || text.isEmpty()) {
             if (view.text is Spannable) view.text = text
@@ -4311,12 +4712,23 @@ class MainActivity : AppCompatActivity() {
             host == "::1" || host.endsWith(".localhost")
     }
 
-    private fun updateImage(screen: Screen, view: ImageView, source: Any?) {
-        val uri = when (source) {
-            is String -> source
-            is JSONObject -> source.optString("uri")
-            else -> ""
+    private fun imageUri(source: Any?): String = when (source) {
+        is String -> source
+        is JSONObject -> source.optString("uri")
+        else -> ""
+    }
+
+    private fun immediateImage(uri: String): Bitmap? {
+        if (uri.startsWith("data:image/") && uri.contains(',')) {
+            val bytes = runCatching { Base64.decode(uri.substringAfter(','), Base64.DEFAULT) }.getOrNull()
+            return bytes?.let { BitmapFactory.decodeByteArray(it, 0, it.size) }
         }
+        if (!uri.contains(':')) return runCatching { assets.open(uri).use { BitmapFactory.decodeStream(it) } }.getOrNull()
+        return null
+    }
+
+    private fun updateImage(screen: Screen, view: ImageView, source: Any?, defaultSource: Any? = null) {
+        val uri = imageUri(source)
         if (uri.isBlank()) {
             if (imageSources[view] == "") return
             imageJobs.remove(view)?.cancel(true)
@@ -4331,6 +4743,7 @@ class MainActivity : AppCompatActivity() {
         imageSources[view] = uri
         imageErrors.remove(view)
         view.setImageDrawable(null)
+        immediateImage(imageUri(defaultSource))?.let(view::setImageBitmap)
         emitImageEvent(screen, view, screen.imageLoadStartHandlers[view])
 
         if (uri.startsWith("data:image/") && uri.contains(',')) {
@@ -4847,6 +5260,7 @@ class MainActivity : AppCompatActivity() {
             if (!preservingInputDrafts) identity?.let(screen.drafts::remove)
         }
         released.forEach(defaultBackgrounds::remove)
+        screen.linkTargets.keys.removeAll(released)
         screen.handlers.keys.removeAll(released)
         screen.pressInHandlers.keys.removeAll(released)
         screen.pressOutHandlers.keys.removeAll(released)