Augment reality to collect data

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

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.augmentrealitytocollectdata.screens.AugmentRealityToCollectDataScreen

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 {
                AugmentRealityToCollectDataApp()
            }
        }
    }

    @Composable
    private fun AugmentRealityToCollectDataApp() {
        Surface(color = MaterialTheme.colorScheme.background) {
            AugmentRealityToCollectDataScreen(
                sampleName = getString(R.string.augment_reality_to_collect_data_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.augmentrealitytocollectdata.components

import android.app.Application
import android.content.Context
import android.widget.Toast
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.lifecycle.AndroidViewModel
import androidx.lifecycle.viewModelScope
import com.arcgismaps.Color
import com.arcgismaps.data.ServiceFeatureTable
import com.arcgismaps.geometry.Point
import com.arcgismaps.mapping.ArcGISScene
import com.arcgismaps.mapping.Basemap
import com.arcgismaps.mapping.BasemapStyle
import com.arcgismaps.mapping.ElevationSource
import com.arcgismaps.mapping.layers.FeatureLayer
import com.arcgismaps.mapping.symbology.SimpleMarkerSceneSymbol
import com.arcgismaps.mapping.symbology.SimpleMarkerSceneSymbolStyle
import com.arcgismaps.mapping.view.Graphic
import com.arcgismaps.mapping.view.GraphicsOverlay
import com.arcgismaps.mapping.view.SingleTapConfirmedEvent
import com.arcgismaps.mapping.view.SurfacePlacement
import com.arcgismaps.toolkit.ar.WorldScaleSceneViewProxy
import com.arcgismaps.toolkit.ar.WorldScaleVpsAvailability
import com.esri.arcgismaps.sample.sampleslib.components.MessageDialogViewModel
import kotlinx.coroutines.channels.BufferOverflow
import kotlinx.coroutines.flow.MutableSharedFlow
import kotlinx.coroutines.flow.sample
import kotlinx.coroutines.launch

class AugmentRealityToCollectDataViewModel(app: Application) : AndroidViewModel(app) {
    private val basemap = Basemap(BasemapStyle.ArcGISHumanGeography)
    // The AR tree survey service feature table
    private val featureTable = ServiceFeatureTable("https://services2.arcgis.com/ZQgQTuoyBrtmoGdP/arcgis/rest/services/AR_Tree_Survey/FeatureServer/0")
    private val featureLayer = FeatureLayer.createWithFeatureTable(featureTable)
    val arcGISScene = ArcGISScene(basemap).apply {
        // an elevation source is required for the scene to be placed at the correct elevation
        // if not used, the scene may appear far below the device position because the device position
        // is calculated with elevation
        baseSurface.elevationSources.add(ElevationSource.fromTerrain3dService())
        baseSurface.backgroundGrid.isVisible = false
        baseSurface.opacity = 0.0f
        // add the AR tree survey feature layer.
        operationalLayers.add(featureLayer)
    }

    // The graphics overlay which shows marker symbols.
    val graphicsOverlay = GraphicsOverlay().apply {
        sceneProperties.surfacePlacement = SurfacePlacement.Absolute
    }

    var isVpsAvailable by mutableStateOf(false)

    val worldScaleSceneViewProxy = WorldScaleSceneViewProxy()

    // Create a message dialog view model for handling error messages
    val messageDialogVM = MessageDialogViewModel()

    var isDialogOptionsVisible by mutableStateOf(false)
        private set

    // The current marker graphic representing the user's selection
    private var treeMarker : Graphic? = null

    // A MutableSharedFlow that emits Point locations of the viewpoint camera
    val viewpointCameraLocationFlow = MutableSharedFlow<Point>(
        extraBufferCapacity = 1,
        onBufferOverflow = BufferOverflow.DROP_OLDEST
    )

    init {
        viewModelScope.launch {
            arcGISScene.load().onFailure { messageDialogVM.showMessageDialog(it) }
        }
        periodicallyPollVpsAvailability()
    }

    // Adds a marker to the graphics overlay based on a single tap event
    fun addMarker(singleTapConfirmedEvent: SingleTapConfirmedEvent) {
        // Remove all graphics from the graphics overlay
        graphicsOverlay.graphics.clear()
        singleTapConfirmedEvent.mapPoint.let { point ->
            // Create a new marker graphic at the specified point with a diamond symbol
            val newMarker = Graphic(
                point,
                SimpleMarkerSceneSymbol(
                    SimpleMarkerSceneSymbolStyle.Diamond,
                    Color.yellow,
                    height = 1.0,
                    width = 1.0,
                    depth = 1.0
                )
            )
            treeMarker = newMarker
            graphicsOverlay.graphics.add(newMarker)
        }
    }

    // Adds a feature to represent a tree to the tree survey service feature table.
    fun addTree(context: Context, health: TreeHealth){
        treeMarker?.let { treeMarker ->
            // Set up the feature attributes
            val featureAttributes = mapOf<String, Any>(
                "Health" to health.value,
                "Height" to 3.2,
                "Diameter" to 1.2,
            )

            // Retrieve the marker's geometry as a Point
            val point = (treeMarker.geometry as? Point) ?: run {
                messageDialogVM.showMessageDialog("Something went wrong")
                return@let
            }

            // Create a new feature at the point
            val feature = featureTable.createFeature(featureAttributes, point)

            // Add the feature to the feature table
            viewModelScope.launch {
                featureTable.addFeature(feature)
                    .onSuccess {
                        // Upload changes from the local feature table to the feature service
                        featureTable.applyEdits()
                            .onSuccess { showToast(context, "Successfully added tree data!")}
                            .onFailure { e -> messageDialogVM.showMessageDialog(e) }
                    }.onFailure { e -> messageDialogVM.showMessageDialog(e) }
            }

            // Resets the feature's attributes and geometry to match the data source, discarding unsaved changes.
            feature.refresh()
        }
    }

    // Emits the camera location if it is not at (0.0, 0.0).
    fun onCurrentViewpointCameraChanged(cameraLocation: Point){
        if (cameraLocation.x != 0.0 && cameraLocation.y != 0.0) {
            viewpointCameraLocationFlow.tryEmit(cameraLocation)
        }
    }

    // Collects viewpoint camera locations once in 10 seconds and checks for VPS availability
    private fun periodicallyPollVpsAvailability(){
        viewModelScope.launch {
            viewpointCameraLocationFlow
                .sample(10_000)
                .collect { location ->
                    worldScaleSceneViewProxy.checkVpsAvailability(location.y, location.x).onSuccess {
                        isVpsAvailable = it == WorldScaleVpsAvailability.Available
                    }
                }
        }
    }

    /**
     * Displays a dialog for adding tree data if a marker exists
     */
    fun showDialog(context: Context){
        if (treeMarker == null) {
            showToast(context, "Please create marker by tapping on the screen")
            return
        }
        isDialogOptionsVisible = true
    }

    fun hideDialog(){
        isDialogOptionsVisible = false
    }
}

/**
 * Represents the health status of a tree.
 *
 * @property value The numerical value associated with the health status.
 */
enum class TreeHealth(val value: Short){
    Dead(0),
    Distressed(5),
    Healthy(10),
}

private fun showToast(context: Context, message: String) {
    Toast.makeText(context, message, Toast.LENGTH_LONG).show()
}

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

import android.content.Context
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Add
import androidx.compose.material3.Button
import androidx.compose.material3.Card
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.FloatingActionButton
import androidx.compose.material3.Icon
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.saveable.rememberSaveable
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.platform.LocalContext
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.text.LinkAnnotation
import androidx.compose.ui.text.SpanStyle
import androidx.compose.ui.text.TextLinkStyles
import androidx.compose.ui.text.buildAnnotatedString
import androidx.compose.ui.text.withLink
import androidx.compose.ui.unit.dp
import androidx.compose.ui.window.Dialog
import androidx.core.content.edit
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import androidx.lifecycle.viewmodel.compose.viewModel
import com.arcgismaps.LoadStatus
import com.arcgismaps.toolkit.ar.WorldScaleSceneView
import com.arcgismaps.toolkit.ar.WorldScaleSceneViewStatus
import com.arcgismaps.toolkit.ar.WorldScaleTrackingMode
import com.arcgismaps.toolkit.ar.rememberWorldScaleSceneViewStatus
import com.esri.arcgismaps.sample.augmentrealitytocollectdata.BuildConfig
import com.esri.arcgismaps.sample.augmentrealitytocollectdata.R
import com.esri.arcgismaps.sample.augmentrealitytocollectdata.components.AugmentRealityToCollectDataViewModel
import com.esri.arcgismaps.sample.augmentrealitytocollectdata.components.TreeHealth
import com.esri.arcgismaps.sample.sampleslib.components.MessageDialog
import com.esri.arcgismaps.sample.sampleslib.components.SampleDialog
import com.esri.arcgismaps.sample.sampleslib.components.SampleTopAppBar

private const val KEY_PREF_ACCEPTED_PRIVACY_INFO = "ACCEPTED_PRIVACY_INFO"

/**
 * Main screen layout for the sample app
 */
@Composable
fun AugmentRealityToCollectDataScreen(sampleName: String) {
    val augmentedRealityViewModel: AugmentRealityToCollectDataViewModel = viewModel()

    var initializationStatus by rememberWorldScaleSceneViewStatus()

    val context = LocalContext.current

    val hasNonDefaultAPIKey = BuildConfig.GOOGLE_API_KEY != "DEFAULT_GOOGLE_API_KEY"
    // Initialize the world scale tracking mode based on whether a google API key is provided
    val worldScaleTrackingMode = remember {
        when {
            hasNonDefaultAPIKey -> { WorldScaleTrackingMode.Geospatial() }
            else -> { WorldScaleTrackingMode.World() }
        }
    }

    var displayCalibrationView by remember { mutableStateOf(false) }

    val sharedPreferences = LocalContext.current.getSharedPreferences("", Context.MODE_PRIVATE)
    var acceptedPrivacyInfo by rememberSaveable {
        mutableStateOf(
            sharedPreferences.getBoolean(
                KEY_PREF_ACCEPTED_PRIVACY_INFO,
                false
            )
        )
    }
    var showPrivacyInfo by rememberSaveable { mutableStateOf(!acceptedPrivacyInfo) }

    Scaffold(
        topBar = { SampleTopAppBar(title = sampleName) },
        floatingActionButton = {
            Column {
                if (!augmentedRealityViewModel.isDialogOptionsVisible) {
                    FloatingActionButton(
                        modifier = Modifier.padding(bottom = 20.dp, end = 12.dp),
                        onClick = { augmentedRealityViewModel.showDialog(context) }
                    ) { Icon(Icons.Filled.Add, contentDescription = "Add tree") }
                }
                if (worldScaleTrackingMode is WorldScaleTrackingMode.World) {
                    FloatingActionButton(
                        modifier = Modifier
                            .align(Alignment.End)
                            .padding(bottom = 20.dp, end = 12.dp),
                        onClick = { displayCalibrationView = true }) {
                        Icon(
                            painter = painterResource(R.drawable.baseline_straighten_24), "Show calibration view"
                        )
                    }
                }
            }
        },
        content = {
            if (showPrivacyInfo) {
                PrivacyInfoDialog(
                    hasCurrentlyAccepted = acceptedPrivacyInfo,
                    onUserResponse = { accepted ->
                        acceptedPrivacyInfo = accepted
                        sharedPreferences.edit { putBoolean(KEY_PREF_ACCEPTED_PRIVACY_INFO, accepted) }
                        showPrivacyInfo = false
                    }
                )
            }
            if (!acceptedPrivacyInfo) {
                Column(
                    modifier = Modifier.fillMaxSize(),
                    verticalArrangement = Arrangement.Center,
                    horizontalAlignment = Alignment.CenterHorizontally
                ) {
                    Text(text = "Privacy Info not accepted")
                    Button(onClick = { showPrivacyInfo = true }) {
                        Text(text = "Show Privacy Info")
                    }
                }
            } else {
                Box(
                    modifier = Modifier
                        .fillMaxSize()
                        .padding(it),
                ) {
                    WorldScaleSceneView(
                        arcGISScene = augmentedRealityViewModel.arcGISScene,
                        modifier = Modifier.fillMaxSize(),
                        onInitializationStatusChanged = { status ->
                            initializationStatus = status
                        },
                        worldScaleTrackingMode = worldScaleTrackingMode,
                        worldScaleSceneViewProxy = augmentedRealityViewModel.worldScaleSceneViewProxy,
                        graphicsOverlays = listOf(augmentedRealityViewModel.graphicsOverlay),
                        onSingleTapConfirmed = augmentedRealityViewModel::addMarker,
                        onCurrentViewpointCameraChanged = { camera ->
                            augmentedRealityViewModel.onCurrentViewpointCameraChanged(camera.location)
                        },
                    ) {
                        Box(modifier = Modifier.fillMaxSize()) {
                            if (worldScaleTrackingMode is WorldScaleTrackingMode.World) {
                                if (displayCalibrationView) {
                                    CalibrationView(
                                        onDismiss = { displayCalibrationView = false },
                                        modifier = Modifier.align(Alignment.BottomCenter),
                                    )
                                }
                            }
                        }
                    }

                    if (augmentedRealityViewModel.isDialogOptionsVisible) {
                        TreeHealthDialog(
                            onOptionSelected = { selectedOption ->
                                augmentedRealityViewModel.addTree(context ,selectedOption)},
                            onDismissRequest = augmentedRealityViewModel::hideDialog
                        )
                    }

                    if (worldScaleTrackingMode is WorldScaleTrackingMode.Geospatial) {
                        Box(
                            modifier = Modifier
                                .fillMaxWidth()
                                .background(Color.Gray.copy(alpha = 0.5f))
                                .padding(8.dp),
                            contentAlignment = Alignment.Center
                        ) {
                            Text(
                                text = if (augmentedRealityViewModel.isVpsAvailable) {
                                    "VPS available"
                                } else {
                                    "VPS unavailable"
                                },
                                color = Color.White
                            )
                        }
                    }

                    when (val status = initializationStatus) {
                        is WorldScaleSceneViewStatus.Initializing -> {
                            // Display a message indicating the initialization status
                            TextWithScrim(
                                if (worldScaleTrackingMode is WorldScaleTrackingMode.Geospatial) {
                                    "Initializing AR in geospatial mode..."
                                } else {
                                    "Initializing AR in world mode..."
                                }
                            )
                        }

                        is WorldScaleSceneViewStatus.Initialized -> {
                            val sceneLoadStatus =
                                augmentedRealityViewModel.arcGISScene.loadStatus.collectAsStateWithLifecycle().value
                            when (sceneLoadStatus) {
                                is LoadStatus.Loading, LoadStatus.NotLoaded -> {
                                    // The scene may take a while to load, so show a progress indicator
                                    Box(
                                        modifier = Modifier
                                            .fillMaxSize(),
                                        contentAlignment = Alignment.Center
                                    ) {
                                        CircularProgressIndicator()
                                    }
                                }

                                is LoadStatus.FailedToLoad -> {
                                    TextWithScrim("Failed to load world scale AR scene: " + sceneLoadStatus.error)
                                }

                                is LoadStatus.Loaded -> {} // Display the main content of the AR scene once it has successfully loaded.
                            }
                        }

                        is WorldScaleSceneViewStatus.FailedToInitialize -> {
                            TextWithScrim(
                                text = "World scale AR failed to initialize: " + (status.error.message ?: status.error)
                            )
                        }
                    }
                }
            }

            augmentedRealityViewModel.messageDialogVM.apply {
                if (dialogStatus) {
                    MessageDialog(
                        title = messageTitle,
                        description = messageDescription,
                        onDismissRequest = ::dismissDialog
                    )
                }
            }
        }
    )
}

/**
 * Displays the provided [text] on top of a half-transparent gray background.
 */
@Composable
private fun TextWithScrim(text: String) {
    Column(
        modifier = Modifier
            .background(Color.Gray.copy(alpha = 0.5f))
            .fillMaxSize(),
        verticalArrangement = Arrangement.Center,
        horizontalAlignment = Alignment.CenterHorizontally
    ) {
        Text(text = text)
    }
}

/**
 * Displays a dialog for selecting the health status of a tree.
 */
@Composable
fun TreeHealthDialog(
    onOptionSelected: (TreeHealth) -> Unit,
    onDismissRequest: () -> Unit
) {
    SampleDialog(onDismissRequest = onDismissRequest) {
        Text("Add Tree ", style = MaterialTheme.typography.titleLarge)
        Text("How healthy is this tree?", style = MaterialTheme.typography.titleMedium)
        Spacer(modifier = Modifier.height(10.dp))
        TreeHealth.entries.forEach { option ->
            Button(
                onClick = {
                    onOptionSelected(option)
                    onDismissRequest()
                },
                modifier = Modifier
                    .fillMaxWidth()
                    .height(48.dp)
            ) {
                Text(
                    text = option.name,
                    style = MaterialTheme.typography.bodyMedium
                )
            }
        }
        Row(modifier = Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.End) {
            TextButton(onClick = onDismissRequest) { Text("Dismiss") }
        }
    }
}

/**
 * An alert dialog that asks the user to accept or deny
 * [ARCore's privacy requirements](https://developers.google.com/ar/develop/privacy-requirements).
 */
@Composable
private fun PrivacyInfoDialog(
    hasCurrentlyAccepted: Boolean,
    onUserResponse: (accepted: Boolean) -> Unit
) {
    Dialog(onDismissRequest = {
        onUserResponse(hasCurrentlyAccepted)
    }) {
        Card {
            Column(
                modifier = Modifier.padding(16.dp)
            ) {
                LegalTextArCore()
                Spacer(Modifier.height(16.dp))
                LegalTextGeospatial()
                Row(
                    modifier = Modifier.fillMaxWidth(),
                    horizontalArrangement = Arrangement.SpaceBetween
                ) {
                    TextButton(onClick = {
                        onUserResponse(false)
                    }) {
                        Text(text = "Decline")
                    }

                    TextButton(onClick = {
                        onUserResponse(true)
                    }) {
                        Text(text = "Accept")
                    }
                }
            }
        }
    }
}

/**
 * Displays the required privacy information for use of ARCore
 */
@Composable
private fun LegalTextArCore() {
    val textLinkStyle =
        TextLinkStyles(style = SpanStyle(color = Color.Blue))
    Text(text = buildAnnotatedString {
        append("This application runs on ")
        withLink(
            LinkAnnotation.Url(
                "https://play.google.com/store/apps/details?id=com.google.ar.core",
                textLinkStyle
            )
        ) {
            append("Google Play Services for AR")
        }
        append("  (ARCore), which is provided by Google and governed by the ")
        withLink(
            LinkAnnotation.Url(
                "https://policies.google.com/privacy",
                textLinkStyle
            )
        ) {
            append("Google Privacy Policy.")
        }
    })
}

/**
 * Displays the required privacy information for use of the Geospatial API
 */
@Composable
private fun LegalTextGeospatial() {
    Text(text = buildAnnotatedString {
        append("To power this session, Google will process sensor data (e.g., camera and location).")
        appendLine()
        withLink(
            LinkAnnotation.Url(
                "https://support.google.com/ar?p=how-google-play-services-for-ar-handles-your-data",
                TextLinkStyles(style = SpanStyle(color = Color.Blue))
            )
        ) {
            append("Learn more")
        }
    })
}