Optimize query. Update teamname on change.

app/src/main/java/me/zobrist/tichucounter/data/DaoBase.kt

@@ -1,7 +1,9 @@
 package me.zobrist.tichucounter.data
 
-import androidx.room.*
+import androidx.room.Dao
-import kotlinx.coroutines.flow.Flow
+import androidx.room.Delete
+import androidx.room.Insert
+import androidx.room.Update
 
 @Dao
 interface DaoBase<T> {

app/src/main/java/me/zobrist/tichucounter/data/GameDao.kt

@@ -5,13 +5,13 @@ import kotlinx.coroutines.flow.Flow
 
 
 @Dao
-interface GameDao: DaoBase<Game> {
+interface GameDao : DaoBase<Game> {
 
     @Query("SELECT * FROM game")
     fun getAll(): Flow<List<Game>>
 
     @Query("SELECT * FROM game WHERE uid is :gameId")
-    fun getGameById(gameId: Long): Game
+    fun getGameById(gameId: Long): Flow<Game>
 
     @Query("SELECT * FROM game WHERE active is 1")
     fun getActive(): Game

app/src/main/java/me/zobrist/tichucounter/data/RoundDao.kt

@@ -1,13 +1,10 @@
 package me.zobrist.tichucounter.data
 
-import androidx.room.Dao
+import androidx.room.*
-import androidx.room.Delete
-import androidx.room.Insert
-import androidx.room.Query
 import kotlinx.coroutines.flow.Flow
 
 @Dao
-interface RoundDao: DaoBase<Round> {
+interface RoundDao : DaoBase<Round> {
 
     @Query("SELECT * FROM round")
     fun getAll(): Flow<List<Round>>
@@ -15,6 +12,14 @@ interface RoundDao: DaoBase<Round> {
     @Query("SELECT * FROM round WHERE gameId is :gameId")
     fun getAllForGame(gameId: Long?): List<Round>
 
+    @Query(
+        "SELECT gameId, scoreA, scoreB, round.uid " +
+                "FROM round " +
+                "LEFT JOIN game ON game.uid = round.gameId " +
+                "WHERE game.active == 1"
+    )
+    fun getForActiveGame(): Flow<List<Round>>
+
     @Insert
     fun insertAll(vararg rounds: Round)
 

app/src/main/java/me/zobrist/tichucounter/fragments/HistoryListViewModel.kt

@@ -6,34 +6,22 @@ import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.launch
-import me.zobrist.tichucounter.data.GameDao
 import me.zobrist.tichucounter.data.Round
 import me.zobrist.tichucounter.data.RoundDao
 import me.zobrist.tichucounter.framework.SingleLiveEvent
-import me.zobrist.tichucounter.repository.GameRepository
 import javax.inject.Inject
 
 @HiltViewModel
-class HistoryListViewModel @Inject constructor(
+class HistoryListViewModel @Inject constructor(private val roundDao: RoundDao) : ViewModel() {
-    private val roundDao: RoundDao,
+
-    private val gameDao: GameDao,
-    private val gameRepository: GameRepository
-) : ViewModel() {
     private val _historyA: MutableLiveData<String> = MutableLiveData<String>()
     private val _historyB: MutableLiveData<String> = MutableLiveData<String>()
     private val _scrollDown: SingleLiveEvent<Boolean> = SingleLiveEvent()
 
-
     init {
         viewModelScope.launch {
-            roundDao.getAll().collect {
+            roundDao.getForActiveGame().collect() { scores ->
-                update()
+                update(scores)
-            }
-        }
-
-        viewModelScope.launch {
-            gameDao.getAll().collect {
-                update()
             }
         }
     }
@@ -53,31 +41,19 @@ class HistoryListViewModel @Inject constructor(
             return _scrollDown
         }
 
-    private suspend fun update() {
+    private fun update(scores: List<Round>) {
-        val scores = gameRepository.getActiveRoundHistory()
+        var historyA = String()
-        if (scores != null) {
+        var historyB = String()
-            getHistoryA(scores)
+
-            getHistoryB(scores)
+        scores.forEach {
+            historyA += it.scoreA.toString() + "\n"
+            historyB += it.scoreB.toString() + "\n"
         }
+        _historyA.value = historyA
+        _historyB.value = historyB
         scrollDown()
     }
 
-    private fun getHistoryA(scores: List<Round>) {
-        var tempHistory = String()
-        scores.forEach {
-            tempHistory += it.scoreA.toString() + "\n"
-        }
-        _historyA.value = tempHistory
-    }
-
-    private fun getHistoryB(scores: List<Round>) {
-        var tempHistory = String()
-        scores.forEach {
-            tempHistory += it.scoreB.toString() + "\n"
-        }
-        _historyB.value = tempHistory
-    }
-
     private fun scrollDown() {
         _scrollDown.value = true
     }

app/src/main/java/me/zobrist/tichucounter/fragments/TeamNames.kt

@@ -4,6 +4,7 @@ import android.os.Bundle
 import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
+import androidx.core.widget.doAfterTextChanged
 import androidx.fragment.app.activityViewModels
 import me.zobrist.tichucounter.databinding.FragmentTeamNamesBinding
 
@@ -16,25 +17,25 @@ class TeamNames : FragmentBase<FragmentTeamNamesBinding>() {
 
     override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
 
-        binding.nameTeamA.setOnFocusChangeListener { _, focus ->
+        binding.nameTeamA.doAfterTextChanged {
-            if (!focus) {
             viewModel.setNameA(binding.nameTeamA.text.toString())
         }
-        }
 
-        binding.nameTeamB.setOnFocusChangeListener { _, focus ->
+        binding.nameTeamB.doAfterTextChanged {
-            if (!focus) {
             viewModel.setNameB(binding.nameTeamB.text.toString())
         }
-        }
 
         viewModel.nameA.observe(viewLifecycleOwner) { value ->
+            if (value != binding.nameTeamA.text.toString()) {
                 binding.nameTeamA.setText(value)
             }
+        }
 
         viewModel.nameB.observe(viewLifecycleOwner) { value ->
+            if (value != binding.nameTeamB.text.toString()) {
                 binding.nameTeamB.setText(value)
             }
+        }
 
     }
 }

app/src/main/java/me/zobrist/tichucounter/fragments/TeamScoresViewModel.kt

@@ -6,36 +6,25 @@ import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.launch
-import me.zobrist.tichucounter.data.GameDao
+import me.zobrist.tichucounter.data.Round
 import me.zobrist.tichucounter.data.RoundDao
-import me.zobrist.tichucounter.repository.GameRepository
 import javax.inject.Inject
 
 @HiltViewModel
-class TeamScoresViewModel @Inject constructor(
+class TeamScoresViewModel @Inject constructor(private val roundDao: RoundDao) : ViewModel() {
-    private val roundDao: RoundDao,
+
-    private val gameDao: GameDao,
-    private val gameRepository: GameRepository
-) : ViewModel() {
     private var _scoreA: MutableLiveData<Int> = MutableLiveData()
     private var _scoreB: MutableLiveData<Int> = MutableLiveData()
 
     init {
         viewModelScope.launch {
-            roundDao.getAll().collect {
+            roundDao.getForActiveGame().collect() { scores ->
-                update()
+                update(scores)
-            }
-        }
-
-        viewModelScope.launch {
-            gameDao.getAll().collect {
-                update()
             }
         }
     }
 
-    private suspend fun update() {
+    private fun update(scores: List<Round>) {
-        val scores = gameRepository.getActiveRoundHistory()
 
         var scoreA = 0
         var scoreB = 0