Tinker热修复原理以及组件化封装

男娘i 2022-04-12 07:52 265阅读 0赞

## 需要创建以下类 ##

*  TinkerManager（对Tinker进行组件化再次封装，减少对系统的侵入）
 *  CustomApplicationLike(委托(代理)模式:Tinker需要对Application的生命周期进行监听，通过ApplicationLike进行委托)
 *  CustomPatchListener(自定义PatchListener监听patch receiver事件)
 *  CustomResultService(自定义TinkerResultService改变patch安装后的行为)
 *  TinkerService(功能：应用程序Tinker更新服务： 1.检查补丁更新 2.从服务器下载patch文件 3.使用TinkerManager完成patch文件加载 4.patch文件会在下次进程启动时生效)

## 项目展示 ##

![多渠道打补丁][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaXlpY2FuZ2dvdV93dWppZQ_size_16_color_FFFFFF_t_70]  
![tinker插件][tinker]

## TinkerManager ##

/** * 作者：wujie on 2018/12/1 14:49 * 邮箱：705030268@qq.com * 功能：对Tinker进行组件化再次封装，减少对系统的侵入 */
    
    public class TinkerManager { 
    
        private static boolean isInstalled = false;
    
        private static ApplicationLike mApplicationLike;
    
        private static CustomPatchListener mPatchListener;
    
    
        /** * 对Tinker的初始化 * @param applicationLike */
        public static void installTinker(ApplicationLike applicationLike) { 
            mApplicationLike = applicationLike;
            if(isInstalled) { 
                return;
            }
    
            mPatchListener = new CustomPatchListener(getApplicationContext());
            LoadReporter loadReporter = new DefaultLoadReporter(getApplicationContext());
            PatchReporter patchReporter = new DefaultPatchReporter(getApplicationContext());
            AbstractPatch upgradePatchProcessor = new UpgradePatch();
    
    // TinkerInstaller.install(mApplicationLike); //对Tinke初始化
            TinkerInstaller.install(applicationLike,
                    loadReporter,
                    patchReporter,
                    mPatchListener,
                    CustomResultService.class,
                    upgradePatchProcessor); //完成Tinker初始化
    
            isInstalled = true;
        }
    
        //完成Patch文件的加载
        public static void loadPatch(String localPath) { 
            if(Tinker.isTinkerInstalled()) { 
                TinkerInstaller.onReceiveUpgradePatch(getApplicationContext(), localPath);
            }
        }
    
        //加个md5校验规则,防止补丁文件被篡改
        //服务端返回原始文件的md5值，客户端下载patch文件以后，获取patch文件的MD5值与服务端返回的md5值比较是否相等
        public static void loadPatch(String path, String md5Value) { 
            if (Tinker.isTinkerInstalled()) { 
                mPatchListener.setCurrentMD5(md5Value);
                TinkerInstaller.onReceiveUpgradePatch(getApplicationContext(), path);
            }
        }
    
        private static Context getApplicationContext() { 
            if(null != mApplicationLike) { 
                return mApplicationLike.getApplication().getApplicationContext();
            }
            return null;
        }
    }

## CustomApplicationLike ##

/** * 作者：wujie on 2018/12/1 15:07 * 邮箱：705030268@qq.com * 功能：委托(代理)模式 * Tinker需要对Application的生命周期进行监听，通过ApplicationLike进行委托，在ApplicationLike中对Tinker进行监听 */
    @DefaultLifeCycle(application = ".MyTinkerApplication",   //通过注解生成Application
            flags = ShareConstants.TINKER_ENABLE_ALL,
            loadVerifyFlag = false)
    public class CustomApplicationLike extends ApplicationLike { 
    
        public CustomApplicationLike(Application application, int tinkerFlags,
                                     boolean tinkerLoadVerifyFlag,
                                     long applicationStartElapsedTime,
                                     long applicationStartMillisTime,
                                     Intent tinkerResultIntent) { 
            super(application, tinkerFlags, tinkerLoadVerifyFlag,
                    applicationStartElapsedTime, applicationStartMillisTime, tinkerResultIntent);
        }
    
        @Override
        public void onBaseContextAttached(Context base) { 
            super.onBaseContextAttached(base);
            //使应用支持分包
            MultiDex.install(base);
            TinkerManager.installTinker(this);
        }
    }

## 自定义PatchListener ##

/** * @function: 自定义PatchListener监听patch receiver事件 * 1.较验patch文件是否合法(自定义规则) 2.启动Service去安装patch文件 */
    public class CustomPatchListener extends DefaultPatchListener { 
    
        private String currentMD5;
    
        public void setCurrentMD5(String md5Value) { 
    
            this.currentMD5 = md5Value;
        }
    
        public CustomPatchListener(Context context) { 
            super(context);
        }
    
    
        @Override
        protected int patchCheck(String path, String patchMd5) { 
            //patch文件md5较验
            if (!Utils.isFileMD5Matched(path, currentMD5)) { 
    
                return ShareConstants.ERROR_PATCH_DISABLE;
            }
            return super.patchCheck(path, patchMd5);
    
        }
    }

## 自定义TinkerResultService ##

/** * @function 自定义TinkerResultService改变patch安装后的行为 * 本类的作用：决定在patch安装完以后的后续操作，默认实现是杀进程 */
    public class CustomResultService extends DefaultTinkerResultService { 
        private static final String TAG = "Tinker.SampleResultService";
    
        //返回patch文件的最终安装结果
        @Override
        public void onPatchResult(PatchResult result) { 
            if (result == null) { 
                TinkerLog.e(TAG, "DefaultTinkerResultService received null result!!!!");
                return;
            }
            TinkerLog.i(TAG, "DefaultTinkerResultService received a result:%s ", result.toString());
    
            //first, we want to kill the recover process
            TinkerServiceInternals.killTinkerPatchServiceProcess(getApplicationContext());
    
            // if success and newPatch, it is nice to delete the raw file, and restart at once
            // only main process can load an upgrade patch!
            if (result.isSuccess) { 
                deleteRawPatchFile(new File(result.rawPatchFilePath));
                //默认加载patch以后，app闪退
    // if (checkIfNeedKill(result)) { 
    // android.os.Process.killProcess(android.os.Process.myPid());
    // } else { 
    // TinkerLog.i(TAG, "I have already install the newly patch version!");
    // }
            }
    
        }
    }

## TinkerService ##

/** * 作者：wujie on 2018/11/23 23:36 * 邮箱：705030268@qq.com * 功能：应用程序Tinker更新服务： * 1.检查补丁更新 * 2.从服务器下载patch文件 * 3.使用TinkerManager完成patch文件加载 * 4.patch文件会在下次进程启动时生效 */
    
    public class TinkerService extends Service { 
        private String mPatchFileDir;
        private String mPatchFile;
        private AppVersion mAppVersion;
        private final int CHECK_PATCH_UPDATE = 0x01;
        private final int DOWNLOAD_PATH = 0x02;
        private final String PATH_DOT = ".apk"; //补丁文件后缀
    
        private Handler mHandler = new Handler() { 
            @Override
            public void handleMessage(Message msg) { 
                switch (msg.what) { 
                    case CHECK_PATCH_UPDATE:
                        checkPatchUpdate();
                        break;
                    case DOWNLOAD_PATH:
                        downPatch();
                        break;
                    default:
                        break;
                }
            }
        };
    
        //对外提供启动servcie方法
        public static void runTinkerService(Context context) { 
            try { 
                Intent intent = new Intent(context, TinkerService.class);
                context.startService(intent);
            } catch (Exception e) { 
                e.printStackTrace();
            }
        }
    
        //用来与被启动者通信的接口
        @Override
        public IBinder onBind(Intent intent) { 
            return null;
        }
    
        @Override
        public void onCreate() { 
            super.onCreate();
            init(); //初始化Patch文件目录
        }
    
        @Override
        public int onStartCommand(Intent intent, int flags, int startId) { 
            mHandler.sendEmptyMessage(CHECK_PATCH_UPDATE); //检查是否有补丁
            return START_NOT_STICKY; //START_NOT_STICKY表示service如果被系统回收不重启
        }
    
        private void checkPatchUpdate() { 
            ApiService.getInstance()
                    .getLatestVersion()
                    .subscribe(appVersion -> { 
                        //如果当前不是最新版本，则不去下载补丁包
                        //原则上补丁包只是应付当前版本的紧急bug
                        if(StringUtils.isEmpty(appVersion.patchurl)) { 
                            stopSelf();
                            return;
                        }
                        mAppVersion = appVersion;
                        mHandler.sendEmptyMessage(DOWNLOAD_PATH);
                    }, new ErrorAction() { 
                        @Override
                        public void accept(Throwable throwable) throws Exception { 
                            super.accept(throwable);
                            stopSelf();
                        }
                    });
        }
    
    
        private void downPatch() { 
            //保存的补丁文件命名规则：xxx/1.0.0.1.apk 1.0.0是正常版本 .1是补丁版本号
            if(null != mAppVersion) { 
                mPatchFile = mPatchFileDir.concat(mAppVersion.patch_versionname).concat(PATH_DOT);
                //判断该补丁是否存在，如果已经存在，不需要重复下载
    // File apatchFile = new File(mPatchFileDir);
    // if(apatchFile == null || !apatchFile.exists()) { 
                   //下载补丁
                    Logger.d("正在下载");
                    FileDownloadService.getInstance(new IDownloadListener() { 
                        @Override
                        public void onDownloadSuccess() { 
                            ToastUtils.showShortSafe("文件下载成功");
                            TinkerManager.loadPatch(mPatchFile);
    // TinkerManager.loadPatch(mPatchFile, md5);
                        }
    
                        @Override
                        public void onDownloadFail(Exception exception) { 
                            ToastUtils.showShortSafe("文件下载失败");
                        }
    
                        @Override
                        public void onProgress(int progress) { 
                            Logger.d("文件下载%d", progress);
                        }
                    }).download(mAppVersion.patchurl, mPatchFile);
    // }
            }
        }
    
    
        public void init() { 
            if(Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) { 
                //sd卡已挂载
                mPatchFileDir = getExternalCacheDir().getAbsolutePath() + "/patch/";
                File patchDir = new File(mPatchFileDir);
                try { 
                    if(null == patchDir || !patchDir.exists()) { 
                        patchDir.mkdir();
                    }
                } catch (Exception e) { 
                    e.printStackTrace();
                    stopSelf();
                }
            } else { 
                ToastUtils.showShortSafe("SD卡未挂载");
                stopSelf();
            }
        }
    }

## gradle生成热修复脚本 ##

apply plugin: 'com.android.application'
    apply plugin: 'me.tatarka.retrolambda' //retrolambda表达式
    apply plugin: 'com.jakewharton.butterknife' //butterknife View注解
    
    def javaVersion = JavaVersion.VERSION_1_8
    def bakPath = file("${buildDir}/bakApk/")
    
    android {
        compileSdkVersion 25
        buildToolsVersion "25.0.3"
        defaultConfig {
            applicationId "com.wj.tinkerutils"
            minSdkVersion 18
            targetSdkVersion 25
            versionCode 1
            versionName "1.0"
            testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
            manifestPlaceholders = [
                    UMENG_APPKEY_VALUE: "xxxx",
                    UMENG_CHANNEL_VALUE: "xxxx"
            ]
        }
        signingConfigs {
            release {
                try {
                    storeFile file("test.jks")
                    keyAlias 'xxx'
                    keyPassword 'xxx'
                    storePassword 'xxx'
                } catch (ex) {
                    throw new InvalidUserDataException(ex.toString())
                }
            }
        }
        buildTypes {
            release {
                minifyEnabled true 
                signingConfig signingConfigs.release
                proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
            }
        }
        configurations.all {
            resolutionStrategy.force 'com.google.code.findbugs:jsr305:1.3.9'
        }
        compileOptions {
            sourceCompatibility javaVersion
            targetCompatibility javaVersion
        }
        //多渠道脚本支持
        productFlavors {
            googleplayer {
                manifestPlaceholders = [UMENG_CHANNEL_VALUE: "googleplayer"]
            }
            baidu {
                manifestPlaceholders = [UMENG_CHANNEL_VALUE: "baidu"]
            }
            productFlavors.all { flavor -> flavor.manifestPlaceholders = [UMENG_CHANNEL_VALUE: name]
            }
        }
    }
    
    dependencies {
        compile fileTree(include: ['*.jar'], dir: 'libs')
        androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', {
            exclude group: 'com.android.support', module: 'support-annotations'
        })
        compile 'com.android.support:appcompat-v7:25.+'
        compile 'com.android.support.constraint:constraint-layout:1.0.2'
        testCompile 'junit:junit:4.12'
        compile 'com.android.support:multidex:1.0.1'
        //dex分包
        //butterknife View注解
        compile 'com.jakewharton:butterknife:8.8.1'
        annotationProcessor 'com.jakewharton:butterknife-compiler:8.8.1'
        //tinker
        //optional, help to generate the final application
        //provided参与编译，不参与打包，这样可以减少apk的大小
        provided("com.tencent.tinker:tinker-android-anno:${TINKER_VERSION}") { changing = true }
        //tinker's main Android lib
        compile("com.tencent.tinker:tinker-android-lib:${TINKER_VERSION}") { changing = true }
        compile 'com.umeng.analytics:analytics:latest.integration'
        //添加友盟统计
        compile 'com.blankj:utilcode:1.7.1'
        //android工具类
        compile project(':good_http_utils')
        //防止RxJava内存泄漏
        compile 'com.trello:rxlifecycle:0.8.0'
        compile 'com.trello:rxlifecycle-components:0.8.0'
        compile 'com.tbruyelle.rxpermissions:rxpermissions:0.9.1@aar' //android6+特殊权限申请
    }
    
    def appTinkerVersion = "app-20181201-21-44-37"
    
    /**
     * ext相关配置
     */
    ext {
        tinkerEnabled = true
        // 基础版本apk
        tinkerOldApkPath = "${bakPath}/" + appTinkerVersion
        // 未开启混淆的话mapping可以忽略，如果开启混淆mapping要保持一致。
        tinkerApplyMappingPath = "${bakPath}/" + appTinkerVersion
        // 与基础版本一起生成的R.text文件
        tinkerApplyResourcePath = "${bakPath}/" + appTinkerVersion
        // 只用于构建所有的Build,如果不是,此处可忽略。
        tinkerBuildFlavorDirectory = "${bakPath}/" + appTinkerVersion
    }
    
    def buildWithTinker() {
        return hasProperty("TINKER_ENABLE") ? TINKER_ENABLE : ext.tinkerEnabled
    }
    
    //基础APK的位置
    def getOldApkPath() {
        return hasProperty("OLD_APK") ? OLD_APK : ext.tinkerOldApkPath
    }
    
    // Mapping的位置
    def getApplyMappingPath() {
        return hasProperty("APPLY_MAPPING") ? APPLY_MAPPING : ext.tinkerApplyMappingPath
    }
    
    // ResourceMapping的位置
    def getApplyResourceMappingPath() {
        return hasProperty("APPLY_RESOURCE") ? APPLY_RESOURCE : ext.tinkerApplyResourcePath
    }
    
    // 用来获取TinkerId(当前版本号就是TinkerId)
    def getTinkerIdValue() {
        return android.defaultConfig.versionName
    }
    
    //多渠道
    def getTinkerBuildFlavorDirectory() {
        return ext.tinkerBuildFlavorDirectory
    }
    
    if (buildWithTinker()) {
        //如果启用，加载Tinker插件，插件封装了些tinker脚本
        apply plugin: 'com.tencent.tinker.patch'
        //所有tinker相关参数配置
        tinkerPatch {
            oldApk = getOldApkPath() //基准apk包的路径，必须输入，否则会报错
            /**
             * 如果出现以下的情况，并且ignoreWarning为false，我们将中断编译。
             * 因为这些情况可能会导致编译出来的patch包带来风险：
             * case 1: minSdkVersion小于14，但是dexMode的值为"raw";
             * case 2: 新编译的安装包出现新增的四大组件(Activity, BroadcastReceiver...)；
             * case 3: 定义在dex.loader用于加载补丁的类不在main dex中;
             * case 4:  定义在dex.loader用于加载补丁的类出现修改；
             * case 5: resources.arsc改变，但没有使用applyResourceMapping编译。
             */
            ignoreWarning = false //不忽略tinker的警告，有则中止patch文件的生成
            useSign = true //强制patch文件也需要签名
            tinkerEnable = buildWithTinker() //是否启用tinker
            //编译相关的配置项
            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
            }
            //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"]
                //todo
                loader = ["com.wj.tinkerutils.tinker.MyTinkerApplication"] //指定加载patch文件用到的类
            }
            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。
                 */
                //todo
                configField("patchMessage", "tinker is sample to use")
                configField("platform", "all")
                /**
                 * 配置patch补丁版本
                 */
                configField("patchVersion", "1.0.0_1")
            }
            //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
        /**
         * bak apk and mapping
         */
        android.applicationVariants.all { variant ->
            /**
             * task type, you want to bak
             */
            def taskName = variant.name
            def date = new Date().format("yyyyMMdd-HH-mm-ss")
    
            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.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"
                        }
                    }
                }
            }
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaXlpY2FuZ2dvdV93dWppZQ_size_16_color_FFFFFF_t_70]: /images/20220412/c315ce2a7e704502a07d955558dfa68d.png
[tinker]: /images/20220412/90865495f5074497af9417954bedff91.png