Introduction

Automating Android SDK installation is standard practice for CI pipelines, onboarding scripts, and reproducible local environments. Manual installation is slow and inconsistent across machines. The reliable approach is using command line tools, scripted package lists, and license acceptance automation.

Install Command Line Tools Non Interactively

Start from the Android command line tools package and configure environment variables.

1export ANDROID_SDK_ROOT="$HOME/android-sdk"
2mkdir -p "$ANDROID_SDK_ROOT/cmdline-tools"
3
4# Assume command line tools archive is already downloaded
5unzip commandlinetools-linux-*.zip -d "$ANDROID_SDK_ROOT/cmdline-tools"
6mv "$ANDROID_SDK_ROOT/cmdline-tools/cmdline-tools" "$ANDROID_SDK_ROOT/cmdline-tools/latest"
7
8export PATH="$ANDROID_SDK_ROOT/cmdline-tools/latest/bin:$ANDROID_SDK_ROOT/platform-tools:$PATH"

Use exact tool versions in CI images to avoid unpredictable updates.

Accept Licenses And Install Required Packages

Automate license acceptance and install only needed components.

yes | sdkmanager --licenses

sdkmanager   "platform-tools"   "platforms;android-34"   "build-tools;34.0.0"   "cmdline-tools;latest"

Avoid installing every available platform, which increases build time and image size.

Verify Installation In Scripts

Always verify tools after installation.

sdkmanager --list | head -n 30
adb version

Fail fast if required packages are missing. This prevents later Gradle failures that are harder to diagnose.

CI Pipeline Example

A simple Linux CI step might look like this.

1#!/usr/bin/env bash
2set -euo pipefail
3
4export ANDROID_SDK_ROOT="$HOME/android-sdk"
5export PATH="$ANDROID_SDK_ROOT/cmdline-tools/latest/bin:$ANDROID_SDK_ROOT/platform-tools:$PATH"
6
7yes | sdkmanager --licenses > /dev/null
8sdkmanager "platform-tools" "platforms;android-34" "build-tools;34.0.0"
9
10./gradlew --no-daemon assembleDebug

Cache $ANDROID_SDK_ROOT between runs for faster pipeline performance.

Pin Versions For Reproducibility

Pin SDK and build tools versions in your scripts and in build.gradle. Floating latest versions can break builds unexpectedly.

For example, align compileSdk and build tools with installed packages:

1android {
2    compileSdk 34
3    defaultConfig {
4        minSdk 24
5        targetSdk 34
6    }
7}

If pipeline and project versions drift, builds can fail with missing platform errors.

Windows And macOS Notes

Automation principles are the same on all platforms. Use platform specific path syntax and shell tools. On Windows runners, PowerShell scripts can call sdkmanager.bat with equivalent package lists.

Containerized Linux environments are usually easiest for deterministic Android builds.

Security And Maintenance

Treat SDK installation scripts as infrastructure code. Keep them in version control, review changes, and test upgrades in staging pipelines before production rollout.

Also monitor disk usage. Android SDK caches can grow quickly and affect runner stability if cleanup policies are missing.

Docker And Developer Onboarding

Containerizing Android SDK setup is effective for reproducible CI and local dev onboarding. Build a base image that includes exact SDK packages and Gradle dependencies, then reuse it across projects.

For local onboarding, provide one bootstrap script that installs command line tools, packages, and environment variables. New developers should be able to run one command and get a working toolchain.

Keep package lists centralized in one script file rather than duplicating commands across CI jobs. Centralization lowers maintenance cost when SDK versions are upgraded.

Offline Or Restricted Network Environments

In corporate networks, direct downloads can fail due to proxies or restricted domains. Mirror required packages internally and configure runners to use approved network routes. Validate mirror freshness during release cycles so new platform versions are available when needed.

Common Pitfalls

• Installing SDK manually and expecting consistent CI behavior.
• Forgetting to accept licenses in non interactive environments.
• Using floating latest package versions without pinning.
• Installing unnecessary packages and slowing pipeline startup.
• Not verifying tool availability before running Gradle tasks.

Summary

• Automate SDK setup with sdkmanager and versioned scripts.
• Accept licenses non interactively in CI.
• Install only required packages and verify toolchain after install.
• Pin SDK and Gradle compile versions for reproducible builds.
• Store installation scripts in source control as maintainable infrastructure.