[부나] 3, 4단계 오목 제출합니다.

app/build.gradle.kts

@@ -37,6 +37,7 @@ android {
 
 dependencies {
     implementation(project(":domain"))
+    implementation(project(":data"))
     implementation("androidx.core:core-ktx:1.9.0")
     implementation("androidx.appcompat:appcompat:1.6.0")
     implementation("com.google.android.material:material:1.7.0")

app/src/main/AndroidManifest.xml

@@ -24,5 +24,4 @@
             </intent-filter>
         </activity>
     </application>
-
-</manifest>
+</manifest>

domain/src/main/kotlin/Application.kt → app/src/main/java/woowacourse/omok/Application.kt

@@ -1,12 +1,14 @@
-import controller.OmokController
+package woowacourse.omok
+
 import domain.game.Omok.Companion.OMOK_BOARD_SIZE
 import domain.rule.BlackRenjuRule
 import domain.rule.WhiteRenjuRule
-import view.OmokInputView
-import view.OmokOutputView
+import woowacourse.omok.controller.ConsoleOmokController
+import woowacourse.omok.view.OmokInputView
+import woowacourse.omok.view.OmokOutputView
 
-fun main() {
-    OmokController(
+suspend fun main() {
+    ConsoleOmokController(
         OmokInputView(),
         OmokOutputView(),
     ).startGame(

app/src/main/java/woowacourse/omok/activity/GameResultActivity.kt

@@ -1,14 +1,14 @@
 package woowacourse.omok.activity
 
 import android.content.Intent
-import android.os.Build
 import android.os.Bundle
 import android.view.View
 import android.widget.ImageView
 import android.widget.TextView
 import androidx.appcompat.app.AppCompatActivity
 import woowacourse.omok.R
 import woowacourse.omok.model.StoneColorModel
+import woowacourse.omok.utils.getSerializable
 import woowacourse.omok.utils.setImageByResId
 
 class GameResultActivity : AppCompatActivity(), View.OnClickListener {
@@ -21,11 +21,7 @@ class GameResultActivity : AppCompatActivity(), View.OnClickListener {
     }
 
     private fun setWinnerStoneImage() {
-        val winnerStoneColor = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-            intent.getSerializableExtra("winner_color", StoneColorModel::class.java)
-        } else {
-            intent.getSerializableExtra("winner_color")
-        }
+        val winnerStoneColor = getSerializable(WINNER_KEY, StoneColorModel::class.java)
         val winnerStoneIv = findViewById<ImageView>(R.id.winner_stone_iv)
         val winnerStoneTv = findViewById<TextView>(R.id.winner_stone_tv)
 
@@ -61,4 +57,8 @@ class GameResultActivity : AppCompatActivity(), View.OnClickListener {
     private fun endGame() {
         finish()
     }
+
+    companion object {
+        internal const val WINNER_KEY = "winner_color"
+    }
 }

app/src/main/java/woowacourse/omok/activity/MainActivity.kt

@@ -1,51 +1,56 @@
 package woowacourse.omok.activity
 
-import android.content.ContentValues
 import android.content.Intent
 import android.os.Bundle
 import android.view.View
 import android.widget.ImageView
 import android.widget.TableLayout
 import android.widget.TableRow
-import android.widget.Toast
+import android.widget.TextView
 import androidx.appcompat.app.AppCompatActivity
 import androidx.core.view.children
-import domain.game.*
+import domain.game.Omok
 import domain.point.Point
 import domain.rule.BlackRenjuRule
 import domain.rule.WhiteRenjuRule
 import domain.stone.StoneColor
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.MainCoroutineDispatcher
+import kotlinx.coroutines.launch
 import woowacourse.omok.R
-import woowacourse.omok.database.OmokDatabase
-import woowacourse.omok.database.repository.OmokRepository
-import woowacourse.omok.database.repository.Repository
+import woowacourse.omok.controller.AndroidOmokController
+import woowacourse.omok.controller.ConsoleOmokController
+import woowacourse.omok.data.database.OmokDatabase
+import woowacourse.omok.data.database.repository.OmokRepository
 import woowacourse.omok.mapper.toPresentation
 import woowacourse.omok.model.StoneColorModel
 import woowacourse.omok.utils.createAlertDialog
 import woowacourse.omok.utils.message
 import woowacourse.omok.utils.negativeButton
 import woowacourse.omok.utils.positiveButton
+import woowacourse.omok.utils.showMessage
+import woowacourse.omok.view.InputView
+import woowacourse.omok.view.OutputView
 
-class MainActivity : AppCompatActivity() {
+class MainActivity(override val coroutineContext: MainCoroutineDispatcher = Dispatchers.Main) :
+    AppCompatActivity(), InputView, OutputView, CoroutineScope {
     private lateinit var board: TableLayout
-    private lateinit var omok: Omok
-    private lateinit var omokRepo: Repository
     private lateinit var manTurnHolder: View
     private lateinit var womanTurnHolder: View
+    private lateinit var omokController: AndroidOmokController
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         setContentView(R.layout.activity_main)
+        init()
+        launch { omokController.startGame(BlackRenjuRule(), WhiteRenjuRule()) }
+    }
 
-        omokRepo = OmokRepository(OmokDatabase.getInstance(this))
-        omok = Omok(BlackRenjuRule(), WhiteRenjuRule())
+    private fun init() {
         initView()
-
-        if (hasPreviousGameHistory()) {
-            showRestartDialog()
-        }
-        setOmokClickListener()
-        showMessage(getString(R.string.omok_start_message))
+        initOmokController()
+        initOmokIntersectionClickListener()
     }
 
     private fun initView() {
@@ -54,105 +59,117 @@ class MainActivity : AppCompatActivity() {
         womanTurnHolder = findViewById(R.id.woman_turn_iv)
     }
 
-    private fun continuePreviousGame() {
-        omokRepo.getAll {
-            if (it.count % 2 == 1) toggleTurnHolder(StoneColorModel.BLACK)
-            while (it.moveToNext()) {
-                val col = it.getInt(it.getColumnIndexOrThrow("x"))
-                val row = it.getInt(it.getColumnIndexOrThrow("y"))
-                val index = row * Omok.OMOK_BOARD_SIZE + col
-                val omokIv: ImageView = boardImageViews()[index]
-                val putResult = omok.put { Point(row, col) }
-                if (putResult is PutSuccess) {
-                    drawStoneOnBoard(omokIv, putResult.stoneColor)
-                }
-            }
-        }
+    private fun initOmokController() {
+        omokController = AndroidOmokController(
+            ConsoleOmokController(this, this),
+            OmokRepository(OmokDatabase.getInstance(this)),
+        )
     }
 
-    private fun setOmokClickListener() {
-        boardImageViews().forEachIndexed { index, view ->
+    private fun initOmokIntersectionClickListener() {
+        boardImageViews().forEachIndexed { index, omokIntersection ->
             val row: Int = index / Omok.OMOK_BOARD_SIZE
             val col: Int = index % Omok.OMOK_BOARD_SIZE
-
-            view.setOnClickListener {
-                val putResult = omok.put { Point(row, col) }
-                processPutResult(putResult, view)
+            omokIntersection.setOnClickListener {
+                launch { omokController.putStone(row, col) }
             }
         }
     }
 
-    private fun processPutResult(result: PutResult, view: ImageView) {
-        when (result) {
-            is PutSuccess -> {
-                toggleTurnHolder(result.stoneColor.toPresentation())
-                savePoint(result.stoneColor.toPresentation(), result.point)
-                drawStoneOnBoard(view, result.stoneColor)
-            }
-            is PutFailed -> showMessage(getString(R.string.inplace_stone))
-            is GameFinish -> {
-                omokRepo.clear()
-                showWinner(result.winnerStoneColor.toPresentation())
+    private fun continuePreviousGame() {
+        launch(Dispatchers.IO) {
+            omokController.loadPreviousPoints { points, pointsCount ->
+                showLatestTurnHolder(pointsCount)
+                drawPreviousPoints(points)
             }
         }
     }
 
-    private fun toggleTurnHolder(prevStoneColor: StoneColorModel) {
-        when(prevStoneColor) {
-            StoneColorModel.BLACK -> {
-                manTurnHolder.visibility = View.GONE
-                womanTurnHolder.visibility = View.VISIBLE
-            }
-            StoneColorModel.WHITE -> {
-                womanTurnHolder.visibility = View.GONE
-                manTurnHolder.visibility = View.VISIBLE
-            }
+    private fun showLatestTurnHolder(pointsCount: Int) {
+        val latestColor = StoneColorModel.calcLatestTurn(pointsCount + 1)
+        toggleTurnHolder(latestColor ?: StoneColorModel.WHITE)
+    }
+
+    private fun drawPreviousPoints(points: List<Point>) {
+        points.forEachIndexed { index, point ->
+            val viewIndex = point.row * Omok.OMOK_BOARD_SIZE + point.col
+            val omokIv: ImageView = boardImageViews()[viewIndex]
+            val curColor = StoneColorModel.calcLatestTurn(index) ?: StoneColorModel.BLACK
+
+            launch(Dispatchers.Main) { drawStoneOnBoard(omokIv, curColor) }
         }
     }
 
-    private fun savePoint(stoneColor: StoneColorModel, point: Point) {
-        val record = ContentValues().apply {
-            put("stone_color", stoneColor.value)
-            put("x", point.col)
-            put("y", point.row)
+    private fun drawStoneOnBoard(view: ImageView, stoneColor: StoneColorModel) {
+        when (stoneColor) {
+            StoneColorModel.BLACK -> view.setImageResource(R.drawable.white_bear)
+            StoneColorModel.WHITE -> view.setImageResource(R.drawable.pink_bear)
         }
-        omokRepo.insert(record)
     }
 
-    private fun hasPreviousGameHistory(): Boolean = !omokRepo.isEmpty()
+    override suspend fun readPosition(onPutStone: (Point) -> Unit) {
+        for (newPoint in omokController.pointChannel) {
+            onPutStone(newPoint)
+        }
+    }
 
-    private fun drawStoneOnBoard(view: ImageView, stoneColor: StoneColor) {
-        when (stoneColor) {
-            StoneColor.BLACK -> view.setImageResource(R.drawable.pink_bear)
-            StoneColor.WHITE -> view.setImageResource(R.drawable.white_bear)
+    override fun startGame() {
+        showMessage(getString(R.string.omok_start_message))
+        if (omokController.hasPreviousGameHistory()) showRestartDialog()
+    }
+
+    override fun drawStone(lastStoneColor: StoneColor, newPoint: Point) {
+        omokController.savePoint(newPoint)
+        val index = newPoint.row * Omok.OMOK_BOARD_SIZE + newPoint.col
+        drawStoneOnBoard(boardImageViews()[index], lastStoneColor.toPresentation())
+    }
+
+    override fun showPutFailed() {
+        showMessage(getString(R.string.inplace_stone))
+    }
+
+    override fun showResult(
+        lastStoneColor: StoneColor,
+        winnerStoneColor: StoneColor,
+        newPoint: Point,
+    ) {
+        omokController.clearPoints()
+        showWinner(winnerStoneColor.toPresentation())
+    }
+
+    override fun showCurrentTurnColor(curStoneColor: StoneColor, point: Point?) {
+        point?.let {
+            toggleTurnHolder(curStoneColor.next().toPresentation())
+            findViewById<TextView>(R.id.last_point_tv).text =
+                getString(R.string.last_put_point, it.col, it.row)
+        }
+    }
+
+    private fun toggleTurnHolder(prevStoneColor: StoneColorModel) {
+        launch(Dispatchers.Main) {
+            manTurnHolder.visibility =
+                if (prevStoneColor == StoneColorModel.WHITE) View.VISIBLE else View.GONE
+            womanTurnHolder.visibility =
+                if (prevStoneColor == StoneColorModel.BLACK) View.VISIBLE else View.GONE
         }
     }
 
     private fun showWinner(winnerColor: StoneColorModel) {
         val resultIntent = Intent(this, GameResultActivity::class.java)
-            .putExtra("winner_color", winnerColor)
+            .putExtra(GameResultActivity.WINNER_KEY, winnerColor)
         startActivity(resultIntent)
         finish()
     }
 
-    private fun showMessage(message: String) {
-        Toast.makeText(this, message, Toast.LENGTH_SHORT).show()
-    }
-
     private fun showRestartDialog(): Unit = createAlertDialog {
         message(getString(R.string.restart_game_ask_message))
         positiveButton(getString(R.string.yes)) { continuePreviousGame() }
-        negativeButton(getString(R.string.no)) { omokRepo.clear() }
+        negativeButton(getString(R.string.no)) { omokController.clearPoints() }
     }.show()
 
     private fun boardImageViews(): List<ImageView> = board.children
         .filterIsInstance<TableRow>()
         .flatMap { it.children }
         .filterIsInstance<ImageView>()
         .toList()
-
-    override fun onDestroy() {
-        super.onDestroy()
-        omokRepo.close()
-    }
 }

app/src/main/java/woowacourse/omok/controller/AndroidOmokController.kt

@@ -0,0 +1,40 @@
+package woowacourse.omok.controller
+
+import domain.game.Omok
+import domain.point.Point
+import domain.rule.OmokRule
+import kotlinx.coroutines.channels.Channel
+import repository.Repository
+
+class AndroidOmokController(
+    private val controller: ConsoleOmokController,
+    private val omokRepo: Repository<Point>,
+) {
+    private lateinit var omok: Omok
+    val pointChannel = Channel<Point>()
+
+    suspend fun startGame(blackRule: OmokRule, whiteRule: OmokRule) {
+        omok = Omok(blackRule, whiteRule)
+        controller.startGame(omok)
+    }
+
+    suspend fun loadPreviousPoints(onLoaded: (List<Point>, pointsCount: Int) -> Unit) {
+        val previousPoints = omokRepo.getAll()
+        previousPoints.forEach { point -> omok.put { point } }
+        onLoaded(previousPoints, previousPoints.size)
+    }
+
+    fun clearPoints() {
+        omokRepo.clear()
+    }
+
+    fun savePoint(point: Point) {
+        omokRepo.insert(point)
+    }
+
+    fun hasPreviousGameHistory(): Boolean = !omokRepo.isEmpty()
+
+    suspend fun putStone(row: Int, col: Int) {
+        pointChannel.send(Point(row, col))
+    }
+}