Android Room+ViewModel开发疑问：分类数据处理与LiveData使用

Hey there! Let's work through your Room+ViewModel+LiveData setup step by step—you're asking all the right questions for a clean, maintainable app architecture.

You’re spot on: all data fetching and computation should live in your ViewModel, not in individual Fragments. Here’s why:

• ViewModels outlive Fragment lifecycles, so your computed state stays consistent even when Fragments are destroyed/recreated (like during screen rotations).
• Using a single Activity-level ViewModel means all your Fragments share the exact same data source—no duplicate logic or sync issues.
• Instead of exposing getter methods, expose pre-computed LiveData streams directly to Fragments. This way, Fragments only need to observe the LiveData and update their UI when data changes, rather than manually requesting updates.

You don’t need to manually register observers inside your ViewModel and generate new LiveData from their onChanged callbacks. Google’s Transformations utility class is made exactly for this scenario—it lets you convert or filter LiveData streams automatically.

For example, if your Room DAO returns a LiveData<List<CategoryItem>> for all table entries, you can create sorted LiveData streams like this:

class CategoryViewModel(private val categoryDao: CategoryDao) : ViewModel() {
    // Raw LiveData from Room (automatically updates when the table changes)
    private val allCategoryItems = categoryDao.getAllCategoryItems()

    // Expose sorted LiveData streams for Fragments to observe
    val itemsSortedByName: LiveData<List<CategoryItem>> = Transformations.map(allCategoryItems) { items ->
        items.sortedBy { it.categoryName }
    }

    val itemsSortedByCreationDate: LiveData<List<CategoryItem>> = Transformations.map(allCategoryItems) { items ->
        items.sortedByDescending { it.creationTimestamp }
    }
}

Room handles the database observation for you—when any entry in the table changes, allCategoryItems emits a new list, and Transformations.map automatically re-runs your sorting logic to update the exposed LiveData streams. Fragments just observe these streams and refresh their UI when needed.

This depends on how many categories you expect and how heavy your computation is:

• If categories are few or computation is lightweight: Stick with full-table observation. It’s simpler to maintain, and Room’s LiveData queries are optimized to only trigger updates when actual data changes. Even if a single category’s entry updates, re-sorting the full list is usually fast enough for most apps.
• If you have hundreds/thousands of categories or heavy computation: Use Transformations.switchMap to dynamically fetch and compute data for specific categories. Here’s how that might look:

class CategoryViewModel(private val categoryDao: CategoryDao) : ViewModel() {
    // MutableLiveData to track which category the user is viewing (Fragments can update this)
    private val selectedCategoryId = MutableLiveData<Long?>()

    // Dynamically fetch and sort data for the selected category
    val currentCategoryItems: LiveData<List<CategoryItem>> = Transformations.switchMap(selectedCategoryId) { categoryId ->
        if (categoryId == null) {
            // No category selected? Return sorted full list
            categoryDao.getAllCategoryItems().map { it.sortedBy { item -> item.name } }
        } else {
            // Return sorted list for the specific category
            categoryDao.getItemsByCategoryId(categoryId).map { it.sortedBy { item -> item.name } }
        }
    }

    // Let Fragments switch the active category
    fun setSelectedCategoryId(categoryId: Long?) {
        selectedCategoryId.value = categoryId
    }
}

If you need to show multiple categories across different Fragments at once, another option is to map the full table to a LiveData<Map<Long, List<CategoryItem>>> (keyed by category ID). Then each Fragment can pull the list for its target category from the map.

To make sure your Fragments access the same computed data, always retrieve the ViewModel using the Activity’s ViewModelStoreOwner (not the Fragment’s own). In your Fragment:

val viewModel = ViewModelProvider(requireActivity())[CategoryViewModel::class.java]

This way, every Fragment attached to the same Activity uses the exact same ViewModel instance, so their observed LiveData streams are perfectly synced.

内容的提问来源于stack exchange，提问作者Wiktor