expo-arcgis 0.1.1 → 0.1.2

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/ExpoArcgisExtrasModule.kt

@@ -0,0 +1,87 @@
+package expo.modules.arcgis
+
+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)
+      }
+    }
+
+    // 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)
@@ -132,6 +140,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?> ->
@@ -358,6 +328,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 +375,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)
       }
@@ -446,6 +424,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

@@ -101,6 +101,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 }

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

@@ -3,7 +3,9 @@ package expo.modules.arcgis
 import com.arcgismaps.geometry.Envelope
 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 +106,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)) }
 

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

@@ -15,8 +15,11 @@ import com.arcgismaps.mapping.symbology.SimpleFillSymbol
 import com.arcgismaps.mapping.symbology.SimpleFillSymbolStyle
 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.SimpleMarkerSceneSymbol
 import com.arcgismaps.mapping.symbology.SimpleMarkerSceneSymbolStyle
+import com.arcgismaps.mapping.symbology.PictureFillSymbol
 import com.arcgismaps.mapping.symbology.PictureMarkerSymbol
 import com.arcgismaps.mapping.symbology.SimpleMarkerSymbol
 import com.arcgismaps.mapping.symbology.SimpleMarkerSymbolStyle
@@ -188,6 +191,28 @@ private fun buildSymbol(s: Map<*, *>): Symbol? = when (s["type"]) {
       (s["height"] as? Number)?.toFloat()?.let { height = it }
     }
   }
+  "picture-fill" -> (s["url"] as? String)?.let { url ->
+    PictureFillSymbol(url).apply {
+      (s["width"] as? Number)?.toFloat()?.let { width = it }
+      (s["height"] as? Number)?.toFloat()?.let { height = it }
+      outline = outlineOf(s["outline"])
+    }
+  }
+  "distance-composite-scene" -> {
+    val composite = DistanceCompositeSceneSymbol()
+    val rangeList = s["ranges"] as? List<*> ?: emptyList<Any>()
+    for (rd in rangeList) {
+      val rdMap = rd as? Map<*, *> ?: continue
+      val sym = (rdMap["symbol"] as? Map<*, *>)?.let(::buildSymbol) ?: continue
+      val range = DistanceSymbolRange(
+        sym,
+        (rdMap["minDistance"] as? Number)?.toDouble(),
+        (rdMap["maxDistance"] as? Number)?.toDouble(),
+      )
+      composite.ranges.add(range)
+    }
+    composite
+  }
   else -> null
 }
 

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

@@ -1,9 +1,16 @@
 package expo.modules.arcgis
 
+import android.util.Base64
+import com.arcgismaps.data.ArcGISFeature
 import com.arcgismaps.data.ArcGISFeatureTable
 import com.arcgismaps.data.Feature
+import com.arcgismaps.data.FeatureCollection
+import com.arcgismaps.data.FeatureCollectionTable
 import com.arcgismaps.data.FeatureRequestMode
 import com.arcgismaps.data.FeatureTable
+import com.arcgismaps.data.Field
+import com.arcgismaps.data.FieldType
+import com.arcgismaps.data.GeoPackage
 import com.arcgismaps.data.QueryFeatureFields
 import com.arcgismaps.data.QueryParameters
 import com.arcgismaps.data.ServiceFeatureTable
@@ -11,12 +18,17 @@ import com.arcgismaps.data.ShapefileFeatureTable
 import com.arcgismaps.data.OgcFeatureCollectionTable
 import com.arcgismaps.data.WfsFeatureTable
 import com.arcgismaps.mapping.layers.AnnotationLayer
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
 import com.arcgismaps.mapping.layers.ArcGISMapImageLayer
 import com.arcgismaps.mapping.layers.ArcGISSceneLayer
 import com.arcgismaps.mapping.layers.ArcGISTiledLayer
 import com.arcgismaps.mapping.layers.ArcGISVectorTiledLayer
 import com.arcgismaps.mapping.layers.BuildingSceneLayer
 import com.arcgismaps.mapping.layers.DimensionLayer
+import com.arcgismaps.mapping.layers.FeatureCollectionLayer
 import com.arcgismaps.mapping.layers.FeatureLayer
 import com.arcgismaps.mapping.layers.GroupLayer
 import com.arcgismaps.mapping.layers.IntegratedMeshLayer
@@ -32,6 +44,7 @@ import com.arcgismaps.mapping.layers.KmlLayer
 import com.arcgismaps.mapping.layers.WmsLayer
 import com.arcgismaps.mapping.layers.WmtsLayer
 import com.arcgismaps.mapping.kml.KmlDataset
+import com.arcgismaps.mapping.view.Graphic
 import com.arcgismaps.raster.ImageServiceRaster
 import com.arcgismaps.raster.Raster
 import expo.modules.kotlin.AppContext
@@ -87,28 +100,115 @@ class FeatureLayerRef(appContext: AppContext, props: Map<String, Any?>) : LayerR
     }
   }
 
-  /** Adds a feature, pushes the edit to the service, and returns the new object id. */
-  suspend fun addFeature(attributes: Map<String, Any?>, geometry: Map<String, Any?>?): Long? {
+  /**
+   * Adds a feature. When `apply` is not `false`, pushes the edit and returns the new object id;
+   * pass `apply = false` to make a local-only edit (batch with `applyEdits`).
+   */
+  suspend fun addFeature(attributes: Map<String, Any?>, geometry: Map<String, Any?>?, apply: Boolean?): Long? {
     val feature = table.createFeature()
     applyAttributes(feature, attributes)
     geometry?.let { dict -> geometryFromDict(dict)?.let { feature.geometry = it } }
     table.addFeature(feature).getOrThrow()
+    if (apply == false) return null
     return persistEdits()
   }
 
-  /** Updates the feature with `objectId` (changed attributes and/or geometry) and pushes the edit. */
-  suspend fun updateFeature(objectId: Long, changes: Map<String, Any?>) {
+  /** Updates the feature with `objectId`. Pass `apply = false` for a local-only edit. */
+  suspend fun updateFeature(objectId: Long, changes: Map<String, Any?>, apply: Boolean?) {
     val feature = featureByObjectId(objectId) ?: return
     (changes["attributes"] as? Map<*, *>)?.let { applyAttributes(feature, it) }
     (changes["geometry"] as? Map<*, *>)?.let { geometryFromDict(it)?.let { g -> feature.geometry = g } }
     table.updateFeature(feature).getOrThrow()
-    persistEdits()
+    if (apply != false) persistEdits()
   }
 
-  /** Deletes the feature with `objectId` and pushes the edit. */
-  suspend fun deleteFeature(objectId: Long) {
+  /** Deletes the feature with `objectId`. Pass `apply = false` for a local-only edit. */
+  suspend fun deleteFeature(objectId: Long, apply: Boolean?) {
     val feature = featureByObjectId(objectId) ?: return
     table.deleteFeature(feature).getOrThrow()
+    if (apply != false) persistEdits()
+  }
+
+  /** Pushes all pending local edits to the service in one batch; returns each edit's result. */
+  suspend fun applyEdits(): List<Map<String, Any?>> {
+    val serviceTable = table as? ServiceFeatureTable ?: return emptyList()
+    return serviceTable.applyEdits().getOrThrow().map {
+      mapOf("objectId" to it.objectId, "completedWithErrors" to it.completedWithErrors)
+    }
+  }
+
+  /** Discards all pending local edits (since the last `applyEdits`). */
+  suspend fun undoLocalEdits() {
+    (table as? ServiceFeatureTable)?.undoLocalEdits()?.getOrThrow()
+  }
+
+  /** Queries features related to `objectId` (across all relationships); returns groups by relationship. */
+  suspend fun queryRelatedFeatures(objectId: Long): List<Map<String, Any?>> {
+    val arcgisTable = table as? ArcGISFeatureTable ?: return emptyList()
+    val feature = featureByObjectId(objectId) as? ArcGISFeature ?: return emptyList()
+    return arcgisTable.queryRelatedFeatures(feature).getOrThrow().map { result ->
+      mapOf(
+        "relationshipId" to (result.relationshipInfo?.id ?: -1L),
+        "features" to result.map { serializeFeature(it) },
+      )
+    }
+  }
+
+  /** Queries the attachments for the feature with `objectId`; returns `[{id, name, contentType, size}]`. */
+  suspend fun queryAttachments(objectId: Long): List<Map<String, Any?>> {
+    val feature = featureByObjectId(objectId) as? ArcGISFeature ?: return emptyList()
+    return feature.fetchAttachments().getOrThrow().map { attachment ->
+      mapOf(
+        "id" to attachment.id,
+        "name" to attachment.name,
+        "contentType" to attachment.contentType,
+        "size" to attachment.size,
+      )
+    }
+  }
+
+  /** Decodes `dataBase64`, adds it as an attachment to the feature, then persists the edit. */
+  suspend fun addAttachment(objectId: Long, name: String, contentType: String, dataBase64: String) {
+    val feature = featureByObjectId(objectId) as? ArcGISFeature ?: return
+    val bytes = Base64.decode(dataBase64, Base64.NO_WRAP)
+    feature.addAttachment(name, contentType, bytes).getOrThrow()
+    persistEdits()
+  }
+
+  /** Fetches the binary data for the attachment with `attachmentId` and returns it as base64. */
+  suspend fun fetchAttachment(objectId: Long, attachmentId: Long): String {
+    val feature = featureByObjectId(objectId) as? ArcGISFeature
+      ?: error("Feature not found: $objectId")
+    val attachment = feature.fetchAttachments().getOrThrow()
+      .firstOrNull { it.id == attachmentId }
+      ?: error("Attachment not found: $attachmentId")
+    val bytes = attachment.fetchData().getOrThrow()
+    return Base64.encodeToString(bytes, Base64.NO_WRAP)
+  }
+
+  /** Deletes the attachment with `attachmentId` from the feature with `objectId`, then persists. */
+  suspend fun deleteAttachment(objectId: Long, attachmentId: Long) {
+    val feature = featureByObjectId(objectId) as? ArcGISFeature
+      ?: error("Feature not found: $objectId")
+    val attachment = feature.fetchAttachments().getOrThrow()
+      .firstOrNull { it.id == attachmentId }
+      ?: error("Attachment not found: $attachmentId")
+    feature.deleteAttachment(attachment).getOrThrow()
+    persistEdits()
+  }
+
+  /** Decodes `dataBase64` and updates the attachment with `attachmentId`, then persists. */
+  suspend fun updateAttachment(
+    objectId: Long, attachmentId: Long,
+    name: String, contentType: String, dataBase64: String,
+  ) {
+    val feature = featureByObjectId(objectId) as? ArcGISFeature
+      ?: error("Feature not found: $objectId")
+    val attachment = feature.fetchAttachments().getOrThrow()
+      .firstOrNull { it.id == attachmentId }
+      ?: error("Attachment not found: $attachmentId")
+    val bytes = Base64.decode(dataBase64, Base64.NO_WRAP)
+    feature.updateAttachment(attachment, name, contentType, bytes).getOrThrow()
     persistEdits()
   }
 
@@ -314,3 +414,85 @@ class GroupLayerRef(appContext: AppContext) : LayerRef(appContext) {
 
   override fun applyProps(changed: Map<String, Any?>) = applyCommonProps(changed)
 }
+
+/**
+ * In-memory [FeatureCollectionLayer] — a layer built from a client-side schema (`fields`) and
+ * `features` (no service). Features become graphics in a [FeatureCollectionTable].
+ */
+class FeatureCollectionLayerRef(appContext: AppContext, props: Map<String, Any?>) : LayerRef(appContext) {
+  private val table: FeatureCollectionTable = run {
+    val fields = (props["fields"] as? List<*> ?: emptyList<Any?>())
+      .mapNotNull { (it as? Map<*, *>)?.let(::makeFeatureCollectionField) }
+    val graphics = (props["features"] as? List<*> ?: emptyList<Any?>()).mapNotNull { spec ->
+      val s = spec as? Map<*, *> ?: return@mapNotNull null
+      Graphic().apply {
+        geometry = (s["geometry"] as? Map<*, *>)?.let { geometryFromDict(it) }
+        (s["attributes"] as? Map<*, *>)?.forEach { (k, v) -> attributes[k.toString()] = v }
+      }
+    }
+    FeatureCollectionTable(graphics, fields).apply {
+      renderer = (props["renderer"] as? Map<*, *>)?.let { buildRenderer(it) }
+    }
+  }
+  override val layer: Layer = FeatureCollectionLayer(FeatureCollection().apply { tables.add(table) })
+
+  override fun applyProps(changed: Map<String, Any?>) {
+    applyCommonProps(changed)
+    if (changed.containsKey("renderer")) {
+      table.renderer = (changed["renderer"] as? Map<*, *>)?.let { buildRenderer(it) }
+    }
+  }
+}
+
+/**
+ * Operational layer loaded from a local GeoPackage (`.gpkg`) file. Opens the GeoPackage
+ * asynchronously, picks the feature table by [tableName] (or the first when null), wraps it in a
+ * [FeatureLayer], and attaches it to the placeholder [GroupLayer] once ready.
+ */
+class GeoPackageLayerRef(appContext: AppContext, path: String, tableName: String?) :
+  LayerRef(appContext) {
+
+  private val group = GroupLayer(emptyList())
+  override val layer: Layer = group
+  private val scope = CoroutineScope(Dispatchers.Main + SupervisorJob())
+
+  init {
+    scope.launch {
+      val pkg = GeoPackage(path)
+      pkg.load().onFailure { return@launch }
+      val tables = pkg.geoPackageFeatureTables
+      if (tables.isEmpty()) return@launch
+      val table = if (tableName != null) {
+        tables.firstOrNull { it.tableName == tableName } ?: return@launch
+      } else {
+        tables[0]
+      }
+      val featureLayer = FeatureLayer.createWithFeatureTable(table)
+      group.layers.add(featureLayer)
+    }
+  }
+
+  override fun applyProps(changed: Map<String, Any?>) = applyCommonProps(changed)
+}
+
+private fun makeFeatureCollectionField(d: Map<*, *>): Field {
+  val name = d["name"] as? String ?: ""
+  return Field(
+    featureCollectionFieldType(d["type"] as? String),
+    name,
+    d["alias"] as? String ?: name,
+    (d["length"] as? Number)?.toInt() ?: 255,
+    null,
+    true,
+    true,
+  )
+}
+
+private fun featureCollectionFieldType(value: String?): FieldType = when (value) {
+  "int16" -> FieldType.Int16
+  "integer" -> FieldType.Int32
+  "long" -> FieldType.Int64
+  "double" -> FieldType.Float64
+  "date" -> FieldType.Date
+  else -> FieldType.Text
+}