Add custom dynamic entity data source

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
/* Copyright 2024 Esri
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

package com.esri.arcgismaps.sample.addcustomdynamicentitydatasource.components

import android.app.Application
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.compose.ui.unit.dp
import androidx.lifecycle.AndroidViewModel
import androidx.lifecycle.viewModelScope
import com.arcgismaps.arcgisservices.LabelingPlacement
import com.arcgismaps.mapping.ArcGISMap
import com.arcgismaps.mapping.BasemapStyle
import com.arcgismaps.mapping.GeoElement
import com.arcgismaps.mapping.Viewpoint
import com.arcgismaps.mapping.labeling.LabelDefinition
import com.arcgismaps.mapping.labeling.SimpleLabelExpression
import com.arcgismaps.mapping.layers.DynamicEntityLayer
import com.arcgismaps.mapping.layers.Layer
import com.arcgismaps.mapping.symbology.TextSymbol
import com.arcgismaps.mapping.view.SingleTapConfirmedEvent
import com.arcgismaps.realtime.ConnectionStatus
import com.arcgismaps.realtime.CustomDynamicEntityDataSource
import com.arcgismaps.realtime.DynamicEntityObservation
import com.arcgismaps.toolkit.geoviewcompose.MapViewProxy
import com.esri.arcgismaps.sample.addcustomdynamicentitydatasource.R
import com.esri.arcgismaps.sample.sampleslib.components.MessageDialogViewModel
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.Job
import kotlinx.coroutines.cancelAndJoin
import kotlinx.coroutines.launch
import java.io.File
import kotlin.time.Duration.Companion.milliseconds

class MapViewModel(application: Application) : AndroidViewModel(application) {

    // Keep track of connected status string state.
    var connectionStatusString by mutableStateOf("")
        private set

    // Set connection status string in he UI.
    private fun updateConnectionStatusString(connectionStatus: String) {
        connectionStatusString = connectionStatus
    }

    private val provisionPath: String by lazy {
        application.getExternalFilesDir(null)?.path.toString() + File.separator + application.getString(
            R.string.add_custom_dynamic_entity_data_source_app_name
        )
    }

    // Create a new custom feed provider that processes observations from a JSON file.
    // This takes the path to the simulation file, field name that will be used as the entity id,
    // and the delay between each observation that is processed.
    // In this example we are using a json file as our custom data source.
    // This field value should be a unique identifier for each entity.
    // Adjusting the value for the delay will change the speed at which the entities and their
    // observations are displayed.
    private val feedProvider = CustomEntityFeedProvider(
        fileName = "$provisionPath/AIS_MarineCadastre_SelectedVessels_CustomDataSource.jsonl",
        entityIdField = "MMSI",
        delayDuration = 10.milliseconds
    )

    private val dynamicEntityDataSource = CustomDynamicEntityDataSource(feedProvider).apply {
        // Observe the connection status of the custom data source.
        viewModelScope.launch {
            connectionStatus.collect { connectionStatus ->
                updateConnectionStatusString(
                    when (connectionStatus) {
                        is ConnectionStatus.Connected -> "Connected"
                        is ConnectionStatus.Disconnected -> "Disconnected"
                        is ConnectionStatus.Connecting -> "Connecting"
                        is ConnectionStatus.Failed -> "Failed"
                    }
                )
            }
        }
    }

    // Create the dynamic entity layer using the custom data source.
    private val dynamicEntityLayer = DynamicEntityLayer(dynamicEntityDataSource).apply {
        trackDisplayProperties.apply {
            // Set up the track display properties, these properties will be used to configure the appearance of the track line and previous observations.
            showPreviousObservations = true
            showTrackLine = true
            maximumObservations = 20
        }

        // Define the label expression to be used, in this case we will use the "VesselName" for each of the dynamic entities.
        val simpleLabelExpression = SimpleLabelExpression("[VesselName]")

        // Set the text symbol color and size for the labels.
        val labelSymbol = TextSymbol().apply {
            color = com.arcgismaps.Color.red
            size = 12.0F
        }

        // Add the label definition to the dynamic entity layer and enable labels.
        labelDefinitions.add(LabelDefinition(simpleLabelExpression, labelSymbol).apply {
            // Set the label position.
            placement = LabelingPlacement.PointAboveCenter
        })
        labelsEnabled = true
    }

    val arcGISMap = ArcGISMap(BasemapStyle.ArcGISOceans).apply {
        initialViewpoint = Viewpoint(47.984, -123.657, 3e6)
        // Add the dynamic entity layer to the map.
        operationalLayers.add(dynamicEntityLayer)
    }

    // Create a mapViewProxy that will be used to identify features in the MapView.
    // This should also be passed to the composable MapView this mapViewProxy is associated with.
    val mapViewProxy = MapViewProxy()

    // create a ViewModel to handle dialog interactions
    val messageDialogVM: MessageDialogViewModel = MessageDialogViewModel()

    fun dynamicEntityDataSourceConnect() =
        viewModelScope.launch { dynamicEntityDataSource.connect() }

    fun dynamicEntityDataSourceDisconnect() =
        viewModelScope.launch { dynamicEntityDataSource.disconnect() }

    // Keep track of the currently selected GeoElement.
    var selectedGeoElement by mutableStateOf<GeoElement?>(null)
        private set

    // Keep track of the most recent observation string.
    var observationString by mutableStateOf("")
        private set

    // Keep track of the Coroutine Scope where observations on being collected on, so that it can
    // be cancelled on subsequent identifies.
    private var observationsJob: Job? = null

    /**
     * Identifies the tapped screen coordinate in the provided [singleTapConfirmedEvent]
     */
    fun identify(singleTapConfirmedEvent: SingleTapConfirmedEvent) {
        viewModelScope.launch {
            // If collecting observations on a previous identify, now cancel and stop collecting.
            observationsJob?.cancelAndJoin()
            // identify the cluster in the feature layer on the tapped coordinate
            mapViewProxy.identify(
                dynamicEntityLayer as Layer,
                screenCoordinate = singleTapConfirmedEvent.screenCoordinate,
                tolerance = 12.dp,
                maximumResults = 1
            ).onSuccess { result ->
                (result.geoElements.firstOrNull() as? DynamicEntityObservation)?.let { observation ->
                    // Set the identified dynamic entity, used to display the callout.
                    selectedGeoElement = observation.dynamicEntity
                    // Define a new CoroutineScope to collect observation events on.
                    observationsJob = launch(Dispatchers.IO) {
                        // Collect observation events and update the observation string accordingly.
                        observation.dynamicEntity?.dynamicEntityChangedEvent?.collect { dynamicEntityChangedInfo ->
                            // Parse the observation attributes, filter out empty values, and remove
                            // starting and ending {}s.
                            observationString = dynamicEntityChangedInfo
                                .receivedObservation?.attributes?.filter {
                                    it.value.toString().isNotEmpty() && !it.key.contains("globalid")
                                }.toString()
                                .replaceFirst("{", " ")
                                .removeSuffix("}")
                                .replace(",", "\n")
                        }
                    }
                    // If no observation is found, set the selectedGeoElement to null.
                } ?: run {
                    selectedGeoElement = null
                    observationString = "Waiting for a new observation ..."
                }
            }.onFailure { error ->
                messageDialogVM.showMessageDialog(
                    title = "Error identifying results: ${error.message.toString()}",
                    description = error.cause.toString()
                )
            }
        }
    }
}