✨ RunningWorker 기능 구현 마무리 및 location listener로 전환

Co-authored-by: yonghanJu <[email protected]>

Author: bngsh

presentation/src/main/java/com/whyranoid/presentation/running/RunningActivity.kt

@@ -2,11 +2,11 @@ package com.whyranoid.presentation.running
 
 import android.os.Bundle
 import androidx.activity.viewModels
-import com.naver.maps.geometry.LatLng
-import com.naver.maps.map.CameraUpdate
 import com.naver.maps.map.MapView
 import com.naver.maps.map.NaverMap
 import com.naver.maps.map.OnMapReadyCallback
+import com.naver.maps.map.overlay.OverlayImage
+import com.naver.maps.map.overlay.PathOverlay
 import com.whyranoid.presentation.R
 import com.whyranoid.presentation.base.BaseActivity
 import com.whyranoid.presentation.databinding.ActivityRunningBinding
@@ -23,38 +23,38 @@ internal class RunningActivity :
 
     private lateinit var mapView: MapView
     private lateinit var naverMap: NaverMap
+    private lateinit var paths: MutableList<PathOverlay>
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
-        mapView = binding.mapView
-
-        mapView.onCreate(savedInstanceState)
-        mapView.getMapAsync(this)
 
-        binding.vm = viewModel
-
-        repeatWhenUiStarted {
-            viewModel.runningState.collect { runningState ->
-                with(runningState.runningData) {
-                    binding.tvStartTime.text = Date(startTime).dateToString("hh:mm")
-                    binding.tvRunningTime.text =
-                        String.format("%d:%02d", runningTime / 60, runningTime % 60)
-                    binding.tvTotalDistance.text = String.format("%.4f m", totalDistance)
-                    binding.tvPace.text = String.format("%.4f km/h", pace * 3.6)
-                }
-            }
-        }
+        initViews(savedInstanceState)
+        observeState()
     }
 
     override fun onMapReady(naverMap: NaverMap) {
         this.naverMap = naverMap
 
-        naverMap.maxZoom = 18.0
-        naverMap.minZoom = 10.0
+        with(naverMap) {
+            maxZoom = MAP_MAX_ZOOM
+            minZoom = MAP_MIN_ZOOM
+            uiSettings.isLocationButtonEnabled = false
+            uiSettings.isZoomControlEnabled = false
+            locationOverlay.isVisible = true
+            locationOverlay.icon = OverlayImage.fromResource(R.drawable.kong)
+            locationOverlay.iconWidth = MAP_ICON_SIZE
+            locationOverlay.iconHeight = MAP_ICON_SIZE
+        }
+
+        paths = mutableListOf()
 
-        naverMap.moveCamera(CameraUpdate.scrollAndZoomTo(LatLng(37.498095, 127.027610), 15.0))
-        naverMap.uiSettings.isLocationButtonEnabled = false
-        naverMap.uiSettings.isZoomControlEnabled = false
+        repeatWhenUiStarted {
+            viewModel.runningState.collect { runningState ->
+                makeNewPath(runningState)
+                updateRunnerPosition(runningState)
+                updatePathsOverlay(runningState)
+            }
+        }
     }
 
     override fun onStart() {
@@ -91,4 +91,60 @@ internal class RunningActivity :
         super.onLowMemory()
         mapView.onLowMemory()
     }
+
+    private fun initViews(savedInstanceState: Bundle?) {
+        mapView = binding.mapView
+
+        mapView.onCreate(savedInstanceState)
+        mapView.getMapAsync(this)
+
+        binding.vm = viewModel
+    }
+
+    private fun observeState() {
+        repeatWhenUiStarted {
+            viewModel.runningState.collect { runningState ->
+                with(runningState.runningData) {
+                    binding.tvStartTime.text = Date(startTime).dateToString("hh:mm")
+                    binding.tvRunningTime.text =
+                        String.format("%d:%02d", runningTime / 60, runningTime % 60)
+                    binding.tvTotalDistance.text = String.format("%.4f m", totalDistance)
+                    binding.tvPace.text = String.format("%.4f km/h", pace * 3.6)
+                }
+            }
+        }
+    }
+
+    private fun provideMogakrunPath(): PathOverlay {
+        return PathOverlay().apply {
+            color = getColor(R.color.mogakrun_secondary_light)
+            width = 20
+        }
+    }
+
+    private fun makeNewPath(runningState: RunningState) {
+        while (paths.size < runningState.runningData.runningPositionList.size) {
+            paths.add(provideMogakrunPath())
+        }
+    }
+
+    private fun updateRunnerPosition(runningState: RunningState) {
+        runningState.runningData.runningPositionList.last().lastOrNull()?.let {
+            naverMap.locationOverlay.position = it.toLatLng()
+        }
+    }
+
+    private fun updatePathsOverlay(runningState: RunningState) {
+        if (runningState.runningData.runningPositionList.last().size >= 2) {
+            paths.last().coords =
+                runningState.runningData.runningPositionList.last().map { it.toLatLng() }
+            paths.last().map = naverMap
+        }
+    }
+
+    companion object {
+        const val MAP_MAX_ZOOM = 18.0
+        const val MAP_MIN_ZOOM = 10.0
+        const val MAP_ICON_SIZE = 80
+    }
 }

presentation/src/main/java/com/whyranoid/presentation/running/RunningRepository.kt

@@ -15,25 +15,27 @@ class RunningRepository @Inject constructor() {
     )
     val runningState get() = _runningState.asStateFlow()
 
-    fun startRunning(startPosition: RunningPosition) {
+    fun startRunning() {
         if (runningState.value is RunningState.NotRunning) {
             _runningState.value = RunningState.Running(
                 RunningData(
                     startTime = System.currentTimeMillis(),
                     runningTime = 0,
                     totalDistance = 0.0,
                     pace = 0.0,
-                    runningPositionList = listOf(startPosition)
+                    runningPositionList = listOf(emptyList())
                 )
             )
         }
     }
 
     fun pauseRunning() = runCatching {
         if (runningState.value is RunningState.Running) {
-            _runningState.value = RunningState.Paused(
-                runningState.value.runningData
+            val newRunningData = runningState.value.runningData.copy(
+                runningPositionList = runningState.value.runningData.runningPositionList.toMutableList()
+                    .also { it.add(emptyList()) }
             )
+            _runningState.value = RunningState.Paused(newRunningData)
         } else {
             throw Exception("상태가 잘못되었습니다.")
         }
@@ -68,18 +70,23 @@ class RunningRepository @Inject constructor() {
     fun setRunningState(runningPosition: RunningPosition) {
         if (_runningState.value is RunningState.Running) {
             val prevRunningData = _runningState.value.runningData
-            val newRunningTime = prevRunningData.runningTime + 1
+            val newRunningTime = prevRunningData.runningTime
             val distance = FloatArray(1)
+
             Location.distanceBetween(
-                prevRunningData.runningPositionList.last().latitude,
-                prevRunningData.runningPositionList.last().longitude,
+                prevRunningData.runningPositionList.last().lastOrNull()?.latitude
+                    ?: runningPosition.latitude,
+                prevRunningData.runningPositionList.last().lastOrNull()?.longitude
+                    ?: runningPosition.longitude,
                 runningPosition.latitude,
                 runningPosition.longitude,
                 distance
             )
             val newTotalDistance = prevRunningData.totalDistance + distance.first()
             val newPace = newTotalDistance / newRunningTime
-            val newRunningPositionList = prevRunningData.runningPositionList.plus(runningPosition)
+            val newRunningPositionList =
+                prevRunningData.runningPositionList.toList().map { it.toMutableList() }
+                    .also { it[it.lastIndex].add(runningPosition) }
 
             _runningState.value = RunningState.Running(
                 RunningData(
@@ -92,6 +99,12 @@ class RunningRepository @Inject constructor() {
             )
         }
     }
+
+    fun tick() {
+        _runningState.value = _runningState.value.let {
+            it.runningData.copy(runningTime = it.runningData.runningTime + 1)
+        }.let { RunningState.Running(it) }
+    }
 }
 
 // TODO : 모델 파일 분리
@@ -100,12 +113,12 @@ data class RunningData(
     val runningTime: Int = 0,
     val totalDistance: Double = 0.0,
     val pace: Double = 0.0,
-    val runningPositionList: List<RunningPosition> = emptyList()
+    val runningPositionList: List<List<RunningPosition>> = listOf(emptyList())
 )
 
 data class RunningFinishData(
     val runningHistory: RunningHistory,
-    val runningPositionList: List<RunningPosition>
+    val runningPositionList: List<List<RunningPosition>>
 )
 
 sealed interface RunningState {