Monitor changes to layer view state

/* Copyright 2025 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.monitorchangestolayerviewstate

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
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.monitorchangestolayerviewstate.screens.MonitorChangesToLayerViewStateScreen

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)

        setContent {
            SampleAppTheme {
                MonitorChangesToLayerViewStateApp()
            }
        }
    }

    @Composable
    private fun MonitorChangesToLayerViewStateApp() {
        Surface(color = MaterialTheme.colorScheme.background) {
            MonitorChangesToLayerViewStateScreen(
                sampleName = getString(R.string.monitor_changes_to_layer_view_state_app_name)
            )
        }
    }
}

/* Copyright 2025 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.monitorchangestolayerviewstate.components

import android.app.Application
import androidx.lifecycle.AndroidViewModel
import androidx.lifecycle.viewModelScope
import com.arcgismaps.geometry.Point
import com.arcgismaps.geometry.SpatialReference
import com.arcgismaps.mapping.ArcGISMap
import com.arcgismaps.mapping.BasemapStyle
import com.arcgismaps.mapping.PortalItem
import com.arcgismaps.mapping.Viewpoint
import com.arcgismaps.mapping.layers.FeatureLayer
import com.arcgismaps.mapping.layers.Layer
import com.arcgismaps.mapping.view.LayerViewStatus
import com.arcgismaps.portal.Portal
import com.esri.arcgismaps.sample.sampleslib.components.MessageDialogViewModel
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.launch

/**
 * ViewModel that creates the map and feature layer, observes load state and exposes
 * simple state flows for UI to display layer visibility and the current layer view status.
 */
class MonitorChangesToLayerViewStateViewModel(app: Application) : AndroidViewModel(app) {
    // The Satellite (MODIS) Thermal Hotspots and Fire Activity portal item with a feature layer.
    private val featureLayer: FeatureLayer by lazy {
        val portalItem = PortalItem(
            portal = Portal("https://www.arcgis.com"),
            itemId = "b8f4033069f141729ffb298b7418b653"
        )
        FeatureLayer.createWithItem(item = portalItem).apply {
            minScale = 1e8
            maxScale = 6e6
        }
    }

    // Map with Topographic basemap and initial viewpoint
    val arcGISMap: ArcGISMap = ArcGISMap(BasemapStyle.ArcGISTopographic).apply {
        initialViewpoint = Viewpoint(
            center = Point(x = -13e6, y = 51e5, spatialReference = SpatialReference.webMercator()),
            scale = 2e7
        )
        // Add the feature layer to the map's operational layers
        operationalLayers.add(featureLayer)

    }

    // Expose whether the layer is visible, UI can trigger flow in updateLayerVisibility().
    private val _layerIsVisibleFlow = MutableStateFlow(true)
    val layerIsVisibleFlow = _layerIsVisibleFlow.asStateFlow()

    // Expose the current LayerViewStatus simple names for the UI
    private val _layerStatusLabelsFlow = MutableStateFlow(listOf("N/A"))
    val layerStatusLabelsFlow = _layerStatusLabelsFlow.asStateFlow()

    // Message dialog for displaying errors
    val messageDialogVM = MessageDialogViewModel()

    init {
        viewModelScope.launch {
            // Load the map which contains the configured feature layer
            arcGISMap.load().onFailure { error ->
                messageDialogVM.showMessageDialog(error)
            }
        }
    }

    /**
     * Called from the MapView's onLayerViewStateChanged callback.
     */
    fun onLayerViewStateChanged(
        layer: Layer,
        layerViewStatusList: List<LayerViewStatus>
    ) {
        // Only observe state of the added feature layer.
        if (layer.id != featureLayer.id) return

        // Convert the current layer view status list
        // to a list of plain strings using ::class.java.simpleName
        _layerStatusLabelsFlow.value = if (layerViewStatusList.isNotEmpty()) {
            layerViewStatusList.map { it::class.java.simpleName }
        } else {
            listOf("N/A")
        }
    }

    /**
     * Toggle visibility of the sample feature layer and update flow state.
     */
    fun updateLayerVisibility(visible: Boolean) {
        _layerIsVisibleFlow.value = visible
        featureLayer.isVisible = visible
    }
}

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

import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Card
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Switch
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import androidx.lifecycle.viewmodel.compose.viewModel
import com.arcgismaps.toolkit.geoviewcompose.MapView
import com.esri.arcgismaps.sample.monitorchangestolayerviewstate.components.MonitorChangesToLayerViewStateViewModel
import com.esri.arcgismaps.sample.sampleslib.components.MessageDialog
import com.esri.arcgismaps.sample.sampleslib.components.SamplePreviewSurface
import com.esri.arcgismaps.sample.sampleslib.components.SampleTopAppBar

/**
 * Main screen layout for the sample app. Observes flows exposed by the ViewModel and
 * wires MapView callbacks back into the ViewModel.
 */
@Composable
fun MonitorChangesToLayerViewStateScreen(sampleName: String) {
    val mapViewModel: MonitorChangesToLayerViewStateViewModel = viewModel()
    // Collect flows from the view model
    val layerIsVisible by mapViewModel.layerIsVisibleFlow.collectAsStateWithLifecycle()
    val layerStatusLabels by mapViewModel.layerStatusLabelsFlow.collectAsStateWithLifecycle()

    Scaffold(
        topBar = { SampleTopAppBar(title = sampleName) },
        content = { padding ->
            Column(
                modifier = Modifier
                    .fillMaxSize()
                    .padding(padding)
            ) {
                // MapView fills the available space
                MapView(
                    modifier = Modifier
                        .weight(1f)
                        .fillMaxWidth(),
                    arcGISMap = mapViewModel.arcGISMap,
                    // Listen for layer view state changes and forward to the view model
                    onLayerViewStateChanged = { layerStateChanged ->
                        mapViewModel.onLayerViewStateChanged(
                            layer = layerStateChanged.layer,
                            layerViewStatusList = layerStateChanged.layerViewState.status.toList()
                        )
                    }
                )
                // Controls are hoisted into a composable function
                LayerControls(
                    layerIsVisible = layerIsVisible,
                    layerStatusLabels = layerStatusLabels,
                    onToggleVisibility = mapViewModel::updateLayerVisibility
                )
            }
            // Show message dialog if the view model reported an error
            mapViewModel.messageDialogVM.apply {
                if (dialogStatus) {
                    MessageDialog(
                        title = messageTitle,
                        description = messageDescription,
                        onDismissRequest = ::dismissDialog
                    )
                }
            }
        }
    )
}

@Composable
private fun LayerControls(
    layerIsVisible: Boolean,
    layerStatusLabels: List<String>,
    onToggleVisibility: (Boolean) -> Unit
) {
    Card(modifier = Modifier.padding(12.dp)) {
        Column(
            modifier = Modifier.padding(12.dp),
            verticalArrangement = Arrangement.spacedBy(12.dp)
        ) {
            Row(
                modifier = Modifier.fillMaxWidth(),
                verticalAlignment = Alignment.CenterVertically,
                horizontalArrangement = Arrangement.SpaceBetween
            ) {
                Text(
                    text = if (layerIsVisible) "Feature layer: Visible" else "Feature layer: Hidden",
                    style = MaterialTheme.typography.titleMedium
                )
                Switch(checked = layerIsVisible, onCheckedChange = onToggleVisibility)
            }

            // Display the current LayerViewState labels
            Row(
                modifier = Modifier.fillMaxWidth(),
                horizontalArrangement = Arrangement.spacedBy(8.dp),
                verticalAlignment = Alignment.CenterVertically
            ) {
                Text(text = "Layer view status:", style = MaterialTheme.typography.titleMedium)
                Text(
                    modifier = Modifier.fillMaxWidth(),
                    text = layerStatusLabels.joinToString(", "),
                    style = MaterialTheme.typography.bodyMedium,
                    textAlign = TextAlign.End
                )
            }
        }
    }
}

@Preview
@Composable
private fun LayerControlsPreview() {
    SamplePreviewSurface {
        LayerControls(
            layerIsVisible = true,
            layerStatusLabels = listOf("Active"),
            onToggleVisibility = { }
        )
    }
}