Android MVVM Implementation Guide: Building Scalable Apps#

Introduction#

Model-View-ViewModel (MVVM) has become the de facto standard for Android application architecture. This comprehensive guide explores implementing MVVM using Android’s Architecture Components, modern state management techniques, and best practices derived from Google’s official samples.

Understanding MVVM Architecture#

Core Components#

MVVM separates application logic into three distinct layers:

1
graph TB
2
    subgraph "MVVM Architecture"
3
        V[View]
4
        VM[ViewModel]
5
        M[Model]
6

7
        V <--> VM
8
        VM <--> M
9

10
        subgraph "View Layer"
11
            V --> ACTIVITY[Activity/Fragment]
12
            V --> COMPOSE[Compose UI]
13
        end
14

15
        subgraph "ViewModel Layer"
16
            VM --> STATE[UI State]
17
            VM --> LOGIC[Business Logic]
18
        end
19

20
        subgraph "Model Layer"
21
            M --> REPO[Repository]
22
            M --> DB[Database]
23
            M --> API[API Service]
24
        end
25
    end

Benefits of MVVM#

Separation of Concerns: Clear responsibility boundaries
Testability: Easy unit testing of business logic
Lifecycle Awareness: Automatic lifecycle management
Data Binding: Reactive UI updates
Configuration Survival: Survives configuration changes

Setting Up MVVM Foundation#

Project Dependencies#

1
// build.gradle (Module: app)
2
dependencies {
3
    // Core AndroidX libraries
4
    implementation "androidx.core:core-ktx:1.12.0"
5
    implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.7.0"
6

7
    // ViewModel and LiveData
8
    implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:2.7.0"
9
    implementation "androidx.lifecycle:lifecycle-livedata-ktx:2.7.0"
10

11
    // Fragment and Activity
12
    implementation "androidx.fragment:fragment-ktx:1.6.2"
13
    implementation "androidx.activity:activity-ktx:1.8.2"
14

15
    // Data Binding
16
    implementation "androidx.databinding:databinding-runtime:8.2.0"
17

18
    // Navigation
19
    implementation "androidx.navigation:navigation-fragment-ktx:2.7.5"
20
    implementation "androidx.navigation:navigation-ui-ktx:2.7.5"
21

22
    // Room Database
23
    implementation "androidx.room:room-runtime:2.6.1"
24
    implementation "androidx.room:room-ktx:2.6.1"
25
    kapt "androidx.room:room-compiler:2.6.1"
26

27
    // Coroutines
28
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3"
29

30
    // Hilt Dependency Injection
31
    implementation "com.google.dagger:hilt-android:2.48.1"
32
    kapt "com.google.dagger:hilt-compiler:2.48.1"
33

34
    // Testing
35
    testImplementation "junit:junit:4.13.2"
36
    testImplementation "org.mockito:mockito-core:5.7.0"
37
    testImplementation "androidx.arch.core:core-testing:2.2.0"
38
    testImplementation "org.jetbrains.kotlinx:kotlinx-coroutines-test:1.7.3"
39
}
40

41
android {
42
    buildFeatures {
43
        dataBinding = true
44
        viewBinding = true
45
    }
46
}

Base Classes#

1
// BaseViewModel.kt - Foundation ViewModel
2
abstract class BaseViewModel : ViewModel() {
3

4
    protected val _isLoading = MutableLiveData<Boolean>()
5
    val isLoading: LiveData<Boolean> = _isLoading
6

7
    protected val _error = MutableLiveData<String?>()
8
    val error: LiveData<String?> = _error
9

10
    protected fun handleError(throwable: Throwable) {
11
        _error.value = when (throwable) {
12
            is IOException -> "Network error. Please check your connection."
13
            is HttpException -> "Server error: ${throwable.message}"
14
            else -> "An unexpected error occurred: ${throwable.message}"
15
        }
16
    }
17

18
    protected fun clearError() {
19
        _error.value = null
20
    }
21

22
    protected fun setLoading(loading: Boolean) {
23
        _isLoading.value = loading
24
    }
25
}
26

27
// BaseFragment.kt - Foundation Fragment
28
abstract class BaseFragment<VB : ViewDataBinding, VM : BaseViewModel> : Fragment() {
29

30
    protected lateinit var binding: VB
31
    protected abstract val viewModel: VM
32

33
    protected abstract fun getLayoutId(): Int
34
    protected abstract fun initializeViews()
35
    protected abstract fun observeViewModel()
36

37
    override fun onCreateView(
38
        inflater: LayoutInflater,
39
        container: ViewGroup?,
40
        savedInstanceState: Bundle?
41
    ): View? {
42
        binding = DataBindingUtil.inflate(inflater, getLayoutId(), container, false)
43
        binding.lifecycleOwner = viewLifecycleOwner
44
        return binding.root
45
    }
46

47
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
48
        super.onViewCreated(view, savedInstanceState)
49
        initializeViews()
50
        observeViewModel()
51
        setupErrorHandling()
52
    }
53

54
    private fun setupErrorHandling() {
55
        viewModel.error.observe(viewLifecycleOwner) { error ->
56
            error?.let {
57
                showError(it)
58
                viewModel.clearError()
59
            }
60
        }
61

62
        viewModel.isLoading.observe(viewLifecycleOwner) { isLoading ->
63
            showLoading(isLoading)
64
        }
65
    }
66

67
    protected open fun showError(message: String) {
68
        Snackbar.make(binding.root, message, Snackbar.LENGTH_LONG).show()
69
    }
70

71
    protected open fun showLoading(show: Boolean) {
72
        // Override in subclasses to show/hide loading indicator
73
    }
74
}

Model Layer Implementation#

Data Models#

1
// Task.kt - Domain Model
2
@Parcelize
3
data class Task(
4
    val id: String = UUID.randomUUID().toString(),
5
    val title: String,
6
    val description: String,
7
    val isCompleted: Boolean = false,
8
    val priority: TaskPriority = TaskPriority.NORMAL,
9
    val dueDate: LocalDateTime? = null,
10
    val createdAt: LocalDateTime = LocalDateTime.now(),
11
    val updatedAt: LocalDateTime = LocalDateTime.now()
12
) : Parcelable {
13

14
    val isActive: Boolean
15
        get() = !isCompleted
16

17
    val isOverdue: Boolean
18
        get() = dueDate?.isBefore(LocalDateTime.now()) == true && !isCompleted
19
}
20

21
enum class TaskPriority(val displayName: String) {
22
    LOW("Low"),
23
    NORMAL("Normal"),
24
    HIGH("High"),
25
    URGENT("Urgent")
26
}
27

28
// TaskEntity.kt - Database Entity
29
@Entity(
30
    tableName = "tasks",
31
    indices = [
32
        Index(value = ["completed"], name = "index_tasks_completed"),
33
        Index(value = ["priority"], name = "index_tasks_priority"),
34
        Index(value = ["due_date"], name = "index_tasks_due_date")
35
    ]
36
)
37
data class TaskEntity(
38
    @PrimaryKey val id: String,
39
    @ColumnInfo(name = "title") val title: String,
40
    @ColumnInfo(name = "description") val description: String,
41
    @ColumnInfo(name = "completed") val isCompleted: Boolean,
42
    @ColumnInfo(name = "priority") val priority: TaskPriority,
43
    @ColumnInfo(name = "due_date") val dueDate: LocalDateTime?,
44
    @ColumnInfo(name = "created_at") val createdAt: LocalDateTime,
45
    @ColumnInfo(name = "updated_at") val updatedAt: LocalDateTime
46
)
47

48
// Extension functions for mapping
49
fun TaskEntity.toDomainModel(): Task = Task(
50
    id = id,
51
    title = title,
52
    description = description,
53
    isCompleted = isCompleted,
54
    priority = priority,
55
    dueDate = dueDate,
56
    createdAt = createdAt,
57
    updatedAt = updatedAt
58
)
59

60
fun Task.toEntity(): TaskEntity = TaskEntity(
61
    id = id,
62
    title = title,
63
    description = description,
64
    isCompleted = isCompleted,
65
    priority = priority,
66
    dueDate = dueDate,
67
    createdAt = createdAt,
68
    updatedAt = updatedAt
69
)

Data Access Layer#

1
// TaskDao.kt - Room Data Access Object
2
@Dao
3
interface TaskDao {
4

5
    @Query("SELECT * FROM tasks ORDER BY created_at DESC")
6
    fun getAllTasks(): Flow<List<TaskEntity>>
7

8
    @Query("SELECT * FROM tasks WHERE completed = 0 ORDER BY priority DESC, due_date ASC")
9
    fun getActiveTasks(): Flow<List<TaskEntity>>
10

11
    @Query("SELECT * FROM tasks WHERE completed = 1 ORDER BY updated_at DESC")
12
    fun getCompletedTasks(): Flow<List<TaskEntity>>
13

14
    @Query("SELECT * FROM tasks WHERE id = :taskId")
15
    fun getTaskById(taskId: String): Flow<TaskEntity?>
16

17
    @Query("SELECT * FROM tasks WHERE due_date <= :date AND completed = 0")
18
    suspend fun getOverdueTasks(date: LocalDateTime): List<TaskEntity>
19

20
    @Query("SELECT * FROM tasks WHERE title LIKE '%' || :query || '%' OR description LIKE '%' || :query || '%'")
21
    fun searchTasks(query: String): Flow<List<TaskEntity>>
22

23
    @Insert(onConflict = OnConflictStrategy.REPLACE)
24
    suspend fun insertTask(task: TaskEntity)
25

26
    @Insert(onConflict = OnConflictStrategy.REPLACE)
27
    suspend fun insertTasks(tasks: List<TaskEntity>)
28

29
    @Update
30
    suspend fun updateTask(task: TaskEntity)
31

32
    @Delete
33
    suspend fun deleteTask(task: TaskEntity)
34

35
    @Query("DELETE FROM tasks WHERE id = :taskId")
36
    suspend fun deleteTaskById(taskId: String)
37

38
    @Query("DELETE FROM tasks WHERE completed = 1")
39
    suspend fun deleteCompletedTasks()
40

41
    @Query("UPDATE tasks SET completed = :completed, updated_at = :updatedAt WHERE id = :taskId")
42
    suspend fun updateTaskCompletion(taskId: String, completed: Boolean, updatedAt: LocalDateTime)
43

44
    @Transaction
45
    suspend fun updateTaskWithTimestamp(task: TaskEntity) {
46
        val updatedTask = task.copy(updatedAt = LocalDateTime.now())
47
        updateTask(updatedTask)
48
    }
49
}
50

51
// AppDatabase.kt - Room Database
52
@Database(
53
    entities = [TaskEntity::class],
54
    version = 1,
55
    exportSchema = false
56
)
57
@TypeConverters(DateConverters::class)
58
abstract class AppDatabase : RoomDatabase() {
59
    abstract fun taskDao(): TaskDao
60
}
61

62
// DateConverters.kt - Type Converters
63
class DateConverters {
64
    @TypeConverter
65
    fun fromTimestamp(value: Long?): LocalDateTime? {
66
        return value?.let { LocalDateTime.ofEpochSecond(it, 0, ZoneOffset.UTC) }
67
    }
68

69
    @TypeConverter
70
    fun dateToTimestamp(date: LocalDateTime?): Long? {
71
        return date?.toEpochSecond(ZoneOffset.UTC)
72
    }
73

74
    @TypeConverter
75
    fun fromPriority(priority: TaskPriority): String = priority.name
76

77
    @TypeConverter
78
    fun toPriority(priority: String): TaskPriority = TaskPriority.valueOf(priority)
79
}

Repository Implementation#

1
// TasksRepository.kt - Repository Interface
2
interface TasksRepository {
3
    fun getAllTasks(): Flow<List<Task>>
4
    fun getActiveTasks(): Flow<List<Task>>
5
    fun getCompletedTasks(): Flow<List<Task>>
6
    fun getTaskById(taskId: String): Flow<Task?>
7
    fun searchTasks(query: String): Flow<List<Task>>
8
    suspend fun getOverdueTasks(): List<Task>
9
    suspend fun saveTask(task: Task)
10
    suspend fun updateTask(task: Task)
11
    suspend fun deleteTask(taskId: String)
12
    suspend fun completeTask(taskId: String)
13
    suspend fun deleteCompletedTasks()
14
    suspend fun refreshTasks()
15
}
16

17
// DefaultTasksRepository.kt - Repository Implementation
18
@Singleton
19
class DefaultTasksRepository @Inject constructor(
20
    private val localDataSource: TaskDao,
21
    private val remoteDataSource: TasksRemoteDataSource?,
22
    @IoDispatcher private val dispatcher: CoroutineDispatcher
23
) : TasksRepository {
24

25
    override fun getAllTasks(): Flow<List<Task>> {
26
        return localDataSource.getAllTasks()
27
            .map { entities -> entities.map { it.toDomainModel() } }
28
            .flowOn(dispatcher)
29
    }
30

31
    override fun getActiveTasks(): Flow<List<Task>> {
32
        return localDataSource.getActiveTasks()
33
            .map { entities -> entities.map { it.toDomainModel() } }
34
            .flowOn(dispatcher)
35
    }
36

37
    override fun getCompletedTasks(): Flow<List<Task>> {
38
        return localDataSource.getCompletedTasks()
39
            .map { entities -> entities.map { it.toDomainModel() } }
40
            .flowOn(dispatcher)
41
    }
42

43
    override fun getTaskById(taskId: String): Flow<Task?> {
44
        return localDataSource.getTaskById(taskId)
45
            .map { entity -> entity?.toDomainModel() }
46
            .flowOn(dispatcher)
47
    }
48

49
    override fun searchTasks(query: String): Flow<List<Task>> {
50
        return localDataSource.searchTasks(query)
51
            .map { entities -> entities.map { it.toDomainModel() } }
52
            .flowOn(dispatcher)
53
    }
54

55
    override suspend fun getOverdueTasks(): List<Task> {
56
        return withContext(dispatcher) {
57
            localDataSource.getOverdueTasks(LocalDateTime.now())
58
                .map { it.toDomainModel() }
59
        }
60
    }
61

62
    override suspend fun saveTask(task: Task) {
63
        withContext(dispatcher) {
64
            try {
65
                val entity = task.toEntity()
66
                localDataSource.insertTask(entity)
67

68
                // Sync with remote if available
69
                remoteDataSource?.saveTask(task)
70
            } catch (e: Exception) {
71
                throw TaskRepositoryException("Failed to save task", e)
72
            }
73
        }
74
    }
75

76
    override suspend fun updateTask(task: Task) {
77
        withContext(dispatcher) {
78
            try {
79
                val entity = task.copy(updatedAt = LocalDateTime.now()).toEntity()
80
                localDataSource.updateTask(entity)
81

82
                // Sync with remote if available
83
                remoteDataSource?.updateTask(task)
84
            } catch (e: Exception) {
85
                throw TaskRepositoryException("Failed to update task", e)
86
            }
87
        }
88
    }
89

90
    override suspend fun deleteTask(taskId: String) {
91
        withContext(dispatcher) {
92
            try {
93
                localDataSource.deleteTaskById(taskId)
94
                remoteDataSource?.deleteTask(taskId)
95
            } catch (e: Exception) {
96
                throw TaskRepositoryException("Failed to delete task", e)
97
            }
98
        }
99
    }
100

101
    override suspend fun completeTask(taskId: String) {
102
        withContext(dispatcher) {
103
            try {
104
                localDataSource.updateTaskCompletion(
105
                    taskId = taskId,
106
                    completed = true,
107
                    updatedAt = LocalDateTime.now()
108
                )
109
                remoteDataSource?.completeTask(taskId)
110
            } catch (e: Exception) {
111
                throw TaskRepositoryException("Failed to complete task", e)
112
            }
113
        }
114
    }
115

116
    override suspend fun deleteCompletedTasks() {
117
        withContext(dispatcher) {
118
            try {
119
                localDataSource.deleteCompletedTasks()
120
                remoteDataSource?.deleteCompletedTasks()
121
            } catch (e: Exception) {
122
                throw TaskRepositoryException("Failed to delete completed tasks", e)
123
            }
124
        }
125
    }
126

127
    override suspend fun refreshTasks() {
128
        withContext(dispatcher) {
129
            try {
130
                remoteDataSource?.let { remote ->
131
                    val remoteTasks = remote.getAllTasks()
132
                    val entities = remoteTasks.map { it.toEntity() }
133
                    localDataSource.insertTasks(entities)
134
                }
135
            } catch (e: Exception) {
136
                // Fail silently for refresh - local data still available
137
                Timber.w(e, "Failed to refresh tasks from remote")
138
            }
139
        }
140
    }
141
}
142

143
// Custom Exception
144
class TaskRepositoryException(message: String, cause: Throwable? = null) : Exception(message, cause)

ViewModel Implementation#

UI State Management#

1
// TasksUiState.kt - UI State Classes
2
data class TasksUiState(
3
    val tasks: List<Task> = emptyList(),
4
    val isLoading: Boolean = false,
5
    val isEmpty: Boolean = false,
6
    val errorMessage: String? = null,
7
    val filter: TaskFilter = TaskFilter.ALL,
8
    val searchQuery: String = "",
9
    val selectedTask: Task? = null
10
) {
11
    val filteredTasks: List<Task>
12
        get() = when (filter) {
13
            TaskFilter.ALL -> tasks
14
            TaskFilter.ACTIVE -> tasks.filter { !it.isCompleted }
15
            TaskFilter.COMPLETED -> tasks.filter { it.isCompleted }
16
            TaskFilter.OVERDUE -> tasks.filter { it.isOverdue }
17
            TaskFilter.HIGH_PRIORITY -> tasks.filter { it.priority == TaskPriority.HIGH || it.priority == TaskPriority.URGENT }
18
        }.let { filtered ->
19
            if (searchQuery.isBlank()) filtered
20
            else filtered.filter {
21
                it.title.contains(searchQuery, ignoreCase = true) ||
22
                it.description.contains(searchQuery, ignoreCase = true)
23
            }
24
        }
25
}
26

27
enum class TaskFilter(val displayName: String) {
28
    ALL("All Tasks"),
29
    ACTIVE("Active"),
30
    COMPLETED("Completed"),
31
    OVERDUE("Overdue"),
32
    HIGH_PRIORITY("High Priority")
33
}
34

35
// UI Events
36
sealed class TasksUiEvent {
37
    object LoadTasks : TasksUiEvent()
38
    object RefreshTasks : TasksUiEvent()
39
    data class SearchTasks(val query: String) : TasksUiEvent()
40
    data class FilterTasks(val filter: TaskFilter) : TasksUiEvent()
41
    data class CompleteTask(val taskId: String) : TasksUiEvent()
42
    data class DeleteTask(val taskId: String) : TasksUiEvent()
43
    data class SelectTask(val task: Task) : TasksUiEvent()
44
    object ClearSelection : TasksUiEvent()
45
    object DeleteCompletedTasks : TasksUiEvent()
46
    object DismissError : TasksUiEvent()
47
}

ViewModel Implementation#

1
// TasksViewModel.kt - Feature ViewModel
2
@HiltViewModel
3
class TasksViewModel @Inject constructor(
4
    private val tasksRepository: TasksRepository,
5
    private val analyticsTracker: AnalyticsTracker,
6
    @IoDispatcher private val dispatcher: CoroutineDispatcher
7
) : ViewModel() {
8

9
    private val _uiState = MutableStateFlow(TasksUiState(isLoading = true))
10
    val uiState: StateFlow<TasksUiState> = _uiState.asStateFlow()
11

12
    // For backward compatibility with Views
13
    val tasks: LiveData<List<Task>> = uiState
14
        .map { it.filteredTasks }
15
        .asLiveData()
16

17
    val isLoading: LiveData<Boolean> = uiState
18
        .map { it.isLoading }
19
        .asLiveData()
20

21
    val isEmpty: LiveData<Boolean> = uiState
22
        .map { it.isEmpty }
23
        .asLiveData()
24

25
    init {
26
        loadTasks()
27
        startPeriodicRefresh()
28
    }
29

30
    fun handleEvent(event: TasksUiEvent) {
31
        when (event) {
32
            is TasksUiEvent.LoadTasks -> loadTasks()
33
            is TasksUiEvent.RefreshTasks -> refreshTasks()
34
            is TasksUiEvent.SearchTasks -> searchTasks(event.query)
35
            is TasksUiEvent.FilterTasks -> filterTasks(event.filter)
36
            is TasksUiEvent.CompleteTask -> completeTask(event.taskId)
37
            is TasksUiEvent.DeleteTask -> deleteTask(event.taskId)
38
            is TasksUiEvent.SelectTask -> selectTask(event.task)
39
            is TasksUiEvent.ClearSelection -> clearSelection()
40
            is TasksUiEvent.DeleteCompletedTasks -> deleteCompletedTasks()
41
            is TasksUiEvent.DismissError -> dismissError()
42
        }
43
    }
44

45
    private fun loadTasks() {
46
        viewModelScope.launch {
47
            try {
48
                _uiState.update { it.copy(isLoading = true, errorMessage = null) }
49

50
                tasksRepository.getAllTasks()
51
                    .catch { throwable ->
52
                        _uiState.update {
53
                            it.copy(
54
                                isLoading = false,
55
                                errorMessage = "Failed to load tasks: ${throwable.message}"
56
                            )
57
                        }
58
                        analyticsTracker.trackError("load_tasks_failed", throwable)
59
                    }
60
                    .collect { taskList ->
61
                        _uiState.update {
62
                            it.copy(
63
                                tasks = taskList,
64
                                isLoading = false,
65
                                isEmpty = taskList.isEmpty(),
66
                                errorMessage = null
67
                            )
68
                        }
69
                        analyticsTracker.trackEvent("tasks_loaded", mapOf("count" to taskList.size))
70
                    }
71
            } catch (e: Exception) {
72
                handleError(e)
73
            }
74
        }
75
    }
76

77
    private fun refreshTasks() {
78
        viewModelScope.launch(dispatcher) {
79
            try {
80
                _uiState.update { it.copy(isLoading = true) }
81
                tasksRepository.refreshTasks()
82
                analyticsTracker.trackEvent("tasks_refreshed")
83
            } catch (e: Exception) {
84
                handleError(e)
85
            }
86
        }
87
    }
88

89
    private fun searchTasks(query: String) {
90
        _uiState.update { it.copy(searchQuery = query) }
91
        analyticsTracker.trackEvent("tasks_searched", mapOf("query_length" to query.length))
92
    }
93

94
    private fun filterTasks(filter: TaskFilter) {
95
        _uiState.update { it.copy(filter = filter) }
96
        analyticsTracker.trackEvent("tasks_filtered", mapOf("filter" to filter.name))
97
    }
98

99
    private fun completeTask(taskId: String) {
100
        viewModelScope.launch(dispatcher) {
101
            try {
102
                tasksRepository.completeTask(taskId)
103
                showTemporaryMessage("Task completed")
104
                analyticsTracker.trackEvent("task_completed")
105
            } catch (e: Exception) {
106
                handleError(e)
107
            }
108
        }
109
    }
110

111
    private fun deleteTask(taskId: String) {
112
        viewModelScope.launch(dispatcher) {
113
            try {
114
                tasksRepository.deleteTask(taskId)
115
                showTemporaryMessage("Task deleted")
116
                analyticsTracker.trackEvent("task_deleted")
117
            } catch (e: Exception) {
118
                handleError(e)
119
            }
120
        }
121
    }
122

123
    private fun selectTask(task: Task) {
124
        _uiState.update { it.copy(selectedTask = task) }
125
    }
126

127
    private fun clearSelection() {
128
        _uiState.update { it.copy(selectedTask = null) }
129
    }
130

131
    private fun deleteCompletedTasks() {
132
        viewModelScope.launch(dispatcher) {
133
            try {
134
                tasksRepository.deleteCompletedTasks()
135
                showTemporaryMessage("Completed tasks deleted")
136
                analyticsTracker.trackEvent("completed_tasks_deleted")
137
            } catch (e: Exception) {
138
                handleError(e)
139
            }
140
        }
141
    }
142

143
    private fun dismissError() {
144
        _uiState.update { it.copy(errorMessage = null) }
145
    }
146

147
    private fun handleError(throwable: Throwable) {
148
        val errorMessage = when (throwable) {
149
            is IOException -> "Network error. Please check your connection."
150
            is TaskRepositoryException -> throwable.message ?: "Repository error occurred"
151
            else -> "An unexpected error occurred"
152
        }
153

154
        _uiState.update {
155
            it.copy(
156
                isLoading = false,
157
                errorMessage = errorMessage
158
            )
159
        }
160

161
        analyticsTracker.trackError("tasks_error", throwable)
162
    }
163

164
    private fun showTemporaryMessage(message: String) {
165
        _uiState.update { it.copy(errorMessage = message) }
166

167
        // Clear message after delay
168
        viewModelScope.launch {
169
            delay(3000)
170
            _uiState.update { currentState ->
171
                if (currentState.errorMessage == message) {
172
                    currentState.copy(errorMessage = null)
173
                } else {
174
                    currentState
175
                }
176
            }
177
        }
178
    }
179

180
    private fun startPeriodicRefresh() {
181
        viewModelScope.launch {
182
            while (true) {
183
                delay(TimeUnit.MINUTES.toMillis(5)) // Refresh every 5 minutes
184
                if (uiState.value.tasks.isNotEmpty()) {
185
                    refreshTasks()
186
                }
187
            }
188
        }
189
    }
190

191
    // Convenience methods for View layer
192
    fun refresh() = handleEvent(TasksUiEvent.RefreshTasks)
193
    fun search(query: String) = handleEvent(TasksUiEvent.SearchTasks(query))
194
    fun filter(filter: TaskFilter) = handleEvent(TasksUiEvent.FilterTasks(filter))
195
    fun completeTask(taskId: String) = handleEvent(TasksUiEvent.CompleteTask(taskId))
196
    fun deleteTask(taskId: String) = handleEvent(TasksUiEvent.DeleteTask(taskId))
197
}

Specialized ViewModels#

1
// TaskDetailViewModel.kt - Detail Screen ViewModel
2
@HiltViewModel
3
class TaskDetailViewModel @Inject constructor(
4
    private val tasksRepository: TasksRepository,
5
    private val savedStateHandle: SavedStateHandle
6
) : BaseViewModel() {
7

8
    private val taskId: String = savedStateHandle.get<String>("taskId")
9
        ?: throw IllegalArgumentException("TaskId is required")
10

11
    private val _task = MutableLiveData<Task?>()
12
    val task: LiveData<Task?> = _task
13

14
    private val _isEditing = MutableLiveData(false)
15
    val isEditing: LiveData<Boolean> = _isEditing
16

17
    // Two-way data binding fields
18
    val title = MutableLiveData<String>()
19
    val description = MutableLiveData<String>()
20
    val priority = MutableLiveData<TaskPriority>()
21
    val dueDate = MutableLiveData<LocalDateTime?>()
22

23
    init {
24
        loadTask()
25
        setupFieldObservers()
26
    }
27

28
    private fun loadTask() {
29
        viewModelScope.launch {
30
            try {
31
                setLoading(true)
32
                tasksRepository.getTaskById(taskId)
33
                    .catch { throwable -> handleError(throwable) }
34
                    .collect { task ->
35
                        _task.value = task
36
                        task?.let { populateFields(it) }
37
                        setLoading(false)
38
                    }
39
            } catch (e: Exception) {
40
                handleError(e)
41
                setLoading(false)
42
            }
43
        }
44
    }
45

46
    private fun populateFields(task: Task) {
47
        title.value = task.title
48
        description.value = task.description
49
        priority.value = task.priority
50
        dueDate.value = task.dueDate
51
    }
52

53
    private fun setupFieldObservers() {
54
        // Enable editing mode when fields are modified
55
        val observer = Observer<Any> { _isEditing.value = true }
56

57
        title.observeForever(observer)
58
        description.observeForever(observer)
59
        priority.observeForever(observer)
60
        dueDate.observeForever(observer)
61
    }
62

63
    fun saveTask() {
64
        val currentTask = _task.value ?: return
65
        val updatedTask = currentTask.copy(
66
            title = title.value ?: "",
67
            description = description.value ?: "",
68
            priority = priority.value ?: TaskPriority.NORMAL,
69
            dueDate = dueDate.value,
70
            updatedAt = LocalDateTime.now()
71
        )
72

73
        viewModelScope.launch {
74
            try {
75
                setLoading(true)
76
                tasksRepository.updateTask(updatedTask)
77
                _isEditing.value = false
78
                setLoading(false)
79
            } catch (e: Exception) {
80
                handleError(e)
81
                setLoading(false)
82
            }
83
        }
84
    }
85

86
    fun discardChanges() {
87
        _task.value?.let { populateFields(it) }
88
        _isEditing.value = false
89
    }
90

91
    fun toggleComplete() {
92
        viewModelScope.launch {
93
            try {
94
                tasksRepository.completeTask(taskId)
95
            } catch (e: Exception) {
96
                handleError(e)
97
            }
98
        }
99
    }
100
}
101

102
// AddTaskViewModel.kt - Add Task ViewModel
103
@HiltViewModel
104
class AddTaskViewModel @Inject constructor(
105
    private val tasksRepository: TasksRepository
106
) : BaseViewModel() {
107

108
    // Two-way data binding fields
109
    val title = MutableLiveData<String>()
110
    val description = MutableLiveData<String>()
111
    val priority = MutableLiveData(TaskPriority.NORMAL)
112
    val dueDate = MutableLiveData<LocalDateTime?>()
113

114
    // Validation
115
    private val _titleError = MutableLiveData<String?>()
116
    val titleError: LiveData<String?> = _titleError
117

118
    private val _isSaveEnabled = MediatorLiveData<Boolean>().apply {
119
        addSource(title) { updateSaveEnabled() }
120
        addSource(description) { updateSaveEnabled() }
121
    }
122
    val isSaveEnabled: LiveData<Boolean> = _isSaveEnabled
123

124
    private fun updateSaveEnabled() {
125
        val titleValid = !title.value.isNullOrBlank()
126
        val descriptionValid = !description.value.isNullOrBlank()
127
        _isSaveEnabled.value = titleValid && descriptionValid
128
    }
129

130
    fun saveTask(): LiveData<Boolean> {
131
        val result = MutableLiveData<Boolean>()
132

133
        if (!validateInput()) {
134
            result.value = false
135
            return result
136
        }
137

138
        val task = Task(
139
            title = title.value!!,
140
            description = description.value!!,
141
            priority = priority.value ?: TaskPriority.NORMAL,
142
            dueDate = dueDate.value
143
        )
144

145
        viewModelScope.launch {
146
            try {
147
                setLoading(true)
148
                tasksRepository.saveTask(task)
149
                setLoading(false)
150
                result.postValue(true)
151
            } catch (e: Exception) {
152
                handleError(e)
153
                setLoading(false)
154
                result.postValue(false)
155
            }
156
        }
157

158
        return result
159
    }
160

161
    private fun validateInput(): Boolean {
162
        var isValid = true
163

164
        if (title.value.isNullOrBlank()) {
165
            _titleError.value = "Title is required"
166
            isValid = false
167
        } else {
168
            _titleError.value = null
169
        }
170

171
        return isValid
172
    }
173

174
    fun clearForm() {
175
        title.value = ""
176
        description.value = ""
177
        priority.value = TaskPriority.NORMAL
178
        dueDate.value = null
179
        _titleError.value = null
180
    }
181
}

View Layer Implementation#

Fragment with Data Binding#

1
// TasksFragment.kt - Main Tasks Screen
2
@AndroidEntryPoint
3
class TasksFragment : BaseFragment<FragmentTasksBinding, TasksViewModel>() {
4

5
    override val viewModel: TasksViewModel by viewModels()
6
    private lateinit var tasksAdapter: TasksAdapter
7

8
    override fun getLayoutId(): Int = R.layout.fragment_tasks
9

10
    override fun initializeViews() {
11
        setupRecyclerView()
12
        setupSwipeRefresh()
13
        setupFab()
14
        setupSearchView()
15
        setupFilterChips()
16
    }
17

18
    override fun observeViewModel() {
19
        // Observe UI state with StateFlow
20
        viewLifecycleOwner.lifecycleScope.launch {
21
            viewModel.uiState.collect { uiState ->
22
                updateUI(uiState)
23
            }
24
        }
25

26
        // Observe tasks with LiveData (for compatibility)
27
        viewModel.tasks.observe(viewLifecycleOwner) { tasks ->
28
            tasksAdapter.submitList(tasks)
29
            updateEmptyState(tasks.isEmpty())
30
        }
31

32
        viewModel.isLoading.observe(viewLifecycleOwner) { isLoading ->
33
            binding.swipeRefresh.isRefreshing = isLoading
34
        }
35
    }
36

37
    private fun setupRecyclerView() {
38
        tasksAdapter = TasksAdapter(
39
            onTaskClick = { task ->
40
                findNavController().navigate(
41
                    TasksFragmentDirections.actionTasksToTaskDetail(task.id)
42
                )
43
            },
44
            onTaskComplete = { task ->
45
                viewModel.completeTask(task.id)
46
            },
47
            onTaskDelete = { task ->
48
                showDeleteConfirmation(task)
49
            }
50
        )
51

52
        binding.recyclerViewTasks.apply {
53
            adapter = tasksAdapter
54
            layoutManager = LinearLayoutManager(context)
55

56
            // Add item decoration
57
            addItemDecoration(DividerItemDecoration(context, DividerItemDecoration.VERTICAL))
58

59
            // Setup item animations
60
            itemAnimator = DefaultItemAnimator().apply {
61
                addDuration = 300
62
                removeDuration = 300
63
            }
64
        }
65
    }
66

67
    private fun setupSwipeRefresh() {
68
        binding.swipeRefresh.setOnRefreshListener {
69
            viewModel.refresh()
70
        }
71
    }
72

73
    private fun setupFab() {
74
        binding.fabAddTask.setOnClickListener {
75
            findNavController().navigate(
76
                TasksFragmentDirections.actionTasksToAddTask()
77
            )
78
        }
79
    }
80

81
    private fun setupSearchView() {
82
        binding.searchView.setOnQueryTextListener(object : SearchView.OnQueryTextListener {
83
            override fun onQueryTextSubmit(query: String?): Boolean {
84
                query?.let { viewModel.search(it) }
85
                return true
86
            }
87

88
            override fun onQueryTextChange(newText: String?): Boolean {
89
                newText?.let { viewModel.search(it) }
90
                return true
91
            }
92
        })
93
    }
94

95
    private fun setupFilterChips() {
96
        binding.chipGroupFilters.setOnCheckedStateChangeListener { _, checkedIds ->
97
            val filter = when (checkedIds.firstOrNull()) {
98
                R.id.chip_all -> TaskFilter.ALL
99
                R.id.chip_active -> TaskFilter.ACTIVE
100
                R.id.chip_completed -> TaskFilter.COMPLETED
101
                R.id.chip_overdue -> TaskFilter.OVERDUE
102
                R.id.chip_high_priority -> TaskFilter.HIGH_PRIORITY
103
                else -> TaskFilter.ALL
104
            }
105
            viewModel.filter(filter)
106
        }
107
    }
108

109
    private fun updateUI(uiState: TasksUiState) {
110
        binding.apply {
111
            // Update loading state
112
            swipeRefresh.isRefreshing = uiState.isLoading
113

114
            // Update empty state
115
            updateEmptyState(uiState.isEmpty)
116

117
            // Update search query
118
            if (searchView.query.toString() != uiState.searchQuery) {
119
                searchView.setQuery(uiState.searchQuery, false)
120
            }
121

122
            // Update filter chips
123
            updateFilterChips(uiState.filter)
124

125
            // Handle errors
126
            uiState.errorMessage?.let { error ->
127
                showError(error)
128
                viewModel.handleEvent(TasksUiEvent.DismissError)
129
            }
130
        }
131
    }
132

133
    private fun updateEmptyState(isEmpty: Boolean) {
134
        binding.groupEmptyState.isVisible = isEmpty
135
        binding.recyclerViewTasks.isVisible = !isEmpty
136
    }
137

138
    private fun updateFilterChips(filter: TaskFilter) {
139
        val chipId = when (filter) {
140
            TaskFilter.ALL -> R.id.chip_all
141
            TaskFilter.ACTIVE -> R.id.chip_active
142
            TaskFilter.COMPLETED -> R.id.chip_completed
143
            TaskFilter.OVERDUE -> R.id.chip_overdue
144
            TaskFilter.HIGH_PRIORITY -> R.id.chip_high_priority
145
        }
146
        binding.chipGroupFilters.check(chipId)
147
    }
148

149
    private fun showDeleteConfirmation(task: Task) {
150
        AlertDialog.Builder(requireContext())
151
            .setTitle("Delete Task")
152
            .setMessage("Are you sure you want to delete '${task.title}'?")
153
            .setPositiveButton("Delete") { _, _ ->
154
                viewModel.deleteTask(task.id)
155
            }
156
            .setNegativeButton("Cancel", null)
157
            .show()
158
    }
159

160
    override fun onCreateOptionsMenu(menu: Menu, inflater: MenuInflater) {
161
        inflater.inflate(R.menu.menu_tasks, menu)
162
        super.onCreateOptionsMenu(menu, inflater)
163
    }
164

165
    override fun onOptionsItemSelected(item: MenuItem): Boolean {
166
        return when (item.itemId) {
167
            R.id.action_delete_completed -> {
168
                viewModel.handleEvent(TasksUiEvent.DeleteCompletedTasks)
169
                true
170
            }
171
            R.id.action_refresh -> {
172
                viewModel.refresh()
173
                true
174
            }
175
            else -> super.onOptionsItemSelected(item)
176
        }
177
    }
178
}

RecyclerView Adapter#

1
// TasksAdapter.kt - RecyclerView Adapter with Data Binding
2
class TasksAdapter(
3
    private val onTaskClick: (Task) -> Unit,
4
    private val onTaskComplete: (Task) -> Unit,
5
    private val onTaskDelete: (Task) -> Unit
6
) : ListAdapter<Task, TasksAdapter.TaskViewHolder>(TaskDiffCallback()) {
7

8
    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): TaskViewHolder {
9
        val binding = ItemTaskBinding.inflate(
10
            LayoutInflater.from(parent.context),
11
            parent,
12
            false
13
        )
14
        return TaskViewHolder(binding)
15
    }
16

17
    override fun onBindViewHolder(holder: TaskViewHolder, position: Int) {
18
        holder.bind(getItem(position))
19
    }
20

21
    inner class TaskViewHolder(
22
        private val binding: ItemTaskBinding
23
    ) : RecyclerView.ViewHolder(binding.root) {
24

25
        fun bind(task: Task) {
26
            binding.apply {
27
                // Set data binding variables
28
                this.task = task
29

30
                // Set click listeners
31
                root.setOnClickListener { onTaskClick(task) }
32

33
                checkboxCompleted.setOnCheckedChangeListener { _, isChecked ->
34
                    if (isChecked != task.isCompleted) {
35
                        onTaskComplete(task)
36
                    }
37
                }
38

39
                buttonDelete.setOnClickListener { onTaskDelete(task) }
40

41
                // Custom binding logic
42
                updatePriorityIndicator(task.priority)
43
                updateDueDateStatus(task.dueDate, task.isCompleted)
44

45
                // Execute pending bindings
46
                executePendingBindings()
47
            }
48
        }
49

50
        private fun updatePriorityIndicator(priority: TaskPriority) {
51
            val color = when (priority) {
52
                TaskPriority.LOW -> R.color.priority_low
53
                TaskPriority.NORMAL -> R.color.priority_normal
54
                TaskPriority.HIGH -> R.color.priority_high
55
                TaskPriority.URGENT -> R.color.priority_urgent
56
            }
57

58
            binding.viewPriorityIndicator.setBackgroundColor(
59
                ContextCompat.getColor(binding.root.context, color)
60
            )
61
        }
62

63
        private fun updateDueDateStatus(dueDate: LocalDateTime?, isCompleted: Boolean) {
64
            binding.textDueDate.apply {
65
                when {
66
                    dueDate == null -> {
67
                        isVisible = false
68
                    }
69
                    isCompleted -> {
70
                        isVisible = true
71
                        text = "Completed"
72
                        setTextColor(ContextCompat.getColor(context, R.color.text_success))
73
                    }
74
                    dueDate.isBefore(LocalDateTime.now()) -> {
75
                        isVisible = true
76
                        text = "Overdue"
77
                        setTextColor(ContextCompat.getColor(context, R.color.text_error))
78
                    }
79
                    else -> {
80
                        isVisible = true
81
                        text = formatDueDate(dueDate)
82
                        setTextColor(ContextCompat.getColor(context, R.color.text_secondary))
83
                    }
84
                }
85
            }
86
        }
87

88
        private fun formatDueDate(dueDate: LocalDateTime): String {
89
            val now = LocalDateTime.now()
90
            return when {
91
                dueDate.toLocalDate() == now.toLocalDate() -> "Today"
92
                dueDate.toLocalDate() == now.toLocalDate().plusDays(1) -> "Tomorrow"
93
                dueDate.isBefore(now.plusDays(7)) -> dueDate.format(DateTimeFormatter.ofPattern("EEE"))
94
                else -> dueDate.format(DateTimeFormatter.ofPattern("MMM dd"))
95
            }
96
        }
97
    }
98

99
    class TaskDiffCallback : DiffUtil.ItemCallback<Task>() {
100
        override fun areItemsTheSame(oldItem: Task, newItem: Task): Boolean {
101
            return oldItem.id == newItem.id
102
        }
103

104
        override fun areContentsTheSame(oldItem: Task, newItem: Task): Boolean {
105
            return oldItem == newItem
106
        }
107
    }
108
}

Data Binding Layouts#

1
<layout xmlns:android="http://schemas.android.com/apk/res/android"
2
    xmlns:app="http://schemas.android.com/apk/res-auto"
3
    xmlns:tools="http://schemas.android.com/tools">
4

5
    <data>
6
        <variable
7
            name="viewModel"
8
            type="com.example.tasks.ui.tasks.TasksViewModel" />
9
    </data>
10

11
    <androidx.coordinatorlayout.widget.CoordinatorLayout
12
        android:layout_width="match_parent"
13
        android:layout_height="match_parent">
14

15
        <com.google.android.material.appbar.AppBarLayout
16
            android:layout_width="match_parent"
17
            android:layout_height="wrap_content">
18

19
            <com.google.android.material.appbar.MaterialToolbar
20
                android:id="@+id/toolbar"
21
                android:layout_width="match_parent"
22
                android:layout_height="?attr/actionBarSize"
23
                app:title="Tasks" />
24

25
            <androidx.appcompat.widget.SearchView
26
                android:id="@+id/search_view"
27
                android:layout_width="match_parent"
28
                android:layout_height="wrap_content"
29
                android:layout_margin="8dp"
30
                app:queryHint="Search tasks..." />
31

32
            <com.google.android.material.chip.ChipGroup
33
                android:id="@+id/chip_group_filters"
34
                android:layout_width="match_parent"
35
                android:layout_height="wrap_content"
36
                android:layout_marginHorizontal="8dp"
37
                app:selectionRequired="true"
38
                app:singleSelection="true">
39

40
                <com.google.android.material.chip.Chip
41
                    android:id="@+id/chip_all"
42
                    style="@style/Widget.Material3.Chip.Filter"
43
                    android:layout_width="wrap_content"
44
                    android:layout_height="wrap_content"
45
                    android:checked="true"
46
                    android:text="All" />
47

48
                <com.google.android.material.chip.Chip
49
                    android:id="@+id/chip_active"
50
                    style="@style/Widget.Material3.Chip.Filter"
51
                    android:layout_width="wrap_content"
52
                    android:layout_height="wrap_content"
53
                    android:text="Active" />
54

55
                <com.google.android.material.chip.Chip
56
                    android:id="@+id/chip_completed"
57
                    style="@style/Widget.Material3.Chip.Filter"
58
                    android:layout_width="wrap_content"
59
                    android:layout_height="wrap_content"
60
                    android:text="Completed" />
61

62
                <com.google.android.material.chip.Chip
63
                    android:id="@+id/chip_overdue"
64
                    style="@style/Widget.Material3.Chip.Filter"
65
                    android:layout_width="wrap_content"
66
                    android:layout_height="wrap_content"
67
                    android:text="Overdue" />
68

69
                <com.google.android.material.chip.Chip
70
                    android:id="@+id/chip_high_priority"
71
                    style="@style/Widget.Material3.Chip.Filter"
72
                    android:layout_width="wrap_content"
73
                    android:layout_height="wrap_content"
74
                    android:text="High Priority" />
75

76
            </com.google.android.material.chip.ChipGroup>
77

78
        </com.google.android.material.appbar.AppBarLayout>
79

80
        <androidx.swiperefreshlayout.widget.SwipeRefreshLayout
81
            android:id="@+id/swipe_refresh"
82
            android:layout_width="match_parent"
83
            android:layout_height="match_parent"
84
            app:layout_behavior="@string/appbar_scrolling_view_behavior">
85

86
            <androidx.recyclerview.widget.RecyclerView
87
                android:id="@+id/recycler_view_tasks"
88
                android:layout_width="match_parent"
89
                android:layout_height="match_parent"
90
                android:clipToPadding="false"
91
                android:paddingBottom="88dp"
92
                tools:listitem="@layout/item_task" />
93

94
        </androidx.swiperefreshlayout.widget.SwipeRefreshLayout>
95

96
        <!-- Empty State -->
97
        <androidx.constraintlayout.widget.Group
98
            android:id="@+id/group_empty_state"
99
            android:layout_width="wrap_content"
100
            android:layout_height="wrap_content"
101
            android:visibility="gone"
102
            app:constraint_referenced_ids="image_empty,text_empty_title,text_empty_subtitle"
103
            tools:visibility="visible" />
104

105
        <ImageView
106
            android:id="@+id/image_empty"
107
            android:layout_width="120dp"
108
            android:layout_height="120dp"
109
            android:layout_gravity="center"
110
            android:layout_marginBottom="32dp"
111
            android:alpha="0.6"
112
            android:src="@drawable/ic_tasks_empty"
113
            app:tint="?attr/colorOnSurfaceVariant" />
114

115
        <TextView
116
            android:id="@+id/text_empty_title"
117
            android:layout_width="wrap_content"
118
            android:layout_height="wrap_content"
119
            android:layout_gravity="center"
120
            android:text="No tasks yet"
121
            android:textAppearance="?attr/textAppearanceHeadlineMedium" />
122

123
        <TextView
124
            android:id="@+id/text_empty_subtitle"
125
            android:layout_width="wrap_content"
126
            android:layout_height="wrap_content"
127
            android:layout_gravity="center"
128
            android:layout_marginTop="8dp"
129
            android:text="Tap the + button to add your first task"
130
            android:textAppearance="?attr/textAppearanceBodyMedium"
131
            android:textColor="?attr/colorOnSurfaceVariant" />
132

133
        <com.google.android.material.floatingactionbutton.FloatingActionButton
134
            android:id="@+id/fab_add_task"
135
            android:layout_width="wrap_content"
136
            android:layout_height="wrap_content"
137
            android:layout_gravity="bottom|end"
138
            android:layout_margin="16dp"
139
            android:contentDescription="Add task"
140
            app:srcCompat="@drawable/ic_add" />
141

142
    </androidx.coordinatorlayout.widget.CoordinatorLayout>
143

144
</layout>

1
<layout xmlns:android="http://schemas.android.com/apk/res/android"
2
    xmlns:app="http://schemas.android.com/apk/res-auto"
3
    xmlns:tools="http://schemas.android.com/tools">
4

5
    <data>
6
        <variable
7
            name="task"
8
            type="com.example.tasks.data.model.Task" />
9
    </data>
10

11
    <com.google.android.material.card.MaterialCardView
12
        android:layout_width="match_parent"
13
        android:layout_height="wrap_content"
14
        android:layout_margin="8dp"
15
        app:cardCornerRadius="8dp"
16
        app:cardElevation="2dp"
17
        app:strokeWidth="0dp">
18

19
        <androidx.constraintlayout.widget.ConstraintLayout
20
            android:layout_width="match_parent"
21
            android:layout_height="wrap_content"
22
            android:padding="16dp">
23

24
            <View
25
                android:id="@+id/view_priority_indicator"
26
                android:layout_width="4dp"
27
                android:layout_height="0dp"
28
                android:layout_marginEnd="12dp"
29
                android:background="@color/priority_normal"
30
                app:layout_constraintBottom_toBottomOf="parent"
31
                app:layout_constraintStart_toStartOf="parent"
32
                app:layout_constraintTop_toTopOf="parent" />
33

34
            <CheckBox
35
                android:id="@+id/checkbox_completed"
36
                android:layout_width="wrap_content"
37
                android:layout_height="wrap_content"
38
                android:checked="@{task.completed}"
39
                app:layout_constraintStart_toEndOf="@id/view_priority_indicator"
40
                app:layout_constraintTop_toTopOf="parent" />
41

42
            <TextView
43
                android:id="@+id/text_title"
44
                android:layout_width="0dp"
45
                android:layout_height="wrap_content"
46
                android:layout_marginStart="8dp"
47
                android:layout_marginEnd="8dp"
48
                android:text="@{task.title}"
49
                android:textAppearance="?attr/textAppearanceBodyLarge"
50
                android:textStyle="@{task.completed ? `italic` : `normal`}"
51
                app:layout_constraintEnd_toStartOf="@id/button_delete"
52
                app:layout_constraintStart_toEndOf="@id/checkbox_completed"
53
                app:layout_constraintTop_toTopOf="@id/checkbox_completed"
54
                app:strikeThrough="@{task.completed}"
55
                tools:text="Sample Task Title" />
56

57
            <TextView
58
                android:id="@+id/text_description"
59
                android:layout_width="0dp"
60
                android:layout_height="wrap_content"
61
                android:layout_marginStart="8dp"
62
                android:layout_marginTop="4dp"
63
                android:layout_marginEnd="8dp"
64
                android:text="@{task.description}"
65
                android:textAppearance="?attr/textAppearanceBodyMedium"
66
                android:textColor="?attr/colorOnSurfaceVariant"
67
                android:visibility="@{task.description.empty ? View.GONE : View.VISIBLE}"
68
                app:layout_constraintEnd_toStartOf="@id/button_delete"
69
                app:layout_constraintStart_toEndOf="@id/checkbox_completed"
70
                app:layout_constraintTop_toBottomOf="@id/text_title"
71
                tools:text="Sample task description" />
72

73
            <TextView
74
                android:id="@+id/text_due_date"
75
                android:layout_width="wrap_content"
76
                android:layout_height="wrap_content"
77
                android:layout_marginStart="8dp"
78
                android:layout_marginTop="4dp"
79
                android:textAppearance="?attr/textAppearanceBodySmall"
80
                android:visibility="gone"
81
                app:layout_constraintStart_toEndOf="@id/checkbox_completed"
82
                app:layout_constraintTop_toBottomOf="@id/text_description"
83
                tools:text="Due Today"
84
                tools:visibility="visible" />
85

86
            <ImageButton
87
                android:id="@+id/button_delete"
88
                android:layout_width="wrap_content"
89
                android:layout_height="wrap_content"
90
                android:background="?attr/selectableItemBackgroundBorderless"
91
                android:contentDescription="Delete task"
92
                android:padding="8dp"
93
                android:src="@drawable/ic_delete"
94
                app:layout_constraintEnd_toEndOf="parent"
95
                app:layout_constraintTop_toTopOf="parent"
96
                app:tint="?attr/colorError" />
97

98
        </androidx.constraintlayout.widget.ConstraintLayout>
99

100
    </com.google.android.material.card.MaterialCardView>
101

102
</layout>

Testing MVVM Implementation#

ViewModel Testing#

1
// TasksViewModelTest.kt - Comprehensive ViewModel Tests
2
@ExperimentalCoroutinesApi
3
class TasksViewModelTest {
4

5
    @get:Rule
6
    var mainCoroutineRule = MainCoroutineRule()
7

8
    @get:Rule
9
    var instantExecutorRule = InstantTaskExecutorRule()
10

11
    // Test doubles
12
    private lateinit var tasksRepository: FakeTasksRepository
13
    private lateinit var analyticsTracker: FakeAnalyticsTracker
14

15
    // Subject under test
16
    private lateinit var viewModel: TasksViewModel
17

18
    @Before
19
    fun setupViewModel() {
20
        tasksRepository = FakeTasksRepository()
21
        analyticsTracker = FakeAnalyticsTracker()
22

23
        viewModel = TasksViewModel(
24
            tasksRepository = tasksRepository,
25
            analyticsTracker = analyticsTracker,
26
            dispatcher = mainCoroutineRule.dispatcher
27
        )
28
    }
29

30
    @Test
31
    fun `loadTasks - success - updates ui state correctly`() = runTest {
32
        // Given
33
        val tasks = listOf(
34
            Task("1", "Task 1", "Description 1"),
35
            Task("2", "Task 2", "Description 2", isCompleted = true)
36
        )
37
        tasksRepository.addTasks(tasks)
38

39
        // When
40
        viewModel.handleEvent(TasksUiEvent.LoadTasks)
41

42
        // Then
43
        val uiState = viewModel.uiState.value
44
        assertEquals(tasks, uiState.tasks)
45
        assertFalse(uiState.isLoading)
46
        assertNull(uiState.errorMessage)
47
        assertFalse(uiState.isEmpty)
48
    }
49

50
    @Test
51
    fun `loadTasks - error - shows error message`() = runTest {
52
        // Given
53
        tasksRepository.setShouldReturnError(true)
54

55
        // When
56
        viewModel.handleEvent(TasksUiEvent.LoadTasks)
57

58
        // Then
59
        val uiState = viewModel.uiState.value
60
        assertTrue(uiState.tasks.isEmpty())
61
        assertFalse(uiState.isLoading)
62
        assertNotNull(uiState.errorMessage)
63
        assertTrue(uiState.isEmpty)
64
    }
65

66
    @Test
67
    fun `filterTasks - active - shows only active tasks`() = runTest {
68
        // Given
69
        val tasks = listOf(
70
            Task("1", "Active Task", "Description", isCompleted = false),
71
            Task("2", "Completed Task", "Description", isCompleted = true)
72
        )
73
        tasksRepository.addTasks(tasks)
74
        viewModel.handleEvent(TasksUiEvent.LoadTasks)
75

76
        // When
77
        viewModel.handleEvent(TasksUiEvent.FilterTasks(TaskFilter.ACTIVE))
78

79
        // Then
80
        val uiState = viewModel.uiState.value
81
        assertEquals(TaskFilter.ACTIVE, uiState.filter)
82
        assertEquals(1, uiState.filteredTasks.size)
83
        assertFalse(uiState.filteredTasks[0].isCompleted)
84
    }
85

86
    @Test
87
    fun `searchTasks - updates search query and filters results`() = runTest {
88
        // Given
89
        val tasks = listOf(
90
            Task("1", "Important Task", "Urgent description"),
91
            Task("2", "Regular Task", "Normal description")
92
        )
93
        tasksRepository.addTasks(tasks)
94
        viewModel.handleEvent(TasksUiEvent.LoadTasks)
95

96
        // When
97
        viewModel.handleEvent(TasksUiEvent.SearchTasks("Important"))
98

99
        // Then
100
        val uiState = viewModel.uiState.value
101
        assertEquals("Important", uiState.searchQuery)
102
        assertEquals(1, uiState.filteredTasks.size)
103
        assertTrue(uiState.filteredTasks[0].title.contains("Important"))
104
    }
105

106
    @Test
107
    fun `completeTask - success - tracks analytics event`() = runTest {
108
        // Given
109
        val task = Task("1", "Task", "Description")
110
        tasksRepository.addTasks(listOf(task))
111

112
        // When
113
        viewModel.handleEvent(TasksUiEvent.CompleteTask(task.id))
114

115
        // Then
116
        verify(analyticsTracker).trackEvent("task_completed")
117
        assertTrue(tasksRepository.isTaskCompleted(task.id))
118
    }
119
}
120

121
// FakeTasksRepository.kt - Test Double
122
class FakeTasksRepository : TasksRepository {
123
    private val tasksData = mutableMapOf<String, Task>()
124
    private var shouldReturnError = false
125

126
    fun addTasks(tasks: List<Task>) {
127
        tasks.forEach { tasksData[it.id] = it }
128
    }
129

130
    fun setShouldReturnError(value: Boolean) {
131
        shouldReturnError = value
132
    }
133

134
    fun isTaskCompleted(taskId: String): Boolean {
135
        return tasksData[taskId]?.isCompleted ?: false
136
    }
137

138
    override fun getAllTasks(): Flow<List<Task>> = flow {
139
        if (shouldReturnError) {
140
            throw IOException("Network error")
141
        }
142
        emit(tasksData.values.toList())
143
    }
144

145
    override suspend fun completeTask(taskId: String) {
146
        if (shouldReturnError) {
147
            throw IOException("Network error")
148
        }
149
        tasksData[taskId] = tasksData[taskId]?.copy(isCompleted = true)
150
            ?: throw TaskRepositoryException("Task not found")
151
    }
152

153
    // Implement other methods...
154
}

Integration Testing#

1
// TasksRepositoryTest.kt - Integration Tests
2
@ExperimentalCoroutinesApi
3
@RunWith(AndroidJUnit4::class)
4
class TasksRepositoryTest {
5

6
    @get:Rule
7
    var mainCoroutineRule = MainCoroutineRule()
8

9
    private lateinit var database: AppDatabase
10
    private lateinit var taskDao: TaskDao
11
    private lateinit var repository: DefaultTasksRepository
12
    private lateinit var remoteDataSource: FakeTasksRemoteDataSource
13

14
    @Before
15
    fun createDb() {
16
        val context = ApplicationProvider.getApplicationContext<Context>()
17
        database = Room.inMemoryDatabaseBuilder(context, AppDatabase::class.java)
18
            .allowMainThreadQueries()
19
            .build()
20
        taskDao = database.taskDao()
21
        remoteDataSource = FakeTasksRemoteDataSource()
22

23
        repository = DefaultTasksRepository(
24
            localDataSource = taskDao,
25
            remoteDataSource = remoteDataSource,
26
            dispatcher = mainCoroutineRule.dispatcher
27
        )
28
    }
29

30
    @After
31
    fun closeDb() {
32
        database.close()
33
    }
34

35
    @Test
36
    fun saveTask_savesToLocalAndRemote() = runTest {
37
        // Given
38
        val task = Task("1", "Test Task", "Description")
39

40
        // When
41
        repository.saveTask(task)
42

43
        // Then
44
        val localTasks = repository.getAllTasks().first()
45
        val remoteTasks = remoteDataSource.getAllTasks()
46

47
        assertTrue(localTasks.contains(task))
48
        assertTrue(remoteTasks.contains(task))
49
    }
50

51
    @Test
52
    fun getAllTasks_returnsLocalTasksWhenRemoteUnavailable() = runTest {
53
        // Given
54
        val localTask = Task("1", "Local Task", "Description")
55
        taskDao.insertTask(localTask.toEntity())
56
        remoteDataSource.setReturnError(true)
57

58
        // When
59
        val tasks = repository.getAllTasks().first()
60

61
        // Then
62
        assertEquals(1, tasks.size)
63
        assertEquals(localTask, tasks[0])
64
    }
65
}

Migration Strategies#

From MVP to MVVM#

1
// Before: MVP Pattern
2
interface TasksContract {
3
    interface View {
4
        fun showTasks(tasks: List<Task>)
5
        fun showLoadingIndicator(show: Boolean)
6
        fun showError(message: String)
7
    }
8

9
    interface Presenter {
10
        fun loadTasks()
11
        fun addTask(task: Task)
12
        fun completeTask(taskId: String)
13
    }
14
}
15

16
class TasksPresenter(
17
    private val view: TasksContract.View,
18
    private val repository: TasksRepository
19
) : TasksContract.Presenter {
20

21
    fun loadTasks() {
22
        view.showLoadingIndicator(true)
23
        // Manual lifecycle management and error handling
24
        repository.getAllTasks { result ->
25
            view.showLoadingIndicator(false)
26
            when (result) {
27
                is Success -> view.showTasks(result.data)
28
                is Error -> view.showError(result.message)
29
            }
30
        }
31
    }
32
}
33

34
// After: MVVM Pattern
35
@HiltViewModel
36
class TasksViewModel @Inject constructor(
37
    private val repository: TasksRepository
38
) : ViewModel() {
39

40
    private val _uiState = MutableStateFlow(TasksUiState())
41
    val uiState: StateFlow<TasksUiState> = _uiState
42

43
    fun loadTasks() {
44
        viewModelScope.launch {
45
            _uiState.update { it.copy(isLoading = true) }
46

47
            repository.getAllTasks()
48
                .catch { throwable ->
49
                    _uiState.update {
50
                        it.copy(isLoading = false, errorMessage = throwable.message)
51
                    }
52
                }
53
                .collect { tasks ->
54
                    _uiState.update {
55
                        it.copy(tasks = tasks, isLoading = false)
56
                    }
57
                }
58
        }
59
    }
60
}

From Views to Compose#

1
// Migration from View-based to Compose MVVM
2
@Composable
3
fun TasksScreen(
4
    viewModel: TasksViewModel = hiltViewModel()
5
) {
6
    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
7

8
    LaunchedEffect(Unit) {
9
        viewModel.handleEvent(TasksUiEvent.LoadTasks)
10
    }
11

12
    TasksContent(
13
        uiState = uiState,
14
        onEvent = viewModel::handleEvent
15
    )
16
}
17

18
@Composable
19
private fun TasksContent(
20
    uiState: TasksUiState,
21
    onEvent: (TasksUiEvent) -> Unit
22
) {
23
    Column {
24
        TasksSearchBar(
25
            query = uiState.searchQuery,
26
            onQueryChange = { onEvent(TasksUiEvent.SearchTasks(it)) }
27
        )
28

29
        TasksFilterChips(
30
            selectedFilter = uiState.filter,
31
            onFilterSelected = { onEvent(TasksUiEvent.FilterTasks(it)) }
32
        )
33

34
        LazyColumn {
35
            items(uiState.filteredTasks) { task ->
36
                TaskItem(
37
                    task = task,
38
                    onComplete = { onEvent(TasksUiEvent.CompleteTask(task.id)) },
39
                    onDelete = { onEvent(TasksUiEvent.DeleteTask(task.id)) }
40
                )
41
            }
42
        }
43
    }
44
}

Best Practices Summary#

MVVM Implementation Guidelines#

Single Responsibility: Each ViewModel should handle one feature
Reactive Programming: Use StateFlow/LiveData for reactive UI
Lifecycle Awareness: Leverage ViewModelScope for coroutines
Error Handling: Centralized error handling in base classes
Testing: Comprehensive unit tests for ViewModels
State Management: Immutable UI state with clear state updates

Performance Optimization#

StateFlow vs LiveData: Use StateFlow for better performance
Background Threading: Use appropriate dispatchers
Memory Management: Proper cleanup in ViewModels
Data Binding: Efficient UI updates with data binding
Caching: Implement proper caching strategies

Code Organization#

1
app/
2
├── data/
3
│   ├── local/
4
│   ├── remote/
5
│   └── repository/
6
├── domain/
7
│   ├── model/
8
│   └── usecase/
9
├── ui/
10
│   ├── base/
11
│   ├── tasks/
12
│   └── addtask/
13
└── di/

Conclusion#

MVVM architecture provides a robust foundation for Android applications, offering clear separation of concerns, excellent testability, and strong lifecycle management. By following the patterns demonstrated in Google’s Architecture Samples and implementing comprehensive testing strategies, developers can build maintainable, scalable Android applications that stand the test of time.

Key takeaways:

Clear Architecture: Proper separation between View, ViewModel, and Model
Modern Tools: Leverage StateFlow, Coroutines, and Data Binding
Testing Excellence: Comprehensive unit and integration tests
Performance: Efficient state management and lifecycle awareness
Scalability: Patterns that support application growth and team collaboration