How to add a screen to Android Studio: step-by-step guide

The development of mobile applications on the Android platform begins with an understanding of the screen architecture. Each interface that the user sees, be it the login page, the main product list, or profile settings, is technically a separate component. In the environment Android Studio this process is fine-tuned to the smallest detail, but requires strict adherence to the project structure. Beginners are often confused by the terms Activity and Fragment, but to create a full-fledged screen, you need to associate the logical part with the visual layout.

Adding a new screen is a fundamental task that every developer faces after creating a Hello World project. Errors at this stage can lead to problems with navigation or incorrect display of interface elements on different devices. It is important to immediately get used to the correct separation of logic and appearance using modern approaches. In this article, we'll look at creating a screen from scratch using the classic s View i XMLapproach, which remains the industry standard.

Before you start coding, you need to make sure that your project is open in Project (Android view) and not in file mode. This will make it easier to navigate through folders java and res. The whole process will take a few minutes if you follow the steps carefully. We will create a new Activity, describe its appearance and configure the transition to it.

Creating a new Activity through the wizard

The fastest and most reliable way to add a new screen is to use the built-in component creation wizard. This eliminates syntax errors when manually creating files and automatically registers the component in the application manifest. To begin, find the folder appin the left panel of the project, then go to java and select the package where your classes are stored (usually called com.example.myapp).

Right-click on the folder with the package, select New, and then Activity. You will see a window with a list of templates. For a simple screen, it is best to choose Empty Activity, since this template provides a blank canvas without unnecessary code. If you select a template with navigation or fragments, the wizard will add additional dependencies that can confuse a novice developer.

In the settings window that opens, specify the class name (for example, SecondActivity) and the file name. markup (for example activity_second.xml) Make sure that the checkbox Launcher Activity is unchecked if you do not want this to be the first screen of the application at launch. Also check the field Package name - it should correspond to the main package of your application.

After clicking the button Finish IDE will generate two files: a Java/Kotlin logic class and an XML layout file. In the class you will see an overridden method onCreate, where the binding to the layout is already specified through the function setContentViewThis is a standard boilerplate design that Android Studio creates automatically for. each new screen.

Structure of XML screen layout

The appearance of any screen in Android is described in XML files located in the directory res/layout. This is where you determine where the buttons, text fields, and images will go. After creating an Activity through the wizard, the file activity_second.xml already contains the basic structure with a root element, most often it is ConstraintLayout or LinearLayout.

Open the created XML file. You'll see code similar to HTML, but with Android-specific attributes. The root element specifies the parameters of the container within which the widgets are located. For example, to add text to the screen, the tag TextViewis used, and for a button - Button. Each element must have unique width and height parameters, often set to wrap_content or match_parent.

It is important to correctly set identifiers (android:id) for all interactive elements. It is this ID that you will access elements from Java or Kotlin code to handle clicks or change text. Without a unique ID, it will be impossible to find an element in the tree, which will lead to compilation errors or logic failures.

Don't forget about the attribute tools:context on the root element. It does not affect the application's runtime, but it helps Android Studio understand which Activity this markup belongs to, which improves the preview and navigation in the code. This is a small thing, but it greatly simplifies development in large projects.

Setting up navigation between screens

Creating a screen is not enough - you need to provide the user with the ability to navigate to it. Navigation in Android is carried out through the object Intent. This is a special intermediary class that tells the system which component needs to be launched. To transition from one Activity to another, the so-called Explicit Intentis used, where the class of the target screen is explicitly indicated.

Suppose you have a main Activity with a button that, when clicked, should open a second screen. In the code of the first Activity, you need to find this button by ID and install an event listener on it. Inside the click processing method (onClick), a new Intent is created, the constructor of which is passed the context of the current Activity and the class of the target Activity.

button.setOnClickListener {
val intent = Intent(this, SecondActivity::class.java)
startActivity(intent)
}

intent.putExtra("USER_ID", 123)
intent.putExtra("IS_PREMIUM", true)
startActivity(intent)