Match viewpoint of geo views

/* Copyright 2026 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.matchviewpointofgeoviews

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.matchviewpointofgeoviews.screens.MatchViewpointOfGeoViewsScreen

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

    @Composable
    private fun MatchViewpointOfGeoViewsApp() {
        Surface(color = MaterialTheme.colorScheme.background) {
            MatchViewpointOfGeoViewsScreen(
                sampleName = getString(R.string.match_viewpoint_of_geo_views_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.matchviewpointofgeoviews.screens

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.lifecycle.viewmodel.compose.viewModel
import com.arcgismaps.mapping.Viewpoint
import com.arcgismaps.toolkit.geoviewcompose.MapView
import com.arcgismaps.toolkit.geoviewcompose.SceneView
import com.esri.arcgismaps.sample.sampleslib.components.SampleTopAppBar

/**
 * Composable screen that displays a MapView and a SceneView stacked vertically and keeps their
 * center-and-scale viewpoints synchronized. The MapView and SceneView notify the ViewModel
 * about navigation state changes and viewpoint updates.
 */
@Composable
fun MatchViewpointOfGeoViewsScreen(sampleName: String) {
    val viewModel: MatchViewpointOfGeoViewsViewModel = viewModel()

    Column(modifier = Modifier.fillMaxSize()) {
        SampleTopAppBar(title = sampleName)

        Column(modifier = Modifier.fillMaxSize()) {
            MapView(
                modifier = Modifier
                    .weight(1f)
                    .fillMaxSize(),
                arcGISMap = viewModel.arcGISMap,
                mapViewProxy = viewModel.mapViewProxy,
                onNavigationChanged = { isNavigating ->
                    viewModel.updateMapIsNavigating(isNavigating)
                },
                onViewpointChangedForCenterAndScale = { newViewpoint: Viewpoint ->
                    viewModel.onMapViewpointChanged(newViewpoint)
                }
            )
            SceneView(
                modifier = Modifier
                    .weight(1f)
                    .fillMaxSize(),
                arcGISScene = viewModel.arcGISScene,
                sceneViewProxy = viewModel.sceneViewProxy,
                onNavigationChanged = { isNavigating ->
                    viewModel.updateSceneIsNavigating(isNavigating)
                },
                onViewpointChangedForCenterAndScale = { newViewpoint: Viewpoint ->
                    viewModel.onSceneViewpointChanged(newViewpoint)
                }
            )
        }
    }
}

package com.esri.arcgismaps.sample.matchviewpointofgeoviews.screens

import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.lifecycle.ViewModel
import com.arcgismaps.geometry.Point
import com.arcgismaps.geometry.SpatialReference
import com.arcgismaps.mapping.ArcGISMap
import com.arcgismaps.mapping.ArcGISScene
import com.arcgismaps.mapping.BasemapStyle
import com.arcgismaps.mapping.Viewpoint
import com.arcgismaps.toolkit.geoviewcompose.MapViewProxy
import com.arcgismaps.toolkit.geoviewcompose.SceneViewProxy

class MatchViewpointOfGeoViewsViewModel : ViewModel() {
    val arcGISMap = ArcGISMap(BasemapStyle.ArcGISImagery)
    val arcGISScene = ArcGISScene(BasemapStyle.ArcGISImagery)
    val mapViewProxy = MapViewProxy()
    val sceneViewProxy = SceneViewProxy()

    // Initial viewpoint
    private val initialViewpoint = Viewpoint(
        center = Point(-13637000.0, 4550000.0, SpatialReference.webMercator()),
        scale = 100_000.0
    )

    // Track navigation state
    var isMapNavigating by mutableStateOf(false)
    var isSceneNavigating by mutableStateOf(false)

    init {
        arcGISMap.initialViewpoint = initialViewpoint
        arcGISScene.initialViewpoint = initialViewpoint
    }

    fun updateMapIsNavigating(navigating: Boolean) {
        isMapNavigating = navigating
    }

    fun updateSceneIsNavigating(navigating: Boolean) {
        isSceneNavigating = navigating
    }

    fun onMapViewpointChanged(newViewpoint: Viewpoint) {
        if (!isSceneNavigating) {
            sceneViewProxy.setViewpoint(newViewpoint)
        }
    }

    fun onSceneViewpointChanged(newViewpoint: Viewpoint) {
        if (!isMapNavigating) {
            mapViewProxy.setViewpoint(newViewpoint)
        }
    }
}