Android studio cache directory

This page is obsolete. You’re being redirected to developer.android.com/studio/build/build-cache.html

• The build cache is now enabled by default.
• There is a new Gradle task called cleanBuildCache for you to more easily clean the build cache. You can use it by typing the following in your terminal: ./gradlew cleanBuildCache

Android Studio 2.2 Beta 3 introduces a new build cache feature that can speed up build times for clean builds by storing and reusing files/directories that were created in previous builds of the same or different Android project.

The build cache is meant to be used across all Android projects. The developer can enable/disable the build cache and specify its location in the gradle.properties file. Currently, the build cache contains only pre-dexed libraries; in the future, we will use it for caching other types of files as well.

Note that the build cache works independently of Gradle’s cache management (e.g., reporting up-to-date statuses). When a task is executed, whether the build cache is used or not during its execution will be unknown to Gradle (i.e., even when the cache is hit, Gradle’s profile report will not show the task as up-to-date). However, you should expect to get faster build times when the build cache is used.

Although there are currently no known issues, we would like to provide the community more time to provide feedback on it. This feature is currently considered to be experimental and is disabled by default (update: this feature enabled by default starting with Android Studio 2.3 Canary 1). With your feedback, we are aiming to graduate it to stable and enable it by default in Android Studio 2.3 or 2.4.

How to use the Build Cache

Step 0

Ensure that android.dexOptions.preDexLibraries is either not set or set to true; otherwise the libraries will not be pre-dexed and therefore the build cache will not be used.

Step 1

In an Android project, open the gradle.properties file and add the following parameters:

android.enableBuildCache= true # Set to true or false to enable or disable the build cache. If this parameter is not set, the build cache is disabled by default.

# Optional, specify the absolute path of the build cache directory. If you use a relative path, it will be relative to the root directory of the Android project. If this parameter is not set, the default build cache directory at /.android/build-cache will be used. Multiple Android projects can share the same cache if they specify the same build cache location (in that case, it is recommended that the default location or a location outside the projects is used, although it is still possible to use a location inside one of the projects). In any case, it is important that the build cache location is not in a “build” directory; otherwise, it would be erased after running a clean task. This parameter is ignored if android.enableBuildCache=false .

Step 2

Build your Android project (on the terminal, type ./gradlew assemble ) and check the following locations to see whether the build cache took effect.

The cached files are stored in the build cache directory set by the android.buildCacheDir parameter above. By default, this is /.android/build-cache.

The final pre-dexed files are stored in

/ module-dir> /build/intermediates/pre-dexed/debug and

/ module-dir> /build/intermediates/pre-dexed/release. You need to run the command line to see the “pre-dexed” directory; if you click the “Run” button from the Android Studio menu, you will not see this directory as it will be deleted.

Note: If you are using Multi-dex with minSdk >= 21, the dexed files will be stored directly into the

/build/intermediates/transforms/dex directory without being stored in

Cleaning the Build Cache

To clean the build cache, you can navigate to the build cache directory and delete all the files in that directory. Th e build cache directory is either located at the path specified by the android.buildCacheDir property in your gradle.properties file, or it is located at /.android/build-cache by default.

Update: starting with Android Studio 2.3 Canary 1, there is a now a Gradle task called cleanBuildCache that you can use to more conveniently clean the build cache. You can use it by typing the following in your terminal:

We encourage you to try this feature and to see how it’s working for you. Please file a bug to us if you find any issues or if you have other feedback about this feature for us. Thanks!

Источник

Put your Android Studio on a diet

How to make a deep clean of your Android Studio & Gradle junk files to fix up the mess.

Do you know that when you’re updating your Android Studio, Gradle or even dependencies, some old files are still present on your machine and can waste some disk free space?

On our laptops, disk space is limited and clearing those files will make you gain a lot of free space available. Having too many junk files may also slow down your machine and your builds!

In my case, I was also having strange build errors or gradle sync failures when it was working on my colleague’s machine.

It was time to do some deep cleaning and put our Android Studio on a diet by following some simple steps.

Clear your project directory

1. Obviously, try to clean your project from android studio : “ Build -> Clean Project”. This will clear your build folders.
2. Clear the cache of Android Studio using “ File -> Invalidate Caches / Restart” choose “ Invalidate and restart option” and close Android Studio.
3. Remove your .gradle directory from the root of your project. It contains some Gradle cache files.
4. Delete also the .idea directory ( make a backup before). It contains some project configuration files.
5. Restart Android Studio.

Big project directories can weight around 500MB to 1GB.

Gradle cleaning

Now let’s take a look at Gradle files. If none of the above suggestions fix your problem, try these:

/.gradle directory. This is the Gradle home directory, containing caches, daemons and wrappers files. This is a really huge one, mine was

Inside those directories, you’ll have sub-directories for each version of Gradle you’ve been using. So, the more projects you have with different Gradle versions, the more sub-directories you will have.
You can delete those 3 directories:

• caches: Gradle cache files.
• daemon: essentially logs files of Gradle daemons.
• wrapper: different distributions of Gradle downloaded on you machine.

Android Studio cleanup

1. Go to your Android home, usually

/.android and clear build-cache and cache directories. There are few MB to free here (

100MB for me)
In the

/Library/ directories, you will find the Android Studio preferences files, settings and plugins. You can clear the directories of previous version of Android Studio (> 1GB per version of AS). Starting with version 3.3, Android Studio will propose you to remove them after an update.

Android SDK cleaning

On Android Studio, check the SDK Manager and remove the following items:

• Old SDKs you don’t use anymore. I guess you’ll not miss the Android 3.0 SDK files.
• Remove the emulators you don’t use as they’re quite heavy ( some GB).
• I recommend to keep “Sources for Android xx” items as it will allow you to check the source code of the SDK from a previous version of Android & help you debugging.
• On the SDK Tools tab, click on “Show Packages Details” and uncheck the old build-tools or NDK versions.
• Delete unused emulators using the AVD.

You can gain easily 10GB with these steps.

Extra cleaning

There is some extra stuff you can clean too:

• Your download directory: you may have downloaded a lot of GIFs, video, Android Studio binaries that you can remove.
• Clear your local git branches that have been merged (don’t remove the ones that you still need!).
• Delete all those photoshopped pictures of your colleagues ( ͡° ͜ʖ ͡°).
• Clear your recycle bin.

That’s it ! You’ve gained some precious disk space on your machine and maybe fixed some weird issues with your Android Studio.

I don’t recommend to do a full clean everyday, you’ll waste time and your build time will be quite longer so you’ll be less productive. Take it only as a “spring cleaning” ritual.

I hope it helped you, and don’t forget to follow the Marie Kondo mantra and only keep things that spark joy.

Источник

Synchronise your Gradle files and get some insight about the Android Studio cache

This tip explains how to synchronize your project with Gradle when updating build.gradle files and provides insight on handling the cache when using Android Studio.

There are multiple levels of cache. We will explain the difference between the cache behind the «Invalidate cache and restart» menu, the «Clean project» one and other gradle caches involved in building an Android project.

This article is not specific to Pepper QiSDK and introduces good practices for using the IDE.

Synchronize a project with Gradle Files¶

When you make changes to the build configuration files in your project, Android Studio requires that you synchronize (i.e. sync) your project files so that the IDE can import the new build configuration and run some tests to make sure there are no build errors.

In order to build projects, Android Studio needs the information contained in Gradle files. These files contain instructions on what dependencies to download and package within your application, information about versions, application id, and other information used to build the packages.

When you create a project you generally have two build.gradle files: one to configure project-wide properties and another one at module level. When your project structure view is set to Android the two files look as follow:

build.gradle (Project: YourFooAppName)

build.gradle (Module: app)

Gradle files and your application code need to be synced if any Gradle file changes, for example when updating dependencies or adding new dependencies manually.

This is the case when the project is robotified (see ‘Result’ of section Creating a robot application). The build.gradle of your module will then get two lines added or updated to the API level you have chosen (the exact version number may vary):

implementation ‘com.aldebaran:qisdk:1.7.5’
implementation ‘com.aldebaran:qisdk-design:1.7.5’

Android Studio should automatically sync the project with Gradle when you robotify your app (ie make it compatible with Pepper’s tablet).

If it does not, then choose menu File > Sync project with Gradle Files or use the elephant icon Sync project from the menu bar to sync your project files manually.

Gradle Sync project icon

If Android Studio notices any errors with your configuration, the Messages window appears with more details about the issue.

Once Gradle files are synced, your project will have access to the necessary libraries, such as the QiSQK ones. You can then use code autocompletion to import libraries.

Understanding Android Studio caches¶

Different types of caches¶

Android Studio caches a lot of files to speed up its use and build time. This cache is necessary to improve, for example, the performance of the IDE or some time-consuming tasks repeated at every build. This could lead to the system cache becoming overloaded or inconsistent.

There are different types of caches in Android Studio or used by Android Studio plugins. Let’s check in details:

• Android Studio System cache
• Gradle build caching
• AGP Android Gradle Plugin cache

Android Studio System cache¶

You can clear the Android Studio System cache using «Invalidate cache and restart». It mainly deals with the indexes and improves Android system performance.

Gradle build caching¶

This cache contains the built packages and the intermediate files involved at packaging your application. It can be found in two different locations:

• In the build/ directory in your project
• In the .gradle/caches/ directory of your Java SDK home directory

AGP Android Gradle Plugin cache¶

This cache contains other building caches and third party dependencies caches.

Now let’s consider each of these caches and explain how to clear them.

How to clear all system caches¶

Clearing the Android Studio System cache¶

The Android Studio cache contains information about the project’s structure, deals with the AS indexes and improves Android system performance.

You may need to clear the cache in several situations. For instance, moving some Java or Kotlin files or directories could lead to errors such as «Cannot resolve symbol». Using a copy of a project from another operating system may also require to clear this cache and clean the project.

If you are using Android Studio 3.6, the cache files are located in the folder $HOME/.AndroidStudio3.6/

To clear this cache, from the main menu in Android Studio , select File | Invalidate Caches / Restart. In the Invalidate Caches dialog, select an action. You can invalidate the cache and restart the IDE, invalidate the cache without restarting the IDE, or just restart the IDE.

When you invalidate the cache, Android Studio rebuilds all projects you had opened in the current version of the IDE.

Clearing the Gradle build cache¶

The Gradle build cache has two distinct parts located in two different directories:

• In the build/ directory in your project
• In the .gradle/caches/ directory of your Java SDK home directory

Build directory «cache» aka incremental builds

This cache handles Gradle generated code and files. Not all parts of the code are rebuilt at every build, only the necessary ones. This can speed up the build. It is located in the build/ directory(ies) within your project. If you clean and «assemble» your application, you can explore those directories to see what is generated.

In order to clean this cache, from the main menu in Android Studio, select Build | Clean project

You can also manually clean the cache using the terminal as follow:

And to rebuild your app, run:

If you want to investigate on what is built and cached, you can use the —scan option of gradlew as follows (but this is out of the scope of this article):

Build cache

The previous «cache» applies only to your current project, on your machine. However, there is another lesser known cache, named «build cache». The build cache stores some outputs that the Android plugin for Gradle generates when building your project, e.g. unpackaged AARs and pre-dexed remote dependencies. The build cache is enabled by default in recent plugins (2.3.0+) but can be activated/deactivated using the gradle property org.gradle.caching=true

This cache is located in the directory $JAVA_SDK_HOME/.gradle/caches/ . In most cases $JAVA_SDK_HOME is your $HOME folder.

In order to clear the build cache run:

«Invalidate cache» has no impact on the «Build Cache», and «Clean Project» has no relation to the «Build Cache».

To clear gradle build caches:

• Build directory cache (in your project)

# delete project-specific cache
$ ./gradlew clean

• Build cache (in $JAVA_SDK_HOME/.gradle)

# delete build cache
$ rm -rf $GRADLE_HOME/caches/build-cache-*

Clearing the Android build cache¶

To complete the cache «tour», let’s present one more layer of cache: the Android Gradle Plugin (AGP) adds some complementary caching over the Gradle build one. This cache stores outputs that the Android plugin for Gradle generates when building your project (such as unpackaged AARs and pre-dexed remote dependencies).

This cache is located in the $HOME/.android/build-cache/ directory.

In order to clear the AGP cache run:

Cache cleaning cheat sheet¶

From time to time you may need to really clean your project, including all related caching. You could do that to measure how long a clean build takes, or if you have experienced a bug potentially related to one of the caches.

Let’s go through all the necessary steps to build a project, having first cleared all of the caches and then rebuilt again using them all. To do so, run the following commands:

# clear the incremental build cache
$ ./gradlew clean

# clear the Gradle build cache
$ rm -rf $GRADLE_HOME/caches/build-cache-*

# clear the AGP cache
$ ./gradlew cleanBuildCache

# clear the 3rd party dependencies cache
$ rm -rf $GRADLE_HOME/caches/modules-2
$ rm -rf $GRADLE_HOME/caches/transform-2

# stop the gradle daemon
$ ./gradlew —stop

# run a build
$ ./gradlew —scan app:assembleDebug

BUILD SUCCESSFUL in 11m 49s
279 actionable tasks: 192 executed, 82 from cache, 5 up-to-date

# re-run a build without changing anything
$ ./gradlew —scan app:assembleDebug

BUILD SUCCESSFUL in 9s
279 actionable tasks: 279 up-to-date

The time gain can be that important. Cache is certainly useful, isn’t it?

Conclusion¶

This article introduces Gradle sync and caching with Android Studio. In some situations you have to manually sync with Gradle files, run a «Clean project» or «Invalidate cache and restart», which are the main actions you should usually face when developing your apps. If they do not solve all of the issues when building your project, you also have a more complete view on how the system caching works in Android Studio.

You can explore more on the topic using Jason Atwood’s very well documented presentation of the Android Studio cache (link in Related Content section below). It is really detailed and will help you understand more of the Android Studio intricacies.

We hope you learned some new things on how to use cache on Android Studio, and that it will be helpful for your future projects. May you code well, clean well and build well!

Источник