Table of Contents
Understanding the Android SDK
The Android Software Development Kit, usually called the Android SDK, is the collection of tools, libraries, and resources that let you build Android apps. Android Studio uses the SDK behind the scenes every time you create, build, run, or debug an app, so having the right SDK components installed and configured is essential.
The SDK is not a single file. It is a folder that contains different packages. Some of these packages are installed by default with Android Studio, and others you choose to add later when your project needs them. You rarely interact with the SDK directly. Most of the time Android Studio manages it for you, but you still need to understand what is inside and how to control it.
When you first install Android Studio, it either installs a fresh SDK or lets you point to an SDK that is already on your computer. After that, you can manage SDK versions and tools using the SDK Manager inside Android Studio. This chapter focuses on what these pieces are and what they do.
SDK Platforms and API Levels
Every Android version has a corresponding API level. The SDK platform for a specific API level contains the libraries, system images, and metadata that let you compile apps for that Android release.
Android uses integer API levels, for example:
- Android 13 has API level 33.
- Android 14 has API level 34.
You will usually choose a specific API level as your compileSdkVersion, which tells the compiler which Android APIs your code is allowed to use. You can also configure a minSdkVersion for the lowest API level your app supports, and a targetSdkVersion that indicates which version your app is designed and tested for. These configuration details are part of the Gradle build system and will be discussed in a later chapter. Here it is enough to know that the SDK platform packages must be installed for any API level you intend to compile against.
You do not need to install all platforms. For most beginners, having the latest stable SDK platform is enough to start. Over time, you may add others if you want to test compatibility with older devices.
Platform Tools
Platform tools are command line programs that can communicate with Android devices and emulators, help you debug apps, and manage app packages.
The most important tool here is the Android Debug Bridge, usually known as adb. Android Studio uses adb internally, but you can also run it manually from a terminal to perform tasks such as checking connected devices, installing APKs, or capturing logs. Other platform tools help with system operations, but as a beginner you can think of platform tools as the bridge between your development machine and any Android device that is attached or emulated.
Platform tools are updated frequently to stay compatible with the latest Android versions. Android Studio usually prompts you when an update is needed, and you should accept these updates to avoid connection and debugging issues.
Build Tools
Build tools are the components that help turn your Kotlin source code and resources into an APK or AAB file that can be installed on a device. They contain compilers, resource processors, and packagers.
You might see different versions of build tools installed side by side. Gradle, which manages your Android builds, selects a specific build tools version for each project. You typically do not run build tools directly. Instead, you click the Run or Build options in Android Studio, and Gradle invokes the appropriate build tools in the background.
Keeping the build tools versions aligned with what your Gradle configuration expects is important. If you update one but not the other, you might see build errors until the versions are synchronized, which you will handle later when you learn about the Gradle build system.
Android Emulator System Images
To run apps on a virtual device, you need emulator system images. These are part of the SDK and represent entire Android system installations for different versions, architectures, and device profiles.
A system image includes a copy of an Android OS, including preinstalled apps and system libraries. When you create a virtual device in the Android Virtual Device Manager, you choose which system image to use. You can have several system images for different API levels, for example one for API 33 and another for API 34, and then launch the one you need to test.
System images are separate from SDK platforms. Installing a platform lets you compile for an API level. Installing the corresponding system image lets you run that API level in the emulator. For basic app development, you usually only need one or two recent system images, because they take significant disk space.
Command Line Tools Package
The command line tools package, sometimes called cmdline-tools, contains utilities for managing and updating the SDK from a terminal. The most relevant one is sdkmanager, which can install or remove SDK packages without using the Android Studio interface.
While beginners mostly manage the SDK from the SDK Manager in Android Studio, knowing that a command line alternative exists can be useful if you ever need to automate setup on multiple machines, use a continuous integration server, or fix SDK configuration issues that prevent Android Studio from starting correctly.
The command line tools also include helpers for creating and managing virtual devices outside of Android Studio, but as a new developer you can safely rely on the graphical tools for these tasks.
Using the SDK Manager in Android Studio
Android Studio includes an SDK Manager that lets you inspect and modify your SDK installation. You can find it in the settings or preferences of Android Studio, usually under a section named "Appearance & Behavior" then "System Settings" then "Android SDK", or by clicking the SDK Manager icon in the toolbar if available.
In the SDK Manager you see at least two main tabs. One shows you SDK Platforms, where each row corresponds to an Android version and API level. Here you select which platforms you want to install. The other shows SDK Tools, where you can manage items like platform tools, build tools, and emulator components. Each item has a version, an installation status, and sometimes additional options.
Android Studio also offers a "Show Package Details" option that reveals more granular versions of the tools and platforms. As a beginner you can leave this unchecked and accept the default recommended items. Over time, when you face version specific issues or need legacy support, you can use those detailed controls to install exactly the tools you need.
Whenever you install or remove SDK components, the SDK Manager shows a progress dialog while it downloads and configures the packages. Because the SDK can be large, these operations may take some time and require a stable internet connection.
Environment Variables and SDK Location
Internally, Android Studio needs to know where your SDK is stored. It shows this path in the SDK Manager at the top as the "Android SDK Location." If you ever move the SDK folder or share it between different IDE installations, you must update this location setting.
Some external tools, such as certain build scripts or command line utilities, look for an environment variable that points to the SDK directory. Common variable names are ANDROID_HOME or ANDROID_SDK_ROOT. These are usually configured at the operating system level and read by tools that run outside Android Studio.
You do not need to configure these variables for basic development inside Android Studio. They become important when you start using command line builds or external automation. At that point, setting them to match the SDK location shown in Android Studio helps keep everything consistent.
Always keep your Android SDK location on a path where you have full read and write permissions, and avoid moving or manually editing files inside the SDK folder unless you are following official guidance.
Updating and Maintaining SDK Components
The Android platform evolves quickly, and SDK components receive regular updates. These updates deliver support for new APIs, bug fixes, performance improvements, and compatibility with new versions of Android Studio.
You should get into the habit of checking the SDK Manager periodically and accepting recommended updates, especially for platform tools, build tools, and emulator components. However, you should be cautious about removing older versions that existing projects still require. If a project targets a specific compile SDK or uses an older build tools version, keep those installed until you are ready to upgrade the project configuration as well.
When you update Android Studio itself, it often prompts you to update the SDK components it depends on. Accepting these updates keeps your environment stable and avoids subtle errors during builds and deployments.
If you ever encounter strange build or device connection problems, checking that your SDK is up to date and that the required platforms and tools are installed is one of the first troubleshooting steps.
How SDK Tools Integrate into Your Workflow
Every part of your everyday Android development workflow involves the SDK tools, even if you do not see them directly. When you press Run, Gradle uses build tools to compile and package your app. When the app installs on an emulator, platform tools use adb to push it and start the activity. When you test on different Android versions, emulator system images provide those environments.
By understanding what the main SDK components are, you gain clarity about what is happening behind the scenes and why Android Studio might ask you to install or update certain items. This knowledge makes it easier to resolve configuration issues and prepares you to use more advanced development workflows later in the course.