Add custom dynamic entity data source

/* 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

import android.content.Intent
import android.os.Bundle
import com.esri.arcgismaps.sample.sampleslib.DownloaderActivity

class DownloadActivity : DownloaderActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        downloadAndStartSample(
            Intent(this, MainActivity::class.java),
            // get the app name of the sample
            getString(R.string.add_custom_dynamic_entity_data_source_app_name),
            // ArcGIS Portal item containing the json file of observations of marine vessels in
            // the Pacific North West
            listOf(
                "https://www.arcgis.com/home/item.html?id=a8a942c228af4fac96baa78ad60f511f"
            )
        )
    }
}

/* 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

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Surface
import androidx.compose.runtime.Composable
import com.arcgismaps.ApiKey
import com.arcgismaps.ArcGISEnvironment
import com.esri.arcgismaps.sample.sampleslib.theme.SampleAppTheme
import com.esri.arcgismaps.sample.addcustomdynamicentitydatasource.screens.MainScreen

class MainActivity : ComponentActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // authentication with an API key or named user is
        // required to access basemaps and other location services
        ArcGISEnvironment.apiKey = ApiKey.create(BuildConfig.ACCESS_TOKEN)

        enableEdgeToEdge()
        setContent {
            SampleAppTheme {
                SampleApp()
            }
        }
    }

    @Composable
    private fun SampleApp() {
        Surface(
            color = MaterialTheme.colorScheme.background
        ) {
            MainScreen(
                sampleName = getString(R.string.add_custom_dynamic_entity_data_source_app_name)
            )
        }
    }
}

/* 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 com.arcgismaps.data.Field
import com.arcgismaps.data.FieldType
import com.arcgismaps.geometry.Point
import com.arcgismaps.geometry.SpatialReference
import com.arcgismaps.realtime.CustomDynamicEntityDataSource
import com.arcgismaps.realtime.DynamicEntityDataSourceInfo
import kotlinx.coroutines.CancellationException
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.Job
import kotlinx.coroutines.NonCancellable
import kotlinx.coroutines.cancelAndJoin
import kotlinx.coroutines.channels.BufferOverflow
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.MutableSharedFlow
import kotlinx.coroutines.flow.asSharedFlow
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import kotlinx.serialization.json.Json
import kotlinx.serialization.json.JsonObject
import kotlinx.serialization.json.JsonPrimitive
import kotlinx.serialization.json.contentOrNull
import kotlinx.serialization.json.double
import kotlinx.serialization.json.jsonObject
import kotlinx.serialization.json.jsonPrimitive
import java.io.File
import java.io.IOException
import kotlin.time.Duration

/**
 * Implements the [CustomDynamicEntityDataSource.EntityFeedProvider] interface on the [CustomDynamicEntityDataSource] to provide
 * feed events from a JSON file for the custom dynamic entity data source. Uses a buffered reader to
 * process lines in the file and emit feed events for each observation. Uses the [onConnect] to
 * start reading the file and [onDisconnect] to cancel the coroutine job as required.
 *
 * @param fileName The path to the simulation file.
 * @param entityIdField The field name that will be used as the entity id.
 * @param delayDuration The delay between each observation that is processed.
 */
class CustomEntityFeedProvider(
    fileName: String,
    private val entityIdField: String,
    private val delayDuration: Duration
) : CustomDynamicEntityDataSource.EntityFeedProvider {

    private val scope = CoroutineScope(Dispatchers.Default)

    private val observationsFile = File(fileName)

    // Create a shared flow to emit feed events.
    private val _feed = MutableSharedFlow<CustomDynamicEntityDataSource.FeedEvent>(
        extraBufferCapacity = Int.MAX_VALUE,
        onBufferOverflow = BufferOverflow.DROP_OLDEST
    )

    // Expose the feed as a shared flow.
    override val feed = _feed.asSharedFlow()

    // Keep track of the feed job to allow us to properly cancel it when needed.
    private var feedJob: Job? = null

    /**
     * Called when the data source is connected. Checks for presence of the observations file and
     * starts reading the file asynchronously. It is important to process the custom data source asynchronously and let the `onConnect` function return immediately.
     */
    override suspend fun onConnect() {
        if (!observationsFile.exists()) {
            throw IOException("Observations file does not exist.")
        }

        readObservationsFileAsync()
    }

    /**
     * Called when the data source is disconnected. Cancels the coroutine job that processes the custom data source.
     */
    override suspend fun onDisconnect() {
        feedJob?.cancelAndJoin()
        feedJob = null
    }

    /**
     * Called when the data source is loaded. Defines the Dynamic Entity Data Source info.
     */
    override suspend fun onLoad(): DynamicEntityDataSourceInfo {
        return DynamicEntityDataSourceInfo(entityIdField, schema).apply {
            spatialReference = SpatialReference.wgs84()
        }
    }

    /**
     * Reads the observations file asynchronously and emits feed events for each observation.
     */
    private fun readObservationsFileAsync() {
        feedJob = scope.launch(Dispatchers.IO) {
            try {
                // While no call to cancel the job has been made.
                observationsFile.bufferedReader().use { reader ->
                    // Read the next line from the file.
                    for (line in reader.lines()) {
                        // Adjusting the value for the delay will change the speed at which the
                        // entities and their observations are displayed.
                        delay(delayDuration)
                        // Emit the next observation.
                        _feed.tryEmit(processNextObservation(line))
                    }
                }
            } catch (e: Exception) {
                if (e is CancellationException) {
                    // Don't swallow CancellationException to maintain structured concurrency when the coroutine is cancelled.
                    throw e
                }
                withContext(NonCancellable) {
                    // Signal that an error occurred. This will change the CustomDynamicEntityDataSource's connectionStatus to Failed.
                    _feed.tryEmit(
                        CustomDynamicEntityDataSource.FeedEvent.ConnectionFailure(
                            e,
                            true
                        )
                    )
                }
            }
        }
    }

    /**
     * Processes the given line from the observations file and returns a new observation.
     */
    private fun processNextObservation(readLine: String): CustomDynamicEntityDataSource.FeedEvent.NewObservation {

        // Get the next observation from the file and parse it as a JSON object.
        val jsonElement = Json.parseToJsonElement(readLine)

        // Get the x and y coordinates of the observation.
        val point =
            (jsonElement.jsonObject["geometry"] as? JsonObject)?.let { geometryJsonObject ->
                // Create a new MapPoint from the x and y coordinates of the observation.
                Point(
                    geometryJsonObject["x"]!!.jsonPrimitive.double,
                    geometryJsonObject["y"]!!.jsonPrimitive.double
                )
            }
        // Get the dictionary of attributes from the observation using the field names as keys.
        val attributes = mutableMapOf<String, Any?>()
        (jsonElement.jsonObject["attributes"] as? JsonObject)?.let { attributesJsonObject ->
            attributesJsonObject.entries.forEach { (key, value) ->
                if (value is JsonPrimitive) {
                    attributes[key] = value.contentOrNull
                }
            }
        }
        // Return a new observation with the point and attributes.
        return CustomDynamicEntityDataSource.FeedEvent.NewObservation(
            point,
            attributes
        )
    }

    /**
     * Defines the schema for the custom data source.
     */
   private val schema: List<Field> by lazy {
        listOf(
            Field(FieldType.Text, "MMSI", "", 256),
            Field(FieldType.Float64, "BaseDateTime", "", 8),
            Field(FieldType.Float64, "LAT", "", 8),
            Field(FieldType.Float64, "LONG", "", 8),
            Field(FieldType.Float64, "SOG", "", 8),
            Field(FieldType.Float64, "COG", "", 8),
            Field(FieldType.Float64, "Heading", "", 8),
            Field(FieldType.Text, "VesselName", "", 256),
            Field(FieldType.Text, "IMO", "", 256),
            Field(FieldType.Text, "CallSign", "", 256),
            Field(FieldType.Text, "VesselType", "", 256),
            Field(FieldType.Text, "Status", "", 256),
            Field(FieldType.Float64, "Length", "", 8),
            Field(FieldType.Float64, "Width", "", 8),
            Field(FieldType.Text, "Cargo", "", 256),
            Field(FieldType.Text, "globalid", "", 256)
        )
    }
}

/* 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()
                )
            }
        }
    }
}

/* 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.screens

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.sizeIn
import androidx.compose.material3.Button
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.unit.dp
import androidx.lifecycle.viewmodel.compose.viewModel
import com.arcgismaps.toolkit.geoviewcompose.MapView
import com.arcgismaps.toolkit.geoviewcompose.theme.CalloutDefaults
import com.esri.arcgismaps.sample.addcustomdynamicentitydatasource.R
import com.esri.arcgismaps.sample.addcustomdynamicentitydatasource.components.MapViewModel
import com.esri.arcgismaps.sample.sampleslib.components.MessageDialog
import com.esri.arcgismaps.sample.sampleslib.components.SampleTopAppBar

/**
 * Main screen layout for the sample app
 */
@Composable
fun MainScreen(sampleName: String) {
    // Create a ViewModel to handle MapView interactions.
    val mapViewModel: MapViewModel = viewModel()
    // Keep track of the state of a connect/disconnect button.
    var isConnected by remember { mutableStateOf(true) }

    Scaffold(
        topBar = { SampleTopAppBar(title = sampleName) },
        content = {
            Column(
                modifier = Modifier
                    .fillMaxSize()
                    .padding(it),
                horizontalAlignment = Alignment.CenterHorizontally
            ) {
                // Show the current connection status.
                Row {
                    Text(text = "Connection status: ")
                    Text(
                        text = mapViewModel.connectionStatusString,
                        color = if (mapViewModel.connectionStatusString.contains("Connected"))
                            Color.Green else MaterialTheme.colorScheme.onBackground
                    )
                }
                MapView(
                    modifier = Modifier
                        .fillMaxSize()
                        .weight(1f),
                    mapViewProxy = mapViewModel.mapViewProxy,
                    arcGISMap = mapViewModel.arcGISMap,
                    onSingleTapConfirmed = mapViewModel::identify,
                    content = {
                        mapViewModel.selectedGeoElement?.let { selectedGeoElement ->
                            Callout(
                                modifier = Modifier.sizeIn(maxWidth = 250.dp),
                                geoElement = selectedGeoElement,
                                // Optional parameters to customize the callout appearance.
                                shapes = CalloutDefaults.shapes(
                                    calloutContentPadding = PaddingValues(4.dp)
                                ),
                                colorScheme = CalloutDefaults.colors(
                                    backgroundColor = MaterialTheme.colorScheme.background,
                                    borderColor = MaterialTheme.colorScheme.outline
                                )
                            ) {
                                // Callout content:
                                Column {
                                    Text(
                                        text = mapViewModel.observationString,
                                        style = MaterialTheme.typography.labelSmall
                                    )
                                }
                            }
                        }
                    }
                )
                Button(
                    onClick = {
                        if (isConnected) {
                            mapViewModel.dynamicEntityDataSourceDisconnect()
                        } else {
                            mapViewModel.dynamicEntityDataSourceConnect()
                        }
                        isConnected = !isConnected
                    }) {
                    Text(
                        text = stringResource(if (!isConnected) R.string.connect else R.string.disconnect)
                    )
                }
                // Display a MessageDialog with any error information
                mapViewModel.messageDialogVM.apply {
                    if (dialogStatus) {
                        MessageDialog(
                            title = messageTitle,
                            description = messageDescription,
                            onDismissRequest = ::dismissDialog
                        )
                    }
                }
            }
        }
    )
}