The development of mobile applications for the Android platform begins with choosing the right tool, and Android Studio is the uncontested industry standard. This integrated development environment (IDE), based on IntelliJ IDEAprovides a powerful set of tools for writing code, debugging and testing. However, for beginners, the first launch of the app is often the most difficult stage, since the interface is full of many buttons, settings and tabs that can be confusing.
The process of initializing a new job involves not just pressing one button, but sequentially setting up the environment. You will choose a programming language, determine the minimum version of the operating system that your application will support, and select an architectural pattern. The correct configuration at the start will save hours of debugging in the future and ensure stable operation of the emulator.
In this material we will analyze in detail each step of the project creation wizard, paying special attention to critical settings that are often ignored. We will also look at typical problems that arise when you first start, and give practical tips on optimizing your workspace for maximum productivity.
Preparing the development environment and installing the SDK
Before you start creating code, you need to make sure that it is installed correctly on your computer Android SDK (Software Development Kit). It is this set of libraries and tools that allows you to compile code into an executable file of .apk or .aabformat. When you first start Android Studio usually it offers to download the necessary components automatically, but sometimes this process requires manual intervention through the menu Tools → SDK Manager.
Pay attention to the platform version. For modern projects, it is recommended to select the latest stable API releases to have access to the latest security and interface features. However, if you plan to support older devices, you will need to additionally download system images for earlier versions of Android.
⚠️ Attention: Make sure that you have at least 10-15 GB of free space on your system drive (usually drive C). Emulators and cached assemblies take up a huge amount of space, and a lack of space can lead to critical compilation errors or the inability to launch the virtual device.
Use an SSD drive to install Android Studio and SDK. The read/write speed of the hard drive (HDD) can increase the project build time (Gradle Build) by 3-5 times.
It is also critical to check the availability of JDK (Java Development Kit). Modern versions of the studio come with a built-in version JBR (JetBrains Runtime), which simplifies setup, but for specific tasks you may need to install an external version of Java. Checking the environment variables JAVA_HOME and ANDROID_HOME is a mandatory step to avoid path conflicts.
Running the New Project Wizard
After successful installation and initial setup of the environment, you will see a welcome screen. To start working, you need to press the button New Project. If you already have a project open, the path will be as follows: File → New → New Project. This action will launch a configuration wizard that will guide you through all the necessary steps to configure the application structure.
The first wizard window prompts you to select a template. The important thing here is to take your time and choose the option that best suits your goals. For most educational projects and simple applications, template Empty Activityis the best choice. It creates the minimum required structure without extra code, allowing you to figure out the basics yourself.
- 📱 Empty Activity: Blank screen with basic setup, ideal for training and uniquely designed applications.
- 🗺️ Basic Activity: Includes a pre-built Navigation Drawer and toolbar, which is convenient for complex applications.
- 📋 Settings Activity: Automatic generates a settings screen with user preferences saved in SharedPreferences.
- 🔑 Login Activity: Provides a ready-made login form interface with fields for email and password.
The choice of template affects the number of files that will be generated automatically. For example, selecting Basic Activity will create additional XML markup files for menus and navigation, which can be overwhelming for a new user. Therefore, if you are just learning, it is better to start with a clean slate.
Setting project parameters and programming language
The next step is to fill in the basic metadata of your application. The field Name specifies the name of the project, which will also be used for the name of the package and display in the list of applications on the device. The name must consist of Latin letters and not contain spaces; to separate words, use upper case (CamelCase), for example, MyFirstApp.
Pay special attention to the field Package name. This is your app's unique identifier in the Google Play ecosystem and on users' devices. Traditionally, it is formed in the reverse order of the domain name (for example, com.example.myapp). It is extremely difficult to change this identifier after creating a project without the risk of breaking signatures and connections within the code, so choose it wisely.
⚠️ Attention: Never use the standard prefix
com.examplefor real projects that you plan to publish. Register your own domain name or use a unique identifier to avoid conflicts with other developers in the application store.
Next is the choice of programming language. You can choose Kotlin or Java. Currently, Google has declared Kotlin a first-class language for Android development. This means that all new documentation, code examples and libraries are optimized for it. Java remains a supported language, but it makes more sense to start new projects in Kotlin.
Selecting Kotlin as the main language provides more concise code, protection against NullPointerException, and better compatibility with modern Jetpack libraries.
Also in this window you select the user interface framework: View or Jetpack Compose. View is a classic XML markup-based system that has been in use for over a decade. Jetpack Compose is a modern declarative toolkit that allows you to create interfaces entirely with Kotlin code. For beginners, Compose may seem complicated, but it is the future of Android development.
Minimum SDK version configuration
One of the most important technical decisions when creating a project is the choice Minimum SDK. This setting determines the oldest version of Android that your app can run on. The lower the version, the wider the audience of potential users, but the more restrictions you impose on the use of modern system APIs.
In the version selection window, the studio will show the percentage of devices that the selected setting covers. For example, choosing API level 21 (Android 5.0) will cover more than 95% of all active devices, but will deny you access to some of the modern security and interface features introduced in Android 12 or 13. Balancing audience reach and technical capabilities is a key task for the application architect.
| API Level | Android version | Codename | Features |
|---|---|---|---|
| 34 | 14 | Upside Down Cake | Latest features, strict background restrictions |
| 33 | 13 | Tiramisu | Improved notification permissions, language support |
| 26 | 8.0 | Oreo | Notification channels, background service restrictions |
| 21 | 5.0 | Lollipop | Basic support for Material Design, 64-bit applications |
If you are creating an application for internal use in a company or specific equipment (for example, data collection terminals), you can safely set a high threshold for the minimum SDK. This will simplify the code and speed up development. For public consumer applications, it is recommended to stick to the level used by popular social networks and instant messengers.
What happens if you choose a Minimum SDK that is too low?
If you specify an API level below 21, you will have to abandon support for 64-bit architectures in some configurations and use outdated support libraries, which will significantly complicate the code and increase the size of the final application.
Project structure and file navigation
After clicking the button Finish the process of indexing and loading dependencies through the build system will begin. Gradle. At this time, you will see a progress bar at the bottom of the screen. Don't be alarmed if the first build takes a few minutes - at this moment all the necessary libraries from the repositories are downloaded.
When the project opens, you will see the file structure in the left panel. The main attention should be paid to the folder app → java (or kotlin), where the source code is located, and the folder rescontaining resources. Resources are divided into subfolders: layout for interfaces, drawable for images, values for lines and colors, mipmap for application icons.
The main activity file is usually called MainActivity.kt (or .java). This is where app execution begins. Inside this file is a method onCreate, which is called by the system when the application starts. Here the components are initialized and the interface is linked to the operating logic.
- 📂 Manifests: Contains a file
AndroidManifest.xmlthat describes permissions, application components and metadata. - 💻 java/kotlin: The application source code, operating logic, classes and functions.
- 🎨 res: All resources: pictures, lines, styles, screen layouts.
- ⚙️ Gradle Scripts: Build configuration files, dependencies, and plugins.
Understanding this structure is critical for navigation. Trying to put an image directly into the code folder or change manifest without understanding XML syntax will result in compilation errors. Always use the context menu (right mouse button) to create new files so that the studio itself suggests the correct type of resource.
Running an application on an emulator or device
The final stage of creating a project is its launch. To do this, in the top toolbar, click the green button Run (triangle icon) or use the hotkey Shift + F10. If you have a real device connected via USB with debugging enabled, the studio will offer to select it from the list.
If there is no physical device, you need to create a virtual one. Click Device Manager and select Create Device. You will be asked to select your device model (for example, Pixel 6) and system image. It is recommended to select images marked Google APIsas they contain Google Play services necessary for testing maps, notifications and authorization.
⚠️ Attention: For the emulator to work correctly, virtualization (Intel VT-x or AMD-V) must be enabled in the BIOS of your computer. Without this hardware function, the emulator will work extremely slowly or will not start at all.
☑️ Check before starting
After successful launch, you will see the standard welcome message "Hello World!" on the screen of the emulator or phone if you used an empty template. This means that the environment is set up correctly and you are ready to write your own code. The output console (Logcat) at the bottom of the screen will display system logs that will help track errors in real time.
Common errors during the first launch and their solutions
Even when strictly following the instructions, beginners often encounter problems. One of the most common is error SDK location not found. This occurs if the path to the SDK is incorrect or the folder has been moved. This can be solved by creating or editing a file local.properties in the root of the project, where you need to specify the current path.
Another common problem is related to Gradle versions. Sometimes the version of the plugin in the file build.gradle is not compatible with the version of Android Studio itself. In such cases, the studio usually offers an automatic solution ("Sync Now" or "Upgrade Gradle"). Agree to the update, as this will synchronize the build tools with the current development environment.
You may also have problems with the emulator that throws the error "x86 image requires Intel HAXM". This can be solved by installing the component Intel Hardware Accelerated Execution Manager via SDK Manager in the SDK Toolstab. For AMD processors, an analogue is setting up the Windows hypervisor or installing a system image labeled ARM, which works through software emulation, albeit slower.
If the emulator starts, but the application immediately closes (“crashes”), open Logcat and filter the logs by your package tag. The first line with a level of ERROR will indicate the exact reason for the failure, often a lack of permission in the Manifest or an error in the XML markup.
Do not ignore yellow warnings (Warnings) in the code editor. While they do not prevent startup, they often indicate outdated methods or potential memory leaks that could become critical in the future. Following Best Practices from the very beginning creates the right development culture.
Which version of Android Studio is the most stable?
It is recommended to use the latest stable version (Stable Channel), which can be downloaded from the official website of the developer. Versions from the Beta or Canary channels contain the latest features, but may be unstable and contain bugs, which is not desirable for training or commercial development.
Is it possible to change the project language from Java to Kotlin after creation?
Yes, it is possible. You can add new Kotlin files to an existing Java project and vice versa. Moreover, Android Studio has a built-in automatic code conversion function: Code → Convert Java File to Kotlin Filewhich allows you to gradually migrate the project to a modern language.
How much space does an empty project take up?
The source code of an empty project itself takes up several kilobytes. However, after the first build and indexing, the project folder can grow to 200-500 MB due to the Gradle cache, compiled classes and temporary files. Regularly clearing your cache (File → Invalidate Caches) helps free up space.
Do you need to pay to use Android Studio?
No, Android Studio is completely free and open source software. You can use it to create both free and commercial applications without any licensing fees from Google itself for using the development environment.
Why does Gradle take a long time to synchronize when first launched?
When first synchronized, Gradle downloads all the necessary dependencies, plugins and libraries specified in the configuration files from remote repositories. Speed depends on your internet connection. Subsequent launches will be much faster, since the files are saved in the local cache.