feat: 모험 기록 상세 페이지 뷰 구현

android/app/src/main/AndroidManifest.xml

@@ -70,6 +70,10 @@
             android:name=".presentation.setting.SettingActivity"
             android:screenOrientation="portrait"
             android:exported="false" />
+        <activity
+            android:name=".presentation.adventuredetail.AdventureDetailActivity"
+            android:screenOrientation="portrait"
+            android:exported="false" />
         <activity
             android:name="com.kakao.sdk.auth.AuthCodeHandlerActivity"
             android:exported="true">

android/app/src/main/java/com/now/naaga/data/mapper/OpenLetterMapper.kt

@@ -0,0 +1,14 @@
+package com.now.naaga.data.mapper
+
+import com.now.domain.model.letter.OpenLetter
+import com.now.naaga.data.remote.dto.OpenLetterDto
+
+fun OpenLetterDto.toDomain(): OpenLetter {
+    return OpenLetter(
+        id = id,
+        player = player.toDomain(),
+        coordinate = coordinateDto.toDomain(),
+        message = message,
+        registerDate = registerDate,
+    )
+}

android/app/src/main/java/com/now/naaga/data/repository/DefaultLetterRepository.kt

@@ -25,6 +25,6 @@ class DefaultLetterRepository(
     }
 
     override suspend fun fetchLetterLogs(gameId: Long, logType: LogType): List<OpenLetter> {
-        TODO("Not yet implemented")
+        return letterService.getInGameLetters(gameId, logType.name).getValueOrThrow().map { it.toDomain() }
     }
 }

android/app/src/main/java/com/now/naaga/data/throwable/DataThrowable.kt

@@ -19,6 +19,9 @@ sealed class DataThrowable(val code: Int, message: String) : Throwable(message)
     // http 응답코드 500번대, body가 null일 때의 에러
     class IllegalStateThrowable : DataThrowable(ILLEGAL_STATE_THROWABLE_CODE, ILLEGAL_STATE_THROWABLE_MESSAGE)
 
+    // 700번대 쪽지 관련 에러
+    class LetterThrowable(code: Int, message: String) : DataThrowable(code, message)
+
     // IO Exception 일 경우의 예외
     class NetworkThrowable : DataThrowable(NETWORK_THROWABLE_CODE, NETWORK_THROWABLE_MESSAGE)
 

android/app/src/main/java/com/now/naaga/presentation/adventuredetail/AdventureDetailActivity.kt

@@ -0,0 +1,107 @@
+package com.now.naaga.presentation.adventuredetail
+
+import android.content.Context
+import android.content.Intent
+import android.os.Bundle
+import androidx.activity.viewModels
+import androidx.appcompat.app.AppCompatActivity
+import com.bumptech.glide.Glide
+import com.google.android.material.tabs.TabLayoutMediator
+import com.now.domain.model.AdventureResult
+import com.now.naaga.R
+import com.now.naaga.data.firebase.analytics.AnalyticsDelegate
+import com.now.naaga.data.firebase.analytics.DefaultAnalyticsDelegate
+import com.now.naaga.databinding.ActivityAdventureDetailBinding
+import com.now.naaga.presentation.adventuredetail.viewpager.ViewPagerAdapter
+import com.now.naaga.presentation.uimodel.model.OpenLetterUiModel
+import com.now.naaga.util.extension.repeatOnStarted
+import com.now.naaga.util.extension.showSnackbarWithEvent
+import dagger.hilt.android.AndroidEntryPoint
+
+@AndroidEntryPoint
+class AdventureDetailActivity : AppCompatActivity(), AnalyticsDelegate by DefaultAnalyticsDelegate() {
+    private lateinit var binding: ActivityAdventureDetailBinding
+    private val viewModel: AdventureDetailViewModel by viewModels()
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        binding = ActivityAdventureDetailBinding.inflate(layoutInflater)
+        setContentView(binding.root)
+
+        val gameId = intent.getLongExtra(KET_GAME_ID, 0L)
+
+        initView(gameId)
+        setClickListeners()
+        subscribe()
+    }
+
+    private fun initView(gameId: Long) {
+        viewModel.fetchReadLetter(gameId)
+        viewModel.fetchWriteLetter(gameId)
+        viewModel.fetchAdventureResult(gameId)
+    }
+
+    private fun setClickListeners() {
+        binding.ivAdventureDetailBack.setOnClickListener { finish() }
+    }
+
+    private fun subscribe() {
+        repeatOnStarted {
+            viewModel.uiState.collect { adventureDetailUiState ->
+                when (adventureDetailUiState) {
+                    is AdventureDetailUiState.Loading, is AdventureDetailUiState.Error -> Unit
+                    is AdventureDetailUiState.Success -> initView(adventureDetailUiState)
+                }
+            }
+        }
+        repeatOnStarted {
+            viewModel.throwableFlow.collect { event ->
+                when (event) {
+                    is AdventureDetailViewModel.Event.NetworkExceptionEvent -> showReRequestSnackbar()
+                    is AdventureDetailViewModel.Event.LetterExceptionEvent -> showReRequestSnackbar()
+                    is AdventureDetailViewModel.Event.GameExceptionEvent -> showReRequestSnackbar()
+                }
+            }
+        }
+    }
+
+    private fun showReRequestSnackbar() {
+        binding.root.showSnackbarWithEvent(
+            message = getString(R.string.snackbar_action_re_request_message),
+            actionTitle = getString(R.string.snackbar_action__re_request_title),
+        ) { finish() }
+    }
+
+    private fun initView(adventureDetailUiState: AdventureDetailUiState.Success) {
+        initViewPager(adventureDetailUiState.readLetters, adventureDetailUiState.writeLetters)
+        initImage(adventureDetailUiState.adventureResult)
+    }
+
+    private fun initViewPager(readLetters: List<OpenLetterUiModel>, writeLetters: List<OpenLetterUiModel>) {
+        binding.vpAdventureDetail.adapter = ViewPagerAdapter(listOf(readLetters, writeLetters))
+
+        TabLayoutMediator(binding.tlAdventureDetail, binding.vpAdventureDetail) { tab, position ->
+            when (position) {
+                0 -> tab.text = getString(R.string.adventure_detail_read_letter)
+                1 -> tab.text = getString(R.string.adventure_detail_write_letter)
+            }
+        }.attach()
+    }
+
+    private fun initImage(adventureResult: AdventureResult) {
+        Glide.with(binding.ivAdventureDetailPhoto)
+            .load(adventureResult.destination.image)
+            .error(R.drawable.ic_none_photo)
+            .into(binding.ivAdventureDetailPhoto)
+    }
+
+    companion object {
+        private const val KET_GAME_ID = "GAME_ID"
+
+        fun getIntentWithId(context: Context, gameId: Long): Intent {
+            return Intent(context, AdventureDetailActivity::class.java).apply {
+                putExtra(KET_GAME_ID, gameId)
+            }
+        }
+    }
+}

android/app/src/main/java/com/now/naaga/presentation/adventuredetail/AdventureDetailUiState.kt

@@ -0,0 +1,16 @@
+package com.now.naaga.presentation.adventuredetail
+
+import com.now.domain.model.AdventureResult
+import com.now.naaga.presentation.uimodel.model.OpenLetterUiModel
+
+sealed interface AdventureDetailUiState {
+    object Loading : AdventureDetailUiState
+
+    data class Success(
+        val readLetters: List<OpenLetterUiModel>,
+        val writeLetters: List<OpenLetterUiModel>,
+        val adventureResult: AdventureResult,
+    ) : AdventureDetailUiState
+
+    object Error : AdventureDetailUiState
+}

android/app/src/main/java/com/now/naaga/presentation/adventuredetail/AdventureDetailViewModel.kt

@@ -0,0 +1,115 @@
+package com.now.naaga.presentation.adventuredetail
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import com.now.domain.model.AdventureResult
+import com.now.domain.model.letter.OpenLetter
+import com.now.domain.model.type.LogType
+import com.now.domain.repository.AdventureRepository
+import com.now.domain.repository.LetterRepository
+import com.now.naaga.data.throwable.DataThrowable
+import com.now.naaga.presentation.uimodel.mapper.toUiModel
+import com.now.naaga.presentation.uimodel.model.OpenLetterUiModel
+import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharedFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asSharedFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.launch
+import java.io.IOException
+import javax.inject.Inject
+
+@HiltViewModel
+class AdventureDetailViewModel @Inject constructor(
+    private val letterRepository: LetterRepository,
+    private val adventureRepository: AdventureRepository,
+) : ViewModel() {
+    private val readLettersFlow = MutableSharedFlow<List<OpenLetter>>()
+
+    private val writeLettersFlow = MutableSharedFlow<List<OpenLetter>>()
+
+    private val adventureFlow = MutableSharedFlow<AdventureResult>()
+
+    private val _uiState: MutableStateFlow<AdventureDetailUiState> = MutableStateFlow(AdventureDetailUiState.Loading)
+    val uiState: StateFlow<AdventureDetailUiState> = _uiState.asStateFlow()
+
+    private val _throwableFlow = MutableSharedFlow<Event>()
+    val throwableFlow: SharedFlow<Event> = _throwableFlow.asSharedFlow()
+
+    init {
+        viewModelScope.launch {
+            combine(readLettersFlow, writeLettersFlow, adventureFlow) { readLetters, writeLetters, adventureResult ->
+                AdventureDetailUiState.Success(
+                    readLetters = getOpenLetterUiModels(readLetters),
+                    writeLetters = getOpenLetterUiModels(writeLetters),
+                    adventureResult = adventureResult,
+                )
+            }.collectLatest { _uiState.value = it }
+        }
+    }
+
+    private fun getOpenLetterUiModels(letters: List<OpenLetter>): List<OpenLetterUiModel> {
+        if (letters.isEmpty()) return listOf(OpenLetterUiModel.DEFAULT_OPEN_LETTER)
+        return letters.map { it.toUiModel() }
+    }
+
+    fun fetchReadLetter(gameId: Long) {
+        viewModelScope.launch {
+            runCatching {
+                letterRepository.fetchLetterLogs(gameId, LogType.READ)
+            }.onSuccess {
+                readLettersFlow.emit(it)
+            }.onFailure {
+                setThrowable(it)
+            }
+        }
+    }
+
+    fun fetchWriteLetter(gameId: Long) {
+        viewModelScope.launch {
+            runCatching {
+                letterRepository.fetchLetterLogs(gameId, LogType.WRITE)
+            }.onSuccess {
+                writeLettersFlow.emit(it)
+            }.onFailure {
+                setThrowable(it)
+            }
+        }
+    }
+
+    fun fetchAdventureResult(gameId: Long) {
+        viewModelScope.launch {
+            runCatching {
+                adventureRepository.fetchAdventureResult(gameId)
+            }.onSuccess {
+                adventureFlow.emit(it)
+            }.onFailure {
+                setThrowable(it)
+            }
+        }
+    }
+
+    private fun setThrowable(throwable: Throwable) {
+        when (throwable) {
+            is IOException -> throwable(Event.NetworkExceptionEvent(throwable))
+            is DataThrowable.LetterThrowable -> throwable(Event.LetterExceptionEvent(throwable))
+            is DataThrowable.GameThrowable -> throwable(Event.GameExceptionEvent(throwable))
+        }
+    }
+
+    private fun throwable(event: Event) {
+        viewModelScope.launch {
+            _throwableFlow.emit(event)
+        }
+    }
+
+    sealed class Event {
+        data class NetworkExceptionEvent(val throwable: Throwable) : Event()
+        data class LetterExceptionEvent(val throwable: Throwable) : Event()
+        data class GameExceptionEvent(val throwable: Throwable) : Event()
+    }
+}

android/app/src/main/java/com/now/naaga/presentation/adventuredetail/recyclerview/LetterAdapter.kt

@@ -0,0 +1,19 @@
+package com.now.naaga.presentation.adventuredetail.recyclerview
+
+import android.view.ViewGroup
+import androidx.recyclerview.widget.RecyclerView
+import com.now.naaga.presentation.uimodel.model.OpenLetterUiModel
+
+class LetterAdapter(private val letters: List<OpenLetterUiModel>) : RecyclerView.Adapter<LetterViewHolder>() {
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): LetterViewHolder {
+        return LetterViewHolder(parent)
+    }
+
+    override fun onBindViewHolder(holder: LetterViewHolder, position: Int) {
+        holder.bind(letters[position])
+    }
+
+    override fun getItemCount(): Int {
+        return letters.size
+    }
+}

android/app/src/main/java/com/now/naaga/presentation/adventuredetail/recyclerview/LetterViewHolder.kt

@@ -0,0 +1,20 @@
+package com.now.naaga.presentation.adventuredetail.recyclerview
+
+import android.view.LayoutInflater
+import android.view.ViewGroup
+import androidx.recyclerview.widget.RecyclerView
+import com.now.naaga.R
+import com.now.naaga.databinding.ItemLetterBinding
+import com.now.naaga.presentation.uimodel.model.OpenLetterUiModel
+
+class LetterViewHolder(parent: ViewGroup) : RecyclerView.ViewHolder(
+    LayoutInflater.from(parent.context).inflate(R.layout.item_letter, parent, false),
+) {
+    private val binding: ItemLetterBinding = ItemLetterBinding.bind(itemView)
+
+    fun bind(letter: OpenLetterUiModel) {
+        binding.tvItemLetterNickname.text = letter.nickname
+        binding.tvItemLetterRegisterDate.text = letter.registerDate
+        binding.tvItemLetter.text = letter.message
+    }
+}

android/app/src/main/java/com/now/naaga/presentation/adventuredetail/viewpager/ViewPagerAdapter.kt

@@ -0,0 +1,19 @@
+package com.now.naaga.presentation.adventuredetail.viewpager
+
+import android.view.ViewGroup
+import androidx.recyclerview.widget.RecyclerView
+import com.now.naaga.presentation.uimodel.model.OpenLetterUiModel
+
+class ViewPagerAdapter(private val data: List<List<OpenLetterUiModel>>) : RecyclerView.Adapter<ViewPagerHolder>() {
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewPagerHolder {
+        return ViewPagerHolder(parent)
+    }
+
+    override fun onBindViewHolder(holder: ViewPagerHolder, position: Int) {
+        holder.bind(data[position])
+    }
+
+    override fun getItemCount(): Int {
+        return data.size
+    }
+}

android/app/src/main/java/com/now/naaga/presentation/adventuredetail/viewpager/ViewPagerHolder.kt

@@ -0,0 +1,19 @@
+package com.now.naaga.presentation.adventuredetail.viewpager
+
+import android.view.LayoutInflater
+import android.view.ViewGroup
+import androidx.recyclerview.widget.RecyclerView
+import com.now.naaga.R
+import com.now.naaga.databinding.ItemViewPagerBinding
+import com.now.naaga.presentation.adventuredetail.recyclerview.LetterAdapter
+import com.now.naaga.presentation.uimodel.model.OpenLetterUiModel
+
+class ViewPagerHolder(parent: ViewGroup) : RecyclerView.ViewHolder(
+    LayoutInflater.from(parent.context).inflate(R.layout.item_view_pager, parent, false),
+) {
+    private val binding: ItemViewPagerBinding = ItemViewPagerBinding.bind(itemView)
+
+    fun bind(data: List<OpenLetterUiModel>) {
+        binding.rvItemViewPager.adapter = LetterAdapter(data)
+    }
+}

android/app/src/main/java/com/now/naaga/presentation/adventurehistory/AdventureHistoryActivity.kt

@@ -9,6 +9,7 @@ import com.now.domain.model.AdventureResult
 import com.now.naaga.R
 import com.now.naaga.data.throwable.DataThrowable
 import com.now.naaga.databinding.ActivityAdventureHistoryBinding
+import com.now.naaga.presentation.adventuredetail.AdventureDetailActivity
 import com.now.naaga.presentation.adventurehistory.recyclerview.AdventureHistoryAdapter
 import com.now.naaga.util.extension.showToast
 import dagger.hilt.android.AndroidEntryPoint
@@ -17,7 +18,7 @@ import dagger.hilt.android.AndroidEntryPoint
 class AdventureHistoryActivity : AppCompatActivity() {
     private lateinit var binding: ActivityAdventureHistoryBinding
     private val viewModel: AdventureHistoryViewModel by viewModels()
-    private val historyAdapter = AdventureHistoryAdapter()
+    private val historyAdapter = AdventureHistoryAdapter(::navigateDetail)
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
@@ -58,6 +59,11 @@ class AdventureHistoryActivity : AppCompatActivity() {
         historyAdapter.submitList(adventureResults)
     }
 
+    private fun navigateDetail(gameId: Long) {
+        val intent = AdventureDetailActivity.getIntentWithId(this, gameId)
+        startActivity(intent)
+    }
+
     companion object {
         fun getIntent(context: Context): Intent {
             return Intent(context, AdventureHistoryActivity::class.java)