expo-arcgis 0.1.2 → 0.1.4

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

@@ -1,6 +1,8 @@
 package expo.modules.arcgis
 
 import com.arcgismaps.analysis.interactive.Analysis
+import com.arcgismaps.analysis.interactive.ExploratoryGeoElementLineOfSight
+import com.arcgismaps.analysis.interactive.ExploratoryGeoElementViewshed
 import com.arcgismaps.analysis.interactive.ExploratoryLineOfSightTargetVisibility
 import com.arcgismaps.analysis.interactive.ExploratoryLocationDistanceMeasurement
 import com.arcgismaps.analysis.interactive.ExploratoryLocationLineOfSight
@@ -75,6 +77,42 @@ class ViewshedRef(appContext: AppContext, props: Map<String, Any?>) : AnalysisRe
   }
 }
 
+/**
+ * SharedObject wrapping an [ExploratoryGeoElementViewshed] — a viewshed whose observer tracks a
+ * [GraphicRef]'s native [Graphic] (a [GeoElement]) as it moves.
+ */
+class GeoElementViewshedRef(appContext: AppContext, graphic: GraphicRef, props: Map<String, Any?>) : AnalysisRef(appContext) {
+  private val viewshed = ExploratoryGeoElementViewshed(
+    graphic.graphic,
+    numOr(props["horizontalAngle"], 45.0),
+    numOr(props["verticalAngle"], 45.0),
+    numOr(props["headingOffset"], 0.0),
+    numOr(props["pitchOffset"], 0.0),
+    (props["minDistance"] as? Number)?.toDouble(),
+    (props["maxDistance"] as? Number)?.toDouble(),
+  )
+
+  override val analysis: Analysis get() = viewshed
+
+  init {
+    applyProps(props)
+  }
+
+  fun applyProps(changed: Map<String, Any?>) {
+    changed.forEach { (key, value) ->
+      when (key) {
+        "headingOffset" -> (value as? Number)?.toDouble()?.let { viewshed.headingOffset = it }
+        "pitchOffset" -> (value as? Number)?.toDouble()?.let { viewshed.pitchOffset = it }
+        "horizontalAngle" -> (value as? Number)?.toDouble()?.let { viewshed.horizontalAngle = it }
+        "verticalAngle" -> (value as? Number)?.toDouble()?.let { viewshed.verticalAngle = it }
+        "minDistance" -> viewshed.minDistance = (value as? Number)?.toDouble()
+        "maxDistance" -> viewshed.maxDistance = (value as? Number)?.toDouble()
+        "frustumOutlineVisible" -> (value as? Boolean)?.let { viewshed.frustumOutlineVisible = it }
+      }
+    }
+  }
+}
+
 /** SharedObject wrapping an [ExploratoryLocationLineOfSight] — streams target visibility to JS. */
 class LineOfSightRef(appContext: AppContext, props: Map<String, Any?>) : AnalysisRef(appContext) {
   private val lineOfSight = ExploratoryLocationLineOfSight(
@@ -151,6 +189,34 @@ class DistanceMeasurementRef(appContext: AppContext, props: Map<String, Any?>) :
   }
 }
 
+/**
+ * SharedObject wrapping an [ExploratoryGeoElementLineOfSight] — a line of sight whose observer
+ * and target both track a [GraphicRef]'s native [Graphic] (a [GeoElement]) as it moves.
+ * Streams the target's visibility back to JS via `onTargetVisibilityChange`.
+ */
+class GeoElementLineOfSightRef(appContext: AppContext, observer: GraphicRef, target: GraphicRef) : AnalysisRef(appContext) {
+  private val lineOfSight = ExploratoryGeoElementLineOfSight(
+    observer.graphic,
+    target.graphic,
+  )
+  private val scope = CoroutineScope(Dispatchers.Main + SupervisorJob())
+
+  override val analysis: Analysis get() = lineOfSight
+
+  init {
+    scope.launch {
+      lineOfSight.targetVisibility.collect { visibility ->
+        emit("onTargetVisibilityChange", mapOf("visibility" to visibilityString(visibility)))
+      }
+    }
+  }
+
+  override fun deallocate() {
+    scope.cancel()
+    super.deallocate()
+  }
+}
+
 /** Decodes a JS point dict into a [Point] (returns null if the value is not a point geometry). */
 internal fun analysisPoint(value: Any?): Point? =
   (value as? Map<*, *>)?.let { geometryFromDict(it) } as? Point

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

@@ -22,11 +22,17 @@ import kotlinx.coroutines.launch
 object AuthChallengeHandler : ArcGISAuthenticationChallengeHandler {
   private var username: String? = null
   private var password: String? = null
+  private var tokenExpirationMinutes: Int? = null
 
-  /** Stores (or clears, when null) the login the handler uses to mint token credentials on demand. */
-  fun setCredentials(username: String?, password: String?) {
+  /**
+   * Stores (or clears, when null) the login the handler uses to mint token credentials on demand.
+   * [tokenExpirationMinutes] is forwarded to [TokenCredential.createWithChallenge]; pass null to
+   * use the server's default expiry.
+   */
+  fun setCredentials(username: String?, password: String?, tokenExpirationMinutes: Int? = null) {
     this.username = username
     this.password = password
+    this.tokenExpirationMinutes = tokenExpirationMinutes
   }
 
   override suspend fun handleArcGISAuthenticationChallenge(
@@ -34,7 +40,7 @@ object AuthChallengeHandler : ArcGISAuthenticationChallengeHandler {
   ): ArcGISAuthenticationChallengeResponse {
     val user = username ?: return ArcGISAuthenticationChallengeResponse.ContinueAndFail
     val pass = password ?: return ArcGISAuthenticationChallengeResponse.ContinueAndFail
-    return TokenCredential.create(challenge.requestUrl, user, pass)
+    return TokenCredential.createWithChallenge(challenge, user, pass, tokenExpirationMinutes)
       .map { ArcGISAuthenticationChallengeResponse.ContinueWithCredential(it) }
       .getOrElse { ArcGISAuthenticationChallengeResponse.ContinueAndFail }
   }

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

@@ -39,6 +39,18 @@ class DynamicEntityLayerRef(appContext: AppContext, props: Map<String, Any?>) :
         emit("onConnectionStatusChange", mapOf("status" to connectionStatusString(status)))
       }
     }
+    // Emit entity-received events (new/updated observation arrived for an entity).
+    scope.launch {
+      dataSource.dynamicEntityReceivedEvent.collect { info ->
+        emit("onDynamicEntityChange", dynamicEntityPayload("received", info.dynamicEntity))
+      }
+    }
+    // Emit entity-purged events (entity evicted by purge rules).
+    scope.launch {
+      dataSource.dynamicEntityPurgedEvent.collect { info ->
+        emit("onDynamicEntityChange", dynamicEntityPayload("purged", info.dynamicEntity))
+      }
+    }
   }
 
   /** Pushes an observation into a custom data source (no-op for a stream service). */
@@ -48,6 +60,24 @@ class DynamicEntityLayerRef(appContext: AppContext, props: Map<String, Any?>) :
     flow.tryEmit(CustomDynamicEntityDataSource.FeedEvent.NewObservation(geom, attributes))
   }
 
+  /**
+   * Returns the observation history for the entity with the given track id, newest first,
+   * capped at [max] entries (default 100). Each observation carries its own `attributes` and
+   * `geometry` snapshot at the time it was received.
+   */
+  suspend fun queryObservations(entityId: String, max: Int = 100): List<Map<String, Any?>> {
+    val result = dataSource.queryDynamicEntities(listOf(entityId)).getOrThrow()
+    val entity = result.toList().firstOrNull()
+      ?: return emptyList()
+    return entity.getObservations(max).map { obs ->
+      val entry = mutableMapOf<String, Any?>(
+        "attributes" to obs.attributes.toMap(),
+      )
+      obs.geometry?.let { entry["geometry"] = dictFromGeometry(it) }
+      entry
+    }
+  }
+
   /** Returns the data source's currently-tracked dynamic entities (attributes + geometry). */
   suspend fun queryDynamicEntities(): Map<String, Any?> {
     val result = dataSource.queryDynamicEntities(DynamicEntityQueryParameters()).getOrThrow()
@@ -81,6 +111,11 @@ class DynamicEntityLayerRef(appContext: AppContext, props: Map<String, Any?>) :
       }
       (dataSource as? ArcGISStreamService)?.filter = filter
     }
+    (changed["purgeOptions"] as? Map<*, *>)?.let { purgeDict ->
+      val opts = dataSource.purgeOptions
+      (purgeDict["maximumObservations"] as? Number)?.let { opts.maximumObservations = it.toLong() }
+      (purgeDict["maximumDuration"] as? Number)?.let { opts.maximumDuration = it.toDouble() }
+    }
   }
 
   override fun deallocate() {
@@ -97,6 +132,24 @@ fun connectionStatusString(status: ConnectionStatus): String = when (status) {
   is ConnectionStatus.Failed -> "failed"
 }
 
+/**
+ * Builds a compact payload for the `onDynamicEntityChange` event.
+ * Only `received` and `purged` change types are emitted (observation-only updates are
+ * captured within `dynamicEntityReceivedEvent` which fires per-entity arrival, not per
+ * observation, so the event rate is bounded to entity lifecycle changes).
+ * Geometry is serialized only when present; attributes are passed as-is (the map returned
+ * by the SDK is a shallow snapshot of the current entity attributes).
+ */
+private fun dynamicEntityPayload(changeType: String, entity: com.arcgismaps.realtime.DynamicEntity): Map<String, Any?> {
+  val payload = mutableMapOf<String, Any?>(
+    "changeType" to changeType,
+    "entityId" to entity.id,
+    "attributes" to entity.attributes.toMap(),
+  )
+  entity.geometry?.let { payload["geometry"] = dictFromGeometry(it) }
+  return payload
+}
+
 /** Builds the real-time data source: a custom feed (push from JS) or a stream service. */
 private fun buildDataSource(
   props: Map<String, Any?>,

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

@@ -1,5 +1,7 @@
 package expo.modules.arcgis
 
+import com.arcgismaps.ArcGISEnvironment
+import com.arcgismaps.httpcore.authentication.TokenCredential
 import expo.modules.kotlin.functions.Coroutine
 import expo.modules.kotlin.modules.Module
 import expo.modules.kotlin.modules.ModuleDefinition
@@ -71,6 +73,19 @@ class ExpoArcgisExtrasModule : Module() {
       }
     }
 
+    // Per-service token credential — mint a token for a specific URL and add it to the store.
+    AsyncFunction("setServiceCredential") Coroutine { serviceUrl: String, username: String, password: String, tokenExpirationMinutes: Int? ->
+      val credential = TokenCredential.create(serviceUrl, username, password, tokenExpirationMinutes)
+        .getOrThrow()
+      ArcGISEnvironment.authenticationManager.arcGISCredentialStore.add(credential, serviceUrl)
+        .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

@@ -59,6 +59,11 @@ class ExpoArcgisGeometryModule : Module() {
     Function("geMove", ::geMove)
     Function("geRotate", ::geRotate)
     Function("geScale", ::geScale)
+    Function("geEllipseGeodesic", ::geEllipseGeodesic)
+    Function("geSectorGeodesic", ::geSectorGeodesic)
+    Function("geWithZ", ::geWithZ)
+    Function("geWithM", ::geWithM)
+    Function("geWithZAndM", ::geWithZAndM)
 
     // CoordinateFormatter — point <-> notation strings, exposed as the JS `coordinateFormatter` namespace.
     Function("cfToLatLong", ::cfToLatLong)
@@ -80,6 +85,11 @@ class ExpoArcgisGeometryModule : Module() {
     AsyncFunction("suggest") Coroutine { searchText: String, params: Map<String, Any?> ->
       suggest(searchText, params)
     }
+    // FLAG: ExpoArcgisGeometry is approaching 64 KB; if the module's definition() grows further,
+    // relocate geocodeSuggestion (and the other geocoder AsyncFunctions) to ExpoArcgisExtrasModule.
+    AsyncFunction("geocodeSuggestion") Coroutine { suggestionId: Int, params: Map<String, Any?> ->
+      geocodeSuggestion(suggestionId, params)
+    }
 
     // Routing — solve a route between stops, exposed as the JS `router` namespace.
     AsyncFunction("solveRoute") Coroutine { stops: List<Map<String, Any?>>, params: Map<String, Any?> ->
@@ -172,8 +182,8 @@ class ExpoArcgisGeometryModule : Module() {
     }
 
     // Offline — take maps/data offline, exposed as the JS `offline` namespace.
-    AsyncFunction("generateOfflineMap") Coroutine { portalItemId: String, areaOfInterest: Map<String, Any?>, downloadName: String ->
-      generateOfflineMap(appContext, appContext.reactContext?.filesDir, portalItemId, areaOfInterest, downloadName)
+    AsyncFunction("generateOfflineMap") Coroutine { portalItemId: String, areaOfInterest: Map<String, Any?>, downloadName: String, overrides: Map<String, Any?>? ->
+      generateOfflineMap(appContext, appContext.reactContext?.filesDir, portalItemId, areaOfInterest, downloadName, overrides)
     }
     AsyncFunction("syncOfflineMap") Coroutine { mobileMapPackagePath: String ->
       syncOfflineMap(appContext, mobileMapPackagePath)

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

@@ -4,6 +4,7 @@ import android.content.Context
 import com.arcgismaps.ApiKey
 import com.arcgismaps.ArcGISEnvironment
 import com.arcgismaps.httpcore.authentication.OAuthApplicationCredential
+import com.arcgismaps.httpcore.authentication.OAuthUserCredential
 import com.arcgismaps.httpcore.authentication.TokenCredential
 import expo.modules.kotlin.Promise
 import expo.modules.kotlin.functions.Coroutine
@@ -34,14 +35,21 @@ class ExpoArcgisModule : Module() {
 
     // Token auth for secured services (e.g. utility-network feature services) — store the login;
     // the challenge handler mints a TokenCredential for the exact challenged resource on demand.
-    Function("setTokenCredential") { username: String, password: String ->
-      AuthChallengeHandler.setCredentials(username, password)
+    // `tokenExpirationMinutes` is optional; the server's default expiry is used when omitted.
+    Function("setTokenCredential") { username: String, password: String, tokenExpirationMinutes: Int? ->
+      AuthChallengeHandler.setCredentials(username, password, tokenExpirationMinutes)
     }
 
-    // Clears the stored login and all cached credentials (token + OAuth).
+    // Revokes any OAuth user credentials on the server, then clears all cached credentials.
     AsyncFunction("signOut") Coroutine { ->
+      val store = ArcGISEnvironment.authenticationManager.arcGISCredentialStore
+      for (credential in store.getCredentials()) {
+        if (credential is OAuthUserCredential) {
+          credential.revokeToken()
+        }
+      }
       AuthChallengeHandler.setCredentials(null, null)
-      ArcGISEnvironment.authenticationManager.arcGISCredentialStore.removeAll()
+      store.removeAll()
     }
 
     // OAuth user sign-in (Android): JS opens the browser between these two steps.
@@ -234,18 +242,22 @@ class ExpoArcgisModule : Module() {
       Function("applyProps") { ref: OgcFeatureLayerRef, changed: Map<String, Any?> -> ref.applyProps(changed) }
     }
 
-    // Real-time DynamicEntityLayer (stream service) — emits onConnectionStatusChange.
+    // Real-time DynamicEntityLayer (stream service) — emits onConnectionStatusChange +
+    // onDynamicEntityChange (received/purged entity events).
     Class(DynamicEntityLayerRef::class) {
       Constructor { props: Map<String, Any?> ->
         DynamicEntityLayerRef(appContext, props).also { it.applyProps(props) }
       }
-      Events("onConnectionStatusChange")
+      Events("onConnectionStatusChange", "onDynamicEntityChange")
       Function("applyProps") { ref: DynamicEntityLayerRef, changed: Map<String, Any?> ->
         ref.applyProps(changed)
       }
       AsyncFunction("queryDynamicEntities") Coroutine { ref: DynamicEntityLayerRef ->
         ref.queryDynamicEntities()
       }
+      AsyncFunction("queryObservations") Coroutine { ref: DynamicEntityLayerRef, entityId: String, max: Int ->
+        ref.queryObservations(entityId, max)
+      }
       Function("pushObservation") { ref: DynamicEntityLayerRef, attributes: Map<String, Any?>, geometry: Map<String, Any?> ->
         ref.pushObservation(attributes, geometry)
       }
@@ -291,6 +303,16 @@ class ExpoArcgisModule : Module() {
       Function("applyProps") { ref: ViewshedRef, changed: Map<String, Any?> -> ref.applyProps(changed) }
     }
 
+    // GeoElement-anchored viewshed — observer tracks a Graphic as it moves.
+    Class(GeoElementViewshedRef::class) {
+      Constructor { graphic: GraphicRef, props: Map<String, Any?> ->
+        GeoElementViewshedRef(appContext, graphic, props)
+      }
+      Function("applyProps") { ref: GeoElementViewshedRef, changed: Map<String, Any?> ->
+        ref.applyProps(changed)
+      }
+    }
+
     // Line of sight — emits onTargetVisibilityChange as the target's visibility changes.
     Class(LineOfSightRef::class) {
       Constructor { props: Map<String, Any?> -> LineOfSightRef(appContext, props) }
@@ -298,6 +320,15 @@ class ExpoArcgisModule : Module() {
       Function("applyProps") { ref: LineOfSightRef, changed: Map<String, Any?> -> ref.applyProps(changed) }
     }
 
+    // GeoElement-anchored line of sight — observer and target each track a Graphic as it moves.
+    // FLAG: added to the main module — integrator may need to relocate for the 64 KB budget.
+    Class(GeoElementLineOfSightRef::class) {
+      Constructor { observer: GraphicRef, target: GraphicRef ->
+        GeoElementLineOfSightRef(appContext, observer, target)
+      }
+      Events("onTargetVisibilityChange")
+    }
+
     Class(DistanceMeasurementRef::class) {
       Constructor { props: Map<String, Any?> -> DistanceMeasurementRef(appContext, props) }
       Events("onMeasurementChange")
@@ -328,6 +359,9 @@ class ExpoArcgisModule : Module() {
       AsyncFunction("associations") Coroutine { ref: UtilityNetworkRef, tableName: String, whereClause: String ->
         ref.associations(tableName, whereClause)
       }
+      Function("getTerminalConfigurations") { ref: UtilityNetworkRef ->
+        ref.getTerminalConfigurations()
+      }
       AsyncFunction("getState") Coroutine { ref: UtilityNetworkRef -> ref.getState() }
       Function("validateNetworkTopology") { ref: UtilityNetworkRef, extent: Map<String, Any?> ->
         ref.validateNetworkTopology(extent)
@@ -405,6 +439,10 @@ class ExpoArcgisModule : Module() {
         view.setCamera(camera)
       }
 
+      Prop("cameraController") { view: ExpoArcgisSceneView, value: Map<String, Any?>? ->
+        view.setCameraController(value)
+      }
+
       Prop("sunLighting") { view: ExpoArcgisSceneView, value: String? ->
         view.setSunLighting(value)
       }

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

@@ -9,7 +9,9 @@ import com.arcgismaps.geometry.Point
 import com.arcgismaps.geometry.SpatialReference
 import com.arcgismaps.mapping.view.AtmosphereEffect
 import com.arcgismaps.mapping.view.Camera
+import com.arcgismaps.mapping.view.GlobeCameraController
 import com.arcgismaps.mapping.view.LightingMode
+import com.arcgismaps.mapping.view.OrbitLocationCameraController
 import com.arcgismaps.mapping.view.SceneView
 import com.arcgismaps.mapping.view.ScreenCoordinate
 import expo.modules.kotlin.AppContext
@@ -147,6 +149,24 @@ class ExpoArcgisSceneView(context: Context, appContext: AppContext) : ExpoView(c
     scope.launch { sceneView.setViewpointCameraAnimated(camera, 0.5f) }
   }
 
+  /** Sets or clears the scene's camera controller (orbit/globe). `null` restores the SDK default. */
+  fun setCameraController(c: Map<String, Any?>?) {
+    sceneView.cameraController = when (c?.get("type") as? String) {
+      "orbitLocation" -> {
+        val target = c["target"] as? Map<*, *>
+        val x = (target?.get("x") as? Number)?.toDouble() ?: 0.0
+        val y = (target?.get("y") as? Number)?.toDouble() ?: 0.0
+        val z = (target?.get("z") as? Number)?.toDouble()
+        val point = if (z != null) Point(x, y, z, SpatialReference.wgs84())
+                    else Point(x, y, SpatialReference.wgs84())
+        val distance = (c["distance"] as? Number)?.toDouble() ?: 1500.0
+        OrbitLocationCameraController(point, distance)
+      }
+      "globe" -> GlobeCameraController()
+      else -> GlobeCameraController() // null/absent → restore SDK default (GlobeCameraController)
+    }
+  }
+
   /** Sun lighting mode (shadows). */
   fun setSunLighting(s: String?) {
     sceneView.sunLighting = when (s) {

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

@@ -1,6 +1,7 @@
 package expo.modules.arcgis
 
 import com.arcgismaps.geometry.Point
+import com.arcgismaps.geometry.SpatialReference
 import com.arcgismaps.tasks.geocode.GeocodeParameters
 import com.arcgismaps.tasks.geocode.GeocodeResult
 import com.arcgismaps.tasks.geocode.LocatorTask
@@ -12,8 +13,31 @@ import java.util.concurrent.ConcurrentHashMap
 /**
  * Free functions backing the JS `geocoder` namespace — forward / reverse geocoding via a
  * [LocatorTask]. Registered as `AsyncFunction`s in `ExpoArcgisGeometryModule`.
+ *
+ * SuggestResult round-trip
+ * ─────────────────────────
+ * [suggest] attaches a `suggestionId` (Int) to each returned item and stashes the native
+ * [SuggestResult] (and its locator URL) in [SuggestRegistry]. The registry is REPLACED on each
+ * new [suggest] call (ids restart from 0) so memory never grows unboundedly.
+ * [geocodeSuggestion] looks up the held result and calls `LocatorTask.geocode(suggestResult)` —
+ * the SDK's precise overload that avoids a text re-search.
  */
 
+/** Holds the native [SuggestResult]s from the most recent [suggest] call. */
+private object SuggestRegistry {
+  @Volatile private var locatorUrl: String = ""
+  @Volatile private var results: Map<Int, SuggestResult> = emptyMap()
+
+  /** Replaces the registry with a fresh set of results (called at the start of each [suggest]). */
+  @Synchronized fun reset(url: String, items: List<SuggestResult>) {
+    locatorUrl = url
+    results = items.mapIndexed { id, r -> id to r }.toMap()
+  }
+
+  @Synchronized fun lookup(id: Int): Pair<SuggestResult, String>? =
+    results[id]?.let { it to locatorUrl }
+}
+
 private const val WORLD_GEOCODER =
   "https://geocode-api.arcgis.com/arcgis/rest/services/World/GeocodeServer"
 
@@ -49,6 +73,8 @@ private fun buildGeocodeParameters(params: Map<String, Any?>): GeocodeParameters
   (params["maxResults"] as? Number)?.toInt()?.let { maxResults = it }
   (params["countryCode"] as? String)?.let { countryCode = it }
   (params["categories"] as? List<*>)?.filterIsInstance<String>()?.let { categories.addAll(it) }
+  (params["resultAttributeNames"] as? List<*>)?.filterIsInstance<String>()?.let { resultAttributeNames.addAll(it) }
+  (params["outputSpatialReference"] as? Number)?.toInt()?.let { outputSpatialReference = SpatialReference(it) }
   ((params["preferredSearchLocation"] as? Map<*, *>)?.let { geometryFromDict(it) } as? Point)
     ?.let { preferredSearchLocation = it }
 }
@@ -59,9 +85,25 @@ private fun buildReverseGeocodeParameters(params: Map<String, Any?>): ReverseGeo
     (params["maxDistance"] as? Number)?.toDouble()?.let { maxDistance = it }
   }
 
-internal suspend fun suggest(searchText: String, params: Map<String, Any?>): List<Map<String, Any?>> =
-  locatorTask(params).suggest(searchText, buildSuggestParameters(params)).getOrThrow()
-    .map { serializeSuggestResult(it) }
+internal suspend fun suggest(searchText: String, params: Map<String, Any?>): List<Map<String, Any?>> {
+  val url = params["locatorUrl"] as? String ?: WORLD_GEOCODER
+  val results = locatorTask(params).suggest(searchText, buildSuggestParameters(params)).getOrThrow()
+  // Stash all results in the registry (replaces any prior batch; ids restart from 0).
+  SuggestRegistry.reset(url, results)
+  return results.mapIndexed { id, r ->
+    serializeSuggestResult(r) + mapOf("suggestionId" to id)
+  }
+}
+
+internal suspend fun geocodeSuggestion(suggestionId: Int, params: Map<String, Any?>): List<Map<String, Any?>> {
+  val (suggestResult, storedUrl) = SuggestRegistry.lookup(suggestionId)
+    ?: error("suggestionId $suggestionId not found — call suggest() first")
+  // Allow the caller to override the locator URL, but fall back to the one stored by suggest().
+  val url = params["locatorUrl"] as? String ?: storedUrl
+  return locators.getOrPut(url) { LocatorTask(url) }
+    .geocode(suggestResult).getOrThrow()
+    .map { serializeGeocodeResult(it) }
+}
 
 private fun buildSuggestParameters(params: Map<String, Any?>): SuggestParameters = SuggestParameters().apply {
   (params["maxResults"] as? Number)?.toInt()?.let { maxResults = it }

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

@@ -1,6 +1,8 @@
 package expo.modules.arcgis
 
 import com.arcgismaps.geometry.Envelope
+import com.arcgismaps.geometry.GeodesicEllipseParameters
+import com.arcgismaps.geometry.GeodesicSectorParameters
 import com.arcgismaps.geometry.Geometry
 import com.arcgismaps.geometry.GeometryEngine
 import com.arcgismaps.geometry.Multipart
@@ -256,3 +258,80 @@ internal fun geScale(
     else GeometryEngine.scale(geometry, factorX, factorY),
   )
 }
+
+// region Z / M builders
+
+internal fun geWithZ(g: Map<String, Any?>, z: Double): Map<String, Any?>? =
+  parseGeo(g)?.let { encode(GeometryEngine.createWithZOrNull(it, z)) }
+
+internal fun geWithM(g: Map<String, Any?>, m: Double): Map<String, Any?>? =
+  parseGeo(g)?.let { encode(GeometryEngine.createWithMOrNull(it, m)) }
+
+internal fun geWithZAndM(g: Map<String, Any?>, z: Double, m: Double): Map<String, Any?>? =
+  parseGeo(g)?.let { encode(GeometryEngine.createWithZAndMOrNull(it, z, m)) }
+
+// region Geodesic construction
+
+internal fun geEllipseGeodesic(params: Map<String, Any?>): Map<String, Any?>? {
+  val centerDict = params["center"] as? Map<String, Any?> ?: return null
+  val center = parsePoint(centerDict) ?: return null
+
+  val semiAxis1Length = (params["semiAxis1Length"] as? Number)?.toDouble() ?: 0.0
+  val semiAxis2Length = (params["semiAxis2Length"] as? Number)?.toDouble() ?: 0.0
+  val axisDirection   = (params["axisDirection"] as? Number)?.toDouble() ?: 0.0
+  val angUnit         = angularUnit(params["angularUnit"] as? String)
+  val linUnit         = linearUnit(params["linearUnit"] as? String)
+  val maxSegLen       = (params["maxSegmentLength"] as? Number)?.toDouble() ?: 0.0
+  val maxPtCount      = (params["maxPointCount"] as? Number)?.toLong() ?: 10L
+  val geoType         = params["geometryType"] as? String
+
+  val p: GeodesicEllipseParameters = when (geoType) {
+    "polyline"   -> GeodesicEllipseParameters.Companion.createForPolyline()
+    "multipoint" -> GeodesicEllipseParameters.Companion.createForMultipoint()
+    else         -> GeodesicEllipseParameters.Companion.createForPolygon()
+  }
+  p.center = center
+  p.semiAxis1Length = semiAxis1Length
+  p.semiAxis2Length = semiAxis2Length
+  p.axisDirection = axisDirection
+  p.angularUnit = angUnit
+  p.linearUnit = linUnit
+  p.maxSegmentLength = maxSegLen
+  p.maxPointCount = maxPtCount
+
+  return encode(GeometryEngine.ellipseGeodesicOrNull(p))
+}
+
+internal fun geSectorGeodesic(params: Map<String, Any?>): Map<String, Any?>? {
+  val centerDict = params["center"] as? Map<String, Any?> ?: return null
+  val center = parsePoint(centerDict) ?: return null
+
+  val semiAxis1Length = (params["semiAxis1Length"] as? Number)?.toDouble() ?: 0.0
+  val semiAxis2Length = (params["semiAxis2Length"] as? Number)?.toDouble() ?: 0.0
+  val axisDirection   = (params["axisDirection"] as? Number)?.toDouble() ?: 0.0
+  val sectorAngle     = (params["sectorAngle"] as? Number)?.toDouble() ?: 0.0
+  val startDirection  = (params["startDirection"] as? Number)?.toDouble() ?: 0.0
+  val angUnit         = angularUnit(params["angularUnit"] as? String)
+  val linUnit         = linearUnit(params["linearUnit"] as? String)
+  val maxSegLen       = (params["maxSegmentLength"] as? Number)?.toDouble() ?: 0.0
+  val maxPtCount      = (params["maxPointCount"] as? Number)?.toLong() ?: 10L
+  val geoType         = params["geometryType"] as? String
+
+  val p: GeodesicSectorParameters = when (geoType) {
+    "polyline"   -> GeodesicSectorParameters.Companion.createForPolyline()
+    "multipoint" -> GeodesicSectorParameters.Companion.createForMultipoint()
+    else         -> GeodesicSectorParameters.Companion.createForPolygon()
+  }
+  p.center = center
+  p.semiAxis1Length = semiAxis1Length
+  p.semiAxis2Length = semiAxis2Length
+  p.axisDirection = axisDirection
+  p.sectorAngle = sectorAngle
+  p.startDirection = startDirection
+  p.angularUnit = angUnit
+  p.linearUnit = linUnit
+  p.maxSegmentLength = maxSegLen
+  p.maxPointCount = maxPtCount
+
+  return encode(GeometryEngine.sectorGeodesicOrNull(p))
+}

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

@@ -4,12 +4,16 @@ import com.arcgismaps.data.FeatureCollectionTable
 import com.arcgismaps.mapping.view.Graphic
 import com.arcgismaps.tasks.geoprocessing.GeoprocessingTask
 import com.arcgismaps.tasks.geoprocessing.geoprocessingparameters.GeoprocessingBoolean
+import com.arcgismaps.tasks.geoprocessing.geoprocessingparameters.GeoprocessingDataFile
 import com.arcgismaps.tasks.geoprocessing.geoprocessingparameters.GeoprocessingDate
+import com.arcgismaps.tasks.geoprocessing.geoprocessingparameters.GeoprocessingRaster
 import com.arcgismaps.tasks.geoprocessing.geoprocessingparameters.GeoprocessingDouble
 import com.arcgismaps.tasks.geoprocessing.geoprocessingparameters.GeoprocessingFeatures
 import com.arcgismaps.tasks.geoprocessing.geoprocessingparameters.GeoprocessingLinearUnit
 import com.arcgismaps.tasks.geoprocessing.geoprocessingparameters.GeoprocessingLong
+import com.arcgismaps.tasks.geoprocessing.geoprocessingparameters.GeoprocessingMultiValue
 import com.arcgismaps.tasks.geoprocessing.geoprocessingparameters.GeoprocessingParameter
+import com.arcgismaps.tasks.geoprocessing.geoprocessingparameters.GeoprocessingParameterType
 import com.arcgismaps.tasks.geoprocessing.geoprocessingparameters.GeoprocessingString
 import expo.modules.kotlin.AppContext
 import java.time.Instant
@@ -60,6 +64,36 @@ private fun buildGeoprocessingParameter(d: Map<*, *>): GeoprocessingParameter? =
       ?.map { Graphic().apply { geometry = it } } ?: emptyList()
     GeoprocessingFeatures(FeatureCollectionTable(graphics, emptyList()))
   }
+  "multiValue" -> {
+    // JS numbers → GeoprocessingDouble, JS strings → GeoprocessingString.
+    val rawValues = d["values"] as? List<*> ?: emptyList<Any>()
+    val elements: List<GeoprocessingParameter> = rawValues.mapNotNull { v ->
+      when (v) {
+        is Number -> GeoprocessingDouble(v.toDouble())
+        is String -> GeoprocessingString(v)
+        else -> null
+      }
+    }
+    // Use the element type of the first item to determine the multiValue's parameterType;
+    // fall back to GeoprocessingParameterType.GeoprocessingString when the list is empty.
+    val paramType = if (elements.firstOrNull() is GeoprocessingDouble)
+      GeoprocessingParameterType.GeoprocessingDouble
+    else
+      GeoprocessingParameterType.GeoprocessingString
+    GeoprocessingMultiValue(paramType, elements)
+  }
+  "dataFile" -> {
+    val filePath = d["filePath"] as? String
+    if (filePath != null) {
+      // Local-file path — use GeoprocessingDataFile.inputFilePath (a settable property).
+      val df = GeoprocessingDataFile.Companion.create()
+      df.inputFilePath = filePath
+      df
+    } else {
+      val url = d["url"] as? String ?: return null
+      GeoprocessingDataFile.Companion.createWithUrl(url)
+    }
+  }
   else -> null
 }
 
@@ -80,5 +114,12 @@ private suspend fun serializeGeoprocessingParameter(param: GeoprocessingParamete
     if (param.canFetchOutputFeatures) param.fetchOutputFeatures().getOrThrow()
     param.features?.map { serializeFeature(it) } ?: emptyList<Map<String, Any?>>()
   }
+  // GeoprocessingRaster extends GeoprocessingDataFile — must come before any GeoprocessingDataFile branch.
+  is GeoprocessingRaster -> {
+    val result = mutableMapOf<String, Any?>("type" to "raster")
+    param.url?.let { result["url"] = it }
+    param.inputFilePath?.let { result["filePath"] = it }
+    result
+  }
   else -> null
 }