Android Architecture Migration Guide: From Legacy to Modern MVVM#

Migrating legacy Android applications to modern architecture patterns is a critical step in maintaining code quality and developer productivity. This comprehensive guide provides strategies for migrating from various legacy patterns to modern MVVM architecture with Jetpack Compose.

Migration Strategy Overview#

Assessment and Planning Phase#

1
// Migration Assessment Checklist
2
data class MigrationAssessment(
3
    val currentArchitecture: ArchitecturePattern,
4
    val codebaseSize: CodebaseMetrics,
5
    val technicalDebt: TechnicalDebtMetrics,
6
    val testCoverage: TestCoverageMetrics,
7
    val migrationComplexity: ComplexityLevel
8
) {
9
    fun generateMigrationPlan(): MigrationPlan {
10
        return MigrationPlan(
11
            phases = listOf(
12
                Phase.DEPENDENCY_INJECTION_SETUP,
13
                Phase.REPOSITORY_PATTERN_INTRODUCTION,
14
                Phase.VIEWMODEL_MIGRATION,
15
                Phase.UI_LAYER_MODERNIZATION,
16
                Phase.TESTING_IMPLEMENTATION
17
            ),
18
            estimatedDuration = calculateDuration(),
19
            riskFactors = identifyRisks()
20
        )
21
    }
22
}
23

24
enum class ArchitecturePattern {
25
    LEGACY_MVC,
26
    MVP,
27
    MVVM_LEGACY,
28
    NO_ARCHITECTURE
29
}

Incremental Migration Approach#

1
// Migration phases with feature flags
2
class MigrationManager(
3
    private val featureFlags: FeatureFlags,
4
    private val analytics: Analytics
5
) {
6
    fun shouldUseLegacyImplementation(feature: Feature): Boolean {
7
        return when (featureFlags.getMigrationPhase(feature)) {
8
            MigrationPhase.NOT_STARTED -> true
9
            MigrationPhase.IN_PROGRESS -> featureFlags.isEnabled("${feature.name}_new_impl")
10
            MigrationPhase.COMPLETED -> false
11
        }
12
    }
13

14
    fun trackMigrationProgress(feature: Feature, success: Boolean) {
15
        analytics.track("migration_progress", mapOf(
16
            "feature" to feature.name,
17
            "success" to success,
18
            "phase" to featureFlags.getMigrationPhase(feature)
19
        ))
20
    }
21
}

Migrating from Legacy MVC/No Architecture#

Before: Legacy Activity-Heavy Architecture#

1
// Legacy: Everything in Activity
2
class LegacyTasksActivity : AppCompatActivity() {
3

4
    private lateinit var tasksAdapter: TasksAdapter
5
    private lateinit var database: SQLiteDatabase
6
    private val tasks = mutableListOf<Task>()
7

8
    override fun onCreate(savedInstanceState: Bundle?) {
9
        super.onCreate(savedInstanceState)
10
        setContentView(R.layout.activity_tasks)
11

12
        setupViews()
13
        setupDatabase()
14
        loadTasks()
15
    }
16

17
    private fun setupViews() {
18
        tasksAdapter = TasksAdapter(tasks) { task ->
19
            // Handle task click directly in activity
20
            if (task.isCompleted) {
21
                markTaskActive(task.id)
22
            } else {
23
                markTaskCompleted(task.id)
24
            }
25
        }
26

27
        findViewById<RecyclerView>(R.id.tasks_list).adapter = tasksAdapter
28

29
        findViewById<FloatingActionButton>(R.id.fab_add_task).setOnClickListener {
30
            // Direct navigation logic
31
            startActivity(Intent(this, AddTaskActivity::class.java))
32
        }
33
    }
34

35
    private fun loadTasks() {
36
        // Direct database access in UI thread (anti-pattern)
37
        Thread {
38
            val cursor = database.rawQuery("SELECT * FROM tasks", null)
39
            val loadedTasks = mutableListOf<Task>()
40

41
            while (cursor.moveToNext()) {
42
                loadedTasks.add(
43
                    Task(
44
                        id = cursor.getString(cursor.getColumnIndex("id")),
45
                        title = cursor.getString(cursor.getColumnIndex("title")),
46
                        isCompleted = cursor.getInt(cursor.getColumnIndex("is_completed")) == 1
47
                    )
48
                )
49
            }
50
            cursor.close()
51

52
            runOnUiThread {
53
                tasks.clear()
54
                tasks.addAll(loadedTasks)
55
                tasksAdapter.notifyDataSetChanged()
56
            }
57
        }.start()
58
    }
59

60
    private fun markTaskCompleted(taskId: String) {
61
        // Direct database update (anti-pattern)
62
        Thread {
63
            database.execSQL("UPDATE tasks SET is_completed = 1 WHERE id = ?", arrayOf(taskId))
64
            loadTasks() // Reload everything
65
        }.start()
66
    }
67
}

After: Modern MVVM with Repository Pattern#

1
// Step 1: Introduce Repository Layer
2
@Singleton
3
class TasksRepository @Inject constructor(
4
    private val localDataSource: TasksLocalDataSource,
5
    private val remoteDataSource: TasksRemoteDataSource,
6
    @IoDispatcher private val dispatcher: CoroutineDispatcher
7
) {
8
    private val _tasks = MutableStateFlow<List<Task>>(emptyList())
9
    val tasks: StateFlow<List<Task>> = _tasks.asStateFlow()
10

11
    suspend fun loadTasks() = withContext(dispatcher) {
12
        try {
13
            val localTasks = localDataSource.getTasks()
14
            _tasks.value = localTasks
15

16
            // Sync with remote if needed
17
            val remoteTasks = remoteDataSource.getTasks()
18
            localDataSource.saveTasks(remoteTasks)
19
            _tasks.value = remoteTasks
20
        } catch (e: Exception) {
21
            Timber.e(e, "Failed to load tasks")
22
        }
23
    }
24

25
    suspend fun updateTask(task: Task) = withContext(dispatcher) {
26
        localDataSource.updateTask(task)
27
        remoteDataSource.updateTask(task)
28
        loadTasks() // Refresh local state
29
    }
30
}
31

32
// Step 2: Implement ViewModel
33
@HiltViewModel
34
class TasksViewModel @Inject constructor(
35
    private val repository: TasksRepository
36
) : ViewModel() {
37

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

41
    init {
42
        loadTasks()
43
        collectTasks()
44
    }
45

46
    private fun collectTasks() {
47
        viewModelScope.launch {
48
            repository.tasks.collect { tasks ->
49
                _uiState.value = _uiState.value.copy(
50
                    tasks = tasks,
51
                    isLoading = false
52
                )
53
            }
54
        }
55
    }
56

57
    fun completeTask(taskId: String) {
58
        viewModelScope.launch {
59
            val task = _uiState.value.tasks.find { it.id == taskId }
60
            task?.let {
61
                repository.updateTask(it.copy(isCompleted = !it.isCompleted))
62
            }
63
        }
64
    }
65

66
    private fun loadTasks() {
67
        _uiState.value = _uiState.value.copy(isLoading = true)
68
        viewModelScope.launch {
69
            repository.loadTasks()
70
        }
71
    }
72
}
73

74
// Step 3: Modernized Activity/Fragment
75
@AndroidEntryPoint
76
class TasksActivity : ComponentActivity() {
77

78
    override fun onCreate(savedInstanceState: Bundle?) {
79
        super.onCreate(savedInstanceState)
80

81
        setContent {
82
            TodoTheme {
83
                TasksScreen()
84
            }
85
        }
86
    }
87
}
88

89
@Composable
90
fun TasksScreen(
91
    viewModel: TasksViewModel = hiltViewModel()
92
) {
93
    val uiState by viewModel.uiState.collectAsState()
94

95
    TasksContent(
96
        uiState = uiState,
97
        onTaskClick = viewModel::completeTask,
98
        onAddTask = { /* Navigate to add task */ }
99
    )
100
}

Migrating from MVP to MVVM#

Before: MVP Architecture#

1
// MVP Presenter
2
class TasksPresenter(
3
    private val view: TasksContract.View,
4
    private val repository: TasksRepository
5
) : TasksContract.Presenter {
6

7
    private var tasks: List<Task> = emptyList()
8

9
    override fun loadTasks() {
10
        view.showLoading()
11

12
        repository.getTasks(object : TasksDataSource.LoadTasksCallback {
13
            override fun onTasksLoaded(tasks: List<Task>) {
14
                this@TasksPresenter.tasks = tasks
15
                view.hideLoading()
16
                view.showTasks(tasks)
17
            }
18

19
            override fun onDataNotAvailable() {
20
                view.hideLoading()
21
                view.showNoTasks()
22
            }
23
        })
24
    }
25

26
    override fun completeTask(task: Task) {
27
        repository.completeTask(task, object : TasksDataSource.CompleteTaskCallback {
28
            override fun onTaskCompleted() {
29
                view.showTaskMarkedComplete()
30
                loadTasks() // Reload all tasks
31
            }
32

33
            override fun onError() {
34
                view.showError("Failed to complete task")
35
            }
36
        })
37
    }
38
}
39

40
// MVP View (Activity/Fragment)
41
class TasksActivity : AppCompatActivity(), TasksContract.View {
42

43
    private lateinit var presenter: TasksContract.Presenter
44
    private lateinit var adapter: TasksAdapter
45

46
    override fun onCreate(savedInstanceState: Bundle?) {
47
        super.onCreate(savedInstanceState)
48
        setContentView(R.layout.activity_tasks)
49

50
        presenter = TasksPresenter(this, TasksRepository.getInstance())
51
        presenter.loadTasks()
52
    }
53

54
    override fun showTasks(tasks: List<Task>) {
55
        adapter.updateTasks(tasks)
56
    }
57

58
    override fun showLoading() {
59
        findViewById<ProgressBar>(R.id.progress_bar).visibility = View.VISIBLE
60
    }
61

62
    // More view methods...
63
}

After: MVVM Migration#

1
// Migration Step 1: Convert Presenter to ViewModel
2
@HiltViewModel
3
class TasksViewModel @Inject constructor(
4
    private val repository: TasksRepository
5
) : ViewModel() {
6

7
    // Replace callbacks with StateFlow/LiveData
8
    private val _uiState = MutableStateFlow(TasksUiState())
9
    val uiState: StateFlow<TasksUiState> = _uiState.asStateFlow()
10

11
    init {
12
        loadTasks()
13
    }
14

15
    // Convert callback-based operations to coroutines
16
    private fun loadTasks() {
17
        viewModelScope.launch {
18
            _uiState.value = _uiState.value.copy(isLoading = true)
19

20
            try {
21
                val tasks = repository.getTasks()
22
                _uiState.value = TasksUiState(
23
                    tasks = tasks,
24
                    isLoading = false,
25
                    isEmpty = tasks.isEmpty()
26
                )
27
            } catch (e: Exception) {
28
                _uiState.value = TasksUiState(
29
                    isLoading = false,
30
                    errorMessage = "Failed to load tasks"
31
                )
32
            }
33
        }
34
    }
35

36
    fun completeTask(task: Task) {
37
        viewModelScope.launch {
38
            try {
39
                repository.completeTask(task)
40
                // State updates automatically through repository
41
            } catch (e: Exception) {
42
                _uiState.value = _uiState.value.copy(
43
                    errorMessage = "Failed to complete task"
44
                )
45
            }
46
        }
47
    }
48
}
49

50
// Migration Step 2: Update Repository to use Coroutines
51
@Singleton
52
class TasksRepository @Inject constructor(
53
    private val tasksDao: TasksDao,
54
    @IoDispatcher private val dispatcher: CoroutineDispatcher
55
) {
56
    // Replace callbacks with suspend functions
57
    suspend fun getTasks(): List<Task> = withContext(dispatcher) {
58
        tasksDao.getTasks()
59
    }
60

61
    suspend fun completeTask(task: Task) = withContext(dispatcher) {
62
        tasksDao.updateTask(task.copy(isCompleted = true))
63
    }
64
}
65

66
// Migration Step 3: Simplified Activity
67
@AndroidEntryPoint
68
class TasksActivity : ComponentActivity() {
69

70
    override fun onCreate(savedInstanceState: Bundle?) {
71
        super.onCreate(savedInstanceState)
72

73
        setContent {
74
            TodoTheme {
75
                TasksScreen()
76
            }
77
        }
78
    }
79
}

Database Migration Strategies#

Migrating from SQLite to Room#

1
// Legacy SQLite Helper
2
class LegacyDatabaseHelper(context: Context) : SQLiteOpenHelper(context, "tasks.db", null, 1) {
3

4
    override fun onCreate(db: SQLiteDatabase) {
5
        db.execSQL("""
6
            CREATE TABLE tasks (
7
                id TEXT PRIMARY KEY,
8
                title TEXT,
9
                description TEXT,
10
                is_completed INTEGER
11
            )
12
        """)
13
    }
14

15
    override fun onUpgrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) {
16
        // Handle upgrades
17
    }
18
}
19

20
// Migration to Room
21
@Database(
22
    entities = [Task::class],
23
    version = 2,
24
    exportSchema = true
25
)
26
@TypeConverters(DateConverter::class)
27
abstract class TodoDatabase : RoomDatabase() {
28
    abstract fun taskDao(): TasksDao
29

30
    companion object {
31
        // Migration from SQLite to Room
32
        val MIGRATION_1_2 = object : Migration(1, 2) {
33
            override fun migrate(database: SupportSQLiteDatabase) {
34
                // Add new columns if needed
35
                database.execSQL("ALTER TABLE tasks ADD COLUMN created_at INTEGER NOT NULL DEFAULT 0")
36
                database.execSQL("ALTER TABLE tasks ADD COLUMN updated_at INTEGER NOT NULL DEFAULT 0")
37
            }
38
        }
39
    }
40
}
41

42
// Data Migration Service
43
class DatabaseMigrationService @Inject constructor(
44
    private val legacyDb: LegacyDatabaseHelper,
45
    private val modernDb: TodoDatabase,
46
    @IoDispatcher private val dispatcher: CoroutineDispatcher
47
) {
48

49
    suspend fun migrateData() = withContext(dispatcher) {
50
        val legacyTasks = extractLegacyTasks()
51
        val modernTasks = convertToModernFormat(legacyTasks)
52
        modernDb.taskDao().insertTasks(modernTasks)
53
    }
54

55
    private fun extractLegacyTasks(): List<LegacyTask> {
56
        val cursor = legacyDb.readableDatabase.rawQuery("SELECT * FROM tasks", null)
57
        val tasks = mutableListOf<LegacyTask>()
58

59
        while (cursor.moveToNext()) {
60
            tasks.add(
61
                LegacyTask(
62
                    id = cursor.getString(cursor.getColumnIndex("id")),
63
                    title = cursor.getString(cursor.getColumnIndex("title")),
64
                    isCompleted = cursor.getInt(cursor.getColumnIndex("is_completed")) == 1
65
                )
66
            )
67
        }
68
        cursor.close()
69
        return tasks
70
    }
71

72
    private fun convertToModernFormat(legacyTasks: List<LegacyTask>): List<Task> {
73
        return legacyTasks.map { legacy ->
74
            Task(
75
                id = legacy.id,
76
                title = legacy.title,
77
                description = "", // Default value for new field
78
                isCompleted = legacy.isCompleted,
79
                createdAt = System.currentTimeMillis(),
80
                updatedAt = System.currentTimeMillis()
81
            )
82
        }
83
    }
84
}

UI Migration: Views to Compose#

Migrating Fragment to Compose#

1
// Legacy Fragment
2
class LegacyTasksFragment : Fragment() {
3

4
    private var _binding: FragmentTasksBinding? = null
5
    private val binding get() = _binding!!
6

7
    private lateinit var viewModel: TasksViewModel
8
    private lateinit var adapter: TasksAdapter
9

10
    override fun onCreateView(
11
        inflater: LayoutInflater,
12
        container: ViewGroup?,
13
        savedInstanceState: Bundle?
14
    ): View {
15
        _binding = FragmentTasksBinding.inflate(inflater, container, false)
16
        return binding.root
17
    }
18

19
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
20
        super.onViewCreated(view, savedInstanceState)
21

22
        setupRecyclerView()
23
        setupFab()
24
        observeViewModel()
25
    }
26

27
    private fun setupRecyclerView() {
28
        adapter = TasksAdapter { task ->
29
            viewModel.completeTask(task.id)
30
        }
31
        binding.tasksList.adapter = adapter
32
    }
33

34
    private fun observeViewModel() {
35
        viewModel.tasks.observe(viewLifecycleOwner) { tasks ->
36
            adapter.submitList(tasks)
37
        }
38

39
        viewModel.loading.observe(viewLifecycleOwner) { isLoading ->
40
            binding.progressBar.visibility = if (isLoading) View.VISIBLE else View.GONE
41
        }
42
    }
43
}
44

45
// Hybrid Migration: Compose in Fragment
46
class ModernTasksFragment : Fragment() {
47

48
    override fun onCreateView(
49
        inflater: LayoutInflater,
50
        container: ViewGroup?,
51
        savedInstanceState: Bundle?
52
    ): View {
53
        return ComposeView(requireContext()).apply {
54
            setContent {
55
                TodoTheme {
56
                    TasksScreen()
57
                }
58
            }
59
        }
60
    }
61
}
62

63
// Full Compose Migration
64
@Composable
65
fun TasksScreen(
66
    viewModel: TasksViewModel = hiltViewModel()
67
) {
68
    val uiState by viewModel.uiState.collectAsState()
69

70
    Box(modifier = Modifier.fillMaxSize()) {
71
        when {
72
            uiState.isLoading -> {
73
                CircularProgressIndicator(
74
                    modifier = Modifier.align(Alignment.Center)
75
                )
76
            }
77
            uiState.tasks.isEmpty() -> {
78
                EmptyTasksContent(
79
                    modifier = Modifier.align(Alignment.Center)
80
                )
81
            }
82
            else -> {
83
                TasksList(
84
                    tasks = uiState.tasks,
85
                    onTaskClick = viewModel::completeTask,
86
                    modifier = Modifier.fillMaxSize()
87
                )
88
            }
89
        }
90

91
        FloatingActionButton(
92
            onClick = { /* Navigate to add task */ },
93
            modifier = Modifier
94
                .align(Alignment.BottomEnd)
95
                .padding(16.dp)
96
        ) {
97
            Icon(Icons.Default.Add, contentDescription = "Add task")
98
        }
99
    }
100
}

Gradual Compose Adoption Strategy#

1
// Phase 1: Compose Views within existing layouts
2
class HybridTasksActivity : AppCompatActivity() {
3

4
    override fun onCreate(savedInstanceState: Bundle?) {
5
        super.onCreate(savedInstanceState)
6
        setContentView(R.layout.activity_hybrid_tasks)
7

8
        // Replace specific views with Compose
9
        findViewById<ViewGroup>(R.id.compose_container).apply {
10
            addView(
11
                ComposeView(this@HybridTasksActivity).apply {
12
                    setContent {
13
                        TasksFilterBar(
14
                            currentFilter = TasksFilterType.ALL_TASKS,
15
                            onFilterSelected = { /* Handle filter */ }
16
                        )
17
                    }
18
                }
19
            )
20
        }
21

22
        // Keep existing RecyclerView for now
23
        setupRecyclerView()
24
    }
25

26
    private fun setupRecyclerView() {
27
        // Existing RecyclerView setup
28
        findViewById<RecyclerView>(R.id.tasks_recycler_view).apply {
29
            adapter = TasksAdapter { task ->
30
                // Handle task interactions
31
            }
32
        }
33
    }
34
}
35

36
// Phase 2: Compose-first with View interop
37
@Composable
38
fun HybridTasksScreen() {
39
    Column {
40
        // New Compose UI
41
        TasksHeader()
42
        TasksFilterBar(
43
            currentFilter = TasksFilterType.ALL_TASKS,
44
            onFilterSelected = { /* Handle filter */ }
45
        )
46

47
        // Legacy RecyclerView wrapped in AndroidView
48
        AndroidView(
49
            factory = { context ->
50
                RecyclerView(context).apply {
51
                    layoutManager = LinearLayoutManager(context)
52
                    adapter = TasksAdapter { task ->
53
                        // Handle task click
54
                    }
55
                }
56
            },
57
            modifier = Modifier.weight(1f)
58
        ) { recyclerView ->
59
            // Update RecyclerView when needed
60
        }
61
    }
62
}
63

64
// Phase 3: Full Compose implementation
65
@Composable
66
fun FullComposeTasksScreen(
67
    viewModel: TasksViewModel = hiltViewModel()
68
) {
69
    val uiState by viewModel.uiState.collectAsState()
70

71
    LazyColumn {
72
        item {
73
            TasksHeader()
74
        }
75

76
        item {
77
            TasksFilterBar(
78
                currentFilter = uiState.currentFilter,
79
                onFilterSelected = viewModel::setFilter
80
            )
81
        }
82

83
        items(uiState.tasks, key = { it.id }) { task ->
84
            TaskItem(
85
                task = task,
86
                onTaskClick = { viewModel.completeTask(it.id) },
87
                onTaskLongClick = { /* Show context menu */ }
88
            )
89
        }
90
    }
91
}

1
// Legacy Fragment Navigation
2
class LegacyNavigationActivity : AppCompatActivity() {
3

4
    override fun onCreate(savedInstanceState: Bundle?) {
5
        super.onCreate(savedInstanceState)
6
        setContentView(R.layout.activity_main)
7

8
        if (savedInstanceState == null) {
9
            supportFragmentManager.beginTransaction()
10
                .replace(R.id.container, TasksFragment.newInstance())
11
                .commit()
12
        }
13
    }
14

15
    fun navigateToAddTask() {
16
        supportFragmentManager.beginTransaction()
17
            .replace(R.id.container, AddTaskFragment.newInstance())
18
            .addToBackStack(null)
19
            .commit()
20
    }
21

22
    fun navigateToTaskDetail(taskId: String) {
23
        supportFragmentManager.beginTransaction()
24
            .replace(R.id.container, TaskDetailFragment.newInstance(taskId))
25
            .addToBackStack(null)
26
            .commit()
27
    }
28
}
29

30
// Modern Compose Navigation
31
@Composable
32
fun TodoNavHost(
33
    navController: NavHostController = rememberNavController()
34
) {
35
    NavHost(
36
        navController = navController,
37
        startDestination = TodoDestinations.TASKS_ROUTE
38
    ) {
39
        composable(TodoDestinations.TASKS_ROUTE) {
40
            TasksScreen(
41
                onAddTask = {
42
                    navController.navigate(TodoDestinations.ADD_EDIT_TASK_ROUTE)
43
                },
44
                onTaskClick = { taskId ->
45
                    navController.navigate(
46
                        "${TodoDestinations.TASK_DETAIL_ROUTE}/$taskId"
47
                    )
48
                }
49
            )
50
        }
51

52
        composable(TodoDestinations.ADD_EDIT_TASK_ROUTE) {
53
            AddEditTaskScreen(
54
                onTaskSave = {
55
                    navController.popBackStack()
56
                },
57
                onBack = {
58
                    navController.popBackStack()
59
                }
60
            )
61
        }
62

63
        composable(
64
            route = "${TodoDestinations.TASK_DETAIL_ROUTE}/{$TASK_ID_ARG}",
65
            arguments = listOf(navArgument(TASK_ID_ARG) { type = NavType.StringType })
66
        ) { backStackEntry ->
67
            val taskId = backStackEntry.arguments?.getString(TASK_ID_ARG)
68
            TaskDetailScreen(
69
                taskId = taskId,
70
                onEditTask = {
71
                    navController.navigate("${TodoDestinations.ADD_EDIT_TASK_ROUTE}/$taskId")
72
                },
73
                onBack = {
74
                    navController.popBackStack()
75
                }
76
            )
77
        }
78
    }
79
}

Testing During Migration#

Migration Testing Strategy#

1
// Test both old and new implementations
2
@RunWith(Parameterized::class)
3
class MigrationTasksRepositoryTest(
4
    private val repositoryFactory: () -> TasksRepository
5
) {
6

7
    companion object {
8
        @JvmStatic
9
        @Parameterized.Parameters
10
        fun repositories() = listOf(
11
            arrayOf<() -> TasksRepository>({ LegacyTasksRepository() }),
12
            arrayOf<() -> TasksRepository>({ ModernTasksRepository() })
13
        )
14
    }
15

16
    private lateinit var repository: TasksRepository
17

18
    @Before
19
    fun setup() {
20
        repository = repositoryFactory()
21
    }
22

23
    @Test
24
    fun saveTask_retrievesTask() = runTest {
25
        // Test works for both implementations
26
        val task = Task(id = "1", title = "Test Task")
27
        repository.saveTask(task)
28

29
        val retrieved = repository.getTask("1")
30
        assertEquals(task.title, retrieved.title)
31
    }
32
}
33

34
// Feature flag testing
35
class MigrationFeatureFlagTest {
36

37
    @Test
38
    fun legacyFlow_whenFeatureFlagDisabled() {
39
        // Given
40
        val featureFlags = mockk<FeatureFlags>()
41
        every { featureFlags.isEnabled("new_tasks_implementation") } returns false
42

43
        // When
44
        val component = TasksComponent(featureFlags)
45

46
        // Then
47
        assertTrue(component.repository is LegacyTasksRepository)
48
    }
49

50
    @Test
51
    fun modernFlow_whenFeatureFlagEnabled() {
52
        // Given
53
        val featureFlags = mockk<FeatureFlags>()
54
        every { featureFlags.isEnabled("new_tasks_implementation") } returns true
55

56
        // When
57
        val component = TasksComponent(featureFlags)
58

59
        // Then
60
        assertTrue(component.repository is ModernTasksRepository)
61
    }
62
}

Performance Monitoring During Migration#

Migration Metrics Collection#

1
// Migration performance monitoring
2
class MigrationMetrics @Inject constructor(
3
    private val analytics: Analytics,
4
    private val performanceCollector: PerformanceCollector
5
) {
6

7
    fun trackScreenLoadTime(screen: String, isLegacy: Boolean, duration: Long) {
8
        analytics.track("screen_load_time", mapOf(
9
            "screen" to screen,
10
            "implementation" to if (isLegacy) "legacy" else "modern",
11
            "duration_ms" to duration
12
        ))
13
    }
14

15
    fun trackMemoryUsage(screen: String, isLegacy: Boolean) {
16
        val memoryInfo = performanceCollector.getMemoryInfo()
17
        analytics.track("memory_usage", mapOf(
18
            "screen" to screen,
19
            "implementation" to if (isLegacy) "legacy" else "modern",
20
            "heap_used_mb" to memoryInfo.heapUsedMB,
21
            "heap_max_mb" to memoryInfo.heapMaxMB
22
        ))
23
    }
24

25
    fun trackCrash(error: Throwable, isLegacy: Boolean) {
26
        analytics.track("migration_crash", mapOf(
27
            "implementation" to if (isLegacy) "legacy" else "modern",
28
            "error_type" to error::class.java.simpleName,
29
            "error_message" to error.message
30
        ))
31
    }
32
}
33

34
// Performance comparison wrapper
35
class PerformanceAwareTasksScreen @Composable() {
36

37
    @Composable
38
    operator fun invoke(migrationMetrics: MigrationMetrics) {
39
        val startTime = remember { System.currentTimeMillis() }
40

41
        // Track when screen is fully composed
42
        LaunchedEffect(Unit) {
43
            val loadTime = System.currentTimeMillis() - startTime
44
            migrationMetrics.trackScreenLoadTime("tasks", false, loadTime)
45
            migrationMetrics.trackMemoryUsage("tasks", false)
46
        }
47

48
        TasksScreen()
49
    }
50
}

Migration Best Practices#

Rollback Strategy#

1
// Circuit breaker pattern for migration rollback
2
class MigrationCircuitBreaker(
3
    private val featureFlags: FeatureFlags,
4
    private val analytics: Analytics
5
) {
6
    private var failureCount = 0
7
    private var lastFailureTime = 0L
8
    private val maxFailures = 5
9
    private val timeout = TimeUnit.MINUTES.toMillis(10)
10

11
    fun shouldUseModernImplementation(): Boolean {
12
        return when (getState()) {
13
            CircuitState.CLOSED -> true // Use modern implementation
14
            CircuitState.OPEN -> {
15
                analytics.track("migration_circuit_open")
16
                false // Fall back to legacy
17
            }
18
            CircuitState.HALF_OPEN -> {
19
                // Gradually test modern implementation
20
                Random.nextFloat() < 0.1f
21
            }
22
        }
23
    }
24

25
    fun recordSuccess() {
26
        failureCount = 0
27
    }
28

29
    fun recordFailure() {
30
        failureCount++
31
        lastFailureTime = System.currentTimeMillis()
32

33
        if (failureCount >= maxFailures) {
34
            analytics.track("migration_circuit_breaker_triggered", mapOf(
35
                "failure_count" to failureCount
36
            ))
37
        }
38
    }
39

40
    private fun getState(): CircuitState {
41
        return when {
42
            failureCount < maxFailures -> CircuitState.CLOSED
43
            System.currentTimeMillis() - lastFailureTime > timeout -> CircuitState.HALF_OPEN
44
            else -> CircuitState.OPEN
45
        }
46
    }
47
}

Data Consistency During Migration#

1
// Dual write strategy during migration
2
class DualWriteTasksRepository @Inject constructor(
3
    private val legacyRepository: LegacyTasksRepository,
4
    private val modernRepository: ModernTasksRepository,
5
    private val featureFlags: FeatureFlags,
6
    private val migrationMetrics: MigrationMetrics
7
) : TasksRepository {
8

9
    override suspend fun saveTask(task: Task) {
10
        val errors = mutableListOf<Exception>()
11

12
        // Write to legacy first (source of truth during migration)
13
        try {
14
            legacyRepository.saveTask(task)
15
        } catch (e: Exception) {
16
            errors.add(e)
17
            migrationMetrics.trackError("legacy_save_failed", e)
18
        }
19

20
        // Write to modern repository if enabled
21
        if (featureFlags.isEnabled("dual_write_modern")) {
22
            try {
23
                modernRepository.saveTask(task)
24
            } catch (e: Exception) {
25
                errors.add(e)
26
                migrationMetrics.trackError("modern_save_failed", e)
27
                // Don't fail the operation for modern repository errors during migration
28
            }
29
        }
30

31
        // Fail only if legacy write fails
32
        if (errors.isNotEmpty() && errors[0] is Exception) {
33
            throw errors[0]
34
        }
35
    }
36

37
    override suspend fun getTask(taskId: String): Task {
38
        return if (featureFlags.isEnabled("read_from_modern")) {
39
            try {
40
                modernRepository.getTask(taskId)
41
            } catch (e: Exception) {
42
                migrationMetrics.trackError("modern_read_fallback", e)
43
                legacyRepository.getTask(taskId)
44
            }
45
        } else {
46
            legacyRepository.getTask(taskId)
47
        }
48
    }
49
}

Conclusion#

Migrating legacy Android applications to modern architecture requires careful planning, incremental implementation, and comprehensive testing. Key strategies include:

Incremental Migration: Use feature flags and gradual rollouts
Dual Implementation: Run old and new systems in parallel during transition
Performance Monitoring: Track metrics to ensure migration improves performance
Rollback Strategy: Implement circuit breakers for quick fallback to legacy code
Data Consistency: Use dual-write strategies during data layer migration
Testing: Comprehensive testing of both legacy and modern implementations

By following these migration patterns, you can modernize your Android applications while minimizing risk and maintaining stability for your users. Remember that migration is a journey, not a destination—take it one step at a time and measure your progress along the way.

The goal is not just to update your technology stack, but to improve code maintainability, developer productivity, and user experience in the long run.