"}],"short_description":"You can create a custom dynamic entity data source to wrap a data feed for use in your ArcGIS Maps SDKs for Native Apps applications.","flexible_content":[{"acf_fc_layout":"content","content":"If you\u2019ve developed an app using ArcGIS Maps SDK for Native Apps, then you\u2019ve probably worked with features and graphics. Have you met their\u00a0geoelement\u00a0<\/a>cousin, dynamic entity? As part of the geoelement family, dynamic entities have attributes and geometry. They\u2019re used to represent observations from a data stream to enable some really cool real-time workflows like:<\/p>\n See the developer guide for information about dynamic entities in the Native Maps SDKs:\u00a0Java<\/a>\u00a0|\u00a0Kotlin<\/a>\u00a0|\u00a0.NET<\/a>\u00a0|\u00a0Qt<\/a>\u00a0|\u00a0Swift<\/a>.<\/p>\n","image_reference":false,"layout":"standard","image_reference_figure":"","snippet":"","spotlight_name":"","section_title":"","position":"Right","spotlight_image":false},{"acf_fc_layout":"content","content":" In this article,<\/span> I\u2019ll give an overview of dynamic entity data sources and step through the process of creating one. I\u2019ll use\u00a0a .NET MAUI example<\/a>\u00a0created using ArcGIS Maps SDK for .NET and C# to highlight these steps. While the code and some of the implementation details differ across Native Maps SDKs, the basic concepts are the same. If you\u2019re new to dynamic entities or want to simply work with them out-of-the-box, you might prefer my previous blog. See\u00a0Eight essential real-time techniques with ArcGIS Maps SDKs for Native Apps<\/a> for a more general discussion. However, if you want to craft your own custom dynamic entity data source, read on!<\/p>\n When working with dynamic entities, a great deal of work is managed by the dynamic entities API. A The initial release of the dynamic entities API at version 200.1 only supported\u00a0ArcGIS stream services<\/a> as a data source. With the 200.2 release, however, Native Maps SDKs also support custom dynamic entity data sources. This gives you the ability to wrap just about any data feed as a Perhaps your app can use an existing ArcGIS stream service as a dynamic entity data source. If you have access to ArcGIS GeoEvent Server<\/a>\u00a0or\u00a0ArcGIS Velocity<\/a>\u00a0you can easily create your own. In those cases, you may not benefit much from creating a custom dynamic entity data source. GeoEvent Server and ArcGIS Velocity both allow you to configure a data source using a variety of data feed formats. You can then expose the data as an ArcGIS stream service.\u00a0Supported feed types<\/a>\u00a0include AWS, Azure, HTTP polling, and many more. If, however, you have a data feed that is not in a standard format or you cannot easily expose your feed with an ArcGIS stream service, a custom data source is a great option.<\/p>\n OK … creating a custom dynamic entity data source might not be “simple”. Of course, the complexity involved depends on the nature of the data feed and your requirements. But, good news! Once you create your data source, it fits into the dynamic entities API to leverage additional functionality. For example, you can display it using a dynamic entities layer, get notifications for data updates, and manage the local data cache. For dynamic entities that move, a dynamic entity layer shows tracks of previous locations and has options for track display.<\/p>\n"},{"acf_fc_layout":"content","content":" I created a .NET MAUI app to illustrate a custom\u00a0 When observations come in, corresponding stations flash red to indicate a bike left or blue to indicate a bike returned.<\/p>\n The bike information comes from the\u00a0CityBikes API<\/a>. This is a REST API that sends information in a JSON response. The app uses a timer to periodically request information from the service. It then deserializes the response into classes that represent the stations (point locations and relevant attributes).<\/p>\n <\/p>\n"},{"acf_fc_layout":"image","image":{"ID":2068792,"id":2068792,"title":"bike-app-maui","filename":"bike-app-maui.png","filesize":404598,"url":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2023\/09\/bike-app-maui.png","link":"https:\/\/www.esri.com\/arcgis-blog\/products\/sdk-net\/developers\/craft-your-own-dynamic-entity-data-source-for-arcgis-maps-sdks-for-native-apps\/bike-app-maui","alt":"A multi-platform .NET MAUI app that shows bike availability at rental stations.","author":"8512","description":"","caption":"A multi-platform .NET MAUI app that shows bike availability at rental stations.","name":"bike-app-maui","status":"inherit","uploaded_to":2068762,"date":"2023-09-07 00:22:04","modified":"2023-09-12 17:08:10","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":995,"height":606,"sizes":{"thumbnail":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2023\/09\/bike-app-maui-213x200.png","thumbnail-width":213,"thumbnail-height":200,"medium":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2023\/09\/bike-app-maui.png","medium-width":429,"medium-height":261,"medium_large":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2023\/09\/bike-app-maui.png","medium_large-width":768,"medium_large-height":468,"large":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2023\/09\/bike-app-maui.png","large-width":995,"large-height":606,"1536x1536":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2023\/09\/bike-app-maui.png","1536x1536-width":995,"1536x1536-height":606,"2048x2048":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2023\/09\/bike-app-maui.png","2048x2048-width":995,"2048x2048-height":606,"card_image":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2023\/09\/bike-app-maui-763x465.png","card_image-width":763,"card_image-height":465,"wide_image":"https:\/\/www.esri.com\/arcgis-blog\/app\/uploads\/2023\/09\/bike-app-maui.png","wide_image-width":995,"wide_image-height":606}},"image_position":"center","orientation":"horizontal","hyperlink":"https:\/\/github.com\/ThadT\/bike-rental-stations-maui"},{"acf_fc_layout":"content","content":" To create a custom dynamic entity data source, follow these basic steps.<\/strong><\/p>\n You can then consume your custom dynamic entity data source in your ArcGIS Maps SDK app.<\/strong><\/p>\n Start by creating a new class to represent your dynamic entity data source. The class must inherit from the\u00a0 My class requests updates for a specified city at a specified interval. It has variables to store the CityBikes URL for the selected city and a timer ( <\/p>\n In the constructor for my class, I accept values for the city name and URL (strings) and an update interval in seconds (int). I store those values in the appropriate variables and then define a function to run when the timer interval expires. The <\/p>\n <\/p>\n"},{"acf_fc_layout":"content","content":" Your custom\u00a0 It might be tempting to make a call to\u00a0 The consuming code calls this method after the connection is established (I\u2019ll show you that code later).<\/p>\n"},{"acf_fc_layout":"content","content":" You need to provide metadata about some important aspects of your data source. Specifically, the schema (fields) to include for observations, a field name that uniquely identifies dynamic entities, and the spatial reference used for their geometry. Notice that geometry is not defined as a field in the schema. Instead, you create points from the latitude and longitude values. You then add an observation and provide the location and attributes. I\u2019ll describe that process later in the article. As of this writing (version 200.2), only point geometry is supported for dynamic entities.<\/p>\n Define data source metadata with a\u00a0 <\/p>\n The values for observations might come directly from the data feed (for example\u00a0StationName<\/em>,\u00a0Address<\/em>, and\u00a0BikesAvailable<\/em>\u00a0attributes). They may also come from values you provide or calculate yourself (for example, the\u00a0InventoryChange<\/em>\u00a0and\u00a0ImageUrl<\/em>).<\/p>\n"},{"acf_fc_layout":"content","content":" The details for how updates from the data feed are read and processed can vary according to your implementation. I won\u2019t go into detail about specifics for my\u00a0 To start with, I check the connection status before requesting updates to avoid a potential exception. You cannot add observations to your data source if it\u2019s not in a connected state.<\/p>\n When you read from the feed, you\u2019ll create a dictionary of attributes ( <\/p>\n For the bike updates, I discovered I was adding an observation for each bike station on every request. I added observations even when there was no change for a station. This was pretty inefficient since I was adding many more \u201cupdates\u201d than I needed to. I also realized that this made my notification events essentially meaningless. They fired whether a change had occurred in the available bikes for that station or not.<\/p>\n The solution was to use a dictionary to store the previous set of values. I could then compare each station\u2019s previous inventory with the updated values. If the values for available bikes or e-bikes change, I record the inventory change and add the observation. If the values are the same for available bikes, I skip the update. For the consumer of the data source, this means notifications only arrive when a station\u2019s values change.<\/p>\n <\/p>\n\n
\n
It’s about to get real (time)<\/h3>\n
DynamicEntityDataSource<\/code><\/a> provides data (observations) as a data stream, delivering a constant series of updates. Once connected to such a data source, dynamic entities automatically update as new observations come from the stream. This information includes updated locations and attributes. Attributes describe the properties of each entity. For moving things, these may be speed, heading, or altitude. For our bike stations, attributes describe the available bike inventory. A dynamic entity layer from the data source can manage the display of dynamic entities on the map.<\/p>\nDynamicEntityDataSource<\/code><\/a> for use in your app.<\/p>\n"},{"acf_fc_layout":"content","content":"Why create a custom data source?<\/h2>\n
From zero to dynamic in five steps<\/h3>\n
Example: Bike rental stations<\/h2>\n
DynamicEntityDataSource<\/code><\/a>. The app shows bike rental stations for a few major cities. These stations are, well, stationary, so you won\u2019t see anything \u201cdynamic\u201d about their locations on the map. Attributes like bike availability, however, are updated frequently, so these values are dynamic. The color of the stations indicates the number of bikes available. Station attributes show the last inventory update time and the change in available bikes (+\/-) since the previous update. The page shows a summary of available bikes for the entire city that updates as observations come in. The user can select favorite stations to quickly see inventory updates for those stations.<\/p>\n\n
DynamicEntityDataSource<\/code><\/a> base class<\/li>\n\n
DynamicEntityLayer<\/code> to display the data source<\/a><\/li>\nCreate a class for your data source<\/h2>\n
DynamicEntityDataSource<\/code><\/a>\u00a0base class and override a handful of methods. I describe the details of these overrides in a bit. My class (CityBikesDataSource<\/code>) consumes a data feed that shows available bikes for rental stations in some major cities.<\/p>\nIDispatcherTimer<\/code><\/a>) to periodically get updates. I also store the city name and a dictionary of the last observations received. This allows me to evaluate the change in bike inventory between updates. These are all details specific to my implementation and could vary greatly on your data feed and use case.<\/p>\n\u2295\u00a0Show code …<\/span><\/summary>\n
\r\ninternal<\/span> class<\/span> CityBikesDataSource<\/span> : DynamicEntityDataSource\r\n{\r\n \/\/ Timer to request updates at a given interval.<\/span>\r\n private<\/span> readonly<\/span> IDispatcherTimer _getBikeUpdatesTimer = Application.Current.Dispatcher.CreateTimer();\r\n \/\/ REST endpoint for a city in the CityBikes API (http:\/\/api.citybik.es\/).<\/span>\r\n private<\/span> readonly<\/span> string<\/span> _cityBikesUrl;\r\n \/\/ Previous observations for bike stations (to evaluate change).<\/span>\r\n private<\/span> readonly<\/span> Dictionary<string<\/span>, Dictionary<string<\/span>, object<\/span>>> _previousObservations = new<\/span>();\r\n \/\/ Name of the city.<\/span>\r\n private<\/span> readonly<\/span> string<\/span> _cityName;\r\n<\/pre>\n<\/div>\n<\/details>\nPullBikeUpdates()<\/code> function contains the logic to send a request to the REST endpoint, deserialize the results, and add observations to the data source.<\/p>\n\u2295\u00a0Show code …<\/span><\/summary>\n
public<\/span> CityBikesDataSource(string<\/span> cityName, string<\/span> cityBikesUrl,\r\n int<\/span> updateIntervalSeconds)\r\n {\r\n \/\/ Store the name of the city.<\/span>\r\n _cityName = cityName;\r\n \/\/ Store the timer interval (how often to request updates from the URL).<\/span>\r\n _getBikeUpdatesTimer.Interval = TimeSpan.FromSeconds(updateIntervalSeconds);\r\n \/\/ URL for a specific city's bike rental stations.<\/span>\r\n _cityBikesUrl = cityBikesUrl;\r\n \/\/ Set the function that will run at each timer interval.<\/span>\r\n _getBikeUpdatesTimer.Tick += (s, e) => _ = PullBikeUpdates(); \r\n }\r\n<\/pre>\n<\/div>\n<\/details>\nConnect to a data feed<\/h2>\n
DynamicEntityDataSource<\/code><\/a>\u00a0must override the\u00a0OnConnectAsync<\/code><\/a>\u00a0method. This is where you put any logic required to connect to the data feed. For my\u00a0CityBikesDataSource<\/code>\u00a0class, I simply start the timer so updates will start coming in at the specified interval.<\/p>\n protected<\/span> override<\/span> Task OnConnectAsync(CancellationToken cancellationToken)\r\n {\r\n \/\/ Start the timer to pull updates periodically.<\/span>\r\n _getBikesTimer.Start();\r\n \r\n\r\n return<\/span> Task.CompletedTask;\r\n }\r\n<\/pre>\n<\/div>\nPullBikeUpdates()<\/code>\u00a0here to get an initial set of observations. Otherwise, the user has to wait until the next timer interval before anything appears on the map, right? Unfortunately, you cannot add observations until the data source is connected (when this override completes). To handle this dilemma, I added a public method to populate the initial set of dynamic entities. I\u2019ve spared you the details here. Refer to the\u00a0bike-rental-stations-maui<\/a>\u00a0project on GitHub if you\u2019re interested.<\/p>\n public<\/span> async<\/span> Task GetInitialBikeStations()\r\n {\r\n \/\/ Exit if the data source is not connected.<\/span>\r\n if<\/span> (this<\/span>.ConnectionStatus != ConnectionStatus.Connected) { return<\/span>; }\r\n\r\n \/\/ <Logic here to add dynamic entity observations><\/span>\r\n }\r\n<\/pre>\n<\/div>\nDefine metadata about your data source<\/h2>\n
DynamicEntityDataSourceInfo<\/code><\/a>\u00a0object. Return it from an override of the\u00a0OnLoadAsync()<\/code><\/a>\u00a0method.<\/p>\n\u2295\u00a0Show code …<\/span><\/summary>\n
protected<\/span> override<\/span> Task<DynamicEntityDataSourceInfo> OnLoadAsync()\r\n {\r\n \/\/ When the data source is loaded, create metadata that defines:<\/span>\r\n \/\/ - A schema (fields) for the observations (bike stations)<\/span>\r\n \/\/ - Which field uniquely identifies entities (StationID)<\/span>\r\n \/\/ - The spatial reference for the station locations (WGS84)<\/span>\r\n var<\/span> fields = new<\/span> List<Field>\r\n {\r\n new<\/span> Field(FieldType.Text, \"StationID\"<\/span>, \"\"<\/span>, 50),\r\n new<\/span> Field(FieldType.Text, \"StationName\"<\/span>, \"\"<\/span>, 125),\r\n new<\/span> Field(FieldType.Text, \"Address\"<\/span>, \"\"<\/span>, 125),\r\n new<\/span> Field(FieldType.Text, \"TimeStamp\"<\/span>, \"\"<\/span>, 50),\r\n new<\/span> Field(FieldType.Float32, \"Longitude\"<\/span>, \"\"<\/span>, 0),\r\n new<\/span> Field(FieldType.Float32, \"Latitude\"<\/span>, \"\"<\/span>, 0),\r\n new<\/span> Field(FieldType.Int32, \"BikesAvailable\"<\/span>, \"\"<\/span>, 0),\r\n new<\/span> Field(FieldType.Int32, \"EBikesAvailable\"<\/span>, \"\"<\/span>, 0),\r\n new<\/span> Field(FieldType.Int32, \"EmptySlots\"<\/span>, \"\"<\/span>, 0),\r\n new<\/span> Field(FieldType.Text, \"ObservationID\"<\/span>, \"\"<\/span>, 50),\r\n new<\/span> Field(FieldType.Int32, \"InventoryChange\"<\/span>, \"\"<\/span>, 0),\r\n new<\/span> Field(FieldType.Text, \"ImageUrl\"<\/span>, \"\"<\/span>, 255),\r\n new<\/span> Field(FieldType.Text, \"CityName\"<\/span>, \"\"<\/span>, 50)\r\n };\r\n var<\/span> info = new<\/span> DynamicEntityDataSourceInfo(\"StationID\"<\/span>, fields)\r\n {\r\n SpatialReference = SpatialReferences.Wgs84\r\n };\r\n\r\n return<\/span> Task.FromResult(info);\r\n }\r\n<\/pre>\n<\/div>\n<\/details>\nRead data from the feed<\/h2>\n
CityBikesDataSource<\/code>\u00a0class. If you\u2019re interested, check out the\u00a0code on GitHub<\/a>.<\/p>\n if<\/span> (this<\/span>.ConnectionStatus != ConnectionStatus.Connected) { return<\/span>; }\r\n<\/pre>\n<\/div>\nDictionary<string, object><\/code><\/a>) and a location (MapPoint<\/code><\/a>) for each observation. You then store the observation by calling\u00a0AddObservation()<\/code><\/a>\u00a0and passing the attributes and location.<\/p>\n\u2295\u00a0Show code …<\/span><\/summary>\n
\/\/ --Code here to get a set of updates from the feed\u2014-<\/span>\r\n\r\n \/\/ Process each update.<\/span>\r\n foreach<\/span> (var<\/span> update in<\/span> bikeUpdates)\r\n {\r\n var<\/span> attributes = new<\/span> Dictionary<string<\/span>, object<\/span>>\r\n {\r\n { \"StationID\"<\/span>, update.StationInfo.StationID },\r\n { \"StationName\"<\/span>, update.StationName },\r\n { \"Address\"<\/span>, update.StationInfo.Address },\r\n { \"TimeStamp\"<\/span>, update.TimeStamp },\r\n { \"Longitude\"<\/span>, update.Longitude },\r\n { \"Latitude\"<\/span>, update.Latitude },\r\n { \"BikesAvailable\"<\/span>, update.BikesAvailable },\r\n { \"EBikesAvailable\"<\/span>, update.StationInfo.EBikesAvailable },\r\n { \"EmptySlots\"<\/span>, update.EmptySlots },\r\n { \"ObservationID\"<\/span>, update.ObservationID },\r\n { \"InventoryChange\"<\/span>, 0 },\r\n { \"ImageUrl\"<\/span>, \"\"<\/span> },\r\n { \"CityName\"<\/span>, _cityName } \r\n };\r\n \/\/ Create a MapPoint for the location from the lat\/long values.<\/span>\r\n var<\/span> location = new<\/span> MapPoint(update.Longitude, update.Latitude, SpatialReferences.Wgs84);\r\n\r\n \/\/ Add the observation to the data source.<\/span>\r\n AddObservation(location, attributes);\r\n }\r\n<\/pre>\n<\/div>\n<\/details>\n\u2295\u00a0Show code …<\/span><\/summary>\n
\/\/ Check if the update has different values for BikesAvailable or EBikesAvailable.<\/span>\r\n if<\/span> ((int<\/span>)attributes[\"BikesAvailable\"<\/span>] != (int<\/span>)lastObservation[\"BikesAvailable\"<\/span>] ||\r\n (int<\/span>)attributes[