Introduce route service

arcgis_map_sdk/lib/src/arcgis_map_controller.dart

@@ -331,4 +331,22 @@ class ArcgisMapController {
     return ArcgisMapPlatform.instance
         .updateIsAttributionTextVisible(mapId, isAttributionTextVisible);
   }
+
+  Future<void> determineClosestPOIs({
+    required LatLng from,
+    required List<PointOfInterest> pointsOfInterest,
+  }) async {
+    return ArcgisMapPlatform.instance.determineClosestPOIs(
+      mapId,
+      from,
+      pointsOfInterest,
+    );
+  }
+
+  Future<RouteResult> calculateRoute({
+    required LatLng from,
+    required LatLng to,
+  }) async {
+    return ArcgisMapPlatform.instance.calculateRoute(mapId, from, to);
+  }
 }

arcgis_map_sdk/lib/src/arcgis_map_sdk.dart

@@ -41,6 +41,8 @@ class ArcgisMap extends StatefulWidget {
     this.onMapCreated,
     this.vectorTileLayerUrls,
     this.isAttributionTextVisible,
+    this.routeServiceUrl,
+    this.closestFacilitiesUrl,
     super.key,
   }) : assert(
           basemap != null ||
@@ -78,6 +80,14 @@ class ArcgisMap extends StatefulWidget {
   /// is ignored.
   final List<String>? vectorTileLayerUrls;
 
+  /// Allows the map to execute different routing tasks by providing a valid
+  /// ArcGIS route service URL.
+  final String? routeServiceUrl;
+
+  /// Allows the map to execute closest facility tasks by providing a valid
+  /// ArcGIS route service URL.
+  final String? closestFacilitiesUrl;
+
   final void Function(ArcgisMapController controller)? onMapCreated;
 
   @override
@@ -112,6 +122,8 @@ class _ArcgisMapState extends State<ArcgisMap> {
     yMin: widget.yMin,
     yMax: widget.yMax,
     vectorTilesUrls: widget.vectorTileLayerUrls,
+    routeServiceUrl: widget.routeServiceUrl,
+    closestFacilitiesUrl: widget.closestFacilitiesUrl,
     isAttributionTextVisible: widget.isAttributionTextVisible,
   );
 
@@ -169,6 +181,8 @@ class _ArcgisMapState extends State<ArcgisMap> {
       yMin: widget.yMin,
       yMax: widget.yMax,
       vectorTilesUrls: widget.vectorTileLayerUrls,
+      routeServiceUrl: widget.routeServiceUrl,
+      closestFacilitiesUrl: widget.closestFacilitiesUrl,
       defaultUiList: widget.defaultUiList,
       isAttributionTextVisible: widget.isAttributionTextVisible,
     );

arcgis_map_sdk/pubspec.yaml

@@ -13,7 +13,9 @@ dependencies:
   arcgis_map_sdk_android: ^0.8.0
   arcgis_map_sdk_ios: ^0.8.0
   arcgis_map_sdk_platform_interface: ^1.0.1
-  arcgis_map_sdk_web: ^0.8.0
+  # todo: this was removed to make sure we don't end up with web artifacts in our mobile build
+  # this is only a temporary solution.
+  #arcgis_map_sdk_web: ^0.8.0
   flutter:
     sdk: flutter
 

arcgis_map_sdk_android/android/src/main/kotlin/dev/fluttercommunity/arcgis_map_sdk_android/ArcgisMapView.kt

@@ -28,14 +28,25 @@ import com.esri.arcgisruntime.mapping.view.Graphic
 import com.esri.arcgisruntime.mapping.view.GraphicsOverlay
 import com.esri.arcgisruntime.mapping.view.LocationDisplay.AutoPanMode
 import com.esri.arcgisruntime.mapping.view.MapView
+import com.esri.arcgisruntime.symbology.SimpleLineSymbol
+import com.esri.arcgisruntime.symbology.SimpleLineSymbol.Style
 import com.esri.arcgisruntime.symbology.Symbol
+import com.esri.arcgisruntime.tasks.networkanalysis.ClosestFacilityTask
+import com.esri.arcgisruntime.tasks.networkanalysis.Facility
+import com.esri.arcgisruntime.tasks.networkanalysis.Incident
+import com.esri.arcgisruntime.tasks.networkanalysis.Route
+import com.esri.arcgisruntime.tasks.networkanalysis.RouteTask
+import com.esri.arcgisruntime.tasks.networkanalysis.Stop
 import com.google.gson.reflect.TypeToken
 import dev.fluttercommunity.arcgis_map_sdk_android.model.AnimationOptions
 import dev.fluttercommunity.arcgis_map_sdk_android.model.ArcgisMapOptions
 import dev.fluttercommunity.arcgis_map_sdk_android.model.LatLng
+import dev.fluttercommunity.arcgis_map_sdk_android.model.RouteResult
 import dev.fluttercommunity.arcgis_map_sdk_android.model.UserPosition
 import dev.fluttercommunity.arcgis_map_sdk_android.model.ViewPadding
+import dev.fluttercommunity.arcgis_map_sdk_android.model.toAGSPoint
 import dev.fluttercommunity.arcgis_map_sdk_android.util.GraphicsParser
+import io.flutter.Log
 import io.flutter.embedding.engine.plugins.FlutterPlugin.FlutterPluginBinding
 import io.flutter.plugin.common.EventChannel
 import io.flutter.plugin.common.MethodCall
@@ -101,7 +112,7 @@ internal class ArcgisMapView(
         mapView.graphicsOverlays.add(defaultGraphicsOverlay)
 
         mapView.addMapScaleChangedListener {
-            if(mapView.mapScale.isNaN()) return@addMapScaleChangedListener
+            if (mapView.mapScale.isNaN()) return@addMapScaleChangedListener
 
             val zoomLevel = getZoomLevel(mapView)
             zoomStreamHandler.addZoom(zoomLevel)
@@ -115,7 +126,7 @@ internal class ArcgisMapView(
             val wgs84Center = GeometryEngine.project(center, SpatialReferences.getWgs84()) as? Point
 
             val latLng = wgs84Center?.let {
-                LatLng(longitude = it.x,latitude = it.y)
+                LatLng(longitude = it.x, latitude = it.y)
             } ?: return@addViewpointChangedListener
 
             centerPositionStreamHandler.add(latLng)
@@ -201,6 +212,10 @@ internal class ArcgisMapView(
 
                 "export_image" -> onExportImage(result)
 
+                "determine_closest_POIs" -> onDetermineClosestPOIs(call = call, result = result)
+
+                "calculate_route" -> onCalculateRoute(call = call, result = result)
+
                 else -> result.notImplemented()
             }
         }
@@ -617,6 +632,198 @@ internal class ArcgisMapView(
 
     }
 
+    private fun onDetermineClosestPOIs(call: MethodCall, result: MethodChannel.Result) {
+        // Ensure this is never called without a closest facilities service url.
+        if (mapOptions.closestFacilitiesUrl == null) {
+            result.finishWithError(Exception("No closest facilities url provided, check map options"))
+        }
+
+        try {
+            val arguments = call.arguments as Map<String, Any>
+
+            Log.w("- Closest POI -", "Received Arguments: $arguments")
+
+            val relevantPOIs =
+                (arguments["pointsOfInterest"] as ArrayList<Map<String, Any>>).map { poi ->
+                    Facility(
+                        Point(
+                            poi["longitude"] as Double,
+                            poi["latitude"] as Double,
+                            SpatialReferences.getWebMercator(),
+                        ),
+                    ).apply {
+                        name = poi["identifier"] as String
+                    }
+                }
+            val from = arguments["from"] as Map<String, Any>
+            val currentLatLng = LatLng(
+                from["longitude"] as Double,
+                from["latitude"] as Double
+            )
+
+            Log.w(
+                "- Closest POI -",
+                "Extracted Arguments: $currentLatLng to ${relevantPOIs.size} POIs"
+            )
+
+            // Create a task to be able to determine the required information.
+            val closestFacilityTask = ClosestFacilityTask(context, mapOptions.routeServiceUrl)
+
+            Log.w("- Closest POI -", "Created Task: $closestFacilityTask")
+
+            val parameterFuture = closestFacilityTask.createDefaultParametersAsync()
+            parameterFuture.addDoneListener {
+                try {
+                    if (parameterFuture.isDone) {
+                        Log.w("- Closest POI -", "Future is done")
+
+                        val closestFacilityParameters = parameterFuture.get()
+
+                        Log.w("- Closest POI -", "Created Parameter: $closestFacilityParameters")
+
+                        // Apply the current coordinates and POIs to the parameters.
+                        closestFacilityParameters.apply {
+                            setIncidents(listOf(Incident(currentLatLng.toAGSPoint())))
+                            setFacilities(relevantPOIs)
+                        }
+
+                        Log.w("- Closest POI -", "Updated Parameters: $closestFacilityParameters")
+
+                        val closestFacilitiesFuture =
+                            closestFacilityTask.solveClosestFacilityAsync(closestFacilityParameters)
+                        closestFacilitiesFuture.addDoneListener {
+                            try {
+                                Log.w("- Closest POI -", "Future is done")
+
+                                val closestFacilityResult = closestFacilitiesFuture.get()
+
+                                Log.w("- Closest POI -", "Solved Route: $closestFacilityResult")
+
+                                val rankedFacilities =
+                                    closestFacilityResult.getRankedFacilityIndexes(0)
+
+                                Log.w("- Closest POI -", "Facilities: $rankedFacilities")
+
+                                // If the result contains a facility, solve the route from incident to facility.
+                                if (rankedFacilities.isNotEmpty()) {
+                                    val closestFacilityIndex = rankedFacilities[0]
+                                    val route = closestFacilityResult.getRoute(
+                                        closestFacilityIndex,
+                                        0,
+                                    )
+                                    val routeSymbol = SimpleLineSymbol(
+                                        Style.SOLID,
+                                        0xFF0000FF.toInt(),
+                                        2.0f
+                                    )
+                                    val routeGraphic = Graphic(
+                                        route?.routeGeometry,
+                                        routeSymbol,
+                                    )
+
+                                    defaultGraphicsOverlay.graphics.add(routeGraphic)
+                                    Log.w("- Closest POI -", "Updated defaultGraphicsOverlay")
+                                }
+                            } catch (e: Exception) {
+                                Log.w(
+                                    "- Closest POI -",
+                                    "Error solving closest facilities: ${e.message}",
+                                )
+                                result.finishWithError(e)
+                            }
+                        }
+                    } else {
+                        Log.w("- Closest POI -", "Failed to load route parameters")
+                        result.finishWithError(Exception("Failed to load route parameters"))
+                    }
+                } catch (e: Exception) {
+                    Log.w("- Closest POI -", "Error creating route parameters: ${e.message}")
+                    result.finishWithError(e)
+                }
+            }
+        } catch (e: Exception) {
+            Log.w("- Closest POI -", "Failed to determine closest POI: $e")
+            result.finishWithError(e)
+        }
+    }
+
+    private fun onCalculateRoute(call: MethodCall, result: MethodChannel.Result) {
+        // Ensure this is never called without a route service url.
+        if (mapOptions.routeServiceUrl == null) {
+            result.finishWithError(Exception("No route service url provided, check map options"))
+        }
+
+        try {
+            val arguments = call.arguments as Map<String, Any>
+
+            val from = arguments["from"] as Map<String, Any>
+            val fromCoordinates = from["coordinates"] as List<Double>
+            val fromLatLng = LatLng(fromCoordinates[0], fromCoordinates[1])
+
+            val to = arguments["to"] as Map<String, Any>
+            val toCoordinates = to["coordinates"] as List<Double>
+            val toLatLng = LatLng(toCoordinates[0], toCoordinates[1])
+
+            val routeTask = RouteTask(context, mapOptions.routeServiceUrl)
+
+            val parameterFuture = routeTask.createDefaultParametersAsync()
+            parameterFuture.addDoneListener {
+                try {
+                    if (parameterFuture.isDone) {
+                        val routeParams = parameterFuture.get()
+
+                        val stops = arrayListOf(
+                            Stop(
+                                Point(
+                                    fromLatLng.longitude,
+                                    fromLatLng.latitude,
+                                    SpatialReferences.getWgs84()
+                                )
+                            ),
+                            Stop(
+                                Point(
+                                    toLatLng.longitude,
+                                    toLatLng.latitude,
+                                    SpatialReferences.getWgs84()
+                                )
+                            )
+                        )
+
+                        routeParams.apply {
+                            // Apply the From and To coordinates to the parameters.
+                            setStops(stops)
+                            // Set return directions true to return turn-by-turn
+                            // directions in the route's directionManeuvers.
+                            isReturnDirections = true
+                        }
+
+                        val routeFuture = routeTask.solveRouteAsync(routeParams)
+                        routeFuture.addDoneListener {
+                            try {
+                                val taskResult = routeFuture.get()
+                                val route = taskResult.routes[0] as Route
+
+                                // Convert the route into a suitable route result.
+                                val routeResult = RouteResult.fromRoute(route)
+
+                                result.success(routeResult.toJson())
+
+                            } catch (e: Exception) {
+                                result.finishWithError(e)
+                            }
+                        }
+                    } else {
+                        result.finishWithError(Exception("Failed to load route parameters"))
+                    }
+                } catch (e: Exception) {
+                    result.finishWithError(e)
+                }
+            }
+        } catch (e: Exception) {
+            result.finishWithError(e)
+        }
+    }
+
     /**
      * Convert map scale to zoom level
      * https://developers.arcgis.com/documentation/mapping-apis-and-services/reference/zoom-levels-and-scale/#conversion-tool

arcgis_map_sdk_android/android/src/main/kotlin/dev/fluttercommunity/arcgis_map_sdk_android/model/ArcgisMapOptions.kt

@@ -7,6 +7,8 @@ data class ArcgisMapOptions(
     val licenseKey: String?,
     val basemap: BasemapStyle?,
     val vectorTilesUrls: List<String>,
+    val routeServiceUrl: String?,
+    val closestFacilitiesUrl: String?,
     val initialCenter: LatLng,
     val isInteractive: Boolean,
     val zoom: Double,

arcgis_map_sdk_android/android/src/main/kotlin/dev/fluttercommunity/arcgis_map_sdk_android/model/RouteManeuver.kt

@@ -0,0 +1,48 @@
+package dev.fluttercommunity.arcgis_map_sdk_android.model
+
+import com.esri.arcgisruntime.geometry.Point
+import com.esri.arcgisruntime.geometry.Polyline
+import com.esri.arcgisruntime.tasks.networkanalysis.DirectionManeuver
+
+class RouteManeuver private constructor(
+    val paths: List<List<LatLng>>,
+    val directionMessage: String,
+    val durationMinutes: Double,
+) {
+    companion object {
+        fun fromDirectionManeuver(maneuver: DirectionManeuver): RouteManeuver {
+            val directionMessage = maneuver.directionText
+            val estimatedTimeMinutes = maneuver.duration
+
+            return when (maneuver.geometry) {
+                is Point -> {
+                    // The first and last entry are the start and end Point.
+                    val pointGeometry = (maneuver.geometry as Point)
+                    RouteManeuver(
+                        paths = listOf(
+                            listOf(LatLng(pointGeometry.x, pointGeometry.y)),
+                        ),
+                        directionMessage = directionMessage,
+                        durationMinutes = estimatedTimeMinutes,
+                    )
+                }
+
+                is Polyline -> {
+                    // The geometries between the start and end point.
+                    val path = (maneuver.geometry as Polyline).parts.partsAsPoints.map {
+                        listOf(LatLng(it.x, it.y))
+                    }
+                    RouteManeuver(
+                        paths = path,
+                        directionMessage = directionMessage,
+                        durationMinutes = estimatedTimeMinutes,
+                    )
+                }
+
+                else -> throw IllegalArgumentException(
+                    "Unsupported geometry type: ${maneuver.geometry?.javaClass?.name}"
+                )
+            }
+        }
+    }
+}