expo-arcgis 0.2.6 → 0.3.1

package/android/src/main/java/expo/modules/arcgis/ExpoArcgisExtrasModule.kt

@@ -47,6 +47,9 @@ class ExpoArcgisExtrasModule : Module() {
       AsyncFunction("addFeatureWithSubtype") Coroutine { ref: FeatureLayerRef, subtypeName: String, attributes: Map<String, Any?>?, geometry: Map<String, Any?>?, apply: Boolean? ->
         ref.addFeatureWithSubtype(subtypeName, attributes, geometry, apply)
       }
+      AsyncFunction("contingentValues") Coroutine { ref: FeatureLayerRef, attributes: Map<String, Any?>, fieldName: String ->
+        ref.contingentValues(attributes, fieldName)
+      }
       AsyncFunction("getContingentValues") Coroutine { ref: FeatureLayerRef, objectId: Long, fieldName: String ->
         ref.getContingentValues(objectId, fieldName)
       }
@@ -93,11 +96,6 @@ class ExpoArcgisExtrasModule : Module() {
         .getOrThrow()
     }
 
-    // Tile-cache size estimation — quick estimate before committing to a download.
-    AsyncFunction("estimateTileCacheSize") Coroutine { tileServiceUrl: String, areaOfInterest: Map<String, Any?>, options: Map<String, Any?>? ->
-      estimateTileCacheSize(tileServiceUrl, areaOfInterest, options)
-    }
-
     // Turn-by-turn navigation — solve a route and track device locations against it.
     AsyncFunction("createRouteTracker") Coroutine { stops: List<Map<String, Any?>>, params: Map<String, Any?> ->
       createRouteTracker(appContext, stops, params)

package/android/src/main/java/expo/modules/arcgis/ExpoArcgisGeometryModule.kt

@@ -96,6 +96,11 @@ class ExpoArcgisGeometryModule : Module() {
       solveRoute(stops, params)
     }
 
+    // Service Area — compute reachable areas from facilities, exposed as the JS `serviceArea` namespace.
+    AsyncFunction("serviceAreaSolve") Coroutine { params: Map<String, Any?> ->
+      serviceAreaSolve(params)
+    }
+
     // Geoprocessing — run a geoprocessing service, exposed as the JS `geoprocessor` namespace.
     AsyncFunction("executeGeoprocessing") Coroutine { serviceUrl: String, inputs: Map<String, Any?> ->
       executeGeoprocessing(appContext, serviceUrl, inputs)
@@ -215,5 +220,8 @@ class ExpoArcgisGeometryModule : Module() {
     AsyncFunction("exportVectorTiles") Coroutine { vectorTileServiceUrl: String, areaOfInterest: Map<String, Any?>, downloadName: String ->
       exportVectorTiles(appContext, appContext.reactContext?.filesDir, vectorTileServiceUrl, areaOfInterest, downloadName)
     }
+    AsyncFunction("estimateTileCacheSize") Coroutine { tileServiceUrl: String, areaOfInterest: Map<String, Any?>, minScale: Double?, maxScale: Double? ->
+      estimateTileCacheSize(tileServiceUrl, areaOfInterest, minScale, maxScale)
+    }
   }
 }

package/android/src/main/java/expo/modules/arcgis/ExpoArcgisMapView.kt

@@ -15,6 +15,7 @@ import com.arcgismaps.location.SimulatedLocationDataSource
 import com.arcgismaps.location.SimulationParameters
 import com.arcgismaps.location.SystemLocationDataSource
 import java.time.Instant
+import com.arcgismaps.mapping.TimeExtent
 import com.arcgismaps.mapping.Viewpoint
 import com.arcgismaps.mapping.view.MapView
 import com.arcgismaps.mapping.view.ScreenCoordinate
@@ -151,6 +152,14 @@ class ExpoArcgisMapView(context: Context, appContext: AppContext) : ExpoView(con
       ?: com.arcgismaps.mapping.view.LatitudeLongitudeGrid().apply { isVisible = false }
   }
 
+  /** Filters time-aware layers to a time window from JS (null shows all time steps). */
+  fun setTimeExtent(config: Map<String, Any?>?) {
+    if (config == null) { mapView.setTimeExtent(null); return }
+    val startMs = (config["startTime"] as? Number)?.toLong() ?: return
+    val endMs = (config["endTime"] as? Number)?.toLong() ?: return
+    mapView.setTimeExtent(TimeExtent(Instant.ofEpochMilli(startMs), Instant.ofEpochMilli(endMs)))
+  }
+
   /** Enables/configures the device location display from JS (null disables it). */
   fun setLocationDisplay(config: Map<String, Any?>?) {
     val locationDisplay = mapView.locationDisplay

package/android/src/main/java/expo/modules/arcgis/ExpoArcgisModule.kt

@@ -40,6 +40,13 @@ class ExpoArcgisModule : Module() {
       AuthChallengeHandler.setCredentials(username, password, tokenExpirationMinutes)
     }
 
+    // Network-layer server-trust override — for on-prem ArcGIS Enterprise with self-signed certs.
+    // NEVER enable in production: disabling TLS validation exposes connections to MITM attacks.
+    Function("setAllowUntrustedHosts") { allow: Boolean ->
+      ArcGISEnvironment.authenticationManager.networkAuthenticationChallengeHandler =
+        if (allow) NetworkTrustHandler else null
+    }
+
     // Revokes any OAuth user credentials on the server, then clears all cached credentials.
     AsyncFunction("signOut") Coroutine { ->
       val store = ArcGISEnvironment.authenticationManager.arcGISCredentialStore
@@ -210,7 +217,8 @@ class ExpoArcgisModule : Module() {
       Constructor { props: Map<String, Any?> ->
         @Suppress("UNCHECKED_CAST")
         val source = props["source"] as? Map<String, Any?> ?: emptyMap()
-        RasterLayerRef(appContext, source).also { it.applyProps(props) }
+        val rasterFunctionJson = props["rasterFunction"] as? String
+        RasterLayerRef(appContext, source, rasterFunctionJson).also { it.applyProps(props) }
       }
       Function("applyProps") { ref: RasterLayerRef, changed: Map<String, Any?> ->
         ref.applyProps(changed)
@@ -225,6 +233,9 @@ class ExpoArcgisModule : Module() {
         ref.applyProps(changed)
       }
       AsyncFunction("getNodes") Coroutine { ref: KmlLayerRef -> ref.getNodes() }
+      Function("playTour") { ref: KmlLayerRef -> ref.playTour() }
+      Function("pauseTour") { ref: KmlLayerRef -> ref.pauseTour() }
+      Function("resetTour") { ref: KmlLayerRef -> ref.resetTour() }
     }
 
     // WFS (Web Feature Service) + OGC API - Features — feature layers over async-populating tables.
@@ -385,6 +396,10 @@ class ExpoArcgisModule : Module() {
         view.setGrid(grid)
       }
 
+      Prop("timeExtent") { view: ExpoArcgisMapView, value: Map<String, Any?>? ->
+        view.setTimeExtent(value)
+      }
+
       AsyncFunction("identify") { view: ExpoArcgisMapView, screenPoint: Map<String, Any?>, options: Map<String, Any?>?, promise: Promise ->
         view.identify(screenPoint, options, promise)
       }
@@ -451,6 +466,10 @@ class ExpoArcgisModule : Module() {
         view.setSunTime(value)
       }
 
+      Prop("timeExtent") { view: ExpoArcgisSceneView, value: Map<String, Any?>? ->
+        view.setTimeExtent(value)
+      }
+
       AsyncFunction("retryLoad") { view: ExpoArcgisSceneView, promise: Promise ->
         view.retryLoad(promise)
       }

package/android/src/main/java/expo/modules/arcgis/ExpoArcgisSceneView.kt

@@ -7,7 +7,9 @@ import androidx.lifecycle.findViewTreeLifecycleOwner
 import com.arcgismaps.geometry.GeometryEngine
 import com.arcgismaps.geometry.Point
 import com.arcgismaps.geometry.SpatialReference
+import com.arcgismaps.mapping.TimeExtent
 import com.arcgismaps.mapping.view.AtmosphereEffect
+import java.time.Instant
 import com.arcgismaps.mapping.view.Camera
 import com.arcgismaps.mapping.view.GlobeCameraController
 import com.arcgismaps.mapping.view.LightingMode
@@ -230,6 +232,14 @@ class ExpoArcgisSceneView(context: Context, appContext: AppContext) : ExpoView(c
     sceneView.sunTime = java.time.Instant.ofEpochMilli(ms.toLong())
   }
 
+  /** Filters time-aware layers to a time window from JS (null shows all time steps). */
+  fun setTimeExtent(config: Map<String, Any?>?) {
+    if (config == null) { sceneView.setTimeExtent(null); return }
+    val startMs = (config["startTime"] as? Number)?.toLong() ?: return
+    val endMs = (config["endTime"] as? Number)?.toLong() ?: return
+    sceneView.setTimeExtent(TimeExtent(Instant.ofEpochMilli(startMs), Instant.ofEpochMilli(endMs)))
+  }
+
   override fun onAttachedToWindow() {
     super.onAttachedToWindow()
     val lifecycle = findViewTreeLifecycleOwner()?.lifecycle

package/android/src/main/java/expo/modules/arcgis/GraphicsOverlayRef.kt

@@ -18,8 +18,10 @@ import com.arcgismaps.mapping.symbology.SimpleLineSymbol
 import com.arcgismaps.mapping.symbology.SimpleLineSymbolStyle
 import com.arcgismaps.mapping.symbology.DistanceCompositeSceneSymbol
 import com.arcgismaps.mapping.symbology.DistanceSymbolRange
+import com.arcgismaps.mapping.symbology.ModelSceneSymbol
 import com.arcgismaps.mapping.symbology.SimpleMarkerSceneSymbol
 import com.arcgismaps.mapping.symbology.SimpleMarkerSceneSymbolStyle
+import com.arcgismaps.mapping.symbology.SymbolSizeUnits
 import com.arcgismaps.mapping.symbology.MultilayerPointSymbol
 import com.arcgismaps.mapping.symbology.MultilayerPolygonSymbol
 import com.arcgismaps.mapping.symbology.MultilayerPolylineSymbol
@@ -346,6 +348,21 @@ private fun buildSymbol(s: Map<*, *>): Symbol? = when (s["type"]) {
     num(s["depth"], 100.0),
     sceneSymbolAnchor(s["anchor"]),
   )
+  "model-scene" -> (s["url"] as? String)?.let { rawUri ->
+    // ModelSceneSymbol(uri, scale) — 3D glTF/model marker. ArcGIS on Android resolves a LOCAL model
+    // by filesystem path, so an expo `file://` URI must be unwrapped (iOS `URL(string:)` accepts the
+    // scheme, Android silently fails to load it). Set heading/pitch/roll (Float) + symbolSizeUnits;
+    // the symbol is Loadable.
+    val uri = if (rawUri.startsWith("file://")) android.net.Uri.parse(rawUri).path ?: rawUri else rawUri
+    val scale = (s["scale"] as? Number)?.toFloat() ?: 1f
+    ModelSceneSymbol(uri, scale).apply {
+      symbolSizeUnits = if (s["sizeUnits"] == "meters") SymbolSizeUnits.Meters else SymbolSizeUnits.Dips
+      heading = (s["heading"] as? Number)?.toFloat() ?: 0f
+      pitch   = (s["pitch"]   as? Number)?.toFloat() ?: 0f
+      roll    = (s["roll"]    as? Number)?.toFloat() ?: 0f
+      anchorPosition = sceneSymbolAnchor(s["anchor"])
+    }
+  }
   "picture-marker" -> (s["url"] as? String)?.let { url ->
     PictureMarkerSymbol(url).apply {
       (s["width"] as? Number)?.toFloat()?.let { width = it }

package/android/src/main/java/expo/modules/arcgis/LayerRef.kt

@@ -57,9 +57,12 @@ import com.arcgismaps.mapping.layers.WmtsLayer
 import com.arcgismaps.mapping.kml.KmlContainer
 import com.arcgismaps.mapping.kml.KmlDataset
 import com.arcgismaps.mapping.kml.KmlNode
+import com.arcgismaps.mapping.kml.KmlTour
+import com.arcgismaps.mapping.kml.KmlTourController
 import com.arcgismaps.mapping.view.Graphic
 import com.arcgismaps.raster.ImageServiceRaster
 import com.arcgismaps.raster.Raster
+import com.arcgismaps.raster.RasterFunction
 import expo.modules.kotlin.AppContext
 import expo.modules.kotlin.sharedobjects.SharedObject
 
@@ -290,6 +293,38 @@ class FeatureLayerRef(appContext: AppContext, private val table: FeatureTable) :
     persistEdits()
   }
 
+  /**
+   * Returns the valid coded values for [fieldName] given a feature's current [attributes].
+   * Use this to drive editing-form dropdowns: pass the feature's current attribute state and the
+   * name of the field being edited; returns `[{ name, code }]` for coded values that satisfy all
+   * contingent-value constraints defined on the table.
+   *
+   * Loads the table and its [ContingentValuesDefinition], builds a temporary [ArcGISFeature] from
+   * [attributes] (via `FeatureTable.createFeature(attributes, null)` + `applyAttributes`), then
+   * calls `getContingentValuesOrNull(feature, fieldName)`.
+   * Non-coded contingent values ([ContingentRangeValue], null, any) are omitted — only
+   * [ContingentCodedValue] entries are returned.
+   *
+   * Requires an [ArcGISFeatureTable]; throws for shapefiles and WFS tables.
+   * Returns an empty list when no constraints are defined for [fieldName].
+   */
+  suspend fun contingentValues(attributes: Map<String, Any?>, fieldName: String): List<Map<String, Any?>> {
+    table.load().getOrThrow()
+    val arcGISTable = table as? ArcGISFeatureTable
+      ?: throw IllegalStateException("contingentValues requires an ArcGIS feature table (not a shapefile or WFS table)")
+    arcGISTable.contingentValuesDefinition.load().getOrThrow()
+    val feature = table.createFeature(attributes, null) as ArcGISFeature
+    val result = arcGISTable.getContingentValuesOrNull(feature, fieldName)
+      ?: return emptyList()
+    return result.byFieldGroup.flatMap { (_, values) ->
+      values.mapNotNull { cv ->
+        if (cv !is ContingentCodedValue) return@mapNotNull null
+        val coded = cv.codedValue
+        mapOf("name" to coded.name, "code" to coded.code)
+      }
+    }
+  }
+
   /**
    * Returns the valid contingent values for [fieldName] on the feature with [objectId].
    * Requires the table to be an [ArcGISFeatureTable]; throws otherwise. Returns an empty list when
@@ -537,21 +572,41 @@ class WmtsLayerRef(appContext: AppContext, url: String, layerId: String) : Layer
 }
 
 /** Operational raster layer from a remote image service or a local raster file. */
-class RasterLayerRef(appContext: AppContext, source: Map<String, Any?>) : LayerRef(appContext) {
-  override val layer: RasterLayer = RasterLayer(rasterFromSource(source))
+class RasterLayerRef(
+  appContext: AppContext,
+  source: Map<String, Any?>,
+  rasterFunctionJson: String? = null,
+) : LayerRef(appContext) {
+  override val layer: RasterLayer = RasterLayer(rasterFromSource(source, rasterFunctionJson))
 
   override fun applyProps(changed: Map<String, Any?>) = applyCommonProps(changed)
 }
 
-/** Builds a [Raster] from a JS source dict: `{type:"imageService",url}` or `{type:"file",path}`. */
-private fun rasterFromSource(s: Map<String, Any?>): Raster =
-  if (s["type"] == "file") Raster.createWithPath(s["path"] as? String ?: "")
-  else ImageServiceRaster(s["url"] as? String ?: "")
+/**
+ * Builds a [Raster] from a JS source dict: `{type:"imageService",url}` or `{type:"file",path}`.
+ * When [rasterFunctionJson] is supplied, wraps the base raster in a [RasterFunction] pipeline:
+ * `RasterFunction.fromJsonOrNull` → wire source raster as first raster argument →
+ * `Raster.createWithRasterFunction`.  Falls back to the plain source raster if parsing fails
+ * or no raster argument is found.
+ */
+private fun rasterFromSource(s: Map<String, Any?>, rasterFunctionJson: String? = null): Raster {
+  val base: Raster =
+    if (s["type"] == "file") Raster.createWithPath(s["path"] as? String ?: "")
+    else ImageServiceRaster(s["url"] as? String ?: "")
+  if (rasterFunctionJson == null) return base
+  val fn = RasterFunction.fromJsonOrNull(rasterFunctionJson) ?: return base
+  val args = fn.arguments ?: return base
+  val firstName = args.rasterNames.firstOrNull() ?: return base
+  args.setRaster(firstName, base)
+  return Raster.createWithRasterFunction(fn)
+}
 
 /** Operational KML layer from a remote .kml/.kmz URL or local file. */
 class KmlLayerRef(appContext: AppContext, url: String) : LayerRef(appContext) {
   private val dataset = KmlDataset(url)
   override val layer: KmlLayer = KmlLayer(dataset)
+  /** Lazily-created controller; held for the lifetime of the ref so play/pause/reset are idempotent. */
+  private var tourController: KmlTourController? = null
 
   override fun applyProps(changed: Map<String, Any?>) = applyCommonProps(changed)
 
@@ -560,6 +615,21 @@ class KmlLayerRef(appContext: AppContext, url: String) : LayerRef(appContext) {
     dataset.load().getOrThrow()
     return dataset.rootNodes.map { serializeKmlNode(it) }
   }
+
+  /** Returns the existing controller, or creates one attached to the first [KmlTour] in the node tree.
+   *  Returns `null` if the dataset has no tour. */
+  private fun controller(): KmlTourController? {
+    tourController?.let { return it }
+    val tour = findFirstTour(dataset.rootNodes) ?: return null
+    return KmlTourController().also { it.tour = tour; tourController = it }
+  }
+
+  /** Starts or resumes playback of the first KML tour. No-ops if no tour exists. */
+  fun playTour() { controller()?.play() }
+  /** Pauses playback of the first KML tour. No-ops if no tour exists. */
+  fun pauseTour() { controller()?.pause() }
+  /** Resets playback of the first KML tour to the beginning. No-ops if no tour exists. */
+  fun resetTour() { controller()?.reset() }
 }
 
 /** Serializes a KML node, recursing into container nodes (documents / folders). */
@@ -575,6 +645,15 @@ private fun serializeKmlNode(node: KmlNode): Map<String, Any?> {
   return dict
 }
 
+/** Depth-first search for the first [KmlTour] in a list of KML nodes. */
+private fun findFirstTour(nodes: List<KmlNode>): KmlTour? {
+  for (node in nodes) {
+    if (node is KmlTour) return node
+    if (node is KmlContainer) findFirstTour(node.childNodes)?.let { return it }
+  }
+  return null
+}
+
 /** Operational WFS layer — a [FeatureLayer] over a [WfsFeatureTable] (Web Feature Service). */
 class WfsLayerRef(appContext: AppContext, url: String, tableName: String) : LayerRef(appContext) {
   override val layer: FeatureLayer = FeatureLayer.createWithFeatureTable(

package/android/src/main/java/expo/modules/arcgis/NetworkTrustHandler.kt

@@ -0,0 +1,26 @@
+package expo.modules.arcgis
+
+import com.arcgismaps.httpcore.authentication.NetworkAuthenticationChallenge
+import com.arcgismaps.httpcore.authentication.NetworkAuthenticationChallengeHandler
+import com.arcgismaps.httpcore.authentication.NetworkAuthenticationChallengeResponse
+import com.arcgismaps.httpcore.authentication.NetworkAuthenticationType
+import com.arcgismaps.httpcore.authentication.ServerTrust
+
+/**
+ * Network-layer trust handler that accepts every server-trust challenge unconditionally.
+ * Only install this for development or on-prem ArcGIS Enterprise with self-signed certificates —
+ * it disables TLS certificate validation, which makes the connection vulnerable to
+ * man-in-the-middle attacks. Never enable in production.
+ */
+object NetworkTrustHandler : NetworkAuthenticationChallengeHandler {
+  override suspend fun handleNetworkAuthenticationChallenge(
+    challenge: NetworkAuthenticationChallenge,
+  ): NetworkAuthenticationChallengeResponse {
+    if (challenge.networkAuthenticationType is NetworkAuthenticationType.ServerTrust) {
+      return NetworkAuthenticationChallengeResponse.ContinueWithCredential(ServerTrust)
+    }
+    // Other challenge kinds (basic / digest / NTLM / client-cert) aren't ours to satisfy — continue
+    // without a credential (mirrors Swift's `.continueWithoutCredential`) instead of cancelling them.
+    return NetworkAuthenticationChallengeResponse.ContinueAndFail
+  }
+}

package/android/src/main/java/expo/modules/arcgis/OfflineFunctions.kt

@@ -209,20 +209,28 @@ internal suspend fun exportTileCache(
 
 /**
  * Estimates the on-disk file size and tile count for an [exportTileCache] download WITHOUT
- * downloading. Runs the [EstimateTileCacheSizeJob] to completion and returns `{fileSize, tileCount}`.
+ * downloading. Passes [minScale]/[maxScale] (0.0 = no limit) to
+ * [ExportTileCacheTask.createDefaultExportTileCacheParameters] to narrow the estimation to the
+ * same scale window that [exportTileCache] would use. Runs the [EstimateTileCacheSizeJob] to
+ * completion and returns `{fileSizeBytes, tileCount}`.
  */
 internal suspend fun estimateTileCacheSize(
   tileServiceUrl: String,
   areaOfInterest: Map<String, Any?>,
-  @Suppress("UNUSED_PARAMETER") options: Map<String, Any?>?,
+  minScale: Double?,
+  maxScale: Double?,
 ): Map<String, Any?> {
   val area = geometryFromDict(areaOfInterest) ?: throw IllegalArgumentException("Invalid area of interest")
   val task = ExportTileCacheTask(tileServiceUrl)
-  val parameters = task.createDefaultExportTileCacheParameters(area, 0.0, 0.0).getOrThrow()
+  val parameters = task.createDefaultExportTileCacheParameters(
+    area,
+    minScale ?: 0.0,
+    maxScale ?: 0.0,
+  ).getOrThrow()
   val job = task.createEstimateTileCacheSizeJob(parameters)
   job.start()
   val estimate = job.result().getOrThrow()
-  return mapOf("fileSize" to estimate.fileSize, "tileCount" to estimate.tileCount)
+  return mapOf("fileSizeBytes" to estimate.fileSize.toDouble(), "tileCount" to estimate.tileCount.toDouble())
 }
 
 internal suspend fun exportVectorTiles(

package/android/src/main/java/expo/modules/arcgis/ServiceAreaFunctions.kt

@@ -0,0 +1,61 @@
+package expo.modules.arcgis
+
+import com.arcgismaps.tasks.networkanalysis.ServiceAreaFacility
+import com.arcgismaps.tasks.networkanalysis.ServiceAreaPolygon
+import com.arcgismaps.tasks.networkanalysis.ServiceAreaResult
+import com.arcgismaps.tasks.networkanalysis.ServiceAreaTask
+import com.arcgismaps.geometry.Point
+import java.util.concurrent.ConcurrentHashMap
+
+/**
+ * Free functions backing the JS `serviceArea` namespace — computing reachable areas from
+ * facilities via a [ServiceAreaTask]. Registered as an `AsyncFunction` in
+ * `ExpoArcgisGeometryModule`.
+ */
+
+/** Caches one [ServiceAreaTask] per service URL so repeated solves don't reload service metadata. */
+private val serviceAreaTasks = ConcurrentHashMap<String, ServiceAreaTask>()
+
+private fun serviceAreaTask(url: String): ServiceAreaTask =
+  serviceAreaTasks.getOrPut(url) { ServiceAreaTask(url) }
+
+internal suspend fun serviceAreaSolve(params: Map<String, Any?>): Map<String, Any?> {
+  val serviceUrl = params["serviceUrl"] as? String
+    ?: error("serviceUrl is required")
+  val task = serviceAreaTask(serviceUrl)
+  // createDefaultParameters() loads the task so the service metadata is populated afterwards.
+  val parameters = task.createDefaultParameters().getOrThrow()
+  val facilitiesDicts = params["facilities"] as? List<*> ?: emptyList<Any?>()
+  parameters.setFacilities(buildFacilities(facilitiesDicts))
+  (params["cutoffs"] as? List<*>)?.let { rawCutoffs ->
+    val cutoffs = rawCutoffs.mapNotNull { (it as? Number)?.toDouble() }
+    if (cutoffs.isNotEmpty()) {
+      // ServiceAreaParameters.defaultImpedanceCutoffs is a mutable live list (no setter / add API).
+      parameters.defaultImpedanceCutoffs.clear()
+      parameters.defaultImpedanceCutoffs.addAll(cutoffs)
+    }
+  }
+  val result = task.solveServiceArea(parameters).getOrThrow()
+  return serializeServiceAreaResult(result)
+}
+
+private fun buildFacilities(dicts: List<*>): List<ServiceAreaFacility> =
+  dicts.filterIsInstance<Map<*, *>>().mapNotNull { dict ->
+    (geometryFromDict(dict) as? Point)?.let { ServiceAreaFacility(it) }
+  }
+
+private fun serializeServiceAreaResult(result: ServiceAreaResult): Map<String, Any?> {
+  val polygons = mutableListOf<Map<String, Any?>>()
+  for ((index, _) in result.facilities.withIndex()) {
+    for (polygon in result.getResultPolygons(index)) {
+      polygons.add(serializeServiceAreaPolygon(polygon))
+    }
+  }
+  return mapOf("polygons" to polygons)
+}
+
+private fun serializeServiceAreaPolygon(polygon: ServiceAreaPolygon): Map<String, Any?> = mapOf(
+  "geometry" to dictFromGeometry(polygon.geometry),
+  "fromCutoff" to polygon.fromImpedanceCutoff,
+  "toCutoff" to polygon.toImpedanceCutoff,
+)

package/build/DynamicEntityLayer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DynamicEntityLayer.d.ts","sourceRoot":"","sources":["../src/DynamicEntityLayer.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,gBAAgB,EAChB,mBAAmB,EACnB,wBAAwB,EAEzB,MAAM,oBAAoB,CAAC;AAQ5B;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB;;;;;mBAwD42qC,CAAC;gBAAkB,CAAC;;;;;;;4DAD95qC,CAAC"}
+{"version":3,"file":"DynamicEntityLayer.d.ts","sourceRoot":"","sources":["../src/DynamicEntityLayer.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,gBAAgB,EAChB,mBAAmB,EACnB,wBAAwB,EAEzB,MAAM,oBAAoB,CAAC;AAQ5B;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB;;;;;mBAwDoguC,CAAC;gBAAkB,CAAC;;;;;;;4DADtjuC,CAAC"}

package/build/ExpoArcgis.types.d.ts

@@ -131,6 +131,15 @@ export type MapViewProps = {
     viewpoint?: Viewpoint;
     /** Device-location display. When set, the view shows the device's GPS location. */
     locationDisplay?: LocationDisplay;
+    /**
+     * Filters time-aware layers to this time window. Both values are epoch milliseconds (UTC).
+     * Pass `null` / omit to show all time steps (no filter). Maps to `GeoView.timeExtent` /
+     * `MapView(timeExtent:)` on both platforms.
+     */
+    timeExtent?: {
+        startTime: number;
+        endTime: number;
+    } | null;
     /** Called once the map has finished loading successfully. */
     onMapLoaded?: (event: {
         nativeEvent: MapLoadedEventPayload;
@@ -640,6 +649,26 @@ export type FeatureLayerHandle = {
      * feature layer. The same handle is returned on repeat calls.
      */
     getServiceGeodatabase(): Promise<ServiceGeodatabaseHandle>;
+    /**
+     * Returns the valid coded values for `fieldName` given the feature's current `attributes`.
+     * Use this to drive editing-form dropdowns: pass the feature's current attribute state and the
+     * name of the field being edited; returns `[{ name, code }]` for coded values that satisfy all
+     * contingent-value constraints defined on the table.
+     *
+     * The table and its `ContingentValuesDefinition` are loaded automatically. A temporary feature
+     * is built from `attributes` (no server round-trip for the feature itself); only `ArcGISFeature`
+     * tables are supported — rejects for shapefiles and WFS tables.
+     *
+     * @example
+     * ```ts
+     * const options = await layer.current.contingentValues({ habitat: 'oak' }, 'species');
+     * // options → [{ name: 'Red Oak', code: 1 }, { name: 'White Oak', code: 2 }]
+     * ```
+     */
+    contingentValues(attributes: Record<string, unknown>, fieldName: string): Promise<{
+        name: string;
+        code: unknown;
+    }[]>;
     /**
      * Returns the valid contingent values for `fieldName` on the feature with `objectId`, given
      * the feature's current attribute state. Contingent values constrain which attribute values
@@ -811,6 +840,14 @@ export type RasterSource = {
 /** Props for a `<RasterLayer>` — mirror the native `RasterLayer` (image service or local raster). */
 export type RasterLayerProps = LayerProps & {
     source: RasterSource;
+    /**
+     * On-the-fly raster function chain to apply to the layer's raster, serialised as JSON
+     * (e.g. a hillshade / colormap / NDVI chain).  When set, the SDK builds a
+     * `RasterFunction.fromJSON` → `Raster(rasterFunction:)` pipeline with the source raster
+     * wired in as the first raster argument.  Construction-time only — changing this prop
+     * requires remounting the layer.
+     */
+    rasterFunction?: string;
 };
 /** Props for a `<KmlLayer>` — mirror `KMLLayer` (remote `.kml`/`.kmz` URL or local file). */
 export type KmlLayerProps = LayerProps & {
@@ -1054,10 +1091,23 @@ export type KmlNodeInfo = {
     /** Child nodes, present for container nodes (documents / folders). */
     children?: KmlNodeInfo[];
 };
-/** Imperative handle exposed by `<KmlLayer>` via `ref`. */
+/**
+ * Imperative handle exposed by `<KmlLayer>` via `ref`.
+ *
+ * **Tour playback (`playTour` / `pauseTour` / `resetTour`) is iOS-only.** On Android the tour
+ * controller cannot drive the camera of the view-based scene view (an ArcGIS Maps SDK limitation —
+ * automatic tour playback exists only on the Compose `SceneView`, and the controller exposes no
+ * camera/viewpoint to drive it manually). The methods are present on Android but no-op visually.
+ */
 export type KmlLayerHandle = {
     /** Loads the KML and returns its node tree (recursing into container nodes). */
     getNodes(): Promise<KmlNodeInfo[]>;
+    /** Starts or resumes playback of the first KML tour found in the layer. No-ops if no tour exists. iOS only (see above). */
+    playTour(): void;
+    /** Pauses playback of the first KML tour found in the layer. No-ops if no tour exists. iOS only (see above). */
+    pauseTour(): void;
+    /** Resets playback of the first KML tour found in the layer to the beginning. No-ops if no tour exists. iOS only (see above). */
+    resetTour(): void;
 };
 /**
  * A geometry value. The `type` discriminator mirrors the ArcGIS web API
@@ -1343,6 +1393,32 @@ export type RouteTrackerHandle = {
     trackLocation(location: TrackedLocation): Promise<RouteTrackingStatus>;
     switchToNextDestination(): Promise<void>;
 };
+/** Parameters for `serviceArea.solve`. */
+export type ServiceAreaSolveParams = {
+    /** URL of the network analysis service (e.g. the ArcGIS World Service Areas service). */
+    serviceUrl: string;
+    /** Facility locations to compute service areas from. */
+    facilities: PointGeometry[];
+    /**
+     * Impedance cutoff values (e.g. travel-time minutes or distance) that define each polygon ring.
+     * When omitted the service's default cutoffs are used.
+     */
+    cutoffs?: number[];
+};
+/** One service-area polygon returned from `serviceArea.solve`. Mirrors the native `ServiceAreaPolygon`. */
+export type ServiceAreaPolygon = {
+    /** The polygon geometry of the reachable area. */
+    geometry: Geometry;
+    /** Lower impedance bound for this polygon ring. */
+    fromCutoff: number;
+    /** Upper impedance bound for this polygon ring. */
+    toCutoff: number;
+};
+/** Result of `serviceArea.solve`. */
+export type ServiceAreaResult = {
+    /** All result polygons across all facilities, ordered by facility then cutoff. */
+    polygons: ServiceAreaPolygon[];
+};
 /** Props for `<AnalysisOverlay>` — a container for visual analyses, hosted by a `<SceneView>`. */
 export type AnalysisOverlayProps = {
     /** Whether the overlay's analyses are drawn. Defaults to `true`. */
@@ -1687,7 +1763,7 @@ export type OfflineTileResult = {
 /** Result of `offline.estimateTileCacheSize` — an estimate of the download footprint. */
 export type TileCacheSizeEstimate = {
     /** Estimated on-disk size of the tile cache in bytes. */
-    fileSize: number;
+    fileSizeBytes: number;
     /** Estimated number of tiles in the tile cache. */
     tileCount: number;
 };
@@ -1818,6 +1894,27 @@ export type SimpleMarkerSceneSymbol = {
     /** Which part of the solid sits on the point. Defaults to `bottom`. */
     anchor?: 'center' | 'bottom' | 'top' | 'origin';
 };
+/**
+ * A 3D model symbol (glTF / `.glb`) for point graphics in a `<SceneView>`. Mirrors the native
+ * `ModelSceneSymbol` (loads the model at `url` at runtime — symbol is `Loadable`).
+ */
+export type ModelSceneSymbol = {
+    type: 'model-scene';
+    /** URL of the glTF / `.glb` model file. Required. */
+    url: string;
+    /** Uniform scale factor applied to the model. Defaults to `1`. */
+    scale?: number;
+    /** Whether the model dimensions are expressed in device-independent pixels or geographic meters. Defaults to `dips`. */
+    sizeUnits?: 'dips' | 'meters';
+    /** Rotation around the vertical (z) axis, in degrees. Defaults to `0`. */
+    heading?: number;
+    /** Rotation around the lateral (x) axis, in degrees. Defaults to `0`. */
+    pitch?: number;
+    /** Rotation around the longitudinal (y) axis, in degrees. Defaults to `0`. */
+    roll?: number;
+    /** Which part of the model sits on the point. Defaults to `bottom`. */
+    anchor?: 'center' | 'bottom' | 'top' | 'origin';
+};
 /** A marker drawn from an image at a URL. Mirrors `PictureMarkerSymbol`. */
 export type PictureMarkerSymbol = {
     type: 'picture-marker';
@@ -1982,7 +2079,7 @@ export type MultilayerPointSymbolType = {
     symbolLayers: SymbolLayerSpec[];
 };
 /** Any symbol usable by a `<Graphic>`. Mirrors the native `Symbol` hierarchy. */
-export type Symbol = SimpleMarkerSymbol | SimpleLineSymbol | SimpleFillSymbol | TextSymbol | SimpleMarkerSceneSymbol | PictureMarkerSymbol | PictureFillSymbol | DistanceCompositeSceneSymbol | CompositeSymbolType | MultilayerPointSymbolType;
+export type Symbol = SimpleMarkerSymbol | SimpleLineSymbol | SimpleFillSymbol | TextSymbol | SimpleMarkerSceneSymbol | ModelSceneSymbol | PictureMarkerSymbol | PictureFillSymbol | DistanceCompositeSceneSymbol | CompositeSymbolType | MultilayerPointSymbolType;
 /** One stop in a `SizeVisualVariable` stops array. */
 export type SizeStop = {
     value: number;
@@ -2228,6 +2325,15 @@ export type SceneViewProps = {
     atmosphereEffect?: AtmosphereEffect;
     /** Sun position, as epoch milliseconds (affects shadow direction). */
     sunTime?: number;
+    /**
+     * Filters time-aware layers to this time window. Both values are epoch milliseconds (UTC).
+     * Pass `null` / omit to show all time steps (no filter). Maps to `GeoView.timeExtent` /
+     * `SceneView(timeExtent:)` on both platforms.
+     */
+    timeExtent?: {
+        startTime: number;
+        endTime: number;
+    } | null;
     /** Called once the scene has finished loading successfully. */
     onSceneLoaded?: (event: {
         nativeEvent: MapLoadedEventPayload;