smap_flutter 1.5.15

sMap for Flutter: maps from the sMap service in Flutter apps, with styles, labels in any language, clustered points, lines, areas and 3D buildings.

Changelog

1.5.15 — 2026-11-01

• Custom markers can be attached to a point layer (attachTo): a marker shows only while the point with its key is drawn on its own — it disappears into a cluster with its point and comes back when the cluster splits, and hides while the point layer is hidden, out of its zoom range, or the point is gone or being dragged. A marker without handlers of its own lets taps through to the point under it. map.drawnPoints(layerId) answers the keys of a point layer's points drawn on their own now.

1.5.12 — 2026-10-31

• Version aligned with Web SDK 1.5.12; no change in this SDK.

1.5.11 — 2026-10-31

• Version aligned with Web SDK 1.5.11; no change in this SDK.

1.5.10 — 2026-10-31

• Version aligned with Web SDK 1.5.10; no change in this SDK.

1.5.9 — 2026-10-31

• Version aligned with Web SDK 1.5.9; no change in this SDK (the 1.5.9 options for classic-style maps are Web only, see MOBILE-SDK-SPEC.md).

1.5.8 — 2026-10-31

• The menu of piled points lists only features at the very spot of the one answering (its coordinate to six decimals); features only overlapping it, each at its own spot, are not listed and the top one answers alone.

1.5.7 — 2026-10-31

• The list of piled custom markers shows its rows in natural order of their text: numbers by value (2 before 10), words alphabetically ignoring case, mixed texts part by part ("A2" before "A10"); equal texts keep their order. Piled points of native layers follow the Android and iOS SDKs' same order.

1.5.6 — 2026-10-31

• Comes with Web SDK 1.5.6 (popups over every control and always wholly inside the map); no change in this package.

1.5.5 — 2026-10-30

• Taps answer the point or custom marker as drawn: a tap counts a feature only within its circle, icon box or widget box plus a small tolerance (SMapOptions.tapTolerance, 6 logical pixels by default), the one containing the tap first, then the nearest, the top one on a tie. A tap beside a pin no longer opens its neighbour.
• Points or markers piled on the tap point are listed in a small menu at the tap; choosing one calls its layer's tap handler, dismissing does nothing, and the camera never moves. overlap: SMapOverlap(label: …) on point and custom marker layers names the rows; SMapOverlap(enabled: false) lets the top one answer without a list.

1.5.2 — 2026-10-30

• Comes with Web SDK 1.5.2 (pins on web maps answer where they are drawn, piled pins are listed, popups move neither the map nor the page); no change in this package.

1.5.1 — 2026-10-30

• No change from 1.5.0; released with the iOS, macOS and Android packages, which first carry the 1.5.0 additions in this version.

1.5.0 — 2026-10-30

• The map gaps G15–G37 (1.5.0), forwarded to the Android and iOS SDKs: fitBounds / fitLayers with padding, bearing, pitch and duration; getCenter, getZoom, getBearing, getPitch, getBounds, jumpTo, easeTo, zoomIn, zoomOut, project, unproject, resize; the map's events (on / off / once / events, with preventDefault given when a listener is added) and the unavailable event with its notice; layer onHover, onDoubleClick, onContextMenu, idProperty, hoverState and states; per-feature …Value options, dashes, sort keys, headings, SDF icon colours, label options and arrows by share; featuresAt; setFeatureState, featureState, removeFeatureState; openTooltip, closeTooltip, openFeaturePopup; moveFeature and updateFeature (custom markers move smoothly in Flutter); images with a pixel ratio and SDF, addImageUrl, hasImage, addGlyphImage; addCircles; SMapGeo.area, centroid, pointOnFeature, circle, union, buffer, simplify, selfIntersects in Dart; the drawing tool's drawing stream, measuring, self-crossing checks, snapping to layers, looks per shape and setProperties; export to PNG or JPEG with the custom markers; tinted models; heat map blur and minOpacity; the search tool (addSearchTool, SMapTool.search); cooperativeGestures; Google in the layer switcher.
• featuresAt now answers the SDK layers' features; the engine's own hit test it was before is engineFeaturesAt.

1.2.16 — 2026-10-30

• Released with Web SDK 1.2.16 (numbered pins drawn sooner on the web); no change in this package.

• Licence: from this version the package is licensed under the Superroute SDK License — see LICENSE and open.superroute.ca/developer/license. Versions published before keep the licence they were published with.

1.2.15 — 2026-10-29

• Plan editor: an insert confirmed right after its stop was dropped no longer waits for the stop's legs, so it is answered sooner (OPEN-ROUTE-EDIT E26, revised). An insert confirmed less than 300 ms after the point was prepared is sent at once; later, while the point is not known to be measured, the server is asked to wait 1.1 s minus the time since the point was sent (100 ms to 1 s), and the wait is given up 200 ms after that, never later than 1.2 s. A point already measured, or one the snapshot's opening sent, is never waited for. New options insertWaitMinAge (300 ms) and insertWaitBudget (1100 ms) (Duration); insertWaitTimeout stays the upper limit.

1.2.12 — 2026-10-29

• The native SDKs come from their new published locations: Android ca.superroute:smap from the sMap Maven repository (https://goodneo-solutions.github.io/smap-sdk-releases/maven, added by the plugin) instead of JitPack, iOS from the binary Swift package https://github.com/Goodneo-Solutions/smap-sdk-releases. The package page links to https://open.superroute.ca/developer/smap.

1.2.11 — 2026-10-29

• Plan editor: a stop dropped on the map or an address picked for an insert has its legs measured before the insert is confirmed, so the insert is answered faster (OPEN-ROUTE-EDIT E25 / E26). SMapPlanEditor.prepareInsert (and the option insertWaitTimeout) sends the points to the open snapshot at once, on the standard path, each once per snapshot, never with an error; a job of no route dropped on a route does this by itself. An insert of such a point first asks the server to wait for it, at most 1.2 s, and is sent then either way.

1.2.10 — 2026-10-29

• Clusters drawn as views no longer stay on screen after their points have split (the native SDKs 1.2.10 this package uses).

1.2.9 — 2026-10-29

• Released with Web SDK 1.2.9 (HTML clusters no longer stay after their points split); no change in this package.

1.2.8 — 2026-10-29

• Released with Web SDK 1.2.8 (popups over custom markers again); no change in this package.

1.2.7 — 2026-10-29

• Custom markers in their tens of thousands: snapshot draws each widget's look once into an image and the map draws the images like points. Taps, tooltips, dragging, opacity and zIndex work as before; markers that look the same share one image (snapshotKey).
• Points with an image each: iconProperty names the property holding each point's image, with iconAnchor, iconOffset, iconOpacityProperty and sortProperty; addImage takes the image's pixelRatio, removeImage forgets one.

1.2.6 — 2026-10-29

• Released with Web SDK 1.2.6 (an area selection answers every layer it was asked for); no change in this package.

1.2.5 — 2026-10-29

• Released with Web SDK 1.2.5 (the canvas map pans smoothly under software graphics); no change in this package.

1.2.2 — 2026-10-29

• Plan editor: opening a distance snapshot sends the plan's points (every job location and vehicle start and end), so the legs between them are measured ahead and edits are answered faster. Nothing to change in your code; servers that do not read the points work as before.

1.2.1 — 2026-10-28

• Released with Web SDK 1.2.1 (pins with numbers drawn as one image); no change in this package.

1.2.0 — 2026-10-28

• The map is the sMap Android or iOS SDK's own, shown in the widget: every call goes to the same call of the native SDK, so the map behaves exactly as in a native app. Your layers, styles, basemap overrides, tools, offline regions and layer descriptions work as before, and regions downloaded with 1.1 stay on the device.
• Custom markers: your own widgets at points (addCustomMarkers), built when they come into view, moved by new data, dragged after a long press (SMapDrag), with tooltips and taps.
• Dragging drawn points after a long press; tooltips while a finger rests on a point, line or area; labels written along lines.
• Clusters as a ring of their points' colours (clusterRing), or as your own widgets (clusterBuilder).
• Heat maps (addHeatmap); hillshading of elevation tiles (setTerrain; reported to onUnsupported as terrain where the phone's engine draws no relief).
• Imagery in place of the street map (setBaseImagery), Google's base maps with your own Map Tiles session (setGoogleBase), and a layer switcher tool (SMapTool.layerSwitcher).
• Your widgets in the map's corners (addControl); two maps kept on the same view (syncWith); tiles you paint with a Canvas (addCanvasTiles); glTF 3D models at points (addModels).
• A drawing and editing tool (drawTool: polygons, rectangles, circles, lines, points, holes, undo) and area selection (selectArea, a box or a free shape).
• Geometry helpers (SMapGeo: distance, length, bounds, point in polygon, nearest point on a line, polylines) and the map's camera geometry (toScreen, toLatLng, camera, cameraChanges, moveCamera).
• For 1.1 apps:
  • SMapController.engine is gone (there is no maplibre_gl controller any more); LatLng and CameraPosition are the SDK's own classes with the same fields.
  • iOS: the app uses Swift Package Manager (flutter config --enable-swift-package-manager); the SDK is not made for CocoaPods.
  • An app that also uses maplibre_gl itself gets two versions of the map engine; use one.
  • httpClient and store still work: the native SDK's own requests and node order go through them.

1.1.7 — 2026-10-28

• Plan editor: faster edits through sMap's fast path, with no code change. When your plan editor token answer names a fast path, or your map key's configuration on sMap does, every edit goes there and falls back to the Open Platform by itself when the fast path asks for it, fails, or does not answer within 2 seconds (5 seconds for a refine). Quota and rate-limit refusals stay final. state().path and SMapPlanChange.path say which path answered; fastPath: false keeps every edit on the Open Platform; controller.planEditor reads a map key's configuration from the map's own sMap service.

1.1.6 — 2026-10-28

• Plan editor: edit a plan of routes on the map, each edit priced by the Open Platform's plan editing. controller.planEditor(…) draws the routes, numbered stops and unassigned jobs; a stop is moved by long-pressing it and dragging it before another stop or onto a route's line, with the drop priced as a preview while it is dragged. The panel (editing.panelTool() as a map tool, or SMapPlanPanel anywhere), in 14 languages, shows the totals, each route's stops with arrivals and violations, undo / redo, refine around locked stops, removing and placing jobs and the positions offered for a placed job. Calls use a plan editor token from your own server or a map key with plan editing switched on, name the app as the platform reports it, and keep working when the distance snapshot expires. SMapPlanEditor also works without a map.
• Map tools: the tools control is now the last button of the map's toolbar by default — the corner of your zoom tool (else your compass tool, else the top left) — and stays last when tools join that corner. Its corner is drawn above the map's other corners and your own tool widgets, and the panel opens towards the middle of the map. A corner you give (SMapToolsOptions(control: SMapToolPosition.topRight), …) is kept as before; the new SMapToolPosition.toolbar names the default and is for the tools control only.
• Map tools: your data layers can be tools — SMapTool.layers('stops', ['stops', 'stop-labels'], label: 'Stops'). Hiding the tool hides the layers, showing it shows them, with the same tools control, controller calls, saved state and change events as other tools. One tool may cover several layers; a layer removed later leaves the tool harmless.

1.1.5 — 2026-10-28

• Map tools: SMap(tools: [...]) lays widgets over the map that can be shown and hidden one by one or all at once — your own widget in a corner (or placed by you with SMapToolPosition.none), or a control the SDK makes with SMapTool.kind: zoom buttons, a compass, a scale bar (metric, or imperial where miles are used) and a locate button (it uses the device's position only while the app holds the location permission). A tools control (one button, top right by default) lists every tool with Show all and Hide all; the controller switches them too (setToolVisible, setToolsVisible, tools()). A hidden tool stays built and keeps its state. The attribution and the sMap badge always stay. The starting state is SMapOptions.tools.hidden and every change is reported to onChange, so the app decides whether and where to keep it. A map without tools is unchanged.
• Android: an app using the SDK no longer closes as soon as the map loads. The plugin handed the map engine its HTTP client before the engine was set up, the engine refused it and the first map request failed.

1.1.2 — 2026-10-27

• The version follows the shared 1.1.2 release; no change of its own.

1.1.1 — 2026-10-27

• Offline regions (Android and iOS): SMapOffline downloads an area of the map (bounding box, zooms, scheme or custom style, language) as one file and keeps it on the device: estimate (size, and whether this app may download; counts nothing), download (continues where it stopped when called again), list, get, refresh, remove, usage. A region is shown for 30 days from its download; after that its map data is removed until it is refreshed.
• SMapOptions.offlineRegion shows a downloaded region from the start, offlineFallback shows one containing the centre when no node answers (on by default) and offlineAutoRefresh downloads again regions in their last 3 days while online (on by default). SMapController.offline, useOfflineRegion and useOnline switch at any time; your layers are kept.
• Downloads need a token, or a map key whose Allow offline regions switch is on, and are billed as the region's tiles.
• Adds the path_provider dependency (where regions are kept).

1.1.0 — 2026-10-27

• Standard style layers and sources: addSource, removeSource, sources, addStyleLayer (in a slot, below a layer, with a zIndex), setPaint, setLayout, setFilter and getStyleLayer, for your layers and the basemap's. Layers copied from other map tools work as they are, and every change is kept across style, language and token changes. removeLayer removes any kind of layer.
• Slots: bottom, roads, labels and top place a layer in the basemap; addPoints, addLines and addPolygons take slot and before too, and slots() says where each slot begins. A layer without a slot draws on top, as before.
• Basemap classes: setBasemap shows, hides and recolours water, land, parks, land use, airports, roads by level, rail, buildings, boundaries, labels and points of interest, and changes line widths; basemap() reads the settings back; the basemap option applies them from the start.
• Saved custom styles: the customStyle option and setStyle('custom:<id>'); setStyle also takes a scheme name.
• Files: formats.read reads KML, KMZ, GPX, encoded polylines (precision 5 and 6), WKT, WKB, CSV, TopoJSON and GeoJSON on the device, into the same features as every other sMap SDK and the service; formats.write, toGeoJSON and toKML write them out; addData draws a file as areas, lines and points; convert has the service convert large files.
• Simplestyle colours, widths and opacities in the data are drawn when a layer gives none of its own.
• External layers: addRasterLayer, addWmsLayer, addWmtsLayer, addVectorTiles (PMTiles included) and addArcGisLayer, each with its attribution. Google and Bing tiles are refused.
• rasterUrl gives the service's raster tiles of any style as a template for other tools.
• toJSON and loadLayers: the layer description shared with the other sMap SDKs.

1.0.6 — 2026-10-27

• Version 1.0.6, released with the Web SDK's drawn-in pin numbers and vehicle markers; no change to this SDK.

1.0.5 — 2026-10-27

• Version 1.0.5, released with the Web SDK popups; no change to the Flutter SDK.

1.0.2 — 2026-10-27

• Version 1.0.2, released with the Web SDK fix; no change to the Flutter SDK.

1.0.1 — 2026-10-27

• Every map shows a small sMap badge (the sMap icon and name on a semi-transparent pill that reads on all five colour schemes) in its bottom-right corner, just left of the attribution button. It is always shown and is not a link; the map data attribution stays visible. The rendering engine's own logo stays off.
• The package description starts with "sMap"; the README starts with the sMap logo.
• Published on pub.dev as smap_flutter (install with smap_flutter: ^1.0.1); the git dependency still works.

1.0.0 (unreleased)

• First release: the SMap widget and SMapController.
• Five colour schemes (light, white, grayscale, dark, black) and labels in any language, switched at run time without losing your layers.
• Short-lived tokens: pass a token, or a getToken callback that is asked for a new one two minutes before each expires.
• Reads from the nearest service node, remembered for an hour, and moves on to the next node when one fails.
• Keeps working while the service address is down: the last node list is kept for 30 days and asked of any known node, and the nodes option names nodes known in advance.
• Points (clustered or not, circles or icons, labels), lines and areas (flat or extruded), with draw order, visibility, data replacement, fitting the camera and tap handlers.
• 3D buildings.
• Map keys: the new apiKey option uses a key that can ship inside the app, checked against the app's identity (Android package name and signing certificate, iOS bundle id).