From 910cf06403f32b70a235bcbe3ddf61180de13888 Mon Sep 17 00:00:00 2001 From: seungjun Date: Sat, 7 Nov 2026 19:53:44 +0900 Subject: [PATCH 01/16] =?UTF-8?q?[FIX/#222]=20=EB=B3=B5=EA=B5=AC=20?= =?UTF-8?q?=EB=AA=A8=EB=8B=AC=20=EC=9D=B4=EC=96=B4=EC=84=9C=20=EA=B8=B0?= =?UTF-8?q?=EB=A1=9D=EC=97=90=EC=84=9C=20=EC=9D=B4=EC=A0=84=20=EA=B8=B0?= =?UTF-8?q?=EB=A1=9D=EC=9D=84=20=EB=AA=BB=20=EC=9D=BD=EC=9C=BC=EB=A9=B4=20?= =?UTF-8?q?=EC=83=88=20=EA=B8=B0=EB=A1=9D=20=EC=97=86=EC=9D=B4=20=EC=9A=B4?= =?UTF-8?q?=EB=8F=99=20=EB=A9=94=EC=9D=B8=EC=9C=BC=EB=A1=9C=20=EC=9D=B4?= =?UTF-8?q?=EB=8F=99?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../recording/WorkoutRecordingViewModel.kt | 5 ++++ .../WorkoutRecordingViewModelTest.kt | 24 +++++++++++++++++++ 2 files changed, 29 insertions(+) diff --git a/feature/workout/impl/src/main/java/com/routee/android/feature/workout/recording/WorkoutRecordingViewModel.kt b/feature/workout/impl/src/main/java/com/routee/android/feature/workout/recording/WorkoutRecordingViewModel.kt index c83f8dd8..8a5a2069 100644 --- a/feature/workout/impl/src/main/java/com/routee/android/feature/workout/recording/WorkoutRecordingViewModel.kt +++ b/feature/workout/impl/src/main/java/com/routee/android/feature/workout/recording/WorkoutRecordingViewModel.kt @@ -329,6 +329,11 @@ internal class WorkoutRecordingViewModel @AssistedInject constructor( val unfinished = getUnfinishedWorkout().getOrElse { Timber.e(it, "운동 기록 복원 실패") _sideEffect.send(WorkoutRecordingSideEffect.ShowRestoreFailed) + // 이어서 기록할 기록을 읽지 못하면 새 기록 없이 운동 메인으로 + if (key.isRecovering) { + _sideEffect.send(WorkoutRecordingSideEffect.NavigateToHome) + return@launch + } UnfinishedWorkout.None } when (unfinished) { diff --git a/feature/workout/impl/src/test/java/com/routee/android/feature/workout/recording/WorkoutRecordingViewModelTest.kt b/feature/workout/impl/src/test/java/com/routee/android/feature/workout/recording/WorkoutRecordingViewModelTest.kt index 8049e8b4..c864c7d4 100644 --- a/feature/workout/impl/src/test/java/com/routee/android/feature/workout/recording/WorkoutRecordingViewModelTest.kt +++ b/feature/workout/impl/src/test/java/com/routee/android/feature/workout/recording/WorkoutRecordingViewModelTest.kt @@ -32,6 +32,8 @@ import java.io.IOException import kotlinx.coroutines.cancel import kotlinx.coroutines.flow.dropWhile import kotlinx.coroutines.flow.first +import kotlinx.coroutines.flow.take +import kotlinx.coroutines.flow.toList import kotlinx.coroutines.test.runTest import kotlinx.coroutines.withTimeout import kotlinx.coroutines.withTimeoutOrNull @@ -174,6 +176,28 @@ class WorkoutRecordingViewModelTest { viewModel.close() } + /** + * GIVEN: 복구로 들어왔는데 기기 기록을 읽지 못할 때 + * WHEN: 화면에 들어오고 카운트다운 끝 신호가 와도 + * THEN: 새 기록 없이 기기 기록을 남기고 복원 실패를 알린 뒤 운동 메인으로 보낸다 + */ + @Test + fun `복구로 들어왔는데 기기 기록을 읽지 못하면 새 기록 없이 운동 메인으로 보낸다`() = runTest { + val tracking = FakeWorkoutTrackingRepository() + val records = FakeWorkoutRecordRepository(getError = IOException()) + val viewModel = viewModel(tracking, records = records, key = WorkoutRecordingNavKey(isRecovering = true)) + + viewModel.onCountdownFinish() + + assertFalse(records.isCleared) + assertNull(tracking.startedRecord) + assertEquals( + listOf(WorkoutRecordingSideEffect.ShowRestoreFailed, WorkoutRecordingSideEffect.NavigateToHome), + viewModel.sideEffect.take(2).toList(), + ) + viewModel.close() + } + /** * GIVEN: 정지 화면에서 기기 저장이 실패할 때 * WHEN: 다시 시작을 누르면 From 98d93a01784513a6e27a74ee988cb790cdcb376f Mon Sep 17 00:00:00 2001 From: seungjun Date: Sat, 7 Nov 2026 19:53:44 +0900 Subject: [PATCH 02/16] =?UTF-8?q?[FIX/#222]=20=EC=95=B1=20=EB=B3=B5?= =?UTF-8?q?=EC=9B=90=20=EB=95=8C=20=EC=A0=80=EC=9E=A5=20=EC=8B=A4=ED=8C=A8?= =?UTF-8?q?=ED=95=9C=20=EA=B8=B0=EB=A1=9D=EC=9D=84=20=EB=8D=AE=EC=96=B4?= =?UTF-8?q?=EC=93=B0=EC=A7=80=20=EC=95=8A=EA=B3=A0=20=EB=B3=B5=EA=B5=AC=20?= =?UTF-8?q?=EB=AA=A8=EB=8B=AC=EB=A1=9C=20=EC=95=88=EB=82=B4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../data/workout/model/UnfinishedWorkout.kt | 5 +-- .../workout/model/UnfinishedWorkoutTest.kt | 22 +++++++++--- .../WorkoutRecordingViewModelTest.kt | 35 +++++++++++++++++++ 3 files changed, 56 insertions(+), 6 deletions(-) diff --git a/core/data/src/main/java/com/routee/android/core/data/workout/model/UnfinishedWorkout.kt b/core/data/src/main/java/com/routee/android/core/data/workout/model/UnfinishedWorkout.kt index 14ef1601..01eaa951 100644 --- a/core/data/src/main/java/com/routee/android/core/data/workout/model/UnfinishedWorkout.kt +++ b/core/data/src/main/java/com/routee/android/core/data/workout/model/UnfinishedWorkout.kt @@ -12,7 +12,7 @@ sealed interface UnfinishedWorkout { /** 앱이 꺼졌다 켜졌거나 일시정지가 2시간을 넘음, 이어서 기록과 종료 후 저장을 고르게 함 */ data class Recoverable(val record: WorkoutRecord) : UnfinishedWorkout - /** 종료했지만 서버 저장에 실패함, [Recoverable]과 같은 복구 안내 */ + /** 앱이 살아 있는 동안 종료했지만 서버 저장에 실패함, [Recoverable]과 같은 복구 안내 */ data class PendingUpload(val record: WorkoutRecord) : UnfinishedWorkout companion object { @@ -27,8 +27,9 @@ sealed interface UnfinishedWorkout { ): UnfinishedWorkout { val record = current ?: saved ?: return None return when { + current == null -> Recoverable(record) record.status == WorkoutStatus.PENDING_UPLOAD -> PendingUpload(record) - current == null || record.isPauseExpiredAt(now) -> Recoverable(record) + record.isPauseExpiredAt(now) -> Recoverable(record) else -> Tracking } } diff --git a/core/data/src/test/java/com/routee/android/core/data/workout/model/UnfinishedWorkoutTest.kt b/core/data/src/test/java/com/routee/android/core/data/workout/model/UnfinishedWorkoutTest.kt index d373a595..a647bcd0 100644 --- a/core/data/src/test/java/com/routee/android/core/data/workout/model/UnfinishedWorkoutTest.kt +++ b/core/data/src/test/java/com/routee/android/core/data/workout/model/UnfinishedWorkoutTest.kt @@ -51,19 +51,33 @@ class UnfinishedWorkoutTest { } /** - * GIVEN: 종료했지만 서버 저장을 확인하지 못한 기록일 때 - * WHEN: 앱에 들어오면 + * GIVEN: 앱이 살아 있는 동안 종료했지만 서버 저장에 실패한 기록일 때 + * WHEN: 확인하면 * THEN: 업로드 대기로 본다 */ @Test - fun `종료한 기록은 업로드 대기로 본다`() { + fun `앱 메모리의 종료한 기록은 업로드 대기로 본다`() { val finished = record().finished(START) - val result = UnfinishedWorkout.of(current = null, saved = finished, now = START) + val result = UnfinishedWorkout.of(current = finished, saved = null, now = START) assertEquals(UnfinishedWorkout.PendingUpload(finished), result) } + /** + * GIVEN: 앱이 꺼졌다 켜져 기기에만 종료한 기록이 있을 때 + * WHEN: 확인하면 + * THEN: 복구 대상으로 본다 + */ + @Test + fun `기기에만 있는 종료한 기록은 복구 대상으로 본다`() { + val finished = record().finished(START) + + val result = UnfinishedWorkout.of(current = null, saved = finished, now = START) + + assertEquals(UnfinishedWorkout.Recoverable(finished), result) + } + /** * GIVEN: 남은 기록이 없을 때 * WHEN: 앱에 들어오면 diff --git a/feature/workout/impl/src/test/java/com/routee/android/feature/workout/recording/WorkoutRecordingViewModelTest.kt b/feature/workout/impl/src/test/java/com/routee/android/feature/workout/recording/WorkoutRecordingViewModelTest.kt index c864c7d4..271151ed 100644 --- a/feature/workout/impl/src/test/java/com/routee/android/feature/workout/recording/WorkoutRecordingViewModelTest.kt +++ b/feature/workout/impl/src/test/java/com/routee/android/feature/workout/recording/WorkoutRecordingViewModelTest.kt @@ -138,6 +138,41 @@ class WorkoutRecordingViewModelTest { viewModel.close() } + /** + * GIVEN: 앱이 꺼졌다 켜져 기록 화면이 바로 복원됐고 기기에 저장 실패한 기록이 있을 때 + * WHEN: 화면에 들어오고 카운트다운 끝 신호가 와도 + * THEN: 복구 모달을 띄우게 운동 메인으로 보내고 새 기록은 시작하지 않는다 + */ + @Test + fun `복원된 기록 화면은 저장 실패한 기록을 덮어쓰지 않는다`() = runTest { + val tracking = FakeWorkoutTrackingRepository() + val records = FakeWorkoutRecordRepository(record = record().finished(START)) + val viewModel = viewModel(tracking, records = records) + + viewModel.onCountdownFinish() + + assertEquals(WorkoutRecordingSideEffect.NavigateToHome, viewModel.sideEffect.first()) + assertNull(tracking.startedRecord) + viewModel.close() + } + + /** + * GIVEN: 앱이 살아 있는 동안 저장에 실패한 기록이 있을 때 + * WHEN: 운동 기록을 눌러 들어와 카운트다운이 끝나면 + * THEN: 남은 기록 대신 새 기록을 시작한다 + */ + @Test + fun `운동 기록을 누르면 저장 실패한 기록 대신 새로 시작한다`() = runTest { + val tracking = FakeWorkoutTrackingRepository(record().finished(START)) + val viewModel = viewModel(tracking) + + viewModel.onCountdownFinish() + + assertEquals(WorkoutStatus.ACTIVITY_IN_PROGRESS, tracking.startedRecord?.status) + assertEquals(WorkoutMode.RECORDING, viewModel.uiState.value.mode) + viewModel.close() + } + /** * GIVEN: 복구 모달에서 이어서 기록을 골라 기록을 일시정지로 불러왔을 때 * WHEN: 카운트다운이 끝나면 From b976e8b0fa27c15ec06e90f480c8cd8908dc9cc5 Mon Sep 17 00:00:00 2001 From: seungjun Date: Sat, 7 Nov 2026 19:53:44 +0900 Subject: [PATCH 03/16] =?UTF-8?q?[FIX/#222]=20=EC=9A=B4=EB=8F=99=20?= =?UTF-8?q?=EA=B8=B0=EB=A1=9D=EC=9D=84=20=EB=88=84=EB=A5=B4=EB=A9=B4=20?= =?UTF-8?q?=EA=B8=B0=EA=B8=B0=EC=97=90=20=EB=82=A8=EC=9D=80=20=EC=9D=B4?= =?UTF-8?q?=EC=A0=84=20=EA=B8=B0=EB=A1=9D=20=EC=82=AD=EC=A0=9C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../recording/WorkoutRecordingViewModel.kt | 4 +++ .../WorkoutRecordingViewModelTest.kt | 36 +++++++++++++++++++ 2 files changed, 40 insertions(+) diff --git a/feature/workout/impl/src/main/java/com/routee/android/feature/workout/recording/WorkoutRecordingViewModel.kt b/feature/workout/impl/src/main/java/com/routee/android/feature/workout/recording/WorkoutRecordingViewModel.kt index 8a5a2069..b6727a8b 100644 --- a/feature/workout/impl/src/main/java/com/routee/android/feature/workout/recording/WorkoutRecordingViewModel.kt +++ b/feature/workout/impl/src/main/java/com/routee/android/feature/workout/recording/WorkoutRecordingViewModel.kt @@ -13,6 +13,7 @@ import com.routee.android.core.data.workout.repository.WorkoutRemoteRepository import com.routee.android.core.data.workout.repository.WorkoutTrackingRepository import com.routee.android.core.domain.workout.AddWorkoutPhotoResult import com.routee.android.core.domain.workout.AddWorkoutPhotoUseCase +import com.routee.android.core.domain.workout.DiscardWorkoutUseCase import com.routee.android.core.domain.workout.GetUnfinishedWorkoutUseCase import com.routee.android.core.domain.workout.ResolveWorkoutPhotoPointUseCase import com.routee.android.core.domain.workout.SaveFinishedWorkoutUseCase @@ -66,6 +67,7 @@ internal class WorkoutRecordingViewModel @AssistedInject constructor( @Assisted private val key: WorkoutRecordingNavKey, private val trackingRepository: WorkoutTrackingRepository, private val getUnfinishedWorkout: GetUnfinishedWorkoutUseCase, + private val discardWorkout: DiscardWorkoutUseCase, private val remoteRepository: WorkoutRemoteRepository, private val saveFinishedWorkout: SaveFinishedWorkoutUseCase, private val resolveWorkoutPhotoPoint: ResolveWorkoutPhotoPointUseCase, @@ -386,8 +388,10 @@ internal class WorkoutRecordingViewModel @AssistedInject constructor( continueRecording() } + // 운동 기록을 누르면 시작 API 결과와 상관없이 기기에 남은 기록을 지움 private fun createWorkout() { startedWorkout = viewModelScope.async { + discardWorkout().onFailure { Timber.e(it, "이전 운동 기록 삭제 실패") } remoteRepository.createWorkout(WorkoutType.HIKING, startedAt).onFailure { Timber.e(it, "운동 시작 API 실패") _sideEffect.send(WorkoutRecordingSideEffect.StartFailed) diff --git a/feature/workout/impl/src/test/java/com/routee/android/feature/workout/recording/WorkoutRecordingViewModelTest.kt b/feature/workout/impl/src/test/java/com/routee/android/feature/workout/recording/WorkoutRecordingViewModelTest.kt index 271151ed..0350e94d 100644 --- a/feature/workout/impl/src/test/java/com/routee/android/feature/workout/recording/WorkoutRecordingViewModelTest.kt +++ b/feature/workout/impl/src/test/java/com/routee/android/feature/workout/recording/WorkoutRecordingViewModelTest.kt @@ -5,6 +5,7 @@ import com.routee.android.core.data.location.model.DeviceLocation import com.routee.android.core.data.workout.model.WorkoutStatus import com.routee.android.core.data.workout.model.WorkoutTrackingState import com.routee.android.core.domain.workout.AddWorkoutPhotoUseCase +import com.routee.android.core.domain.workout.DiscardWorkoutUseCase import com.routee.android.core.domain.workout.GetUnfinishedWorkoutUseCase import com.routee.android.core.domain.workout.ResolveWorkoutPhotoPointUseCase import com.routee.android.core.domain.workout.SaveFinishedWorkoutUseCase @@ -173,6 +174,40 @@ class WorkoutRecordingViewModelTest { viewModel.close() } + /** + * GIVEN: 저장 실패한 기록이 남은 채 운동 기록을 눌렀을 때 + * WHEN: 시작 API가 성공하면 + * THEN: 카운트다운이 끝나기 전에 기기 기록을 지운다 + */ + @Test + fun `시작 API가 성공해도 카운트다운이 끝나기 전에 저장 실패한 기록을 지운다`() = runTest { + val tracking = FakeWorkoutTrackingRepository(record().finished(START)) + val records = FakeWorkoutRecordRepository() + val viewModel = viewModel(tracking, records = records) + + assertTrue(tracking.isCleared) + assertTrue(records.isCleared) + assertNull(tracking.startedRecord) + viewModel.close() + } + + /** + * GIVEN: 저장 실패한 기록이 남은 채 운동 기록을 눌렀을 때 + * WHEN: 시작 API가 실패하면 + * THEN: 시작 실패를 알리고 기기 기록은 지운다 + */ + @Test + fun `시작 API가 실패해도 저장 실패한 기록을 지운다`() = runTest { + val tracking = FakeWorkoutTrackingRepository(record().finished(START)) + val records = FakeWorkoutRecordRepository() + val viewModel = viewModel(tracking, FakeWorkoutRemoteRepository(createError = IOException()), records = records) + + assertEquals(WorkoutRecordingSideEffect.StartFailed, viewModel.sideEffect.first()) + assertTrue(tracking.isCleared) + assertTrue(records.isCleared) + viewModel.close() + } + /** * GIVEN: 복구 모달에서 이어서 기록을 골라 기록을 일시정지로 불러왔을 때 * WHEN: 카운트다운이 끝나면 @@ -700,6 +735,7 @@ class WorkoutRecordingViewModelTest { key = key, trackingRepository = tracking, getUnfinishedWorkout = GetUnfinishedWorkoutUseCase(tracking, records, clock), + discardWorkout = DiscardWorkoutUseCase(tracking, records, photos), remoteRepository = remote, saveFinishedWorkout = SaveFinishedWorkoutUseCase( trackingRepository = tracking, From 7a5e0470f2e836fc610a082fa7457fef95d252ae Mon Sep 17 00:00:00 2001 From: seungjun Date: Sat, 7 Nov 2026 19:53:45 +0900 Subject: [PATCH 04/16] =?UTF-8?q?[ADD/#222]=20=EC=9A=B4=EB=8F=99=20?= =?UTF-8?q?=EC=82=AC=EC=A7=84=20Room=20=ED=85=8C=EC=9D=B4=EB=B8=94=20?= =?UTF-8?q?=EC=B6=94=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../2.json | 275 ++++++++++++++++++ .../android/core/database/RouteeDatabase.kt | 10 +- .../android/core/database/dao/WorkoutDao.kt | 6 +- .../core/database/dao/WorkoutPhotoDao.kt | 37 +++ .../core/database/di/DatabaseModule.kt | 4 + .../database/entity/WorkoutPhotoEntity.kt | 47 +++ docs/architecture/data-layer.md | 4 +- 7 files changed, 376 insertions(+), 7 deletions(-) create mode 100644 core/database/schemas/com.routee.android.core.database.RouteeDatabase/2.json create mode 100644 core/database/src/main/java/com/routee/android/core/database/dao/WorkoutPhotoDao.kt create mode 100644 core/database/src/main/java/com/routee/android/core/database/entity/WorkoutPhotoEntity.kt diff --git a/core/database/schemas/com.routee.android.core.database.RouteeDatabase/2.json b/core/database/schemas/com.routee.android.core.database.RouteeDatabase/2.json new file mode 100644 index 00000000..9bd8bdaa --- /dev/null +++ b/core/database/schemas/com.routee.android.core.database.RouteeDatabase/2.json @@ -0,0 +1,275 @@ +{ + "formatVersion": 1, + "database": { + "version": 2, + "identityHash": "6399f533e3f64f0719e30b3a2b2cbd67", + "entities": [ + { + "tableName": "workout", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER NOT NULL, `title` TEXT NOT NULL, `type` TEXT NOT NULL, `status` TEXT NOT NULL, `started_at` INTEGER NOT NULL, `duration_millis` INTEGER NOT NULL, `resumed_at` INTEGER, `paused_at` INTEGER, `last_recorded_at` INTEGER NOT NULL, `distance` REAL NOT NULL, `max_elevation` REAL, `ended_at` INTEGER, `map_image_object_key` TEXT, `map_image_path` TEXT, PRIMARY KEY(`id`))", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "title", + "columnName": "title", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "type", + "columnName": "type", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "status", + "columnName": "status", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "startedAt", + "columnName": "started_at", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "durationMillis", + "columnName": "duration_millis", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "resumedAt", + "columnName": "resumed_at", + "affinity": "INTEGER" + }, + { + "fieldPath": "pausedAt", + "columnName": "paused_at", + "affinity": "INTEGER" + }, + { + "fieldPath": "lastRecordedAt", + "columnName": "last_recorded_at", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "distance", + "columnName": "distance", + "affinity": "REAL", + "notNull": true + }, + { + "fieldPath": "maxElevation", + "columnName": "max_elevation", + "affinity": "REAL" + }, + { + "fieldPath": "endedAt", + "columnName": "ended_at", + "affinity": "INTEGER" + }, + { + "fieldPath": "mapImageObjectKey", + "columnName": "map_image_object_key", + "affinity": "TEXT" + }, + { + "fieldPath": "mapImagePath", + "columnName": "map_image_path", + "affinity": "TEXT" + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "id" + ] + } + }, + { + "tableName": "track_point", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`workout_id` INTEGER NOT NULL, `point_index` INTEGER NOT NULL, `latitude` REAL NOT NULL, `longitude` REAL NOT NULL, `elevation` REAL NOT NULL, `recorded_at` INTEGER NOT NULL, PRIMARY KEY(`workout_id`, `point_index`), FOREIGN KEY(`workout_id`) REFERENCES `workout`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "workoutId", + "columnName": "workout_id", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "pointIndex", + "columnName": "point_index", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "latitude", + "columnName": "latitude", + "affinity": "REAL", + "notNull": true + }, + { + "fieldPath": "longitude", + "columnName": "longitude", + "affinity": "REAL", + "notNull": true + }, + { + "fieldPath": "elevation", + "columnName": "elevation", + "affinity": "REAL", + "notNull": true + }, + { + "fieldPath": "recordedAt", + "columnName": "recorded_at", + "affinity": "INTEGER", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "workout_id", + "point_index" + ] + }, + "foreignKeys": [ + { + "table": "workout", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "workout_id" + ], + "referencedColumns": [ + "id" + ] + } + ] + }, + { + "tableName": "workout_photo", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `workout_id` INTEGER NOT NULL, `file_path` TEXT, `point_index` INTEGER NOT NULL, `latitude` REAL NOT NULL, `longitude` REAL NOT NULL, `elevation` REAL NOT NULL, `recorded_at` INTEGER NOT NULL, `taken_at` INTEGER NOT NULL, `title` TEXT NOT NULL, `timeline_id` INTEGER, `server_title` TEXT, `server_image_url` TEXT, PRIMARY KEY(`id`), FOREIGN KEY(`workout_id`) REFERENCES `workout`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "workoutId", + "columnName": "workout_id", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "filePath", + "columnName": "file_path", + "affinity": "TEXT" + }, + { + "fieldPath": "pointIndex", + "columnName": "point_index", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "latitude", + "columnName": "latitude", + "affinity": "REAL", + "notNull": true + }, + { + "fieldPath": "longitude", + "columnName": "longitude", + "affinity": "REAL", + "notNull": true + }, + { + "fieldPath": "elevation", + "columnName": "elevation", + "affinity": "REAL", + "notNull": true + }, + { + "fieldPath": "recordedAt", + "columnName": "recorded_at", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "takenAt", + "columnName": "taken_at", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "title", + "columnName": "title", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "timelineId", + "columnName": "timeline_id", + "affinity": "INTEGER" + }, + { + "fieldPath": "serverTitle", + "columnName": "server_title", + "affinity": "TEXT" + }, + { + "fieldPath": "serverImageUrl", + "columnName": "server_image_url", + "affinity": "TEXT" + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "id" + ] + }, + "indices": [ + { + "name": "index_workout_photo_workout_id", + "unique": false, + "columnNames": [ + "workout_id" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_workout_photo_workout_id` ON `${TABLE_NAME}` (`workout_id`)" + } + ], + "foreignKeys": [ + { + "table": "workout", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "workout_id" + ], + "referencedColumns": [ + "id" + ] + } + ] + } + ], + "setupQueries": [ + "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)", + "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, '6399f533e3f64f0719e30b3a2b2cbd67')" + ] + } +} \ No newline at end of file diff --git a/core/database/src/main/java/com/routee/android/core/database/RouteeDatabase.kt b/core/database/src/main/java/com/routee/android/core/database/RouteeDatabase.kt index 3f32d22e..ecf501a6 100644 --- a/core/database/src/main/java/com/routee/android/core/database/RouteeDatabase.kt +++ b/core/database/src/main/java/com/routee/android/core/database/RouteeDatabase.kt @@ -1,18 +1,24 @@ package com.routee.android.core.database +import androidx.room.AutoMigration import androidx.room.Database import androidx.room.RoomDatabase import androidx.room.TypeConverters import com.routee.android.core.database.dao.WorkoutDao +import com.routee.android.core.database.dao.WorkoutPhotoDao import com.routee.android.core.database.entity.TrackPointEntity import com.routee.android.core.database.entity.WorkoutEntity +import com.routee.android.core.database.entity.WorkoutPhotoEntity import com.routee.android.core.database.util.InstantConverter @Database( - entities = [WorkoutEntity::class, TrackPointEntity::class], - version = 1, + entities = [WorkoutEntity::class, TrackPointEntity::class, WorkoutPhotoEntity::class], + version = 2, + autoMigrations = [AutoMigration(from = 1, to = 2)], ) @TypeConverters(InstantConverter::class) internal abstract class RouteeDatabase : RoomDatabase() { abstract fun workoutDao(): WorkoutDao + + abstract fun workoutPhotoDao(): WorkoutPhotoDao } diff --git a/core/database/src/main/java/com/routee/android/core/database/dao/WorkoutDao.kt b/core/database/src/main/java/com/routee/android/core/database/dao/WorkoutDao.kt index e6fab698..28c0fd98 100644 --- a/core/database/src/main/java/com/routee/android/core/database/dao/WorkoutDao.kt +++ b/core/database/src/main/java/com/routee/android/core/database/dao/WorkoutDao.kt @@ -37,7 +37,7 @@ interface WorkoutDao { return updateWorkout(workout) } - /** 기존 기록과 경로 좌표를 모두 지우고 새 기록 저장 */ + /** 기존 기록, 경로 좌표, 사진을 모두 지우고 새 기록 저장 */ @Transaction suspend fun replaceWorkout(workout: WorkoutEntity) { deleteWorkouts() @@ -48,11 +48,11 @@ interface WorkoutDao { @Query("SELECT * FROM track_point WHERE workout_id = :workoutId ORDER BY point_index") suspend fun getTrackPoints(workoutId: Long): List - /** 기록 삭제, 경로 좌표도 같이 삭제 */ + /** 기록 삭제, 경로 좌표와 사진도 같이 삭제 */ @Query("DELETE FROM workout WHERE id = :workoutId") suspend fun deleteWorkout(workoutId: Long) - /** 모든 기록과 경로 좌표 삭제 */ + /** 모든 기록, 경로 좌표, 사진 삭제 */ @Query("DELETE FROM workout") suspend fun deleteWorkouts() } diff --git a/core/database/src/main/java/com/routee/android/core/database/dao/WorkoutPhotoDao.kt b/core/database/src/main/java/com/routee/android/core/database/dao/WorkoutPhotoDao.kt new file mode 100644 index 00000000..0b9ddeac --- /dev/null +++ b/core/database/src/main/java/com/routee/android/core/database/dao/WorkoutPhotoDao.kt @@ -0,0 +1,37 @@ +package com.routee.android.core.database.dao + +import androidx.room.Dao +import androidx.room.Insert +import androidx.room.Query +import androidx.room.Transaction +import com.routee.android.core.database.entity.WorkoutPhotoEntity + +/** 운동 사진(`workout_photo`) 테이블 읽기, 쓰기 */ +@Dao +interface WorkoutPhotoDao { + /** 기록의 사진, 찍은 순서 */ + @Query("SELECT * FROM workout_photo WHERE workout_id = :workoutId ORDER BY taken_at") + suspend fun getPhotos(workoutId: Long): List + + /** 사진 추가 */ + @Insert + suspend fun insertPhotos(photos: List) + + /** 기록의 사진 삭제 */ + @Query("DELETE FROM workout_photo WHERE workout_id = :workoutId") + suspend fun deletePhotos(workoutId: Long) + + /** 기록의 사진을 모두 지우고 새 목록 저장 */ + @Transaction + suspend fun replacePhotos( + workoutId: Long, + photos: List, + ) { + deletePhotos(workoutId) + insertPhotos(photos) + } + + /** 모든 사진 삭제 */ + @Query("DELETE FROM workout_photo") + suspend fun clearPhotos() +} diff --git a/core/database/src/main/java/com/routee/android/core/database/di/DatabaseModule.kt b/core/database/src/main/java/com/routee/android/core/database/di/DatabaseModule.kt index 4da817c4..8d065a8b 100644 --- a/core/database/src/main/java/com/routee/android/core/database/di/DatabaseModule.kt +++ b/core/database/src/main/java/com/routee/android/core/database/di/DatabaseModule.kt @@ -4,6 +4,7 @@ import android.content.Context import androidx.room.Room import com.routee.android.core.database.RouteeDatabase import com.routee.android.core.database.dao.WorkoutDao +import com.routee.android.core.database.dao.WorkoutPhotoDao import dagger.Module import dagger.Provides import dagger.hilt.InstallIn @@ -24,4 +25,7 @@ internal object DatabaseModule { @Provides fun provideWorkoutDao(database: RouteeDatabase): WorkoutDao = database.workoutDao() + + @Provides + fun provideWorkoutPhotoDao(database: RouteeDatabase): WorkoutPhotoDao = database.workoutPhotoDao() } diff --git a/core/database/src/main/java/com/routee/android/core/database/entity/WorkoutPhotoEntity.kt b/core/database/src/main/java/com/routee/android/core/database/entity/WorkoutPhotoEntity.kt new file mode 100644 index 00000000..dc133f2b --- /dev/null +++ b/core/database/src/main/java/com/routee/android/core/database/entity/WorkoutPhotoEntity.kt @@ -0,0 +1,47 @@ +package com.routee.android.core.database.entity + +import androidx.room.ColumnInfo +import androidx.room.Entity +import androidx.room.ForeignKey +import androidx.room.Index +import androidx.room.PrimaryKey +import java.time.Instant + +/** + * 운동 중 찍은 사진 테이블 (`workout_photo`), 기록이 지워지면 같이 삭제 + * + * @param id 기기에서 만든 식별자 + * @param workoutId 기록 `id` + * @param filePath 압축한 JPEG 파일 경로, 서버에서 불러온 사진은 null + * @param pointIndex 찍은 위치에 연결한 경로 좌표 순서 + * @param timelineId 타임라인 등록 결과, 아직 못 올렸으면 null + * @param serverTitle 서버에 반영된 장소명 + * @param serverImageUrl 서버 사진 주소 + */ +@Entity( + tableName = "workout_photo", + foreignKeys = [ + ForeignKey( + entity = WorkoutEntity::class, + parentColumns = ["id"], + childColumns = ["workout_id"], + onDelete = ForeignKey.CASCADE, + ), + ], + indices = [Index("workout_id")], +) +data class WorkoutPhotoEntity( + @PrimaryKey val id: String, + @ColumnInfo(name = "workout_id") val workoutId: Long, + @ColumnInfo(name = "file_path") val filePath: String?, + @ColumnInfo(name = "point_index") val pointIndex: Int, + val latitude: Double, + val longitude: Double, + val elevation: Double, + @ColumnInfo(name = "recorded_at") val recordedAt: Instant, + @ColumnInfo(name = "taken_at") val takenAt: Instant, + val title: String, + @ColumnInfo(name = "timeline_id") val timelineId: Long?, + @ColumnInfo(name = "server_title") val serverTitle: String?, + @ColumnInfo(name = "server_image_url") val serverImageUrl: String?, +) diff --git a/docs/architecture/data-layer.md b/docs/architecture/data-layer.md index 8c5754b0..0f65b3b3 100644 --- a/docs/architecture/data-layer.md +++ b/docs/architecture/data-layer.md @@ -14,8 +14,8 @@ | Path under `core/database/.../` | Example | | --- | --- | | (root) | `RouteeDatabase` (one Room DB for the app, internal) | -| `dao/` | `WorkoutDao` | -| `entity/` | `WorkoutEntity`, `TrackPointEntity` | +| `dao/` | `WorkoutDao`, `WorkoutPhotoDao` | +| `entity/` | `WorkoutEntity`, `TrackPointEntity`, `WorkoutPhotoEntity` | Hilt modules live in `core/data/.../di/` and `core/database/.../di/`. From 54d538dac8188cd549e094a57211e8f5d15b26ea Mon Sep 17 00:00:00 2001 From: seungjun Date: Sat, 7 Nov 2026 19:53:46 +0900 Subject: [PATCH 05/16] =?UTF-8?q?[FIX/#222]=20=EC=95=B1=EC=9D=B4=20?= =?UTF-8?q?=EB=8B=A4=EC=8B=9C=20=EC=BC=9C=EC=A0=B8=EB=8F=84=20=EB=AA=BB=20?= =?UTF-8?q?=EC=98=AC=EB=A6=B0=20=EC=82=AC=EC=A7=84=EC=9D=84=20=EA=B8=B0?= =?UTF-8?q?=EA=B8=B0=EC=97=90=EC=84=9C=20=EB=B6=88=EB=9F=AC=EC=99=80=20?= =?UTF-8?q?=EB=8B=A4=EC=8B=9C=20=EC=97=85=EB=A1=9C=EB=93=9C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../data/workout/local/WorkoutEntityMapper.kt | 36 ++++++ .../repository/WorkoutPhotoRepository.kt | 4 +- .../repository/WorkoutPhotoRepositoryImpl.kt | 54 +++++++- .../WorkoutPhotoRepositoryImplTest.kt | 121 +++++++++++++++++- 4 files changed, 203 insertions(+), 12 deletions(-) diff --git a/core/data/src/main/java/com/routee/android/core/data/workout/local/WorkoutEntityMapper.kt b/core/data/src/main/java/com/routee/android/core/data/workout/local/WorkoutEntityMapper.kt index 061722f6..06b59946 100644 --- a/core/data/src/main/java/com/routee/android/core/data/workout/local/WorkoutEntityMapper.kt +++ b/core/data/src/main/java/com/routee/android/core/data/workout/local/WorkoutEntityMapper.kt @@ -1,11 +1,13 @@ package com.routee.android.core.data.workout.local import com.routee.android.core.data.workout.model.TrackPoint +import com.routee.android.core.data.workout.model.WorkoutPhoto import com.routee.android.core.data.workout.model.WorkoutRecord import com.routee.android.core.data.workout.model.WorkoutStatus import com.routee.android.core.data.workout.model.WorkoutType import com.routee.android.core.database.entity.TrackPointEntity import com.routee.android.core.database.entity.WorkoutEntity +import com.routee.android.core.database.entity.WorkoutPhotoEntity internal fun WorkoutEntity.toModel() = WorkoutRecord( activityId = id, @@ -57,3 +59,37 @@ internal fun TrackPoint.toEntity(activityId: Long) = TrackPointEntity( elevation = elevation, recordedAt = recordedAt, ) + +internal fun WorkoutPhotoEntity.toModel() = WorkoutPhoto( + id = id, + activityId = workoutId, + filePath = filePath, + point = TrackPoint( + pointIndex = pointIndex, + latitude = latitude, + longitude = longitude, + elevation = elevation, + recordedAt = recordedAt, + ), + takenAt = takenAt, + title = title, + timelineId = timelineId, + serverTitle = serverTitle, + serverImageUrl = serverImageUrl, +) + +internal fun WorkoutPhoto.toEntity() = WorkoutPhotoEntity( + id = id, + workoutId = activityId, + filePath = filePath, + pointIndex = point.pointIndex, + latitude = point.latitude, + longitude = point.longitude, + elevation = point.elevation, + recordedAt = point.recordedAt, + takenAt = takenAt, + title = title, + timelineId = timelineId, + serverTitle = serverTitle, + serverImageUrl = serverImageUrl, +) diff --git a/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepository.kt b/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepository.kt index 26bbe7e1..bbfa3e9f 100644 --- a/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepository.kt +++ b/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepository.kt @@ -41,12 +41,12 @@ interface WorkoutPhotoRepository { /** 사진 삭제, 다음 [syncPhotos] 때 기기 파일과 서버 사진도 지움 */ fun removePhoto(photoId: String) - /** 앱이 다시 켜져 비어 있으면 서버에 올린 사진으로 채움, 이미 있으면 그대로 */ + /** 앱이 다시 켜져 비어 있으면 기기에 저장한 사진으로, 그것도 없으면 서버에 올린 사진으로 채움. 이미 있으면 그대로 */ suspend fun restore(activityId: Long): Result /** 못 올린 사진 업로드, 바뀐 장소명 수정, 지운 사진 삭제를 서버에 반영. 끝까지 못 올린 사진 수 반환 */ suspend fun syncPhotos(activityId: Long): Int - /** 저장을 마쳤거나 저장할 수 없는 기록의 사진 삭제 */ + /** 기기의 사진 전체 삭제 */ suspend fun clear(): Result } diff --git a/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepositoryImpl.kt b/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepositoryImpl.kt index b5a7e313..9d597843 100644 --- a/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepositoryImpl.kt +++ b/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepositoryImpl.kt @@ -9,9 +9,12 @@ import com.routee.android.core.data.timeline.model.TimelinePhotoStatus import com.routee.android.core.data.timeline.model.TimelinePhotoUpload import com.routee.android.core.data.timeline.repository.TimelinePhotoRepository import com.routee.android.core.data.workout.local.WorkoutPhotoLocalDataSource +import com.routee.android.core.data.workout.local.toEntity +import com.routee.android.core.data.workout.local.toModel import com.routee.android.core.data.workout.model.TrackPoint import com.routee.android.core.data.workout.model.WorkoutPhoto import com.routee.android.core.data.workout.model.toServerElevation +import com.routee.android.core.database.dao.WorkoutPhotoDao import java.io.File import java.time.Instant import java.util.UUID @@ -29,6 +32,7 @@ import kotlinx.coroutines.sync.withLock @Singleton internal class WorkoutPhotoRepositoryImpl @Inject constructor( private val localDataSource: WorkoutPhotoLocalDataSource, + private val photoDao: WorkoutPhotoDao, private val timelinePhotoRepository: TimelinePhotoRepository, private val recapRepository: RecapRepository, private val archiveDetailRepository: ArchiveDetailRepository, @@ -41,6 +45,9 @@ internal class WorkoutPhotoRepositoryImpl @Inject constructor( // 기기에서 지울 사진 파일, 올리는 중일 수 있어 동기화 때 지움 private val removedFiles = MutableStateFlow>(emptySet()) + + // 기기에 저장한 사진을 이미 불러온 기록, 지운 사진을 다시 불러오지 않게 앱 실행마다 한 번만 + private var loadedActivityId: Long? = null private val mutex = Mutex() private val syncMutex = Mutex() @@ -53,6 +60,7 @@ internal class WorkoutPhotoRepositoryImpl @Inject constructor( takenAt: Instant, title: String, ): Result = suspendRunCatching { + loadSavedPhotos(activityId) val id = UUID.randomUUID().toString() val path = localDataSource.compress(activityId, id, original) val photo = WorkoutPhoto( @@ -67,11 +75,13 @@ internal class WorkoutPhotoRepositoryImpl @Inject constructor( clearOthers(activityId) _photos.value += photo } + savePhotos(activityId) photo } - // 좌표는 경로 조회의 마커, 장소명과 큰 이미지는 타임라인 사진 목록에서. 목록을 못 받으면 썸네일과 빈 장소명 + // 기기에 저장한 사진이 없을 때만 서버에서. 좌표는 경로 조회의 마커, 장소명과 큰 이미지는 타임라인 사진 목록에서. 목록을 못 받으면 썸네일과 빈 장소명 override suspend fun restore(activityId: Long): Result = suspendRunCatching { + loadSavedPhotos(activityId) if (_photos.value.any { it.activityId == activityId }) return@suspendRunCatching val photos = coroutineScope { val track = async { recapRepository.getActivityTrack(activityId) } @@ -107,12 +117,17 @@ internal class WorkoutPhotoRepositoryImpl @Inject constructor( } } - override suspend fun syncPhotos(activityId: Long): Int = syncMutex.withLock { - deleteRemovedFiles() - uploadPending(activityId) - updateTitles(activityId) - deleteRemoved(activityId) - _photos.value.count { it.activityId == activityId && it.timelineId == null } + override suspend fun syncPhotos(activityId: Long): Int { + loadSavedPhotos(activityId) + savePhotos(activityId) + return syncMutex.withLock { + deleteRemovedFiles() + uploadPending(activityId) + updateTitles(activityId) + deleteRemoved(activityId) + savePhotos(activityId) + _photos.value.count { it.activityId == activityId && it.timelineId == null } + } } override suspend fun clear(): Result = suspendRunCatching { @@ -121,7 +136,32 @@ internal class WorkoutPhotoRepositoryImpl @Inject constructor( _photos.value = emptyList() removedTimelines.value = emptySet() removedFiles.value = emptySet() + loadedActivityId = null localDataSource.clear() + photoDao.clearPhotos() + } + } + + // 앱이 꺼졌다 켜졌으면 기기에 저장한 사진을 불러옴 + private suspend fun loadSavedPhotos(activityId: Long) { + mutex.withLock { + if (loadedActivityId == activityId) return + loadedActivityId = activityId + if (_photos.value.any { it.activityId == activityId }) return + val saved = suspendRunCatching { photoDao.getPhotos(activityId) }.getOrDefault(emptyList()) + if (saved.isEmpty()) return + clearOthers(activityId) + _photos.value = saved.map { it.toModel() } + } + } + + // 앱이 꺼져도 남게 기기에 저장, 실패해도 메모리 사진으로 계속 + private suspend fun savePhotos(activityId: Long) { + suspendRunCatching { + mutex.withLock { + val photos = _photos.value.filter { it.activityId == activityId }.map { it.toEntity() } + photoDao.replacePhotos(activityId, photos) + } } } diff --git a/core/data/src/test/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepositoryImplTest.kt b/core/data/src/test/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepositoryImplTest.kt index 67113a1e..cf7a111c 100644 --- a/core/data/src/test/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepositoryImplTest.kt +++ b/core/data/src/test/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepositoryImplTest.kt @@ -13,6 +13,8 @@ import com.routee.android.core.data.timeline.model.TimelinePhotoUpload import com.routee.android.core.data.timeline.model.TimelinePhotoUploadResult import com.routee.android.core.data.timeline.repository.TimelinePhotoRepository import com.routee.android.core.data.workout.local.WorkoutPhotoLocalDataSource +import com.routee.android.core.database.dao.WorkoutPhotoDao +import com.routee.android.core.database.entity.WorkoutPhotoEntity import java.io.File import java.io.IOException import java.nio.file.Files @@ -28,9 +30,12 @@ class WorkoutPhotoRepositoryImplTest { private val recap = FakeRecapRepository() private val archive = FakeArchiveDetailRepository() private val directory: File = Files.createTempDirectory("workout_photo").toFile() + private val dao = FakeWorkoutPhotoDao() + private val timelinePhotos = FakeTimelinePhotoRepository() private val repository = WorkoutPhotoRepositoryImpl( localDataSource = WorkoutPhotoLocalDataSource { directory }, - timelinePhotoRepository = FakeTimelinePhotoRepository(), + photoDao = dao, + timelinePhotoRepository = timelinePhotos, recapRepository = recap, archiveDetailRepository = archive, ) @@ -100,6 +105,102 @@ class WorkoutPhotoRepositoryImplTest { assertTrue(repository.photos.value.isEmpty()) } + /** + * GIVEN: 앱이 다시 켜졌고 기기에 저장한 사진이 있을 때 + * WHEN: 복구하면 + * THEN: 서버를 부르지 않고 기기 사진으로 채운다 + */ + @Test + fun `기기에 저장한 사진이 있으면 서버를 부르지 않는다`() = runTest { + dao.rows += photoRow(id = "a", timelineId = 3) + + repository.restore(ACTIVITY_ID).getOrThrow() + + assertEquals(0, recap.trackCallCount) + assertEquals("a.jpg", repository.photos.value.single().filePath) + } + + /** + * GIVEN: 앱이 다시 켜졌고 기기에 못 올린 사진이 있을 때 + * WHEN: 사진을 반영하면 + * THEN: 다시 올리고 타임라인 등록 결과를 기기에 저장한다 + */ + @Test + fun `앱이 다시 켜져도 못 올린 사진을 다시 올린다`() = runTest { + dao.rows += photoRow(id = "a") + + val missing = repository.syncPhotos(ACTIVITY_ID) + + assertEquals(0, missing) + assertEquals(listOf("a"), timelinePhotos.uploadedIds) + assertEquals(UPLOADED_TIMELINE_ID, dao.rows.single().timelineId) + } + + /** + * GIVEN: 앱이 다시 켜졌고 기기에 못 올린 사진이 있을 때 + * WHEN: 다시 올려도 실패하면 + * THEN: 못 올린 사진으로 센다 + */ + @Test + fun `다시 올려도 실패하면 못 올린 사진으로 센다`() = runTest { + dao.rows += photoRow(id = "a") + timelinePhotos.uploadError = IOException() + + assertEquals(1, repository.syncPhotos(ACTIVITY_ID)) + } + + /** + * GIVEN: 기기에 저장한 사진이 있을 때 + * WHEN: 사진을 모두 지우면 + * THEN: 저장한 사진도 지운다 + */ + @Test + fun `사진을 지우면 저장한 사진도 지운다`() = runTest { + dao.rows += photoRow(id = "a") + + repository.clear().getOrThrow() + + assertTrue(dao.rows.isEmpty()) + } + + private fun photoRow( + id: String, + timelineId: Long? = null, + ) = WorkoutPhotoEntity( + id = id, + workoutId = ACTIVITY_ID, + filePath = "$id.jpg", + pointIndex = 1, + latitude = 37.5, + longitude = 127.0, + elevation = 0.0, + recordedAt = Instant.parse("2026-10-24T01:00:00Z"), + takenAt = Instant.parse("2026-10-24T01:00:00Z"), + title = "", + timelineId = timelineId, + serverTitle = null, + serverImageUrl = null, + ) + + private class FakeWorkoutPhotoDao : WorkoutPhotoDao { + val rows = mutableListOf() + + override suspend fun getPhotos(workoutId: Long): List = + rows.filter { it.workoutId == workoutId } + + override suspend fun insertPhotos(photos: List) { + rows += photos + } + + override suspend fun deletePhotos(workoutId: Long) { + rows.removeAll { it.workoutId == workoutId } + } + + override suspend fun clearPhotos() { + rows.clear() + } + } + private class FakeRecapRepository : RecapRepository { var trackError: Throwable? = null var trackCallCount = 0 @@ -168,10 +269,19 @@ class WorkoutPhotoRepositoryImplTest { } private class FakeTimelinePhotoRepository : TimelinePhotoRepository { + val uploadedIds = mutableListOf() + val deletedTimelineIds = mutableListOf() + var uploadError: Throwable? = null + var deleteError: Throwable? = null + override suspend fun uploadPhotos( activityId: Long, photos: List, - ): List = emptyList() + ): List = photos.map { photo -> + uploadedIds += photo.clientId + val result = uploadError?.let { Result.failure(it) } ?: Result.success(UPLOADED_TIMELINE_ID) + TimelinePhotoUploadResult(clientId = photo.clientId, result = result) + } override suspend fun updateTitle( activityId: Long, @@ -182,12 +292,17 @@ class WorkoutPhotoRepositoryImplTest { override suspend fun deletePhoto( activityId: Long, timelineId: Long, - ): Result = Result.success(Unit) + ): Result { + deleteError?.let { return Result.failure(it) } + deletedTimelineIds += timelineId + return Result.success(Unit) + } override suspend fun clearUploadState(activityId: Long) = Unit } private companion object { const val ACTIVITY_ID = 1L + const val UPLOADED_TIMELINE_ID = 20L } } From b57d35bc37d87ee300769de2ba800cb23037bdd8 Mon Sep 17 00:00:00 2001 From: seungjun Date: Sat, 7 Nov 2026 19:53:46 +0900 Subject: [PATCH 06/16] =?UTF-8?q?[MOD/#222]=20=ED=83=80=EC=9E=84=EB=9D=BC?= =?UTF-8?q?=EC=9D=B8=20=EC=82=AC=EC=A7=84=EC=9D=84=20=EC=84=9C=EB=B2=84=20?= =?UTF-8?q?=EC=A1=B0=ED=9A=8C=20=EC=97=86=EC=9D=B4=20=EA=B8=B0=EA=B8=B0=20?= =?UTF-8?q?=EB=8D=B0=EC=9D=B4=ED=84=B0=EB=A1=9C=20=ED=91=9C=EC=8B=9C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../workout/SaveFinishedWorkoutUseCase.kt | 3 ++- .../workout/SaveFinishedWorkoutUseCaseTest.kt | 8 ++++---- .../feature/timeline/main/TimelineViewModel.kt | 9 +++++++++ .../timeline/main/model/TimelinePhotos.kt | 17 +++++++++++++++++ 4 files changed, 32 insertions(+), 5 deletions(-) create mode 100644 feature/timeline/impl/src/main/java/com/routee/android/feature/timeline/main/model/TimelinePhotos.kt diff --git a/core/domain/src/main/java/com/routee/android/core/domain/workout/SaveFinishedWorkoutUseCase.kt b/core/domain/src/main/java/com/routee/android/core/domain/workout/SaveFinishedWorkoutUseCase.kt index 2bbaeec4..ebe3ee81 100644 --- a/core/domain/src/main/java/com/routee/android/core/domain/workout/SaveFinishedWorkoutUseCase.kt +++ b/core/domain/src/main/java/com/routee/android/core/domain/workout/SaveFinishedWorkoutUseCase.kt @@ -36,7 +36,8 @@ class SaveFinishedWorkoutUseCase @Inject constructor( val missingPhotoCount = photoRepository.syncPhotos(record.activityId) remoteRepository.completeWorkout(record, state.trackPoints, objectKey) .getOrElse { return failed(it) } - clearRecord() + // 타임라인이 서버를 다시 부르지 않게 사진은 남김, 다음 운동 시작이나 로그아웃 때 지움 + trackingRepository.clear() return if (missingPhotoCount > 0) WorkoutSaveResult.PhotosMissing else WorkoutSaveResult.Saved } diff --git a/core/domain/src/test/java/com/routee/android/core/domain/workout/SaveFinishedWorkoutUseCaseTest.kt b/core/domain/src/test/java/com/routee/android/core/domain/workout/SaveFinishedWorkoutUseCaseTest.kt index db42291d..296d162c 100644 --- a/core/domain/src/test/java/com/routee/android/core/domain/workout/SaveFinishedWorkoutUseCaseTest.kt +++ b/core/domain/src/test/java/com/routee/android/core/domain/workout/SaveFinishedWorkoutUseCaseTest.kt @@ -54,17 +54,17 @@ class SaveFinishedWorkoutUseCaseTest { /** * GIVEN: 찍을 때 못 올린 사진이 있는 종료한 기록일 때 * WHEN: 저장하면 - * THEN: 완료 전에 사진을 다시 올리고, 저장 후 기기 사진을 지운다 + * THEN: 완료 전에 사진을 다시 올리고, 타임라인에 보여주게 기기 사진은 남긴다 */ @Test - fun `저장하면 못 올린 사진을 다시 올리고 기기 사진을 지운다`() = runTest { + fun `저장하면 못 올린 사진을 다시 올리고 기기 사진은 남긴다`() = runTest { tracking.state(points = 2) val result = saveFinishedWorkout(JPEG) assertEquals(WorkoutSaveResult.Saved, result) assertEquals(listOf(7L), photos.syncedActivityIds) - assertTrue(photos.isCleared) + assertFalse(photos.isCleared) } /** @@ -82,7 +82,7 @@ class SaveFinishedWorkoutUseCaseTest { assertEquals(WorkoutSaveResult.PhotosMissing, result) assertEquals("map-key", remote.completedKey) - assertTrue(photos.isCleared) + assertFalse(photos.isCleared) } /** diff --git a/feature/timeline/impl/src/main/java/com/routee/android/feature/timeline/main/TimelineViewModel.kt b/feature/timeline/impl/src/main/java/com/routee/android/feature/timeline/main/TimelineViewModel.kt index 1d670779..175d07fa 100644 --- a/feature/timeline/impl/src/main/java/com/routee/android/feature/timeline/main/TimelineViewModel.kt +++ b/feature/timeline/impl/src/main/java/com/routee/android/feature/timeline/main/TimelineViewModel.kt @@ -9,6 +9,7 @@ import com.routee.android.core.data.archive.model.ArchivePhoto import com.routee.android.core.data.archive.repository.ArchiveDetailRepository import com.routee.android.core.data.photo.GalleryImageStore import com.routee.android.core.data.recap.repository.RecapRepository +import com.routee.android.core.data.workout.repository.WorkoutPhotoRepository import com.routee.android.core.navigation.util.NavKeyViewModelFactory import com.routee.android.core.ui.UiState import com.routee.android.feature.timeline.api.TimelineNavKey @@ -18,6 +19,7 @@ import com.routee.android.feature.timeline.main.model.TimelineRequestResult import com.routee.android.feature.timeline.main.model.TimelineSideEffect import com.routee.android.feature.timeline.main.model.TimelineUiState import com.routee.android.feature.timeline.main.model.toRequestFailure +import com.routee.android.feature.timeline.main.model.toTimelinePhotos import com.routee.android.feature.timeline.main.model.toTimelineTrack import dagger.assisted.Assisted import dagger.assisted.AssistedFactory @@ -41,6 +43,7 @@ internal class TimelineViewModel @AssistedInject constructor( private val recordSaver: TimelineRecordSaver, private val archiveDetailRepository: ArchiveDetailRepository, private val recapRepository: RecapRepository, + private val workoutPhotoRepository: WorkoutPhotoRepository, ) : ViewModel() { val activityId = key.activityId val endedAtEpochMillis = key.endedAtEpochMillis @@ -118,7 +121,13 @@ internal class TimelineViewModel @AssistedInject constructor( } } + // 종료 때 올린 사진이 기기에 있으면 서버를 부르지 않음 private fun loadPhotos() { + val devicePhotos = workoutPhotoRepository.photos.value.toTimelinePhotos(activityId) + if (devicePhotos.isNotEmpty()) { + showPhotos(devicePhotos) + return + } viewModelScope.launch { // TODO P1 기획: 사진 목록 조회 실패 안내 (지금은 사진 섹션, 나의 루트 초기 목록 없이 진행) archiveDetailRepository.getPhotos(activityId) diff --git a/feature/timeline/impl/src/main/java/com/routee/android/feature/timeline/main/model/TimelinePhotos.kt b/feature/timeline/impl/src/main/java/com/routee/android/feature/timeline/main/model/TimelinePhotos.kt new file mode 100644 index 00000000..499b585b --- /dev/null +++ b/feature/timeline/impl/src/main/java/com/routee/android/feature/timeline/main/model/TimelinePhotos.kt @@ -0,0 +1,17 @@ +package com.routee.android.feature.timeline.main.model + +import com.routee.android.core.data.archive.model.ArchivePhoto +import com.routee.android.core.data.workout.model.WorkoutPhoto +import java.io.File + +/** 기기에 남은 [activityId] 사진 중 서버에 올린 사진, 못 올린 사진은 기록에 없어 뺌 */ +internal fun List.toTimelinePhotos(activityId: Long): List = + filter { it.activityId == activityId } + .mapNotNull { photo -> + val timelineId = photo.timelineId ?: return@mapNotNull null + val imageUrl = photo.filePath?.let { File(it).toURI().toString() } + ?: photo.serverImageUrl + ?: return@mapNotNull null + ArchivePhoto(timelineId, photo.title.takeIf(String::isNotBlank), imageUrl, photo.takenAt) + } + .sortedBy { it.createdAt } From a568fd6b788141dc6f07f407f69a5cd7c051c062 Mon Sep 17 00:00:00 2001 From: seungjun Date: Sat, 7 Nov 2026 19:53:47 +0900 Subject: [PATCH 07/16] =?UTF-8?q?[MOD/#222]=20=EC=82=AC=EC=A7=84=20?= =?UTF-8?q?=EC=82=AD=EC=A0=9C=EB=A5=BC=20=EC=84=9C=EB=B2=84=20=EC=9D=91?= =?UTF-8?q?=EB=8B=B5=EC=9D=84=20=EB=B0=9B=EC=9D=80=20=EB=92=A4=EC=97=90?= =?UTF-8?q?=EB=A7=8C=20=EB=B0=98=EC=98=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../repository/WorkoutPhotoRepository.kt | 8 +-- .../repository/WorkoutPhotoRepositoryImpl.kt | 54 ++++--------------- .../WorkoutPhotoRepositoryImplTest.kt | 53 ++++++++++++++++++ .../workout/FakeWorkoutPhotoRepository.kt | 3 +- .../setting/FakeDeviceDataRepositories.kt | 2 +- .../recording/WorkoutRecordingViewModel.kt | 25 +++++---- .../workout/FakeWorkoutRepositories.kt | 5 +- .../WorkoutRecordingViewModelTest.kt | 27 +++++++++- 8 files changed, 112 insertions(+), 65 deletions(-) diff --git a/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepository.kt b/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepository.kt index bbfa3e9f..9d3a3194 100644 --- a/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepository.kt +++ b/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepository.kt @@ -6,7 +6,7 @@ import java.io.File import java.time.Instant import kotlinx.coroutines.flow.StateFlow -/** 진행 중인 운동의 사진, 기기에서 먼저 바꾸고 [syncPhotos]로 서버에 반영 */ +/** 진행 중인 운동의 사진, 업로드와 장소명은 기기에서 먼저 바꾸고 [syncPhotos]로 서버에 반영 */ interface WorkoutPhotoRepository { /** 지금 기록의 사진, 찍은 순서 */ val photos: StateFlow> @@ -38,13 +38,13 @@ interface WorkoutPhotoRepository { title: String, ) - /** 사진 삭제, 다음 [syncPhotos] 때 기기 파일과 서버 사진도 지움 */ - fun removePhoto(photoId: String) + /** 사진 삭제, 서버에서 지운 뒤 기기에서 지움. 실패하면 사진은 그대로 */ + suspend fun deletePhoto(photoId: String): Result /** 앱이 다시 켜져 비어 있으면 기기에 저장한 사진으로, 그것도 없으면 서버에 올린 사진으로 채움. 이미 있으면 그대로 */ suspend fun restore(activityId: Long): Result - /** 못 올린 사진 업로드, 바뀐 장소명 수정, 지운 사진 삭제를 서버에 반영. 끝까지 못 올린 사진 수 반환 */ + /** 못 올린 사진 업로드, 바뀐 장소명 수정을 서버에 반영. 끝까지 못 올린 사진 수 반환 */ suspend fun syncPhotos(activityId: Long): Int /** 기기의 사진 전체 삭제 */ diff --git a/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepositoryImpl.kt b/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepositoryImpl.kt index 9d597843..602be9b7 100644 --- a/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepositoryImpl.kt +++ b/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepositoryImpl.kt @@ -40,12 +40,6 @@ internal class WorkoutPhotoRepositoryImpl @Inject constructor( private val _photos = MutableStateFlow>(emptyList()) override val photos: StateFlow> = _photos.asStateFlow() - // 서버에서 지울 사진 (activityId, timelineId) - private val removedTimelines = MutableStateFlow>>(emptySet()) - - // 기기에서 지울 사진 파일, 올리는 중일 수 있어 동기화 때 지움 - private val removedFiles = MutableStateFlow>(emptySet()) - // 기기에 저장한 사진을 이미 불러온 기록, 지운 사진을 다시 불러오지 않게 앱 실행마다 한 번만 private var loadedActivityId: Long? = null private val mutex = Mutex() @@ -105,15 +99,14 @@ internal class WorkoutPhotoRepositoryImpl @Inject constructor( _photos.update { photos -> photos.map { if (it.id == photoId) it.copy(title = title) else it } } } - override fun removePhoto(photoId: String) { - var removed: WorkoutPhoto? = null - _photos.update { photos -> - removed = photos.find { it.id == photoId } - photos.filterNot { it.id == photoId } - } - removed?.let { photo -> - photo.filePath?.let { path -> removedFiles.update { it + path } } - photo.timelineId?.let { markRemoved(photo.activityId, it) } + // 올리는 중이면 끝난 뒤에 지움 + override suspend fun deletePhoto(photoId: String): Result = syncMutex.withLock { + suspendRunCatching { + val photo = _photos.value.find { it.id == photoId } ?: return@suspendRunCatching + photo.timelineId?.let { timelinePhotoRepository.deletePhoto(photo.activityId, it).getOrThrow() } + _photos.update { photos -> photos.filterNot { it.id == photoId } } + photo.filePath?.let { localDataSource.delete(it) } + savePhotos(photo.activityId) } } @@ -121,10 +114,8 @@ internal class WorkoutPhotoRepositoryImpl @Inject constructor( loadSavedPhotos(activityId) savePhotos(activityId) return syncMutex.withLock { - deleteRemovedFiles() uploadPending(activityId) updateTitles(activityId) - deleteRemoved(activityId) savePhotos(activityId) _photos.value.count { it.activityId == activityId && it.timelineId == null } } @@ -134,8 +125,6 @@ internal class WorkoutPhotoRepositoryImpl @Inject constructor( mutex.withLock { _photos.value.map { it.activityId }.distinct().forEach { timelinePhotoRepository.clearUploadState(it) } _photos.value = emptyList() - removedTimelines.value = emptySet() - removedFiles.value = emptySet() loadedActivityId = null localDataSource.clear() photoDao.clearPhotos() @@ -178,9 +167,6 @@ internal class WorkoutPhotoRepositoryImpl @Inject constructor( timelineIds[photo.id]?.let { photo.copy(timelineId = it, serverTitle = sentTitles[photo.id]) } ?: photo } } - // 올리는 동안 지운 사진은 서버에서도 지움 - val remaining = _photos.value.map { it.id }.toSet() - timelineIds.filterKeys { it !in remaining }.values.forEach { markRemoved(activityId, it) } } // 서버는 빈 장소명으로 수정하지 않음 @@ -197,36 +183,14 @@ internal class WorkoutPhotoRepositoryImpl @Inject constructor( } } - private suspend fun deleteRemovedFiles() { - val paths = removedFiles.value - paths.forEach { localDataSource.delete(it) } - removedFiles.update { it - paths } - } - - private suspend fun deleteRemoved(activityId: Long) { - removedTimelines.value.filter { it.first == activityId }.forEach { removed -> - timelinePhotoRepository.deletePhoto(activityId, removed.second).onSuccess { - removedTimelines.update { it - removed } - } - } - } - - // 이전 기록에서 남은 사진, 업로드 상태, 지울 사진 정리 + // 이전 기록에서 남은 사진, 업로드 상태 정리 private suspend fun clearOthers(activityId: Long) { val others = _photos.value.map { it.activityId }.distinct().filter { it != activityId } if (others.isEmpty()) return localDataSource.deleteOthers(activityId) others.forEach { timelinePhotoRepository.clearUploadState(it) } - removedTimelines.update { removed -> removed.filterTo(mutableSetOf()) { it.first == activityId } } _photos.update { photos -> photos.filter { it.activityId == activityId } } } - - private fun markRemoved( - activityId: Long, - timelineId: Long, - ) { - removedTimelines.update { it + (activityId to timelineId) } - } } // 기기 파일이 없으면 올릴 수 없어 null diff --git a/core/data/src/test/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepositoryImplTest.kt b/core/data/src/test/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepositoryImplTest.kt index cf7a111c..75694b22 100644 --- a/core/data/src/test/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepositoryImplTest.kt +++ b/core/data/src/test/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepositoryImplTest.kt @@ -149,6 +149,59 @@ class WorkoutPhotoRepositoryImplTest { assertEquals(1, repository.syncPhotos(ACTIVITY_ID)) } + /** + * GIVEN: 서버에 올린 사진이 있을 때 + * WHEN: 사진을 지우면 + * THEN: 서버와 기기에서 모두 지운다 + */ + @Test + fun `올린 사진을 지우면 서버와 기기에서 지운다`() = runTest { + dao.rows += photoRow(id = "a", timelineId = 3) + repository.restore(ACTIVITY_ID).getOrThrow() + + repository.deletePhoto("a").getOrThrow() + + assertEquals(listOf(3L), timelinePhotos.deletedTimelineIds) + assertTrue(repository.photos.value.isEmpty()) + assertTrue(dao.rows.isEmpty()) + } + + /** + * GIVEN: 서버 삭제가 실패할 때 + * WHEN: 올린 사진을 지우면 + * THEN: 실패를 돌려주고 사진은 그대로 둔다 + */ + @Test + fun `서버 삭제가 실패하면 사진을 그대로 둔다`() = runTest { + dao.rows += photoRow(id = "a", timelineId = 3) + timelinePhotos.deleteError = IOException() + repository.restore(ACTIVITY_ID).getOrThrow() + + assertTrue(repository.deletePhoto("a").isFailure) + + assertEquals("a", repository.photos.value.single().id) + assertEquals("a", dao.rows.single().id) + } + + /** + * GIVEN: 아직 못 올린 사진을 지웠을 때 + * WHEN: 사진을 반영하면 + * THEN: 서버를 부르지 않고, 지운 사진을 다시 불러오거나 올리지 않는다 + */ + @Test + fun `못 올린 사진을 지우면 다시 불러오지 않는다`() = runTest { + dao.rows += photoRow(id = "a") + repository.restore(ACTIVITY_ID).getOrThrow() + + repository.deletePhoto("a").getOrThrow() + repository.syncPhotos(ACTIVITY_ID) + + assertTrue(timelinePhotos.deletedTimelineIds.isEmpty()) + assertTrue(timelinePhotos.uploadedIds.isEmpty()) + assertTrue(repository.photos.value.isEmpty()) + assertTrue(dao.rows.isEmpty()) + } + /** * GIVEN: 기기에 저장한 사진이 있을 때 * WHEN: 사진을 모두 지우면 diff --git a/core/domain/src/test/java/com/routee/android/core/domain/workout/FakeWorkoutPhotoRepository.kt b/core/domain/src/test/java/com/routee/android/core/domain/workout/FakeWorkoutPhotoRepository.kt index 0af4469e..d41a1d07 100644 --- a/core/domain/src/test/java/com/routee/android/core/domain/workout/FakeWorkoutPhotoRepository.kt +++ b/core/domain/src/test/java/com/routee/android/core/domain/workout/FakeWorkoutPhotoRepository.kt @@ -55,8 +55,9 @@ internal class FakeWorkoutPhotoRepository( _photos.value = _photos.value.map { if (it.id == photoId) it.copy(title = title) else it } } - override fun removePhoto(photoId: String) { + override suspend fun deletePhoto(photoId: String): Result { _photos.value = _photos.value.filterNot { it.id == photoId } + return Result.success(Unit) } override suspend fun syncPhotos(activityId: Long): Int { diff --git a/feature/setting/impl/src/test/java/com/routee/android/feature/setting/FakeDeviceDataRepositories.kt b/feature/setting/impl/src/test/java/com/routee/android/feature/setting/FakeDeviceDataRepositories.kt index 0b3b6da7..bcd32b4c 100644 --- a/feature/setting/impl/src/test/java/com/routee/android/feature/setting/FakeDeviceDataRepositories.kt +++ b/feature/setting/impl/src/test/java/com/routee/android/feature/setting/FakeDeviceDataRepositories.kt @@ -101,7 +101,7 @@ internal class FakeWorkoutPhotoRepository : WorkoutPhotoRepository { title: String, ) = Unit - override fun removePhoto(photoId: String) = Unit + override suspend fun deletePhoto(photoId: String): Result = Result.success(Unit) override suspend fun syncPhotos(activityId: Long): Int = 0 diff --git a/feature/workout/impl/src/main/java/com/routee/android/feature/workout/recording/WorkoutRecordingViewModel.kt b/feature/workout/impl/src/main/java/com/routee/android/feature/workout/recording/WorkoutRecordingViewModel.kt index b6727a8b..1a16689b 100644 --- a/feature/workout/impl/src/main/java/com/routee/android/feature/workout/recording/WorkoutRecordingViewModel.kt +++ b/feature/workout/impl/src/main/java/com/routee/android/feature/workout/recording/WorkoutRecordingViewModel.kt @@ -99,6 +99,9 @@ internal class WorkoutRecordingViewModel @AssistedInject constructor( // 삭제 스낵바가 떠 있는 사진, 스낵바가 닫히면 삭제 확정 private val pendingDeletePhotoId = MutableStateFlow(null) + // 서버 삭제를 기다리는 사진, 실패하면 다시 보임 + private val deletingPhotoIds = MutableStateFlow>(emptySet()) + init { moveToLastLocation() prepareRecording() @@ -220,7 +223,7 @@ internal class WorkoutRecordingViewModel @AssistedInject constructor( syncPhotos() } - /** 사진 모달에서 삭제, 지도와 개수에서 바로 빼고 스낵바가 닫히면 확정 */ + /** 사진 모달에서 삭제, 지도와 개수에서 바로 빼고 스낵바가 닫히면 서버에서 지움 */ fun onPhotoDeleteClick() { val photo = _uiState.value.openedPhoto ?: return confirmPhotoDelete() @@ -298,11 +301,6 @@ internal class WorkoutRecordingViewModel @AssistedInject constructor( viewModelScope.launch { _sideEffect.send(WorkoutRecordingSideEffect.NavigateToHome) } } - // 스낵바가 결과 없이 닫혀도 화면을 떠날 때 확정 - override fun onCleared() { - confirmPhotoDelete() - } - private suspend fun finishWorkout() { trackingRepository.finish().onFailure { Timber.e(it, "운동 종료 실패") @@ -351,7 +349,7 @@ internal class WorkoutRecordingViewModel @AssistedInject constructor( } } - // 앱이 다시 켜져 사진 목록이 비었으면 서버에 올린 사진으로 마커와 개수 복구, 복구면 카운트다운 동안 + // 앱이 다시 켜져 사진 목록이 비었으면 기기에 저장한 사진으로 마커와 개수 복구, 없으면 서버에서. 복구면 카운트다운 동안 private fun restorePhotos() { val activityId = trackingRepository.state.value.record?.activityId ?: return viewModelScope.launch { photoRepository.restore(activityId).onFailure { Timber.e(it, "운동 사진 복구 실패") } } @@ -410,8 +408,9 @@ internal class WorkoutRecordingViewModel @AssistedInject constructor( trackingRepository.state.map { it.record?.activityId }.distinctUntilChanged(), photoRepository.photos, pendingDeletePhotoId, - ) { activityId, photos, pendingDeleteId -> - photos.filter { it.activityId == activityId && it.id != pendingDeleteId } + deletingPhotoIds, + ) { activityId, photos, pendingDeleteId, deletingIds -> + photos.filter { it.activityId == activityId && it.id != pendingDeleteId && it.id !in deletingIds } } .collect { photos -> _uiState.update { it.copy(photos = photos.map { photo -> photo.toMapPhoto() }.toImmutableList()) } @@ -433,10 +432,14 @@ internal class WorkoutRecordingViewModel @AssistedInject constructor( private fun confirmPhotoDelete() { val photoId = pendingDeletePhotoId.value ?: return - photoRepository.removePhoto(photoId) + deletingPhotoIds.update { it + photoId } pendingDeletePhotoId.value = null _uiState.update { it.copy(isPhotoDeletePending = false) } - syncPhotos() + viewModelScope.launch { + // TODO P1 기획: 사진 삭제 실패 안내 (지금은 사진만 다시 보임) + photoRepository.deletePhoto(photoId).onFailure { Timber.e(it, "사진 삭제 실패") } + deletingPhotoIds.update { it - photoId } + } } private fun syncPhotos() { diff --git a/feature/workout/impl/src/test/java/com/routee/android/feature/workout/FakeWorkoutRepositories.kt b/feature/workout/impl/src/test/java/com/routee/android/feature/workout/FakeWorkoutRepositories.kt index 883defa4..0b90cb05 100644 --- a/feature/workout/impl/src/test/java/com/routee/android/feature/workout/FakeWorkoutRepositories.kt +++ b/feature/workout/impl/src/test/java/com/routee/android/feature/workout/FakeWorkoutRepositories.kt @@ -178,6 +178,7 @@ internal class FakeWorkoutPhotoRepository( private val missingCount: Int = 0, private val serverPhotos: List = emptyList(), ) : WorkoutPhotoRepository { + var deleteError: Throwable? = null private val _photos = MutableStateFlow>(emptyList()) override val photos: StateFlow> = _photos val discarded = mutableListOf() @@ -229,8 +230,10 @@ internal class FakeWorkoutPhotoRepository( _photos.value = _photos.value.map { if (it.id == photoId) it.copy(title = title) else it } } - override fun removePhoto(photoId: String) { + override suspend fun deletePhoto(photoId: String): Result { + deleteError?.let { return Result.failure(it) } _photos.value = _photos.value.filterNot { it.id == photoId } + return Result.success(Unit) } override suspend fun syncPhotos(activityId: Long): Int = missingCount diff --git a/feature/workout/impl/src/test/java/com/routee/android/feature/workout/recording/WorkoutRecordingViewModelTest.kt b/feature/workout/impl/src/test/java/com/routee/android/feature/workout/recording/WorkoutRecordingViewModelTest.kt index 0350e94d..0d5a5e7b 100644 --- a/feature/workout/impl/src/test/java/com/routee/android/feature/workout/recording/WorkoutRecordingViewModelTest.kt +++ b/feature/workout/impl/src/test/java/com/routee/android/feature/workout/recording/WorkoutRecordingViewModelTest.kt @@ -657,10 +657,10 @@ class WorkoutRecordingViewModelTest { /** * GIVEN: 사진 2장이 있는 기록 중일 때 * WHEN: 모달에서 삭제하고 스낵바가 시간이 지나 닫히면 - * THEN: 지도와 개수에서 바로 빼고, 스낵바가 닫히면 삭제를 확정한다 + * THEN: 지도와 개수에서 바로 빼고, 스낵바가 닫히면 서버에서 지운다 */ @Test - fun `삭제하면 바로 빼고 스낵바가 닫히면 확정한다`() = runTest { + fun `삭제하면 바로 빼고 스낵바가 닫히면 지운다`() = runTest { val photos = FakeWorkoutPhotoRepository().apply { setPhotos(listOf(photo("a"), photo("b"))) } val viewModel = viewModel(FakeWorkoutTrackingRepository(record()), photos = photos) viewModel.onPhotoMarkerClick("a") @@ -703,6 +703,29 @@ class WorkoutRecordingViewModelTest { viewModel.close() } + /** + * GIVEN: 서버 삭제가 실패할 때 + * WHEN: 삭제 스낵바가 닫히면 + * THEN: 사진과 개수를 되돌린다 + */ + @Test + fun `서버 삭제가 실패하면 사진을 되돌린다`() = runTest { + val photos = FakeWorkoutPhotoRepository().apply { + setPhotos(listOf(photo("a"))) + deleteError = IOException() + } + val viewModel = viewModel(FakeWorkoutTrackingRepository(record()), photos = photos) + viewModel.onPhotoMarkerClick("a") + viewModel.onPhotoDeleteClick() + + viewModel.onPhotoDeleteSnackbarClose("a", isUndone = false) + + assertEquals(1, viewModel.uiState.value.photoCount) + assertEquals(1, photos.photos.value.size) + assertFalse(viewModel.uiState.value.isPhotoDeletePending) + viewModel.close() + } + /** * GIVEN: 사진을 삭제해 스낵바가 떠 있을 때 * WHEN: 카메라 버튼을 누르면 From abf633d7a95073df70d9111d9558390a429fc0c0 Mon Sep 17 00:00:00 2001 From: seungjun Date: Sat, 7 Nov 2026 19:53:50 +0900 Subject: [PATCH 08/16] =?UTF-8?q?[REFACTOR/#222]=20=EC=93=B0=EC=A7=80=20?= =?UTF-8?q?=EC=95=8A=EB=8A=94=20=EC=A7=80=EB=8F=84=20=ED=82=A4,=20?= =?UTF-8?q?=ED=8C=8C=EC=9D=BC=20=EA=B2=BD=EB=A1=9C,=20=EC=97=85=EB=A1=9C?= =?UTF-8?q?=EB=93=9C=20=EB=8C=80=EA=B8=B0=20=EA=B8=B0=EB=A1=9D=20=EB=B6=88?= =?UTF-8?q?=EB=9F=AC=EC=98=A4=EA=B8=B0=20=EC=A0=9C=EA=B1=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../repository/TimelineMapImageRepository.kt | 9 +- .../TimelineMapImageRepositoryImpl.kt | 21 +--- .../data/workout/local/WorkoutEntityMapper.kt | 4 - .../local/WorkoutMapImageLocalDataSource.kt | 64 ----------- .../core/data/workout/model/WorkoutRecord.kt | 15 +-- .../repository/WorkoutRecordRepository.kt | 10 +- .../repository/WorkoutRecordRepositoryImpl.kt | 15 --- .../repository/WorkoutTrackingRepository.kt | 3 - .../WorkoutTrackingRepositoryImpl.kt | 11 -- .../WorkoutMapImageLocalDataSourceTest.kt | 53 --------- .../workout/model/UnfinishedWorkoutTest.kt | 2 - .../data/workout/model/WorkoutRecordTest.kt | 9 +- .../workout/model/WorkoutTrackingStateTest.kt | 2 - .../WorkoutRecordRepositoryImplTest.kt | 64 +---------- .../WorkoutRemoteRepositoryImplTest.kt | 2 - .../WorkoutTrackingRepositoryImplTest.kt | 43 +------ .../2.json | 16 +-- .../core/database/dao/WorkoutDaoTest.kt | 2 - .../android/core/database/RouteeDatabase.kt | 8 +- .../core/database/entity/WorkoutEntity.kt | 28 ++--- .../workout/SaveFinishedWorkoutUseCase.kt | 28 +---- .../domain/auth/ClearDeviceDataUseCaseTest.kt | 7 -- .../workout/SaveFinishedWorkoutUseCaseTest.kt | 105 ++---------------- .../domain/workout/TrackWorkoutUseCaseTest.kt | 4 - .../workout/WorkoutPhotoTestFixtures.kt | 4 - docs/architecture/data-layer.md | 2 +- .../setting/FakeDeviceDataRepositories.kt | 7 -- .../workout/FakeWorkoutRepositories.kt | 22 +--- .../workout/main/WorkoutMainViewModelTest.kt | 1 - .../WorkoutRecordingViewModelTest.kt | 1 - .../WorkoutNotificationContentTest.kt | 2 - 31 files changed, 52 insertions(+), 512 deletions(-) delete mode 100644 core/data/src/main/java/com/routee/android/core/data/workout/local/WorkoutMapImageLocalDataSource.kt delete mode 100644 core/data/src/test/java/com/routee/android/core/data/workout/local/WorkoutMapImageLocalDataSourceTest.kt diff --git a/core/data/src/main/java/com/routee/android/core/data/timeline/repository/TimelineMapImageRepository.kt b/core/data/src/main/java/com/routee/android/core/data/timeline/repository/TimelineMapImageRepository.kt index 670b8e4e..06846221 100644 --- a/core/data/src/main/java/com/routee/android/core/data/timeline/repository/TimelineMapImageRepository.kt +++ b/core/data/src/main/java/com/routee/android/core/data/timeline/repository/TimelineMapImageRepository.kt @@ -1,14 +1,9 @@ package com.routee.android.core.data.timeline.repository -import android.graphics.Bitmap import com.routee.android.core.data.workout.exception.WorkoutException -import java.io.File /** 기록 완료용 지도 이미지 업로드 */ interface TimelineMapImageRepository { - /** 지도 스냅샷 업로드와 완료 요청에 사용할 object key 반환 */ - suspend fun uploadMapImage(activityId: Long, bitmap: Bitmap): Result - - /** 저장해 둔 지도 캡처 파일 업로드, object key 반환. 서버에 기록이 없으면 [WorkoutException.Rejected] */ - suspend fun uploadMapImage(activityId: Long, imageFile: File): Result + /** 지도 캡처 JPEG 업로드, 완료 요청에 쓸 object key 반환. 서버에 기록이 없으면 [WorkoutException.Rejected] */ + suspend fun uploadMapImage(activityId: Long, jpeg: ByteArray): Result } diff --git a/core/data/src/main/java/com/routee/android/core/data/timeline/repository/TimelineMapImageRepositoryImpl.kt b/core/data/src/main/java/com/routee/android/core/data/timeline/repository/TimelineMapImageRepositoryImpl.kt index fdaffdad..2cb4862a 100644 --- a/core/data/src/main/java/com/routee/android/core/data/timeline/repository/TimelineMapImageRepositoryImpl.kt +++ b/core/data/src/main/java/com/routee/android/core/data/timeline/repository/TimelineMapImageRepositoryImpl.kt @@ -1,11 +1,9 @@ package com.routee.android.core.data.timeline.repository import android.content.Context -import android.graphics.Bitmap import com.routee.android.core.common.util.suspendRunCatching import com.routee.android.core.data.timeline.remote.service.TimelineMapImageService import com.routee.android.core.data.upload.PresignedImageUploader -import com.routee.android.core.data.upload.UPLOAD_JPEG_QUALITY import com.routee.android.core.data.upload.remote.dto.request.ImageUrlRequest import com.routee.android.core.data.workout.exception.mapWorkoutException import com.routee.android.core.network.extension.mapApiException @@ -22,29 +20,16 @@ internal class TimelineMapImageRepositoryImpl @Inject constructor( private val uploader: PresignedImageUploader, private val apiResponseHandler: ApiResponseHandler, ) : TimelineMapImageRepository { - override suspend fun uploadMapImage(activityId: Long, bitmap: Bitmap): Result = suspendRunCatching { - val imageFile = withContext(Dispatchers.IO) { - File.createTempFile("routee_map_", ".jpg", context.cacheDir).also { file -> - try { - file.outputStream().use { output -> - check(bitmap.compress(Bitmap.CompressFormat.JPEG, UPLOAD_JPEG_QUALITY, output)) - } - } catch (error: Exception) { - file.delete() - throw error - } - } - } + override suspend fun uploadMapImage(activityId: Long, jpeg: ByteArray): Result = suspendRunCatching { + val imageFile = File(context.cacheDir, "$activityId.jpg") try { + withContext(Dispatchers.IO) { imageFile.writeBytes(jpeg) } uploadFile(activityId, imageFile).getOrThrow() } finally { imageFile.delete() } } - override suspend fun uploadMapImage(activityId: Long, imageFile: File): Result = - uploadFile(activityId, imageFile) - private suspend fun uploadFile(activityId: Long, imageFile: File): Result { val url = apiResponseHandler.safeApiCall { service.createMapImageUrl(activityId, ImageUrlRequest(imageFile.name)) diff --git a/core/data/src/main/java/com/routee/android/core/data/workout/local/WorkoutEntityMapper.kt b/core/data/src/main/java/com/routee/android/core/data/workout/local/WorkoutEntityMapper.kt index 06b59946..65330f03 100644 --- a/core/data/src/main/java/com/routee/android/core/data/workout/local/WorkoutEntityMapper.kt +++ b/core/data/src/main/java/com/routee/android/core/data/workout/local/WorkoutEntityMapper.kt @@ -22,8 +22,6 @@ internal fun WorkoutEntity.toModel() = WorkoutRecord( distanceMeters = distance, maxElevationMeters = maxElevation, endedAt = endedAt, - mapImageObjectKey = mapImageObjectKey, - mapImagePath = mapImagePath, ) internal fun WorkoutRecord.toEntity() = WorkoutEntity( @@ -39,8 +37,6 @@ internal fun WorkoutRecord.toEntity() = WorkoutEntity( distance = distanceMeters, maxElevation = maxElevationMeters, endedAt = endedAt, - mapImageObjectKey = mapImageObjectKey, - mapImagePath = mapImagePath, ) internal fun TrackPointEntity.toModel() = TrackPoint( diff --git a/core/data/src/main/java/com/routee/android/core/data/workout/local/WorkoutMapImageLocalDataSource.kt b/core/data/src/main/java/com/routee/android/core/data/workout/local/WorkoutMapImageLocalDataSource.kt deleted file mode 100644 index f15b0ef0..00000000 --- a/core/data/src/main/java/com/routee/android/core/data/workout/local/WorkoutMapImageLocalDataSource.kt +++ /dev/null @@ -1,64 +0,0 @@ -package com.routee.android.core.data.workout.local - -import android.content.Context -import dagger.hilt.android.qualifiers.ApplicationContext -import java.io.File -import java.nio.file.Files -import java.nio.file.StandardCopyOption -import javax.inject.Inject -import kotlinx.coroutines.Dispatchers -import kotlinx.coroutines.withContext - -/** 운동 기록 지도 캡처 파일, 기록마다 한 장 */ -internal class WorkoutMapImageLocalDataSource( - private val directory: () -> File, -) { - @Inject - constructor( - @ApplicationContext context: Context, - ) : this({ File(context.filesDir, DIRECTORY) }) - - /** 캡처 저장, 같은 기록이면 덮어씀. 파일 경로 반환 */ - suspend fun save( - activityId: Long, - jpeg: ByteArray, - ): String = withContext(Dispatchers.IO) { - val dir = directory().apply { mkdirs() } - val target = File(dir, "$activityId$IMAGE_SUFFIX") - val temp = File.createTempFile("$activityId$TEMP_SEPARATOR", TEMP_SUFFIX, dir) - try { - temp.writeBytes(jpeg) - Files.move( - temp.toPath(), - target.toPath(), - StandardCopyOption.REPLACE_EXISTING, - StandardCopyOption.ATOMIC_MOVE, - ) - } finally { - temp.delete() - } - target.path - } - - /** 기록의 캡처와 남은 임시 파일 삭제 */ - suspend fun delete(activityId: Long) { - withContext(Dispatchers.IO) { - directory() - .listFiles { file -> - file.name == "$activityId$IMAGE_SUFFIX" || file.name.startsWith("$activityId$TEMP_SEPARATOR") - }?.forEach(File::delete) - } - } - - /** 모든 캡처 삭제 */ - suspend fun clear() { - withContext(Dispatchers.IO) { directory().deleteRecursively() } - } - - private companion object { - const val DIRECTORY = "workout_map" - const val IMAGE_SUFFIX = ".jpg" - const val TEMP_SEPARATOR = "-temp-" - const val TEMP_SUFFIX = ".tmp" - } -} diff --git a/core/data/src/main/java/com/routee/android/core/data/workout/model/WorkoutRecord.kt b/core/data/src/main/java/com/routee/android/core/data/workout/model/WorkoutRecord.kt index 5fc0bef8..640b8ef2 100644 --- a/core/data/src/main/java/com/routee/android/core/data/workout/model/WorkoutRecord.kt +++ b/core/data/src/main/java/com/routee/android/core/data/workout/model/WorkoutRecord.kt @@ -16,8 +16,6 @@ val WORKOUT_PAUSE_LIMIT: Duration = Duration.ofHours(2) * @param pausedAt 일시정지 시각, 2시간 규칙 판단 * @param lastRecordedAt 마지막 위치 기록 시각, 복구 안내와 종료 후 저장 기준 * @param endedAt 종료 시각, 저장에 실패한 기록을 복구해 다시 종료할 때도 사용 - * @param mapImageObjectKey 지도 이미지 업로드 결과, 있으면 업로드 생략 - * @param mapImagePath 지도 캡처 파일 경로 */ data class WorkoutRecord( val activityId: Long, @@ -32,8 +30,6 @@ data class WorkoutRecord( val distanceMeters: Double, val maxElevationMeters: Double?, val endedAt: Instant?, - val mapImageObjectKey: String?, - val mapImagePath: String?, ) { /** 기록 중이거나 일시정지 중, 종료 후 저장 확인 전이면 false */ val isTracking: Boolean @@ -90,16 +86,11 @@ data class WorkoutRecord( /** * 복구 안내에서 고를 때까지 일시정지로 둠, 꺼져 있던 시간은 뺌 (durationMillis = 마지막 기록 시각까지, pausedAt = now) - * 저장에 실패한 종료 기록은 운동 시간과 종료 시각은 그대로 두고 일시정지로 되돌림, 지도는 다시 캡처 + * 저장에 실패한 종료 기록은 운동 시간과 종료 시각은 그대로 두고 일시정지로 되돌림 */ fun recovered(now: Instant): WorkoutRecord { if (status == WorkoutStatus.PENDING_UPLOAD) { - return copy( - status = WorkoutStatus.ACTIVITY_PAUSED, - pausedAt = now, - mapImageObjectKey = null, - mapImagePath = null, - ) + return copy(status = WorkoutStatus.ACTIVITY_PAUSED, pausedAt = now) } return copy( status = WorkoutStatus.ACTIVITY_PAUSED, @@ -151,8 +142,6 @@ data class WorkoutRecord( distanceMeters = 0.0, maxElevationMeters = null, endedAt = null, - mapImageObjectKey = null, - mapImagePath = null, ) } } diff --git a/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutRecordRepository.kt b/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutRecordRepository.kt index c299b76a..8a1f7424 100644 --- a/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutRecordRepository.kt +++ b/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutRecordRepository.kt @@ -7,7 +7,7 @@ import com.routee.android.core.data.workout.model.WorkoutRecord interface WorkoutRecordRepository { suspend fun getRecord(): Result - /** 새 기록 시작, 남아 있던 기록과 지도 캡처는 삭제 */ + /** 새 기록 시작, 남아 있던 기록은 삭제 */ suspend fun startRecord(record: WorkoutRecord): Result suspend fun saveRecord(record: WorkoutRecord): Result @@ -20,13 +20,7 @@ interface WorkoutRecordRepository { suspend fun getTrackPoints(activityId: Long): Result> - /** 지도 캡처 저장, 파일 경로를 넣은 기록 반환 */ - suspend fun saveMapImage( - record: WorkoutRecord, - jpeg: ByteArray, - ): Result - - /** 기록, 경로 좌표, 지도 캡처 삭제 */ + /** 기록, 경로 좌표 삭제 */ suspend fun deleteRecord(activityId: Long): Result suspend fun clearRecords(): Result diff --git a/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutRecordRepositoryImpl.kt b/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutRecordRepositoryImpl.kt index 9c188cbc..38321a3a 100644 --- a/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutRecordRepositoryImpl.kt +++ b/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutRecordRepositoryImpl.kt @@ -1,7 +1,6 @@ package com.routee.android.core.data.workout.repository import com.routee.android.core.common.util.suspendRunCatching -import com.routee.android.core.data.workout.local.WorkoutMapImageLocalDataSource import com.routee.android.core.data.workout.local.toEntity import com.routee.android.core.data.workout.local.toModel import com.routee.android.core.data.workout.model.TrackPoint @@ -11,13 +10,11 @@ import javax.inject.Inject internal class WorkoutRecordRepositoryImpl @Inject constructor( private val workoutDao: WorkoutDao, - private val mapImageLocalDataSource: WorkoutMapImageLocalDataSource, ) : WorkoutRecordRepository { override suspend fun getRecord(): Result = suspendRunCatching { workoutDao.getWorkout()?.toModel() } override suspend fun startRecord(record: WorkoutRecord): Result = suspendRunCatching { workoutDao.replaceWorkout(record.toEntity()) - mapImageLocalDataSource.clear() } override suspend fun saveRecord(record: WorkoutRecord): Result = suspendRunCatching { @@ -35,24 +32,12 @@ internal class WorkoutRecordRepositoryImpl @Inject constructor( workoutDao.getTrackPoints(activityId).map { it.toModel() } } - override suspend fun saveMapImage( - record: WorkoutRecord, - jpeg: ByteArray, - ): Result = suspendRunCatching { - val path = mapImageLocalDataSource.save(record.activityId, jpeg) - val saved = record.copy(mapImagePath = path) - checkUpdated(workoutDao.updateWorkout(saved.toEntity())) - saved - } - override suspend fun deleteRecord(activityId: Long): Result = suspendRunCatching { workoutDao.deleteWorkout(activityId) - mapImageLocalDataSource.delete(activityId) } override suspend fun clearRecords(): Result = suspendRunCatching { workoutDao.deleteWorkouts() - mapImageLocalDataSource.clear() } private fun checkUpdated(updatedRows: Int) { diff --git a/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutTrackingRepository.kt b/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutTrackingRepository.kt index 9cbdec4a..ba8d719e 100644 --- a/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutTrackingRepository.kt +++ b/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutTrackingRepository.kt @@ -45,9 +45,6 @@ interface WorkoutTrackingRepository { */ suspend fun finish(endedAt: Instant? = null): Result - /** 기기에 저장된 업로드 대기 기록을 경로와 함께 불러옴, 저장해 둔 지도 키와 캡처 경로도 반영. 기록 중이면 그대로 */ - suspend fun loadPendingUpload(): Result - /** 저장을 마쳤거나 저장할 수 없는 기록 삭제, 상태 비움 */ suspend fun clear(): Result } diff --git a/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutTrackingRepositoryImpl.kt b/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutTrackingRepositoryImpl.kt index d20a410d..67220782 100644 --- a/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutTrackingRepositoryImpl.kt +++ b/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutTrackingRepositoryImpl.kt @@ -4,7 +4,6 @@ import com.routee.android.core.common.util.suspendRunCatching import com.routee.android.core.data.location.model.DeviceLocation import com.routee.android.core.data.workout.model.StartedWorkout import com.routee.android.core.data.workout.model.WorkoutRecord -import com.routee.android.core.data.workout.model.WorkoutStatus import com.routee.android.core.data.workout.model.WorkoutTrackingState import com.routee.android.core.data.workout.model.WorkoutType import java.time.Clock @@ -83,16 +82,6 @@ internal class WorkoutTrackingRepositoryImpl @Inject constructor( recordRepository.saveRecord(finished).onSuccess { _state.value = _state.value.copy(record = finished) } } - override suspend fun loadPendingUpload(): Result = mutex.withLock { - suspendRunCatching { - if (_state.value.record?.isTracking == true) return@suspendRunCatching - val saved = recordRepository.getRecord().getOrThrow() - if (saved?.status != WorkoutStatus.PENDING_UPLOAD) return@suspendRunCatching - val trackPoints = recordRepository.getTrackPoints(saved.activityId).getOrThrow() - _state.value = WorkoutTrackingState(record = saved, trackPoints = trackPoints) - } - } - override suspend fun clear(): Result = mutex.withLock { val record = _state.value.record ?: return@withLock Result.success(Unit) recordRepository.deleteRecord(record.activityId).onSuccess { _state.value = WorkoutTrackingState() } diff --git a/core/data/src/test/java/com/routee/android/core/data/workout/local/WorkoutMapImageLocalDataSourceTest.kt b/core/data/src/test/java/com/routee/android/core/data/workout/local/WorkoutMapImageLocalDataSourceTest.kt deleted file mode 100644 index e1ebdae3..00000000 --- a/core/data/src/test/java/com/routee/android/core/data/workout/local/WorkoutMapImageLocalDataSourceTest.kt +++ /dev/null @@ -1,53 +0,0 @@ -package com.routee.android.core.data.workout.local - -import java.io.File -import kotlinx.coroutines.test.runTest -import org.junit.Assert.assertEquals -import org.junit.Assert.assertTrue -import org.junit.Before -import org.junit.Rule -import org.junit.Test -import org.junit.rules.TemporaryFolder - -class WorkoutMapImageLocalDataSourceTest { - @get:Rule - val tempFolder = TemporaryFolder() - - private lateinit var directory: File - private lateinit var dataSource: WorkoutMapImageLocalDataSource - - @Before - fun setUp() { - directory = File(tempFolder.root, "workout_map") - dataSource = WorkoutMapImageLocalDataSource { directory } - } - - /** - * GIVEN: 같은 기록일 때 - * WHEN: 캡처를 두 번 저장하면 - * THEN: 마지막 캡처 파일 하나만 남는다 - */ - @Test - fun `같은 기록에 두 번 저장하면 마지막 캡처만 남는다`() = runTest { - dataSource.save(activityId = 1, jpeg = byteArrayOf(1)) - val path = dataSource.save(activityId = 1, jpeg = byteArrayOf(2)) - - assertEquals(listOf(File(path)), directory.listFiles()?.toList()) - assertTrue(File(path).readBytes().contentEquals(byteArrayOf(2))) - } - - /** - * GIVEN: 캡처와 쓰다 남은 임시 파일이 있을 때 - * WHEN: 기록을 지우면 - * THEN: 캡처와 임시 파일이 모두 지워진다 - */ - @Test - fun `기록을 지우면 캡처와 남은 임시 파일을 지운다`() = runTest { - dataSource.save(activityId = 1, jpeg = byteArrayOf(1)) - File(directory, "1-temp-123.tmp").writeBytes(byteArrayOf(1)) - - dataSource.delete(activityId = 1) - - assertEquals(emptyList(), directory.listFiles()?.toList()) - } -} diff --git a/core/data/src/test/java/com/routee/android/core/data/workout/model/UnfinishedWorkoutTest.kt b/core/data/src/test/java/com/routee/android/core/data/workout/model/UnfinishedWorkoutTest.kt index a647bcd0..a1bd4790 100644 --- a/core/data/src/test/java/com/routee/android/core/data/workout/model/UnfinishedWorkoutTest.kt +++ b/core/data/src/test/java/com/routee/android/core/data/workout/model/UnfinishedWorkoutTest.kt @@ -101,8 +101,6 @@ class UnfinishedWorkoutTest { distanceMeters = 0.0, maxElevationMeters = null, endedAt = null, - mapImageObjectKey = null, - mapImagePath = null, ) private companion object { diff --git a/core/data/src/test/java/com/routee/android/core/data/workout/model/WorkoutRecordTest.kt b/core/data/src/test/java/com/routee/android/core/data/workout/model/WorkoutRecordTest.kt index b4b26d3d..2fb63519 100644 --- a/core/data/src/test/java/com/routee/android/core/data/workout/model/WorkoutRecordTest.kt +++ b/core/data/src/test/java/com/routee/android/core/data/workout/model/WorkoutRecordTest.kt @@ -162,14 +162,13 @@ class WorkoutRecordTest { } /** - * GIVEN: 지도 키까지 올리고 저장에 실패한 종료 기록일 때 + * GIVEN: 저장에 실패한 종료 기록일 때 * WHEN: 복구 안내를 위해 불러오면 - * THEN: 운동 시간과 종료 시각은 그대로 일시정지로 되돌리고 지도는 비운다 + * THEN: 운동 시간과 종료 시각은 그대로 일시정지로 되돌린다 */ @Test fun `저장에 실패한 종료 기록을 복구하면 종료를 되돌린다`() { val finished = record().finished(START.plusSeconds(90)) - .copy(mapImageObjectKey = "map-key", mapImagePath = "map.jpg") val recovered = finished.recovered(START.plusSeconds(3_600)) @@ -177,8 +176,6 @@ class WorkoutRecordTest { assertEquals(90_000L, recovered.durationMillisAt(START.plusSeconds(7_200))) assertEquals(START.plusSeconds(3_600), recovered.pausedAt) assertEquals(START.plusSeconds(90), recovered.endedAt) - assertNull(recovered.mapImageObjectKey) - assertNull(recovered.mapImagePath) } /** @@ -260,8 +257,6 @@ class WorkoutRecordTest { distanceMeters = 0.0, maxElevationMeters = null, endedAt = null, - mapImageObjectKey = null, - mapImagePath = null, ) private companion object { diff --git a/core/data/src/test/java/com/routee/android/core/data/workout/model/WorkoutTrackingStateTest.kt b/core/data/src/test/java/com/routee/android/core/data/workout/model/WorkoutTrackingStateTest.kt index e635ed06..27a67654 100644 --- a/core/data/src/test/java/com/routee/android/core/data/workout/model/WorkoutTrackingStateTest.kt +++ b/core/data/src/test/java/com/routee/android/core/data/workout/model/WorkoutTrackingStateTest.kt @@ -170,8 +170,6 @@ class WorkoutTrackingStateTest { distanceMeters = 0.0, maxElevationMeters = null, endedAt = null, - mapImageObjectKey = null, - mapImagePath = null, ), ) diff --git a/core/data/src/test/java/com/routee/android/core/data/workout/repository/WorkoutRecordRepositoryImplTest.kt b/core/data/src/test/java/com/routee/android/core/data/workout/repository/WorkoutRecordRepositoryImplTest.kt index a51cf934..69318204 100644 --- a/core/data/src/test/java/com/routee/android/core/data/workout/repository/WorkoutRecordRepositoryImplTest.kt +++ b/core/data/src/test/java/com/routee/android/core/data/workout/repository/WorkoutRecordRepositoryImplTest.kt @@ -1,32 +1,22 @@ package com.routee.android.core.data.workout.repository -import com.routee.android.core.data.workout.local.WorkoutMapImageLocalDataSource import com.routee.android.core.data.workout.model.TrackPoint import com.routee.android.core.data.workout.model.WorkoutRecord import com.routee.android.core.data.workout.model.WorkoutStatus import com.routee.android.core.data.workout.model.WorkoutType -import java.io.File import java.time.Instant import kotlinx.coroutines.test.runTest import org.junit.Assert.assertEquals -import org.junit.Assert.assertFalse -import org.junit.Assert.assertNull import org.junit.Assert.assertTrue import org.junit.Before -import org.junit.Rule import org.junit.Test -import org.junit.rules.TemporaryFolder class WorkoutRecordRepositoryImplTest { - @get:Rule - val tempFolder = TemporaryFolder() - private lateinit var repository: WorkoutRecordRepositoryImpl @Before fun setUp() { - val mapImageLocalDataSource = WorkoutMapImageLocalDataSource { tempFolder.root } - repository = WorkoutRecordRepositoryImpl(FakeWorkoutDao(), mapImageLocalDataSource) + repository = WorkoutRecordRepositoryImpl(FakeWorkoutDao()) } /** @@ -45,39 +35,6 @@ class WorkoutRecordRepositoryImplTest { assertEquals(updated, repository.getRecord().getOrThrow()) } - /** - * GIVEN: 이전 기록에 지도 캡처가 있을 때 - * WHEN: 새 기록을 시작하면 - * THEN: 이전 지도 캡처가 지워지고 새 기록만 남는다 - */ - @Test - fun `새 기록을 시작하면 이전 지도 캡처를 지운다`() = runTest { - repository.startRecord(record(activityId = 1)) - val path = - requireNotNull(repository.saveMapImage(record(activityId = 1), byteArrayOf(1)).getOrThrow().mapImagePath) - - repository.startRecord(record(activityId = 2)) - - assertFalse(File(path).exists()) - assertEquals(2L, repository.getRecord().getOrThrow()?.activityId) - } - - /** - * GIVEN: 지도 캡처가 있는 기록일 때 - * WHEN: 기록을 지우면 - * THEN: 기록과 지도 캡처가 모두 지워진다 - */ - @Test - fun `기록을 지우면 지도 캡처도 지운다`() = runTest { - repository.startRecord(record()) - val path = requireNotNull(repository.saveMapImage(record(), byteArrayOf(1)).getOrThrow().mapImagePath) - - repository.deleteRecord(ACTIVITY_ID) - - assertNull(repository.getRecord().getOrThrow()) - assertFalse(File(path).exists()) - } - /** * GIVEN: 기록을 시작했을 때 * WHEN: 다른 id의 기록을 저장하면 @@ -93,23 +50,6 @@ class WorkoutRecordRepositoryImplTest { assertEquals(1L, repository.getRecord().getOrThrow()?.activityId) } - /** - * GIVEN: 지도 캡처 파일을 쓸 수 없을 때 - * WHEN: 지도 캡처를 저장하면 - * THEN: 실패를 돌려주고 기록에는 파일 경로가 저장되지 않는다 - */ - @Test - fun `지도 캡처 파일 저장에 실패하면 실패를 돌려준다`() = runTest { - val unwritable = File(tempFolder.newFile("not_directory"), "workout_map") - val repository = WorkoutRecordRepositoryImpl(FakeWorkoutDao(), WorkoutMapImageLocalDataSource { unwritable }) - repository.startRecord(record()) - - val result = repository.saveMapImage(record(), byteArrayOf(1)) - - assertTrue(result.isFailure) - assertNull(repository.getRecord().getOrThrow()?.mapImagePath) - } - private fun record(activityId: Long = ACTIVITY_ID) = WorkoutRecord( activityId = activityId, title = "2026.10.22 기록", @@ -123,8 +63,6 @@ class WorkoutRecordRepositoryImplTest { distanceMeters = 0.0, maxElevationMeters = null, endedAt = null, - mapImageObjectKey = null, - mapImagePath = null, ) private fun point(index: Int) = TrackPoint( diff --git a/core/data/src/test/java/com/routee/android/core/data/workout/repository/WorkoutRemoteRepositoryImplTest.kt b/core/data/src/test/java/com/routee/android/core/data/workout/repository/WorkoutRemoteRepositoryImplTest.kt index 65528bd4..ab72602b 100644 --- a/core/data/src/test/java/com/routee/android/core/data/workout/repository/WorkoutRemoteRepositoryImplTest.kt +++ b/core/data/src/test/java/com/routee/android/core/data/workout/repository/WorkoutRemoteRepositoryImplTest.kt @@ -189,8 +189,6 @@ class WorkoutRemoteRepositoryImplTest { distanceMeters = 1_234.6, maxElevationMeters = 116.4, endedAt = endedAt, - mapImageObjectKey = null, - mapImagePath = null, ) private fun point( diff --git a/core/data/src/test/java/com/routee/android/core/data/workout/repository/WorkoutTrackingRepositoryImplTest.kt b/core/data/src/test/java/com/routee/android/core/data/workout/repository/WorkoutTrackingRepositoryImplTest.kt index e7b99770..a0e8cf57 100644 --- a/core/data/src/test/java/com/routee/android/core/data/workout/repository/WorkoutTrackingRepositoryImplTest.kt +++ b/core/data/src/test/java/com/routee/android/core/data/workout/repository/WorkoutTrackingRepositoryImplTest.kt @@ -1,7 +1,6 @@ package com.routee.android.core.data.workout.repository import com.routee.android.core.data.location.model.DeviceLocation -import com.routee.android.core.data.workout.local.WorkoutMapImageLocalDataSource import com.routee.android.core.data.workout.model.StartedWorkout import com.routee.android.core.data.workout.model.TrackPoint import com.routee.android.core.data.workout.model.WorkoutRecord @@ -16,14 +15,9 @@ import org.junit.Assert.assertEquals import org.junit.Assert.assertNull import org.junit.Assert.assertTrue import org.junit.Before -import org.junit.Rule import org.junit.Test -import org.junit.rules.TemporaryFolder class WorkoutTrackingRepositoryImplTest { - @get:Rule - val tempFolder = TemporaryFolder() - private val clock = TestClock(START) private val remoteRepository = FakeWorkoutRemoteRepository() private lateinit var recordRepository: WorkoutRecordRepository @@ -31,8 +25,7 @@ class WorkoutTrackingRepositoryImplTest { @Before fun setUp() { - recordRepository = - WorkoutRecordRepositoryImpl(FakeWorkoutDao(), WorkoutMapImageLocalDataSource { tempFolder.root }) + recordRepository = WorkoutRecordRepositoryImpl(FakeWorkoutDao()) repository = WorkoutTrackingRepositoryImpl(recordRepository, remoteRepository, clock) } @@ -213,38 +206,6 @@ class WorkoutTrackingRepositoryImplTest { assertEquals(WorkoutStatus.PENDING_UPLOAD, recordRepository.getRecord().getOrThrow()?.status) } - /** - * GIVEN: 앱이 다시 켜져 상태는 비었고 기기에 지도 키를 저장한 업로드 대기 기록이 있을 때 - * WHEN: 업로드 대기 기록을 불러오면 - * THEN: 지도 키와 경로 좌표까지 불러온다 - */ - @Test - fun `업로드 대기 기록을 경로와 함께 불러온다`() = runTest { - val pending = record().copy(status = WorkoutStatus.PENDING_UPLOAD, endedAt = START) - recordRepository.startRecord(record()) - recordRepository.saveTrackPoint(record(), point(1)) - recordRepository.saveRecord(pending.copy(mapImageObjectKey = "map.jpg")) - - repository.loadPendingUpload() - - assertEquals("map.jpg", repository.state.value.record?.mapImageObjectKey) - assertEquals(listOf(1), repository.state.value.trackPoints.map { it.pointIndex }) - } - - /** - * GIVEN: 기록 중일 때 - * WHEN: 업로드 대기 기록을 불러오면 - * THEN: 기록 중인 상태를 그대로 둔다 - */ - @Test - fun `기록 중이면 업로드 대기 기록을 불러오지 않는다`() = runTest { - repository.start(STARTED_WORKOUT, WorkoutType.HIKING, START) - - repository.loadPendingUpload() - - assertEquals(WorkoutStatus.ACTIVITY_IN_PROGRESS, repository.state.value.record?.status) - } - /** * GIVEN: 일시정지한 기록일 때 * WHEN: 경로 좌표를 더하면 @@ -345,8 +306,6 @@ class WorkoutTrackingRepositoryImplTest { distanceMeters = 0.0, maxElevationMeters = null, endedAt = null, - mapImageObjectKey = null, - mapImagePath = null, ) private fun point(index: Int) = TrackPoint( diff --git a/core/database/schemas/com.routee.android.core.database.RouteeDatabase/2.json b/core/database/schemas/com.routee.android.core.database.RouteeDatabase/2.json index 9bd8bdaa..5b5b2684 100644 --- a/core/database/schemas/com.routee.android.core.database.RouteeDatabase/2.json +++ b/core/database/schemas/com.routee.android.core.database.RouteeDatabase/2.json @@ -2,11 +2,11 @@ "formatVersion": 1, "database": { "version": 2, - "identityHash": "6399f533e3f64f0719e30b3a2b2cbd67", + "identityHash": "bbda0ec20db6f0a8f6debf1b160a0a6c", "entities": [ { "tableName": "workout", - "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER NOT NULL, `title` TEXT NOT NULL, `type` TEXT NOT NULL, `status` TEXT NOT NULL, `started_at` INTEGER NOT NULL, `duration_millis` INTEGER NOT NULL, `resumed_at` INTEGER, `paused_at` INTEGER, `last_recorded_at` INTEGER NOT NULL, `distance` REAL NOT NULL, `max_elevation` REAL, `ended_at` INTEGER, `map_image_object_key` TEXT, `map_image_path` TEXT, PRIMARY KEY(`id`))", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER NOT NULL, `title` TEXT NOT NULL, `type` TEXT NOT NULL, `status` TEXT NOT NULL, `started_at` INTEGER NOT NULL, `duration_millis` INTEGER NOT NULL, `resumed_at` INTEGER, `paused_at` INTEGER, `last_recorded_at` INTEGER NOT NULL, `distance` REAL NOT NULL, `max_elevation` REAL, `ended_at` INTEGER, PRIMARY KEY(`id`))", "fields": [ { "fieldPath": "id", @@ -75,16 +75,6 @@ "fieldPath": "endedAt", "columnName": "ended_at", "affinity": "INTEGER" - }, - { - "fieldPath": "mapImageObjectKey", - "columnName": "map_image_object_key", - "affinity": "TEXT" - }, - { - "fieldPath": "mapImagePath", - "columnName": "map_image_path", - "affinity": "TEXT" } ], "primaryKey": { @@ -269,7 +259,7 @@ ], "setupQueries": [ "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)", - "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, '6399f533e3f64f0719e30b3a2b2cbd67')" + "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, 'bbda0ec20db6f0a8f6debf1b160a0a6c')" ] } } \ No newline at end of file diff --git a/core/database/src/androidTest/java/com/routee/android/core/database/dao/WorkoutDaoTest.kt b/core/database/src/androidTest/java/com/routee/android/core/database/dao/WorkoutDaoTest.kt index 42e0622a..f40ba058 100644 --- a/core/database/src/androidTest/java/com/routee/android/core/database/dao/WorkoutDaoTest.kt +++ b/core/database/src/androidTest/java/com/routee/android/core/database/dao/WorkoutDaoTest.kt @@ -132,8 +132,6 @@ class WorkoutDaoTest { distance = 0.0, maxElevation = null, endedAt = null, - mapImageObjectKey = null, - mapImagePath = null, ) private fun point( diff --git a/core/database/src/main/java/com/routee/android/core/database/RouteeDatabase.kt b/core/database/src/main/java/com/routee/android/core/database/RouteeDatabase.kt index ecf501a6..e52b6dad 100644 --- a/core/database/src/main/java/com/routee/android/core/database/RouteeDatabase.kt +++ b/core/database/src/main/java/com/routee/android/core/database/RouteeDatabase.kt @@ -2,8 +2,10 @@ package com.routee.android.core.database import androidx.room.AutoMigration import androidx.room.Database +import androidx.room.DeleteColumn import androidx.room.RoomDatabase import androidx.room.TypeConverters +import androidx.room.migration.AutoMigrationSpec import com.routee.android.core.database.dao.WorkoutDao import com.routee.android.core.database.dao.WorkoutPhotoDao import com.routee.android.core.database.entity.TrackPointEntity @@ -14,7 +16,7 @@ import com.routee.android.core.database.util.InstantConverter @Database( entities = [WorkoutEntity::class, TrackPointEntity::class, WorkoutPhotoEntity::class], version = 2, - autoMigrations = [AutoMigration(from = 1, to = 2)], + autoMigrations = [AutoMigration(from = 1, to = 2, spec = Migration1To2::class)], ) @TypeConverters(InstantConverter::class) internal abstract class RouteeDatabase : RoomDatabase() { @@ -22,3 +24,7 @@ internal abstract class RouteeDatabase : RoomDatabase() { abstract fun workoutPhotoDao(): WorkoutPhotoDao } + +@DeleteColumn(tableName = "workout", columnName = "map_image_object_key") +@DeleteColumn(tableName = "workout", columnName = "map_image_path") +internal class Migration1To2 : AutoMigrationSpec diff --git a/core/database/src/main/java/com/routee/android/core/database/entity/WorkoutEntity.kt b/core/database/src/main/java/com/routee/android/core/database/entity/WorkoutEntity.kt index 7ddae184..33d384ec 100644 --- a/core/database/src/main/java/com/routee/android/core/database/entity/WorkoutEntity.kt +++ b/core/database/src/main/java/com/routee/android/core/database/entity/WorkoutEntity.kt @@ -8,20 +8,18 @@ import java.time.Instant /** * 운동 기록 테이블 (`workout`) * - * @param id 서버 `activityId` - * @param title 시작 API가 준 기본 제목 - * @param type `HIKING`, `RUNNING` - * @param status `ACTIVITY_IN_PROGRESS`, `ACTIVITY_PAUSED`, `PENDING_UPLOAD` - * @param startedAt 시작 시각 - * @param durationMillis 마지막 일시정지까지 누적된 운동 시간 - * @param resumedAt 마지막으로 시작하거나 다시 시작한 시각, 일시정지면 null - * @param pausedAt 일시정지 시각, 2시간 규칙 판단 - * @param lastRecordedAt 마지막 위치 기록 시각, 복구 안내와 종료 후 저장 기준 - * @param distance 누적 거리 (m) - * @param maxElevation 최고 고도 (m) - * @param endedAt 종료 시각, 완료 API를 다시 보낼 때 사용 - * @param mapImageObjectKey 지도 이미지 업로드 결과, 있으면 업로드 생략 - * @param mapImagePath 지도 캡처 파일 경로 + * @param id 서버 `activityId` + * @param title 시작 API가 준 기본 제목 + * @param type `HIKING`, `RUNNING` + * @param status `ACTIVITY_IN_PROGRESS`, `ACTIVITY_PAUSED`, `PENDING_UPLOAD` + * @param startedAt 시작 시각 + * @param durationMillis 마지막 일시정지까지 누적된 운동 시간 + * @param resumedAt 마지막으로 시작하거나 다시 시작한 시각, 일시정지면 null + * @param pausedAt 일시정지 시각, 2시간 규칙 판단 + * @param lastRecordedAt 마지막 위치 기록 시각, 복구 안내와 종료 후 저장 기준 + * @param distance 누적 거리 (m) + * @param maxElevation 최고 고도 (m) + * @param endedAt 종료 시각, 완료 API를 다시 보낼 때 사용 */ @Entity(tableName = "workout") data class WorkoutEntity( @@ -37,6 +35,4 @@ data class WorkoutEntity( val distance: Double, @ColumnInfo(name = "max_elevation") val maxElevation: Double?, @ColumnInfo(name = "ended_at") val endedAt: Instant?, - @ColumnInfo(name = "map_image_object_key") val mapImageObjectKey: String?, - @ColumnInfo(name = "map_image_path") val mapImagePath: String?, ) diff --git a/core/domain/src/main/java/com/routee/android/core/domain/workout/SaveFinishedWorkoutUseCase.kt b/core/domain/src/main/java/com/routee/android/core/domain/workout/SaveFinishedWorkoutUseCase.kt index ebe3ee81..93663a15 100644 --- a/core/domain/src/main/java/com/routee/android/core/domain/workout/SaveFinishedWorkoutUseCase.kt +++ b/core/domain/src/main/java/com/routee/android/core/domain/workout/SaveFinishedWorkoutUseCase.kt @@ -1,37 +1,32 @@ package com.routee.android.core.domain.workout -import com.routee.android.core.common.util.suspendRunCatching import com.routee.android.core.data.timeline.repository.TimelineMapImageRepository import com.routee.android.core.data.workout.exception.WorkoutException -import com.routee.android.core.data.workout.model.WorkoutRecord import com.routee.android.core.data.workout.repository.WorkoutPhotoRepository -import com.routee.android.core.data.workout.repository.WorkoutRecordRepository import com.routee.android.core.data.workout.repository.WorkoutRemoteRepository import com.routee.android.core.data.workout.repository.WorkoutTrackingRepository -import java.io.File import javax.inject.Inject -/** 종료한 운동 저장, 지도 캡처와 못 올린 사진을 올리고 완료 API 호출. 앱이 다시 켜졌으면 기기에 남은 업로드 대기 기록을 보냄 */ +/** 종료한 운동 저장, 지도 캡처와 못 올린 사진을 올리고 완료 API 호출 */ class SaveFinishedWorkoutUseCase @Inject constructor( private val trackingRepository: WorkoutTrackingRepository, - private val recordRepository: WorkoutRecordRepository, private val mapImageRepository: TimelineMapImageRepository, private val remoteRepository: WorkoutRemoteRepository, private val photoRepository: WorkoutPhotoRepository, ) { /** - * @param mapImage 경로 전체를 담은 지도 캡처 JPEG, null 이면 기기에 저장해 둔 지도 키나 캡처 파일을 씀 + * @param mapImage 경로 전체를 담은 지도 캡처 JPEG, 캡처에 실패했으면 null */ suspend operator fun invoke(mapImage: ByteArray?): WorkoutSaveResult { - trackingRepository.loadPendingUpload().onFailure { return WorkoutSaveResult.Failed } val state = trackingRepository.state.value val record = state.finishedRecord ?: return WorkoutSaveResult.Failed if (!state.isSavable) { clearRecord() return WorkoutSaveResult.InvalidRoute } - val objectKey = getMapImageObjectKey(record, mapImage).getOrElse { return failed(it) } - ?: return WorkoutSaveResult.MapImageMissing + if (mapImage == null) return WorkoutSaveResult.MapImageMissing + val objectKey = mapImageRepository.uploadMapImage(record.activityId, mapImage) + .getOrElse { return failed(it) } // 대표 사진은 완료 시점에 정해져서 완료 전에 다시 올리고 장소명, 삭제도 반영. 그래도 못 올린 사진은 빼고 저장 val missingPhotoCount = photoRepository.syncPhotos(record.activityId) remoteRepository.completeWorkout(record, state.trackPoints, objectKey) @@ -52,19 +47,6 @@ class SaveFinishedWorkoutUseCase @Inject constructor( clearRecord() return WorkoutSaveResult.Rejected } - - // 올린 키가 있으면 그대로, 없으면 캡처를 기기에 저장해 올리고 다시 올리지 않게 키를 남김. 캡처가 없으면 null - private suspend fun getMapImageObjectKey( - record: WorkoutRecord, - jpeg: ByteArray?, - ): Result = suspendRunCatching { - record.mapImageObjectKey?.let { return@suspendRunCatching it } - val saved = if (jpeg != null) recordRepository.saveMapImage(record, jpeg).getOrThrow() else record - val imagePath = saved.mapImagePath ?: return@suspendRunCatching null - val objectKey = mapImageRepository.uploadMapImage(record.activityId, File(imagePath)).getOrThrow() - recordRepository.saveRecord(saved.copy(mapImageObjectKey = objectKey)) - objectKey - } } /** 종료한 운동 저장 결과 */ diff --git a/core/domain/src/test/java/com/routee/android/core/domain/auth/ClearDeviceDataUseCaseTest.kt b/core/domain/src/test/java/com/routee/android/core/domain/auth/ClearDeviceDataUseCaseTest.kt index a1eaa5c6..8062738c 100644 --- a/core/domain/src/test/java/com/routee/android/core/domain/auth/ClearDeviceDataUseCaseTest.kt +++ b/core/domain/src/test/java/com/routee/android/core/domain/auth/ClearDeviceDataUseCaseTest.kt @@ -78,8 +78,6 @@ class ClearDeviceDataUseCaseTest { override suspend fun recover(): Result = Result.success(Unit) - override suspend fun loadPendingUpload(): Result = Result.success(Unit) - override suspend fun finish(endedAt: Instant?): Result = Result.success(Unit) override suspend fun clear(): Result { @@ -105,11 +103,6 @@ class ClearDeviceDataUseCaseTest { override suspend fun getTrackPoints(activityId: Long): Result> = Result.success(emptyList()) - override suspend fun saveMapImage( - record: WorkoutRecord, - jpeg: ByteArray, - ): Result = Result.success(record) - override suspend fun deleteRecord(activityId: Long): Result = Result.success(Unit) override suspend fun clearRecords(): Result { diff --git a/core/domain/src/test/java/com/routee/android/core/domain/workout/SaveFinishedWorkoutUseCaseTest.kt b/core/domain/src/test/java/com/routee/android/core/domain/workout/SaveFinishedWorkoutUseCaseTest.kt index 296d162c..3721f85b 100644 --- a/core/domain/src/test/java/com/routee/android/core/domain/workout/SaveFinishedWorkoutUseCaseTest.kt +++ b/core/domain/src/test/java/com/routee/android/core/domain/workout/SaveFinishedWorkoutUseCaseTest.kt @@ -1,6 +1,5 @@ package com.routee.android.core.domain.workout -import android.graphics.Bitmap import com.routee.android.core.data.location.model.DeviceLocation import com.routee.android.core.data.timeline.repository.TimelineMapImageRepository import com.routee.android.core.data.workout.exception.WorkoutException @@ -10,10 +9,8 @@ import com.routee.android.core.data.workout.model.WorkoutRecord import com.routee.android.core.data.workout.model.WorkoutStatus import com.routee.android.core.data.workout.model.WorkoutTrackingState import com.routee.android.core.data.workout.model.WorkoutType -import com.routee.android.core.data.workout.repository.WorkoutRecordRepository import com.routee.android.core.data.workout.repository.WorkoutRemoteRepository import com.routee.android.core.data.workout.repository.WorkoutTrackingRepository -import java.io.File import java.io.IOException import java.time.Instant import kotlinx.coroutines.flow.MutableStateFlow @@ -27,16 +24,15 @@ import org.junit.Test class SaveFinishedWorkoutUseCaseTest { private val tracking = FakeTrackingRepository() - private val records = FakeRecordRepository() private val mapImages = FakeMapImageRepository() private val remote = FakeRemoteRepository() private val photos = FakeWorkoutPhotoRepository() - private val saveFinishedWorkout = SaveFinishedWorkoutUseCase(tracking, records, mapImages, remote, photos) + private val saveFinishedWorkout = SaveFinishedWorkoutUseCase(tracking, mapImages, remote, photos) /** * GIVEN: 경로 좌표가 2개 이상인 종료한 기록일 때 * WHEN: 지도 캡처와 함께 저장하면 - * THEN: 캡처를 기기에 저장해 올리고, 받은 키로 완료한 뒤 기기 기록을 지운다 + * THEN: 캡처를 올리고, 받은 키로 완료한 뒤 기기 기록을 지운다 */ @Test fun `저장하면 캡처를 올리고 완료한 뒤 기기 기록을 지운다`() = runTest { @@ -45,8 +41,7 @@ class SaveFinishedWorkoutUseCaseTest { val result = saveFinishedWorkout(JPEG) assertEquals(WorkoutSaveResult.Saved, result) - assertEquals("map/7.jpg", mapImages.uploadedPath) - assertEquals("map-key", records.saved?.mapImageObjectKey) + assertEquals(JPEG, mapImages.uploadedJpeg) assertEquals("map-key", remote.completedKey) assertTrue(tracking.isCleared) } @@ -75,7 +70,7 @@ class SaveFinishedWorkoutUseCaseTest { @Test fun `다시 올려도 실패한 사진은 빼고 저장한다`() = runTest { val photos = FakeWorkoutPhotoRepository(missingCount = 1) - val saveFinishedWorkout = SaveFinishedWorkoutUseCase(tracking, records, mapImages, remote, photos) + val saveFinishedWorkout = SaveFinishedWorkoutUseCase(tracking, mapImages, remote, photos) tracking.state(points = 2) val result = saveFinishedWorkout(JPEG) @@ -136,12 +131,12 @@ class SaveFinishedWorkoutUseCaseTest { } /** - * GIVEN: 지도 캡처에 실패했고 저장해 둔 캡처도 없을 때 + * GIVEN: 지도 캡처에 실패했을 때 * WHEN: 저장하면 - * THEN: 다시 캡처하라고 돌려주고 기기 기록은 남긴다 + * THEN: 완료하지 않고 기기 기록은 남긴다 */ @Test - fun `캡처가 없으면 다시 캡처하라고 하고 기기 기록을 남긴다`() = runTest { + fun `캡처가 없으면 완료하지 않고 기기 기록을 남긴다`() = runTest { tracking.state(points = 2) val result = saveFinishedWorkout(null) @@ -151,39 +146,6 @@ class SaveFinishedWorkoutUseCaseTest { assertFalse(tracking.isCleared) } - /** - * GIVEN: 앱이 다시 켜져 상태는 비었고 기기에 지도 키를 올려 둔 업로드 대기 기록이 있을 때 - * WHEN: 캡처 없이 저장하면 - * THEN: 기기 기록을 불러와 지도는 다시 올리지 않고 그 키로 완료한 뒤 지운다 - */ - @Test - fun `저장해 둔 지도 키가 있으면 다시 올리지 않고 완료한다`() = runTest { - tracking.pending = pendingState(RECORD.copy(mapImageObjectKey = "saved-key", mapImagePath = "map/7.jpg")) - - val result = saveFinishedWorkout(null) - - assertEquals(WorkoutSaveResult.Saved, result) - assertNull(mapImages.uploadedPath) - assertEquals("saved-key", remote.completedKey) - assertTrue(tracking.isCleared) - } - - /** - * GIVEN: 지도 키는 없고 캡처 파일만 남은 업로드 대기 기록일 때 - * WHEN: 캡처 없이 저장하면 - * THEN: 남은 캡처 파일을 올려 완료한다 - */ - @Test - fun `저장해 둔 캡처 파일이 있으면 그 파일을 올려 완료한다`() = runTest { - tracking.pending = pendingState(RECORD.copy(mapImagePath = "map/7.jpg")) - - val result = saveFinishedWorkout(null) - - assertEquals(WorkoutSaveResult.Saved, result) - assertEquals("map/7.jpg", mapImages.uploadedPath) - assertEquals("map-key", remote.completedKey) - } - /** * GIVEN: 서버에 기록이 없어 완료를 거절할 때 * WHEN: 저장하면 @@ -218,17 +180,11 @@ class SaveFinishedWorkoutUseCaseTest { assertTrue(tracking.isCleared) } - private fun pendingState(record: WorkoutRecord) = - WorkoutTrackingState(record = record, trackPoints = (1..2).map(::point)) - private class FakeTrackingRepository : WorkoutTrackingRepository { private val _state = MutableStateFlow(WorkoutTrackingState()) override val state: StateFlow = _state var isCleared = false - // 기기에 남은 업로드 대기 기록, 불러오면 상태가 됨 - var pending: WorkoutTrackingState? = null - fun state( points: Int, record: WorkoutRecord = RECORD, @@ -252,11 +208,6 @@ class SaveFinishedWorkoutUseCaseTest { override suspend fun recover(): Result = Result.success(Unit) - override suspend fun loadPendingUpload(): Result { - pending?.let { _state.value = it } - return Result.success(Unit) - } - override suspend fun finish(endedAt: Instant?): Result = Result.success(Unit) override suspend fun clear(): Result { @@ -266,50 +217,16 @@ class SaveFinishedWorkoutUseCaseTest { } } - private class FakeRecordRepository : WorkoutRecordRepository { - var saved: WorkoutRecord? = null - - override suspend fun getRecord(): Result = Result.success(saved) - - override suspend fun startRecord(record: WorkoutRecord): Result = Result.success(Unit) - - override suspend fun saveRecord(record: WorkoutRecord): Result { - saved = record - return Result.success(Unit) - } - - override suspend fun saveTrackPoint( - record: WorkoutRecord, - point: TrackPoint, - ): Result = Result.success(Unit) - - override suspend fun getTrackPoints(activityId: Long): Result> = Result.success(emptyList()) - - override suspend fun saveMapImage( - record: WorkoutRecord, - jpeg: ByteArray, - ): Result = Result.success(record.copy(mapImagePath = "map/${record.activityId}.jpg")) - - override suspend fun deleteRecord(activityId: Long): Result = Result.success(Unit) - - override suspend fun clearRecords(): Result = Result.success(Unit) - } - private class FakeMapImageRepository : TimelineMapImageRepository { - var uploadedPath: String? = null + var uploadedJpeg: ByteArray? = null var error: Throwable? = null override suspend fun uploadMapImage( activityId: Long, - bitmap: Bitmap, - ): Result = Result.failure(UnsupportedOperationException()) - - override suspend fun uploadMapImage( - activityId: Long, - imageFile: File, + jpeg: ByteArray, ): Result { error?.let { return Result.failure(it) } - uploadedPath = imageFile.path + uploadedJpeg = jpeg return Result.success("map-key") } } @@ -360,8 +277,6 @@ class SaveFinishedWorkoutUseCaseTest { distanceMeters = 100.0, maxElevationMeters = null, endedAt = START.plusSeconds(60), - mapImageObjectKey = null, - mapImagePath = null, ) fun point(index: Int) = TrackPoint( diff --git a/core/domain/src/test/java/com/routee/android/core/domain/workout/TrackWorkoutUseCaseTest.kt b/core/domain/src/test/java/com/routee/android/core/domain/workout/TrackWorkoutUseCaseTest.kt index e4c2977c..e8b5d67a 100644 --- a/core/domain/src/test/java/com/routee/android/core/domain/workout/TrackWorkoutUseCaseTest.kt +++ b/core/domain/src/test/java/com/routee/android/core/domain/workout/TrackWorkoutUseCaseTest.kt @@ -178,8 +178,6 @@ class TrackWorkoutUseCaseTest { override suspend fun recover(): Result = Result.success(Unit) - override suspend fun loadPendingUpload(): Result = Result.success(Unit) - override suspend fun finish(endedAt: Instant?): Result = Result.success(Unit) override suspend fun clear(): Result = Result.success(Unit) @@ -197,8 +195,6 @@ class TrackWorkoutUseCaseTest { distanceMeters = 0.0, maxElevationMeters = null, endedAt = null, - mapImageObjectKey = null, - mapImagePath = null, ) } diff --git a/core/domain/src/test/java/com/routee/android/core/domain/workout/WorkoutPhotoTestFixtures.kt b/core/domain/src/test/java/com/routee/android/core/domain/workout/WorkoutPhotoTestFixtures.kt index 558d570c..9b4e79ef 100644 --- a/core/domain/src/test/java/com/routee/android/core/domain/workout/WorkoutPhotoTestFixtures.kt +++ b/core/domain/src/test/java/com/routee/android/core/domain/workout/WorkoutPhotoTestFixtures.kt @@ -78,8 +78,6 @@ internal class FakePhotoTrackingRepository( override suspend fun recover(): Result = Result.success(Unit) - override suspend fun loadPendingUpload(): Result = Result.success(Unit) - override suspend fun finish(endedAt: Instant?): Result = Result.success(Unit) override suspend fun clear(): Result = Result.success(Unit) @@ -98,8 +96,6 @@ internal class FakePhotoTrackingRepository( distanceMeters = 0.0, maxElevationMeters = null, endedAt = null, - mapImageObjectKey = null, - mapImagePath = null, ) } } diff --git a/docs/architecture/data-layer.md b/docs/architecture/data-layer.md index 0f65b3b3..8fd74265 100644 --- a/docs/architecture/data-layer.md +++ b/docs/architecture/data-layer.md @@ -8,7 +8,7 @@ | `exception/` | `AuthException` | | `remote/service/` | `AuthService` | | `remote/dto/request\|response/` | `LoginRequest`, `TokenResponse` | -| `local/` | `TokenLocalDataSource`, `WorkoutMapImageLocalDataSource`, `WorkoutEntityMapper` | +| `local/` | `TokenLocalDataSource`, `WorkoutPhotoLocalDataSource`, `WorkoutEntityMapper` | | `repository/` | `AuthRepository`, `AuthRepositoryImpl` | | Path under `core/database/.../` | Example | diff --git a/feature/setting/impl/src/test/java/com/routee/android/feature/setting/FakeDeviceDataRepositories.kt b/feature/setting/impl/src/test/java/com/routee/android/feature/setting/FakeDeviceDataRepositories.kt index bcd32b4c..c16f7fcf 100644 --- a/feature/setting/impl/src/test/java/com/routee/android/feature/setting/FakeDeviceDataRepositories.kt +++ b/feature/setting/impl/src/test/java/com/routee/android/feature/setting/FakeDeviceDataRepositories.kt @@ -43,8 +43,6 @@ internal class FakeWorkoutTrackingRepository : WorkoutTrackingRepository { override suspend fun recover(): Result = Result.success(Unit) - override suspend fun loadPendingUpload(): Result = Result.success(Unit) - override suspend fun finish(endedAt: Instant?): Result = Result.success(Unit) override suspend fun clear(): Result = Result.success(Unit) @@ -66,11 +64,6 @@ internal class FakeWorkoutRecordRepository : WorkoutRecordRepository { override suspend fun getTrackPoints(activityId: Long): Result> = Result.success(emptyList()) - override suspend fun saveMapImage( - record: WorkoutRecord, - jpeg: ByteArray, - ): Result = Result.success(record) - override suspend fun deleteRecord(activityId: Long): Result = Result.success(Unit) override suspend fun clearRecords(): Result { diff --git a/feature/workout/impl/src/test/java/com/routee/android/feature/workout/FakeWorkoutRepositories.kt b/feature/workout/impl/src/test/java/com/routee/android/feature/workout/FakeWorkoutRepositories.kt index 0b90cb05..814d1473 100644 --- a/feature/workout/impl/src/test/java/com/routee/android/feature/workout/FakeWorkoutRepositories.kt +++ b/feature/workout/impl/src/test/java/com/routee/android/feature/workout/FakeWorkoutRepositories.kt @@ -1,6 +1,5 @@ package com.routee.android.feature.workout -import android.graphics.Bitmap import com.routee.android.core.data.geocoding.repository.ReverseGeocodingRepository import com.routee.android.core.data.location.model.DeviceLocation import com.routee.android.core.data.location.repository.LocationRepository @@ -82,13 +81,6 @@ internal class FakeWorkoutTrackingRepository( return Result.success(Unit) } - override suspend fun loadPendingUpload(): Result { - if (_state.value.record?.isTracking != true && savedRecord?.status == WorkoutStatus.PENDING_UPLOAD) { - _state.value = WorkoutTrackingState(record = savedRecord, trackPoints = savedTrackPoints) - } - return Result.success(Unit) - } - override suspend fun finish(endedAt: Instant?): Result { _state.value = _state.value.copy(record = _state.value.record?.finished(START, endedAt ?: START)) return Result.success(Unit) @@ -149,11 +141,6 @@ internal class FakeWorkoutRecordRepository( override suspend fun getTrackPoints(activityId: Long): Result> = Result.success(emptyList()) - override suspend fun saveMapImage( - record: WorkoutRecord, - jpeg: ByteArray, - ): Result = Result.success(record.copy(mapImagePath = "map/${record.activityId}.jpg")) - override suspend fun deleteRecord(activityId: Long): Result = Result.success(Unit) override suspend fun clearRecords(): Result { @@ -165,12 +152,7 @@ internal class FakeWorkoutRecordRepository( internal class FakeMapImageRepository : TimelineMapImageRepository { override suspend fun uploadMapImage( activityId: Long, - bitmap: Bitmap, - ): Result = Result.success("map-key") - - override suspend fun uploadMapImage( - activityId: Long, - imageFile: File, + jpeg: ByteArray, ): Result = Result.success("map-key") } @@ -299,8 +281,6 @@ internal fun record(status: WorkoutStatus = WorkoutStatus.ACTIVITY_IN_PROGRESS) distanceMeters = 1_234.4, maxElevationMeters = 302.6, endedAt = null, - mapImageObjectKey = null, - mapImagePath = null, ) internal fun photo(id: String) = WorkoutPhoto( diff --git a/feature/workout/impl/src/test/java/com/routee/android/feature/workout/main/WorkoutMainViewModelTest.kt b/feature/workout/impl/src/test/java/com/routee/android/feature/workout/main/WorkoutMainViewModelTest.kt index 0e702665..761bc915 100644 --- a/feature/workout/impl/src/test/java/com/routee/android/feature/workout/main/WorkoutMainViewModelTest.kt +++ b/feature/workout/impl/src/test/java/com/routee/android/feature/workout/main/WorkoutMainViewModelTest.kt @@ -515,7 +515,6 @@ class WorkoutMainViewModelTest { getUnfinishedWorkout = GetUnfinishedWorkoutUseCase(tracking, records, clock), saveFinishedWorkout = SaveFinishedWorkoutUseCase( trackingRepository = tracking, - recordRepository = records, mapImageRepository = FakeMapImageRepository(), remoteRepository = FakeWorkoutRemoteRepository(), photoRepository = FakeWorkoutPhotoRepository(), diff --git a/feature/workout/impl/src/test/java/com/routee/android/feature/workout/recording/WorkoutRecordingViewModelTest.kt b/feature/workout/impl/src/test/java/com/routee/android/feature/workout/recording/WorkoutRecordingViewModelTest.kt index 0d5a5e7b..a0c35881 100644 --- a/feature/workout/impl/src/test/java/com/routee/android/feature/workout/recording/WorkoutRecordingViewModelTest.kt +++ b/feature/workout/impl/src/test/java/com/routee/android/feature/workout/recording/WorkoutRecordingViewModelTest.kt @@ -762,7 +762,6 @@ class WorkoutRecordingViewModelTest { remoteRepository = remote, saveFinishedWorkout = SaveFinishedWorkoutUseCase( trackingRepository = tracking, - recordRepository = records, mapImageRepository = FakeMapImageRepository(), remoteRepository = remote, photoRepository = photos, diff --git a/feature/workout/impl/src/test/java/com/routee/android/feature/workout/tracking/WorkoutNotificationContentTest.kt b/feature/workout/impl/src/test/java/com/routee/android/feature/workout/tracking/WorkoutNotificationContentTest.kt index 4f7d372f..5005057d 100644 --- a/feature/workout/impl/src/test/java/com/routee/android/feature/workout/tracking/WorkoutNotificationContentTest.kt +++ b/feature/workout/impl/src/test/java/com/routee/android/feature/workout/tracking/WorkoutNotificationContentTest.kt @@ -74,8 +74,6 @@ class WorkoutNotificationContentTest { distanceMeters = 15_530.0, maxElevationMeters = 2_132.4, endedAt = null, - mapImageObjectKey = null, - mapImagePath = null, ) private companion object { From 7df5ee28fa29130ff1b7d96ffbbfd23c0aa63550 Mon Sep 17 00:00:00 2001 From: seungjun Date: Sat, 7 Nov 2026 19:53:51 +0900 Subject: [PATCH 09/16] =?UTF-8?q?[REFACTOR/#222]=20=ED=99=94=EB=A9=B4=20?= =?UTF-8?q?=ED=8C=8C=EC=83=9D=20=EA=B0=92=EC=9D=84=20UiState=EB=A1=9C=20?= =?UTF-8?q?=EC=9D=B4=EB=8F=99,=20=EB=B3=B5=EA=B5=AC=20=EC=A0=95=EB=A6=AC?= =?UTF-8?q?=20=EC=BD=94=EB=93=9C=20=EB=AC=B6=EA=B8=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../feature/timeline/main/TimelineScreen.kt | 3 +- .../timeline/main/model/TimelineUiState.kt | 6 +++- .../feature/workout/main/WorkoutMainScreen.kt | 29 +++++++++---------- .../workout/main/WorkoutMainViewModel.kt | 6 ++-- .../workout/main/model/WorkoutMainUiState.kt | 11 +++++++ 5 files changed, 33 insertions(+), 22 deletions(-) diff --git a/feature/timeline/impl/src/main/java/com/routee/android/feature/timeline/main/TimelineScreen.kt b/feature/timeline/impl/src/main/java/com/routee/android/feature/timeline/main/TimelineScreen.kt index 0d49d3f4..68c5a718 100644 --- a/feature/timeline/impl/src/main/java/com/routee/android/feature/timeline/main/TimelineScreen.kt +++ b/feature/timeline/impl/src/main/java/com/routee/android/feature/timeline/main/TimelineScreen.kt @@ -135,7 +135,6 @@ internal fun TimelineRoute( val defaultTitle = stringResource(R.string.timeline_default_record_title, recordDate) val focusManager = LocalFocusManager.current val photos = uiState.photos - val hasPhotoSection = photos is UiState.Loading || (photos as? UiState.Success)?.data?.isNotEmpty() == true fun finishTitleEdit() { viewModel.onTitleEditFinish() focusManager.clearFocus() @@ -189,7 +188,7 @@ internal fun TimelineRoute( }, modifier = modifier, routeMap = { TimelineRouteMap(track = uiState.track) }, - photoSection = if (hasPhotoSection) { + photoSection = if (uiState.hasPhotoSection) { { TimelinePhotoSection( photos = photos, diff --git a/feature/timeline/impl/src/main/java/com/routee/android/feature/timeline/main/model/TimelineUiState.kt b/feature/timeline/impl/src/main/java/com/routee/android/feature/timeline/main/model/TimelineUiState.kt index 3db43fb8..12f1b150 100644 --- a/feature/timeline/impl/src/main/java/com/routee/android/feature/timeline/main/model/TimelineUiState.kt +++ b/feature/timeline/impl/src/main/java/com/routee/android/feature/timeline/main/model/TimelineUiState.kt @@ -12,4 +12,8 @@ internal data class TimelineUiState( val isTitleEditing: Boolean = false, val track: UiState = UiState.Loading, val photos: UiState> = UiState.Loading, -) +) { + // 불러오는 중이거나 사진이 있으면 사진 섹션 표시 + val hasPhotoSection: Boolean + get() = photos is UiState.Loading || (photos as? UiState.Success)?.data?.isNotEmpty() == true +} diff --git a/feature/workout/impl/src/main/java/com/routee/android/feature/workout/main/WorkoutMainScreen.kt b/feature/workout/impl/src/main/java/com/routee/android/feature/workout/main/WorkoutMainScreen.kt index d45aab18..c53a1c91 100644 --- a/feature/workout/impl/src/main/java/com/routee/android/feature/workout/main/WorkoutMainScreen.kt +++ b/feature/workout/impl/src/main/java/com/routee/android/feature/workout/main/WorkoutMainScreen.kt @@ -133,23 +133,17 @@ internal fun WorkoutMainRoute( } if (uiState.recovery != null) { - LaunchedEffect(Unit) { - WorkoutTrackingService.stop(context) - WorkoutPauseAlarm.cancel(context) - WorkoutPauseNotification.cancel(context) - } + LaunchedEffect(Unit) { stopWorkoutTracking(context) } } uiState.recoveryCaptureRoute?.let { route -> LaunchedEffect(route) { viewModel.onRecoveryMapCaptured(mapState.captureRouteJpeg(route)) } } - val isLocationGranted = uiState.locationPermission == LocationPermission.GRANTED WorkoutMainScreen( uiState = uiState, mapState = mapState, - // 종료 후 저장 캡처에는 내 위치를 넣지 않음 - myLocation = if (isLocationGranted && !uiState.isRecoverySaving) viewModel.myLocation else null, + myLocation = if (uiState.isMyLocationVisible) viewModel.myLocation else null, onMyLocationClick = viewModel::onMyLocationClick, onRecordClick = viewModel::onRecordClick, ) @@ -239,6 +233,13 @@ private fun WorkoutRecoveryDialog( // 예: 03/03 오전 3:33 private val RecoveryTimeFormatter = DateTimeFormatter.ofPattern("MM/dd a h:mm", Locale.KOREAN) +// 복구 모달이 뜨면 이전 기록의 위치 기록과 2시간 알람, 알림을 멈춤 +private fun stopWorkoutTracking(context: Context) { + WorkoutTrackingService.stop(context) + WorkoutPauseAlarm.cancel(context) + WorkoutPauseNotification.cancel(context) +} + private val LOCATION_PERMISSIONS = arrayOf( Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION, @@ -282,14 +283,10 @@ private fun WorkoutMainScreen( modifier = Modifier.padding(vertical = RouteeTheme.spacing.Spacing14), ) LocationChip( - text = when { - uiState.locationPermission != LocationPermission.GRANTED -> - stringResource(R.string.workout_main_location_permission_required) - - !uiState.isLocationServiceEnabled || uiState.address == null -> - stringResource(R.string.workout_main_location_checking) - - else -> uiState.address + text = if (uiState.isLocationGranted) { + uiState.visibleAddress ?: stringResource(R.string.workout_main_location_checking) + } else { + stringResource(R.string.workout_main_location_permission_required) }, ) } diff --git a/feature/workout/impl/src/main/java/com/routee/android/feature/workout/main/WorkoutMainViewModel.kt b/feature/workout/impl/src/main/java/com/routee/android/feature/workout/main/WorkoutMainViewModel.kt index 9c6ec980..77c88307 100644 --- a/feature/workout/impl/src/main/java/com/routee/android/feature/workout/main/WorkoutMainViewModel.kt +++ b/feature/workout/impl/src/main/java/com/routee/android/feature/workout/main/WorkoutMainViewModel.kt @@ -93,7 +93,7 @@ internal class WorkoutMainViewModel @Inject constructor( // 위치 서비스가 꺼져 있으면 켜기 전까지 시작하지 않음 fun onRecordClick() { when { - uiState.value.locationPermission != LocationPermission.GRANTED -> showLocationPermissionDialog() + !uiState.value.isLocationGranted -> showLocationPermissionDialog() !uiState.value.isLocationServiceEnabled -> _uiState.update { it.copy(isLocationServiceDialogVisible = true) } @@ -146,7 +146,7 @@ internal class WorkoutMainViewModel @Inject constructor( } fun onMyLocationClick() { - if (uiState.value.locationPermission == LocationPermission.GRANTED) { + if (uiState.value.isLocationGranted) { viewModelScope.launch { _sideEffect.send(WorkoutMainSideEffect.FollowMyLocation(from = null)) } } else { showLocationPermissionDialog() @@ -282,7 +282,7 @@ internal class WorkoutMainViewModel @Inject constructor( _sideEffect.send(WorkoutMainSideEffect.ShowRecoverySaveFailed) } } - if (_uiState.value.locationPermission == LocationPermission.GRANTED) { + if (_uiState.value.isLocationGranted) { _sideEffect.send(WorkoutMainSideEffect.FollowMyLocation(from = null)) } } diff --git a/feature/workout/impl/src/main/java/com/routee/android/feature/workout/main/model/WorkoutMainUiState.kt b/feature/workout/impl/src/main/java/com/routee/android/feature/workout/main/model/WorkoutMainUiState.kt index 8e567030..5d89ad3b 100644 --- a/feature/workout/impl/src/main/java/com/routee/android/feature/workout/main/model/WorkoutMainUiState.kt +++ b/feature/workout/impl/src/main/java/com/routee/android/feature/workout/main/model/WorkoutMainUiState.kt @@ -23,6 +23,17 @@ internal data class WorkoutMainUiState( // 진입 때 남은 기록 확인 중이면 true, 새 기록이 남은 기록과 겹치지 않게 운동 기록 비활성화 val isCheckingUnfinishedWorkout: Boolean = true, ) { + val isLocationGranted: Boolean + get() = locationPermission == LocationPermission.GRANTED + + // 종료 후 저장 캡처에는 내 위치를 넣지 않음 + val isMyLocationVisible: Boolean + get() = isLocationGranted && !isRecoverySaving + + // 위치 서비스가 꺼져 있으면 이전 주소를 보여주지 않음 + val visibleAddress: String? + get() = address.takeIf { isLocationServiceEnabled } + // 위치 권한, 위치 서비스 안내 모달이 닫히거나 처리가 실패하면 다시 보여줌 val isRecoveryDialogVisible: Boolean get() = recovery != null && !isLocationGuideDialogVisible && !isRecoveryInProgress From 42ea0a0e4699a36fe812c8340f6d123017f3608a Mon Sep 17 00:00:00 2001 From: seungjun Date: Sat, 7 Nov 2026 21:14:50 +0900 Subject: [PATCH 10/16] =?UTF-8?q?[FIX/#222]=20=EA=B8=B0=EA=B8=B0=20?= =?UTF-8?q?=EC=82=AC=EC=A7=84=EC=9D=84=20=EB=AA=BB=20=EC=9D=BD=EC=9C=BC?= =?UTF-8?q?=EB=A9=B4=20=EB=8D=AE=EC=96=B4=EC=93=B0=EC=A7=80=20=EC=95=8A?= =?UTF-8?q?=EA=B3=A0=20=EB=8B=A4=EC=9D=8C=EC=97=90=20=EB=8B=A4=EC=8B=9C=20?= =?UTF-8?q?=EC=9D=BD=EA=B8=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../repository/WorkoutPhotoRepositoryImpl.kt | 24 ++++++++------- .../WorkoutPhotoRepositoryImplTest.kt | 29 +++++++++++++++++-- 2 files changed, 40 insertions(+), 13 deletions(-) diff --git a/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepositoryImpl.kt b/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepositoryImpl.kt index 602be9b7..37b6a311 100644 --- a/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepositoryImpl.kt +++ b/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepositoryImpl.kt @@ -40,7 +40,7 @@ internal class WorkoutPhotoRepositoryImpl @Inject constructor( private val _photos = MutableStateFlow>(emptyList()) override val photos: StateFlow> = _photos.asStateFlow() - // 기기에 저장한 사진을 이미 불러온 기록, 지운 사진을 다시 불러오지 않게 앱 실행마다 한 번만 + // 기기에 저장한 사진을 읽은 기록, 지운 사진을 다시 불러오지 않게 앱 실행마다 한 번만. 읽기 전에는 기기에 저장하지 않음 private var loadedActivityId: Long? = null private val mutex = Mutex() private val syncMutex = Mutex() @@ -75,7 +75,7 @@ internal class WorkoutPhotoRepositoryImpl @Inject constructor( // 기기에 저장한 사진이 없을 때만 서버에서. 좌표는 경로 조회의 마커, 장소명과 큰 이미지는 타임라인 사진 목록에서. 목록을 못 받으면 썸네일과 빈 장소명 override suspend fun restore(activityId: Long): Result = suspendRunCatching { - loadSavedPhotos(activityId) + check(loadSavedPhotos(activityId)) { "기기 사진 읽기 실패" } if (_photos.value.any { it.activityId == activityId }) return@suspendRunCatching val photos = coroutineScope { val track = async { recapRepository.getActivityTrack(activityId) } @@ -131,23 +131,25 @@ internal class WorkoutPhotoRepositoryImpl @Inject constructor( } } - // 앱이 꺼졌다 켜졌으면 기기에 저장한 사진을 불러옴 - private suspend fun loadSavedPhotos(activityId: Long) { - mutex.withLock { - if (loadedActivityId == activityId) return - loadedActivityId = activityId - if (_photos.value.any { it.activityId == activityId }) return - val saved = suspendRunCatching { photoDao.getPhotos(activityId) }.getOrDefault(emptyList()) - if (saved.isEmpty()) return + // 앱이 꺼졌다 켜졌으면 기기에 저장한 사진을 불러옴, 그 사이 찍은 사진은 합침. 못 읽으면 false, 다음에 다시 읽음 + private suspend fun loadSavedPhotos(activityId: Long): Boolean = mutex.withLock { + if (loadedActivityId == activityId) return@withLock true + val saved = suspendRunCatching { photoDao.getPhotos(activityId) }.getOrElse { return@withLock false } + loadedActivityId = activityId + val current = _photos.value.filter { it.activityId == activityId } + val missing = saved.map { it.toModel() }.filter { photo -> current.none { it.id == photo.id } } + if (missing.isNotEmpty()) { clearOthers(activityId) - _photos.value = saved.map { it.toModel() } + _photos.value = (current + missing).sortedBy { it.takenAt } } + true } // 앱이 꺼져도 남게 기기에 저장, 실패해도 메모리 사진으로 계속 private suspend fun savePhotos(activityId: Long) { suspendRunCatching { mutex.withLock { + if (loadedActivityId != activityId) return@withLock val photos = _photos.value.filter { it.activityId == activityId }.map { it.toEntity() } photoDao.replacePhotos(activityId, photos) } diff --git a/core/data/src/test/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepositoryImplTest.kt b/core/data/src/test/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepositoryImplTest.kt index 75694b22..f700ce4c 100644 --- a/core/data/src/test/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepositoryImplTest.kt +++ b/core/data/src/test/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepositoryImplTest.kt @@ -120,6 +120,28 @@ class WorkoutPhotoRepositoryImplTest { assertEquals("a.jpg", repository.photos.value.single().filePath) } + /** + * GIVEN: 앱이 다시 켜졌고 기기에 저장한 사진을 읽지 못할 때 + * WHEN: 복구하고 사진을 반영한 뒤 다시 복구하면 + * THEN: 서버로 채우거나 기기 사진을 덮어쓰지 않고, 다음 복구 때 다시 읽는다 + */ + @Test + fun `기기 사진을 못 읽으면 덮어쓰지 않고 다음에 다시 읽는다`() = runTest { + dao.rows += photoRow(id = "a") + dao.readError = IOException() + + assertTrue(repository.restore(ACTIVITY_ID).isFailure) + repository.syncPhotos(ACTIVITY_ID) + + assertEquals(0, recap.trackCallCount) + assertEquals("a", dao.rows.single().id) + + dao.readError = null + repository.restore(ACTIVITY_ID).getOrThrow() + + assertEquals("a", repository.photos.value.single().id) + } + /** * GIVEN: 앱이 다시 켜졌고 기기에 못 올린 사진이 있을 때 * WHEN: 사진을 반영하면 @@ -237,9 +259,12 @@ class WorkoutPhotoRepositoryImplTest { private class FakeWorkoutPhotoDao : WorkoutPhotoDao { val rows = mutableListOf() + var readError: Throwable? = null - override suspend fun getPhotos(workoutId: Long): List = - rows.filter { it.workoutId == workoutId } + override suspend fun getPhotos(workoutId: Long): List { + readError?.let { throw it } + return rows.filter { it.workoutId == workoutId } + } override suspend fun insertPhotos(photos: List) { rows += photos From 6ad45efe1eb3085f739165cd77dba2f09acd140a Mon Sep 17 00:00:00 2001 From: seungjun Date: Sat, 7 Nov 2026 21:14:51 +0900 Subject: [PATCH 11/16] =?UTF-8?q?[FIX/#222]=20=EC=82=AC=EC=A7=84=20?= =?UTF-8?q?=EC=82=AD=EC=A0=9C=20=EB=95=8C=20=EA=B8=B0=EA=B8=B0=20=EA=B8=B0?= =?UTF-8?q?=EB=A1=9D=EC=9D=84=20=ED=8C=8C=EC=9D=BC=EB=B3=B4=EB=8B=A4=20?= =?UTF-8?q?=EB=A8=BC=EC=A0=80=20=EC=A0=80=EC=9E=A5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../data/workout/repository/WorkoutPhotoRepositoryImpl.kt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepositoryImpl.kt b/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepositoryImpl.kt index 37b6a311..57319006 100644 --- a/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepositoryImpl.kt +++ b/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepositoryImpl.kt @@ -101,12 +101,12 @@ internal class WorkoutPhotoRepositoryImpl @Inject constructor( // 올리는 중이면 끝난 뒤에 지움 override suspend fun deletePhoto(photoId: String): Result = syncMutex.withLock { - suspendRunCatching { + suspendRunCatching { val photo = _photos.value.find { it.id == photoId } ?: return@suspendRunCatching photo.timelineId?.let { timelinePhotoRepository.deletePhoto(photo.activityId, it).getOrThrow() } _photos.update { photos -> photos.filterNot { it.id == photoId } } - photo.filePath?.let { localDataSource.delete(it) } savePhotos(photo.activityId) + photo.filePath?.let { localDataSource.delete(it) } } } From 90e0743e889a708d455b23e253b95d0301684b2a Mon Sep 17 00:00:00 2001 From: seungjun Date: Sat, 7 Nov 2026 21:44:16 +0900 Subject: [PATCH 12/16] =?UTF-8?q?[REFACTOR/#222]=20=ED=83=80=EC=9E=84?= =?UTF-8?q?=EB=9D=BC=EC=9D=B8=20=EC=82=AC=EC=A7=84=20=EC=A1=B0=ED=9A=8C=20?= =?UTF-8?q?UseCase=20=EC=B6=94=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../timeline/GetTimelinePhotosUseCase.kt | 33 ++++++++ .../timeline/GetTimelinePhotosUseCaseTest.kt | 76 +++++++++++++++++++ 2 files changed, 109 insertions(+) create mode 100644 core/domain/src/main/java/com/routee/android/core/domain/timeline/GetTimelinePhotosUseCase.kt create mode 100644 core/domain/src/test/java/com/routee/android/core/domain/timeline/GetTimelinePhotosUseCaseTest.kt diff --git a/core/domain/src/main/java/com/routee/android/core/domain/timeline/GetTimelinePhotosUseCase.kt b/core/domain/src/main/java/com/routee/android/core/domain/timeline/GetTimelinePhotosUseCase.kt new file mode 100644 index 00000000..bc9c549d --- /dev/null +++ b/core/domain/src/main/java/com/routee/android/core/domain/timeline/GetTimelinePhotosUseCase.kt @@ -0,0 +1,33 @@ +package com.routee.android.core.domain.timeline + +import com.routee.android.core.data.archive.model.ArchivePhoto +import com.routee.android.core.data.archive.repository.ArchiveDetailRepository +import com.routee.android.core.data.workout.model.WorkoutPhoto +import com.routee.android.core.data.workout.repository.WorkoutPhotoRepository +import java.io.File +import javax.inject.Inject + +/** 타임라인 사진 목록, 기기에 올린 사진이 있으면 서버를 부르지 않음 */ +class GetTimelinePhotosUseCase @Inject constructor( + private val photoRepository: WorkoutPhotoRepository, + private val archiveDetailRepository: ArchiveDetailRepository, +) { + suspend operator fun invoke(activityId: Long): Result> { + val devicePhotos = photoRepository.photos.value.toTimelinePhotos(activityId) + if (devicePhotos.isNotEmpty()) return Result.success(devicePhotos) + return archiveDetailRepository.getPhotos(activityId) + } +} + +// 서버에 올린 사진만, 찍은 순서 +private fun List.toTimelinePhotos(activityId: Long): List = + filter { it.activityId == activityId } + .mapNotNull { photo -> + val timelineId = photo.timelineId ?: return@mapNotNull null + val imageUrl = photo.imageUrl() ?: return@mapNotNull null + ArchivePhoto(timelineId, photo.title.takeIf(String::isNotBlank), imageUrl, photo.takenAt) + } + .sortedBy { it.createdAt } + +// 기기 파일이 있으면 file: 주소, 없으면 서버 주소 +internal fun WorkoutPhoto.imageUrl(): String? = filePath?.let { File(it).toURI().toString() } ?: serverImageUrl diff --git a/core/domain/src/test/java/com/routee/android/core/domain/timeline/GetTimelinePhotosUseCaseTest.kt b/core/domain/src/test/java/com/routee/android/core/domain/timeline/GetTimelinePhotosUseCaseTest.kt new file mode 100644 index 00000000..5746a648 --- /dev/null +++ b/core/domain/src/test/java/com/routee/android/core/domain/timeline/GetTimelinePhotosUseCaseTest.kt @@ -0,0 +1,76 @@ +package com.routee.android.core.domain.timeline + +import com.routee.android.core.data.archive.model.ArchiveDetail +import com.routee.android.core.data.archive.model.ArchivePhoto +import com.routee.android.core.data.archive.repository.ArchiveDetailRepository +import com.routee.android.core.domain.workout.FakeWorkoutPhotoRepository +import com.routee.android.core.domain.workout.PHOTO_START +import com.routee.android.core.domain.workout.workoutPhoto +import java.time.Instant +import kotlinx.coroutines.test.runTest +import org.junit.Assert.assertEquals +import org.junit.Test + +class GetTimelinePhotosUseCaseTest { + private val photos = FakeWorkoutPhotoRepository() + private val archiveDetail = FakeArchiveDetailRepository() + private val getTimelinePhotos = GetTimelinePhotosUseCase(photos, archiveDetail) + + /** + * GIVEN: 기기에 이 기록의 올린 사진, 못 올린 사진, 다른 기록 사진이 있을 때 + * WHEN: 사진 목록을 조회하면 + * THEN: 서버를 부르지 않고 이 기록의 올린 사진만 찍은 순서로 돌려준다 + */ + @Test + fun `기기에 올린 사진이 있으면 서버를 부르지 않는다`() = runTest { + photos.setPhotos( + listOf( + workoutPhoto(1).copy(timelineId = 11, takenAt = PHOTO_START.plusSeconds(10)), + workoutPhoto(2).copy(timelineId = 12), + workoutPhoto(3), + workoutPhoto(4, activityId = 8).copy(timelineId = 14), + ), + ) + + val result = getTimelinePhotos(ACTIVITY_ID).getOrThrow() + + assertEquals(listOf(12L, 11L), result.map { it.id }) + assertEquals(0, archiveDetail.photoRequestCount) + } + + /** + * GIVEN: 앱이 다시 켜져 기기에 사진이 없을 때 + * WHEN: 사진 목록을 조회하면 + * THEN: 서버에서 조회한다 + */ + @Test + fun `기기에 사진이 없으면 서버에서 조회한다`() = runTest { + val result = getTimelinePhotos(ACTIVITY_ID).getOrThrow() + + assertEquals(SERVER_PHOTOS, result) + assertEquals(1, archiveDetail.photoRequestCount) + } + + private class FakeArchiveDetailRepository : ArchiveDetailRepository { + var photoRequestCount = 0 + + override suspend fun getDetail(activityId: Long): Result = error("Unused") + + override suspend fun getPhotos(activityId: Long): Result> { + photoRequestCount++ + return Result.success(SERVER_PHOTOS) + } + + override suspend fun updateTitle( + activityId: Long, + title: String, + ): Result = error("Unused") + + override suspend fun deleteActivity(activityId: Long): Result = error("Unused") + } + + private companion object { + const val ACTIVITY_ID = 7L + val SERVER_PHOTOS = listOf(ArchivePhoto(21, "정상", "https://image", Instant.EPOCH)) + } +} From f623e8d6584f58a7a2e8cdc2413f8603549d89bc Mon Sep 17 00:00:00 2001 From: seungjun Date: Sat, 7 Nov 2026 21:44:17 +0900 Subject: [PATCH 13/16] =?UTF-8?q?[SETTING/#222]=20timeline=EC=97=90=20core?= =?UTF-8?q?:domain=20=EC=9D=98=EC=A1=B4=EC=84=B1=20=EC=B6=94=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- feature/timeline/impl/build.gradle.kts | 1 + 1 file changed, 1 insertion(+) diff --git a/feature/timeline/impl/build.gradle.kts b/feature/timeline/impl/build.gradle.kts index 0f055b90..4a471a08 100644 --- a/feature/timeline/impl/build.gradle.kts +++ b/feature/timeline/impl/build.gradle.kts @@ -8,6 +8,7 @@ android { dependencies { implementation(projects.core.common) + implementation(projects.core.domain) implementation(projects.core.map) implementation(projects.core.network) implementation(projects.feature.timeline.api) From effcc6b442a1be0b4a7c0302acf93bcefd19647a Mon Sep 17 00:00:00 2001 From: seungjun Date: Sat, 7 Nov 2026 21:44:17 +0900 Subject: [PATCH 14/16] =?UTF-8?q?[REFACTOR/#222]=20=ED=83=80=EC=9E=84?= =?UTF-8?q?=EB=9D=BC=EC=9D=B8=20=EC=82=AC=EC=A7=84=20=EB=AA=A9=EB=A1=9D?= =?UTF-8?q?=EC=9D=84=20UseCase=EB=A1=9C=20=EC=A1=B0=ED=9A=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../feature/timeline/main/TimelineViewModel.kt | 13 +++---------- .../timeline/main/model/TimelinePhotos.kt | 17 ----------------- 2 files changed, 3 insertions(+), 27 deletions(-) delete mode 100644 feature/timeline/impl/src/main/java/com/routee/android/feature/timeline/main/model/TimelinePhotos.kt diff --git a/feature/timeline/impl/src/main/java/com/routee/android/feature/timeline/main/TimelineViewModel.kt b/feature/timeline/impl/src/main/java/com/routee/android/feature/timeline/main/TimelineViewModel.kt index 175d07fa..c043882a 100644 --- a/feature/timeline/impl/src/main/java/com/routee/android/feature/timeline/main/TimelineViewModel.kt +++ b/feature/timeline/impl/src/main/java/com/routee/android/feature/timeline/main/TimelineViewModel.kt @@ -9,7 +9,7 @@ import com.routee.android.core.data.archive.model.ArchivePhoto import com.routee.android.core.data.archive.repository.ArchiveDetailRepository import com.routee.android.core.data.photo.GalleryImageStore import com.routee.android.core.data.recap.repository.RecapRepository -import com.routee.android.core.data.workout.repository.WorkoutPhotoRepository +import com.routee.android.core.domain.timeline.GetTimelinePhotosUseCase import com.routee.android.core.navigation.util.NavKeyViewModelFactory import com.routee.android.core.ui.UiState import com.routee.android.feature.timeline.api.TimelineNavKey @@ -19,7 +19,6 @@ import com.routee.android.feature.timeline.main.model.TimelineRequestResult import com.routee.android.feature.timeline.main.model.TimelineSideEffect import com.routee.android.feature.timeline.main.model.TimelineUiState import com.routee.android.feature.timeline.main.model.toRequestFailure -import com.routee.android.feature.timeline.main.model.toTimelinePhotos import com.routee.android.feature.timeline.main.model.toTimelineTrack import dagger.assisted.Assisted import dagger.assisted.AssistedFactory @@ -43,7 +42,7 @@ internal class TimelineViewModel @AssistedInject constructor( private val recordSaver: TimelineRecordSaver, private val archiveDetailRepository: ArchiveDetailRepository, private val recapRepository: RecapRepository, - private val workoutPhotoRepository: WorkoutPhotoRepository, + private val getTimelinePhotos: GetTimelinePhotosUseCase, ) : ViewModel() { val activityId = key.activityId val endedAtEpochMillis = key.endedAtEpochMillis @@ -121,16 +120,10 @@ internal class TimelineViewModel @AssistedInject constructor( } } - // 종료 때 올린 사진이 기기에 있으면 서버를 부르지 않음 private fun loadPhotos() { - val devicePhotos = workoutPhotoRepository.photos.value.toTimelinePhotos(activityId) - if (devicePhotos.isNotEmpty()) { - showPhotos(devicePhotos) - return - } viewModelScope.launch { // TODO P1 기획: 사진 목록 조회 실패 안내 (지금은 사진 섹션, 나의 루트 초기 목록 없이 진행) - archiveDetailRepository.getPhotos(activityId) + getTimelinePhotos(activityId) .onSuccess(::showPhotos) .onFailure { error -> Timber.e(error, "사진 조회 실패") diff --git a/feature/timeline/impl/src/main/java/com/routee/android/feature/timeline/main/model/TimelinePhotos.kt b/feature/timeline/impl/src/main/java/com/routee/android/feature/timeline/main/model/TimelinePhotos.kt deleted file mode 100644 index 499b585b..00000000 --- a/feature/timeline/impl/src/main/java/com/routee/android/feature/timeline/main/model/TimelinePhotos.kt +++ /dev/null @@ -1,17 +0,0 @@ -package com.routee.android.feature.timeline.main.model - -import com.routee.android.core.data.archive.model.ArchivePhoto -import com.routee.android.core.data.workout.model.WorkoutPhoto -import java.io.File - -/** 기기에 남은 [activityId] 사진 중 서버에 올린 사진, 못 올린 사진은 기록에 없어 뺌 */ -internal fun List.toTimelinePhotos(activityId: Long): List = - filter { it.activityId == activityId } - .mapNotNull { photo -> - val timelineId = photo.timelineId ?: return@mapNotNull null - val imageUrl = photo.filePath?.let { File(it).toURI().toString() } - ?: photo.serverImageUrl - ?: return@mapNotNull null - ArchivePhoto(timelineId, photo.title.takeIf(String::isNotBlank), imageUrl, photo.takenAt) - } - .sortedBy { it.createdAt } From 66fe7bfbbe4248a4d61346f9775c058fb4dc0ba5 Mon Sep 17 00:00:00 2001 From: seungjun Date: Sun, 8 Nov 2026 10:58:28 +0900 Subject: [PATCH 15/16] =?UTF-8?q?[FIX/#222]=20=ED=99=95=EC=A0=95=ED=95=9C?= =?UTF-8?q?=20=EC=82=AC=EC=A7=84=20=EC=82=AD=EC=A0=9C=EB=A5=BC=20=ED=99=94?= =?UTF-8?q?=EB=A9=B4=EC=9D=B4=20=EB=8B=AB=ED=98=80=EB=8F=84=20=EB=81=9D?= =?UTF-8?q?=EA=B9=8C=EC=A7=80=20=EC=A7=84=ED=96=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../repository/WorkoutPhotoRepositoryImpl.kt | 23 ++++++++------ .../WorkoutPhotoRepositoryImplTest.kt | 30 +++++++++++++++++++ 2 files changed, 44 insertions(+), 9 deletions(-) diff --git a/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepositoryImpl.kt b/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepositoryImpl.kt index 57319006..0506bb32 100644 --- a/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepositoryImpl.kt +++ b/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepositoryImpl.kt @@ -1,5 +1,6 @@ package com.routee.android.core.data.workout.repository +import com.routee.android.core.common.di.ApplicationScope import com.routee.android.core.common.util.suspendRunCatching import com.routee.android.core.data.archive.model.ArchivePhoto import com.routee.android.core.data.archive.repository.ArchiveDetailRepository @@ -20,6 +21,7 @@ import java.time.Instant import java.util.UUID import javax.inject.Inject import javax.inject.Singleton +import kotlinx.coroutines.CoroutineScope import kotlinx.coroutines.async import kotlinx.coroutines.coroutineScope import kotlinx.coroutines.flow.MutableStateFlow @@ -36,6 +38,7 @@ internal class WorkoutPhotoRepositoryImpl @Inject constructor( private val timelinePhotoRepository: TimelinePhotoRepository, private val recapRepository: RecapRepository, private val archiveDetailRepository: ArchiveDetailRepository, + @param:ApplicationScope private val externalScope: CoroutineScope, ) : WorkoutPhotoRepository { private val _photos = MutableStateFlow>(emptyList()) override val photos: StateFlow> = _photos.asStateFlow() @@ -99,16 +102,18 @@ internal class WorkoutPhotoRepositoryImpl @Inject constructor( _photos.update { photos -> photos.map { if (it.id == photoId) it.copy(title = title) else it } } } - // 올리는 중이면 끝난 뒤에 지움 - override suspend fun deletePhoto(photoId: String): Result = syncMutex.withLock { - suspendRunCatching { - val photo = _photos.value.find { it.id == photoId } ?: return@suspendRunCatching - photo.timelineId?.let { timelinePhotoRepository.deletePhoto(photo.activityId, it).getOrThrow() } - _photos.update { photos -> photos.filterNot { it.id == photoId } } - savePhotos(photo.activityId) - photo.filePath?.let { localDataSource.delete(it) } + // 서버와 기기가 어긋나지 않게 화면이 닫혀도 끝까지, 올리는 중이면 끝난 뒤에 지움 + override suspend fun deletePhoto(photoId: String): Result = externalScope.async { + syncMutex.withLock { + suspendRunCatching { + val photo = _photos.value.find { it.id == photoId } ?: return@suspendRunCatching + photo.timelineId?.let { timelinePhotoRepository.deletePhoto(photo.activityId, it).getOrThrow() } + _photos.update { photos -> photos.filterNot { it.id == photoId } } + savePhotos(photo.activityId) + photo.filePath?.let { localDataSource.delete(it) } + } } - } + }.await() override suspend fun syncPhotos(activityId: Long): Int { loadSavedPhotos(activityId) diff --git a/core/data/src/test/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepositoryImplTest.kt b/core/data/src/test/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepositoryImplTest.kt index f700ce4c..c0fff924 100644 --- a/core/data/src/test/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepositoryImplTest.kt +++ b/core/data/src/test/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepositoryImplTest.kt @@ -20,6 +20,11 @@ import java.io.IOException import java.nio.file.Files import java.time.Instant import java.time.YearMonth +import kotlinx.coroutines.CompletableDeferred +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.launch +import kotlinx.coroutines.test.UnconfinedTestDispatcher +import kotlinx.coroutines.test.runCurrent import kotlinx.coroutines.test.runTest import org.junit.Assert.assertEquals import org.junit.Assert.assertNull @@ -38,6 +43,7 @@ class WorkoutPhotoRepositoryImplTest { timelinePhotoRepository = timelinePhotos, recapRepository = recap, archiveDetailRepository = archive, + externalScope = CoroutineScope(UnconfinedTestDispatcher()), ) /** @@ -205,6 +211,28 @@ class WorkoutPhotoRepositoryImplTest { assertEquals("a", dao.rows.single().id) } + /** + * GIVEN: 서버 삭제 응답을 기다리는 중일 때 + * WHEN: 화면이 닫혀 지우던 쪽이 취소되면 + * THEN: 삭제는 끝까지 진행해 서버와 기기에서 모두 지운다 + */ + @Test + fun `화면이 닫혀도 확정한 삭제는 끝까지 한다`() = runTest { + dao.rows += photoRow(id = "a", timelineId = 3) + repository.restore(ACTIVITY_ID).getOrThrow() + val serverResponse = CompletableDeferred() + timelinePhotos.deleteResponse = serverResponse + + val deleting = launch { repository.deletePhoto("a") } + runCurrent() + deleting.cancel() + serverResponse.complete(Unit) + + assertEquals(listOf(3L), timelinePhotos.deletedTimelineIds) + assertTrue(repository.photos.value.isEmpty()) + assertTrue(dao.rows.isEmpty()) + } + /** * GIVEN: 아직 못 올린 사진을 지웠을 때 * WHEN: 사진을 반영하면 @@ -351,6 +379,7 @@ class WorkoutPhotoRepositoryImplTest { val deletedTimelineIds = mutableListOf() var uploadError: Throwable? = null var deleteError: Throwable? = null + var deleteResponse: CompletableDeferred? = null override suspend fun uploadPhotos( activityId: Long, @@ -371,6 +400,7 @@ class WorkoutPhotoRepositoryImplTest { activityId: Long, timelineId: Long, ): Result { + deleteResponse?.await() deleteError?.let { return Result.failure(it) } deletedTimelineIds += timelineId return Result.success(Unit) From 1bee753342f815987a9739c91bfb742269329753 Mon Sep 17 00:00:00 2001 From: seungjun Date: Sun, 8 Nov 2026 11:03:34 +0900 Subject: [PATCH 16/16] =?UTF-8?q?[FIX/#222]=20=EC=82=AC=EC=A7=84=20?= =?UTF-8?q?=EC=82=AD=EC=A0=9C=EC=9D=98=20=EB=AA=A9=EB=A1=9D=20=EB=B0=98?= =?UTF-8?q?=EC=98=81=EC=9D=84=20=EC=82=AC=EC=A7=84=20=EC=B6=94=EA=B0=80?= =?UTF-8?q?=EC=99=80=20=EA=B2=B9=EC=B9=98=EC=A7=80=20=EC=95=8A=EA=B2=8C=20?= =?UTF-8?q?=EC=9E=A0=EA=B8=88?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../core/data/workout/repository/WorkoutPhotoRepositoryImpl.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepositoryImpl.kt b/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepositoryImpl.kt index 0506bb32..5e28852f 100644 --- a/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepositoryImpl.kt +++ b/core/data/src/main/java/com/routee/android/core/data/workout/repository/WorkoutPhotoRepositoryImpl.kt @@ -108,7 +108,7 @@ internal class WorkoutPhotoRepositoryImpl @Inject constructor( suspendRunCatching { val photo = _photos.value.find { it.id == photoId } ?: return@suspendRunCatching photo.timelineId?.let { timelinePhotoRepository.deletePhoto(photo.activityId, it).getOrThrow() } - _photos.update { photos -> photos.filterNot { it.id == photoId } } + mutex.withLock { _photos.update { photos -> photos.filterNot { it.id == photoId } } } savePhotos(photo.activityId) photo.filePath?.let { localDataSource.delete(it) } }