Summary of common configurations of Android gradle

This article summarizes the common configurations in the build.gradle file in Android development. Some configurations are used in specific scenarios, and some are added to solve some problems. Therefore, by default, the configuration in the default build.gradle file generated when creating a new project in the Android Studio tool is used. When you encounter problems, add some configurations.

 // apply plugin: 'com.android.library' // Library configuration apply plugin: 'com.android.application' // Application configuration repositories { // This needs to be configured when importing AAR files. AAR files are placed in the libs directory
 flatDir {
 dirs 'libs'  
 }
 } 
 
 android {
 compileSdkVersion 25 // The version of the Android compilation SDK, that is, the android.jar file of 4.0SDK, 5.0SDK, etc.
 buildToolsVersion "25.0.2" // Use the version of the compilation tool in the SDK
 useLibrary "org.apache.http.legacy" // Use Apache's httpClient package in 6.0 because Google removed this http request library in 6.0 
 
 defaultConfig {
 applicationId "com.xxx" // The package name of the application can be referenced in AndroidMainfest.xml using ${applicationId}
 minSdkVersion 15 // minimum compatible version
 targetSdkVersion 25 // target version
 versionCode 1 // Application version number
 versionName SDK_VERSION // Application version name
 multiDexEnabled true // Enable multi-dex if the number of code methods in the app exceeds 65535 
 
 testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner" // android unit test configuration 
 
 } 
 
 sourceSets { // Specify the path of code and resources. For details, please refer to http://google.github.io/android-gradle-dsl/2.3/com.android.build.gradle.api.AndroidSourceSet.html
 main {
 manifest.srcFile 'AndroidManifest.xml' //Specify the path to manifest.xml
 java.srcDirs = [ 'src' ] // java file path, one level above the package name, multiple directories are separated by commas, such as [ 'src' , 'core' ]
 resources.srcDirs = [ 'src' ] // All directories of resource resources. Note that this refers to some resources contained in the jar file, such as properties files, rather than the res resources in the APK
 aidl.srcDirs = [ 'src' ] // directory of aidl files
 renderscript.srcDirs = [ 'src' ] // path to the renderscript file
 res.srcDirs = [ 'res' ] // Resource path in android APK
 assets.srcDirs = [ 'assets' ] // asset directory in android app
 jniLibs.srcDirs = [ 'libs' ] // Path to the SO library
 }
 } 
 
 lintOptions {
 checkReleaseBuilds false // Disable lint check when compiling release
 abortOnError false // Error reporting will not stop packaging unless it is very serious and affects
 disable 'MissingTranslation' , 'ExtraTranslation' // Disable some options in lint check
 } 
 
 dexOptions {
 javaMaxHeapSize "4g" // Set the maximum heap memory size when compiling project code, otherwise the compilation memory will overflow when the project is too large
 } 
 
 compileOptions { // For details, please refer to http://google.github.io/android-gradle-dsl/2.3/com.android.build.gradle.internal.CompileOptions.html
 sourceCompatibility JavaVersion.VERSION_1_7 // Set the version of the code compilation. Generally, this is configured when using JDK1.8 to make the compiled jar package more universal for others to use
        targetCompatibility JavaVersion.VERSION_1_7
 } 
 
 packagingOptions {
 exclude 'META-INF/DEPENDENCIES.txt' // Exclude the declaration files in these third-party jars, otherwise it is easy to cause errors during compilation
        exclude 'META-INF/LICENSE.txt'  
        exclude 'META-INF/NOTICE.txt'  
        exclude 'META-INF/NOTICE'  
        exclude 'META-INF/LICENSE'  
        exclude 'META-INF/DEPENDENCIES'  
        exclude 'META-INF/notice.txt'  
        exclude 'META-INF/license.txt'  
        exclude 'META-INF/dependencies.txt'  
        exclude 'META-INF/LGPL2.1'  
 } 
 
 buildTypes {
 debug { storeFile file( "debug.keystore" ) ​​// relative path of signature file
 storePassword "android" // Signature password
 keyAlias ​​"androiddebugkey" // alias
 keyPassword "android" // Alias ​​password 
 
 buildConfigField "boolean" , "FLAG_DEBUG" , "true" // Automatically generate public in the class of BuildConfig.   static final boolean FLAG_DEBUG = true ; code
           buildConfigField "String" , "API_VERSION" , "\"1\""   
            
 ndk {
 abiFilters "armeabi" , "armeabi-v7a" // Only keep SO libraries of these CPU architectures, which require a higher version of gradle to support
 }
 // jniDebuggable true // Enable JNI debug. This option is rarely used and is not recommended. It will affect the debugging speed of Java code.
 } 
 
 release {
            buildConfigField "boolean" , "FLAG_DEBUG" , "false"  
            buildConfigField "String" , "API_VERSION" , "\"1\""  
 minifyEnabled true // Remove useless content from the code when obfuscating
 shrinkResources true // Remove useless resources during obfuscation, for the contents in the res/directory, do not compress the size of the image
 proguardFiles getDefaultProguardFile( 'proguard-android.txt' ), 'proguard-rules.pro' // Configure obfuscation file 
             
 ndk {
 abiFilters "armeabi" , "armeabi-v7a" // Only keep SO libraries of these CPU architectures, which require a higher version of gradle to support
 }
 }
 }
 } 
 
 dependencies { compile fileTree(include: [ '*.jar' ], dir: 'libs' ) // Import all jar packages in the libs directory
 androidTestCompile( 'com.android.support.test.espresso:espresso-core:2.2.2' , { // Exclude modules in group , note group and module names com.android.support:support-annotations
        exclude group : 'com.android.support' , module: 'support-annotations'  
 })
 compile 'com.android.support:appcompat-v7:25.1.0' // Use Google's appcompat-v7 package
 testCompile 'junit:junit:4.12' // Import junit unit test 
 
 compile 'com.android.support:multidex:1.0.0' // Add loading of multi-dex library
 compile files( 'libs/gson.jar' ) // Reference the gson.jar package in the libs directory
 compile( name : 'HMS-SDK-2.4.0.300' , ext: 'aar' ) // Import the HMS-SDK-2.4.0.300.aar file. You also need to refer to the configuration in the file header.
 compile( 'com.facebook.fresco:fresco:1.0.0' ) { exclude module: 'support-v4' } // Import the fresco library, but do not use the support-v4 library referenced in it, otherwise it will lead to repeated introduction and compilation error duplicate
 provided fileTree(dir: 'compilelibs' , include: [ '*.jar' ]) // Introduce the jar files in the compilelibs directory to participate in the compilation, but do not include the code of these packages in the APK, jar or AAR. }// Use the jar task to generate the jar file, relying on the assembleRelease tasktask buildJar(type: Jar, dependsOn: [ 'assembleRelease' ]) {
    destinationDir = file( 'build/outputs/jar/' )
 appendix = ""  
 baseName = ""  
 version = SDK_VERSION // manifest information
    def map = [ 'Version' : SDK_VERSION, 'Gradle' : project.gradle.gradleVersion, 'Vendor' : 'szcomtop.com' , 'Date' : new Date ().getDateTimeString()
 ]
    manifest.attributes(map)// from ( 'build/intermediates/classes/release/' )
 from (project.zipTree( 'build/intermediates/transforms/proguard/release/jars/3/3/main.jar' ))
    exclude( '**/BuildConfig.class' )
    exclude( '**/BuildConfig\$*.class' )
 exclude( '**/R.class' )
    exclude( '**/R\$*.class' )
 include( '**/*.class' )
 }// Use the Copy task to copy content task copySDK(type: Copy, dependsOn: [ 'buildJar' ]) {
 from ( 'build/outputs/jar' )
 into ( '../app/libs/' )
 include( "*.jar" )
 }

How to use

We will continue to update, and with the upgrade of Android's gradle tool, some configurations may change. For example, ndk.abiFilters can only be used in a higher version of the gradle tool. Upgrading the gradle version may also cause compilation failures and other problems, which take a long time to solve, so please be cautious.

Regarding the usage of some configurations, one example is given below, and the others are similar.

For example, how do you know there is a compileOptions configuration? What settings can be set under this configuration? How do you use these settings? What values ​​can be given?

 compileOptions { 
 
 sourceCompatibility JavaVersion.VERSION_1_7 // Set the version of the code compilation. Generally, this is configured when using JDK1.8 to make the compiled jar package more universal for others to use 
 
 targetCompatibility JavaVersion.VERSION_1_7 
 
 }

Start from the official website

Click here for the usage documentation of the gradle tool officially defined by android, and click here for the official gradle documentation.

There is a DSL in the link. What is this DSL? DSL is the abbreviation of Gradle Build Language. Haha, just kidding, it is the abbreviation of Domain Specific Language, and Domain can be understood as Project.

I’m getting off topic, let’s move on.

compileOptions Example

Open the official documentation page of the Android Gradle tool and you will see the version selection page as shown below:

This version corresponds to the gradle version in the build.gradle file in the root directory of the Android Studio project. At the same time, it is found that this version corresponds to the version of Android Studio. As shown in the following figure:

Click the link of the current 2.2 version to enter the following interface, as shown in the figure below, find compileOptions on the left and click this link (to get familiar with this official document, you can start from the Home item on the left):

Click the link marked with a red box in the above picture, and you will be redirected to the configuration instructions as shown in the following figure. This jump method is a bit similar to the Java API, but you should see the details this time, but you don’t:

If you need to view further details, you can only click on the link marked with a red frame in the above picture. After entering, you will find familiar content, as shown in the following figure:

Do you have a long-lost feeling that you are finally about to see the truth? There is only one step left. The available options and their meanings in compileOptions have been clearly written above. Clicking sourceCompatibility will jump to the content shown in the following figure:

From the above, you can see what values ​​sourceCompatibility can take, and finally found the result.

OK, that’s all for the compileOptions example. The same method can be used for other configurations. The official Gradle documentation is similar. The rest is just a matter of familiarity.