Android Studio: What It Is and How to Use It

What Is Android Studio?

Android Studio IDE is the official development environment from Google, released in 2013 based on IntelliJ IDEA Community. It provides a full set of tools for Android applications: code writing (Kotlin/Java), visual UI design (XML/Jetpack Compose), building (Gradle), testing (JUnit/Espresso), and profiling.

The current version is Android Studio Ladybug (2025), based on IntelliJ 2024.3. The IDE supports the latest Android 16 API Level (Baklava), stable Jetpack Compose 1.8, and Kotlin 2.1. According to Google I/O 2025, 94% of Android developers use Android Studio as their primary IDE for commercial projects.

Key features: AGP (Android Gradle Plugin) for flexible build configuration, R8 obfuscator for APK size reduction, Play Feature Delivery for modular applications, Firebase Test Lab integration. Android Studio is available for Windows, macOS, Linux, and ChromeOS.

Android Project Structure

An Android project in Android Studio is organized on a multi-module principle. Each module (app, feature, core) contains source sets: `main` (production code), `test` (unit tests), and `androidTest` (UI tests). Resources are split by qualifiers: layout, values, drawable, mipmap.

Version Catalog (libs.versions.toml) provides centralized dependency management. Instead of specifying versions manually in each build.gradle.kts, you use libs.androidx.compose.ui, libs.ktor.client, and other declarative references. Google recommends version catalogs for all new projects as the standard library management approach.

Layout Editor and Jetpack Compose

Layout Editor is a visual editor for XML interfaces (ConstraintLayout, LinearLayout) with Split mode: a canvas preview on the left and XML code on the right. The Palette contains View components: Button, TextView, RecyclerView, EditText. The Attributes Panel displays the selected component's properties with editors for padding, margins, and constraints.

Jetpack Compose Preview is an alternative to the Layout Editor for declarative UIs. In Android Studio Ladybug, Preview works for @Composable functions with different parameters: Dark/Light Mode, various screen sizes, localization. The @Preview(showBackground = true, uiMode = UI_MODE_NIGHT_YES) annotation creates multiple preview panels in one window.

ConstraintLayout is the basic layout for complex interfaces. In the Layout Editor, you can create constraints between views by dragging, set up chains for uniform distribution, and barriers for dynamic heights. MotionLayout (an extension of ConstraintLayout) supports transition animation in the editor.

Gradle: Android Build System

Gradle is the automated build system for Android projects, managed through the Android Gradle Plugin (AGP). AGP defines tasks: assembleDebug, assembleRelease, bundleDebug (AAB), lint, test. Gradle build scripts are written in Kotlin DSL (build.gradle.kts) or Groovy; Kotlin DSL is the standard for new projects.

// build.gradle.kts (app module)
plugins {
    alias(libs.plugins.android.application)
    alias(libs.plugins.kotlin.android)
    alias(libs.plugins.kotlin.compose)
}

android {
    namespace = "com.example.app"
    compileSdk = 36
    
    defaultConfig {
        applicationId = "com.example.app"
        minSdk = 26
        targetSdk = 36
        versionCode = 1
        versionName = "1.0.0"
    }
    
    buildTypes {
        release {
            isMinifyEnabled = true
            proguardFiles(
                getDefaultProguardFile("proguard-android-optimize.txt"),
                "proguard-rules.pro"
            )
        }
    }
}

Multi-module projects in Android Studio split code into feature modules (app, :feature:home, :feature:profile) and core modules (:core:network, :core:designsystem). Each module has its own build.gradle.kts. AGP compiles all modules into a single APK/AAB. Convention plugins extract common settings (Kotlin options, Compose) into a build-logic subproject, reducing duplication.

Android Emulator and AVD

Android Emulator is a virtual device for running and testing Android applications on a computer. Each virtual device is described by an AVD (Android Virtual Device) configuration: model (Pixel 9, Galaxy S25), API Level (Android 14, 15, 16), RAM size, and disk size.

Emulator features: instant snapshots (for quick state restoration), GPS coordinate simulation, camera (with image upload), phone calls and SMS, sensors (accelerometer, gyroscope), multitouch (via Extended Controls). Google recommends the emulator for 80% of tests and a physical device for hardware-dependent features (camera, Bluetooth, fingerprint).

Android Emulator on Apple Silicon (M1/M2/M3) runs natively via Hypervisor.framework without Rosetta. Emulator performance on Apple Silicon is comparable to a physical device. For emulation acceleration, the Android Emulator Plugin + Vulkan is used for GPU-accelerated graphics.

Android Profiler and Debugging

Android Profiler is a built-in performance monitoring tool in Android Studio. The Profiler shows in real time: CPU (core load, threads, GC duration), Memory (Java/Kotlin heap, Native, Stack, Graphics), Network (incoming/outgoing traffic, HTTP requests), and Energy (battery drain by component).

Debugging in Android Studio: Debugger with breakpoints (conditional breakpoints, logpoints), Evaluate Expression, Frame Drop Inspector for analyzing missed frames, Layout Inspector for the View hierarchy on a running application. Background Task Inspector displays WorkManager tasks, AlarmManager, and JobScheduler.

Firebase Test Lab is cloud-based testing on real devices in Google Cloud, integrated into Android Studio. Tests run on a device matrix (10+ models) with different Android versions and localizations. Results include test run videos, screenshots, and logs.