How to Determine the Version of Android SDK Installed on a Computer

Overview of Android SDK Version Identification Methods

Accurately identifying the installed Android SDK version is fundamental to ensuring project compatibility and development efficiency in Android application development. Developers need to understand the available API levels and tool versions in their environment to properly configure build targets and dependencies. This article systematically introduces multiple practical methods for determining Android SDK versions in Windows operating systems.

Checking SDK Version Through File System Paths

The most direct method for version identification is by inspecting the platforms folder within the Android SDK installation directory. In Windows systems, the SDK is typically installed in specific program files directories, with exact paths depending on system architecture and installation type.

For 32-bit operating systems, the default SDK installation path is:

C:\Program Files\Android\Android-sdk\platforms\

In 64-bit system environments, path selection becomes more complex:

• If 32-bit ADT (Android Development Tools) is installed, the path is: C:\Program Files (x86)\Android\Android-sdk\platforms\
• If 64-bit ADT is installed, the path is: C:\Program Files\Android\Android-sdk\platforms\

Upon entering the platforms directory, you can see folders named with "android-" prefixes, such as "android-33", "android-31", etc. These folder names directly correspond to specific API levels. Each folder contains framework libraries, resource files, and system images for the respective version.

Querying SDK Information Using Command-Line Tools

Beyond manual file path inspection, Android SDK provides powerful command-line tools to obtain detailed version information. The android list target command lists all available Android platform targets.

Open Command Prompt or PowerShell, navigate to the Android SDK tools directory, and execute the following command:

android list target

This command outputs information in a format similar to:

Available Android targets:
----------
id: 1 or "android-33"
     Name: Android API 33
     Type: Platform
     API level: 33
     Revision: 1
     Skins: HVGA, QVGA, WQVGA400, WQVGA432, WSVGA, WXGA720, WXGA800, WXGA800-7in
----------
id: 2 or "android-31"
     Name: Android API 31
     Type: Platform
     API level: 31
     Revision: 1

The output clearly displays each available platform's ID, name, API level, and revision version. This method is particularly suitable for use in automated scripts or continuous integration environments.

Viewing Through Android Studio Integrated Environment

For developers using Android Studio, the IDE provides a more intuitive version management interface. SDK information can be accessed through multiple methods:

Method 1: Through project structure settings

File > Project Structure > SDK Location > Android SDK Location

Method 2: Using the SDK Manager

Tools > Android > SDK Manager

The SDK Manager not only displays installed SDK versions but also provides complete package management functionality, including:

• SDK Platforms: Platform packages for various API levels
• SDK Tools: Build tools, platform tools, and command-line tools
• System Images: Emulator system images
• Google Play services: Google API libraries and samples

In the SDK Manager, installed packages display version numbers and status, packages awaiting updates show download icons, and packages marked for removal display red X marks.

Inspecting SDK Tool Property Files

Another precise method for obtaining version information is by examining property files within the SDK directory. In the Android SDK tools directory, there exists a source.properties file that contains detailed version metadata.

Example file path:

C:\<android sdk path>\tools\source.properties

Opening this file with a text editor reveals content similar to:

Pkg.Desc=Android SDK Tools
Pkg.Revision=26.1.1
Pkg.SourceUrl=https://dl.google.com/android/repository/tools_r26.1.1-windows.zip

The Pkg.Revision field explicitly indicates the SDK tools version number. This method is particularly valuable for precise version control and dependency management.

Practical Recommendations for SDK Version Management

Based on content from the reference article regarding SDK tool updates, developers should establish systematic version management strategies:

First, regularly check for updates using the SDK Manager. Android Studio automatically detects available updates and notifies users through bubble dialogs. Manual checking path is: File > Settings > Appearance & Behavior > System Settings > Updates (on macOS: Android Studio > Check for Updates).

Second, understand different release channels:

• Canary channel: Bleeding-edge releases updated roughly weekly, containing latest features but potentially more bugs
• RC channel: Release candidates based on stable Canary builds
• Stable channel: Official stable releases suitable for production development

For non-graphical interface environments, such as continuous integration servers, use the sdkmanager command-line tool for version management:

sdkmanager --list
sdkmanager --update
sdkmanager --licenses

These commands respectively list available packages, update installed packages, and accept license agreements.

Version Compatibility and Build Configuration

After correctly identifying SDK versions, developers need to appropriately set target API levels in project build configurations. It's recommended to use the latest stable version as the compilation target while configuring appropriate minSdkVersion in build.gradle files to ensure backward compatibility.

Example configuration:

android {
    compileSdkVersion 33
    defaultConfig {
        minSdkVersion 21
        targetSdkVersion 33
    }
}

This configuration allows applications to fully utilize new features on the latest devices while maintaining compatibility with older Android versions.

Conclusion

Determining Android SDK versions is fundamental work in Android development. The file path inspection, command-line queries, IDE integrated management, and property file analysis methods introduced in this article each have their advantages and are suitable for different development scenarios. Developers are advised to choose appropriate methods based on specific needs and establish regular version checking and update mechanisms to ensure development environment stability and project compatibility.