"}],"short_description":"Different techniques to track a moving dynamic entity with the ArcGIS Maps SDKs for Native Apps.","flexible_content":[{"acf_fc_layout":"content","content":"- \n
- Manually Pan the GeoView<\/em><\/a><\/li>\n
- Custom LocationDataSource<\/em> with MapView.LocationDisplay<\/em><\/a><\/li>\n
- SceneView<\/em> and CameraController<\/em><\/a><\/li>\n<\/ol>\n<\/li>\n
- Summary<\/a><\/li>\n<\/ol>\n"},{"acf_fc_layout":"content","content":"
The Dynamics: DynamicEntity<\/em>, DynamicEntityObservation<\/em>, and DynamicEntityDataSource<\/em><\/h3>\n
Several important classes in the ArcGIS Maps SDKs for Native Apps help manage and track moving entities. When developing a real-world application where live entities are always on the move, it’s essential to understand these core “dynamic” classes: DynamicEntity<\/em><\/a>,\u00a0DynamicEntityObservation<\/em><\/a>, and\u00a0DynamicEntityDataSource<\/em><\/a>.<\/p>\n
A\u00a0DynamicEntity<\/em>\u00a0represents a real-world object, like a vehicle, person, or asset, whose location and attributes can change over time. In real-time tracking applications, dynamic entities are usually the central elements. Each\u00a0DynamicEntity<\/em>\u00a0has historical snapshots, called observations, represented by\u00a0DynamicEntityObservation<\/em>\u00a0objects. An observation captures an entity’s state, including its location and attributes, at a specific point in time. The Native Maps SDK reads these observations from a data stream provided by a\u00a0DynamicEntityDataSource<\/em>\u00a0object, which periodically updates its associated entities with new observations.<\/p>\n
This article explores these “dynamic” objects and how they’re used to simulate and track moving entities.<\/p>\n"},{"acf_fc_layout":"content","content":"
Sample Application<\/h2>\n
You can find a sample application that demonstrates the techniques described in this article on my GitHub repo<\/a>. Source code from this application is referred to in later sections of this article and can be used as a reference for setting up similar code in your apps.<\/p>\n"},{"acf_fc_layout":"image","image":{"ID":2641472,"id":2641472,"title":"FollowEntity","filename":"FollowEntity.png","filesize":315780,"url":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2024\/12\/FollowEntity.png","link":"https:\/\/www.esri.com\/arcgis-blog\/products\/sdk-net\/developers\/track-a-moving-dynamic-entity-with-the-arcgis-maps-sdk-for-native-apps\/followentity","alt":"Sample application demonstrating how to follow a dynamic entity.","author":"350922","description":"Sample application demonstrating how to follow a dynamic entity.","caption":"Follow Entity Sample Application","name":"followentity","status":"inherit","uploaded_to":2639542,"date":"2024-12-26 23:21:53","modified":"2024-12-26 23:22:23","menu_order":0,"mime_type":"image\/png","type":"image","subtype":"png","icon":"https:\/\/www.esri.com\/arcgis-blog\/wp-includes\/images\/media\/default.png","width":810,"height":458,"sizes":{"thumbnail":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2024\/12\/FollowEntity-213x200.png","thumbnail-width":213,"thumbnail-height":200,"medium":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2024\/12\/FollowEntity.png","medium-width":462,"medium-height":261,"medium_large":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2024\/12\/FollowEntity.png","medium_large-width":768,"medium_large-height":434,"large":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2024\/12\/FollowEntity.png","large-width":810,"large-height":458,"1536x1536":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2024\/12\/FollowEntity.png","1536x1536-width":810,"1536x1536-height":458,"2048x2048":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2024\/12\/FollowEntity.png","2048x2048-width":810,"2048x2048-height":458,"card_image":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2024\/12\/FollowEntity.png","card_image-width":810,"card_image-height":458,"wide_image":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2024\/12\/FollowEntity.png","wide_image-width":810,"wide_image-height":458}},"image_position":"center","orientation":"horizontal","hyperlink":"https:\/\/github.com\/gdestigter\/FollowEntity"},{"acf_fc_layout":"content","content":"
This app simulates deliveries for a fictional warehousing company in San Diego, with warehouses scattered around the city. It simulates deliveries from each warehouse to random points throughout the city. Delivery trucks are represented by DynamicEntity<\/em> objects, and their locations are updated periodically using a custom DynamicEntityDataSource<\/em>. To make the simulation more realistic, our custom data source uses an offline route task to create valid driving routes from the warehouse to the delivery point and back. The app lets the user select a truck on the map and follow its movement around the city.<\/p>\n
This sample app leverages the ArcGIS Maps SDK for .NET, though similar applications can be developed using any platform supported by the ArcGIS Maps SDKs for Native Apps. See the developer guide for information about dynamic entities in the Native Maps SDKs: Kotlin<\/a>\u00a0|\u00a0.NET<\/a>\u00a0|\u00a0Qt<\/a>\u00a0|\u00a0Swift<\/a>.<\/p>\n"},{"acf_fc_layout":"content","content":"
![\"ArcGIS](\"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2024\/12\/toolkit-213x200.png\")
<\/p>\nCheck it out!<\/p>\n
Custom Data Sources<\/p>\n
The\u00a0DynamicEntityDataSource<\/em> class in the ArcGIS Maps SDKs for Native Apps serves as the base class for real-time streaming data sources in the Esri platform, such as\u00a0ArcGISStreamService<\/em>. But user code can also extend it to create custom data sources. The sample app used in this article, for instance, creates a custom DynamicEntityDataSource<\/em> to simulate delivery truck progress. It generates driving routes and emits a new observation for each truck at a configurable time interval, including its simulated location. See the corresponding code in the SimulationSource <\/em>class<\/a> from the sample repo. Creating a custom data source like this is extremely useful for testing or demoing an app, as it eliminates the need to connect to a live service.<\/p>\n
For more information, you can refer to an excellent blog post on creating custom data sources: Craft your own dynamic entity data source for ArcGIS Maps SDKs for Native Apps<\/a>.<\/p>\n<\/section>\n"},{"acf_fc_layout":"content","content":"
Following a Single DynamicEntity<\/em><\/h2>\n
For our application to follow a single DynamicEntity<\/em>, the viewpoint of the MapView<\/em><\/a> or SceneView<\/em><\/a> needs to be updated to ensure the entity remains visible as it moves. Let’s look at some techniques to achieve this, highlighting their advantages, disadvantages, and when to apply them in an application.<\/p>\n
Selecting a DynamicEntity<\/em><\/h3>\n
Our sample app uses a selection halo to indicate which truck the user is interested in. To select an entity from the data source, the user taps on a truck symbol on the map. The GeoView.IdentifyLayerAsync<\/em><\/a> method is used to find the DynamicEntityObservation<\/em> associated with the user\u2019s tap point. You\u2019ll see in the code snippet below, that IdentifyLayerAsync<\/em> does not return DynamicEntity<\/em> objects but rather returns individual observations. This is helpful in our case as the user may tap on any observation in the track of the delivery truck they\u2019re interested in. This alleviates the difficulty of tapping on a moving object as the latest observation in the track may be changing quickly and tapping on a previous static observation is easier for the user. Once we have an observation in the track, we get its associated DynamicEntity<\/em> and use the DynamicEntityLayer.<\/em>SelectDynamicEntity<\/em> method to select the entity on the map. When a DynamicEntity<\/em> is selected, the selection halo moves with the entity, so whenever a new observation associated with this entity comes in, the selection moves too. This is an easy way to show the movement of an entity on a map or scene.<\/p>\n
\n\u2295\u00a0Show code …<\/span><\/summary>\n
<\/p>\n
\n\/\/ select a single dynamic entity\r\npublic<\/span> async<\/span> Task Identify<\/span>(Point position, MapPoint? _)\r\n{\r\n _dynamicEntityLayer.ClearSelection();\r\n\r\n var<\/span> result = await<\/span> MapViewController.IdentifyLayerAsync(_dynamicEntityLayer, position, 2d<\/span>);\r\n if<\/span> (result?.GeoElements?.FirstOrDefault() is<\/span> DynamicEntityObservation observation)\r\n {\r\n SelectedEntity = observation.GetDynamicEntity();\r\n if<\/span> (SelectedEntity is<\/span> not null<\/span>)\r\n _dynamicEntityLayer.SelectDynamicEntity(SelectedEntity);\r\n }\r\n}\r\n<\/pre>\n<\/div>\n<\/details>\n<\/p>\n
Now we can look at different ways to update the MapView<\/em> or SceneView<\/em> to keep the selected entity in view as it moves.<\/p>\n"},{"acf_fc_layout":"content","content":"
<\/p>\nCheck it out!<\/p>\n
ArcGIS Maps SDKs for Native Apps Toolkit<\/p>\n
The sample app uses the ArcGIS Maps SDK for .NET Toolkit<\/a> to provide\u00a0some functionality.\u00a0This\u00a0open-source project\u00a0offers\u00a0controls and components\u00a0that help when developing Native Maps SDKs applications.\u00a0In this application, the identify code is wrapped in\u00a0an out-of-the-box\u00a0feature of the\u00a0GeoViewController<\/em>\u00a0MVVM assistant\u00a0class of\u00a0the toolkit.\u00a0This GeoViewController<\/em>\u00a0is bound to our\u00a0GeoView<\/em>, allowing\u00a0the view model code to call methods on the view without\u00a0breaking Model-View-View Model priciples<\/a><\/p>\n
The toolkit provides many other useful components for developing Native Maps SDKs applications. Consider using it in your next application.<\/p>\n<\/section>\n"},{"acf_fc_layout":"content","content":"
Option 1: Manually Pan the GeoView<\/em><\/h3>\n
The first and most obvious option for following a moving DynamicEntity<\/em> is to manually update the viewpoint of the MapView<\/em> or SceneView <\/em>to keep the entity centered in the view whenever its location changes. There are methods on the GeoView <\/em>(the base class for Ma<\/em>pView<\/em> and SceneView<\/em>) that make this straightforward and consistent for both 2D and 3D views.<\/p>\n
You can be notified of changes to a DynamicEntity<\/em> by listening to its DynamicEntityChanged<\/em> event. This event is raised anytime a new observation is received for the DynamicEntity<\/em>. When this event is triggered, you can manually update the GeoView\u2019s<\/em> viewpoint to center on the entity\u2019s new location.<\/p>\n
In the sample, we use the GeoView.SetViewpointAsync<\/em><\/a> method to update the viewpoint whenever the selected DynamicEntity<\/em> changes location. This method allows us to keep the truck centered in the view by performing an animated pan. Alternatively, you can use the SetViewpoint<\/em> <\/a>method to disable the pan animation. There are also many constructors for creating Viewpoints<\/em> that offer various options for setting center, scale, rotation, and 3D camera values. Creative use of these methods can give you fine-grained control of the GeoView\u2019s<\/em> viewpoint in your application. Note that most of these methods are available for both the MapView<\/em> and SceneView<\/em>. For instance, you can pan the view to keep the truck in a corner of the map, showing more of the map in the direction it’s heading. Or you can display a more zoomed-out view based on the truck’s current speed.<\/p>\n
The manual approach has two key benefits: it’s straightforward to implement and gives you full control over the viewpoint. However, this approach also has a drawback: it requires application code to manually update the viewpoint whenever the entity changes. Additionally, automatic updates to the viewpoint at random intervals can disrupt user interactions like panning and zooming, so it’s crucial to consider how this might affect the overall user experience and application flow.<\/p>\n
Here is an example of how to manually follow a moving DynamicEntity<\/em> using the DynamicEntityChanged<\/em> event:<\/p>\n
\n\u2295\u00a0Show code …<\/span><\/summary>\n
<\/p>\n
\nprivate<\/span> void<\/span> FollowSelectedEntity_Manual<\/span>()\r\n{\r\n SelectedEntity.DynamicEntityChanged += SelectedEntity_DynamicEntityChanged;\r\n}\r\n\r\nprivate<\/span> void<\/span> StopFollowingSelectedEntity_Manual<\/span>()\r\n{\r\n SelectedEntity.DynamicEntityChanged -= SelectedEntity_DynamicEntityChanged;\r\n}\r\n\r\nprivate<\/span> async<\/span> void<\/span> SelectedEntity_DynamicEntityChanged<\/span>(object?<\/span> sender, DynamicEntityChangedEventArgs e)\r\n{\r\n if<\/span> (e.ReceivedObservation?.Geometry is<\/span> MapPoint point)\r\n {\r\n GeoView.SetViewpointAsync(new<\/span> Viewpoint(point));\r\n }\r\n}\r\n<\/pre>\n<\/div>\n<\/details>\n"},{"acf_fc_layout":"content","content":"Option 2: Custom LocationDataSource<\/em> with MapView.LocationDisplay<\/em><\/h3>\n
Here is a second approach to following an entity in a 2D map: use the built-in MapView.<\/em>LocationDisplay<\/em><\/a> property to automatically pan the map when the entity location changes. To do this, you can create a custom LocationDataSource<\/em> <\/a>that uses the selected DynamicEntity<\/em> as the source for location updates and then connect the new data source to the MapView.LocationDisplay<\/em> property.<\/p>\n
Custom LocationDataSource<\/em><\/strong><\/h4>\n
Our CustomLocationDataSource<\/em> class below inherits from the LocationDataSource<\/em> class provided by the ArcGIS Maps SDK for .NET. It\u2019s a standalone data source that can provide location updates to the LocationDisplay<\/em> component of the MapView<\/em>. CustomLocationDataSource<\/em> listens for changes to the selected DynamicEntity<\/em> using the DynamicEntityChanged<\/em> event (as mentioned in option #1 above) and emits a location update accordingly.<\/p>\n
\n\u2295\u00a0Show code …<\/span><\/summary>\n
<\/p>\n
\n\/\/ Example code for creating a custom LocationDataSource\r\npublic<\/span> class<\/span> CustomLocationDataSource<\/span> : LocationDataSource\r\n{\r\n private<\/span> DynamicEntity _entity;\r\n\r\n public<\/span> CustomLocationDataSource<\/span>(DynamicEntity entity)\r\n {\r\n _entity = entity;\r\n }\r\n\r\n protected<\/span> override<\/span> Task OnStartAsync<\/span>()\r\n {\r\n _entity.DynamicEntityChanged += Entity_DynamicEntityChanged;\r\n return<\/span> Task.CompletedTask;\r\n }\r\n\r\n protected<\/span> override<\/span> Task OnStopAsync<\/span>()\r\n {\r\n _entity.DynamicEntityChanged -= Entity_DynamicEntityChanged;\r\n return<\/span> Task.CompletedTask;\r\n }\r\n\r\n private<\/span> void<\/span> Entity_DynamicEntityChanged<\/span>(object?<\/span> sender, DynamicEntityChangedEventArgs e)\r\n {\r\n \/\/ Update the location based on the entity's location<\/span>\r\n UpdateLocation(new<\/span> Location((MapPoint)_entity.Geometry,\r\n horizontalAccuracy: 0.0<\/span>, velocity: 1.0<\/span>, course: 0.0<\/span>, isLastKnown: false<\/span>));\r\n }\r\n}\r\n<\/pre>\n<\/div>\n<\/details>\n<\/p>\n
LocationDisplay<\/em><\/strong><\/h4>\n
The\u00a0LocationDisplay<\/em>\u00a0is a built-in component of the Native Maps SDKs, mainly used to show the current device’s location on the map; however, by setting\u00a0LocationDisplay.DataSource<\/em>\u00a0to an instance of the\u00a0CustomLocationDataSource<\/em>\u00a0created above, we can use the\u00a0LocationDisplay<\/em>\u00a0to show the location of our selected\u00a0DynamicEntity<\/em>\u00a0instead. In the code below, we set the\u00a0AutoPanMode<\/em>\u00a0property of the\u00a0LocationDisplay<\/em>\u00a0to\u00a0Recenter<\/em>. This ensures the map automatically pans to keep the entity in view as it moves. The\u00a0LocationDisplay<\/em>\u00a0has many other settings that can be used to customize the display of the entity’s location. For example, our app uses\u00a0WanderEffect<\/em>\u00a0to tell the\u00a0MapView<\/em> to wait until the entity moves a certain amount before triggering a pan of the map. For more information, see the documentation for the LocationDisplay<\/em> class<\/a>.<\/p>\n
\n\u2295\u00a0Show code …<\/span><\/summary>\n
<\/p>\n
\nprivate<\/span> async<\/span> void<\/span> FollowSelectedEntity_LocationDataSource<\/span>()\r\n{\r\n if<\/span> (SelectedEntity is<\/span> not null<\/span>)\r\n {\r\n var<\/span> followSource = new<\/span> EntityLocationDataSource(SelectedEntity);\r\n await<\/span> FollowEntityController.UpdateLocationDisplayAsync(followSource);\r\n }\r\n}\r\n\r\nprivate<\/span> async<\/span> void<\/span> StopFollowingSelectedEntity_LocationDataSource<\/span>()\r\n{\r\n await<\/span> FollowEntityController.UpdateLocationDisplayAsync(null<\/span>);\r\n}\r\n\r\npublic<\/span> async<\/span> Task UpdateLocationDisplayAsync<\/span>(LocationDataSource? dataSource)\r\n{\r\n if<\/span> (mapView.LocationDisplay.DataSource is<\/span> not null<\/span>)\r\n await<\/span> mapView.LocationDisplay.DataSource.StopAsync();\r\n\r\n if<\/span> (dataSource is<\/span> null<\/span>)\r\n {\r\n mapView.LocationDisplay.DataSource = null<\/span>;\r\n mapView.LocationDisplay.IsEnabled = false<\/span>;\r\n return<\/span>;\r\n }\r\n\r\n mapView.LocationDisplay.DataSource = dataSource;\r\n mapView.LocationDisplay.AutoPanMode = LocationDisplayAutoPanMode.Recenter;\r\n mapView.LocationDisplay.InitialZoomScale = mapView.MapScale;\r\n mapView.LocationDisplay.ShowLocation = false<\/span>;\r\n mapView.LocationDisplay.WanderExtentFactor = 0.5d<\/span>;\r\n mapView.LocationDisplay.IsEnabled = true<\/span>;\r\n}\r\n<\/pre>\n<\/div>\n<\/details>\nUsing the built-in LocationDisplay<\/em> is a robust way to track a moving entity as the Native Maps SDK handles panning the map automatically. The underlying API turns off the automatic recenter functionality when the user interacts with the map allowing the user to pan and zoom freely. Additionally, the\u00a0LocationDisplay<\/em>\u00a0comes with built-in symbology for displaying the location on the map, which could be useful in other scenarios, even though our sample application doesn’t utilize it.<\/p>\n
Although creating a custom\u00a0
- Custom LocationDataSource<\/em> with MapView.LocationDisplay<\/em><\/a><\/li>\n