Android Architecture Samples: Complete Guide to Modern App Development#

Introduction#

Google’s Android Architecture Samples repository stands as the definitive reference for building robust, testable, and maintainable Android applications. This comprehensive guide explores the architectural patterns, modern technologies, and best practices demonstrated in this essential resource for Android developers.

Repository Overview#

The Android Architecture Samples focuses on a deceptively simple TODO application that showcases sophisticated architectural decisions. The principle: “Simple enough to understand quickly, but complex enough to showcase important design decisions and testing strategies.”

Key Objectives#

Educational Resource: Demonstrate modern Android development patterns
Best Practices: Showcase architectural design decisions
Testing Excellence: Comprehensive testing strategies
Real-World Application: Practical implementation examples

Architecture Foundation#

MVVM Pattern Implementation#

The repository implements a clean MVVM (Model-View-ViewModel) architecture with clear separation of concerns:

1
graph TB
2
    subgraph "UI Layer"
3
        UI[Jetpack Compose UI]
4
        VM[ViewModel]
5
        UI --> VM
6
        VM --> UI
7
    end
8

9
    subgraph "Domain Layer"
10
        UC[Use Cases]
11
        VM --> UC
12
        UC --> VM
13
    end
14

15
    subgraph "Data Layer"
16
        REPO[Repository]
17
        LOCAL[Room Database]
18
        REMOTE[Remote Data Source]
19
        UC --> REPO
20
        REPO --> LOCAL
21
        REPO --> REMOTE
22
    end
23

24
    subgraph "DI Container"
25
        HILT[Hilt]
26
        HILT --> VM
27
        HILT --> UC
28
        HILT --> REPO
29
    end

Single Activity Architecture#

Modern Android development embraces single-activity architecture with Navigation Compose:

1
// MainActivity.kt - Single Activity Implementation
2
@AndroidEntryPoint
3
class MainActivity : ComponentActivity() {
4
    override fun onCreate(savedInstanceState: Bundle?) {
5
        super.onCreate(savedInstanceState)
6

7
        setContent {
8
            TodoTheme {
9
                val navController = rememberNavController()
10
                TodoNavHost(navController = navController)
11
            }
12
        }
13
    }
14
}
15

16
// Navigation Setup
17
@Composable
18
fun TodoNavHost(navController: NavHostController) {
19
    NavHost(
20
        navController = navController,
21
        startDestination = "tasks"
22
    ) {
23
        composable("tasks") {
24
            TasksScreen(
25
                onTaskClick = { taskId ->
26
                    navController.navigate("task_detail/$taskId")
27
                },
28
                onAddTask = {
29
                    navController.navigate("add_task")
30
                }
31
            )
32
        }
33

34
        composable(
35
            "task_detail/{taskId}",
36
            arguments = listOf(navArgument("taskId") { type = NavType.StringType })
37
        ) { backStackEntry ->
38
            val taskId = backStackEntry.arguments?.getString("taskId")
39
            TaskDetailScreen(
40
                taskId = taskId,
41
                onBack = { navController.popBackStack() }
42
            )
43
        }
44

45
        composable("add_task") {
46
            AddEditTaskScreen(
47
                onTaskSave = { navController.popBackStack() },
48
                onBack = { navController.popBackStack() }
49
            )
50
        }
51
    }
52
}

Technology Stack Deep Dive#

Jetpack Compose UI Implementation#

The project demonstrates modern declarative UI with Jetpack Compose:

1
// TasksScreen.kt - Compose UI Implementation
2
@Composable
3
fun TasksScreen(
4
    onTaskClick: (String) -> Unit,
5
    onAddTask: () -> Unit,
6
    modifier: Modifier = Modifier,
7
    viewModel: TasksViewModel = hiltViewModel()
8
) {
9
    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
10

11
    TasksContent(
12
        loading = uiState.isLoading,
13
        tasks = uiState.items,
14
        currentFilteringLabel = uiState.filteringUiInfo.currentFilteringLabel,
15
        noTasksLabel = uiState.filteringUiInfo.noTasksLabel,
16
        noTasksIconRes = uiState.filteringUiInfo.noTaskIconRes,
17
        onRefresh = viewModel::refresh,
18
        onTaskClick = onTaskClick,
19
        onTaskCheckedChange = viewModel::completeTask,
20
        onAddTask = onAddTask,
21
        modifier = modifier
22
    )
23
}
24

25
@Composable
26
private fun TasksContent(
27
    loading: Boolean,
28
    tasks: List<Task>,
29
    currentFilteringLabel: String,
30
    noTasksLabel: String,
31
    @DrawableRes noTasksIconRes: Int,
32
    onRefresh: () -> Unit,
33
    onTaskClick: (String) -> Unit,
34
    onTaskCheckedChange: (Task, Boolean) -> Unit,
35
    onAddTask: () -> Unit,
36
    modifier: Modifier = Modifier
37
) {
38
    LoadingContent(
39
        loading = loading,
40
        empty = tasks.isEmpty() && !loading,
41
        emptyContent = {
42
            TasksEmptyContent(
43
                noTasksLabel = noTasksLabel,
44
                noTasksIconRes = noTasksIconRes,
45
                modifier = Modifier.fillMaxSize()
46
            )
47
        },
48
        onRefresh = onRefresh,
49
        modifier = modifier
50
    ) {
51
        LazyColumn {
52
            items(tasks) { task ->
53
                TaskItem(
54
                    task = task,
55
                    onTaskClick = onTaskClick,
56
                    onCheckedChange = { onTaskCheckedChange(task, it) }
57
                )
58
            }
59
        }
60
    }
61
}

ViewModel with State Management#

Modern state management using StateFlow and reactive programming:

1
// TasksViewModel.kt - Reactive State Management
2
@HiltViewModel
3
class TasksViewModel @Inject constructor(
4
    private val tasksRepository: TasksRepository,
5
    private val savedStateHandle: SavedStateHandle
6
) : ViewModel() {
7

8
    private val _savedFilterType = savedStateHandle.getStateFlow(
9
        TASKS_FILTER_SAVED_STATE_KEY,
10
        TasksFilterType.ALL_TASKS
11
    )
12

13
    private val _filterUiInfo = _savedFilterType.map { getFilterUiInfo(it) }
14
        .stateIn(
15
            scope = viewModelScope,
16
            started = SharingStarted.WhileSubscribed(5000),
17
            initialValue = getFilterUiInfo(TasksFilterType.ALL_TASKS)
18
        )
19

20
    private val _userMessage: MutableStateFlow<String?> = MutableStateFlow(null)
21
    val userMessage: StateFlow<String?> = _userMessage.asStateFlow()
22

23
    private val _isLoading = MutableStateFlow(false)
24
    val isLoading: StateFlow<Boolean> = _isLoading.asStateFlow()
25

26
    val uiState: StateFlow<TasksUiState> = combine(
27
        _filterUiInfo,
28
        _isLoading,
29
        _userMessage
30
    ) { filterUiInfo, isLoading, userMessage ->
31
        TasksUiState(
32
            items = filterTasks(tasksRepository.getTasksStream(), filterUiInfo.currentFiltering),
33
            isLoading = isLoading,
34
            filteringUiInfo = filterUiInfo,
35
            userMessage = userMessage
36
        )
37
    }.stateIn(
38
        scope = viewModelScope,
39
        started = SharingStarted.WhileSubscribed(5000),
40
        initialValue = TasksUiState(isLoading = true)
41
    )
42

43
    fun refresh() {
44
        _isLoading.value = true
45
        viewModelScope.launch {
46
            tasksRepository.refresh()
47
            _isLoading.value = false
48
        }
49
    }
50

51
    fun clearCompletedTasks() {
52
        viewModelScope.launch {
53
            tasksRepository.clearCompletedTasks()
54
            showSnackbarMessage("Completed tasks cleared")
55
        }
56
    }
57

58
    fun completeTask(task: Task, completed: Boolean) {
59
        viewModelScope.launch {
60
            if (completed) {
61
                tasksRepository.completeTask(task.id)
62
                showSnackbarMessage("Task marked as complete")
63
            } else {
64
                tasksRepository.activateTask(task.id)
65
                showSnackbarMessage("Task marked as active")
66
            }
67
        }
68
    }
69

70
    private fun showSnackbarMessage(message: String) {
71
        _userMessage.value = message
72
    }
73

74
    fun snackbarMessageShown() {
75
        _userMessage.value = null
76
    }
77
}
78

79
data class TasksUiState(
80
    val items: List<Task> = emptyList(),
81
    val isLoading: Boolean = false,
82
    val filteringUiInfo: FilteringUiInfo = FilteringUiInfo(),
83
    val userMessage: String? = null
84
)

Repository Pattern Implementation#

Clean data layer with repository pattern:

1
// TasksRepository.kt - Repository Interface
2
interface TasksRepository {
3
    fun getTasksStream(): Flow<List<Task>>
4
    fun getTaskStream(taskId: String): Flow<Task?>
5
    suspend fun getTasks(forceUpdate: Boolean = false): List<Task>
6
    suspend fun getTask(taskId: String, forceUpdate: Boolean = false): Task?
7
    suspend fun refresh()
8
    suspend fun refreshTask(taskId: String)
9
    suspend fun saveTask(task: Task)
10
    suspend fun completeTask(taskId: String)
11
    suspend fun completeTask(task: Task)
12
    suspend fun activateTask(taskId: String)
13
    suspend fun activateTask(task: Task)
14
    suspend fun clearCompletedTasks()
15
    suspend fun deleteAllTasks()
16
    suspend fun deleteTask(taskId: String)
17
}
18

19
// DefaultTasksRepository.kt - Repository Implementation
20
@Singleton
21
class DefaultTasksRepository @Inject constructor(
22
    private val localDataSource: TasksDataSource,
23
    private val remoteDataSource: TasksDataSource,
24
    @IoDispatcher private val dispatcher: CoroutineDispatcher
25
) : TasksRepository {
26

27
    override fun getTasksStream(): Flow<List<Task>> {
28
        return localDataSource.getTasksStream()
29
    }
30

31
    override fun getTaskStream(taskId: String): Flow<Task?> {
32
        return localDataSource.getTaskStream(taskId)
33
    }
34

35
    override suspend fun getTasks(forceUpdate: Boolean): List<Task> {
36
        if (forceUpdate) {
37
            try {
38
                updateTasksFromRemoteDataSource()
39
            } catch (ex: Exception) {
40
                Timber.w(ex, "Remote data source fetch failed")
41
            }
42
        }
43
        return localDataSource.getTasks()
44
    }
45

46
    override suspend fun refresh() {
47
        updateTasksFromRemoteDataSource()
48
    }
49

50
    override suspend fun saveTask(task: Task) {
51
        coroutineScope {
52
            launch { remoteDataSource.saveTask(task) }
53
            launch { localDataSource.saveTask(task) }
54
        }
55
    }
56

57
    override suspend fun completeTask(taskId: String) {
58
        coroutineScope {
59
            launch { remoteDataSource.completeTask(taskId) }
60
            launch { localDataSource.completeTask(taskId) }
61
        }
62
    }
63

64
    private suspend fun updateTasksFromRemoteDataSource() {
65
        withContext(dispatcher) {
66
            val remoteTasks = remoteDataSource.getTasks()
67
            localDataSource.deleteAllTasks()
68
            localDataSource.saveTasks(remoteTasks)
69
        }
70
    }
71
}

Room Database Integration#

Local data persistence with Room:

1
// Task.kt - Entity Model
2
@Entity(tableName = "tasks")
3
data class Task(
4
    @PrimaryKey val id: String = UUID.randomUUID().toString(),
5
    @ColumnInfo(name = "title") var title: String = "",
6
    @ColumnInfo(name = "description") var description: String = "",
7
    @ColumnInfo(name = "completed") var isCompleted: Boolean = false
8
) {
9
    val titleForList: String
10
        get() = if (title.isNotEmpty()) title else description
11

12
    val isActive
13
        get() = !isCompleted
14

15
    val isEmpty
16
        get() = title.isEmpty() || description.isEmpty()
17
}
18

19
// TaskDao.kt - Data Access Object
20
@Dao
21
interface TaskDao {
22
    @Query("SELECT * FROM tasks")
23
    fun observeAll(): Flow<List<Task>>
24

25
    @Query("SELECT * FROM tasks WHERE id = :taskId")
26
    fun observeById(taskId: String): Flow<Task?>
27

28
    @Query("SELECT * FROM tasks")
29
    suspend fun getAll(): List<Task>
30

31
    @Query("SELECT * FROM tasks WHERE id = :taskId")
32
    suspend fun getById(taskId: String): Task?
33

34
    @Insert(onConflict = OnConflictStrategy.REPLACE)
35
    suspend fun insert(task: Task)
36

37
    @Insert(onConflict = OnConflictStrategy.REPLACE)
38
    suspend fun insertAll(tasks: List<Task>)
39

40
    @Update
41
    suspend fun update(task: Task): Int
42

43
    @Query("UPDATE tasks SET completed = :completed WHERE id = :taskId")
44
    suspend fun updateCompleted(taskId: String, completed: Boolean)
45

46
    @Query("DELETE FROM tasks WHERE id = :taskId")
47
    suspend fun deleteById(taskId: String): Int
48

49
    @Query("DELETE FROM tasks")
50
    suspend fun deleteAll()
51

52
    @Query("DELETE FROM tasks WHERE completed = 1")
53
    suspend fun deleteCompleted(): Int
54
}
55

56
// ToDoDatabase.kt - Room Database
57
@Database(
58
    entities = [Task::class],
59
    version = 1,
60
    exportSchema = false
61
)
62
@TypeConverters(DateConverter::class)
63
abstract class ToDoDatabase : RoomDatabase() {
64
    abstract fun taskDao(): TaskDao
65
}

Hilt Dependency Injection#

Modern dependency injection with Hilt:

1
// DatabaseModule.kt - Hilt Database Module
2
@Module
3
@InstallIn(SingletonComponent::class)
4
object DatabaseModule {
5

6
    @Singleton
7
    @Provides
8
    fun provideDatabase(@ApplicationContext context: Context): ToDoDatabase {
9
        return Room.databaseBuilder(
10
            context.applicationContext,
11
            ToDoDatabase::class.java,
12
            "Tasks.db"
13
        ).build()
14
    }
15

16
    @Provides
17
    fun provideTaskDao(database: ToDoDatabase): TaskDao = database.taskDao()
18
}
19

20
// DataSourceModule.kt - Data Source Module
21
@Module
22
@InstallIn(SingletonComponent::class)
23
abstract class DataSourceModule {
24

25
    @Singleton
26
    @Binds
27
    @Local
28
    abstract fun bindLocalDataSource(dataSource: TasksLocalDataSource): TasksDataSource
29

30
    @Singleton
31
    @Binds
32
    @Remote
33
    abstract fun bindRemoteDataSource(dataSource: TasksRemoteDataSource): TasksDataSource
34
}
35

36
// RepositoryModule.kt - Repository Module
37
@Module
38
@InstallIn(SingletonComponent::class)
39
abstract class RepositoryModule {
40

41
    @Singleton
42
    @Binds
43
    abstract fun bindTasksRepository(repository: DefaultTasksRepository): TasksRepository
44
}
45

46
// Qualifiers.kt - Hilt Qualifiers
47
@Qualifier
48
@Retention(AnnotationRetention.RUNTIME)
49
annotation class Remote
50

51
@Qualifier
52
@Retention(AnnotationRetention.RUNTIME)
53
annotation class Local
54

55
@Qualifier
56
@Retention(AnnotationRetention.RUNTIME)
57
annotation class IoDispatcher
58

59
@Qualifier
60
@Retention(AnnotationRetention.RUNTIME)
61
annotation class MainDispatcher
62

63
@Qualifier
64
@Retention(AnnotationRetention.RUNTIME)
65
annotation class DefaultDispatcher

Testing Architecture#

Comprehensive Testing Strategy#

The repository demonstrates a three-tiered testing approach:

1
graph TB
2
    subgraph "Testing Pyramid"
3
        E2E[End-to-End Tests]
4
        INT[Integration Tests]
5
        UNIT[Unit Tests]
6

7
        E2E --> INT
8
        INT --> UNIT
9
    end
10

11
    subgraph "Test Types"
12
        UI_TEST[UI Tests]
13
        REPO_TEST[Repository Tests]
14
        VM_TEST[ViewModel Tests]
15
        DAO_TEST[Database Tests]
16
    end
17

18
    subgraph "Testing Tools"
19
        JUNIT[JUnit]
20
        ESPRESSO[Espresso]
21
        ROBO[Robolectric]
22
        MOCKITO[Mockito]
23
        COROUTINE_TEST[Coroutine Test]
24
    end

Unit Testing Implementation#

1
// TasksViewModelTest.kt - ViewModel Unit Tests
2
@ExperimentalCoroutinesApi
3
@RunWith(JUnit4::class)
4
class TasksViewModelTest {
5

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

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

12
    // Subject under test
13
    private lateinit var tasksViewModel: TasksViewModel
14

15
    // Use a fake repository to be injected into the viewmodel
16
    private lateinit var tasksRepository: FakeTasksRepository
17

18
    @Before
19
    fun setupViewModel() {
20
        tasksRepository = FakeTasksRepository()
21
        val task1 = Task("Title1", "Description1")
22
        val task2 = Task("Title2", "Description2", true)
23
        val task3 = Task("Title3", "Description3", true)
24
        tasksRepository.addTasks(task1, task2, task3)
25

26
        tasksViewModel = TasksViewModel(tasksRepository, SavedStateHandle())
27
    }
28

29
    @Test
30
    fun loadAllTasksFromRepository_loadingTogglesAndDataLoaded() = runTest {
31
        // Pause dispatcher so we can verify initial values
32
        mainCoroutineRule.dispatcher.scheduler.apply {
33
            pauseDispatcher()
34

35
            // When loading of tasks is requested
36
            tasksViewModel.refresh()
37

38
            // Then progress indicator is shown
39
            assertTrue(tasksViewModel.uiState.value.isLoading)
40

41
            // Execute pending coroutines actions
42
            runCurrent()
43

44
            // Then progress indicator is hidden
45
            assertFalse(tasksViewModel.uiState.value.isLoading)
46
        }
47
    }
48

49
    @Test
50
    fun loadTasks_error() = runTest {
51
        // Make the repository return errors
52
        tasksRepository.setReturnError(true)
53

54
        // Load tasks
55
        tasksViewModel.refresh()
56

57
        // Then progress indicator is hidden and error message is shown
58
        assertFalse(tasksViewModel.uiState.value.isLoading)
59
        assertEquals("Error loading tasks", tasksViewModel.userMessage.value)
60
    }
61

62
    @Test
63
    fun completeTask_dataAndSnackbarUpdated() = runTest {
64
        // With a repository that has an active task
65
        val task = Task("Title", "Description")
66
        tasksRepository.addTasks(task)
67

68
        // Complete task
69
        tasksViewModel.completeTask(task, true)
70

71
        // Verify the task is completed
72
        assertTrue(tasksRepository.tasksServiceData[task.id]?.isCompleted ?: false)
73

74
        // And snackbar message is updated
75
        assertEquals("Task marked as complete", tasksViewModel.userMessage.value)
76
    }
77
}

Repository Testing#

1
// DefaultTasksRepositoryTest.kt - Repository Tests
2
@ExperimentalCoroutinesApi
3
@RunWith(AndroidJUnit4::class)
4
@SmallTest
5
class DefaultTasksRepositoryTest {
6

7
    private val task1 = Task("Title1", "Description1")
8
    private val task2 = Task("Title2", "Description2")
9
    private val task3 = Task("Title3", "Description3")
10
    private val remoteTasks = listOf(task1, task2).sortedBy { it.id }
11
    private val localTasks = listOf(task3).sortedBy { it.id }
12
    private val newTasks = listOf(task3).sortedBy { it.id }
13

14
    private lateinit var localDataSource: TasksDataSource
15
    private lateinit var remoteDataSource: TasksDataSource
16

17
    // Class under test
18
    private lateinit var tasksRepository: DefaultTasksRepository
19

20
    @get:Rule
21
    var mainCoroutineRule = MainCoroutineRule()
22

23
    @Before
24
    fun createRepository() {
25
        localDataSource = FakeDataSource(localTasks.toMutableList())
26
        remoteDataSource = FakeDataSource(remoteTasks.toMutableList())
27

28
        // Get a reference to the class under test
29
        tasksRepository = DefaultTasksRepository(
30
            localDataSource, remoteDataSource, Dispatchers.Main
31
        )
32
    }
33

34
    @Test
35
    fun getTasks_requestsAllTasksFromRemoteDataSource() = runTest {
36
        // When tasks are requested from the tasks repository
37
        val tasks = tasksRepository.getTasks(true)
38

39
        // Then tasks are loaded from the remote data source
40
        assertEquals(remoteTasks.sortedBy { it.id }, tasks.sortedBy { it.id })
41
    }
42

43
    @Test
44
    fun getTasks_WithDirtyCache_tasksAreRetrievedFromRemote() = runTest {
45
        // When calling getTasks in the repository with dirty cache
46
        val tasks = tasksRepository.getTasks(true)
47

48
        // And the remote data source has data
49
        assertEquals(remoteTasks.sortedBy { it.id }, tasks.sortedBy { it.id })
50
    }
51

52
    @Test
53
    fun getTasks_WithCleanCache_tasksAreRetrievedFromLocal() = runTest {
54
        // When calling getTasks in the repository without forcing an update
55
        val tasks = tasksRepository.getTasks(false)
56

57
        // Then the local data source is queried
58
        assertEquals(localTasks.sortedBy { it.id }, tasks.sortedBy { it.id })
59
    }
60

61
    @Test
62
    fun saveTask_savesToLocalAndRemote() = runTest {
63
        // When a task is saved to the tasks repository
64
        val newTask = Task("New Title", "New Description")
65
        tasksRepository.saveTask(newTask)
66

67
        // Then the remote and local data sources are called
68
        assertThat(remoteDataSource.getTasks(), hasItem(newTask))
69
        assertThat(localDataSource.getTasks(), hasItem(newTask))
70
    }
71

72
    @Test
73
    fun completeTask_completesTaskToServiceAPIUpdatesCache() = runTest {
74
        // Save a task
75
        tasksRepository.saveTask(task1)
76

77
        // Mark the task as complete
78
        tasksRepository.completeTask(task1.id)
79

80
        // Verify the task is completed in both data sources
81
        assertThat(tasksRepository.getTask(task1.id, false)?.isCompleted, `is`(true))
82
    }
83
}

UI Testing with Compose#

1
// TasksScreenTest.kt - Compose UI Tests
2
@RunWith(AndroidJUnit4::class)
3
@MediumTest
4
@ExperimentalCoroutinesApi
5
class TasksScreenTest {
6

7
    @get:Rule
8
    val composeTestRule = createAndroidComposeRule<ComponentActivity>()
9

10
    @get:Rule
11
    var hiltRule = HiltAndroidRule(this)
12

13
    @BindValue @JvmField
14
    val repository: TasksRepository = FakeTasksRepository()
15

16
    @Before
17
    fun init() {
18
        hiltRule.inject()
19
    }
20

21
    @Test
22
    fun displayTask_whenRepositoryHasData() {
23
        // Set up repository with test data
24
        (repository as FakeTasksRepository).addTasks(
25
            Task("TITLE1", "DESCRIPTION1"),
26
            Task("TITLE2", "DESCRIPTION2", isCompleted = true),
27
        )
28

29
        // Start up the screen under test
30
        composeTestRule.setContent {
31
            TodoTheme {
32
                TasksScreen(
33
                    onTaskClick = { },
34
                    onAddTask = { }
35
                )
36
            }
37
        }
38

39
        // Verify tasks are displayed on screen
40
        composeTestRule.onNodeWithText("TITLE1").assertIsDisplayed()
41
        composeTestRule.onNodeWithText("DESCRIPTION1").assertIsDisplayed()
42
        composeTestRule.onNodeWithText("TITLE2").assertIsDisplayed()
43
        composeTestRule.onNodeWithText("DESCRIPTION2").assertIsDisplayed()
44
    }
45

46
    @Test
47
    fun displayCompletedTask() {
48
        // Set up repository with completed task
49
        (repository as FakeTasksRepository).addTasks(
50
            Task("TITLE1", "DESCRIPTION1", isCompleted = true)
51
        )
52

53
        composeTestRule.setContent {
54
            TodoTheme {
55
                TasksScreen(
56
                    onTaskClick = { },
57
                    onAddTask = { }
58
                )
59
            }
60
        }
61

62
        // Check that the task is marked as completed
63
        composeTestRule.onNodeWithText("TITLE1").assertIsDisplayed()
64
        composeTestRule
65
            .onNodeWithContentDescription("Mark as incomplete")
66
            .assertIsDisplayed()
67
    }
68

69
    @Test
70
    fun clickAddTaskButton_navigateToAddEditScreen() {
71
        // Set up navigation callback
72
        val navController = TestNavHostController(
73
            LocalContext.current
74
        )
75
        navController.navigatorProvider.addNavigator(ComposeNavigator())
76

77
        composeTestRule.setContent {
78
            TodoTheme {
79
                CompositionLocalProvider(LocalNavController provides navController) {
80
                    TasksScreen(
81
                        onTaskClick = { },
82
                        onAddTask = { navController.navigate("add_task") }
83
                    )
84
                }
85
            }
86
        }
87

88
        // Click add task FAB
89
        composeTestRule.onNodeWithContentDescription("Add task").performClick()
90

91
        // Verify navigation occurred
92
        assertEquals("add_task", navController.currentBackStackEntry?.destination?.route)
93
    }
94
}

Advanced Architectural Patterns#

Use Cases Implementation#

Clean architecture with use cases for complex business logic:

1
// GetTasksUseCase.kt - Domain Use Case
2
class GetTasksUseCase @Inject constructor(
3
    private val tasksRepository: TasksRepository
4
) {
5
    operator fun invoke(filterType: TasksFilterType): Flow<List<Task>> {
6
        return tasksRepository.getTasksStream().map { tasks ->
7
            filterTasks(tasks, filterType)
8
        }
9
    }
10

11
    private fun filterTasks(tasks: List<Task>, filterType: TasksFilterType): List<Task> {
12
        return when (filterType) {
13
            TasksFilterType.ALL_TASKS -> tasks
14
            TasksFilterType.ACTIVE_TASKS -> tasks.filter { it.isActive }
15
            TasksFilterType.COMPLETED_TASKS -> tasks.filter { it.isCompleted }
16
        }
17
    }
18
}
19

20
// CompleteTaskUseCase.kt - Business Logic Use Case
21
class CompleteTaskUseCase @Inject constructor(
22
    private val tasksRepository: TasksRepository
23
) {
24
    suspend operator fun invoke(taskId: String): Result<Unit> {
25
        return try {
26
            tasksRepository.completeTask(taskId)
27
            Result.Success(Unit)
28
        } catch (e: Exception) {
29
            Result.Error(e)
30
        }
31
    }
32
}

State Management Patterns#

Advanced state management with sealed classes:

1
// UiState.kt - UI State Management
2
sealed class UiState<out T> {
3
    object Loading : UiState<Nothing>()
4
    data class Success<T>(val data: T) : UiState<T>()
5
    data class Error(val exception: Throwable) : UiState<Nothing>()
6
}
7

8
// Resource.kt - Resource Wrapper
9
sealed class Resource<T>(
10
    val data: T? = null,
11
    val message: String? = null
12
) {
13
    class Success<T>(data: T) : Resource<T>(data)
14
    class Error<T>(message: String, data: T? = null) : Resource<T>(data, message)
15
    class Loading<T>(data: T? = null) : Resource<T>(data)
16
}
17

18
// TasksUiState.kt - Feature-Specific UI State
19
data class TasksUiState(
20
    val tasks: List<Task> = emptyList(),
21
    val isLoading: Boolean = false,
22
    val userMessage: String? = null,
23
    val isTaskSaved: Boolean = false,
24
    val isTaskDeleted: Boolean = false,
25
    val filteringUiInfo: FilteringUiInfo = FilteringUiInfo()
26
)
27

28
// ViewModel with State Management
29
@HiltViewModel
30
class TasksViewModel @Inject constructor(
31
    private val getTasksUseCase: GetTasksUseCase,
32
    private val completeTaskUseCase: CompleteTaskUseCase,
33
    private val deleteTaskUseCase: DeleteTaskUseCase,
34
    savedStateHandle: SavedStateHandle
35
) : ViewModel() {
36

37
    private val _uiState = MutableStateFlow(TasksUiState(isLoading = true))
38
    val uiState: StateFlow<TasksUiState> = _uiState.asStateFlow()
39

40
    init {
41
        loadTasks()
42
    }
43

44
    private fun loadTasks() {
45
        viewModelScope.launch {
46
            getTasksUseCase(TasksFilterType.ALL_TASKS)
47
                .catch { exception ->
48
                    _uiState.value = _uiState.value.copy(
49
                        isLoading = false,
50
                        userMessage = "Error loading tasks: ${exception.message}"
51
                    )
52
                }
53
                .collect { tasks ->
54
                    _uiState.value = _uiState.value.copy(
55
                        tasks = tasks,
56
                        isLoading = false
57
                    )
58
                }
59
        }
60
    }
61
}

Error Handling Strategy#

Comprehensive error handling across layers:

1
// Result.kt - Result Wrapper
2
sealed class Result<out T> {
3
    data class Success<T>(val data: T) : Result<T>()
4
    data class Error(val exception: Throwable) : Result<Nothing>()
5

6
    inline fun <R> map(transform: (value: T) -> R): Result<R> {
7
        return when (this) {
8
            is Success -> Success(transform(data))
9
            is Error -> Error(exception)
10
        }
11
    }
12

13
    inline fun onSuccess(action: (value: T) -> Unit): Result<T> {
14
        if (this is Success) action(data)
15
        return this
16
    }
17

18
    inline fun onError(action: (exception: Throwable) -> Unit): Result<T> {
19
        if (this is Error) action(exception)
20
        return this
21
    }
22
}
23

24
// Repository Error Handling
25
class DefaultTasksRepository @Inject constructor(
26
    private val localDataSource: TasksDataSource,
27
    private val remoteDataSource: TasksDataSource
28
) : TasksRepository {
29

30
    override suspend fun getTasks(forceUpdate: Boolean): Result<List<Task>> {
31
        return try {
32
            if (forceUpdate) {
33
                val remoteResult = remoteDataSource.getTasks()
34
                when (remoteResult) {
35
                    is Result.Success -> {
36
                        localDataSource.deleteAllTasks()
37
                        localDataSource.saveTasks(remoteResult.data)
38
                        Result.Success(remoteResult.data)
39
                    }
40
                    is Result.Error -> {
41
                        // Fall back to local data
42
                        localDataSource.getTasks()
43
                    }
44
                }
45
            } else {
46
                localDataSource.getTasks()
47
            }
48
        } catch (e: Exception) {
49
            Result.Error(e)
50
        }
51
    }
52
}
53

54
// ViewModel Error Handling
55
@HiltViewModel
56
class TasksViewModel @Inject constructor(
57
    private val tasksRepository: TasksRepository
58
) : ViewModel() {
59

60
    private val _errorMessage = MutableLiveData<String>()
61
    val errorMessage: LiveData<String> = _errorMessage
62

63
    fun loadTasks() {
64
        viewModelScope.launch {
65
            tasksRepository.getTasks()
66
                .onSuccess { tasks ->
67
                    // Update UI with tasks
68
                }
69
                .onError { exception ->
70
                    _errorMessage.value = when (exception) {
71
                        is NetworkException -> "Network error. Please check your connection."
72
                        is DatabaseException -> "Local database error."
73
                        else -> "An unexpected error occurred."
74
                    }
75
                }
76
        }
77
    }
78
}

Performance Optimization#

Memory Management#

Efficient memory usage with lifecycle-aware components:

1
// LifecycleAwareViewModel.kt - Memory Efficient ViewModel
2
@HiltViewModel
3
class TasksViewModel @Inject constructor(
4
    private val tasksRepository: TasksRepository
5
) : ViewModel() {
6

7
    private val _tasks = MutableLiveData<List<Task>>()
8
    val tasks: LiveData<List<Task>> = _tasks
9

10
    // Use StateFlow for better memory management
11
    private val _uiState = MutableStateFlow(TasksUiState())
12
    val uiState: StateFlow<TasksUiState> = _uiState
13
        .stateIn(
14
            scope = viewModelScope,
15
            started = SharingStarted.WhileSubscribed(5000), // Stop after 5 seconds
16
            initialValue = TasksUiState()
17
        )
18

19
    override fun onCleared() {
20
        super.onCleared()
21
        // Clean up resources
22
        viewModelScope.cancel()
23
    }
24
}
25

26
// Efficient Data Loading
27
class TasksRepository {
28
    fun getTasksStream(): Flow<List<Task>> {
29
        return tasksDao.observeAll()
30
            .distinctUntilChanged() // Avoid unnecessary emissions
31
            .flowOn(Dispatchers.IO) // Background thread
32
    }
33
}

Database Optimization#

Room database performance optimizations:

1
// Optimized Dao with Indices
2
@Entity(
3
    tableName = "tasks",
4
    indices = [
5
        Index(value = ["completed"], name = "index_tasks_completed"),
6
        Index(value = ["title"], name = "index_tasks_title")
7
    ]
8
)
9
data class Task(
10
    @PrimaryKey val id: String = UUID.randomUUID().toString(),
11
    @ColumnInfo(name = "title") var title: String = "",
12
    @ColumnInfo(name = "description") var description: String = "",
13
    @ColumnInfo(name = "completed") var isCompleted: Boolean = false,
14
    @ColumnInfo(name = "created_date") val createdDate: Long = System.currentTimeMillis()
15
)
16

17
@Dao
18
interface TaskDao {
19
    // Optimized queries with indices
20
    @Query("SELECT * FROM tasks WHERE completed = :completed ORDER BY created_date DESC")
21
    fun getTasksByStatus(completed: Boolean): Flow<List<Task>>
22

23
    @Query("SELECT * FROM tasks WHERE title LIKE '%' || :query || '%' OR description LIKE '%' || :query || '%'")
24
    suspend fun searchTasks(query: String): List<Task>
25

26
    // Batch operations for better performance
27
    @Insert(onConflict = OnConflictStrategy.REPLACE)
28
    suspend fun insertAll(tasks: List<Task>)
29

30
    @Transaction
31
    suspend fun updateTasksTransaction(tasks: List<Task>) {
32
        deleteAll()
33
        insertAll(tasks)
34
    }
35
}

Compose Performance#

Jetpack Compose performance optimization:

1
// Optimized Composables with remember and derivedStateOf
2
@Composable
3
fun TasksScreen(
4
    viewModel: TasksViewModel = hiltViewModel()
5
) {
6
    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
7

8
    // Remember expensive computations
9
    val filteredTasks = remember(uiState.tasks, uiState.filter) {
10
        uiState.tasks.filter { task ->
11
            when (uiState.filter) {
12
                TasksFilterType.ACTIVE_TASKS -> !task.isCompleted
13
                TasksFilterType.COMPLETED_TASKS -> task.isCompleted
14
                TasksFilterType.ALL_TASKS -> true
15
            }
16
        }
17
    }
18

19
    LazyColumn(
20
        modifier = Modifier.fillMaxSize(),
21
        contentPadding = PaddingValues(16.dp)
22
    ) {
23
        items(
24
            items = filteredTasks,
25
            key = { task -> task.id } // Provide stable keys
26
        ) { task ->
27
            TaskItem(
28
                task = task,
29
                onTaskClick = viewModel::selectTask,
30
                onTaskComplete = viewModel::completeTask
31
            )
32
        }
33
    }
34
}
35

36
// Stable data classes for better recomposition
37
@Stable
38
data class TaskUiState(
39
    val id: String,
40
    val title: String,
41
    val description: String,
42
    val isCompleted: Boolean
43
)
44

45
// Optimized item composable
46
@Composable
47
fun TaskItem(
48
    task: Task,
49
    onTaskClick: (String) -> Unit,
50
    onTaskComplete: (String, Boolean) -> Unit,
51
    modifier: Modifier = Modifier
52
) {
53
    // Use remember for callbacks to avoid recomposition
54
    val onClickCallback = remember(task.id) {
55
        { onTaskClick(task.id) }
56
    }
57

58
    val onCompleteCallback = remember(task.id) {
59
        { completed: Boolean -> onTaskComplete(task.id, completed) }
60
    }
61

62
    Card(
63
        modifier = modifier
64
            .fillMaxWidth()
65
            .clickable { onClickCallback() },
66
        elevation = CardDefaults.cardElevation(defaultElevation = 4.dp)
67
    ) {
68
        TaskContent(
69
            title = task.title,
70
            description = task.description,
71
            isCompleted = task.isCompleted,
72
            onComplete = onCompleteCallback
73
        )
74
    }
75
}

Migration Patterns#

From MVP to MVVM#

Migration strategy from MVP to MVVM architecture:

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

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

15
// Migrated MVVM Pattern
16
@HiltViewModel
17
class TasksViewModel @Inject constructor(
18
    private val tasksRepository: TasksRepository
19
) : ViewModel() {
20

21
    private val _uiState = MutableStateFlow(TasksUiState())
22
    val uiState: StateFlow<TasksUiState> = _uiState
23

24
    fun loadTasks() {
25
        viewModelScope.launch {
26
            _uiState.value = _uiState.value.copy(isLoading = true)
27

28
            try {
29
                val tasks = tasksRepository.getTasks()
30
                _uiState.value = _uiState.value.copy(
31
                    tasks = tasks,
32
                    isLoading = false
33
                )
34
            } catch (e: Exception) {
35
                _uiState.value = _uiState.value.copy(
36
                    isLoading = false,
37
                    errorMessage = e.message
38
                )
39
            }
40
        }
41
    }
42
}

From Views to Compose#

Migration from traditional Views to Jetpack Compose:

1
// Legacy XML Layout
2
/*
3
<LinearLayout
4
    android:layout_width="match_parent"
5
    android:layout_height="match_parent"
6
    android:orientation="vertical">
7

8
    <RecyclerView
9
        android:id="@+id/recycler_view_tasks"
10
        android:layout_width="match_parent"
11
        android:layout_height="0dp"
12
        android:layout_weight="1" />
13

14
    <ProgressBar
15
        android:id="@+id/progress_bar"
16
        android:layout_width="wrap_content"
17
        android:layout_height="wrap_content"
18
        android:layout_gravity="center" />
19

20
</LinearLayout>
21
*/
22

23
// Migrated Compose Implementation
24
@Composable
25
fun TasksScreen(
26
    viewModel: TasksViewModel = hiltViewModel()
27
) {
28
    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
29

30
    Column(
31
        modifier = Modifier.fillMaxSize()
32
    ) {
33
        if (uiState.isLoading) {
34
            Box(
35
                modifier = Modifier.fillMaxSize(),
36
                contentAlignment = Alignment.Center
37
            ) {
38
                CircularProgressIndicator()
39
            }
40
        } else {
41
            LazyColumn(
42
                modifier = Modifier.weight(1f)
43
            ) {
44
                items(uiState.tasks) { task ->
45
                    TaskItem(
46
                        task = task,
47
                        onTaskClick = { /* handle click */ }
48
                    )
49
                }
50
            }
51
        }
52
    }
53
}

Best Practices Summary#

Architecture Guidelines#

Single Responsibility: Each class has one reason to change
Dependency Inversion: Depend on abstractions, not concretions
Separation of Concerns: Clear layer boundaries
Testability: All components easily testable in isolation

Code Organization#

1
// Recommended Package Structure
2
com.example.todoapp/
3
├── data/
4
│   ├── local/
5
│   │   ├── TaskDao.kt
6
│   │   ├── ToDoDatabase.kt
7
│   │   └── TasksLocalDataSource.kt
8
│   ├── remote/
9
│   │   └── TasksRemoteDataSource.kt
10
│   └── DefaultTasksRepository.kt
11
├── di/
12
│   ├── DatabaseModule.kt
13
│   ├── RepositoryModule.kt
14
│   └── NetworkModule.kt
15
├── domain/
16
│   ├── model/
17
│   │   └── Task.kt
18
│   ├── repository/
19
│   │   └── TasksRepository.kt
20
│   └── usecase/
21
│       ├── GetTasksUseCase.kt
22
│       └── CompleteTaskUseCase.kt
23
└── ui/
24
    ├── tasks/
25
    │   ├── TasksScreen.kt
26
    │   ├── TasksViewModel.kt
27
    │   └── TasksUiState.kt
28
    ├── addedittask/
29
    └── theme/

Performance Best Practices#

Use StateFlow over LiveData for better performance
Implement proper lifecycle awareness with WhileSubscribed
Optimize Compose recomposition with stable keys and remember
Use background dispatchers for heavy operations
Implement proper error handling at all layers

Conclusion#

The Android Architecture Samples repository provides a comprehensive blueprint for modern Android development. By implementing MVVM architecture with Jetpack Compose, Hilt dependency injection, Room database, and comprehensive testing strategies, it demonstrates how to build maintainable, scalable, and testable Android applications.

Key takeaways:

Modern Stack: Jetpack Compose + MVVM + Hilt + Room
Testing Excellence: Comprehensive unit, integration, and UI tests
Performance Optimization: Memory management and efficient data loading
Best Practices: Clean architecture, separation of concerns, and dependency inversion
Real-World Implementation: Practical examples ready for production use

The repository serves as both an educational resource and a production-ready template for building robust Android applications that follow Google’s recommended architectural patterns and best practices.