Move complex logic out of MainView into MainViewModel using coroutine (#6036)

* Use a single source of truth for the UI

Author: TimoPtr

wear/src/main/kotlin/io/homeassistant/companion/android/home/HomeActivity.kt

@@ -170,7 +170,7 @@ class HomeActivity :
         mainViewModel.initAllSensors()
 
         lifecycleScope.launch {
-            if (mainViewModel.loadingState.value == MainViewModel.LoadingState.READY) {
+            if (mainViewModel.loadingState == MainViewModel.LoadingState.READY) {
                 try {
                     mainViewModel.updateUI()
                 } catch (e: CancellationException) {

wear/src/main/kotlin/io/homeassistant/companion/android/home/MainViewModel.kt

@@ -65,6 +65,33 @@ class MainViewModel @Inject constructor(
         ERROR,
     }
 
+    /**
+     * Holds entity classification information for filtering entities in the UI.
+     */
+    data class EntityClassification(
+        val entitiesWithoutArea: Set<String> = emptySet(),
+        val entitiesWithCategory: Set<String> = emptySet(),
+        val entitiesHidden: Set<String> = emptySet(),
+        val hasAreasToShow: Boolean = false,
+        val hasMoreEntitiesToShow: Boolean = false,
+    )
+
+    /**
+     * Immutable UI state for MainView that contains thread-safe snapshots of all data.
+     */
+    data class MainViewUiState(
+        val entities: Map<String, Entity> = emptyMap(),
+        val favoriteCaches: List<FavoriteCaches> = emptyList(),
+        val isFavoritesOnly: Boolean = false,
+        val loadingState: LoadingState = LoadingState.LOADING,
+        val entitiesByAreaOrder: List<String> = emptyList(),
+        val entitiesByArea: Map<String, List<String>> = emptyMap(),
+        val areas: List<AreaRegistryResponse> = emptyList(),
+        val entitiesByDomainFilteredOrder: List<String> = emptyList(),
+        val entitiesByDomainFiltered: Map<String, List<String>> = emptyMap(),
+        val entitiesByDomain: Map<String, List<String>> = emptyMap(),
+    )
+
     private val app = application
 
     private lateinit var homePresenter: HomePresenter
@@ -86,6 +113,12 @@ class MainViewModel @Inject constructor(
     private val _supportedEntities = MutableStateFlow(emptyList<String>())
     val supportedEntities = _supportedEntities.asStateFlow()
 
+    private val _entityClassification = MutableStateFlow(EntityClassification())
+    val entityClassification = _entityClassification.asStateFlow()
+
+    private val _mainViewUiState = MutableStateFlow(MainViewUiState())
+    val mainViewUiState = _mainViewUiState.asStateFlow()
+
     /**
      * IDs of favorites in the Favorites database.
      */
@@ -115,13 +148,22 @@ class MainViewModel @Inject constructor(
     var entitiesByDomainOrder = mutableStateListOf<String>()
         private set
 
+    /**
+     * Filtered entities by domain - only entities without area, category, or hidden status.
+     * Used for the "More Entities" section in the UI.
+     */
+    var entitiesByDomainFiltered = mutableStateMapOf<String, SnapshotStateList<Entity>>()
+        private set
+    var entitiesByDomainFilteredOrder = mutableStateListOf<String>()
+        private set
+
     // Content of EntityListView
-    var entityLists = mutableStateMapOf<String, List<Entity>>()
+    var entityListIds = mutableStateMapOf<String, List<String>>()
     var entityListsOrder = mutableStateListOf<String>()
     var entityListFilter: (Entity) -> Boolean = { true }
 
     // settings
-    var loadingState = mutableStateOf(LoadingState.LOADING)
+    var loadingState by mutableStateOf(LoadingState.LOADING)
         private set
     var isHapticEnabled = mutableStateOf(false)
         private set
@@ -200,7 +242,7 @@ class MainViewModel @Inject constructor(
             if (!homePresenter.isConnected()) return@launch
             try {
                 // Load initial state
-                loadingState.value = LoadingState.LOADING
+                loadingState = LoadingState.LOADING
                 updateUI()
 
                 // Finished initial load, update state
@@ -209,14 +251,16 @@ class MainViewModel @Inject constructor(
                     homePresenter.onInvalidAuthorization()
                     return@launch
                 }
-                loadingState.value = if (webSocketState == WebSocketState.Active) {
+                loadingState = if (webSocketState == WebSocketState.Active) {
                     LoadingState.READY
                 } else {
                     LoadingState.ERROR
                 }
+                updateMainViewUiState()
             } catch (e: Exception) {
                 Timber.e(e, "Exception while loading entities")
-                loadingState.value = LoadingState.ERROR
+                loadingState = LoadingState.ERROR
+                updateMainViewUiState()
             }
         }
     }
@@ -261,6 +305,8 @@ class MainViewModel @Inject constructor(
         }
         if (!isFavoritesOnly) {
             updateEntityDomains()
+        } else {
+            updateMainViewUiState()
         }
     }
 
@@ -316,48 +362,175 @@ class MainViewModel @Inject constructor(
         .map { it.entityId }
         .filter { it.split(".")[0] in supportedDomains() }
 
-    private fun updateEntityDomains() {
+    /**
+     * Updates the main view UI state with thread-safe snapshots of all data.
+     * This should be called on a background thread whenever state changes.
+     */
+    private fun updateMainViewUiState() {
+        _mainViewUiState.value = MainViewUiState(
+            entities = entities.toMap(),
+            favoriteCaches = favoriteCaches.toList(),
+            isFavoritesOnly = isFavoritesOnly,
+            loadingState = loadingState,
+            entitiesByAreaOrder = entitiesByAreaOrder.toList(),
+            entitiesByArea = entitiesByArea.mapValues { (_, entities) -> entities.map { it.entityId } },
+            areas = areas.toList(),
+            entitiesByDomainFilteredOrder = entitiesByDomainFilteredOrder.toList(),
+            entitiesByDomainFiltered = entitiesByDomainFiltered.mapValues { (_, entities) ->
+                entities.map { it.entityId }
+            },
+            entitiesByDomain = entitiesByDomain.mapValues { (_, entities) -> entities.map { it.entityId } },
+        )
+    }
+
+    /**
+     * This function does a lot of manipulation and could take some time so we need
+     * to make sure it doesn't happen in the Main thread.
+     */
+    private suspend fun updateEntityDomains() = withContext(Dispatchers.Default) {
         val entitiesList = entities.values.toList().sortedBy { it.entityId }
         val areasList = areaRegistry.orEmpty().sortedBy { it.name }
         val domainsList = entitiesList.map { it.domain }.distinct()
+        val validAreaIds = areasList.map { it.areaId }.toSet()
+
+        // Single pass: compute entity metadata and cache area lookups to avoid redundant calls
+        val entityAreaMap = mutableMapOf<String, AreaRegistryResponse?>()
+        val withoutArea = mutableSetOf<String>()
+        val withCategory = mutableSetOf<String>()
+        val hidden = mutableSetOf<String>()
+
+        entities.keys.forEach { entityId ->
+            val area = getAreaForEntity(entityId)
+            entityAreaMap[entityId] = area
+
+            if (area == null) {
+                withoutArea.add(entityId)
+            }
+            if (getCategoryForEntity(entityId) != null) {
+                withCategory.add(entityId)
+            }
+            if (getHiddenByForEntity(entityId) != null) {
+                hidden.add(entityId)
+            }
+        }
+
+        // Determine if entity should be shown in filtered views
+        val shouldShowEntity: (String) -> Boolean = { entityId ->
+            entityId !in withCategory && entityId !in hidden
+        }
+
+        // Group entities by area using cached area lookups
+        updateEntitiesByArea(areasList, entitiesList, entityAreaMap)
+
+        // Remove areas that no longer exist
+        entitiesByArea.keys.toList().forEach { areaId ->
+            if (areaId !in validAreaIds) {
+                entitiesByArea.remove(areaId)
+            }
+        }
+
+        // Group entities by domain (both full and filtered) in a single pass
+        updateEntitiesByDomain(domainsList, entitiesList, withoutArea, withCategory, hidden)
+
+        // Compute UI visibility flags
+        val hasAreasToShow = entitiesByArea.values.any { areaEntities ->
+            areaEntities.any { entity -> shouldShowEntity(entity.entityId) }
+        }
+
+        val hasMoreEntitiesToShow = withoutArea.any(shouldShowEntity)
+
+        // Update entity classification with all computed values
+        _entityClassification.value = EntityClassification(
+            entitiesWithoutArea = withoutArea,
+            entitiesWithCategory = withCategory,
+            entitiesHidden = hidden,
+            hasAreasToShow = hasAreasToShow,
+            hasMoreEntitiesToShow = hasMoreEntitiesToShow,
+        )
+
+        // Update the main view UI state with snapshots
+        updateMainViewUiState()
+    }
 
-        // Create a list with all areas + their entities
+    /**
+     * Updates the entities grouped by area.
+     */
+    private fun updateEntitiesByArea(
+        areasList: List<AreaRegistryResponse>,
+        entitiesList: List<Entity>,
+        entityAreaMap: Map<String, AreaRegistryResponse?>,
+    ) {
         areasList.forEach { area ->
-            val entitiesInArea = mutableStateListOf<Entity>()
-            entitiesInArea.addAll(
-                entitiesList
-                    .filter { getAreaForEntity(it.entityId)?.areaId == area.areaId }
-                    .sortedBy { (it.attributes["friendly_name"] ?: it.entityId) as String },
-            )
+            val entitiesInArea = entitiesList
+                .filter { entityAreaMap[it.entityId]?.areaId == area.areaId }
+                .sortedBy { (it.attributes["friendly_name"] ?: it.entityId) as String }
+
             entitiesByArea[area.areaId]?.let {
                 it.clear()
                 it.addAll(entitiesInArea)
             } ?: run {
-                entitiesByArea[area.areaId] = entitiesInArea
+                entitiesByArea[area.areaId] = mutableStateListOf<Entity>().apply { addAll(entitiesInArea) }
             }
         }
+
         entitiesByAreaOrder.clear()
         entitiesByAreaOrder.addAll(areasList.map { it.areaId })
-        // Quick check: are there any areas in the list that no longer exist?
-        entitiesByArea.forEach {
-            if (!areasList.any { item -> item.areaId == it.key }) {
-                entitiesByArea.remove(it.key)
-            }
-        }
+    }
+
+    /**
+     * Updates entities grouped by domain (both full and filtered).
+     */
+    private fun updateEntitiesByDomain(
+        domainsList: List<String>,
+        entitiesList: List<Entity>,
+        withoutArea: Set<String>,
+        withCategory: Set<String>,
+        hidden: Set<String>,
+    ) {
+        val filteredDomainsList = mutableListOf<String>()
 
-        // Create a list with all discovered domains + their entities
         domainsList.forEach { domain ->
-            val entitiesInDomain = mutableStateListOf<Entity>()
-            entitiesInDomain.addAll(entitiesList.filter { it.domain == domain })
+            // All entities in domain
+            val entitiesInDomain = entitiesList.filter { it.domain == domain }
+
             entitiesByDomain[domain]?.let {
                 it.clear()
                 it.addAll(entitiesInDomain)
             } ?: run {
-                entitiesByDomain[domain] = entitiesInDomain
+                entitiesByDomain[domain] = mutableStateListOf<Entity>().apply { addAll(entitiesInDomain) }
+            }
+
+            // Filtered entities (without area, category, or hidden status)
+            val entitiesInDomainFiltered = entitiesInDomain.filter { entity ->
+                entity.entityId in withoutArea &&
+                    entity.entityId !in withCategory &&
+                    entity.entityId !in hidden
+            }
+
+            if (entitiesInDomainFiltered.isNotEmpty()) {
+                filteredDomainsList.add(domain)
+                entitiesByDomainFiltered[domain]?.let {
+                    it.clear()
+                    it.addAll(entitiesInDomainFiltered)
+                } ?: run {
+                    entitiesByDomainFiltered[domain] =
+                        mutableStateListOf<Entity>().apply { addAll(entitiesInDomainFiltered) }
+                }
             }
         }
+
         entitiesByDomainOrder.clear()
         entitiesByDomainOrder.addAll(domainsList)
+
+        // Remove domains that no longer have filtered entities
+        entitiesByDomainFiltered.keys.toList().forEach { domain ->
+            if (domain !in filteredDomainsList) {
+                entitiesByDomainFiltered.remove(domain)
+            }
+        }
+
+        entitiesByDomainFilteredOrder.clear()
+        entitiesByDomainFilteredOrder.addAll(filteredDomainsList)
     }
 
     fun toggleEntity(entityId: String, state: String) {

wear/src/main/kotlin/io/homeassistant/companion/android/home/views/HomeView.kt

@@ -5,6 +5,8 @@ import android.provider.Settings
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.contract.ActivityResultContracts
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.derivedStateOf
+import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateListOf
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
@@ -85,9 +87,9 @@ fun LoadHomePage(mainViewModel: MainViewModel) {
                     },
                     onRetryLoadEntitiesClicked = mainViewModel::loadEntities,
                     onSettingsClicked = { swipeDismissableNavController.navigate(SCREEN_SETTINGS) },
-                    onNavigationClicked = { lists, order, filter ->
-                        mainViewModel.entityLists.clear()
-                        mainViewModel.entityLists.putAll(lists)
+                    onNavigationClicked = { entityIdLists, order, filter ->
+                        mainViewModel.entityListIds.clear()
+                        mainViewModel.entityListIds.putAll(entityIdLists)
                         mainViewModel.entityListsOrder.clear()
                         mainViewModel.entityListsOrder.addAll(order)
                         mainViewModel.entityListFilter = filter
@@ -130,8 +132,18 @@ fun LoadHomePage(mainViewModel: MainViewModel) {
                 }
             }
             composable(SCREEN_ENTITY_LIST) {
+                // Build entity lists by looking up entities from the live entities map
+                // This ensures real-time state updates when entities change
+                // Using derivedStateOf to only recompute when entityListIds or entities change
+                val entityLists by remember {
+                    derivedStateOf {
+                        mainViewModel.entityListIds.mapValues { (_, entityIds) ->
+                            entityIds.mapNotNull { entityId -> mainViewModel.entities[entityId] }
+                        }
+                    }
+                }
                 EntityViewList(
-                    entityLists = mainViewModel.entityLists,
+                    entityLists = entityLists,
                     entityListsOrder = mainViewModel.entityListsOrder,
                     entityListFilter = mainViewModel.entityListFilter,
                     onEntityClicked = { entityId, state ->
@@ -150,7 +162,7 @@ fun LoadHomePage(mainViewModel: MainViewModel) {
                         mainViewModel.refreshNotificationPermission()
                     }
                 SettingsView(
-                    loadingState = mainViewModel.loadingState.value,
+                    loadingState = mainViewModel.loadingState,
                     favorites = mainViewModel.favoriteEntityIds.value,
                     onClickSetFavorites = {
                         swipeDismissableNavController.navigate(