expo-arcgis 0.1.1 → 0.1.3

package/README.md

@@ -18,14 +18,14 @@ authentication.
 | Area | What's covered |
 |---|---|
 | **2D / 3D** | `<MapView>` + `<Map>`; `<SceneView>` + `<Scene>` (surface, camera, web scenes, light/shadows) |
-| **Layers** | Feature, Tile, MapImage, Vector-tile, Raster, WMS, WMTS, KML, Scene, IntegratedMesh, PointCloud, OGC 3D Tiles, WebTiled, OpenStreetMap, WFS, OGC API Features, DynamicEntity (stream), Annotation, Dimension, BuildingScene (3D), OrientedImagery, SubtypeFeature, **Group** (container) |
+| **Layers** | Feature, Tile, MapImage, Vector-tile, Raster, WMS, WMTS, KML, Scene, IntegratedMesh, PointCloud, OGC 3D Tiles, WebTiled, OpenStreetMap, WFS, OGC API Features, DynamicEntity (stream), Annotation, Dimension, BuildingScene (3D), OrientedImagery, SubtypeFeature, **Group** (container), **FeatureCollection** (in-memory), **GeoPackage** (local `.gpkg`) |
 | **Graphics** | `<GraphicsOverlay>` + `<Graphic>`, symbols (simple marker/line/fill, text, 3D scene symbol, picture-marker), renderers (simple / unique-value / class-breaks), labels, clustering |
 | **Geometry** | `geometryEngine` (buffer, project, distance, intersect, …), `coordinateFormatter`, codec for all geometry types |
 | **Query** | feature query / count / extent / statistics on a `<FeatureLayer>` ref; `identify` on a view ref |
 | **Editing** | add / update / delete features, `<GeometryEditor>` (tools), feature templates |
 | **Location** | device location, simulated location data source, `onLocationChange` |
 | **Geocoding** | `geocoder.geocode` / `reverseGeocode` / `suggest`, offline `.loc` locators |
-| **Routing** | `router.solveRoute` / directions, travel modes, point barriers, curb approach |
+| **Routing** | `router.solveRoute` / directions, travel modes, point barriers, curb approach; `router.createRouteTracker` turn-by-turn navigation |
 | **Analysis (3D)** | `<AnalysisOverlay>` + `<Viewshed>` / `<LineOfSight>` / `<DistanceMeasurement>` |
 | **Geoprocessing** | `geoprocessor.execute` → `JobRef` (progress + cancel), typed parameters |
 | **Utility network** | `<UtilityNetwork>` load + trace, named configs, associations, `describeNetwork` |
@@ -126,7 +126,7 @@ const [hit] = await geocoder.geocode('Los Angeles');
   `IntegratedMeshLayer`, `PointCloudLayer`, `Ogc3DTilesLayer`, `WebTiledLayer`, `OpenStreetMapLayer`,
   `WmsLayer`, `WmtsLayer`, `RasterLayer`, `KmlLayer`, `WfsLayer`, `OgcFeatureLayer`, `DynamicEntityLayer`,
   `AnnotationLayer`, `DimensionLayer`, `BuildingSceneLayer`, `OrientedImageryLayer`, `SubtypeFeatureLayer`,
-  `GroupLayer`
+  `GroupLayer`, `FeatureCollectionLayer`, `GeoPackageLayer`
 - **Graphics & analysis** — `GraphicsOverlay`, `Graphic`, `AnalysisOverlay`, `Viewshed`, `LineOfSight`,
   `DistanceMeasurement`, `GeometryEditor`, `UtilityNetwork`
 - **Namespaces** — `geometryEngine`, `coordinateFormatter`, `geocoder`, `router`, `geoprocessor`, `offline`

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). */
@@ -97,6 +109,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

@@ -0,0 +1,102 @@
+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
+
+/**
+ * Third native module, hosting the heavier operational-layer SharedObject classes (currently
+ * [FeatureLayerRef]), exposed to JS as `ExpoArcgisExtras`. Split out of [ExpoArcgisGeometryModule]
+ * so that no module's `definition()` exceeds the JVM 64 KB method-size limit. SharedObjects are
+ * global, so a ref constructed here attaches to a `<MapView>` from the main module fine.
+ */
+class ExpoArcgisExtrasModule : Module() {
+  override fun definition() = ModuleDefinition {
+    Name("ExpoArcgisExtras")
+
+    Class(FeatureLayerRef::class) {
+      Constructor { props: Map<String, Any?> ->
+        FeatureLayerRef(appContext, props).also { it.applyProps(props) }
+      }
+      Function("applyProps") { ref: FeatureLayerRef, changed: Map<String, Any?> ->
+        ref.applyProps(changed)
+      }
+      AsyncFunction("queryFeatures") Coroutine { ref: FeatureLayerRef, query: Map<String, Any?>? ->
+        ref.queryFeatures(query)
+      }
+      AsyncFunction("queryFeatureCount") Coroutine { ref: FeatureLayerRef, query: Map<String, Any?>? ->
+        ref.queryFeatureCount(query)
+      }
+      AsyncFunction("queryExtent") Coroutine { ref: FeatureLayerRef, query: Map<String, Any?>? ->
+        ref.queryExtent(query)
+      }
+      AsyncFunction("queryStatistics") Coroutine { ref: FeatureLayerRef, query: Map<String, Any?> ->
+        ref.queryStatistics(query)
+      }
+      AsyncFunction("queryFeatureTemplates") Coroutine { ref: FeatureLayerRef ->
+        ref.queryFeatureTemplates()
+      }
+      AsyncFunction("addFeature") Coroutine { ref: FeatureLayerRef, attributes: Map<String, Any?>, geometry: Map<String, Any?>?, apply: Boolean? ->
+        ref.addFeature(attributes, geometry, apply)
+      }
+      AsyncFunction("updateFeature") Coroutine { ref: FeatureLayerRef, objectId: Long, changes: Map<String, Any?>, apply: Boolean? ->
+        ref.updateFeature(objectId, changes, apply)
+      }
+      AsyncFunction("deleteFeature") Coroutine { ref: FeatureLayerRef, objectId: Long, apply: Boolean? ->
+        ref.deleteFeature(objectId, apply)
+      }
+      AsyncFunction("applyEdits") Coroutine { ref: FeatureLayerRef ->
+        ref.applyEdits()
+      }
+      AsyncFunction("undoLocalEdits") Coroutine { ref: FeatureLayerRef ->
+        ref.undoLocalEdits()
+      }
+      AsyncFunction("queryRelatedFeatures") Coroutine { ref: FeatureLayerRef, objectId: Long ->
+        ref.queryRelatedFeatures(objectId)
+      }
+      AsyncFunction("queryAttachments") Coroutine { ref: FeatureLayerRef, objectId: Long ->
+        ref.queryAttachments(objectId)
+      }
+      AsyncFunction("addAttachment") Coroutine { ref: FeatureLayerRef, objectId: Long, name: String, contentType: String, dataBase64: String ->
+        ref.addAttachment(objectId, name, contentType, dataBase64)
+      }
+      AsyncFunction("fetchAttachment") Coroutine { ref: FeatureLayerRef, objectId: Long, attachmentId: Long ->
+        ref.fetchAttachment(objectId, attachmentId)
+      }
+      AsyncFunction("deleteAttachment") Coroutine { ref: FeatureLayerRef, objectId: Long, attachmentId: Long ->
+        ref.deleteAttachment(objectId, attachmentId)
+      }
+      AsyncFunction("updateAttachment") Coroutine { ref: FeatureLayerRef, objectId: Long, attachmentId: Long, name: String, contentType: String, dataBase64: String ->
+        ref.updateAttachment(objectId, attachmentId, name, contentType, dataBase64)
+      }
+    }
+
+    // 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)
+    }
+    Class(RouteTrackerRef::class) {
+      AsyncFunction("trackLocation") Coroutine { ref: RouteTrackerRef, location: Map<String, Any?> ->
+        ref.trackLocation(location)
+      }
+      AsyncFunction("switchToNextDestination") Coroutine { ref: RouteTrackerRef ->
+        ref.switchToNextDestination()
+      }
+    }
+  }
+}

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

@@ -1,5 +1,7 @@
 package expo.modules.arcgis
 
+import com.arcgismaps.ArcGISEnvironment
+import com.arcgismaps.httpcore.authentication.ArcGISCredentialStore
 import expo.modules.kotlin.functions.Coroutine
 import expo.modules.kotlin.modules.Module
 import expo.modules.kotlin.modules.ModuleDefinition
@@ -30,6 +32,12 @@ class ExpoArcgisGeometryModule : Module() {
     Function("geClip", ::geClip)
     Function("geCut", ::geCut)
     Function("geConvexHull", ::geConvexHull)
+    Function("geLabelPoint", ::geLabelPoint)
+    Function("geNormalizeCentralMeridian", ::geNormalizeCentralMeridian)
+    Function("geReshape", ::geReshape)
+    Function("geIntersections", ::geIntersections)
+    Function("geExtend", ::geExtend)
+    Function("geAutoComplete", ::geAutoComplete)
     Function("geBoundary", ::geBoundary)
     Function("geSimplify", ::geSimplify)
     Function("geDensify", ::geDensify)
@@ -51,6 +59,8 @@ class ExpoArcgisGeometryModule : Module() {
     Function("geMove", ::geMove)
     Function("geRotate", ::geRotate)
     Function("geScale", ::geScale)
+    Function("geEllipseGeodesic", ::geEllipseGeodesic)
+    Function("geSectorGeodesic", ::geSectorGeodesic)
 
     // CoordinateFormatter — point <-> notation strings, exposed as the JS `coordinateFormatter` namespace.
     Function("cfToLatLong", ::cfToLatLong)
@@ -132,6 +142,36 @@ class ExpoArcgisGeometryModule : Module() {
       Function("addLayer") { ref: GroupLayerRef, layer: LayerRef -> ref.addLayer(layer) }
       Function("removeLayer") { ref: GroupLayerRef, layer: LayerRef -> ref.removeLayer(layer) }
     }
+    // FeatureLayerRef moved to the third module (ExpoArcgisExtras) to keep this module's
+    // definition() under the 64 KB limit. SharedObjects are global, so it stays cross-module.
+    // In-memory FeatureCollectionLayer — built from a client-side schema + features (no service).
+    Class(FeatureCollectionLayerRef::class) {
+      Constructor { props: Map<String, Any?> ->
+        FeatureCollectionLayerRef(appContext, props).also { it.applyProps(props) }
+      }
+      Function("applyProps") { ref: FeatureCollectionLayerRef, changed: Map<String, Any?> -> ref.applyProps(changed) }
+    }
+    // GeoPackage layer — async-loads a local .gpkg, picks the feature table, wraps it in a FeatureLayer.
+    Class(GeoPackageLayerRef::class) {
+      Constructor { props: Map<String, Any?> ->
+        GeoPackageLayerRef(
+          appContext,
+          props["path"] as? String ?: "",
+          props["tableName"] as? String,
+        ).also { it.applyProps(props) }
+      }
+      Function("applyProps") { ref: GeoPackageLayerRef, changed: Map<String, Any?> -> ref.applyProps(changed) }
+    }
+
+    // Auth — persistent credential store (survives app restarts via Android encrypted storage).
+    // Registered here (not in the main module) because the main module is at the JVM 64 KB limit.
+    AsyncFunction("enablePersistentCredentialStore") Coroutine { ->
+      val store = ArcGISCredentialStore.createWithPersistence().getOrThrow()
+      ArcGISEnvironment.authenticationManager.arcGISCredentialStore = store
+    }
+    AsyncFunction("clearCredentialStore") Coroutine { ->
+      ArcGISEnvironment.authenticationManager.arcGISCredentialStore.removeAll()
+    }
 
     // Offline — take maps/data offline, exposed as the JS `offline` namespace.
     AsyncFunction("generateOfflineMap") Coroutine { portalItemId: String, areaOfInterest: Map<String, Any?>, downloadName: String ->

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

@@ -196,6 +196,22 @@ class ExpoArcgisMapView(context: Context, appContext: AppContext) : ExpoView(con
     }
   }
 
+  /** Identifies popups under a screen point — evaluates each and returns `{ title, fields }`. */
+  fun identifyPopups(screenPoint: Map<String, Any?>, options: Map<String, Any?>?, promise: Promise) {
+    val x = (screenPoint["x"] as? Number)?.toDouble() ?: 0.0
+    val y = (screenPoint["y"] as? Number)?.toDouble() ?: 0.0
+    val tolerance = (options?.get("tolerance") as? Number)?.toDouble() ?: 12.0
+    val maxResults = (options?.get("maxResults") as? Number)?.toInt() ?: 1
+    scope.launch {
+      try {
+        val results = mapView.identifyLayers(ScreenCoordinate(x, y), tolerance, false, maxResults).getOrThrow()
+        promise.resolve(serializePopups(results))
+      } catch (e: Exception) {
+        promise.reject("IDENTIFY_ERROR", e.message ?: "Identify failed", e)
+      }
+    }
+  }
+
   /** Retries loading the map (Loadable pattern) — useful after a network outage. Re-emits the result. */
   fun retryLoad(promise: Promise) {
     val map = mapView.map ?: run { promise.resolve(null); return }

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

@@ -96,38 +96,8 @@ class ExpoArcgisModule : Module() {
     }
 
     // Operational layers — SharedObjects the JS <FeatureLayer>/<TileLayer> construct.
-    Class(FeatureLayerRef::class) {
-      Constructor { props: Map<String, Any?> ->
-        FeatureLayerRef(appContext, props).also { it.applyProps(props) }
-      }
-      Function("applyProps") { ref: FeatureLayerRef, changed: Map<String, Any?> ->
-        ref.applyProps(changed)
-      }
-      AsyncFunction("queryFeatures") Coroutine { ref: FeatureLayerRef, query: Map<String, Any?>? ->
-        ref.queryFeatures(query)
-      }
-      AsyncFunction("queryFeatureCount") Coroutine { ref: FeatureLayerRef, query: Map<String, Any?>? ->
-        ref.queryFeatureCount(query)
-      }
-      AsyncFunction("queryExtent") Coroutine { ref: FeatureLayerRef, query: Map<String, Any?>? ->
-        ref.queryExtent(query)
-      }
-      AsyncFunction("queryStatistics") Coroutine { ref: FeatureLayerRef, query: Map<String, Any?> ->
-        ref.queryStatistics(query)
-      }
-      AsyncFunction("queryFeatureTemplates") Coroutine { ref: FeatureLayerRef ->
-        ref.queryFeatureTemplates()
-      }
-      AsyncFunction("addFeature") Coroutine { ref: FeatureLayerRef, attributes: Map<String, Any?>, geometry: Map<String, Any?>? ->
-        ref.addFeature(attributes, geometry)
-      }
-      AsyncFunction("updateFeature") Coroutine { ref: FeatureLayerRef, objectId: Long, changes: Map<String, Any?> ->
-        ref.updateFeature(objectId, changes)
-      }
-      AsyncFunction("deleteFeature") Coroutine { ref: FeatureLayerRef, objectId: Long ->
-        ref.deleteFeature(objectId)
-      }
-    }
+    // FeatureLayerRef is registered on the ExpoArcgisGeometry module to keep this module's
+    // definition() under the Android JVM 64 KB method-size limit (SharedObjects cross modules).
 
     Class(TiledLayerRef::class) {
       Constructor { props: Map<String, Any?> ->
@@ -264,12 +234,13 @@ 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)
       }
@@ -358,6 +329,10 @@ class ExpoArcgisModule : Module() {
       AsyncFunction("associations") Coroutine { ref: UtilityNetworkRef, tableName: String, whereClause: String ->
         ref.associations(tableName, whereClause)
       }
+      AsyncFunction("getState") Coroutine { ref: UtilityNetworkRef -> ref.getState() }
+      Function("validateNetworkTopology") { ref: UtilityNetworkRef, extent: Map<String, Any?> ->
+        ref.validateNetworkTopology(extent)
+      }
     }
 
     // Interactive GeometryEditor — bound to a <MapView> for sketching; emits onGeometryChange.
@@ -401,6 +376,10 @@ class ExpoArcgisModule : Module() {
         view.identify(screenPoint, options, promise)
       }
 
+      AsyncFunction("identifyPopups") { view: ExpoArcgisMapView, screenPoint: Map<String, Any?>, options: Map<String, Any?>?, promise: Promise ->
+        view.identifyPopups(screenPoint, options, promise)
+      }
+
       AsyncFunction("retryLoad") { view: ExpoArcgisMapView, promise: Promise ->
         view.retryLoad(promise)
       }
@@ -427,6 +406,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)
       }
@@ -446,6 +429,10 @@ class ExpoArcgisModule : Module() {
       AsyncFunction("identify") { view: ExpoArcgisSceneView, screenPoint: Map<String, Any?>, options: Map<String, Any?>?, promise: Promise ->
         view.identify(screenPoint, options, promise)
       }
+
+      AsyncFunction("identifyPopups") { view: ExpoArcgisSceneView, screenPoint: Map<String, Any?>, options: Map<String, Any?>?, promise: Promise ->
+        view.identifyPopups(screenPoint, options, promise)
+      }
     }
   }
 }

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
@@ -101,6 +103,22 @@ class ExpoArcgisSceneView(context: Context, appContext: AppContext) : ExpoView(c
     }
   }
 
+  /** Identifies popups under a screen point — evaluates each and returns `{ title, fields }`. */
+  fun identifyPopups(screenPoint: Map<String, Any?>, options: Map<String, Any?>?, promise: Promise) {
+    val x = (screenPoint["x"] as? Number)?.toDouble() ?: 0.0
+    val y = (screenPoint["y"] as? Number)?.toDouble() ?: 0.0
+    val tolerance = (options?.get("tolerance") as? Number)?.toDouble() ?: 12.0
+    val maxResults = (options?.get("maxResults") as? Number)?.toInt() ?: 1
+    scope.launch {
+      try {
+        val results = sceneView.identifyLayers(ScreenCoordinate(x, y), tolerance, false, maxResults).getOrThrow()
+        promise.resolve(serializePopups(results))
+      } catch (e: Exception) {
+        promise.reject("IDENTIFY_ERROR", e.message ?: "Identify failed", e)
+      }
+    }
+  }
+
   /** Retries loading the scene (Loadable pattern) — useful after a network outage. Re-emits the result. */
   fun retryLoad(promise: Promise) {
     val scene = sceneView.scene ?: run { promise.resolve(null); return }
@@ -131,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

@@ -25,9 +25,19 @@ private fun locatorTask(params: Map<String, Any?>): LocatorTask {
   return locators.getOrPut(url) { LocatorTask(url) }
 }
 
-internal suspend fun geocode(searchText: String, params: Map<String, Any?>): List<Map<String, Any?>> =
-  locatorTask(params).geocode(searchText, buildGeocodeParameters(params)).getOrThrow()
-    .map { serializeGeocodeResult(it) }
+internal suspend fun geocode(searchText: String, params: Map<String, Any?>): List<Map<String, Any?>> {
+  val locator = locatorTask(params)
+  val parameters = buildGeocodeParameters(params)
+  @Suppress("UNCHECKED_CAST")
+  val searchValues = (params["searchValues"] as? Map<*, *>)
+    ?.mapNotNull { (k, v) -> if (k is String && v is String) k to v else null }
+    ?.toMap()
+  return if (!searchValues.isNullOrEmpty()) {
+    locator.geocode(searchValues, parameters).getOrThrow()
+  } else {
+    locator.geocode(searchText, parameters).getOrThrow()
+  }.map { serializeGeocodeResult(it) }
+}
 
 internal suspend fun reverseGeocode(point: Map<String, Any?>, params: Map<String, Any?>): List<Map<String, Any?>> {
   val location = geometryFromDict(point) as? Point ?: return emptyList()

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

@@ -1,9 +1,13 @@
 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
 import com.arcgismaps.geometry.Point
+import com.arcgismaps.geometry.Polygon
 import com.arcgismaps.geometry.Polyline
 
 /**
@@ -104,6 +108,39 @@ internal fun geCut(g: Map<String, Any?>, cutter: Map<String, Any?>): List<Map<St
 internal fun geConvexHull(g: Map<String, Any?>): Map<String, Any?>? =
   parseGeo(g)?.let { encode(GeometryEngine.convexHullOrNull(it)) }
 
+internal fun geLabelPoint(g: Map<String, Any?>): Map<String, Any?>? =
+  (parseGeo(g) as? Polygon)?.let { encode(GeometryEngine.labelPointOrNull(it)) }
+
+internal fun geNormalizeCentralMeridian(g: Map<String, Any?>): Map<String, Any?>? =
+  parseGeo(g)?.let { encode(GeometryEngine.normalizeCentralMeridian(it)) }
+
+internal fun geReshape(g: Map<String, Any?>, reshaper: Map<String, Any?>): Map<String, Any?>? {
+  val multipart = parseGeo(g) as? Multipart ?: return null
+  val line = parseGeo(reshaper) as? Polyline ?: return null
+  return encode(GeometryEngine.reshape(multipart, line))
+}
+
+internal fun geIntersections(a: Map<String, Any?>, b: Map<String, Any?>): List<Map<String, Any?>> {
+  val g1 = parseGeo(a) ?: return emptyList()
+  val g2 = parseGeo(b) ?: return emptyList()
+  return GeometryEngine.tryIntersections(g1, g2).mapNotNull { encode(it) }
+}
+
+internal fun geExtend(p: Map<String, Any?>, extender: Map<String, Any?>): Map<String, Any?>? {
+  val polyline = parseGeo(p) as? Polyline ?: return null
+  val ext = parseGeo(extender) as? Polyline ?: return null
+  return encode(GeometryEngine.extend(polyline, ext, emptySet()))
+}
+
+internal fun geAutoComplete(
+  existing: List<Map<String, Any?>>,
+  boundaries: List<Map<String, Any?>>,
+): List<Map<String, Any?>> {
+  val polygons = existing.mapNotNull { parseGeo(it) as? Polygon }
+  val lines = boundaries.mapNotNull { parseGeo(it) as? Polyline }
+  return GeometryEngine.tryAutoComplete(polygons, lines).mapNotNull { encode(it) }
+}
+
 internal fun geBoundary(g: Map<String, Any?>): Map<String, Any?>? =
   parseGeo(g)?.let { encode(GeometryEngine.boundaryOrNull(it)) }
 
@@ -221,3 +258,69 @@ internal fun geScale(
     else GeometryEngine.scale(geometry, factorX, factorY),
   )
 }
+
+// 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,15 @@ 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.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 +63,28 @@ 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 url = d["url"] as? String ?: return null
+    GeoprocessingDataFile.Companion.createWithUrl(url)
+  }
   else -> null
 }