There are many new features of Android Studio 3.0. They can directly speed up the construction speed of Android Studio and speed up development efficiency. The construction speed directly affects the development efficiency. Wasting time is wasted is wasting life. You can modify some configurations and optimize the construction speed.
How to do it before Android Studio 3.0
Shorten build time by configuring DEX resources
gradle Add the following code
android {
...
dexOptions {
maxProcessCount 4 // this is the default value
javaMaxHeapSize "2g"
}
}
maxProcessCount
Sets the maximum number of DEX processes that can be started in parallel
javaMaxHeapSize Sets the maximum memory allocation pool size for the dex operation
According to the configuration of your computer, set these two values. Usually, the larger the two values, the better
Enable dexing-in-process and incremental Java compilation
Android Plugin for Gradle version 2.1.0 and later also introduces other build process improvements, including incremental Java compilation and dexing-in-process. Incremental Java compilation is enabled by default. This compilation method only recompiles the source code parts that have changed or need to be recompiled, which can shorten the compilation time during development.
dexing-in-process executes dexing in the build process rather than a separate external VM process. This not only makes incremental construction faster, but also significantly improves the speed of complete construction. To enable this feature, you need to set the maximum heap size of the Gradle background process to at least 2048 MB. To set it up, you can include the following code in the project's file
= -Xmx2048m
If you have defined a value for javaMaxHeapSize in a module-level file, you need to set the maximum heap size of the background process to the value of javaMaxHeapSize + 1024 MB. For example, if you have set javaMaxHeapSize to "2g", you need to add the following code to the project's file:
= -Xmx3072m
What to do after 3.0
Use the D8 compiler as the DEX compiler
Android Studio 3.0 includes a new optional DEX compiler called D8. It will soon replace the old DX compiler. Now you can choose to use the new compiler. DEX compiler directly affects the app's build time, dex file size, and runtime performance. When using the new D8 compiler, D8 compiles faster and outputs smaller .dex files, and the same or better app runtime performance. To use the D8 compiler, add the following code to the project's file
android.enableD8=true
Use new dependencies
That is, reference to dependencies code block
dependencies{
compile project('xxx')
compile ':glide:3.7.0'
}
There are 4 ways to introduce Android gradle 3.0 plug-in
* implementation is equivalent to the original compile
* api is equivalent to the original compile
* compileOnly is equivalent to the original provided
* runtimeOnly is equivalent to the original apk
Generally speaking, the main use of compile is
To increase the speed of building
Replace with
implementation project('xxx')
implementation ':glide:3.7.0'
api project('xxx')
api ':glide:3.7.0'
So what's the difference between the two?
At this time, one thing you need to pay attention to is, for example, in a lib called A, a B library is used to refer to implementation, and a C module (whether it is lib or app) refers to A. The module of C cannot refer to B, that is, the classes and methods in the B library cannot be used. This is also why using implementation will speed up the build and can reduce duplicate compilation. To reference the library B to, you can use the API. In 3.0, the API usage can completely replace the previous compile, so there is no need to worry about compilation issues.
A brief summary:
implementation: C refers to A. Even if A library implements B, C will not refer to B.
api: C refers to A, and library A refers to B in the API method, C will refer to B
compileOnly only relies on libraries for compilation, and will not package the libraries into apk, which is very useful in some specific scenarios.
runtimeOnly is not used to compile, but it will be packaged into apk. This method is deprecated (not recommended)
refer to
Configuration build
Migrate to Android Plugin for Gradle 3.0.0