Android 构建那些事

include ':app', ':lib'

/**
 * buildscript代码块用来配置Gradle自己的repositories和dependencies，所以不能包含modules使用的dependencies
 */

buildscript {

    /**
     * repositories 代码块用来配置 Gradle 用来搜索和下载依赖的仓库
     * Gradle 默认是支持像 JCenter，Maven Central，和 Ivy 远程仓库的，你也可以使用本地仓库或定义你自己的远程仓库
     * 下面的代码定义了 Gradle 用于搜索下载依赖的 JCenter 仓库和 Google 的 Maven 仓库
     */

    repositories {
        google()
        jcenter()
    }

    /**
     * dependencies 代码块用来配置 Gradle 用来构建工程的依赖，下面的代码表示添加一个
     * Gradle 的 Android 插件作为 classpath 依赖
     */

    dependencies {
        classpath 'com.android.tools.build:gradle:3.0.1'
    }
}

/**
 * allprojects 代码块用来配置工程中所有 modules 都要使用的仓库和依赖
 * 但是你应该在每个 module 级的 build 文件中配置 module 独有的依赖。
 * 对于一个新工程，Android Studio 默认会让所有 modules 使用 JCenter 仓库和 Google 的 Maven 仓库
 */

allprojects {
   repositories {
       google()
       jcenter()
   }
}

buildscript {...}

allprojects {...}

ext {
    // 如让所有 modules 都使用相同的版本以避免冲突
    compileSdkVersion = 26
    supportLibVersion = "27.0.2"
    ...
}
...

android {
  compileSdkVersion rootProject.ext.compileSdkVersion
  ...
}
...
dependencies {
    compile "com.android.support:appcompat-v7:${rootProject.ext.supportLibVersion}"
    ...
}

/**
 * 为这个构建应用 Gradle 的 Android 插件，以便 android 代码块中 Android 特定的构建配置可用
 */

apply plugin: 'com.android.application'

/**
 * android 代码块用来配置 Android 特定的构建配置
 */

android {

  /**
   * compileSdkVersion 用来指定 Gradle 用来编译应用的 Android API level，也就是说
   * 你的应用可以使用这个 API level 及更低 API level 的 API 特性
   */

  compileSdkVersion 26

  /**
   * buildToolsVersion 用来指定 SDK 所有构建工具、命令行工具、以及 Gradle 用来构建应用的编译器版本
   * 你需要使用 SDK Manager 下载好该版本的构建工具
   * 在 3.0.0 或更高版本的插件中。该属性是可选的，插件会使用推荐的版本
   */

  buildToolsVersion "27.0.3"

  /**
   * defaultConfig 代码块包含所有构建变体（build variants）默认使用的配置，也可以重写 main/AndroidManifest.xml 中的属性
   * 当然，你也可以在 product flavors（产品风味）中重写其中一些属性
   */

  defaultConfig {

    /**
     * applicationId 是发布时的唯一指定包名，尽管如此，你还是需要在 main/AndroidManifest.xml 文件中
     * 定义值是该包名的 package 属性
     */

    applicationId 'com.example.myapp'

    // 定义可以运行该应用的最小 API level
    minSdkVersion 15

    // 指定测试该应用的 API level
    targetSdkVersion 26

    // 定义应用的版本号
    versionCode 1

    // 定义用户友好型的版本号描述
    versionName "1.0"
  }

  /**
   * buildTypes 代码块用来配置多个构建类型，构建系统默认定义了两个构建类型: debug 和 release
   * debug 构建类型默认不显式声明，但它包含调试工具并使用 debug key 签名
   * release 构建类型默认应用了混淆配置
   */

  buildTypes {
    release {
        minifyEnabled true
        proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
    }
  }

  /**
   * 由于 product flavors 必须属于一个已命名的 flavor dimension，所以你至少需要定义一个 flavor dimension
   * 如定义一个等级和最小 api 的 flavor dimension
   */

  flavorDimensions "tier", "minApi"

  productFlavors {
       free {
        // 这个 product flavor 属于 "tier" flavor dimension
        // 如果只有一个 dimension 那么这个属性就是可选的
        dimension "tier"
        ...
      }

      paid {
        dimension "tier"
        ...
      }

      minApi23 {
          dimension "minApi"
          ...
      }

      minApi18 {
          dimension "minApi"
          ...
      }
  }

  /**
   * 你可以使用 splits 代码块配置为不同屏幕分辨率或 ABI 的设备生成仅包含其支持的代码和资源的 APK
   * 同时你需要配置 build 文件以便每个 APK 使用不同的 versionCode
   */

  splits {
    density {

      // 启用或禁用构建多个 APK
      enable false

      // 构建多个 APK 时排除这些分辨率
      exclude "ldpi", "tvdpi", "xxxhdpi", "400dpi", "560dpi"
    }
  }
}

/**
 * 该 module 级 build 文件的 dependencies 代码块仅用来指定该 module 自己的依赖
 */

dependencies {
    implementation project(":lib")
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    implementation 'com.android.support:appcompat-v7:27.0.2'
}

// The following types can appear anywhere in the code
// but say nothing about API or implementation usage
import org.apache.commons.httpclient.*;
import org.apache.commons.httpclient.methods.*;
import org.apache.commons.lang3.exception.ExceptionUtils;
import java.io.IOException;
import java.io.UnsupportedEncodingException;

public class HttpClientWrapper {

    private final HttpClient client; // private member: implementation details

    // HttpClient is used as a parameter of a public method
    // so "leaks" into the public API of this component
    public HttpClientWrapper(HttpClient client) {
        this.client = client;
    }

    // public methods belongs to your API
    public byte[] doRawGet(String url) {
        GetMethod method = new GetMethod(url);
        try {
            int statusCode = doGet(method);
            return method.getResponseBody();

        } catch (Exception e) {
            ExceptionUtils.rethrow(e); // this dependency is internal only
        } finally {
            method.releaseConnection();
        }
        return null;
    }

    // GetMethod is used in a private method, so doesn't belong to the API
    private int doGet(GetMethod method) throws Exception {
        int statusCode = client.executeMethod(method);
        if (statusCode != HttpStatus.SC_OK) {
            System.err.println("Method failed: " + method.getStatusLine());
        }
        return statusCode;
    }
}

dependencies {
    api 'commons-httpclient:commons-httpclient:3.1'
    implementation 'org.apache.commons:commons-lang3:3.5'
}

apply plugin: 'java-library'
repositories {
    mavenCentral()
}
dependencies {
    implementation 'org.springframework:spring-web:5.0.2.RELEASE'
}

implementation 'org.springframework:spring-web:5.+'

implementation 'org.springframework:spring-web:5.0.3.BUILD-SNAPSHOT'

configurations {
    antContrib
    externalLibs
    deploymentTools
}

dependencies {
    antContrib files('ant/antcontrib.jar')
    externalLibs files('libs/commons-lang.jar', 'libs/log4j.jar')
    deploymentTools fileTree(dir: 'tools', include: '*.exe')
}

project(':web-service') {
    dependencies {
        implementation project(':utils')
        implementation project(':api')
    }
}

configurations.all {
    resolutionStrategy {
        eachDependency { details ->
            // Force all of the primary support libraries to use the same version.
            if (details.requested.group == 'com.android.support' &&
                    details.requested.name != 'multidex' &&
                    details.requested.name != 'multidex-instrumentation') {
                details.useVersion supportLibVersion
            }
        }
    }
}

android.applicationVariants.all { variant ->
    variant.outputs.all {
        outputFileName = "${variant.name}-${variant.versionName}.apk"
    }
}

com/example/MyClass.class
com/example/MyOtherClass.class

android {
    buildTypes {
        release {
            multiDexKeepFile file('multidex-config.txt')
            ...
        }
    }
}

-keep class com.example.** { *; }

android {
    buildTypes {
        release {
            multiDexKeepProguard file('multidex-config.pro')
            ...
        }
    }
}