When using the Data Binding Library,
LiveDataListener.onChanged() might fail with a NPE. A fix
for this issue will be included in Android Studio 3.4.1 and is already
available in the latest
Preview version of Android Studio 3.5.
(See
issue #122066788)

IntelliJ IDEA 2018.3.4

The core Android Studio IDE has been updated with improvements from IntelliJ
IDEA through the
2018.3.4 release.

Android Gradle plugin 3.4.0 updates

For information on what’s new in Android Gradle plugin 3.4.0, see its release
notes.

New Project Structure Dialog

The new Project Structure Dialog (PSD) makes it easier to update
dependencies and configure different aspects of your project, such as modules,
build variants, signing configurations, and build variables.

You can open the PSD by selecting File > Project Structure from the menu
bar. You can also open the PSD by pressing Ctrl+Shift+Alt+S on Windows and
Linux, or Command+; (semicolon) on macOS. You can find descriptions of some of
the new and updated sections of the PSD below.

Variables

The new variables section of the PSD allows you to create and manage build
variables, such as those to keep version numbers for dependencies consistent
across your project.

Add new build variables at a project- or module-level directly from the PSD.

Note: If your existing build configuration files assign values through complex
Groovy scripts, you may not be able to edit those values through the PSD.
Additionally, you can not edit build files written in Kotlin using the PSD.

Modules

Configure properties that are applied to all build variants in an existing
module or add new modules to your project from the Modules section. For
example, this is where you can configure defaultConfig properties or manage
signing configurations.

Dependencies

Inspect and visualize each dependency in the dependency graph of
your project, as resolved by Gradle during project sync, by following these
steps:

In the left pane of the PSD, select Dependencies.

In the Modules pane, select a module for which you’d like to inspect the
resolved dependencies.

On the right side of the PSD, open the Resolved Dependencies pane, which
is shown below.

You can also quickly search for and add dependencies to your project by first
selecting a module from the Dependencies section of the PSD, clicking
the (+) button in the Declared Dependencies section, and selecting the type
of dependency you want to add.

Depending on the type of dependency you select, you should see a dialog,
similar to the one below, that helps you add the dependency to the module.

Build Variants

In this section of the PSD, create and configure build variants and product
flavors for each module in your project. You can add manifest placeholders, add
ProGuard files, and assign signing keys, and more.

Suggestions

See suggested updates for project dependencies and build variables in the
Suggestions section, as shown below.

New Resource Manager

Resource Manager is a new tool window for importing, creating, managing, and
using resources in your app. You can open the tool window by selecting
View > Tool Windows > Resource Manager from the menu bar. The Resource
Manager allows you to do the following:

Visualize resources: You can preview drawables, colors, and layouts to
quickly find the resources you need.

Bulk import: You can import multiple drawable assets at once by either
dragging and dropping them into the Resource Manager tool window or by
using the Import drawables wizard. To access the wizard, select the (+)
button at the top-left corner of the tool window, and then select
Import Drawables from the drop down menu.

Convert SVGs into VectorDrawable objects: You can use the
Import Drawables wizard to convert your SVG images into VectorDrawable
objects.

Drag and drop assets: From the Resource Manager tool window, you can
drag and drop drawables onto both the design and XML views of the Layout
Editor.

View alternative versions: You can now view alternative versions of your
resources by double-clicking a resource within the Tool window. This view
shows the different versions you have created and the qualifiers that were
included.

Tile and list views: You can change the view within the tool window to
visualize your resources in different arrangements.

Checking build IDs when profiling and debugging APKs

When you provide debugging symbol files for the .so shared libraries inside
your APK, Android Studio verifies that the
build ID of the provided symbol files match
the build ID of the .so libraries inside the APK.

If you build the native libraries in your APK with a build ID, Android Studio
checks whether the build ID in your symbol files matches the build ID in your
native libraries and rejects the symbol files if there is a mismatch. If
you did not build with a build ID, then providing incorrect symbol files may
cause problems with debugging.

R8 enabled by default

R8 integrates desugaring, shrinking, obfuscating,
optimizing, and dexing all in one step—resulting in
noticeable build performance improvements.
R8 was introduced in Android Gradle plugin 3.3.0 and
is now enabled by default for both app and Android library projects using
plugin 3.4.0 and higher.

The image below provides a high-level overview of the compile process
before R8 was introduced.

Now, with R8, desugaring, shrinking, obfuscating, optimizing, and dexing (D8)
are all completed in one step, as illustrated below.

Keep in mind, R8 is designed to work with your existing ProGuard rules, so
you’ll likely not need to take any actions to benefit from R8. However,
because it’s a different technology to ProGuard that’s designed specifically
for Android projects, shrinking and optimization may result in removing code
that ProGuard may have not. So, in this unlikely situation, you might need to
add additional rules to keep that code in your build output.

If you experience issues using R8, read the
R8 compatibility FAQ
to check if there’s a solution to your issue. If a solution isn’t documented,
please report a bug.
You can disable R8 by adding one of the following lines to your project’s
gradle.properties file:

Note: For a given build type, if you set useProguard to false in your app
module's build.gradle file, the Android Gradle plugin uses R8 to shrink your
app's code for that build type, regardless of whether you disable R8 in your
project's gradle.properties file.

Navigation Editor now supports all argument types

All argument types supported by the Navigation component are now supported in
the Navigation Editor. For more information on supported types, see
Pass data between destinations.

Layout Editor improvements

The Attributes pane in the Layout Editor has been streamlined into a single
page with sections you can expand to reveal attributes you can configure. The
Attributes pane also includes the following updates:

A new Declared Attributes section lists the attributes the layout file
specifies and allows you to quickly add new ones.

The Attributes pane now also features indicators next to each attribute
that are solid when the attribute's value is a resource reference
and empty
otherwise.

Attributes with errors or warnings are now highlighted. Red highlights
indicate errors (for example, when you use invalid layout values) and
orange highlights indicate warnings (for example, when you use hard-coded
values).

New intention action to quickly import dependencies

If you start using certain Jetpack and Firebase classes in your code, a new
intention action suggests adding the required Gradle library dependency to your
project, if you haven’t already done so. For example, if you reference the
WorkManager class without first importing the required
android.arch.work:work-runtime dependency, an intention action lets you do so
easily in a single click, as shown below.

In particular, because Jetpack repackaged the support library into discrete
packages that are easier to manage and update, this intention action helps you
quickly add only the dependencies you need for the Jetpack components you want
to use.

3.3 (January 2019)

Android Studio 3.3 is a major release that includes a variety of new features
and improvements.

3.3.2 (March 2019)

This minor update includes various bug fixes and performance improvements.
To see a list of noteable bug fixes, read the related post on the
Release Updates blog.

3.3.1 (February 2019)

This minor update includes various bug fixes and performance improvements.

IntelliJ IDEA 2018.2.2

The core Android Studio IDE has been updated with improvements from IntelliJ
IDEA through the
2018.2.2 release.

Android Gradle plugin updates

For information on what’s new in the Android Gradle plugin, see its
release notes.

Delete unused Android Studio directories

When you run a major version of Android Studio for the first time, it looks for
directories containing caches, settings, indices, and logs for versions of
Android Studio for which a corresponding installation can’t be found. The
Delete Unused Android Studio Directories dialog then displays locations,
sizes, and last-modified times of these unused directories and provides an
option to delete them.

The directories Android Studio considers for deletion are listed below:

Create New Project wizard

Profiler updates

Android Studio 3.3 includes updates to several of the individual profilers.

Improved performance

Based on user feedback, rendering performance while using the profilers has been
greatly improved. Please continue to
provide feedback,
especially if you continue to see performance issues.

Profiler memory allocation tracking options

To improve app performance while profiling, the
Memory Profiler now samples memory
allocations periodically by default. If desired, you can change this behavior by
using the Allocation Tracking dropdown when testing on devices running
Android 8.0 (API level 26) or higher.

Using the Allocation Tracking dropdown, you can choose from the following
modes:

Full: captures all object memory allocations. Note that if you have an app
that allocates a lot of objects, you might see significant performance issues
while profiling.

Sampled: captures a periodic sample of object memory allocations. This is
the default behavior and has less impact on app performance while profiling.
You might encounter some performance issues with apps that allocate a lot of
objects within a short time period.

Off: turns memory allocation off. If not already selected, this mode is
enabled automatically while taking a CPU recording and then returned to the
previous setting when the recording is finished. You can change this behavior
in the CPU recording configuration dialog.

The tracking affects both Java objects and JNI references.

Inspect frame rendering data

In the CPU Profiler, you can now inspect how
long it takes your Java app to render each frame on the main UI thread and
RenderThread. This data might be useful when investigating bottlenecks that
cause UI jank and low framerates. For example, each frame that takes longer than
the 16ms required to maintain a smooth framerate is displayed in red.

To see frame rendering data, record a trace
using a configuration that allows you to Trace System Calls. After recording
the trace, look for info about each frame along the timeline for the recording
under the section called FRAMES, as shown below.

To learn more about investigating and fixing framerate issues, read
Slow rendering.

Fragments in the event timeline

The event timeline now shows when fragments are attached and detached.
Additionally, when you hover over a fragment, a tooltip shows you the fragment
status.

Automatic downloading of SDK components

When your project needs an SDK component from the SDK platforms, NDK, or CMake,
Gradle now attempts to automatically download the required packages as long as
you’ve previously accepted any related license agreements using the SDK Manager.

Support for Clang-Tidy

Android Studio now includes support for static code analysis using
Clang-Tidy for projects that include
native code. To enable support for Clang-Tidy,
update your NDK to r18 or higher.

You can then enable or re-enable the inspections by opening the Settings or
Preferences dialog and navigating to
Editor > Inspections > C/C++ > General > Clang-Tidy. When selecting this
inspection in the Settings or Preferences dialog, you can also see the
list of Clang-Tidy checks that are enabled and disabled under the
Option section of the right-most panel. To enable
additional checks,
add them to the list and click Apply.

To configure Clang-Tidy with additional options,
click Configure Clang-Tidy Checks Options and add them in the dialog that
opens.

Removal of options for C++ customization

The following options have been removed from the Customize C++ Support
dialog:

Exceptions Support (-fexceptions)

Runtime Type Information Support (-ftti)

The respective behaviors are enabled for all projects created through Android Studio.

CMake version 3.10.2

CMake version 3.10.2 is now included with SDK Manager. Note that Gradle still
uses version 3.6.0 by default.

To specify a CMake version for Gradle to use, add the following to your module’s
build.gradle file:

New “+” syntax to specify minimum CMake versions

When specifying a version of CMake in your main module’s build.gradle file,
you can now append a “+” to match the behavior of CMake’s
cmake_minimum_required()
command.

Caution: Using "+" syntax with other build dependencies
is discouraged, as dynamic dependencies can cause unexpected version updates and
difficulty resolving version differences.

Android App Bundles now support Instant Apps

Android Studio now lets you build Android App Bundles with
full support for Google Play Instant. In
other words, you can now build and deploy both installed app and instant
experiences from a single Android Studio project and include them in a single
Android App Bundle.

If you’re creating a new Android Studio project using the Create New Project
dialog, make sure you check the box next to
Configure your project > This project will support instant apps. Android
Studio then creates a new app project as it normally would, but includes the
following properties in your manifest to add Instant app support to your app’s
base module:

You can then
create an instant-enabled dynamic feature
module by selecting File > New > New Module from the menu bar and then
selecting Instant Dynamic Feature Module from the Create New Module
dialog. Keep in mind, creating this module also instant-enables your app’s base
module.

To deploy your app to a local device as an instant experience,
edit your run configuration and check the
box next to General > Deploy as instant app.

Single-variant project sync

Syncing your project with your build configuration
is an important step in letting Android Studio understand how your project is
structured. However, this process can be time-consuming for large projects. If
your project uses multiple build variants, you can now optimize project syncs by
limiting them to only the variant you have currently selected.

You need to use Android Studio 3.3 or higher with Android Gradle plugin 3.3.0
or higher to enable this optimization. When you meet these requirements, the
IDE prompts you to enable this optimization when you sync your project. The
optimization is also enabled by default on new projects.

Note: This optimization currently supports projects that include only the Java
programming language. If, for example, the IDE detects Kotlin or C++ code in
your project, it does not automatically enable this optimization, and you should
not enable it manually.

Provide quick feedback

If you've opted into sharing usage statistics to help improve Android Studio,
you'll see these two new icons in the status bar at the bottom of the IDE
window:

Simply click the icon that best represents your current experience with the IDE.
When you do so, the IDE sends usage statistics that allow the Android Studio
team to better understand your sentiment. In some cases, such as when you
indicate a negative experience with the IDE, you'll have an opportunity to
provide additional feedback.

If you haven't already done so, you can enable sharing usage statistics by
opening the Settings dialog (Preferences on a Mac), navigating to
Appearance & Behavior > System Settings > Data Sharing, and checking
Send usage statistics to Google.

3.2 (September 2018)

Android Studio 3.2 is a major release that includes a variety of new features
and improvements.

3.2.1 (October 2018)

This update to Android Studio 3.2 includes the following changes and fixes:

The bundled Kotlin version is now 1.2.71.

The default build tools version is now 28.0.3.

In the Navigation library, argument types have been renamed from
type to argType.

The following bugs have been fixed:

When using the Data Binding library, variable names with underscores
were causing compilation errors.

CMake was causing IntelliSense and other CLion features to
fail.

Adding a SliceProvider was causing compilation errors
in projects that did not use androidx.* libraries.

Some Kotlin unit tests were not being run.

An issue with data binding was causing a
PsiInvalidElementAccessException.

<merge> elements were sometimes causing
the Layout Editor to crash.

3.2.0 known issues

Note: These issues have been resolved in Android Studio
3.2.1

We strongly recommend against using Kotlin version 1.2.70.

Kotlin version 1.2.61 fixes a bug that can cause Android Studio to hang,
but Kotlin 1.2.70 does not include this fix.

Kotlin versions 1.2.71 and later, however, do include this fix.

Although you typically don't need to specify the build tools version,
when using Android Gradle plugin 3.2.0 with
renderscriptSupportModeEnabled set to true, you
need to include the following in each module's build.gradle
file:

android.buildToolsVersion "28.0.3"

What's New Assistant

A new assistant informs you about the latest changes in Android Studio.

The assistant opens when you start Android Studio after a fresh installation or
update if it detects that there is new information to show. You can also open
the assistant by choosing Help > What's new in Android Studio.

Android Jetpack

Android Jetpack helps to accelerate Android development with components, tools,
and guidance that eliminate repetitive tasks and enable you to more quickly and
easily build high-quality, testable apps. Android Studio includes the following
updates to support Jetpack. For more information, see the
Jetpack documentation.

Navigation Editor

The new Navigation Editor integrates with the navigation components of Android
Jetpack to provide a graphical view for creating the navigation structure of
your app. The Navigation Editor simplifies the design and implementation of
navigation between in-app destinations.

In Android Studio 3.2, the Navigation Editor is an experimental feature. To
enable the Navigation Editor, click File > Settings
(Android Studio > Preferences on Mac), select the Experimental category
in the left pane, check the box next to Enable Navigation Editor, and
restart Android Studio.

AndroidX migration

As part of Jetpack, we are migrating the Android Support Libraries to a new
Android extension library using the androidx namespace. For more
information, see the
AndroidX overview.

Android Studio 3.2 helps you through this process with a new migration feature.

To migrate an existing project to AndroidX, choose Refactor > Migrate to
AndroidX. If you have any Maven dependencies that have not migrated to the
AndroidX namespace, the Android Studio build system also automatically converts
those project dependencies.

The Android Gradle plugin provides the following global flags that you can set
in your gradle.properties file:

android.useAndroidX: When set to true, this flag
indicates that you want to start using AndroidX from now on. If the flag is
absent, Android Studio behaves as if the flag were set to false.

android.enableJetifier: When set to true, this
flag indicates that you want to have tool support (from the Android Gradle
plugin) to automatically convert existing third-party libraries as if they
were written for AndroidX. If the flag is absent, Android Studio behaves as
if the flag were set to false.

Both flags are set to true when you use the Migrate to AndroidX command.

If you want to start using AndroidX libraries immediately and don't need to
convert existing third-party libraries, you can set the
android.useAndroidX flag to true and the
android.enableJetifier flag to false.

Android App Bundle

Android App Bundle is a new upload format that includes all of your app’s
compiled code and resources, but defers APK generation and signing to the Google
Play Store.

Google Play’s new app serving model, called Dynamic Delivery, then uses your
app bundle to generate and serve optimized APKs for each user’s device
configuration, so each user downloads only the code and resources they need to
run your app. You no longer need to build, sign, and manage multiple APKs, and
users get smaller, more optimized downloads.

Additionally, you can add dynamic feature modules to your app project and
include them in your app bundle. Through Dynamic Delivery, your users can then
download and install your app’s dynamic features on demand.

For more information, including instructions for building and analyzing an
Android App Bundle, see
Android App Bundle.

Sample data in Layout Editor

Many Android layouts have runtime data that can make it difficult to visualize
the look and feel of a layout during the design stage of app development. You
can now easily see a preview of your view in the Layout Editor filled with
sample data. When you add a view, a button
appears below the view in the Design window. Click this button to set the
design-time view attributes. You can choose
from a variety of sample data templates and specify the number of sample items
with which to populate the view.

To try using sample data, add a
RecyclerView
to a new layout, click the design-time attributes button
below the view, and choose a selection from the carousel of sample data
templates.

Slices

Slices provide a new way to embed portions of your app's functionality in
other user interface surfaces on Android. For example, Slices make it possible
to show app functionality and content in Google Search suggestions.

Android Studio 3.2 has a built-in template to help you to extend your app with
the new Slice Provider APIs, as well as new lint checks to ensure that you're
following best practices when constructing the Slices.

To get started right-click a project folder and choose
New > Other > Slice Provider.

IntelliJ IDEA 2018.1.6

Android profilers

Sessions

You can now save Profiler data as
sessions to revisit and
inspect later. The profiler keeps your session data until you restart the IDE.

When you
record a method trace or
capture a heap dump, the IDE adds that data (along with your app's network
activity) as a separate entry to the current session, and you can easily switch
back and forth between recordings to compare data.

System Trace

In the CPU Profiler, select the
new System Trace configuration to inspect your device's system CPU and
thread activity. This trace configuration is built on
systrace
and is useful for investigating system-level issues, such as UI jank.

While using this trace configuration, you can visually mark important code
routines in the profiler timeline by instrumenting your C/C++ code with the
native tracing API or your Java code with the
Trace class.

Inspect JNI references in the Memory Profiler

If you deploy your app to a device running Android 8.0 (API level 26) or higher,
you can now inspect memory allocations for your app’s JNI code using the
Memory Profiler.

While your app is running, select a portion of the timeline that you want to
inspect and select JNI heap from the drop-down menu above the class list, as
shown below. You can then inspect objects in the heap as you normally would and
double-click objects in the Allocation Call Stack tab to see where the JNI
references are allocated and released in your code.

Import, export, and inspect memory heap dump files

You can now import, export, and inspect .hprof memory heap dump files created
with the Memory Profiler.

Import your .hprof file by clicking Start new profiler session in the
profiler’s Sessions pane and then selecting Load from file. You can then
inspect its data in the Memory Profiler as you would any other heap dump.

To save heap dump data to review later, use the Export Heap Dump button at
the right of the Heap Dump entry in the Sessions pane. In the
Export As dialog that appears, save the file with the .hprof filename
extension.

Record CPU activity during app startup

You can now record CPU activity during your app's startup, as follows:

Select Run > Edit Configurations from the main menu.

Under the Profiling tab of your desired run configuration, check the box
next to Start recording a method trace on startup.

Export CPU traces

After you record CPU activity with the CPU Profiler, you can export the data as
a .trace file to share with others or inspect later.

To export a trace after you’ve recorded CPU activity, do the following:

Right-click on the recording you want to export from the CPU timeline.

Select Export trace from the dropdown menu.

Navigate to where you want to save the file and click Save.

Import and inspect CPU trace files

You can now import and inspect .trace files created with the
Debug API or
CPU Profiler. (Currently, you
can't import System Trace recordings.)

Import your trace file by clicking Start new profiler session in the
profiler’s Sessions pane and then selecting Load from file. You can then
inspect its data in the CPU Profiler similar to how you normally would, with the
following exceptions:

CPU activity is not represented along the CPU timeline.

The thread activity timeline indicates only where trace data is available for
each thread and not actual thread states (such as running, waiting, or
sleeping).

Record CPU activity using the Debug API

You can now start and stop recording CPU activity in the CPU Profiler by
instrumenting your app with the Debug API. After
you deploy your app to a device, the profiler automatically starts recording CPU
activity when your app calls
startMethodTracing(String tracePath),
and the profiler stops recording when your app calls
stopMethodTracing(). While
recording CPU activity that’s triggered using this API, the CPU Profiler shows
Debug API as the selected CPU recording configuration.

Energy Profiler

The Energy Profiler displays a visualization of the
estimated energy usage of your app, as well as system events that affect energy
usage, such as wakelocks, alarms, and jobs.

The Energy Profiler appears as a new row at the bottom of the Profiler
window when you run your app on a connected device or Android Emulator running
Android 8.0 (API 26) or higher.

Click the Energy row to maximize the Energy Profiler view. Place your mouse
pointer over a bar in the timeline to see a breakdown of energy use by CPU,
network, and location (GPS) resources, as well as relevant system events.

System events that affect energy usage are indicated in the System timeline
below the Energy timeline. Details of system events within the specified
time range are shown in the event pane when you select a time range in the
Energy timeline.

To see the call stack and other details for a system event, such as a wakelock,
select it in the event pane. To go to the code responsible for a system event,
double-click the entry in the call stack.

Lint checking

Android Studio 3.2 includes many new and improved features for
lint checking.

The new lint checks help you to find and identify common code problems, ranging
from warnings about potential usability issues to high-priority errors regarding
potential security vulnerabilities.

Lint checks for Java/Kotlin interoperability

To make sure that your Java code interoperates well with your Kotlin code, new
lint checks enforce the best practices described in the
Kotlin Interop Guide.
Examples of these checks include looking for the presence of Nullability
annotations, use of Kotlin hard keywords, and placing lambda parameters last.

To enable these checks for command-line builds, add the following to your
build.gradle file:

android {
lintOptions {
check 'Interoperability'
}
}

Lint checks for Slices

New lint checks for Slices help to ensure that you are constructing Slices
correctly. For example, lint checks warn you if you have not assigned a primary
action to a Slice.

New Gradle target

Use the new lintFix Gradle task to apply all of the safe fixes suggested
by the lint check directly to the source code. An example of a lint check that
suggests a safe fix to apply is SyntheticAccessor.

Metadata updates

Various metadata, such as the service cast check, have been updated for lint
checks to work with Android 9 (API level 28).

Warning if running lint on a new variant

Lint now records which variant and version a baseline is recorded with, and lint
warns you if you run it on a different variant than the one with which the
baseline was created.

Improvements to existing lint checks

Android Studio 3.2 includes many improvements to existing lint checks. For
example, the resource cycle checks now apply to additional resource types, and
the translation detector can find missing translations on the fly, in the
editor.

Issue IDs more discoverable

Issue IDs are now shown in more places now, including in the Inspection
Results window. This makes it easier for you to find the information that you
need to enable or disable specific checks through lintOptions in
build.gradle.

Data Binding V2

Data Binding V2 is now enabled by default and is compatible with V1. This means
that, if you have library dependencies that you compiled with V1, you can use
them with projects using Data Binding V2. However, note that projects using V1
cannot consume dependencies that were compiled with V2.

D8 desugaring

In Android Studio 3.1, we integrated the desugaring step into the D8 tool as an
experimental feature, reducing overall build time. In Android Studio 3.2,
desugaring with D8 is turned on by default.

New code shrinker

R8 is a new tool for code shrinking and obfuscation that replaces ProGuard. You
can start using the preview version of R8 by including the following in your
project’s gradle.properties file:

android.enableR8 = true

Changed default ABIs for multi-APKs

When building multiple APKs that
each target a different ABI, the plugin no longer generates APKs for the
following ABIs by default: mips, mips64, and armeabi.

If you want to build APKs that target these ABIs, you must use
NDK r16b or lower and specify the ABIs
in your build.gradle file, as shown below:

splits {
abi {
include 'armeabi', 'mips', 'mips64'
...
}
}

Note: This behavior change is also included in Android Studio 3.1 RC1 and
higher.

Improved editor features for CMake build files

If you use CMake to
add C and C++ code to your project,
Android Studio now includes improved editor features to help you to edit your
CMake build scripts, such as the following:

Syntax highlighting and code completion:
The IDE now highlights and suggests code completion for common CMake commands.
Additionally, you can navigate to a file by clicking it while pressing the
Control key (Command on Mac).

Code reformatting: You can now use IntelliJ’s code reformat option to
apply code styles to your CMake build scripts.

Safe refactoring: The IDE’s built-in refactoring tools now also check if
you are renaming or deleting files that you reference in your CMake build
scripts.

Navigate external header files

When using the Project window in previous versions of Android Studio, you
could navigate and inspect only the header files that belong to libraries you
build from a local project. With this release, you can now also view and inspect
header files included with external C/C++ library dependencies that you import
into your app project.

If you already
include C/C++ code and libraries in your project,
open the Project window on the left side of the IDE by selecting
View > Tool Windows > Project from the main menu and select Android from
the drop-down menu. In the cpp directory, all headers that are within the
scope of your app project are organized under the include node for each of
your local C/C++ library dependencies, as shown below.

Native multidex enabled by default

Previous versions of Android Studio enabled native multidex when deploying the
debug version of an app to a device running Android API level 21 or higher. Now,
whether you’re deploying to a device or building an APK for release, the Android
plugin for Gradle enables native multidex for all modules that set
minSdkVersion=21 or higher.

The new version of AAPT2 fixes many issues, including improved handling of
non-ASCII characters on Windows.

Removal of configuration on demand

The Configure on demand preference has been removed from Android Studio.

Android Studio no longer passes the --configure-on-demand argument to Gradle.

ADB Connection Assistant

The new ADB Connection Assistant
provides step-by-step instructions to help you set up and use a device over the
Android Debug Bridge (ADB) connection.

To start the assistant, choose Tools > Connection Assistant.

The ADB Connection Assistant provides instructions, in-context controls, and
a list of connected devices in a series of pages in the Assistant panel.

Emulator improvements

You can now save and load snapshots of an AVD (Android virtual device) at
any time in the Android Emulator, making it fast and easy to return an
emulated device to a known state for testing. When you edit an AVD using the AVD
Manager, you can specify which AVD snapshot to load when the AVD starts.

Controls for saving, loading, and managing AVD snapshots are now in the
Snapshots tab in the emulator's Extended controls window.

3.1 (March 2018)

Android Studio 3.1.0 is a major release that includes a variety of new features
and improvements.

3.1.4 (August 2018)

This update to Android Studio 3.1 includes the following changes and fixes:

The bundled Kotlin is now version 1.2.50.

New projects are created with kotlin-stdlib-jdk* artifacts,
rather than with kotlin-stdlib-jre* artifacts, which are
deprecated.

R8 parsing of ProGuard rules has been improved.

The following bugs have been fixed:

Attempting to run the Kotlin Main class failed with an error:
"Error: Could not find or load main class..."

R8 entered an infinite loop while performing certain optimizations.

Using the Rerun failed tests command in the Run window
sometimes incorrectly returned the message "No tests were found".

D8 did not correctly handle invoke-virtual instances,
causing a crash with a VerifyError:
invoke-super/virtual can't be used on private method

The Data Binding compiler was depending on an old version of
com.android.tools:annotations. The compiler now uses
tools annotations from the base project when available.

Android Studio crashed during fragment transitions when using
profilers.

The debugger crashed when debugging a layout with a text box.

D8 failed to read some ZIP files with special characters.

3.1.3 (June 2018)

This update to Android Studio 3.1 includes fixes for the following bugs:

Memory leaks caused Android Studio to become slow and unresponsive
after you had been using the Layout Editor. This update includes fixes
for most of these issues. We intend to release another update soon to
address additional memory leaks.

Some applications built with D8 crashed on some Verizon Ellipsis tablets.

Installation of applications built with D8 failed with an
INSTALL_FAILED_DEXOPT error on devices running Android 5.0 or
5.1 (API level 21 or 22).

Some applications that used the OkHttp library and were built with D8
crashed on devices running Android 4.4 (API level 19).

Android Studio sometimes failed to start, with a
ProcessCanceledException during class initialization for
com.intellij.psi.jsp.JspElementType.

3.1.2 (April 2018)

This update to Android Studio 3.1 includes fixes for the following bugs:

In some cases, Android Studio hung indefinitely during exit.

Builds configured with source sets
failed with the following message when Instant Run was enabled:

"The SourceSet name is not recognized by the Android
Gradle Plugin."

When Instant Run was enabled, builds of new Kotlin projects failed when
triggered by the Run command.

During editing of the build.gradle file, there was sometimes
a noticeable delay between typing a character and the character appearing
on the screen.

Build failures occurred during dexing in some projects with large
numbers of modules or external dependencies, with the following error
message:

The computation of the D8 main DEX list was not taking into account some
reflective invocations.

This update also includes changes that make running lint checks from Gradle
much faster in some scenarios.

3.1.1 (April 2018)

This update to Android Studio 3.1 includes fixes for the following bugs:

In some cases, when a project created in Android Studio 3.0 was opened
for the first time in Android Studio 3.1, the Gradle-aware Make task
was removed from the Before launch area in Run/Debug
Configurations. The result was that projects did not build when the
Run or Debug button was clicked, which in turn caused
failures such as deployment of incorrect APKs and crashes when using
Instant Run.

To solve this problem, Android Studio 3.1.1 adds the Gradle-aware Make
task to the run configuration for projects that are missing this entry.
This modification occurs after the first Gradle sync when the project is
loaded.

The debugger crashed when debugging a layout with a text box if advanced
profiling was enabled.

Android Studio froze after you clicked Build Variants.

AAR (Android archive) files were extracted twice, once during the Gradle
sync process and once during the Gradle build process.

Elements were missing from some vector drawables imported from SVG files.

The warning regarding the deprecation of the compile
dependency configuration has been updated with better guidance regarding
the implementation and api configurations. For
details of migrating away from using the compile
configuration, see the
documentation for the new dependency configurations.

Coding/IDE

IntelliJ 2017.3.3

The core Android Studio IDE has been updated with improvements from IntelliJ
IDEA through the 2017.3.3 release. Improvements include better control flow
analysis for collections and strings, improved nullability inference, new quick
fixes, and much more.

For details, see the JetBrains release notes for IntelliJ IDEA versions
2017.2 and
2017.3, as well as the
JetBrains release notes for
bug-fix updates.

You can right-click a table name in SQL and rename it, which also
rewrites the corresponding Java or Kotlin code (including, for example, the
return type of the query). Renaming works in the other direction, too, so
renaming a Java class or field rewrites the corresponding SQL code.

SQL usages are shown when using Find usages (right-click and choose
Find usages from the context menu).

To navigate to an SQL entity's declaration in Java or Kotlin code, you can
hold Control (Command on Mac) while clicking the entity.

You don't need to make any changes to your code or your development workflow to
get these benefits, unless you had previously manually disabled the D8 compiler.
If you set android.enableD8 to false in your
gradle.properties, either delete that flag or set it to
true:

Kotlin upgraded to version 1.2.30

Kotlin code now analyzed with command-line lint check

For each project that you would like to run lint on,
Google's Maven repository must
be included in the top-level build.gradle file. The Maven
repository is already included for projects created in Android Studio 3.0 and
higher.

Performance tools

Sample native C++ processes with CPU Profiler

The CPU Profiler now includes a default
configuration to record sampled traces of your app's native threads. You can
use this configuration by deploying your app to a device running Android 8.0
(API level 26) or higher and then selecting Sampled (Native) from the
CPU Profiler's recording configurations dropdown menu. After that,
record and inspect a trace as
you normally would.

Request tab in the Network Profiler

The Network Profiler now includes a
Request tab that provides details about network requests during the
selected timeline. In previous versions, the Network Profiler only provided
information about network responses.

Thread View in the Network Profiler

After selecting a portion of the timeline in the
Network Profiler, you can select one of
the following tabs to see more detail about the network activity during that
timeframe:

Connection View: Provides the same information as previous versions of
Android Studio—it lists files that were sent or received during the
selected portion of the timeline across all of your app's CPU threads. For
each request, you can inspect the size, type, status, and transmission duration.

Thread View: Displays network activity of each of your app's CPU threads.
This view allows you to inspect which of your app's threads are responsible
for each network request.

Layout Inspector

The Layout Inspector gained new
features, including some functionality previously provided by the deprecated
Hierarchy Viewer and Pixel Perfect tools:

Zoom buttons and keyboard shortcuts for navigating and inspecting layouts

Reference grid overlay

Ability to load a reference image and use it as an overlay (useful for
comparing your layout with a UI mockup)

You can use the new Convert view
command in the Component tree or design editor to convert a view or layout
to another type of view or layout.

You can now easily create constraints to items near the selected view using the
new Create a connection
buttons in the view inspector at the top of the Attributes window.

Run and Instant Run

The behavior of the Use same selection for future launches option in the
Select deployment target dialog has been made more consistent. If the Use
same selection option is enabled, then the Select deployment target
dialog opens only the first time that you use the Run command until the
selected device is no longer connected.

When targeting a device running Android 8.0 (API level 26) or higher, Instant
Run can deploy changes to resources without
causing an application restart. This is possible because the resources are
contained in a split APK.

Emulator

For details of what's new and changed in the emulator since Android Studio 3.0,
see the Android Emulator release notes from version 27.0.2
through version 27.1.12.

Major improvements include the following:

Quick Boot snapshots for saving of emulator state and faster start, with the
ability to use the Save now command to save a custom start state.

User interface and user experience improvements

More tooltips, keyboard shortcuts, and helpful messages

We have added tooltips and helpful message overlays in many places throughout
Android Studio.

To see keyboard shortcuts for many commands, just hold the mouse pointer over a
button until the tooltip appears.

Tools > Android menu removed

The Tools > Android menu has been removed. Commands that were previously
under this menu have been moved.

Many commands moved to directly under the Tools menu.

The Sync project with gradle files command moved to the File menu.

The Device Monitor command has been removed, as described below.

Device Monitor available from the command line

In Android Studio 3.1, the Device Monitor serves less of a role than it
previously did. In many cases, the functionality available through the Device
Monitor is now provided by new and improved tools.

See the
Device Monitor documentation for instructions
for invoking the Device Monitor from the command line and for details of the
tools available through the Device Monitor.

3.0 (October 2017)

Android Studio 3.0.0 is a major release that includes a variety of new
features and improvements.

macOS users: If you are updating an older version of Android Studio,
you may encounter an update error dialog that says "Some conflicts were
found in the installation area". Simply ignore this error and click
Cancel to resume the installation.

3.0.1 (November 2017)

This is a minor update to Android Studio 3.0 that includes general bug
fixes and performance improvements.

Android Plugin for Gradle 3.0.0

The new Android plugin for Gradle
includes a variety of improvements and new features, but it primarily improves
build performance for projects that have a large number of modules. When using
the new plugin with these large projects, you should experience the following:

Faster build configuration times due to new delayed dependency resolution.

Using ndkCompile is now more restricted. You should instead migrate to
using either CMake or ndk-build to compile native code that you want to package
into your APK. To learn more, read
Migrate from ndkcompile.

Kotlin support

As announced at Google I/O 2017,
the Kotlin programming language is now officially supported on Android.
So with this release, Android Studio includes Kotlin language
support for Android development.

You can incorporate Kotlin into your project by converting a Java file to Kotlin
(click Code > Convert Java File to Kotlin File) or by creating a new Kotlin-
enabled project using the New Project wizard.

Java 8 language features support

You can now use certain Java 8 language features and
consume libraries built with Java 8. Jack is no longer required, and you
should first disable Jack
to use the improved Java 8 support built into the default toolchain.

To update your project to support the new Java 8 language toolchain,
update the Source Compatibility and Target Compatibility to 1.8
in the Project Structure dialog (click File > Project Structure).
To learn more, read how to
use Java 8 language features.

Android Profiler

The new Android Profiler replaces the Android Monitor tool and provides a
new suite of tools to measure your app's CPU, memory, and network usage in
realtime. You can perform sample-based method tracing to time your code
execution, capture heap dumps, view memory allocations, and inspect the details
of network-transmitted files.

The event timeline at the top of the window shows touch events, key
presses, and activity changes so you have more context to understand other
performance events in the timeline.

Note: The Logcat view also moved to a
separate window (it was previously inside Android Monitor, which was removed).

From the Android Profiler's overview timeline, click on the CPU, MEMORY,
or NETWORK timelines to access the corresponding profiler tools.

CPU Profiler

The CPU Profiler helps you analyze the CPU thread usage of your app by
triggering a sample or instrumented CPU trace. Then, you can
troubleshoot CPU performance issues using a variety of data views and filters.

Memory Profiler

The Memory Profiler helps you identify memory leaks and memory churn that can
lead to stutter, freezes, and even app crashes. It shows a realtime graph of
your app's memory use, lets you capture a heap dump, force garbage collections,
and track memory allocations.

APK profiling and debugging

Android Studio now allows you to profile and debug any
APK without having to build it from an Android Studio project—as long as the
APK is built to enable debugging and
you have access to the debug symbols and source files.

To get started, click Profile or debug APK from the
Android Studio Welcome screen. Or, if you already have a project open, click
File > Profile or debug APK from the menu bar. This displays the
unpacked APK files, but it does not decompile the code.
So, to properly add breakpoints and view stack traces,
you need to attach Java source files and native debug symbols.

Instant Apps support

New support for Android Instant Apps allows you to create Instant Apps in your
project using two new module types: Instant App modules and Feature modules
(these require that you install the Instant Apps Development SDK).

Android Studio also includes a new modularize refactoring action to help you
add support for Instant Apps in an existing project. For example, if you want to
refactor your project to place some classes in an Instant App feature module,
select the classes in the Project window and click Refactor >
Modularize. In the dialog that appears, select the module where the classes
should go and click OK.

And when you're ready to test your Instant App, you can build and run your
Instant App module on a connected device by specifying the Instant App's URL
within the run configuration launch
options: Select Run >
Edit Configurations, select your Instant App module, and then set the URL
under Launch Options.

Support for font resources

To support the new font resources in Android 8.0, Android Studio includes a
font resources selector to help bundle fonts into your app or configure
your project to download the fonts on the device (when available). The layout
editor can also preview the fonts in your layout.

To try downloadable fonts, ensure that your device or emulator is running
Google Play Services v11.2.63 or higher. For more information, read about
Downloadable Fonts.

Firebase App Indexing Assistant

The Firebase Assistant has been updated with a new tutorial to test App
Indexing.
To open the Assistant, select Tools > Firebase.
Then select App Indexing > Test App Indexing.

The tutorial includes new
buttons to test your public and personal content indexing:

In step 2, click Preview search results to verify that your URLs
are showing up in Google Search results.

In step 3, click Check for errors to verify that the indexable
objects in your app have been added to the personal content index.

New UI to create chains: Select multiple views, and then right-click
and select Chain.

Layout Inspector

The Layout Inspector includes
enhancements to make it easier to debug issues with your app layouts, including
grouping properties into common categories and new search functionality in both
the View Tree and the Properties panes.

APK Analyzer

You can now use the APK Analyzer from the command line with the
apkanalyzer tool.

The APK Analyzer has also been updated with the following improvements:

For APKs built with ProGuard, you can load ProGuard mapping files that add
capabilities to the DEX viewer, including:

Bolded nodes to indicate that the nodes should not be removed when
shrinking code.

A button to show nodes that were removed during the shrinking process.

A button that restores the original names of nodes in the tree view that
were obfuscated by ProGuard.

The DEX Viewer now shows the estimated size impact of each package, class and
method.

New filtering options at the top to show and hide fields and methods.

In the tree view, nodes that are references not defined in the DEX file appear
in italics.

Preview for D8 DEX compiler

Android Studio 3.0 includes an optional new DEX compiler called D8. It will
eventually replace the DX compiler, but you can opt-in to use the new D8
compiler now.

DEX compilation directly impacts your app's build time, .dex file
size, and runtime performance. And when comparing the new D8 compiler with the
current DX compiler, D8 compiles faster and outputs smaller .dex files, while
having the same or better app runtime performance.

To try it, set the following in your project's gradle.properties file:

Google's Maven repository

Android Studio now uses Google’s Maven Repository by default instead of
depending on the Android SDK Manager to get updates for Android Support Library,
Google Play Services, Firebase, and other dependencies. This makes it easier to
keep your libraries up to date, especially when using
a continuous integration (CI) system.

All new projects now include the Google Maven repository by default. To update
your existing project, add google() in the repositories block of the
top-level build.gradle file:

Other changes

Native debugging with Android Studio no longer supports 32-bit Windows.
We've chosen to focus on other platforms because very few developers are using
this platform. If you are using 32-bit Windows and you plan to debug native
code, you should keep using Android Studio 2.3.

Upgraded the base IDE to
IntelliJ 2017.1.2,
which adds a number of new features from
2016.3 and
2017.1,
such as Java 8 language refactoring, parameter hints, semantic highlighting,
draggable breakpoints, instant results in search, and much more.

This is a minor update to Android Studio 2.3 that fixes an issue where some
physical Android devices did not work properly with Instant Run (see Issue
#235879).

New

Android Studio can now convert PNG, BMP, JPG, and static GIF files to
WebP format. WebP is an image file format from Google that provides lossy
compression (like JPEG) as well as transparency (like PNG) but can provide
better compression than either JPEG or PNG. For more information, see
Convert images to WebP in Android
Studio.

The Layout Editor also now lets you create a list of favorite attributes so
you don't have to click View all attributes to access the attributes
you use most.

When adding a material icon using the Vector Import Dialog (File >
New > Vector Asset), you can now filter the list of available icons by
category or by icon name. For more information, see Adding a material
icon.

New and updated
annotations. The new @RestrictTo annotation for methods,
classes, and packages lets you restrict an API. The updated
@VisibleForTesting annotation now has an optional
otherwise argument that lets you designate what the visibility
of a method should be if not for the need to make it visible for testing.
Lint uses the otherwise option to enforce the intended
visibility of the method.

New lint baseline support
allows you to use a snapshot of your project's current set of warnings as a
baseline for future inspection runs so only new issues are reported. The
baseline snapshot lets you start using lint to fail the build for new issues
without having to go back and address all existing issues first.

Object Animator Validation: Lint analyzes your code to make sure that
your ObjectAnimator calls reference valid methods with the
right signatures and checks that those methods are annotated with
@Keep to prevent ProGuard from renaming or removing them during
release builds.

Unnecessary Item Decorator Copy: Older versions of the
RecyclerView library did not include a divider decorator
class, but one was provided as a sample in the support demos. Recent
versions of the library have a divider decorator class. Lint looks for
the old sample and suggests replacing it with the new one.

WifiManager Leak: Prior to Android 7.0 (API level 24), initializing
the WifiManager with Context.getSystemService()
can cause a memory leak if the context is not the application context.
Lint looks for these initializations, and if it cannot determine
that the context is the application context, it suggests you use Context.getApplicationContext() to get the proper context for the
initialization.

Improved Resource Prefix: The existing resourcePrefix
lint check had many limitations. You can now configure your project with
a prefix, such as android { resourcePrefix 'my_lib'
}, and lint makes sure that all of your resources are using this
prefix. You can use variations of the name for styles and themes. For
example for the my_lib prefix, you can have themes named
MyLibTheme, myLibAttr,
my_lib_layout, and so on.

Switch to WebP: This check identifies images in your project that can
be converted to WebP format based on your project’s
minSdkVersion setting. An associated quickfix can
automatically convert the images, or you can convert images to WebP manually.

Changes

A separate button to push changes with Instant Run: After deploying your
app, you now click Apply Changes to quickly push incremental changes to your running app using
Instant Run. The Run and Debug
buttons are always available to you when you want to reliably push your
changes and force an app restart.

Instant Run is supported only when deploying your app to a target
device running Android 5.0 (API level 21) or higher.

Instant Run is no longer disabled for projects that link to external native
projects using CMake or ndk-build. However, you can only use Instant
Run to push incremental changes to your Java code, not your native code.

Cold swaps (which you can force for a running app by clicking
Run) are now more reliable. Forcing a cold swap
also fixes the issue where changes to notification and widget UIs were
not updated on the target device.

Includes optimizations that make app startup much faster. These
optimizations may affect profiling, so you should temporarily disable Instant Run whenever
profiling your app.

The AVD Manager and SDK Manager buttons are now included in the lean Navigation Bar as
well as the full Toolbar. To use the lean Navigation Bar, click
View to open the View menu, then ensure that Navigation Bar
is selected and Toolbar is not selected.

The "Hybrid" debugger has been renamed to "Dual" debugger.

In the Run/Debug
Configurations dialog, under Defaults in the left pane, the following run
configuration names have changed with no behavior changes:

The JUnit name has changed to Android JUnit. If you have a project
that uses JUnit run configurations, those configurations are transformed
to Android JUnit run configurations the first time you open the project
with Android Studio. A dialog appears to inform you of the name change.

The Android Tests name has changed to Android Instrumented Tests.

The GPU Debugger has
been removed from Android Studio as of version 2.3. An open-source,
standalone version of the tool is now available on GitHub.

The Run/Debug option is no longer available when you right-click a
*.gradle build script.

Known issue: Some device manufacturers block apps from automatically
launching after being installed on the device. When deploying your app to a
physical device using Android Studio 2.3, this restriction breaks the
intended behavior of Instant Run and causes the following error output:
Error: Not found; no service started. To avoid this issue,
either use the emulator or enable
automatic launching for your app in your device's settings. The proceedure
for doing this is different for each device, so check the instructions
provided by the manufacturer. For example, some affected Asus devices need to
whitelist apps using the Auto-start Manager. To learn
more about this issue, see Issue
#235879.

2.2 (September 2016)

2.2.3 (December 2016)

This is a minor update to Android Studio 2.2. It includes a bug fixes
focused around gradle, the core IDE, and lint.

Highlighted build changes:

ProGuard version rollback. Due to a correctness issue
discovered in ProGuard 5.3.1, we have rolled back to ProGuard 5.2.1. We
have worked with the ProGuard team on getting a fix quickly, and we expect
to roll forward to ProGuard 5.3.2 in Android Studio 2.3 Canary 3.

Bug fix for aaptOptionsIgnoreAssetsPattern
not working properly (issue
224167)

This is a minor update to Android Studio 2.2. It includes several bug fixes
and a new feature to enable extra logging to help us troubleshoot Instant
Run issues—to help us improve Instant Run, please enable extra logging and report
any issues.

New

New Layout
Inspector lets you examine snapshots of your layout hierarchy
while your app is running on the emulator or a device.

New Assistant
window to help you integrate Firebase services into your app.

New APK
Analyzer tool so you can inspect the contents of your packaged
app.

New Espresso Test
Recorder tool (currently in beta) to help you create UI tests by
recording your own interactions.

New build cache
(currently experimental) to speed up build performance.

New C/C++ build integration with CMake and ndk-build.
Compile and build new or existing native code into libraries packaged into
your APK, and debug using lldb. For new projects, Android Studio uses CMake
by default, but also supports ndk-build for existing projects. To learn how
to include native code in your Android application, read Add C and C++ Code to Your
Project. To learn how to debug native code with lldb, see Debug Native Code.

New Samples
Browser so you can easily look up Google Android sample code
from within Android Studio to jump start app development.

New Merged Manifest Viewer to help you diagnose how your
manifest file merges with your app dependencies across project build
variants.

The Run window now contains log messages for the current
running app. Note that you can configure the logcat Monitor display, but not the
Run window.

The Debugger tab of the Android App and Android
Tests templates now contain several new options for debugging with LLDB.

The Profiling tab of the Android App and Android
Tests templates now contain a Capture GPU Commands
option for enabling GPU tracing. You can display GPU traces in the GPU
Debugger (a beta feature).

The Android Tests template now has a Firebase Test Lab Device
Matrix option for the Deployment Target.

The Native Application template has been deprecated. If you use this
template in a project, Android Studio automatically converts it to the
Android App template.

The Android Application template has been renamed to Android App.

Improved installation, configuration, performance, and UI features in the
GPU
Debugger (currently in beta).

Android Studio now comes bundled with OpenJDK 8.
Existing projects still use the JDK specified in File > Project
Structure > SDK Location. You can switch to use the new bundled
JDK by clicking File > Project Structure > SDK
Location and checking the Use embedded JDK
checkbox.

Added new help menus and buttons in the UI so you can
more easily find the online documentation.

Changes

Updated the IDE codebase from IntelliJ 15 to IntelliJ
2016.1

Instant Run now requires the platform SDK corresponding to the target
device API level to be installed.

Instant Run will automatically disabled if user is running the app under
a work profile or as a secondary user.

Fixed many reliability issues for Instant Run where changes
were not getting deployed or the app would crash:

Some app assets were not deployed to your running app. ( Bug: #213454)

App crashes when user transitions between Instant Run and non Instant
Run sessions where a Serializable class does not have serialVersionUID
defined. (Bug: #209006)

Added an updated AccelerometerPlay
sample so you can try out the emulator Accelerometer
control. Select File > New >
Import Sample to import the project.

Removed the Scale AVD property from the AVD Manager.

The Android Emulator -port and -ports
command-line options now report which ports and serial number the emulator
instance is using, and warn if there are any issues with the values you
provided.

Improved the Create New Class dialog
and the corresponding file templates. Note: If you've
previously customized the AnnotationType,
Class, Enum, Interface, or
Singleton file templates, you need to modify your templates
to comply with the new templates or you won’t be able to use the new fields
in the Create New Class dialog.

2.1 (April 2016)

The primary changes in this update provide support for development with the
Android N Preview.

2.1.3 (August 2016)

This update adds compatibility with Gradle 2.14.1, which includes performance
improvements, new features, and an important security fix. For more details, see the Gradle
release notes.

By default, new projects in Android Studio 2.1.3 use Gradle 2.14.1. For
existing projects, the IDE prompts you to upgrade to Gradle 2.14.1 and
Android plugin
for Gradle 2.1.3, which is required when using Gradle 2.14.1 and
higher.

Fixed a regression in the Android Studio 2.1.1 security update that
caused git rebase to fail.

2.1.1 (May 2016)

Security release update.

The Android N platform adds support for Java 8 language features, which
require a new experimental compiler called Jack. The latest version of Jack is
currently supported only in Android Studio 2.1. So if you want to use Java 8
language features, you need to use Android Studio 2.1 to build your app.

Note:Instant Run
is disabled when you enable the Jack compiler because they currently are not
compatible.

Although Android Studio 2.1 is now stable, the Jack compiler is still
experimental and you must enable it with the jackOptions
property in your build.gradle file.

Other than the changes to support the N Preview, Android Studio 2.1
includes minor bug fixes and the following enhancements:

The Java-aware C++ debugger is now enabled by default when you're
using an N device or emulator and select Native debugger mode
(in the Debugger tab for your run/debug configuration).

For other build enhancements, including incremental Java compilation
and dexing-in-process,update your Android plugin for
Gradle to version 2.1.0.

2.0 (April 2016)

Note: If you are developing for the N Developer Preview, you
should use Android Studio 2.1 Preview. Android Studio 2.0 does not support
all the features required to target the N Preview. To learn more, read about
how to properly set up your
developer environment for the N Preview.

Instant Run:

Android Studio now deploys clean builds faster than ever before.
Additionally, pushing incremental code changes to the emulator or a physical
device is now almost instantaneous. Review your updates without redeploying a
new debug build or, in many cases, without restarting the app.

Instant Run supports pushing the following changes to a running app:

Changes to the implementation of an existing instance method or
static method

Changes to an existing app resource

Changes to structural code, such as a method signature or a static
field (requires a target device running API level 21 or higher).

Note: Instant Run is supported only when you deploy the
debug build variant, use Android plugin for
Gradle version 2.0.0 or higher, and configure your app's module-level
build.gradle file for minSdkVersion 15 or higher.
For the best performance, configure your app for minSdkVersion
21 or higher.

New additions to Lint:

Inspection of switch statements using @IntDef annotated integers to make sure
all constants are handled. To quickly add any missing statements, use the
intention action drop-down menu and select Add Missing @IntDef
Constants.

Flags for incorrect attempts to use string interpolation to insert
version numbers in the build.gradle file.

Flags for native code in unsafe locations, such as the res/
and asset/ folders.
This flag encourages storing native code in the libs/
folder, which is then securely packaged into the application’s
data/app-lib/ folder at install time. AOSP: #169950

Find and remove any unused resources by selecting Refactor > Remove
Unused Resources from the menu bar. Unused resource detection now
supports resources only referenced by unused resources, references in raw
files such as .html image references, and tools:keep and
tools:discard attributes used by the Gradle resource shrinker, while
considering inactive source sets (such as resources used in other build
flavors) and properly handling static field imports.

Checks that implicit API references are supported on all platforms
targeted by minSdkVersion.

Optimized for Android Emulator 2.0, which is faster than ever before,
supports a wider range of virtual devices, and features a drastically
improved UI. To learn more about the new emulator, read the SDK Tools release notes.

System images are now categorized under the following tabs:
Recommended, x86, and Other.

Under advanced settings, you can enable multi-core support and
specify the number of cores the emulator can use.

Under advanced settings, you can determine how graphics are rendered
on the emulator by selecting one of the following options:

Hardware: use you computer's graphics card for
faster rendering.

Software: use software-based rendering.

Auto: let the emulator decide the best option. This
is the default setting.

Improved AAPT packaging times by specifying deploy target before the app
is built. This allows Android Studio to efficiently package only the
resources required by the specified device.

Added Cloud Test Lab integration to provide on-demand app testing with
the convenience and scalability of a cloud service. Learn more about how you
can use Cloud
Test Lab with Android Studio.

Added a preview of the new GPU Debugger. For graphics
intensive applications, you can now visually step through your OpenGL ES code
to optimize your app or game.

Added Google App Indexing Test. Add support for URLs, app
indexing, and search functionality to your apps to help drive more
traffic to your app, discover which app content is used most, and attract
new users. Test and validate URLs in your app all within Android
Studio. See Supporting URLs and App
Indexing in Android Studio.

Upgrades from the latest IntelliJ 15 release, including improved code
analysis and performance. See What's New in IntelliJ for a
complete description of the new features and enhancements.

XML editor auto-complete now adds quotations marks when completing
attributes. To check if this option is enabled, open the Setting or
Preferences dialogue, navigate to Editor > General > Smart
Keys, and check the box next to Add quotes for attribute value on
attribute completion. Issue: 195113

Fixed a case where launching an app for debugging resulted in the debugger connecting to the
wrong device. Issue: 195167

Fixed a null pointer exception that could occur when attempting to run an app in
certain scenarios.

Android Studio v1.5.0 (November 2015)

Fixes and enhancements:

Added new Memory Monitor analysis abilities to Android Monitor. When you view an HPROF file
captured from this monitor, the display is now more helpful so you can more quickly locate
problems, such as memory leaks. To use this monitor, click Android Monitor at
the bottom of the main window. In Android Monitor, click the Memory tab. While
the monitor is running, click the Dump Java Heap icon, and then click
Captures in the main window and double-click the file to view it. Click
Capture Analysis on the right. (The
Android Device Monitor can't be running at the same time as Android Monitor.)

Added new deep link and app link support. The Code Editor can automatically create an
intent filter for deep linking in the AndroidManifest.xml file. It can also
generate code to help you integrate with the
App Indexing API
in an activity in a Java file. A deep link testing feature
helps you verify that a specified deep link can launch an app. In the General
tab of the Run/Debug Configurations dialog, you can specify deep link launch
options. You can also test App Indexing API calls in an activity by using the Android Monitor
logcat display. The Android lint tool now has warnings for
certain issues involving deep links and the App Indexing API.

Added the ability to use short names when code-completing custom views in the Code Editor.

Added support for more VectorDrawable elements to
Vector Asset Studio
for backward-compatibility. Vector Asset Studio can use these elements to convert vector
drawables into PNG raster images to use with Android 4.4 (API level 20) and lower.

Added new lint checks for Android TV and Android Auto to give you
immediate, actionable feedback in Android Studio, along with several quick fixes. For example,
for Android TV, it can report and provide a quick fix for permissions, unsupported hardware,
uses-feature element, and missing banner issues. For Android Auto, it can
validate the correct usage in the descriptor file referred from your
AndroidManifest.xml file, report if there isn't an intent filter for the
MediaBrowserService class, and identify certain voice actions issues.

Added new lint checks for insecure broadcast receivers,
SSLCertificateSocketFactory and HostnameVerifier class uses, and
File.setReadable() and File.setWritable() calls. It also detects
invalid manifest resource lookups, especially for resources that vary by configuration.

Fixed a number of stability issues.

Android Studio v1.4.1 (October 2015)

Fixes and enhancements:

Fixed a Gradle model caching issue that could lead to excessive Gradle syncing when the IDE
was restarted.

Fixed a native debugging deadlock issue.

Fixed an issue blocking users of the Subversion 1.9 version control system.

Fixed a Device Chooser dialog problem where after connecting a device that was
unauthorized you could no longer select the emulator. Issue: 189658

Fixed incorrect translation error reporting for locales that have a region qualifier and a
translation in the region (but not in the base locale). Issue: 188577

Fixed a deadlock issue in the Theme Editor related to its interaction with the Layout
Editor. Issue: 188070

Fixed an issue where the android:required attribute was ignored in the manifest.
Issue: 187665

Android Studio v1.4.0 (September 2015)

Fixes and enhancements:

Added the Vector Asset Studio
tool for importing vector graphics, such as material icons
and SVG files. To use this tool, in the Android view of the Project window, right-click the
res folder and select New > Vector Asset.

Added new Android Monitor functions, GPU and Network. To use these monitors, click
Android Monitor at the bottom of the main window. The Android Device Monitor
can't be running at the same time as Android Monitor.

Added an early preview of the new Theme Editor. To use this feature, select
Tools > Android > Theme Editor.

Updated the Android templates for the Design Support Library. Templates now include support
for the Material Design specification, as well as the appcompat Support Library
for backwards compatibility.

Android Studio v1.3.2 (August 2015)

Fixes and enhancements:

Added support for Android 6.0 (API level 23), including new icons and AVD Manager
support for creating devices with new screen densities.

Fixed an exception that was occurring during update checks.
Issue: 183068

Added additional annotations,
such as @RequiresPermission, @CheckResults, and
@MainThread.

Added the capability to generate Java heap dumps and analyze thread allocations from the
Memory Monitor. You can also
convert Android-specific HPROF binary format files to standard HPROF format from within
Android Studio.

Modified new project and module creation to include
res/mipmap folders for
density-specific launcher icons. These res/mipmap folders replace the
res/drawable
folders for launcher icons.

Updated launcher icons to have a
Material Design look and added an
xxxhdpi launcher icon.

Added and enhanced Lint checks
for region and language combinations, launcher icons, resource names, and other common
code problems.

Added support for Best Current Practice (BCP) language tag 47.

Android Studio v1.0.1 (December 2014)

Various fixes and enhancements:

Fixed AVD Manager and device.xml file lock issue.

Fixed the emulator log on Windows systems.

Fixed issue with creating AVDs with Android Studio and Android SDK installed on different
drives on Windows systems.

Sets the default update channel for new downloads to Stable. If you
installed the 1.0.0 version of Android Studio and would like stable, production-ready version
updates, use File > Settings > Updates to change to the Stable
update channel.

Merged in the latest IntelliJ codebase changes. Includes fixes for issues reported by Studio users such as tweaks to Linux font sizes and font rendering.

Android Gradle plug-in updated to 0.5.0.

Caution: This new version is not backwards compatible.
When opening a project that uses an older version of the plug-in, Studio will show an error
stating Gradle <project_name> project refresh failed.

The updated Gradle plug-in includes the following changes:

Fixed IDE model to contain the output file even if it's customized through the DSL. Also
fixed the DSL to get/set the output file on the variant object so that it's not necessary to
use variant.packageApplication or variant.zipAlign

Fixed dependency resolution so that we resolved the combination of (default config,
build types, flavor(s)) together instead of separately.

Fixed dependency for tests of library project to properly include all the dependencies
of the library itself.

Gradle errors from aapt no longer point to merged output files in the build/ folder, they
point back to the real source locations.

Parallel Builds. It's now possible to use Gradle's parallel builds. Please be aware that
parallel builds are in "incubation" (see Gradle's
documentation.) This feature is off by default. To enable it, go to
Preferences > Compiler and check the box Compile
independent modules in parallel.

Further work on the new resource repository used for layout rendering, resource
folding in the editor, and more:

Basic support for .aar library dependencies (e.g. using a library without a local copy of
the sources). Still not working for resource XML validation and navigation in source editors.

Cycle detection in resource references.

Quick Documentation (F1), which can show all translations of the string under the caret,
will now also show all resource overlays from the various Gradle flavors and build types, as
well as libraries. They are listed in reverse resource overlay order, with strikethrough on
the versions of the string that are masked.

Fixes to handle updating the merged resources when the set of module dependencies
change.