Android Studio is an integrated development environment for creating Android apps on Windows, macOS, Linux and ChromeOS. It brings source editing, interface previews, Gradle builds and device testing into one workspace. Developers can work on apps for phones, tablets, foldables, watches and other Android devices, then examine both the running app and the package produced by the build.
App modules
An Android Studio project can contain an application alongside library modules. Each app module groups its manifest, Kotlin and Java code, and resources such as images and interface strings. This separates reusable code from the application that packages it, while keeping the files and build settings accessible within the same project.
Code editing
The editor provides code completion for Kotlin, Java and C/C++, with native development supported through the Android NDK. Code inspections and Android lint examine source files for problems such as incompatible API use, accessibility issues and resource mistakes. These checks can identify an Android-specific problem before it becomes something to investigate on a device.
Compose previews
For interfaces written with Jetpack Compose, Android Studio can display composable functions beside the code. Developers can preview and interact with the interface at different screen sizes, including foldable and multi-window configurations. Animation previews expose individual frames so that a transition can be examined without repeatedly trying to stop a running screen at the right moment.
Live Edit applies changes to composables on an emulator or physical device without a full build. Layout Inspector adds a view of the running Compose layout, including how often components are recomposed or skipped.
Gradle variants
Android Studio uses Gradle and the Android Gradle plugin to turn source code and resources into APK files or Android App Bundles. Build scripts control dependencies, SDK settings and packaging. Libraries can come from local files, other project modules or remote repositories, so their inclusion is part of the build configuration.
Build types and product flavors determine which app is produced. A debug build can include debugging support, while a release build uses its release settings and signing configuration. Optional product flavors allow different app editions to share common code while supplying their own resources or functionality. Combining a flavor with a build type creates a build variant, letting one project produce several distinct packages.
Code and resource shrinking can remove unused material from the resulting app. Release signing also belongs to the build configuration; Android Studio’s default debug signing does not supply the release signing settings needed for distribution.
Device emulation
The Android Emulator runs virtual Android devices on the development computer. Each Android Virtual Device defines an Android system image and hardware characteristics, with separate storage for its app data. Developers choose that virtual device as a run target and interact with its screen using a mouse and keyboard.
Beyond displaying the app, the emulator can change conditions such as orientation, location and network speed. Phone, tablet, watch, TV and automotive device profiles let developers examine behavior across different Android targets. A foldable device can switch between folded and unfolded states, making layout changes part of the test. Android Studio can also run an app on a connected physical device.
Runtime debugging
Android Studio’s debugger pauses a debuggable app at selected lines, method calls, field accesses or exceptions. With execution stopped, developers can inspect variables, evaluate expressions and move through the code. Conditional breakpoints restrict a pause to a particular state; logging breakpoints record information without stopping the app.
Java and Kotlin debugging can be combined with LLDB for C and C++ code in the same app. Logcat provides another view of execution through device and application messages, including exception stack traces. Filtering that output helps isolate a failure while reproducing it on the chosen device.
Performance profiling
The profiling tools examine CPU activity, memory use, graphics performance and network requests while an app runs. Memory allocation tracking links created objects to the actions that produced them. A heap snapshot gives a more detailed view of classes, their instances and the references between objects, helping investigate retained memory and possible leaks.
Android Studio keeps the resulting recordings available for further analysis.
APK analysis
APK Analyzer opens a built APK or Android App Bundle and displays its contents as a file tree. Developers can inspect the final merged manifest, compiled DEX code and packaged resources, including images and translated strings. Size information shows which files contribute to the package, and a comparison between two artifacts reveals where their contents or sizes differ.
Build variants, library manifests and shrinking rules can all make the packaged app differ from the source project. The DEX viewer exposes classes and method references; loading a matching obfuscation map can restore original names for inspection.
Gemini in Android Studio
Gemini in Android Studio adds an account-based assistant for Android development questions and code generation. It can help investigate Gradle errors, work on Compose interfaces and analyze crashes through its integrations with Logcat and App Quality Insights.
The individual free edition has a smaller context window. Usage billed through an API key and eligible Google One memberships offer additional capacity, while business offerings add higher quotas and administrative controls. These service choices are separate from the editor, local builds and emulator workflow.
