Running a app in Android Studio: from the first click to successful compilation

Launching the first application in Android Studio is a moment that separates theory and practice. Many beginners encounter errors even at the stage of setting up the environment, and experienced developers sometimes lose sight of optimizing the build process. This article will help you figure out how to properly launch a app in Android Studio —from creating a new project to debugging on a physical device.

We will look at all the key steps: choosing an assembly configuration, setting up an emulator, connecting a smartphone via ADB, and also look at typical errors like Installation failed or Emulator not responding. We will pay special attention to the subtleties that are rarely mentioned in the official documentation - for example, how to speed up the first launch of the emulator or why the application may not open on some versions Android.

If you are just starting your journey in Android development, this guide will become your cheat sheet. Experienced programmers will find here tips on optimizing the workflow and diagnosing unobvious problems.

1. Preparing Android Studio for the first launch

Before launching the app, make sure that your development environment is configured correctly. Android Studio requires preliminary configuration, especially if you installed it for the first time. Here's what you need to check:

• 📋 SDK updates: Go to Tools → SDK Manager and install the latest versions Android SDK Platform and Android SDK Command-line Tools.
• 🔧 Plugins: Make sure plugins are activated Android Support i Google Services v Settings → Plugins.
• 🗃️ Gradle cache: Clear the cache via File → Invalidate Caches / Restartif synchronization errors occurred previously.
• 🛠️ Java JDK: Android Studio requires JDK 11 or later. Check the version in the terminal with the command java -version.

One ​​of the most common sources of problems is incompatibility of Gradle versions. If, when synchronizing a project, you see an error like Gradle project sync failed, open the file gradle-wrapper.properties in the project root and update the distribution line:

distributionUrl=https\://services.gradle.org/distributions/gradle-8.2-bin.zip

Also check the file build.gradle (Project) —it should contain the current version plugin Android Gradle Plugin:

classpath 'com.android.tools.build:gradle:8.1.0'

2. Creating a new project: step by step

To start the app, you first need to create a project. In Android Studio this is done through the wizard New Project. Let's look at the key points:

1. Selecting a template: For the first launch, select Empty Activity —this is the minimum required structure with one screen.
2. Name and package: Specify Name (application display name) and Package name (a unique identifier in the format com.example.myapp).
3. Language programming: Kotlin (recommended by Google) or Java. For beginners, it is easier to start with Javaif you are familiar with it.
4. Minimum SDK version: Select API 21 (Android 5.0) or higher. You should not go lower - this will narrow the audience of users.

After creating the project Android Studio will automatically generate the file structure:

• 📁 app/src/main/java/ — source code (MainActivity.kt or MainActivity.java)
• 📁 app/src/main/res/ — resources (layouts, images, lines)
• 📄 app/build.gradle — module assembly configuration
• 📄 AndroidManifest.xml — application manifest

Pay attention to the file activity_main.xml in the folder res/layout —the layout of the main screen is stored here. By default, there will be simple text. "Hello World!"It can be edited manually or through a visual editor Design.

3. Setting up the Android emulator

The emulator allows you to test the application without a physical device. However, setting it up is often difficult. Here's how to create a virtual device (AVD) Right:

1. Open Tools → Device Manager.
2. Click Create Device and select the model (for example, Pixel 5).
3. Indicate the system: recommended Android 13 (API 33) or newer.
4. In section System Image select x86_64 (for PC) or ARM (if you plan to test on Mac M1/M2).
5. Configure the emulator settings: RAM (minimum 2 GB), Internal Storage (2 GB), enable Hardware - GLES 2.0 to speed up graphics.

After creating the emulator, you can launch it through the Play v Device Managerbutton. The first launch may take several minutes - the emulator downloads the necessary components. To speed up the process:

• 🚀 Use Quick Boot (enabled in the emulator settings).
• 💾 Create snapshot (Snapshot) after the first boot.
• 🔄 Disable animation in the emulator developer settings (Settings → Developer options → Window animation scale → Off).

ARM-based emulators are slower than x86, but more accurately simulate real devices. If your processor supports virtualization (Intel VT-x or AMD-V), enable it in the BIOS for speedup.

Is it installed Hyper-V (for Windows) or KVM (for Linux)?

Are there enough RAM allocated (minimum 4 GB for emulator + system)?

Are other resource-intensive apps disabled?

Are video card drivers updated (to speed up OpenGL)?-->

4. Launching the app on the emulator

When the project and the emulator are ready, you can start launching. Here are the step-by-step guide:

1. Make sure that the correct module is selected in the top panel ( Android Studio correct module selected (app) and device (your emulator).
2. Press the green button Run (or Shift + F10).
3. Wait for the project to build. In the window Build Output you will see the process log.
4. After successful compilation, the emulator will automatically open your application.

If the launch does not occur, check:

If the application starts, but you see a blank screen or an error "App not installed", check:

• 🔍 Is it correct? package name v build.gradle?
• 📱 Is there enough space on the virtual device?
• 🔒 Is the installer of unknown sources blocked in the emulator settings?

5. Running on a physical device

Testing on a real smartphone or tablet gives more accurate results than an emulator. To do this you need:

1. Enable developer mode on the device:
   • Go to Settings → About phone.
   • Click 7 times on Build number.
   • Return to Settings - the item will appear For Developers.

If the device is not detected, do:

• 🔌 Check that the cable supports data transfer (not only charging).
• 🔄 Switch USB mode to File transfer (MTP) in the notification shade.
• 🖥️ Install drivers ADB for your model (for example Google USB Driver for Nexus/Pixel devices).
• 🔍 Enter in the terminal Android Studio the command:

  adb devices

  If the device is displayed as unauthorized, confirm permission to phone.

On some devices (for example, Xiaomi, Huawei), you additionally need:

• 🔒 Allow Installation from unknown sources in the security settings.
• 🔄 Enable USB debugging (security options) in the developer menu.
• 📱 Disable MIUI Optimization (for Xiaomi), if the application crashes on startup.

6. Optimizing the launch process

Building and launching a project in Android Studio can take a lot of time. Here's how to speed up this process:

• ⚡ Instant Run: Enable in Settings → Build, Execution, Deployment → Instant Run (does not work with all code changes).
• 🗑️ Clear cache: Perform periodically File → Invalidate Caches / Restart.
• 📦 Multi-module projects: Divide the project into modules (app, core, features) for parallel assembly.
• 🔄 Gradle daemon: Enable File → Settings → Build, Execution, Deployment → Gradle → Enable Gradle daemon.

To speed up the emulator:

• 🖥️ Use emulator with support for hardware acceleration (in the AVD settings, select Hardware - GLES 2.0).
• 💾 Create snapshot (Snapshot) for fast loading.
• 🔧 Disable unnecessary emulator functions (for example, Live Wallpaper or Multi-Window).

If you are working with Kotlin, add the following lines to gradle.properties to speed up compilation:

kotlin.compiler.experimental=true
kotlin.compile.incremental=true

It is also useful for large projects:

• 📦 Use dynamic features (Dynamic Feature Modules) to load parts of the application on demand.
• 🔄 Configure caching dependencies in gradle.properties:

  org.gradle.caching=true

7. Diagnosis and solution of common errors

Even experienced developers encounter errors when starting up. Let's look at the most common ones and ways to solve them:

google()
mavenCentral()

adb kill-server
adb start-server

If the application starts, but does not work correctly:

• 🔍 Check logs in Logcat (filter by Error or WTF).
• 📱 Make sure that permissions in AndroidManifest.xml are requested correctly (for example, INTERNET or CAMERA).
• 🔄 Clear application data on the device (Settings → Applications → Your application → Storage → Clear data).

To diagnose performance problems:

• 📊 Use Android Profiler (View → Tool Windows → Profiler).
• 🔍 Enable StrictMode to detect memory leaks or slow operations in the main stream.
• 🛠️ Check memory usage memory usage Memory Profiler.

emulator -avd YourAVDName -no-snapshot-load

8. data-i="297">In addition to standard tools

In addition to standard means Android Studio, there are tools that simplify launching and testing:

• 🔧 ADB AppControl: Utility for managing applications via ADB (installation, uninstallation, clearing cache).
• 📱 Genymotion: Alternative emulator with advanced functions (for example, simulating GPS or SMS).
• 🚀 Firebase Test Lab: Cloud testing on real devices (free up to 10 tests per day).
• 🔍 LeakCanary: Library for detecting memory leaks in real time.

To automate the launch, you can use:

• 🤖 Gradle scripts: Write a custom task in build.gradle to build and install APK on several devices simultaneously.
• 📟 CI/CD: Configure GitHub Actions or Bitrise to automatically run tests on every commit.

Example of a Gradle task for installing an APK on all connected devices:

task installDebugToAllDevices(type: Exec) {
commandLine 'adb', 'devices'
// Get a list of devices and install APK on each
doFirst {
def devices = commandLine.execute().text.readLines().tail().findAll { it.trim() }
devices.each { device ->
def deviceId = it.split()[0]
exec {
commandLine 'adb', '-s', deviceId, 'install', '-r', "${buildDir}/outputs/apk/debug/app-debug.apk"
}
}
}
}

To work with Firebase Test Lab add to build.gradle:

android {
testBuildType "googlePlay"
}

dependencies {
implementation 'com.google.firebase:firebase-appdistribution-gradle:3.2.0'
}

FAQ: Frequently asked questions about running apps in Android Studio