AndroidX: What It Is, Key Libraries, and Migration

What is AndroidX

AndroidX is an open-source library that is part of Android Jetpack. Google released AndroidX in 2018 as a replacement for Support Library, which had been providing backward-compatible components for older Android versions since 2011.

Before AndroidX, each Support Library component had its own version tied to the targetSdkVersion. Developers had to include multiple versions of the same library simultaneously, leading to dependency conflicts and increased APK size.

AndroidX solved this problem through semantic versioning (SemVer). Now each library is a separate Gradle artifact with a version in MAJOR.MINOR.PATCH format. Developers can update Room from 2.4.0 to 2.6.0 without touching Activity, Fragment, or other modules.

History of AndroidX

The first stable release of AndroidX 1.0.0 came in December 2018 alongside Android 9 Pie. Google announced that Support Library was entering maintenance mode and all new components — Navigation, WorkManager, Compose — would be released only as part of AndroidX. The last Support Library version — 28.0.0 — was released in 2019.

According to Google I/O 2019, the key reason for the transition was the need to accelerate update releases. In the old model, one library had to wait for another due to a single package version. AndroidX removed this bottleneck, and Jetpack began receiving major and minor releases every 2–3 months.

Differences Between AndroidX and Support Library

The main difference is the namespace. Support Library used the android.support.* package, while AndroidX moved to androidx.*. This change allowed splitting libraries into functional modules. For example, Fragment in Support Library was called android.support.v4.app.Fragment, while in AndroidX it is androidx.fragment.app.Fragment.

The second important difference is architecture. AndroidX ships with Jetpack — a set of app architecture recommendations. Jetpack includes ViewModel, LiveData, Room, Navigation, and WorkManager, which were designed as a unified ecosystem rather than scattered utilities.

Backward compatibility also improved. While Support Library supported Android 2.3+, AndroidX guarantees operation on devices with Android 4.0 (API 14) and above — covering over 99% of active devices according to Google Play Console 2024.

AndroidX Library Composition

AndroidX includes over 100 libraries grouped by category. Each group covers a specific area: UI, data, navigation, background tasks, multimedia, and testing. Below is an overview of the key modules.

Core and Base Libraries

androidx.core:core is the base library containing backward-compatible versions of system APIs: NotificationCompat, ActivityCompat, ContextCompat. The core-ktx module provides Kotlin extensions for working with files, SharedPreferences, and view elements.

The androidx.activity:activity library introduced the Activity Result API (registerForActivityResult), replacing the deprecated startActivityForResult. The fragment:fragment module manages the fragment lifecycle and supports FragmentManager for transactions and back stack.

androidx.lifecycle is the foundation of Jetpack architecture. LifecycleOwner and LifecycleObserver allow components to react to Activity or Fragment lifecycle changes. ViewModel preserves data during screen rotation, while LiveData notifies the UI of data changes.

class MainViewModel : ViewModel() {
    private val _users = MutableLiveData<List<User>>()
    val users: LiveData<List<User>> = _users

    fun loadUsers() {
        viewModelScope.launch {
            val result = repository.getUsers()
            _users.value = result
        }
    }
}

UI Libraries

androidx.recyclerview:recyclerview is a powerful component for displaying lists and grids. RecyclerView supports LayoutManager (LinearLayoutManager, GridLayoutManager), ItemDecoration, and animations via ItemAnimator. The ListAdapter with AsyncListDiffer simplifies list updates with automatic diff calculation.

androidx.navigation:navigation is a library for navigating between screens. The Navigation Component works with NavHostFragment and NavController, supports Safe Args for typed parameter passing, and Deep Links for external links. NavGraph describes all routes in an XML file.

androidx.compose.ui is a declarative UI framework, Jetpack Compose, built on Kotlin. Unlike the View system, Compose only redraws changed elements through recomposition. Material Design 3 components (Button, TextField, Scaffold) are available in the material3 module.

Data Libraries

androidx.room:room is an ORM for local data storage. Room generates DAO classes from annotated SQLite queries, validates SQL syntax at compile time, and supports RxJava and Kotlin Flow. Version 2.6 includes KSP support for faster code generation.

androidx.work:workmanager is a library for guaranteed background task execution. WorkManager supports periodic tasks, work chains (beginWith, then), and launch criteria (Constraints: network, charging, storage). Even if the app is closed, WorkManager delivers the task after device reboot.

androidx.datastore:datastore is a modern replacement for SharedPreferences. DataStore uses Kotlin Coroutines and Flow, works synchronously and asynchronously, preventing UI thread blocking. Preferences DataStore stores simple key-value pairs, while Proto DataStore handles typed objects via Protocol Buffers.

How to Migrate to AndroidX

Automatic migration is Google's recommended way to transition from Support Library to AndroidX. Android Studio since version 3.2 includes the built-in Refactor Migrate to AndroidX tool, which replaces namespaces and updates dependencies in build.gradle.

Before migration, you need to update the compileSdk version to 28 or higher. Also ensure that all third-party libraries support AndroidX. If a dependency hasn't migrated yet, use the android.enableJetifier=true flag in gradle.properties — it automatically rewrites the bytecode of third-party libraries.

Automatic Migration in Android Studio

In Android Studio, select Refactor Migrate to AndroidX from the menu. The IDE will scan the entire project, find all imports from the android.support.* package, and replace them with androidx.*. Dependencies in app/build.gradle will also be updated — Support Library artifacts will be replaced with corresponding AndroidX versions.

After migration, Gradle Sync may show errors if some dependencies were not found. Check the list of used libraries in the Google Maven documentation — all AndroidX artifacts are published on google(). If a library is unavailable, add mavenCentral() to repositories.

android {
    compileSdk 34
}

dependencies {
    // Support Library (deprecated)
    // implementation 'com.android.support:appcompat-v7:28.0.0'
    
    // AndroidX
    implementation 'androidx.core:core-ktx:1.13.1'
    implementation 'androidx.appcompat:appcompat:1.7.0'
    implementation 'androidx.activity:activity-ktx:1.9.3'
    implementation 'androidx.fragment:fragment-ktx:1.8.5'
    implementation 'androidx.recyclerview:recyclerview:1.3.2'
    implementation 'androidx.room:room-runtime:2.6.1'
    ksp 'androidx.room:room-compiler:2.6.1'
}

Manual Migration

If the project is too large or contains custom Views from Support Library, automatic replacement may be incomplete. Manually replace all strings in the code: change imports, XML attributes (app/src/main/res), and manifest references. For Support Library attributes, the android: prefix changes to app: (e.g., app:cardCornerRadius instead of android:cardCornerRadius).

After manual migration, check R-references. Support Library exported resources through android.support.v7.appcompat.R, while AndroidX uses androidx.appcompat.R. Search the project and replace all references to old R paths. The project build should complete without errors or deprecation warnings.

Benefits of Using AndroidX

The first advantage of AndroidX is modularity. You only include the libraries you actually use. If your app only needs RecyclerView and Navigation, there's no need to pull in the entire Support Library with all View components. This reduces APK size and speeds up build time.

The second advantage is regular updates. Jetpack releases stable versions every 1–3 months. Room 2.6.0, released in 2024, added KSP support and Kotlin 2.0 compatibility. Navigation 2.8.0 introduced type-safe routes based on Kotlinx Serialization. Developers get new features without waiting for the next Android version.

The third advantage is Kotlin integration. All AndroidX libraries have -ktx modules with extension functions. viewLifecycleOwner.lifecycleScope launches coroutines in the fragment context, collectLatest processes Flow, and SharedFlow and StateFlow are fully compatible with lifecycle-aware components. This makes code more concise and safer.

Backward compatibility is a key advantage of AndroidX over new platform APIs. You can use AppCompatDelegate.setDefaultNightMode for dark theme on Android 4.0+, NotificationCompat.setBubble for bubbles on Android 5.0+, and LocationRequestCompat for fused location on Android 4.0+. Device coverage reaches 99% without increasing the minimum SDK version.

The fourth advantage is testing. AndroidX includes the androidx.test library for writing instrumented and unit tests. FragmentScenario and ActivityScenario allow testing UI components in isolation, while TestNavHostController enables navigation verification without running a real device. MockK and Robolectric complete the ecosystem.