Migrating Legacy Android Apps to Modern Architecture

Refactoring Legacy Apps covers safe, local refactoring techniques. This article is the bigger picture: a sequenced migration from a legacy stack to modern Android architecture, without a rewrite.

From where to where

The strangler approach

The migration sequence

1. Foundations: update Gradle, AGP and dependencies; enable Kotlin; add crash reporting and CI with tests. See CI/CD.
2. Safety net: characterization tests around critical flows (login, checkout), plus a few UI smoke tests.
3. Data layer first: introduce repositories that wrap existing data code, so screens stop talking to databases and network directly.
4. ViewModels: move screen logic out of Activities/Fragments, starting with the most-changed screens.
5. Async: replace AsyncTask/callbacks with coroutines at the repository boundary.
6. DI: add Hilt and migrate singletons gradually.
7. UI: new screens in Compose; migrate existing screens when they need significant changes.
8. Storage: Room and DataStore migrations with data-migration tests.

Example: wrapping a callback API

// Legacy Java API: LegacyApi.fetchUser(id, Callback<User>)
class UserRepository @Inject constructor(private val legacy: LegacyApi) {

    suspend fun getUser(id: String): User = suspendCancellableCoroutine { cont ->
        val call = legacy.fetchUser(id, object : LegacyApi.Callback<User> {
            override fun onSuccess(user: User) { cont.resume(user) }
            override fun onError(t: Throwable) { cont.resumeWithException(t) }
        })
        cont.invokeOnCancellation { call.cancel() }   // propagate cancellation
    }
}
// Screens now call repository.getUser() from a ViewModel; LegacyApi can be replaced later.

Compose interop during migration

class OrdersFragment : Fragment() {
    private val viewModel: OrdersViewModel by viewModels()

    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, s: Bundle?) =
        ComposeView(requireContext()).apply {
            setViewCompositionStrategy(ViewCompositionStrategy.DisposeOnViewTreeLifecycleDestroyed)
            setContent { AppTheme { OrdersScreen(viewModel) } }
        }
}

Keep the Fragment and navigation for now, and replace the UI inside. Migrate navigation later. See XML to Compose with AI.

Measure progress meaningfully

• Crash-free rate and ANR rate in migrated areas.
• Lead time for changes in migrated vs legacy features.
• Test coverage on critical flows.
• Avoid vanity metrics like "% Kotlin files" as the main goal.

Pitfalls

Frequently asked questions

Conclusion

Migrate incrementally: foundations and tests first, then repositories, ViewModels, coroutines, Hilt, Compose and modern storage, shipping every step and measuring outcomes that matter.

Next step: learn how senior engineers make these decisions in Engineering Trade-offs in Android.