SDK Extensions leverage[modular system components](https://source.android.com/docs/core/ota/modular-system)to add APIs to the public SDK for certain previously released API levels. These APIs are delivered to devices when end-users receive module updates through[Google Play system updates](https://support.google.com/product-documentation/answer/11462338). App developers can utilize these APIs in their apps to provide additional functionality that wasn't originally available in the SDK for these previous versions of Android.

## API Versioning

Starting with Android 11 (API level 30), Android devices include a set of SDK Extensions. When new APIs are added, they are included in an API level, but may also be included in an SDK extension of a particular version. For example, the[`ACTION_PICK_IMAGES`](https://developer.android.com/reference/android/provider/MediaStore#ACTION_PICK_IMAGES)API for Photo Picker was added to the public SDK in Android 13 (API level 33), but is also available through SDK extensions starting in R Extensions Version 2.[SDK Extension names](https://developer.android.com/guide/sdk-extensions#extension-names)correspond to an integer constant--either a constant from[`Build.VERSION_CODES`](https://developer.android.com/reference/android/os/Build.VERSION_CODES), or one defined in the`SdkExtensions`class (such as[`SdkExtensions.AD_SERVICES`](https://developer.android.com/reference/android/os/ext/SdkExtensions#AD_SERVICES)).

## Determine which SDK Extensions to use

Before you can use SDK Extension APIs, you first need to determine which SDKs include the APIs that support your app's use cases.

The API reference pages for SDK Extension APIs specify the earliest SDK extension version that your app can use to access an API. If the documentation also specifies an Android platform version (referenced by API level), then that API is also available for all devices running that version of Android or higher.

For example,`ACTION_PICK_IMAGES`is available generally in the public SDK starting with Android 13 (API level 33), but is also available on devices as far back as Android 11 (API level 30) so long as the device has at least R Extensions Version 2:

![APIs that are part of SDK Extensions show their extension version in the API reference docs](https://developer.android.com/static/images/guide/sdk-extensions/extension-version.png)

To use this API, you need to compile against an SDK that is at least API level 33, or Extension Level at least 2.

To use an extension SDK, follow these steps:

1. Look up the minimum extensions version that you need by checking the feature documentation and API reference for the APIs that you want to use.
2. After you determine the required extension version for your feature set, open the SDK Manager in Android Studio.
3. Select the Android SDK Platform entry with the corresponding extension version (or a higher version, as the APIs are additive). For example: Android SDK Platform 33, Extension Level 4.
4. Declare these values in your app's`build.gradle.kts`or`build.gradle`file:

   ### Groovy

   ```groovy
   android {
       compileSdk 33
       compileSdkExtension 4
       ...
   }
   ```

   ### Kotlin

   ```kotlin
   android {
       compileSdk = 33
       compileSdkExtension = 4
       ...
   }
   ```

## Check whether SDK Extensions are available

Your app can check what SDK Extension versions are available at runtime, and while developing you can look up the extension versions using Android Debug Bridge (adb) commands, as described in the following sections.

### Check at runtime

Your app can check at runtime whether SDK Extensions are available for a given platform version using the[`getExtensionVersion()`](https://developer.android.com/reference/android/os/ext/SdkExtensions#getExtensionVersion(int))method. For example, the following code would check whether extension version 2 or higher for the Android 11 (API level 30) SDK Extension is available:  

### Kotlin

```kotlin
fun isPhotoPickerAvailable(): Boolean {
    return SdkExtensions.getExtensionVersion(Build.VERSION_CODES.R) >= 2
    // Safely use extension APIs that are available with Android 11 (API level 30) Extensions Version 2, such as Photo Picker.
}
```

### Java

```java
public static final boolean isPhotoPickerAvailable() {
    return SdkExtensions.getExtensionVersion(Build.VERSION_CODES.R) >= 2;
}
```

This is similar to doing a check based on[`Build.VERSION.SDK_INT`](https://developer.android.com/reference/android/os/Build.VERSION#SDK_INT):  

### Kotlin

```kotlin
fun isPhotoPickerAvailable(): Boolean {
    return Build.VERSION.SDK_INT >= 33
}
```

### Java

```java
public static final boolean isPhotoPickerAvailable() {
    return Build.VERSION.SDK_INT >= 33;
}
```

This`SDK_INT`check is still safe and valid, but`isPhotoPickerAvailable`would return false on some devices even though the extension API is available. As a result, the`SDK_INT`check is not optimal, and the extension version check is a better way to check for API availability. All devices with`SDK_INT`greater than or equal to`33`(Android 13 or higher) have the Photo Picker APIs in the public SDK, but there are devices with`SDK_INT`less than 33 (such as Android 11, 12, and 12L) that could also access the APIs if they have R extension versions of at least`2`.

In this case, using an extension version check can help your app deliver additional functionality to more users. See[SDK Extension names and constants](https://developer.android.com/guide/sdk-extensions#extension-names)for a list of all the constants that you can use to check for certain SDK Extensions on a device.

#### Ad Services Extensions

Similar to the general set of SDK Extensions, the`AdServices`API reference sometimes indicates that an API is part of an "Ad Services Extensions" version. Unlike the general SDK Extensions, Ad Services Extensions use the`SdkExtensions.AD_SERVICES`constant to determine which version is on a device:  

### Kotlin

```kotlin
fun isAdServicesAvailable(): Boolean {
    return SdkExtensions.getExtensionVersion(SdkExtensions.AD_SERVICES) >= 4
}
```

### Java

```java
public static final boolean isAdServicesAvailable() {
    return SdkExtensions.getExtensionVersion(SdkExtensions.AD_SERVICES) >= 4;
}
```

To learn more about the features in Ad Services Extensions and how to get started, see the[Ad Services Extensions documentation](https://developer.android.com/design-for-safety/privacy-sandbox/program-overview).

#### Utility methods

In some cases, SDK Extensions have Jetpack utility methods for checking the availability of their SDK Extension APIs. For example, you can use a[Jetpack library function to check for PhotoPicker availability](https://developer.android.com/reference/kotlin/androidx/activity/result/contract/ActivityResultContracts.PickVisualMedia#isPhotoPickerAvailable(android.content.Context)), which abstracts away the conditional version checks.

#### Tools support

In Android Studio Flamingo \| 2022.2.1 or higher, the lint tool can scan for issues with SDK Extension versions as part of its NewAPI check. In addition, Android Studio can auto-generate the correct version checks for APIs that are launched using SDK Extensions.
![](https://developer.android.com/static/images/guide/sdk-extensions/extensions-lint-check.png)The lint tool flags instances where the minimum SDK Extensions version required to call an API has not been met.

#### SDK Extension names and constants

The following table describes how the different sets of SDK Extensions that are listed in API reference documentation map to constants that your app can use to check for API availability at runtime. The general set of SDK Extensions for each public SDK maps to values of[`Build.VERSION_CODES`](https://developer.android.com/reference/android/os/Build.VERSION_CODES).

|   SDK Extension name   |             Constant              |           Eligible devices           |
|------------------------|-----------------------------------|--------------------------------------|
| R Extensions           | `VERSION_CODES.R`                 | Android 11 (API Level 30) and higher |
| S Extensions           | `VERSION_CODES.S`                 | Android 12 (API Level 31) and higher |
| T Extensions           | `VERSION_CODES.TIRAMISU`          | Android 13 (API level 33) and higher |
| U Extensions           | `VERSION_CODES.UPSIDE_DOWN_CAKE`  | Android 14 (API level 34) and higher |
| V Extensions           | `VERSION_CODES.VANILLA_ICE_CREAM` | Android 15 (API level 35) and higher |
| Ad Services Extensions | `SdkExtensions.AD_SERVICES`       | Android 13 (API level 33) and higher |

### Check using adb

To check which SDK Extensions are available on a device using adb, run the following command:  

```
adb shell getprop | grep build.version.extensions
```

After running the command, you'll see output that looks similar to this:  

    [build.version.extensions.r]: [3] # Android 11 (API level 30) and higher
    [build.version.extensions.s]: [3] # Android 12 (API level 31) and higher
    [build.version.extensions.t]: [3] # Android 13 (API level 33) and higher

Each line shows an SDK Extension that's present on the device along with their corresponding extensions version (3 in this case).