Working with XML in Android Studio is an integral part of mobile application development. These files are responsible for interfaces, configurations and resources, but their location is not always obvious to newbies. If you are looking for where exactly this or that XML document is stored, or want to understand the structure of the project, this article will help you understand all the nuances. We will look at not only standard paths, but also hidden folders, and also explain what each file type is responsible for.

Many developers are faced with a problem: the project is open, but the desired XML file has “disappeared” from view or is not displayed in the expected directory. The reasons may be different - from incorrectly setting the visibility of files in Android Studio to the assembly features of a particular project. Next, you will learn how to quickly find XML resources, what tools the IDE has for this, and what to do if the files “disappeared” after updating studio or Gradle.

Before diving into the details, we will answer the main question: XML in Android Studio is stored in several key folders, each of which is responsible for its own functional area. The main directories are res/ (resources), manifest/ (application configuration) and sometimes assets/ (additional data). But this is just the tip of the iceberg: the actual structure may include dozens of subfolders, especially in large projects with a modular architecture.

📊 How often do you work with XML in Android Studio?
Daily
Several times a week
Nearby
Only when setting up layouts

1. Project structure: where to look for XML files in a standard Android project

When creating a new project in Android Studio (for example, with a template Empty Activity), the folder structure is generated automatically. The main XML files are distributed in the following directories:

  • 📄 app/src/main/res/ —all application resources are stored here, including layouts (layout/), rows (values/), styles and themes. This is the folder most “populated” with XML files.
  • 📜 app/src/main/AndroidManifest.xml —the main manifest of the application, which describes permissions, activities and components.
  • 🗃️ app/src/main/assets/ —an optional folder for static files (for example, XML configurations for libraries or data). Here the files are not compiled into resources, but are packaged “as is.”

It is important to understand that the path app/src/main/ is the standard for the module app. If your project uses multi-module architecture, then similar folders will be duplicated in each module (for example, feature-auth/src/main/res/). This complicates the search, but makes it easier to support large projects.

To quickly open the desired directory, use the panel Project (usually on the left). If the folder res/ is not visible, check that display Android (and not Project Files or Packages) is selected in the drop-down menu. In Android mode, the structure is simplified and key XML files (for example, activity_main.xml) are immediately visible.

💡

Click Alt+1 (Windows/Linux) or Cmd+1 (Mac) to quickly open the panel Projectif it is hidden.

2. Types of XML files in Android and their location

XML files in Android projects are divided into several categories, each of which has its own purpose and standard location. Let's look at the main types:

File type Folder Example file Purpose
Layouts (Layouts) res/layout/ activity_main.xml Describe the structure of screens (buttons, text fields, etc.).
Strings and styles res/values/ strings.xml, styles.xml Stores texts, colors, sizes and styles for localization and theming.
Manifest Root src/main/ AndroidManifest.xml Application configuration: permissions, activities, services.
Animations res/anim/ or res/animator/ slide_in.xml Defines animations of transitions between screens.
Menu res/menu/ main_menu.xml Menu structure in Toolbar or context menus.

Important nuance: files in the folder res/values/ (for example, colors.xml or dimens.xml) are often ignored when searching, although they are also XML and are critical for responsive design. If you are looking for where the color is stored buttons or indentation - check this directory first.

For convenience Android Studio automatically groups files by type in the panel Project. For example, all layouts (.xml from res/layout/) are displayed in the Layoutsection, and rows - in Values. This simplifies navigation, but sometimes hides the real folder structure.

What is res/values-night/?

This is a folder for resources that are used in the "night" mode (dark theme). colors.xml here can override the colors for the dark theme, mientras that res/values/ stores the values ​​for the light one.

3. How to quickly find an XML file: Android Studio tools

If you know the file name (for example, fragment_home.xml), but don't remember where it is stored, use the built-in search Android Studio:

  1. Click Ctrl+Shift+F (Windows/Linux) or Cmd+Shift+F (Mac) for a global search.
  2. In the input field, enter the file name (for example, fragment_home).
  3. The search results will display all matches, including the path to the file.
  4. Double-click on the result to open the file in editor.

To search by XML content (for example, if you are looking for a file where android:id="@+id/btn_submit"is used), use the same short path, but enter not the file name, but a piece of code. This is especially useful when you are working with someone else's project and do not know the folder structure.

Another way is to use the panel Structure (Alt+7). It displays the hierarchy of elements in the currently open XML file, which is useful for navigating large layouts (for example, with nested <include> or <merge>).

Make sure the panel Project is visible (Alt+1)

Check display modes (Android/Project)

Use global search (Ctrl+Shift+F)

View sections Layout and Values in the panel Project-->

4. Hidden XML files: where to look for library and Gradle configurations

Not all XML files are on the surface. Some of them are generated automatically or hidden in library folders. Here's where to look for them:

  • 🔧 app/build/generated/ - generated files are stored here, including R.java and sometimes XML resources (for example, for Data Binding). Do not edit these files manually - they are rewritten every time). assembly.
  • 📦 app/.idea/ —configurations Android Studio (for example, workspace.xml). These files are responsible for the IDE settings, and not for the application logic.
  • 🔄 app/src/debug/ or app/src/release/ —assembly-specific XML files may be located here (for example, different manifests for debug and release versions).

If you have included an external library (for example, Firebase or Retrofit, its XML configuration can be located in:

  • app/src/main/res/ (if the library adds resources)
  • app/libs/ (if it is a local .aar-file with resources)

For viewing XML files from included dependencies (for example, from Google Play Services) use the tool Classpath or External Libraries in the panel Project. However, you cannot edit them directly - only through a fork or feedback from the library developers.

💡

The files in build/generated/ are temporary. Changing them does not make sense, since they are recreated every time the project is built.

5. XML Display Issues: Why Files Are Not Visible or Won't Open

Sometimes XML files “disappear” from view or won't open in the editor. Common reasons and solutions:

⚠️ Attention: If after updating Android Studio or Gradle the files in the folder res/are no longer displayed, check the plugin version com.android.tools.build:gradle in the file build.gradle. Incompatibility of versions can lead to failures of project indexing.
  • 🔍 Files are not displayed in the panel Project:
    — Make sure that the mode is enabled Android (not Project Files).
    —Check whether the file has been added to .gitignore (then it may be hidden).
    — Right-click on the folder res/ → Synchronize.
  • 🚫 The file does not open in the editor:
    — The file may be damaged Try opening it in a text editor (for example, Notepad++).
    — Check the file encoding (should be UTF-8).
    — If the XML contains errors, Android Studio may block its opening.
  • 🔄 Changes in XML are not applied:
    — Run Build → Clean Project, then Rebuild Project.
    — Check if resources are cached (in Build → Rebuild).
    — Make sure the file is in the correct folder (for example, res/layout/and not in assets/).

If the problem persists, try creating a new file with the same name and content. Sometimes this helps to "wake up" the version control system or cache Android Studio.

6. XML editing: best practices and tools

Working with XML in Android Studio can be tedious, especially if the files contain hundreds of lines of code. Some tips for effective editing:

  • 🎨 Use Design and Code tabs:
    — Tab Design allows you to visually edit layouts (for example, drag and drop buttons).
    — Tab Code gives full control over the XML code.
    — Switch between them using keys Alt+Shift+Left/Right.
  • 🔍 Search and replace with regular expressions:
    — Press Ctrl+R to replace.
    — Use regex for complex replacements (for example, replace all android:layout_width="wrap_content" with match_parent).
    — To search by attributes, use .android:id="(@\+id/.?)".*.
  • 📋 Templates and live templates (Live Templates):
    — Enter <Button and click Tab — Android Studio will automatically append the template.
    — Customize your templates in File → Settings → Editor → Live Templates.

To check XML for errors, use the built-in validation: Android Studio highlights syntax errors in red and warnings in yellow. If the file is not saved, it most likely contains a critical error (for example, an unclosed tag or an invalid attribute).

⚠️ Attention: When editing AndroidManifest.xml avoid manually entering permissions. Instead, use Alt+Insert → Permissionto add the permission without errors. Incorrectly specified permission may cause the application to crash on some devices.

To work with large XML files (for example, complex layouts with many <include>), it is recommended to break them into smaller components. This improves performance Android Studio and simplifies code maintenance.

7. XML in multi-module projects: search features

If your project uses several modules (for example, :app, :feature-auth, :core-ui), searching for XML files becomes more complicated. Here's how to simplify the process:

  • 🗺️ Use Project mode:
    — Switch to the Project Files panel mode Projectto see the full structure of all modules.
    — Folders res/ will be duplicated in each module.
  • 🔗 Links to resources between modules:
    — To use an XML resource (for example, a layout) from one module in another, declare a dependency in build.gradle: 
    implementation project(':core-ui')

    — Access resources via @core_ui:layout/activity_main.
  • 🔍 Global search in all modules:
    — Ctrl+Shift+F searches in all modules simultaneously.
    — Specify the path relative to the module (for example, feature-auth/src/main/res/layout/).

In multi-module projects, the problem of duplication of resources often arises (for example, two modules contain strings.xml with the same keys). To avoid conflicts, use unique prefixes for resource names (for example, auth_login_button instead of just login_button).

If you can't find the XML file that should be in the project, check:

  1. Is the module excluded from the assembly (in settings.gradle).
  2. Is the file hidden in the settings Android Studio (for example, by a filter by name).
  3. Is the file deleted by mistake (check git status).

FAQ: Frequently asked questions about working with XML in Android Studio

Where is it stored AndroidManifest.xml in a multi-module project?

Each module has its own AndroidManifest.xmllocated in src/main/ this module is located in. module :app. During assembly, all manifests are combined (merged), and the final version can be seen in app/build/intermediates/merged_manifest/.

How to open an XML file from a library (for example, AppCompat)?

Files from external libraries (for example, .aar or .jar) cannot be edited directly. However, you can:

  1. View their contents through External Libraries in the panel Project (read only).
  2. Download the library sources (if they are open) and connect them as a module.
  3. Use decompilation tools (for example, JADX), but this violates the license agreements of most libraries.
Why does Android Studio not show changes in XML after saving?

This can happen due to several reasons:

  • The resource cache is not updated - run Build → Clean Project.
  • The file is in the wrong folder (for example, in assets/ instead of res/).
  • Error in the XML code - check the syntax highlighting (red lines indicate errors).
  • Problems with Instant Run —disable it in Settings → Build, Execution, Deployment → Instant Run.
Is it possible to rename an XML file without consequences?

Yes, but with caution:

  1. Use Refactor → Rename (Shift+F6) to Android Studio automatically updated all file references in the code.
  2. Check that the file name is not used explicitly in the code (for example, setContentView(R.layout.old_name)).
  3. Make sure the new name follows the rules (for example, lowercase and underscores only).

If the file is used in other modules, update links may require manual editing.

Where XML files for different configurations are stored (for example, land, night)?

Files for alternative configurations (orientation, theme, language, etc.) are stored in folders with qualifiers:

  • res/layout-land/ — layouts for landscape orientation.
  • res/values-night/ — resources for the dark theme.
  • res/layout-sw600dp/ — layouts for tablets (width ≥ 600dp).
  • res/values-ru/ — lines for Russian localization.

When the application starts, Android automatically selects the appropriate file based on the current device configuration.