tinker_config.gradle

apply plugin: 'com.tencent.bugly.tinker-support'
//apply plugin: 'com.tencent.tinker.patch'

// 接入指南：https://github.com/Tencent/tinker/wiki/Tinker-%E6%8E%A5%E5%85%A5%E6%8C%87%E5%8D%97

/**
 * 1. 执行assembleRelease编译生成基准包
 * // 2. 执行tinkerPatchRelease编译补丁包
 * 2. 执行buildTinkerPatchRelease编译补丁包
 * 3. 生成的补丁包在build/outputs/patch
 */

def bakPath = file("${buildDir}/bakApk/")

/**
 * 此处填写每次构建生成的基准包目录
 */
def baseApkDir = "app-0828-09-54-57"

/**
 * 对于插件各参数的详细解析请参考
 */
tinkerSupport {

    // 开启tinker-support插件，默认值true
    enable = true

    // 指定归档目录，默认值当前module的子目录tinker
    autoBackupApkDir = "${bakPath}"

    // 是否启用覆盖tinkerPatch配置功能，默认值false
    // 开启后tinkerPatch配置不生效，即无需添加tinkerPatch
    overrideTinkerPatchConfiguration = true

    // 编译补丁包时，必需指定基线版本的apk，默认值为空
    // 如果为空，则表示不是进行补丁包的编译
    // @{link tinkerPatch.oldApk }
    baseApk = "${bakPath}/${baseApkDir}/app-release.apk"

    // 对应tinker插件applyMapping
    baseApkProguardMapping = "${bakPath}/${baseApkDir}/app-release-mapping.txt"

    // 对应tinker插件applyResourceMapping
    baseApkResourceMapping = "${bakPath}/${baseApkDir}/app-release-R.txt"

    // 构建基准包和补丁包都要指定不同的tinkerId，并且必须保证唯一性
    tinkerId = "2.0.1_patch_02"

    // 构建多渠道补丁时使用
    // buildAllFlavorsDir = "${bakPath}/${baseApkDir}"

    // 是否启用加固模式，默认为false.(tinker-spport 1.0.7起支持）
    // isProtectedApp = true

    // 是否开启反射Application模式
    enableProxyApplication = false

    // 是否支持新增非export的Activity（注意：设置为true才能修改AndroidManifest文件）
    supportHotplugComponent = true

}

/**
 * 一般来说,我们无需对下面的参数做任何的修改
 * 对于各参数的详细介绍请参考:
 * https://github.com/Tencent/tinker/wiki/Tinker-%E6%8E%A5%E5%85%A5%E6%8C%87%E5%8D%97
 */
tinkerPatch {
    //oldApk ="${bakPath}/${appName}/app-release.apk"
    ignoreWarning = false
    useSign = true
    dex {
        dexMode = "jar"
        pattern = ["classes*.dex"]
        loader = []
    }
    lib {
        pattern = ["lib/*/*.so"]
    }

    res {
        pattern = ["res/*", "r/*", "assets/*", "resources.arsc", "AndroidManifest.xml"]
        ignoreChange = []
        largeModSize = 100
    }

    packageConfig {
    }
    sevenZip {
        zipArtifact = "com.tencent.mm:SevenZip:1.1.10"
//        path = "/usr/local/bin/7za"
    }
    buildConfig {
        keepDexApply = false
//        tinkerId = "2.0.1-base"
//        applyMapping = "${bakPath}/${appName}/app-release-mapping.txt" //  可选，设置mapping文件，建议保持旧apk的proguard混淆方式
//        applyResourceMapping = "${bakPath}/${appName}/app-release-R.txt" // 可选，设置R.txt文件，通过旧apk文件保持ResId的分配
    }
}

///**
// * you can use assembleRelease to build you base apk
// * use tinkerPatchRelease -POLD_APK=  -PAPPLY_MAPPING=  -PAPPLY_RESOURCE= to build patch
// * add apk from the build/bakApk
// */
//ext {
//    // 是否打开tinker的功能。
//    tinkerEnabled = true
//
//    // 基准apk包的路径，必须输入，否则会报错。
//    tinkerOldApkPath = "${bakPath}/app-release-0827-14-32-40.apk"
//    // 可选参数；在编译新的apk时候，我们希望通过保持旧apk的proguard混淆方式，从而减少补丁包的大小。
//    // 这个只是推荐设置，不设置applyMapping也不会影响任何的assemble编译。
//    tinkerApplyMappingPath = "${bakPath}/app-release-0827-14-32-40-mapping.txt"
//    // 可选参数；在编译新的apk时候，我们希望通过旧apk的R.txt文件保持ResId的分配，
//    // 这样不仅可以减少补丁包的大小，同时也避免由于ResId改变导致remote view异常
//    tinkerApplyResourcePath = "${bakPath}/app-release-0827-14-32-40-R.txt"
//
//    // only use for build all flavor, if not, just ignore this field
//    tinkerBuildFlavorDirectory = "${bakPath}/app-flavor"
//}
//
//// hasProperty检查gradle.properties里面有没有这个字段
//def getOldApkPath() {
//    return hasProperty("OLD_APK") ? OLD_APK : ext.tinkerOldApkPath
//}
//
//def getApplyMappingPath() {
//    return hasProperty("APPLY_MAPPING") ? APPLY_MAPPING : ext.tinkerApplyMappingPath
//}
//
//def getApplyResourceMappingPath() {
//    return hasProperty("APPLY_RESOURCE") ? APPLY_RESOURCE : ext.tinkerApplyResourcePath
//}
//
//def getTinkerIdValue() {
//    return hasProperty("TINKER_ID") ? TINKER_ID : "2.0.1_patch"
//}
//
//def buildWithTinker() {
//    return hasProperty("TINKER_ENABLE") ? Boolean.parseBoolean(TINKER_ENABLE) : ext.tinkerEnabled
//}
//
//def getTinkerBuildFlavorDirectory() {
//    return ext.tinkerBuildFlavorDirectory
//}
//
//tinkerPatch {
//    /**
//     * 基准apk包的路径，必须输入，否则会报错。
//     */
//    oldApk = getOldApkPath()
//    /**
//     * 如果出现以下的情况，并且ignoreWarning为false，我们将中断编译。因为这些情况可能会导致编译出来的patch包带来风险：
//     * 1. minSdkVersion小于14，但是dexMode的值为"raw";
//     * 2. 新编译的安装包出现新增的四大组件(Activity, BroadcastReceiver...)；
//     * 3. 定义在dex.loader用于加载补丁的类不在main dex中;
//     * 4. 定义在dex.loader用于加载补丁的类出现修改；
//     * 5. resources.arsc改变，但没有使用applyResourceMapping编译。
//     */
//    ignoreWarning = false
//
//    /**
//     * 在运行过程中，我们需要验证基准apk包与补丁包的签名是否一致，我们是否需要为你签名。
//     */
//    useSign = true
//
//    /**
//     * 是否打开tinker的功能。
//     */
//    tinkerEnable = buildWithTinker()
//
//    /**
//     * 编译相关的配置项
//     *
//     * Warning, applyMapping will affect the normal android build!
//     */
//    buildConfig {
//        /**
//         * 可选参数；在编译新的apk时候，我们希望通过保持旧apk的proguard混淆方式，从而减少补丁包的大小。
//         * 这个只是推荐设置，不设置applyMapping也不会影响任何的assemble编译。
//         */
//        applyMapping = getApplyMappingPath()
//        /**
//         * 可选参数；在编译新的apk时候，我们希望通过旧apk的R.txt文件保持ResId的分配，
//         * 这样不仅可以减少补丁包的大小，同时也避免由于ResId改变导致remote view异常
//         */
//        applyResourceMapping = getApplyResourceMappingPath()
//
//        /**
//         * 在运行过程中，我们需要验证基准apk包的tinkerId是否等于补丁包的tinkerId。
//         * 这个是决定补丁包能运行在哪些基准包上面，一般来说我们可以使用git版本号、versionName等等。
//         */
//        tinkerId = getTinkerIdValue()
//
//        /**
//         * 如果我们有多个dex,编译补丁时可能会由于类的移动导致变更增多。
//         * 若打开keepDexApply模式，补丁包将根据基准包的类分布来编译。
//         */
//        keepDexApply = false
//
//        /**
//         * 是否使用加固模式，仅仅将变更的类合成补丁。注意，这种模式仅仅可以用于加固应用中。
//         */
//        isProtectedApp = false
//
//        /**
//         * 是否支持新增非export的Activity
//         */
//        supportHotplugComponent = false
//    }
//
//    /**
//     * dex相关的配置项
//     */
//    dex {
//        /**
//         * 只能是'raw'或者'jar'。
//         * 对于'raw'模式，我们将会保持输入dex的格式。
//         * 对于'jar'模式，我们将会把输入dex重新压缩封装到jar。如果你的minSdkVersion小于14，你必须选择‘jar’模式，
//         * 而且它更省存储空间，但是验证md5时比'raw'模式耗时。默认我们并不会去校验md5,一般情况下选择jar模式即可。
//         */
//        dexMode = "jar"
//
//        /**
//         * 需要处理dex路径，支持*、?通配符，必须使用'/'分割。路径是相对安装包的，例如assets/...
//         */
//        pattern = ["classes*.dex",
//                   "assets/secondary-dex-?.jar"]
//        /**
//         * 这一项非常重要，它定义了哪些类在加载补丁包的时候会用到。这些类是通过Tinker无法修改的类，也是一定要放在main dex的类。
//         * 这里需要定义的类有：
//         * 1. 你自己定义的Application类；
//         * 2. Tinker库中用于加载补丁包的部分类，即com.tencent.tinker.loader.*；
//         * 3. 如果你自定义了TinkerLoader，需要将它以及它引用的所有类也加入loader中；
//         * 4. 其他一些你不希望被更改的类，例如Sample中的BaseBuildInfo类。这里需要注意的是，这些类的直接引用类也需要加入到loader中。或者你需要将这个类变成非preverify。
//         * 5. 使用1.7.6版本之后的gradle版本，参数1、2会自动填写。若使用newApk或者命令行版本编译，1、2依然需要手动填写
//         *
//         */
//        loader = [
//                //use sample, let BaseBuildInfo unchangeable with tinker
//                "tinker.sample.android.app.BaseBuildInfo"
//        ]
//    }
//
//    /**
//     * lib相关的配置项
//     */
//    lib {
//        /**
//         * 需要处理lib路径，支持*、?通配符，必须使用'/'分割。与dex.pattern一致, 路径是相对安装包的，例如assets/...
//         */
//        pattern = ["lib/*/*.so"]
//    }
//
//    res {
//        /**
//         * 需要处理res路径，支持*、?通配符，必须使用'/'分割。与dex.pattern一致, 路径是相对安装包的，例如assets/...，
//         * 务必注意的是，只有满足pattern的资源才会放到合成后的资源包。
//         */
//        pattern = ["res/*", "assets/*", "resources.arsc", "AndroidManifest.xml"]
//
//        /**
//         * 支持*、?通配符，必须使用'/'分割。若满足ignoreChange的pattern，在编译时会忽略该文件的新增、删除与修改。
//         * 最极端的情况，ignoreChange与上面的pattern一致，即会完全忽略所有资源的修改。
//         */
//        ignoreChange = ["assets/sample_meta.txt"]
//
//        /**
//         * 对于修改的资源，如果大于largeModSize，我们将使用bsdiff算法。
//         * 这可以降低补丁包的大小，但是会增加合成时的复杂度。默认大小为100kb
//         */
//        largeModSize = 100
//    }
//
//    /**
//     * 用于生成补丁包中的'package_meta.txt'文件
//     */
//    packageConfig {
//        /**
//         * configField("key", "value"), 默认我们自动从基准安装包与新安装包的Manifest中读取tinkerId,并自动写入configField。
//         * 在这里，你可以定义其他的信息，在运行时可以通过TinkerLoadResult.getPackageConfigByName得到相应的数值。
//         * 但是建议直接通过修改代码来实现，例如BuildConfig。
//         */
//        configField("patchMessage", "tinker is sample to use")
//        /**
//         * just a sample case, you can use such as sdkVersion, brand, channel...
//         * you can parse it in the SamplePatchListener.
//         * Then you can use patch conditional!
//         */
//        configField("platform", "all")
//        /**
//         * patch version via packageConfig
//         */
//        configField("patchVersion", "1.0")
//    }
//    //or you can add config filed outside, or get meta value from old apk
//    //project.tinkerPatch.packageConfig.configField("test1", project.tinkerPatch.packageConfig.getMetaDataFromOldApk("Test"))
//    //project.tinkerPatch.packageConfig.configField("test2", "sample")
//
//    /**
//     * 7zip路径配置项，执行前提是useSign为true
//     */
//    sevenZip {
//        /**
//         * 例如"com.tencent.mm:SevenZip:1.1.10"，将自动根据机器属性获得对应的7za运行文件，推荐使用。
//         */
//        zipArtifact = "com.tencent.mm:SevenZip:1.1.10"
//        /**
//         * 系统中的7za路径，例如"/usr/local/bin/7za"。path设置会覆盖zipArtifact，若都不设置，将直接使用7za去尝试。
//         */
////        path = "/usr/local/bin/7za"
//    }
//}
//
//List<String> flavors = new ArrayList<>();
//project.android.productFlavors.each { flavor ->
//    flavors.add(flavor.name)
//}
//boolean hasFlavors = flavors.size() > 0
//def date = new Date().format("MMdd-HH-mm-ss")
//
///**
// * bak apk and mapping
// */
//android.applicationVariants.all { variant ->
//    /**
//     * task type, you want to bak
//     */
//    def taskName = variant.name
//
//    tasks.all {
//        if ("assemble${taskName.capitalize()}".equalsIgnoreCase(it.name)) {
//
//            it.doLast {
//                copy {
//                    def fileNamePrefix = "${project.name}-${variant.baseName}"
//                    def newFileNamePrefix = hasFlavors ? "${fileNamePrefix}" : "${fileNamePrefix}-${date}"
//
//                    def destPath = hasFlavors ? file("${bakPath}/${project.name}-${date}/${variant.flavorName}") : bakPath
//                    from variant.outputs.first().outputFile
//                    into destPath
//                    rename { String fileName ->
//                        fileName.replace("${fileNamePrefix}.apk", "${newFileNamePrefix}.apk")
//                    }
//
//                    from "${buildDir}/outputs/mapping/${variant.dirName}/mapping.txt"
//                    into destPath
//                    rename { String fileName ->
//                        fileName.replace("mapping.txt", "${newFileNamePrefix}-mapping.txt")
//                    }
//
//                    from "${buildDir}/intermediates/symbols/${variant.dirName}/R.txt"
//                    into destPath
//                    rename { String fileName ->
//                        fileName.replace("R.txt", "${newFileNamePrefix}-R.txt")
//                    }
//                }
//            }
//        }
//    }
//}
//project.afterEvaluate {
//    //sample use for build all flavor for one time
//    if (hasFlavors) {
//        task(tinkerPatchAllFlavorRelease) {
//            group = 'tinker'
//            def originOldPath = getTinkerBuildFlavorDirectory()
//            for (String flavor : flavors) {
//                def tinkerTask = tasks.getByName("tinkerPatch${flavor.capitalize()}Release")
//                dependsOn tinkerTask
//                def preAssembleTask = tasks.getByName("process${flavor.capitalize()}ReleaseManifest")
//                preAssembleTask.doFirst {
//                    String flavorName = preAssembleTask.name.substring(7, 8).toLowerCase() + preAssembleTask.name.substring(8, preAssembleTask.name.length() - 15)
//                    project.tinkerPatch.oldApk = "${originOldPath}/${flavorName}/${project.name}-${flavorName}-release.apk"
//                    project.tinkerPatch.buildConfig.applyMapping = "${originOldPath}/${flavorName}/${project.name}-${flavorName}-release-mapping.txt"
//                    project.tinkerPatch.buildConfig.applyResourceMapping = "${originOldPath}/${flavorName}/${project.name}-${flavorName}-release-R.txt"
//
//                }
//
//            }
//        }
//
//        task(tinkerPatchAllFlavorDebug) {
//            group = 'tinker'
//            def originOldPath = getTinkerBuildFlavorDirectory()
//            for (String flavor : flavors) {
//                def tinkerTask = tasks.getByName("tinkerPatch${flavor.capitalize()}Debug")
//                dependsOn tinkerTask
//                def preAssembleTask = tasks.getByName("process${flavor.capitalize()}DebugManifest")
//                preAssembleTask.doFirst {
//                    String flavorName = preAssembleTask.name.substring(7, 8).toLowerCase() + preAssembleTask.name.substring(8, preAssembleTask.name.length() - 13)
//                    project.tinkerPatch.oldApk = "${originOldPath}/${flavorName}/${project.name}-${flavorName}-debug.apk"
//                    project.tinkerPatch.buildConfig.applyMapping = "${originOldPath}/${flavorName}/${project.name}-${flavorName}-debug-mapping.txt"
//                    project.tinkerPatch.buildConfig.applyResourceMapping = "${originOldPath}/${flavorName}/${project.name}-${flavorName}-debug-R.txt"
//                }
//
//            }
//        }
//    }
//}