The following are new features in Android Studio Bumblebee.

## Support for KMP test execution

You can run tests for Kotlin Multiplatform (KMP) projects from Android Studio Bumblebee.

In order to ensure your tests run successfully from Android Studio, make sure you have all the requirements below:

- AGP 7.0.0-alpha08 or higher
- Gradle 6.8.2 or higher
- Kotlin plugin 1.4.30 or higher

## New Device Manager

![New Device Manager window with](https://developer.android.com/static/studio/images/run/new-device-manager.png)

The**Device Manager**is a stand-in replacement for the AVD Manager, both from Android Studio's Welcome Screen or after you open a project. The Device Manager introduces some new capabilities that make this feature more easy to create and manage all of your local test devices, such as:

- A more flexible UI that supports being docked in the IDE, floating, or in a separate window, like you can with other Android Studio tool windows. This gives you easier access to your devices without obstructing other windows of the IDE.
- A**Virtual**tab that allows you to create, manage, and deploy virtual devices; see details of each device at a glance; or quickly inspect the device in the Device File Explorer with a single click.
- A**Physical**tab that allows you to quickly pair to a new device using ADB Wifi and see details of each physical device at a glance. You can also quickly inspect each device's file system using the Device File Explorer with a click of a button.

To open the new**Device Manager**, do one of the following:

- From the Android Studio Welcome screen, select**More Actions \> Virtual Device Manager**.

| **Note:** You can currently create and manage only virtual devices from the welcome screen.

- After opening a project, select**View \> Tool Windows \> Device Manager**from the main menu bar.

## New in Layout Inspector

### Capture layout hierarchy snapshots

Layout Inspector now allows you to save snapshots of your running app's layout hierarchy, so that you can easily share them with others or refer to them later.

Snapshots capture the data you would typically see when using the Layout Inspector, including a detailed 3D rendering of your layout, the component tree of your View, Compose, or hybrid layout, and detailed attributes for each component of your UI. To save a snapshot, do the following:

1. Deploy your app to a device running API level 23 or higher
2. Open the Layout Inspector by selecting**View \> Tool Windows \> Layout Inspector**.
3. The Layout Inspector should connect to your app process automatically. If not, select the app process from the dropdown menu.
4. When you want to capture a snapshot, click**Export snapshot** ![Export icon](https://developer.android.com/static/studio/images/debug/export-icon.png)from the Layout Inspector toolbar.
5. In the system dialog that appears, specify the name and location you want to save your snapshot. Make sure to save the file with a`*.li`extension.

You can then load a Layout Inspector snapshot by selecting**File \> Open** from the main menu bar, and opening a`*.li`file.

![Layout inspector snapshot for the Sunflower sample app](https://developer.android.com/static/studio/images/debug/layout-inspector.png)

### Support for inspecting Compose semantics

In Compose,[Semantics](https://developer.android.com/jetpack/compose/semantics)describe your UI in an alternative manner that is understandable for[Accessibility](https://developer.android.com/jetpack/compose/accessibility)services and for the[Testing](https://developer.android.com/jetpack/compose/testing)framework. In Android Studio Bumblebee, you can now use the Layout Inspector to inspect semantic information in your Compose layouts.

![Semantic information displayed via the Layout Inspector](https://developer.android.com/static/studio/images/debug/layout-inspector-semantic-info.png)

When selecting a Compose node, use the**Attributes** window to check whether it declares semantic information directly, merges semantics from its children, or both. To quickly identify which nodes include semantics, either declared or merged, use select the**View options** dropdown in the**Component Tree** window and select**Highlight Semantics Layers**. This highlights only the nodes in the tree that include semantics, and you can use your keyboard to quickly navigate between them.

### Avoid Activity restarts

Connecting the Layout Inspector to a running app on older versions of Android Studio would cause your app's Activity to restart. This is required to set a device flag that enables inspection of your app's layouts.

In Android Studio Bumblebee, you can avoid Activity restarts when connecting the Layout Inspector by setting this flag ahead of time using one of the following steps:

- Enable a Run Configuration option

  1. Select**Run \> Edit Configurations** from the main menu bar. The**Run/Debug Configurations**dialog appears.
  2. Navigate to the run configuration you would like to use.
  3. In the**Layout Inspector options** section, check the box next to**Connect to Layout Inspector without restarting activity**.
  4. Use the run configuration the next time you want to inspect your app using the Layout Inspector.
- Set the flag from the command line:

  1. Open a terminal window on the machine that's connected to your device
  2. Set the device flag for your app using the following command:

      adb shell settings put global debug_view_attributes_application_package <my_package_name>

  1. Deploy your app to the device and connect the Layout Inspector. Android Studio will check whether the flag is set and avoid restarting the Activity if possible.

| **Note:** While typically not noticeable, setting this device flag when not using the Layout Inspector might affect the app's performance.

### Document Layout Inspector snapshots

You can now capture snapshots of your app's layout hierarchy to save, share, or inspect later. Snapshots capture the data you would typically see when using the Layout Inspector, including a detailed 3D rendering of your layout, the component tree of your View, Compose, or hybrid layout, and detailed attributes for each component of your UI. When inspecting the layout of a live running app, click**Export snapshot** ![Export icon](https://developer.android.com/static/studio/images/debug/export-icon.png)from the Layout Inspector toolbar and save the snapshot with an`*.li`extension. You can then load a Layout Inspector snapshot by selecting**File \> Open** from the main menu bar, and opening a`*.li`file. The snapshot appears in a tab in the Editor window, so that you can easily compare it with your running app.

![](https://developer.android.com/static/studio/images/debug/layout-inspector-snapshot.gif)

## New in App Inspection

In Android Studio Bumblebee, there are new tools and functionalities in the App Inspection window. You can open the**App Inspector** by selecting**View \> Tool Windows \> App Inspection**from the main menu bar.

### Network Inspector

The Network Profiler in the**Profilers** tool window has now moved to the**App Inspection** tool window. If you've previously used the Network Profiler, all the same features and rich network traffic data is still available. Simply deploy your app to a device running API level 26 and higher and open the**App Inspector \> Network Inspector**tab.

### Inspect Jobs, Alarms, and Wakelocks

The**Background Task Inspector** now allows you to inspect your app's Jobs, Alarms, and Wakelocks, in addition to the existing support for inspecting Workers. Each type of asynchronous task now appears under the appropriate heading in the inspector tab, allowing you to easily monitor its status and progress. Similar to Workers, you can select a Job, Alarm, or Wakelock to inspect its detailed information in the**Task Details**panel.

![Background Task Inspector showing Jobs, Alarms, and Wakelocks](https://developer.android.com/static/studio/images/inspect/background-task-inspector.png)
| **Note:** This functionality has been migrated from the[Energy profiler](https://developer.android.com/studio/profile/energy-profiler). So you should now use the**Background task inspector**to inspect all of your app's asynchronous tasks.

Because Workers use Jobs and Wakelocks under the hood, those tasks that are scheduled by Workers appear as children of each Worker. Keep in mind, you can only see Workers in the**Graph mode.**

## New in Profilers

In Android Studio Bumblebee, there are new features that give you more insight into how your app uses resources. To profile your app, select**View \> Tool Windows \> Profiler**from the main menu bar.

### Jank detection track

When profiling your app using devices running Android 11 (API level 30) or higher, the CPU profiler now shows a new group of tracks that illustrate the stages of each frame under**Frame Lifecycle** :**Application** ,**Wait for GPU** ,**Composition** and**Frames on display** . Each track labels the frames with a frame number and color-codes the rectangle to make it easy for you to visualize where a particular frame is in its lifecycle, along with guides you can toggle to compare with Vsync events. You can use this data to understand where jank might occur in your app and investigate the root causes. In the**Analysis** panel, there is now a**Frames** tab, which conveniently summarizes rendering information for all frames. For more information, see[UI jank detection](https://developer.android.com/studio/profile/jank-detection).

### Profileable app profiling support

When profiling your app, it's important to generate accurate data with the version of your app that most closely resembles what your users will install. To do so, you can now include the[`<profileable>`](https://developer.android.com/guide/topics/manifest/profileable-element)property in your app's manifest to profile apps that are not debuggable, as shown by the following code.  

    <profileable android:shell="true"/>

Profileable is a manifest configuration introduced in Android 10, and is available for CPU and Memory profiling tasks. Using the profileable flag instead of the debuggable flag has the key advantage of lower overhead for performance measurement; however, certain profiling features are not available for Profileable builds, such as the Event timeline, API initiated CPU profiling, heap dumps, or live location recordings. For more information, see[Profileable applications](https://developer.android.com/studio/profile#profileable-apps).

### Collapse callstack frames

You can now collapse frames that are irrelevant to your investigation when inspecting a**Callstack Sample Recording** in the**Profilers** tool window. Callstacks are useful to understand which part of the code has been executed, and why it was invoked. However, the callstack for a Java/Kotlin program usually includes not only Java/Kotlin code, but also frames from native code that can be distracting. To learn more about refining the callstack view, see[Inspect callstack frames](https://developer.android.com/studio/profile/inspect-traces#callstack-frame).

## Wireless debugging

Android Studio Bumblebee supports the wireless debugging feature on Android 11 and higher devices. Pair and deploy your app from Android Studio over Wi-Fi without using a USB cable or managing Android Debug Bridge (adb) connections using the command line. To use, navigate to the**Pair devices using Wi-Fi** option from the device selection menu, and then either choose a QR code or Pairing PIN Code. Then on your Android 11 and higher device, under**Developer options** , and find the**Wireless Debugging** screen and initialize and connect to an adb session wirelessly with Android Studio. Learn more about the wireless debugging setup at[Connect to a device over Wi-Fi (Android 11+)](https://developer.android.com/studio/command-line/adb#connect-to-a-device-over-wi-fi-android-11+).

![Pairing a device over Wi-Fi](https://developer.android.com/static/studio/images/releases/wireless-debugging.gif)

## Compose interactive preview enabled by default

Starting with Android Studio Bumblebee, the interactive preview feature is enabled by default. The interactive preview allows you to interact with a preview as it would work on a device. The interactive preview is isolated from other preview in a sandbox environment, where you can click elements and enter user input in the preview. It's a quick way to test different states and gestures of your composable, like a checkbox being checked or empty.

Preview interactive mode runs directly inside Android Studio without an emulator running, which results in some limitations:

- No network access.
- No file access.
- Some Context APIs may not be fully available.

![User interacting with a preview inside Android Studio](https://developer.android.com/static/studio/images/releases/interactive-preview.gif)

## Animated Vector Drawable (AVD) preview

The Animated Vector Drawable tool offers the ability to preview animated drawable resources. This tools helps you preview`<animation-list>`,`<animated-vector>`, and`<animated-selector>`resources in Android Studio and makes it easier to refine your custom animations.

![User previewing and playing an animation inside Android Studio](https://developer.android.com/static/studio/images/releases/avd-preview.gif)

## Non-transitive R classes on by default

Non-transitive R classes are now on by default. You can use non-transitive R classes with the Android Gradle plugin to build faster builds for applications with multiple modules. Doing so helps prevent resource duplication by ensuring that each module's R class only contains references to its own resources, without pulling references from its dependencies. This leads to more up-to-date builds and the corresponding benefits of compilation avoidance.

You can get help using this feature by going to**Refactor \> Migrate to Non-Transitive R Classes...**

## Apple Silicon support update

For those using macOS on Apple Silicon (arm64) hardware, Android Studio Arctic Fox and the Android Emulator have supported this new architecture since last year. However, with this release, we have now updated the Android SDK platform tools v32.0.0 (which includes adb and fastboot) and build tools v32.1.0 (which includes aapt) to be universal binaries so that your Android developer tools no longer need the Rosetta binary translator to run. See the[SDK platform tools release notes](https://developer.android.com/studio/releases/platform-tools#revisions).

## Updated device picker for design tools

To simplify designing your app for the diverse number of Android devices, we've updated the device picker in various design tool windows, such as Layout Editor and Layout Validation, with reference devices that reflect popular sizes of each device form factor. From phones to tablets, and Wear devices to Android TVs, it's now easier to preview, validate, or edit your layout on screen sizes that are most representative of popular real-world devices.

![Device picker with devices and their size and density, grouped by class](https://developer.android.com/static/studio/images/releases/new-device-picker.png)

## Android testing

Android Studio Bumblebee and AGP 7.1 introduce several new features and improvements to help you more reliably and scalably run your automated instrumentation tests and see useful results you can use to debug issues.

### Unified Gradle test runner

Android Gradle plugin 7.1.0 and Android Studio Bumblebee and higher use Gradle's own implementation of the Android instrumented test runner to run instrumented tests. By using the same test runner, results are likely to be consistent whether you run using AGP from the command line, such as on a continuous integration server, or from Android Studio.

![Unified Gradle test runner in Bumblebee](https://developer.android.com/static/studio/images/test/consolidated-test-runner.png)

Previous versions of Android Studio use the IntelliJ Android instrumented test runner instead of Gradle's Android instrumented test runner. So if you're not using the latest version of Android Studio, depending on whether you run your tests from Android Studio or from the command line using the Gradle plugin, you might see different test results, such as tests passing using one runner and failing on another.

![Discrete test runners in older versions of Android Studio](https://developer.android.com/static/studio/images/test/no-consolidated-test-runner.png)

If you already have instrumented test configurations saved to your project, they'll use Gradle to run tests on your connected device. You can create a new instrumented test configuration using the gutter action next to your test class or method, as shown below.

![Run tests from gutter action](https://developer.android.com/static/studio/images/test/run-test-from-gutter.png)

When running your instrumented tests, you can confirm that Android Studio is using the Gradle test runner by inspecting the test output in the Test Matrix for Gradle task output. Although we are improving this feature with each release of Android Studio, there are some known issues. If you are experiencing issues, please[report a bug](https://issuetracker.google.com/issues/new?component=192708&title=%5BUTP%5D+%5BIssue+title%5D&template=840533). You can also[disable the new testing pipeline](https://developer.android.com/studio/releases/past-releases/as-bumblebee-release-notes#disable-utp)to revert to the old behavior.

#### Android Emulator now runs directly inside Android Studio by default

The Android Emulator runs directly inside Android Studio by default. This allows you to conserve screen real estate, navigate quickly between the emulator and the editor window using hotkeys, and organize your IDE and emulator workflow in a single application window.

![The emulator launching in a tool window in Android Studio.](https://developer.android.com/static/studio/images/releases/emulator-tool-window.gif)

When the emulator is running, you'll have access to common emulator actions like rotating, and extended control options like navigation playback. To run the emulator in a separate window instead go to**File \> Settings \> Tools \> Emulator** (**Android Studio \> Preferences \> Tools \> Emulator** on macOS) and deselect**Launch in a tool window**.

#### Disable the new testing pipeline

By default Android Studio Bumblebee uses Gradle to run its instrumentation tests. If you're experiencing issues, you can disable this behavior as follows:

1. Select**File \> Settings \> Build, Execution, Deployment \> Testing** (or**Android Studio \> Preferences \> Build, Execution, Deployment \> Testing**on MacOS.)
2. Uncheck the box next to**Run Android instrumented tests using Gradle** and click**OK**.

You can also revert to older behaviors by doing one of the following:

- When running Gradle tasks from the command line, use the following command line parameter:`-Pandroid.experimental.androidTest.useUnifiedTestPlatform=false`
- Add the following parameter to your project's`gradle.properties`file:`android.experimental.androidTest.useUnifiedTestPlatform=false`

To help resolve issues that you might be expereincing, please[report a bug](https://issuetracker.google.com/issues/new?component=192708&title=%5BUTP%5D+%5BIssue+title%5D&template=840533).

## Patch releases

The following are patch releases in Android Studio Bumblebee.  
**Android Studio Bumblebee \| 2021.1.1 Patch 3 (April 2022)**

This minor update includes the following bug fixes:

- Android Gradle plugin
  - Duplicate class issues reported by R8
- Build Variants
  - `versionNameSuffix`no longer works if the variant's version name is set via the new onVariants API
- Compose Preview
  - Performance and stability related bug fixes.
  - Solve freeze that occurred occasionally when using the Live Edit of Literals feature.
- Import/Sync
  - "Gradle sync needed" message has redundant AGP versions
  - Recompile Foo.java/kt cleans too much and does not recompile the right component
- Project Structure
  - AGP Upgrade Assistant stability improvements when changing target versions
  - AGP Upgrade Assistant now informs users about Gradle plugins being upgraded
- Network Inspector
  - New Network inspector crashes after Bumblebee update
  - I am constantly getting this error when the debugger is connected on the latest version of Android Studio.
  - `TrackedHttpURLConnection.getHeaderField`crashes with`NullPointerException`

For more information, see the[Android Studio Bumblebee Patch 3 blog post](https://androidstudio.googleblog.com/2022/04/android-studio-bumblebee-202111-patch-3.html).

**Android Studio Bumblebee \| 2021.1.1 Patch 2 (February 2022)**

This update includes the following bug fixes:

- C++ Build
  - `ModelCache.safeGet(androidProjectResult.androidProject::getNdkVersion, "")`must not be null
- Code Editor
  - Bug in Android Studio Live Templates - the`className()`expression is not resolving the class name
- D8/R8
  - `java.lang.NoSuchMethodError`: No static method`$jacocoInit`
  - Android test coverage broken due to Mockito error
  - Need workaround for broken CAS implementation on API 31
  - Sealed classes are not supported
  - `NullPointerException`when enabling horizontal class merging in Chrome
  - `AbstractMethodError`after virtual method merging
  - Failure to verify stack frames due to incorrect init-class out-type
  - Dex input uses a register that is not defined
  - `StringBuilderOptimizerAnalysisTest`is failing on release branches
  - Non-determinism in R8
- Deployment
  - Running the project of a device owner application fails with`Couldn't terminate the existing process for`error message
- Design Tools
  - Compose Previews fail to find resources from other modules when non-transitive R classes is enabled
  - Studio freezes on build.
- Embedded Emulator
  - Miscellaneous performance and stability improvements.
- Import/Sync
  - IDE error when launching Bumblebee: Output listing build file is not available for output type Apk in`IdeBuildTasksAndOutputInformationImp`
- IntelliJ
  - Env variables not sourced when launched from Mac OS X Monterey Dock
- Jetpack (androidx) \> Navigation
  - Upgrade SafeArgs to be built on latest stable AGP
- Tools Windows
  - Can't run Android Device Manager
  - Network Inspector in BumbleBee doesn't show the api response in readable format

For more information, see the[Android Studio Bumblebee Patch 2 blog post](https://androidstudio.googleblog.com/2022/02/android-studio-bumblebee-202111-patch-2.html).

**Android Studio Bumblebee \| 2021.1.1 Patch 1 (February 2022)**

This minor update includes the following bug fixes:

- Emulator
  - Unable to connect to embedded emulator after upgrading to Bumblebee (Mac M1)
- IntelliJ
  - Env variables not sourced when launched from Mac OS X Monterey Dock

For more information, see the[Android Studio Bumblebee Patch 1 blog post](https://androidstudio.googleblog.com/2022/04/android-studio-bumblebee-202111-patch-3.html).