Getting Started with Android Studio

Version Requirements

This course is tested with the following versions (January 2026). Newer versions should work fine:

The Goal

Before we dive into Android Studio, let's look at where we're headed. By the end of this engineering track, you'll have built a beautiful, native Android calculator app featuring expressive motion, haptic feedback, and a robust UDF architecture.

Go Beyond Vibe Coding

If you've been using AI tools to generate Jetpack Compose code—prompting and hoping for the best—you've probably hit a wall. Maybe the code builds but you don't understand it. Maybe you can't debug issues or customise behaviour. Maybe you feel like an imposter.

That's Vibe Coding. And whilst it's a valid starting point, to truly own your work—to build Android apps with intention and ship with confidence—you need to understand Kotlin and Compose properly.

This track teaches you real Android engineering skills. Not just copying and pasting, but genuinely understanding how to build native Android interfaces. Android Studio is where that journey begins.

What Is Android Studio?

Android Studio is Google's official IDE (Integrated Development Environment) for Android development. It's built on IntelliJ IDEA (a powerful, professional code editor) and includes everything you need to build Android apps:

Built on the professional IntelliJ IDEA foundation, it provides a comprehensive suite of tools including a sophisticated code editor for Kotlin and Java, a visual layout editor, and integrated Android emulators. Robust build tools, a debugger, and performance profilers are also included to ensure you have everything necessary to develop and refine your applications.

Unlike web development where you can choose any editor, Android development works best with Android Studio. It's free and provides the most complete experience.

Why Designers Should Learn Android Studio

Even if you're primarily a designer, understanding Android Studio helps you:

Learning the environment allows you to see exactly how your designs perform when prototyped in Jetpack Compose, giving you a deeper understanding of what is technically possible on Android. Furthermore, it enables you to collaborate more effectively by speaking the same language as your engineering team and empowers you to ship your own ideas without waiting for external help.

System Requirements

Android Studio runs on Mac, Windows, and Linux:

Mac

• macOS 11 (Big Sur) or later
• Apple Silicon or Intel processor
• 8GB RAM minimum (16GB recommended)
• 8GB disk space minimum (SSD recommended)

Windows

• Windows 10/11 64-bit
• x86_64 CPU architecture
• 8GB RAM minimum (16GB recommended)
• 8GB disk space minimum (SSD recommended)

Linux

• 64-bit Linux distribution
• GNU C Library (glibc) 2.31 or later
• 8GB RAM minimum (16GB recommended)

Storage Note: You'll need additional space for Android SDKs and emulators—plan for 20-30GB total.

Installing Android Studio

Step 1: Download

1. Go to developer.android.com/studio
2. Click Download Android Studio
3. Accept the terms and conditions
4. Download the installer for your platform

Step 2: Install

Mac:

1. Open the downloaded .dmg file
2. Drag Android Studio to the Applications folder
3. Open Android Studio from Applications

Windows:

1. Run the downloaded .exe installer
2. Follow the setup wizard
3. Choose installation location (default is fine)
4. Install Android Virtual Device (AVD) when prompted

Linux:

1. Extract the downloaded .tar.gz
2. Run studio.sh from the bin folder
3. Follow the setup wizard

Step 3: First-Time Setup

When you first launch Android Studio:

If this is a fresh installation, choose "Do not import settings" when prompted. Follow the guided setup wizard by selecting the Standard installation type and picking your preferred UI theme, such as Darcula for dark mode or the standard Light option. After verifying the SDK components, you must wait for them to finish downloading before the Welcome screen appears, signaling that the environment is ready for use.

The Android Studio Interface

Android Studio's interface has several key areas:

Welcome Screen

When you open Android Studio without a project: The Welcome screen provides immediate access to core functions, allowing you to create a new app project, open an existing one, or quickly jump back into previous work through the recent projects list.

Main Editor Areas

The interface is divided into several functional zones: the Project Panel on the left manages your file structure and Gradle scripts, while the central Editor area houses your code and layout previews across multiple tabs. Surrounding these are various Tool Windows for build output, terminal access, and Logcat device monitoring, ensuring all diagnostic data is within easy reach.

Toolbar (Top) The Toolbar at the top provides essential controls for running and debugging your application, alongside selectors for target devices and build variants.

Essential Shortcuts

The most important: ⌘/Ctrl + Shift + A lets you search for any action.

Creating Your First Project

Let's create a simple Jetpack Compose project:

Step 1: Start New Project

1. Click New Project on the Welcome screen
2. Or: File → New → New Project

Step 2: Choose Template

1. Select Phone and Tablet on the left
2. Choose Empty Activity (with Compose icon)
3. Click Next

Step 3: Configure Project

• Name: My First App
• Package name: com.yourname.myfirstapp
• Save location: Choose your preferred folder
• Language: Kotlin
• Minimum SDK: API 26 (Android 8.0) is a good default
• Build configuration language: Kotlin DSL (Recommended)

Click Finish.

Step 4: Wait for Gradle

Android Studio uses Gradle to manage builds. The first time, it downloads many dependencies. This can take several minutes.

Watch the progress bar at the bottom. When it says "Gradle sync finished," you're ready.

Understanding the Project Structure

Your new project contains:

MyFirstApp/
├── app/
│   ├── src/
│   │   ├── main/
│   │   │   ├── java/com/yourname/myfirstapp/
│   │   │   │   └── MainActivity.kt
│   │   │   ├── res/           ← Resources (images, strings)
│   │   │   └── AndroidManifest.xml
│   │   └── androidTest/       ← UI tests
│   └── build.gradle.kts       ← App build config
├── gradle/                    ← Gradle wrapper
└── build.gradle.kts           ← Project build config

Key Files

MainActivity.kt

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            MyFirstAppTheme {
                Surface(
                    modifier = Modifier.fillMaxSize(),
                    color = MaterialTheme.colorScheme.background
                ) {
                    Greeting("Android")
                }
            }
        }
    }
}

@Composable
fun Greeting(name: String, modifier: Modifier = Modifier) {
    Text(
        text = "Hello $name!",
        modifier = modifier
    )
}

This is your first Compose code! We'll learn the syntax later—for now, recognise that this creates a screen showing "Hello Android!"

The AndroidManifest.xml file is used to declare all of your app's components and required permissions, while the app-level build.gradle.kts file configures your specific dependencies and build settings.

Running Your App

Setting Up an Emulator

1. Click Device Manager in the toolbar (phone icon)
2. Click Create Device
3. Select a phone (e.g., Pixel 7)
4. Click Next
5. Select a system image (download if needed—choose the latest)
6. Click Next, then Finish

The emulator appears in Device Manager. Click the play button to start it.

Running on the Emulator

1. Select your emulator in the toolbar dropdown
2. Click the Run button (green play icon) or press ⌘/Ctrl + R
3. Wait for the build and deployment

Your app launches in the emulator showing "Hello Android!"

Running on a Physical Device

To test on a real phone:

1. Enable Developer Options on your Android phone:

   • Go to Settings → About Phone
   • Tap Build Number seven times

2. Enable USB Debugging:

   • Go to Settings → Developer Options
   • Enable USB debugging

3. Connect your phone via USB

4. Your device appears in the toolbar—select it and run

Jetpack Compose Preview

Like SwiftUI, Compose has live previews:

@Preview(showBackground = true)
@Composable
fun GreetingPreview() {
    MyFirstAppTheme {
        Greeting("Design Engineer")
    }
}

The preview appears in the Split or Design view (tabs at top right of editor).

Preview Controls

The preview pane offers several useful controls, including the ability to build and refresh components instantly, an interactive mode for testing UI behavior, and various device settings to preview your design across different screen sizes.

Troubleshooting Common Issues

Gradle Sync Failed

If Gradle sync fails, you should first check your internet connection before attempting to invalidate caches and restart through the File menu; as a last resort, deleting the .gradle folder in your home directory may resolve deeper configuration conflicts.

Emulator Won't Start

When an emulator fails to start, ensure that hardware virtualisation is enabled in your system's BIOS and that all graphics drivers are up to date. You might also try using a different system image or allocating more RAM to the virtual device within its configuration settings.

"SDK location not found"

To fix an "SDK location not found" error, navigate to the Project Structure menu and explicitly set the correct Android SDK path under the SDK Location settings.

Slow Performance

Slow performance can often be mitigated by allocating more memory through the System Settings or switching to SSD storage. To further improve speed, close unnecessary background applications or consider using a physical device for testing instead of a resource-heavy emulator.

Test Your Understanding

Next Steps

Continue to Understanding Kotlin Basics →