craft-native 0.0.238 → 0.0.241

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

@@ -110,17 +110,7 @@ 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
+{{NATIVE_MAP_IMPORTS}}
 import org.json.JSONArray
 import org.json.JSONObject
 import java.io.File
@@ -597,422 +587,7 @@ 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 val scaleView = LinearLayout(context).apply {
-        orientation = LinearLayout.VERTICAL
-        setPadding(4, 2, 4, 2)
-        background = GradientDrawable().apply { setColor(Color.argb(230, 255, 255, 255)); cornerRadius = 4f }
-        importantForAccessibility = View.IMPORTANT_FOR_ACCESSIBILITY_NO
-    }
-    private val scaleLabel = TextView(context).apply { textSize = 11f; setTextColor(Color.rgb(37, 51, 33)) }
-    private val scaleLine = View(context).apply { setBackgroundColor(Color.rgb(37, 51, 33)) }
-    private var googleMap: GoogleMap? = null
-    private var tileOverlay: com.google.android.gms.maps.model.TileOverlay? = null
-    private var tileTemplate: String? = null
-    private val tileAttribution = TextView(context).apply { textSize = 9f; setTextColor(Color.DKGRAY); setBackgroundColor(Color.argb(220, 255, 255, 255)); maxLines = 2; visibility = View.GONE }
-    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
-    var onMapPress: ((LatLng) -> Unit)? = null
-    var onRegionChangeComplete: ((JSONObject) -> Unit)? = null
-    private var userChangingCamera = false
-    private var markerBearings = mutableMapOf<String, Float>()
-    private var directionIcon: com.google.android.gms.maps.model.BitmapDescriptor? = null
-    private var lifecycleStarted = false
-    private var destroyed = false
-    private var initialCameraKey: String? = null
-
-    init {
-        addView(mapView, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT))
-        scaleView.addView(scaleLabel)
-        scaleView.addView(scaleLine, LinearLayout.LayoutParams(1, 2))
-        addView(scaleView, LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT, Gravity.BOTTOM or Gravity.START).apply {
-            leftMargin = (8 * resources.displayMetrics.density).roundToInt()
-            bottomMargin = (24 * resources.displayMetrics.density).roundToInt()
-        })
-        scaleView.visibility = View.GONE
-        addView(tileAttribution, LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT, Gravity.BOTTOM or Gravity.END).apply { rightMargin = (8 * resources.displayMetrics.density).roundToInt(); bottomMargin = (8 * resources.displayMetrics.density).roundToInt() })
-        mapView.onCreate(null)
-        mapView.getMapAsync(this)
-    }
-
-    override fun onMapReady(map: GoogleMap) {
-        if (destroyed) return
-        googleMap = map
-        map.setOnMapClickListener { point -> onMapPress?.invoke(point) }
-        map.setOnCameraMoveStartedListener { reason ->
-            if (reason == GoogleMap.OnCameraMoveStartedListener.REASON_GESTURE) userChangingCamera = true
-        }
-        map.setOnCameraMoveListener { updateScale() }
-        map.setOnCameraIdleListener {
-            updateScale()
-            if (userChangingCamera) {
-                userChangingCamera = false
-                val bounds = map.projection.visibleRegion.latLngBounds
-                val position = map.cameraPosition
-                val longitudeDelta = (bounds.northeast.longitude - bounds.southwest.longitude + 360) % 360
-                onRegionChangeComplete?.invoke(JSONObject()
-                    .put("center", JSONObject().put("latitude", position.target.latitude).put("longitude", position.target.longitude))
-                    .put("span", JSONObject().put("latitudeDelta", bounds.northeast.latitude - bounds.southwest.latitude).put("longitudeDelta", longitudeDelta))
-                    .put("heading", position.bearing).put("pitch", position.tilt))
-            }
-        }
-        map.setOnMarkerClickListener { marker ->
-            val id = markers.entries.firstOrNull { it.value == marker }?.key ?: return@setOnMarkerClickListener false
-            onMarkerTap?.invoke(id)
-            // The native contract dispatches the marker event itself. Consume
-            // the click so Google Maps does not also show an unsolicited info
-            // window for the marker title.
-            true
-        }
-        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
-        applyMapPadding()
-        map.uiSettings.isCompassEnabled = craftNativeBoolean(pendingProps.opt("showsCompass"))
-        // The toolbar is replaced by authored actions; the scale uses the native projection.
-        map.uiSettings.isMapToolbarEnabled = false
-        map.uiSettings.isScrollGesturesEnabled = craftNativeBoolean(pendingProps.opt("scrollEnabled"), true)
-        map.uiSettings.isZoomGesturesEnabled = craftNativeBoolean(pendingProps.opt("zoomEnabled"), true)
-        map.uiSettings.isRotateGesturesEnabled = craftNativeBoolean(pendingProps.opt("rotateEnabled"))
-        map.mapType = when (craftNativeOptionalString(pendingProps.opt("mapType")).orEmpty().lowercase()) {
-            "satellite" -> GoogleMap.MAP_TYPE_SATELLITE
-            "hybrid" -> GoogleMap.MAP_TYPE_HYBRID
-            "terrain" -> GoogleMap.MAP_TYPE_TERRAIN
-            else -> GoogleMap.MAP_TYPE_NORMAL
-        }
-        applyTileOverlay()
-        val showUserLocation = craftNativeBoolean(pendingProps.opt("showsUserLocation")) && hasLocationPermission()
-        runCatching { map.isMyLocationEnabled = showUserLocation }
-        val nextMarkers = mutableMapOf<String, Pair<LatLng, String?>>()
-        val nextBearings = mutableMapOf<String, Float>()
-        val nextHandlers = mutableMapOf<String, String>()
-        val nextPolylines = mutableMapOf<String, Triple<List<LatLng>, Int, Float>>()
-        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 = craftNativeOptionalString(props.opt("id"))
-                ?: craftNativeOptionalString(child.opt("id"))
-                ?: "overlay-$index"
-            val points = coordinates(props.optJSONArray("geometry"))
-            if (type == "mapmarker" || type == "marker") {
-                points.firstOrNull()?.let { point ->
-                    nextMarkers[id] = point to (props.opt("title") as? String)
-                    (props.opt("bearing") as? Number)?.toDouble()?.takeIf { it.isFinite() }?.let { nextBearings[id] = (it % 360).toFloat() }
-                    listOf(events.opt("onPress"), events.opt("onMarkerPress"))
-                        .firstNotNullOfOrNull(::craftNativeOptionalString)
-                        ?.let { nextHandlers[id] = it }
-                }
-            } else if (type == "mappolyline" || type == "polyline") {
-                if (points.size > 1) {
-                    // Keep malformed authored widths inert, matching the iOS
-                    // host. An omitted or null width still gets the shared
-                    // default; an attacker-controlled NaN, infinity, zero,
-                    // or negative value must not become a valid overlay.
-                    val rawWidth = props.opt("strokeWidth")
-                    val authoredWidth = when (rawWidth) {
-                        null, JSONObject.NULL -> 3.0
-                        is Number -> rawWidth.toDouble()
-                        else -> 3.0
-                    }
-                    // MapKit's lineWidth is expressed in points, while the
-                    // Google Maps SDK consumes screen pixels. Keep the
-                    // protocol in logical points and convert only at this
-                    // Android host boundary so dense displays stay in parity.
-                    val width = (authoredWidth * resources.displayMetrics.density).toFloat()
-                    if (!authoredWidth.isFinite() || !width.isFinite() || width <= 0f) continue
-                    nextPolylines[id] = Triple(points, color(craftNativeOptionalString(props.opt("strokeColor")).orEmpty()), width)
-                }
-            }
-        }
-        markerBearings = nextBearings
-        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
-                marker.setIcon(if (markerBearings.containsKey(id)) directionMarkerIcon() else BitmapDescriptorFactory.defaultMarker())
-                marker.isFlat = markerBearings.containsKey(id)
-                marker.rotation = markerBearings[id] ?: 0f
-                marker.setAnchor(0.5f, if (markerBearings.containsKey(id)) 0.5f else 1f)
-            } else {
-                map.addMarker(MarkerOptions().position(value.first).title(value.second).icon(if (markerBearings.containsKey(id)) directionMarkerIcon() else BitmapDescriptorFactory.defaultMarker()).flat(markerBearings.containsKey(id)).rotation(markerBearings[id] ?: 0f).anchor(0.5f, if (markerBearings.containsKey(id)) 0.5f else 1f))?.let { markers[id] = it }
-            }
-        }
-        markerHandlers.clear()
-        markerHandlers.putAll(nextHandlers)
-        polylines.keys.filter { nextPolylines[it] == null }.forEach { id ->
-            polylines.remove(id)?.remove()
-        }
-        for ((id, value) in nextPolylines) {
-            val polyline = polylines[id]
-            if (polyline != null) {
-                polyline.points = value.first
-                polyline.color = value.second
-                polyline.width = value.third
-            } else {
-                map.addPolyline(PolylineOptions().addAll(value.first).color(value.second).width(value.third))?.let { polylines[id] = it }
-            }
-        }
-        val explicitRegion = region(pendingProps.optJSONObject("region"))
-        val initialRegion = region(pendingProps.optJSONObject("initialRegion"))
-        if (explicitRegion != null) {
-            // A controlled region is an exact camera request. The padding
-            // used for fitToBounds is framing chrome, not part of the region
-            // contract, and would otherwise zoom every Android screen out.
-            moveCamera(explicitRegion, padding = 0)
-            initialCameraKey = null
-        } else if (initialRegion != null) {
-            val key = "region:${pendingProps.optJSONObject("initialRegion")}"
-            if (initialCameraKey != key) {
-                moveCamera(initialRegion, padding = 0)
-                initialCameraKey = key
-            }
-        } else if (craftNativeBoolean(pendingProps.opt("fitToBounds"))) {
-            val key = "fit:${overlayKey(nextMarkers, nextPolylines)}:${pendingProps.optJSONObject("edgePadding")}"
-            if (initialCameraKey != key) {
-                if (fitToBounds()) initialCameraKey = key
-            }
-        } else {
-            initialCameraKey = null
-        }
-        applyCameraOrientation()
-        updateScale()
-    }
-
-    private fun applyTileOverlay() {
-        val map = googleMap ?: return
-        val options = pendingProps.optJSONObject("tileOverlay")
-        val template = options?.optString("urlTemplate").orEmpty()
-        val credit = options?.optString("attribution").orEmpty()
-        val next = template.takeIf { it.startsWith("https://") && listOf("{z}", "{x}", "{y}").all { key -> it.contains(key) } && credit.isNotBlank() }
-        if (next != tileTemplate) {
-            tileOverlay?.remove(); tileOverlay = null; tileTemplate = next
-            if (next != null) {
-                val provider = object : com.google.android.gms.maps.model.UrlTileProvider(256, 256) {
-                    override fun getTileUrl(x: Int, y: Int, zoom: Int): java.net.URL? = runCatching { java.net.URL(next.replace("{x}", x.toString()).replace("{y}", y.toString()).replace("{z}", zoom.toString())) }.getOrNull()
-                }
-                tileOverlay = map.addTileOverlay(com.google.android.gms.maps.model.TileOverlayOptions().tileProvider(provider).zIndex(-1f))
-            }
-        }
-        if (next != null) map.mapType = GoogleMap.MAP_TYPE_NONE
-        tileAttribution.text = credit
-        tileAttribution.visibility = if (next == null) View.GONE else View.VISIBLE
-    }
-
-    private fun applyMapPadding() {
-        val authored = pendingProps.optJSONObject("edgePadding")
-        fun inset(name: String): Double = (authored?.opt(name) as? Number)?.toDouble()?.takeIf { it.isFinite() }?.coerceIn(0.0, 10_000.0)?.times(resources.displayMetrics.density) ?: 0.0
-        var left = inset("left"); var top = inset("top"); var right = inset("right"); var bottom = inset("bottom")
-        val horizontal = left + right
-        val vertical = top + bottom
-        val availableWidth = (width - 40 * resources.displayMetrics.density).coerceAtLeast(0f).toDouble()
-        val availableHeight = (height - 40 * resources.displayMetrics.density).coerceAtLeast(0f).toDouble()
-        if (horizontal > availableWidth && horizontal > 0) { left *= availableWidth / horizontal; right *= availableWidth / horizontal }
-        if (vertical > availableHeight && vertical > 0) { top *= availableHeight / vertical; bottom *= availableHeight / vertical }
-        googleMap?.setPadding(left.roundToInt(), top.roundToInt(), right.roundToInt(), bottom.roundToInt())
-    }
-
-    private fun updateScale() {
-        val map = googleMap ?: return
-        if (!craftNativeBoolean(pendingProps.opt("showsScale")) || width <= 0 || height <= 0) { scaleView.visibility = View.GONE; return }
-        val maximumWidth = (80 * resources.displayMetrics.density).roundToInt()
-        val origin = map.projection.fromScreenLocation(android.graphics.Point(width / 2, height / 2))
-        val end = map.projection.fromScreenLocation(android.graphics.Point(width / 2 + maximumWidth, height / 2))
-        val distance = FloatArray(1)
-        android.location.Location.distanceBetween(origin.latitude, origin.longitude, end.latitude, end.longitude, distance)
-        val metres = distance[0].toDouble()
-        if (!metres.isFinite() || metres <= 0) { scaleView.visibility = View.GONE; return }
-        val magnitude = Math.pow(10.0, kotlin.math.floor(kotlin.math.log10(metres)))
-        val length = listOf(5.0, 2.0, 1.0).firstOrNull { it * magnitude <= metres }?.times(magnitude) ?: magnitude
-        scaleLabel.text = if (length >= 1000) "${length / 1000} km" else "${length.roundToInt()} m"
-        scaleLine.layoutParams = LinearLayout.LayoutParams((maximumWidth * length / metres).roundToInt().coerceAtLeast(1), 2)
-        scaleView.visibility = View.VISIBLE
-    }
-
-    private fun applyCameraOrientation() {
-        val map = googleMap ?: return
-        val camera = map.cameraPosition
-        val pitch = (pendingProps.opt("cameraPitch") as? Number)?.toDouble()?.takeIf { it.isFinite() }?.coerceIn(0.0, 60.0)?.toFloat() ?: camera.tilt
-        val heading = (pendingProps.opt("cameraHeading") as? Number)?.toDouble()?.takeIf { it.isFinite() }?.toFloat() ?: camera.bearing
-        if (kotlin.math.abs(camera.tilt - pitch) > 0.01f || kotlin.math.abs(camera.bearing - heading) > 0.01f) {
-            map.moveCamera(CameraUpdateFactory.newCameraPosition(com.google.android.gms.maps.model.CameraPosition.Builder(camera).tilt(pitch).bearing(heading).build()))
-        }
-    }
-
-    private fun directionMarkerIcon(): com.google.android.gms.maps.model.BitmapDescriptor {
-        directionIcon?.let { return it }
-        val size = (26 * resources.displayMetrics.density).roundToInt().coerceAtLeast(24)
-        val bitmap = Bitmap.createBitmap(size, size, Bitmap.Config.ARGB_8888)
-        val canvas = Canvas(bitmap)
-        val paint = Paint(Paint.ANTI_ALIAS_FLAG)
-        paint.color = Color.WHITE
-        canvas.drawCircle(size / 2f, size / 2f, size / 2f, paint)
-        paint.color = Color.rgb(36, 114, 75)
-        canvas.drawCircle(size / 2f, size / 2f, size * 0.43f, paint)
-        paint.color = Color.WHITE
-        paint.textSize = size * 0.76f
-        paint.textAlign = Paint.Align.CENTER
-        paint.typeface = Typeface.DEFAULT_BOLD
-        canvas.drawText("↑", size / 2f, size / 2f - (paint.ascent() + paint.descent()) / 2, paint)
-        return BitmapDescriptorFactory.fromBitmap(bitmap).also { directionIcon = it }
-    }
-
-    override fun onSizeChanged(width: Int, height: Int, oldWidth: Int, oldHeight: Int) {
-        super.onSizeChanged(width, height, oldWidth, oldHeight)
-        applyMapPadding()
-        updateScale()
-        // MapView can become ready before its host has a usable viewport. Do
-        // not mark a fit as complete until the camera update can be issued.
-        if (width > 0 && height > 0 && craftNativeBoolean(pendingProps.opt("fitToBounds")) && initialCameraKey == null) {
-            applyPending()
-        }
-    }
-
-    private fun moveCamera(bounds: LatLngBounds, padding: Int = 24) {
-        post {
-            if (width > 0 && height > 0) {
-                googleMap?.moveCamera(CameraUpdateFactory.newLatLngBounds(bounds, padding))
-                applyCameraOrientation()
-            }
-        }
-    }
-
-    private fun overlayKey(
-        markers: Map<String, Pair<LatLng, String?>>,
-        polylines: Map<String, Triple<List<LatLng>, Int, Float>>,
-    ): String {
-        val markerKey = markers.toSortedMap().entries.joinToString("|") { (id, value) ->
-            "$id:${value.first.latitude},${value.first.longitude}"
-        }
-        val polylineKey = polylines.toSortedMap().entries.joinToString("|") { (id, value) ->
-            "$id:" + value.first.joinToString(";") { point -> "${point.latitude},${point.longitude}" }
-        }
-        return "m[$markerKey]p[$polylineKey]"
-    }
-
-    private fun fitToBounds(): Boolean {
-        val map = googleMap ?: return false
-        if (width <= 0 || height <= 0) return false
-        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 false
-        post {
-            if (width > 0 && height > 0) {
-                applyMapPadding()
-                val padding = if (pendingProps.has("edgePadding")) 0 else (24 * resources.displayMetrics.density).roundToInt()
-                map.moveCamera(CameraUpdateFactory.newLatLngBounds(builder.build(), padding))
-                applyCameraOrientation()
-            }
-        }
-        return true
-    }
-
-    override fun onAttachedToWindow() {
-        super.onAttachedToWindow()
-        if (destroyed) return
-        mapView.onStart()
-        mapView.onResume()
-        lifecycleStarted = true
-    }
-
-    override fun onDetachedFromWindow() {
-        if (lifecycleStarted) {
-            mapView.onPause()
-            mapView.onStop()
-            lifecycleStarted = false
-        }
-        super.onDetachedFromWindow()
-    }
-
-    fun destroy() {
-        if (destroyed) return
-        destroyed = true
-        if (lifecycleStarted) {
-            mapView.onPause()
-            mapView.onStop()
-            lifecycleStarted = false
-        }
-        onMarkerTap = null
-        onMapPress = null
-        onRegionChangeComplete = null
-        directionIcon = null
-        tileOverlay?.remove(); tileOverlay = null
-        markerHandlers.clear()
-        markers.values.forEach { it.remove() }
-        markers.clear()
-        polylines.values.forEach { it.remove() }
-        polylines.clear()
-        mapView.onDestroy()
-        googleMap = null
-    }
-
-    fun lowMemory() {
-        if (!destroyed) mapView.onLowMemory()
-    }
-
-    private fun hasLocationPermission(): Boolean =
-        ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED ||
-            ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_COARSE_LOCATION) == PackageManager.PERMISSION_GRANTED
-
-    private fun coordinates(geometry: JSONArray?): List<LatLng> {
-        if (geometry == null) return emptyList()
-        return (0 until geometry.length() - 1 step 2).mapNotNull { index ->
-            val latitude = finiteNumber(geometry.opt(index)) ?: return@mapNotNull null
-            val longitude = finiteNumber(geometry.opt(index + 1)) ?: return@mapNotNull null
-            if (latitude.isFinite() && longitude.isFinite() &&
-                latitude >= -90.0 && latitude <= 90.0 &&
-                longitude >= -180.0 && longitude <= 180.0
-            ) 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 = finiteNumber(center.opt("latitude")) ?: return null
-        val longitude = finiteNumber(center.opt("longitude")) ?: return null
-        val latitudeDelta = finiteNumber(span.opt("latitudeDelta"))
-            ?: finiteNumber(span.opt("latitude_delta"))
-            ?: return null
-        val longitudeDelta = finiteNumber(span.opt("longitudeDelta"))
-            ?: finiteNumber(span.opt("longitude_delta"))
-            ?: return null
-        if (!latitude.isFinite() || !longitude.isFinite() || !latitudeDelta.isFinite() || !longitudeDelta.isFinite() ||
-            latitude < -90.0 || latitude > 90.0 || longitude < -180.0 || longitude > 180.0 ||
-            latitudeDelta <= 0.0 || latitudeDelta > 180.0 ||
-            longitudeDelta <= 0.0 || longitudeDelta > 360.0 ||
-            latitude - latitudeDelta / 2.0 < -90.0 || latitude + latitudeDelta / 2.0 > 90.0
-        ) return null
-        return LatLngBounds(LatLng(latitude - latitudeDelta / 2, longitude - longitudeDelta / 2), LatLng(latitude + latitudeDelta / 2, longitude + longitudeDelta / 2))
-    }
-
-    private fun finiteNumber(value: Any?): Double? =
-        (value as? Number)?.toDouble()?.takeIf { it.isFinite() }
-
-    private fun color(value: String): Int = runCatching { craftNativeColor(value) }.getOrDefault(Color.BLUE)
-}
+{{NATIVE_MAP_HOST}}
 
 /** A finite celebration owned by a View, never by the JavaScript frame loop. */
 internal class CraftNativeCelebration(private val view: View) {
@@ -1882,7 +1457,7 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
             putEnum(base, 16, if (root) sharedAlignItemsCode(alignItems) else 3)
             putEnum(base, 17, if (root) 0 else sharedAlignSelfCode(style.alignSelf))
             putEnum(base, 18, if (root && wrap) 1 else 0)
-            putEnum(base, 19, if (root) alignContentCode() else 6)
+            putEnum(base, 19, if (root) alignContentCode() else 5)
             put(base, 20, margins[2].toFloat())
             put(base, 21, margins[1].toFloat())
             put(base, 22, margins[3].toFloat())
@@ -7000,6 +6575,7 @@ class MainActivity : AppCompatActivity() {
         val label = craftNativeOptionalString(props.opt("accessibilityLabel"))
             ?: craftNativeOptionalString(props.opt("alt"))?.takeIf { type == "Image" || type == "ImageBackground" }
         val value = craftNativeOptionalString(props.opt("accessibilityValue"))
+        val testId = craftNativeOptionalString(props.opt("testID"))
         view.contentDescription = when {
             label != null && value != null -> "$label, $value"
             label != null -> label
@@ -7024,6 +6600,9 @@ class MainActivity : AppCompatActivity() {
         ViewCompat.setAccessibilityDelegate(view, object : AccessibilityDelegateCompat() {
             override fun onInitializeAccessibilityNodeInfo(host: View, info: AccessibilityNodeInfoCompat) {
                 super.onInitializeAccessibilityNodeInfo(host, info)
+                // Expose STX test identities to Android's native automation
+                // tree without replacing the label read by TalkBack.
+                info.viewIdResourceName = testId
                 info.className = when (role) {
                     "button" -> Button::class.java.name
                     "image" -> ImageView::class.java.name

package/dist/android/templates/build.gradle.kts.app.template

@@ -99,7 +99,7 @@ dependencies {
     // Google Play Location Services (for geolocation)
     implementation("com.google.android.gms:play-services-location:21.1.0")
 
-{{GOOGLE_MAPS_DEPENDENCY}}
+{{NATIVE_MAP_DEPENDENCY}}
 
     // Google Play In-App Review
     implementation("com.google.android.play:review:2.0.1")

package/dist/android/templates/build.gradle.kts.project.template

@@ -1,6 +1,6 @@
 // Top-level build file where you can add configuration options common to all sub-projects/modules.
 plugins {
     id("com.android.application") version "8.9.1" apply false
-    id("org.jetbrains.kotlin.android") version "2.0.21" apply false
+    id("org.jetbrains.kotlin.android") version "2.2.10" apply false
 {{GOOGLE_SERVICES_PLUGIN}}
 }

package/dist/cli.js

@@ -3424,7 +3424,7 @@ function pinCraftNativeDependency(packagePath, craftVersion) {
 `);
 }
 // package.json
-var version = "0.0.238";
+var version = "0.0.241";
 
 // bin/cli.ts
 var spawnedFrom = process6.env[CRAFT_CLI_SPAWN_MARKER];

package/dist/index.cjs

@@ -310,7 +310,7 @@ function craftBinaryNotFoundMessage(triedPath) {
 `);
 }
 // package.json
-var version = "0.0.238";
+var version = "0.0.241";
 
 // src/sdk-version.ts
 var SDK_VERSION = version;

package/dist/index.js

@@ -57,7 +57,7 @@ function craftBinaryNotFoundMessage(triedPath) {
 `);
 }
 // package.json
-var version = "0.0.238";
+var version = "0.0.241";
 
 // src/sdk-version.ts
 var SDK_VERSION = version;

package/dist/ios/src/index.js

@@ -228,10 +228,18 @@ function serializeSimulatorSteps(steps) {
       if (!Number.isInteger(number(step.index)))
         throw new Error("field index must be an integer");
       arg = `${step.index} ${step.text}`;
+    } else if ("position" in step) {
+      if (number(step.position) > 1)
+        throw new Error("Slider position must be between 0 and 1");
+      arg = `${token(step.id)} ${step.position}`;
     } else if ("id" in step)
       arg = `${token(step.id)} ${step.text}`;
     else if ("text" in step) {
       arg = step.text;
+      if (step.command === "longpressid")
+        token(arg);
+      if (step.command === "expectapp" && !/^[A-Za-z0-9-]+(?:\.[A-Za-z0-9-]+)+$/.test(arg))
+        throw new Error("Expected an application bundle identifier");
       if ("seconds" in step && step.seconds !== undefined) {
         if (arg.includes("|"))
           throw new Error("A timed expectation cannot contain |");

package/dist/ios/src/testing.d.ts

@@ -66,15 +66,27 @@ export type SimulatorStep = {
     index: number;
     text: string;
 } | {
-    command: 'typeid' | 'labelid';
+    command: 'typeid' | 'labelid' | 'valueid';
     id: string;
     text: string;
+}
+/** Adjust an actual native UISlider by identifier, using its normalized range. */
+ | {
+    command: 'sliderid';
+    id: string;
+    position: number;
+}
+/** Assert a handoff reached the foreground application without launching it. */
+ | {
+    command: 'expectapp';
+    text: string;
+    seconds?: number;
 } | {
     command: 'expect' | 'expectexact' | 'expectid' | 'systemexpect';
     text: string;
     seconds?: number;
 } | {
-    command: 'tap' | 'tapif' | 'tapid' | 'tapexact' | 'type' | 'absent' | 'absentid' | 'selected' | 'tab' | 'scrollto' | 'dismiss' | 'log' | 'systemtap' | 'systemabsent';
+    command: 'tap' | 'tapif' | 'tapid' | 'longpressid' | 'tapexact' | 'type' | 'absent' | 'absentid' | 'selected' | 'tab' | 'scrollto' | 'dismiss' | 'log' | 'systemtap' | 'systemabsent';
     text: string;
 } | {
     command: 'shot' | 'tree' | 'audit' | 'exec' | 'systemtree';