SDK升级到r_16后，混淆程序又出现问题了.找到解决办法.

最新推荐文章于 2021-07-12 14:30:21 发布
最新推荐文章于 2021-07-12 14:30:21 发布
阅读量61 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： 移动开发
原文链接：http://www.cnblogs.com/keis/archive/2011/12/30/2307959.html
本文详细介绍了在Android开发过程中遇到的ProGuard混淆警告问题，包括警告产生的原因、解决方法及具体操作步骤。通过加入特定配置项，成功解决了无法找到引用类的警告，避免了BUILD FAILED的情况。

怎么升级SDK和ADT会遇到这么多的问题，续jar包出现问题后，又到混淆出现问题了.

以下是在网络上找到的解决办法，经验证有效。

        编译与反编译，一对相辅相成的矛盾。反编译有时候会和不光彩的事情联系在一起，以致于编译者常常费劲心思，加大反编译的难度，比如采用混淆代码等方式。ProGuard正是这么一个工具：

The ProGuard tool shrinks, optimizes, and obfuscates your code by removing unused code and renaming classes, fields, and methods with semantically obscure name.

Android SDK整合了ProGuard，并在文档中用了一个章节来描述如何使用它。依照文档来实施，多半没有问题，不过在使用中有时候遇到了一些问题：（就是提示一些包找不到）

 

依照以往的惯例，发生warning，可忽视之，只有看到error，才会小紧张一把。不过这次的warning导致了BUILD FAILED，这回问题大了。

按照提示，在proguard.cfg里，加入-dontskipnonpubliclibraryclasses，再试，还是有问题。

那就到官网找找答案吧，Manual -> Troubleshooting -> “Warning: can’t find referenced class”，找到这么一句话：try your luck with the -ignorewarnings option, or even the -dontwarn option.再对比日志信息，发现：

[proguard] Warning: net.poemcode.Digest: can’t find referenced class org.apache.CastleProvider

打开proguard.cfg，加入-dontwarn net.poemcode.**，在打包一次。'

 

附件是default.properties和proguard.cfg 文件

转载于:https://www.cnblogs.com/keis/archive/2011/12/30/2307959.html

友盟SDK升级（手动集成）
qq_42862581的博客
06-03 2274
友盟SDK升级友盟官方地址：https://developer.umeng.com1，下载SDK jar包2，导入项目中4，申请第三方账号5，需要在工程AndroidManifest.xml清单文件中增加：6，添加权限7，初始化友盟8，混淆设置 在升级之前，把之前项目中手动添加的友盟相关的jar包全部删除。之后在从新添加最新的包。 友盟官方地址：https://developer.umeng.com 1，下载SDK jar包 选择完之后，点击完成，再点击下载。 2，导入项目中 1，把解压之后的文件夹中的
J2ME-Polish2.0RC4 对doja的支持不是很好,建议采用j2mepolish-2.0-Preview.jar
风流浪子的专栏
07-12 1851
J2ME-Polish2.0RC4 对doja的支持不是很好。 建议采用j2mepolish-2.0-Preview.jar。  回复：关于需要指定libraryjars的问题，理解polish原理即可。见build.xml里的binaryLibraries="${polish.home}/import/midp-2.0.jar"Hi Robert ,           Thank yo
android 混淆 去除第三方jar
gongxinifacai的博客
06-10 168
              编译与反编译，一对相辅相成的矛盾。反编译有时候会和不光彩的事情联系在一起，以致于编译者常常费劲心思，加大反编译的难度，比如采用混淆代码等方式。ProGuard正是这么一个工具： The ProGuard tool shrinks, optimizes, and obfuscates your code by removing unused code and ...
解决加入新浪SDK后，无法混淆的问题
11-24 6424
当项目加入sinaSDK后，混淆项目时，虽然已经写了： -dontwarn com.weibo.sdk.android.** 但是仍然无法发布成功，会出现如下错误： Proguard returned with error code 1. See console Note: there were 1 duplicate class definitions. Warning: librar
android 混淆过滤,android studio 代码混淆如何忽略第三方jar包
weixin_29867767的博客
05-25 975
8种机械键盘轴体对比本人程序员，要买一个写代码的键盘，请问红轴和茶轴怎么选？最近在打包混淆时，遇到一个问题，混淆编译都不出错，运行出错，一般遇到这种问题，肯定是在运行的地方有代码被混淆了，经过错误排查，发现是程序中用到第三方的jar包的方法出现问题了，原来android studio混淆打包时把第三方的jar包给混淆了。于是想这个问题很简单，保持jar包不混淆就好，于是直接在app目录下的pro...
Android SDK Manager build-tools升级build-tools_r18.0.1-windows.rar
02-29
3. **移动文件夹**：将解压后的`18.0.1`文件夹复制到`<SDK Path>/build-tools/`目录下。如果已有旧版本的18.0.1，可以覆盖或者保留两个版本以备不时之需。 4. **更新IDE设置**：如果你使用的是Android Studio或其他...
Android_SDK_R22.6.1
02-07
**Android SDK R22.6.1：核心概念与组件** Android SDK（软件开发工具包）是Android应用程序开发者必备的工具集，它包含了构建、测试和调试Android应用所需的所有组件。R22.6.1是SDK的一个特定版本，发布于2013年，...
android-sdk-build-tools22.0.1.rar
04-17
Android SDK Build-Tools 22.0.1是Android开发者必备的工具集，主要用于构建Android应用程序。这个版本的Build-Tools包含了多个用于编译、打包和优化APK的关键组件。以下将详细介绍这些组件及其功能： 1. **AAPT ...
build-tools_r29-rc2-windows.zip
05-28
【标题】"build-tools_r29-rc2-windows.zip" 是一个特定版本的Android开发工具包，用于构建和打包Android应用程序。这个压缩包是专为Windows操作系统设计的，包含了适用于该平台的工具。 【描述】指出，这个压缩包...
can't find referenced method 'boolean equalsIgnoreCase(java.lang.String)'
fonter
08-03 339
今天别人遇到一个奇怪的BUG，抛出的异常如下： can't find referenced method 'boolean equalsIgnoreCase(java.lang.String)' in class java.lang.StringWarning: there were 1 unresolved references to program class members.       ...
java proguard_使用proguard混淆java9代码
weixin_33898154的博客
02-16 1502
序本文主要研究一下如何使用proguard混淆java9代码mavencom.github.wvengenproguard-maven-pluginpackageproguard6.0.1${project.build.finalName}.jar${project.build.finalName}.jar!META-INF/maven/**,!module-info.classtrue${pro...
使用proguard混淆java9代码
weixin_33724046的博客
03-15 1147
序 本文主要研究一下如何使用proguard混淆java9代码 maven &lt;plugin&gt; &lt;groupId&gt;com.github.wvengen&lt;/groupId&gt; &lt;artifactId&gt;proguard-maven-plugin&lt;/artifactId&gt; &lt;executions&gt; ...
Android Proguard 不混淆所有第三方jar（忽略配置设置）
热门推荐
王能的小屋
12-12 2万+
今天给大家分享一个只混淆自己的项目代码而不混淆所有第三方jar的方法（没错，是所有的第三方都不进行混淆，无论来什么第三方，都不需要动混淆配置） 一、为app添加混淆 在app的buildTypes里开启对指定包进行混淆，这里我混淆了release和debug的，并且增加了一个不混淆的类型（注①） buildTypes { release { mini...
android 混淆构建 class not found 错误
Primer5
07-12 786
取消警告： 使用 -dontwarn + 类/包路径取消警告 # SDK代码混淆 -dontwarn com.bytedance.retrofit2.** -dontwarn com.bytedance.JProtect.** -dontwarn com.bytedance.framwork.** -dontwarn com.bytedance.sdk.openadsdk.** -dontwarn ms.bd.c.** -dontwarn com.bytedance.embed_dr.** -dontwar
android代码混淆时，如何防止第三方jar包被混淆导致程序出错
村长
01-26 7130
代码混淆是给其他人破解自己的程序带来更多困难，但混淆不能影响我们程序的正常运行．最近在代码混淆时出现一个问题：就是第三方jar被混淆时出现程序错误，错误主要是说找不到相关的类． 　　　　这个问题也不奇怪，我们要使用的第三方jar包被混淆成我们程序不能认识的代码,结果肯定找不到类．我们要如何解决这个问题呢？ 　　　　解决方案： 1.首先把android工程中project.properties
Android代码混淆
weixin_30765319的博客
09-07 122
这是在工程中的proguard-project.txt中发现的 # To enable ProGuard in your project, edit project.properties# to define the proguard.config property as described in that file.## Add project specific ProGuard rule...
Android代码混淆第三方jar，can't find referenced class的解决
xx0624236的专栏
05-21 1万+
出现can't find referenced class的警告时，可以在proguard.cfg中添加-ignorewarnings来解决。 另外，对于有的第三方jar，可能已经进行过代码混淆了，在这里就要保持，例如百度的地图包jar。保持jar，避免混淆的代码如下： -keep class com.baidu.mapapi.** {*;} 不混淆com.baidu.mapapi包中的所有
11:38:01.885 19493-19787 DecryptUtil com.kotei.overseas.navi I 原始 ZIP 文件已成功删除: /data/user/0/com.kotei.overseas.navi/cache/KVM_Navi_EU_148_2.zip 2025-09-01 11:38:01.885 19493-19787 DecryptUtil com.kotei.overseas.navi I aesDaraPath:/storage/emulated/0/Android/data/com.kotei.overseas.navi/files/overseas/data/mapoffline/sign/KVM_Navi_EU_148_2.zip.enc 2025-09-01 11:38:01.886 19493-19787 DecryptUtil com.kotei.overseas.navi I signDataPtah/storage/emulated/0/Android/data/com.kotei.overseas.navi/files/overseas/data/mapoffline/sign/KVM_Navi_EU_148_2.zip.enc.sig 2025-09-01 11:38:02.566 19493-19493 VRI[MainAc...y]@fe06fc1 com.kotei.overseas.navi I onDisplayChanged oldDisplayState=2 newDisplayState=2 2025-09-01 11:38:06.810 19493-19787 DecryptUtil com.kotei.overseas.navi I base64格式签名数据: g013oFHKCv0K+0I5nwbCToUOch9aIfSNLhgyDzJ30uM5gN8VlS/K3l5gAHtjMv/Lm0269M5vtAdsi/tJ3sPdFSkZrdyfxA2CFaxAZpOMuLe7AJEZfbvRX0+XY88lArYvivdfK/6gTGdGYiTSsFzvzxYvSd/yGmmJOZKP9zmAVySAhyTcAbqenxV4nIfefD9t3R/OSxlKqCJsKZiO800ffXO010s65U64XVqh0Fc+2I0PibzA2LyYJ2q+YObkABe9W2YDgXWq91bzPNtX+nSRV4T6773Mf+i4j2MedPIb7LwFwx5HD3eFUpmp+KY5jYFUO4anW5UemQDwJne/Xurstw== 2025-09-01 11:38:06.817 19493-19787 DecryptUtil com.kotei.overseas.navi I PUBLIC_KEY: OpenSSLRSAPublicKey{modulus=cb4a3563eed96eff8d354083c7e2cc066aacc8f1aca2343a3ed5f9d271c41c9c3ae2532c8e3f56612d15accba7a7a10c43b58294d77d4298fe1a25f8ca292079f1e1c31883911aecdcd9a2a562395ce8d38e31cf26ff2eee4d58ef14deba4266cbce823d618c2631d46e6e81ae1fbf7148eeb9a53e51b560923b07282b029f1ff228ca6a33bcd5f9d5107de7d094bdf4391674d7f0cd5d33e2ed78ee0f969339164b87295ba5251c51c0bab383cd99003e28dcafa4ea12c9f5288e8a08fe9552717c46362eb79a0dfe18333e2bf555699c4c9a65dc39303262d4eaa03f715b623e0bee87091c619de808ae621d2bd4e5f6add6d7556928935291995b7a7a6c45,publicExponent=10001} 2025-09-01 11:38:06.818 19493-19787 DecryptUtil com.kotei.overseas.navi I 创建密钥和IV规格 success! 2025-09-01 11:38:06.819 19493-19787 DecryptUtil com.kotei.overseas.navi I 创建Cipher实例并初始化 success! 2025-09-01 11:38:37.028 19493-19787 DecryptUtil com.kotei.overseas.navi I 解密并写入数据 success! 2025-09-01 11:38:37.835 19493-19787 DecryptUtil com.kotei.overseas.navi I dataVerification success 2025-09-01 11:38:46.831 19493-19506 i.overseas.navi com.kotei.overseas.navi I Background concurrent copying GC freed 570KB AllocSpace bytes, 386(49MB) LOS objects, 13% free, 308MB/356MB, paused 6.418ms,41us total 41.373ms 2025-09-01 11:38:51.451 19493-19493 VRI[MainAc...y]@fe06fc1 com.kotei.overseas.navi I onDisplayChanged oldDisplayState=2 newDisplayState=2 2025-09-01 11:38:55.600 19493-19493 VRI[MainAc...y]@fe06fc1 com.kotei.overseas.navi I onDisplayChanged oldDisplayState=2 newDisplayState=2 2025-09-01 11:38:56.288 19493-19493 VRI[MainAc...y]@fe06fc1 com.kotei.overseas.navi I onDisplayChanged oldDisplayState=2 newDisplayState=2 2025-09-01 11:39:02.605 19493-19493 VRI[MainAc...y]@fe06fc1 com.kotei.overseas.navi I onDisplayChanged oldDisplayState=2 newDisplayState=2 2025-09-01 11:39:03.923 19493-19932 i.overseas.navi com.kotei.overseas.navi W Long monitor contention with owner pool-8-thread-3 (19931) at int java.util.zip.ZipFile$ZipFileInputStream.read(byte[], int, int)(ZipFile.java:1010) waiters=3 in int java.util.zip.ZipFile$ZipFileInputStream.read(byte[], int, int) for 119ms 2025-09-01 11:39:51.253 19493-19493 VRI[MainAc...y]@fe06fc1 com.kotei.overseas.navi I onDisplayChanged oldDisplayState=2 newDisplayState=2 2025-09-01 11:39:54.596 19493-19787 DecryptUtil com.kotei.overseas.navi I inputVerifyDataPath/data/user/0/com.kotei.overseas.navi/cache/KVM_Navi_EU_148_3.zip 2025-09-01 11:39:54.596 19493-19787 DecryptUtil com.kotei.overseas.navi I inputVerifyDataPath[/data/user/0/com.kotei.overseas.navi/cache/KVM_Navi_EU_148_3.zip] -> signPath[/storage/emulated/0/Android/data/com.kotei.overseas.navi/files/overseas/data/mapoffline/sign/] 2025-09-01 11:39:54.686 19493-19533 USBOfflineUpdater com.kotei.overseas.navi I message: 解密验签 KVM_Navi_EU_148_3.zip: 338B/3.0GB progress：51.4 目前跳过了第二个zip包的处理导致进度十分异常：package com.kotei.overseas.navi.update; import static com.kotei.overseas.navi.security.DecryptUtil.dataVerification; import android.content.BroadcastReceiver; import android.content.Context; import android.content.Intent; import android.content.IntentFilter; import android.os.AsyncTask; import android.os.Handler; import android.os.Looper; import android.util.Log; import androidx.annotation.NonNull; import com.here.sdk.core.engine.SDKNativeEngine; import com.here.sdk.maploader.MapDownloader; import com.here.sdk.maploader.MapDownloaderConstructionCallback; import com.kotei.overseas.navi.business.data.MapDataController; import com.kotei.overseas.navi.security.DecryptUtil; import com.kotei.overseas.navi.security.DfCert; import java.io.File; import java.io.IOException; import java.io.UncheckedIOException; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; import java.util.concurrent.atomic.AtomicInteger; import java.util.regex.Pattern; import java.util.stream.Stream; /** * USB离线更新系统 */ public class USBOfflineUpdater { private static final String TAG = "USBOfflineUpdater"; // 状态码定义 /** * 操作成功 */ public static final int SUCCESS = 0; /** * 错误：未检测到USB设备 */ public static final int ERROR_NO_USB = 1; /** * 错误：未找到升级包文件 */ public static final int ERROR_NO_UPDATE_PACKAGE = 2; /** * 错误：电池电量不足（低于安全阈值） */ public static final int ERROR_BATTERY_LOW = 3; /** * 错误：存储空间不足 */ public static final int ERROR_STORAGE_INSUFFICIENT = 4; /** * 错误：系统正在执行其他升级任务 */ public static final int ERROR_UPDATE_IN_PROGRESS = 5; /** * 错误：文件复制失败（检查存储权限或磁盘状态） */ public static final int ERROR_COPY_FAILED = 6; /** * 错误：升级包解压失败（文件可能损坏） */ public static final int ERROR_EXTRACT_FAILED = 7; /** * 错误：用户手动取消操作 */ public static final int ERROR_USER_CANCELED = 8; /** * 错误：未预期的系统异常 */ public static final int ERROR_UNEXPECTED = 9; /** * 错误：升级过程中USB设备被移除 */ public static final int ERROR_USB_REMOVED = 10; /** * 错误：车辆档位未处于停车挡（P档） */ public static final int ERROR_VEHICLE_SHIFTED = 11; /** * 错误：电池电量极低（无法维持升级过程） */ public static final int ERROR_BATTERY_TOO_LOW = 12; /** * 错误：文件校验失败（MD5/SHA256校验不匹配） */ public static final int ERROR_FILE_VERIFY_FAILED = 13; /** * 错误：文件解密或验签失败 */ public static final int ERROR_DECRYPT_OR_SIGN_FAILED = 14; // 更新阶段定义 /** * 空闲状态（未开始升级） */ private static final int PHASE_IDLE = 0; /** * 设备检测阶段（检查USB/存储设备） */ private static final int PHASE_DETECTING = 1; /** * 升级包校验阶段（验证完整性/签名） */ private static final int PHASE_CHECKING = 2; /** * 系统备份阶段（备份当前系统数据） */ private static final int PHASE_BACKUP = 3; /** * 文件复制阶段（写入升级包到临时分区） */ private static final int PHASE_COPYING = 4; /** * 解压阶段（解压升级包内容） */ private static final int PHASE_EXTRACTING = 5; /** * 清理阶段（删除临时文件） */ private static final int PHASE_CLEANUP = 6; /** * 回滚阶段（升级失败时恢复备份） */ private static final int PHASE_ROLLBACK = 7; // 权重分配比例 private static final float BACKUP_WEIGHT = 0.1f; // 备份阶段权重10% private static final float PACKAGE_COPY_WEIGHT = 0.29f; // 升级包拷贝阶段权重29% private static final float PACKAGE_VERIFY_WEIGHT = 0.31f; // 升级包解密验签阶段权重31% private static final float PACKAGE_EXTRACT_WEIGHT = 0.29f; // 升级包解压阶段权重29% private static final float VERIFICATION_WEIGHT = 0.01f; // 校验阶段权重1% // 声明 mProgress 为实例变量（非静态） private float mProgress = 0; // 当前进度值（0~1） private static USBOfflineUpdater instance; private final Context context; private UpdateTask currentTask; private UpdateListener updateListener; private SDKNativeEngine sdkNativeEngine; private MapDataController mapDataController; // 目录配置 private File usbRoot; private File cacheDir; private File storageDir;// private File backupDir; // // 更新控制 public boolean isPaused = false; public boolean isCancelled = false; public final AtomicInteger currentPhase = new AtomicInteger(PHASE_IDLE); // 错误信息 private String lastErrorMessage = ""; // 电量阈值 private static final int MIN_BATTERY_LEVEL = 30; // 最低电量百分比 private static final int MIN_BATTERY_LEVEL_CRITICAL = 15; // 严重低电量 //升级包格式 private static final String FILE_NAME_PATTERN = "^KVM_Navi_EU_" + "(?<version>\\d{1,3})" // 版本号(1-3位数字) + "_" + "(?<serial>\\d{1,2})" // 1-2位数字编号 + "(\\.\\w+)?$"; // 可选的文件扩展名 // 进度计算相关变量（新增） private long totalUpdateSize = 0; // 所有升级包总大小 private long UpdateSize = 0; // 当前升级包大小 private long currentCopiedBytes = 0; // 当前已拷贝字节数 private long currentVerifiedBytes = 0; // 当前已验签字节数 private long currentExtractedBytes = 0; // 当前已解压字节数 private long backupSize = 0; // 备份数据大小 private long storageSize = 0; private long rollBackCopiedBytes = 0; private int currentPackageIndex = 0; // 当前处理的升级包索引 private int totalPackageCount = 0; // 总升级包数量 // 用于跟踪回滚状态 public boolean isRollingBack = false; private long rollbackTotalSize = 0; private long rollbackProcessedSize = 0; //zwx取消逻辑完善对应：P1:备份未完成点击取消-程序死机 private boolean isBackupCompleted = false; // USB监听器 private final BroadcastReceiver usbReceiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { String action = intent.getAction(); if (Intent.ACTION_MEDIA_MOUNTED.equals(action)) { //zwxtest // File usbPath = new File(intent.getData().getPath()); File usbPath = new File("/data/data/com.kotei.overseas.navi/files"); if (usbPath.exists() && usbPath.canRead()) { usbRoot = usbPath; Log.i(TAG, "USB mounted: " + usbRoot.getAbsolutePath()); } } else if (Intent.ACTION_MEDIA_EJECT.equals(action) || Intent.ACTION_MEDIA_UNMOUNTED.equals(action)) { if (currentTask != null && currentPhase.get() > PHASE_CHECKING) { cancelUpdate(ERROR_USB_REMOVED, "USB设备被移除"); } usbRoot = null; Log.e(TAG, "USB removed"); } } }; // // 车辆状态监听器（模拟） private final BroadcastReceiver vehicleReceiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { if ("com.example.ACTION_SHIFT_CHANGE".equals(intent.getAction())) { String shift = intent.getStringExtra("shift"); if (!"P".equals(shift) && currentPhase.get() > PHASE_CHECKING) { // cancelUpdate(ERROR_VEHICLE_SHIFTED, "车辆已退出P挡"); } } } }; // 单例模式 public static synchronized USBOfflineUpdater getInstance(Context context) { if (instance == null) { instance = new USBOfflineUpdater(context); } return instance; } public static synchronized USBOfflineUpdater getInstance() { return instance; } private USBOfflineUpdater(Context context) { this.context = context.getApplicationContext(); // 初始化SDK sdkNativeEngine = SDKNativeEngine.getSharedInstance(); mapDataController = MapDataController.getInstance(); try { DfCert.getInstance().getService(); } catch (Exception e) { Log.e(TAG, "Exception:" + e.toString()); } //zwx 执行顺序？ // 初始化目录（默认值） Log.i(TAG, "zwx:=== 启动目录初始化 ===" ); cacheDir = this.context.getCacheDir(); Log.i(TAG, "初始化cacheDir目录为:" + cacheDir.getAbsolutePath());//ZWX storageDir = new File(sdkNativeEngine.getOptions().persistentMapStoragePath); Log.i(TAG, "初始化storageDir目录为:" + storageDir.getAbsolutePath());//ZWX // ✅ 初始化 backupDir backupDir = new File(cacheDir, "backup"); // ✅ 基于 cacheDir 固定路径 // 注册USB监听器 IntentFilter usbFilter = new IntentFilter(); usbFilter.addAction(Intent.ACTION_MEDIA_MOUNTED); usbFilter.addAction(Intent.ACTION_MEDIA_EJECT); usbFilter.addAction(Intent.ACTION_MEDIA_UNMOUNTED); usbFilter.addDataScheme("file"); context.registerReceiver(usbReceiver, usbFilter); // 注册车辆状态监听器（模拟） IntentFilter vehicleFilter = new IntentFilter("com.example.ACTION_SHIFT_CHANGE"); context.registerReceiver(vehicleReceiver, vehicleFilter); //清除数据存储目录下的预留数据 removeLegacy(); } public void initialization(UpdateListener listener) { // isRollingBack = true; Log.i(TAG, "挂起线程执行初始化" );//ZWX this.updateListener = listener; Thread USBOfflineUpdaterInitialization = new Thread(new Runnable() { @Override public void run() { // 启动时检查恢复 checkRecoveryOnStartup(); } }); USBOfflineUpdaterInitialization.setName("USBOfflineUpdaterInitialization"); USBOfflineUpdaterInitialization.start(); } // 动态设置目录 public void setDirectories(File usbRoot, File cacheDir, File storageDir) { if (usbRoot != null) { this.usbRoot = usbRoot; } if (cacheDir != null) { this.cacheDir = cacheDir; } if (storageDir != null) { this.storageDir = storageDir; } } /** * 检测升级包 * * @return 状态码 (SUCCESS 或错误码) */ public int detectUpdatePackages() { //zwxtest // 1. 检测USB是否插入 File usbPath = new File("/data/data/com.kotei.overseas.navi/files"); if (usbPath.exists() && usbPath.canRead()) { usbRoot = usbPath; Log.i(TAG, "USB mounted: " + usbRoot.getAbsolutePath()); } //zwxtest if (usbRoot == null || !usbRoot.exists() || !usbRoot.isDirectory()) { return ERROR_NO_USB; } File[] tempPackages = usbRoot.listFiles(); // 2. 查找升级包 (命名格式: update_v{版本号}_{日期}.zip) File[] packages = usbRoot.listFiles(file -> file.isFile() && file.getName().matches(FILE_NAME_PATTERN) ); return (packages != null && packages.length > 0) ? SUCCESS : ERROR_NO_UPDATE_PACKAGE; } /** * 环境检测 * * @return 状态码 (SUCCESS 或错误码) */ public int checkEnvironment() { // 1. 检测电量 int batteryLevel = PowerUtils.getBatteryLevel(context); if (batteryLevel < MIN_BATTERY_LEVEL) { return batteryLevel < MIN_BATTERY_LEVEL_CRITICAL ? ERROR_BATTERY_TOO_LOW : ERROR_BATTERY_LOW; } // 2. 检测缓存空间 (需大于15GB) long requiredSpace = 15L * 1024 * 1024 * 1024; // 15GB long availableSpace = StorageUtils.getAvailableSpace(cacheDir); if (availableSpace < requiredSpace) { Log.e(TAG, "缓存空间剩余：【" + availableSpace + "】"); return ERROR_STORAGE_INSUFFICIENT; } return SUCCESS; } /** * 判读是否正在进行离线更新 */ public boolean isOfflineUpdate() { return currentTask != null && !currentTask.isCancelled(); } /** * 用户点击USB更新-点击查看-触发startUpdate-触发startUpdate重载（本方法）-调用UpdateTask */ public void startUpdate(UpdateListener listener) { this.updateListener = listener; int result = checkEnvironment(); if (result != SUCCESS) { notifyListener(result, "环境检测不合格"); return; } if (isRollingBack) { notifyListener(ERROR_UPDATE_IN_PROGRESS, "正在进行数据回滚"); return; } if (isOfflineUpdate()) { notifyListener(ERROR_UPDATE_IN_PROGRESS, "已有更新任务正在进行"); return; } Log.i(TAG, "检测到更新任务触发，开始进行地图更新"); notifyProgress("开始进行更新"); // 计算总工作量（新增） calculateTotalWorkload(); currentTask = new UpdateTask(); currentTask.execute(); } // 计算总工作量（新增） private void calculateTotalWorkload() { totalUpdateSize = 0; File[] packages = getUpdatePackages(); totalPackageCount = packages != null ? packages.length : 0; if (packages != null) { for (File pkg : packages) { totalUpdateSize += pkg.length(); } } // backupSize = estimateBackupSize();//zwx backupSize = FileUtils.getDirectorySize(storageDir); Log.i(TAG, "总工作量计算: 升级包数量=" + totalPackageCount + ", 升级包大小=" + formatSize(totalUpdateSize) + ", 备份大小=" + formatSize(backupSize)); } // 获取更新包（新增） private File[] getUpdatePackages() { if (usbRoot == null) return new File[0]; return usbRoot.listFiles(file -> file.isFile() && file.getName().matches(FILE_NAME_PATTERN) ); } // 格式化文件大小（新增） private String formatSize(long size) { if (size < 1024) return size + "B"; else if (size < 1024 * 1024) return String.format("%.1fKB", size / 1024.0); else if (size < 1024 * 1024 * 1024) return String.format("%.1fMB", size / (1024.0 * 1024)); else return String.format("%.1fGB", size / (1024.0 * 1024 * 1024)); } /** * 暂停更新 */ public void pauseUpdate() { isPaused = true; notifyProgress("更新已暂停"); } /** * 恢复更新 */ public void resumeUpdate() { isPaused = false; notifyProgress("更新已恢复"); } /** * 取消更新 */ public void cancelUpdate() { cancelUpdate(ERROR_USER_CANCELED, "用户取消更新"); // performRollback(backupDir);//zwx } private void cancelUpdate(int errorCode, String message) { isCancelled = true; lastErrorMessage = message; notifyListener(errorCode, message); } // 进度通知 // private void notifyProgress(String message) { // new Handler(Looper.getMainLooper()).post(() -> { // if (updateListener != null) { // // 计算当前总进度（修改） // float progress = calculateOverallProgress(); // updateListener.onProgress(currentPhase.get(), progress, message); // } // }); // } //zwx更改对应：P4： 升级包的解压阶段，进度会跳变，未能成功在UI显示进度 private final Handler uiHandler = new Handler(Looper.getMainLooper()); private void notifyProgress(String message) { uiHandler.post(() -> { if (updateListener != null) { float progress = calculateOverallProgress(); updateListener.onProgress(currentPhase.get(), progress, message); } }); } private float calculateOverallProgress() { // if (isRollingBack) { // // 回滚阶段：直接计算回滚进度 // if (rollbackTotalSize > 0) { // mProgress = 99; // return mProgress; // } // return 0; // } if (totalPackageCount == 0 && currentPhase.get() != PHASE_ROLLBACK) return 0; // 每个包的总权重（拷贝+验签+解压） float packageTotalWeight = PACKAGE_COPY_WEIGHT + PACKAGE_VERIFY_WEIGHT + PACKAGE_EXTRACT_WEIGHT; //再次确认totalPackageCount是否等于0 if (totalPackageCount == 0) { throw new IllegalStateException("totalPackageCount should not be 0 here!"); } // 每个包的阶段权重 float packageCopyWeight = PACKAGE_COPY_WEIGHT / totalPackageCount; float packageVerifyWeight = PACKAGE_VERIFY_WEIGHT / totalPackageCount; float packageExtractWeight = PACKAGE_EXTRACT_WEIGHT / totalPackageCount; switch (currentPhase.get()) { case PHASE_BACKUP: if(backupSize > 0) { mProgress = BACKUP_WEIGHT * (currentCopiedBytes / (float) backupSize); }else{ mProgress = BACKUP_WEIGHT; } if(mProgress > BACKUP_WEIGHT) { mProgress = BACKUP_WEIGHT; } break; case PHASE_COPYING: // 基础：备份 + 已完成包的完整进度 float copyBase = BACKUP_WEIGHT + (packageTotalWeight * currentPackageIndex) / totalPackageCount; // 增量：当前包拷贝进度 float copyProgress = currentCopiedBytes / (float) UpdateSize; mProgress = copyBase + packageCopyWeight * copyProgress; break; case PHASE_CHECKING: // 基础：备份 + 已完成包的完整进度 + 当前包拷贝完成 float verifyBase = BACKUP_WEIGHT + (packageTotalWeight * currentPackageIndex) / totalPackageCount + packageCopyWeight; // 增量：当前包验签进度 float verifyProgress = currentVerifiedBytes / (float) UpdateSize; mProgress = verifyBase + packageVerifyWeight * verifyProgress; break; case PHASE_EXTRACTING: // 修复：添加当前包验签完成 float extractBase = BACKUP_WEIGHT + (packageTotalWeight * currentPackageIndex) / totalPackageCount + packageCopyWeight + packageVerifyWeight; // 添加这行 // 增量：当前包解压进度 float extractProgress = currentExtractedBytes / (float) UpdateSize; mProgress = extractBase + packageExtractWeight * extractProgress; break; case PHASE_DETECTING: mProgress = BACKUP_WEIGHT + packageTotalWeight + VERIFICATION_WEIGHT * (currentVerifiedBytes / (float) totalUpdateSize); break; case PHASE_CLEANUP: // case PHASE_ROLLBACK: // mProgress = 0.99f; // // break; case PHASE_ROLLBACK: // 增量：当前包拷贝进度 mProgress = rollBackCopiedBytes / (float) backupSize; break; } return Math.min(Math.round(mProgress * 10000) / 100.00f, 100.00f); } // 结果通知 private void notifyListener(int resultCode, String message) { new Handler(Looper.getMainLooper()).post(() -> { if (updateListener != null) { updateListener.onResult(resultCode, message); } }); } // 获取当前进度百分比 private int getCurrentProgress() { // 此处可添加子任务进度计算 return (int) mProgress; } // ================== 核心更新逻辑 ================== private class UpdateTask extends AsyncTask<Void, Void, Integer> { // private File backupFile;//zwx-s private File[] updatePackages; @Override protected void onPreExecute() { currentPhase.set(PHASE_DETECTING); isCancelled = false; isPaused = false; currentCopiedBytes = 0; currentExtractedBytes = 0; mProgress = 0; // 重置进度为0 } @Override protected Integer doInBackground(Void... voids) { try { // 阶段1: 备份数据 currentPhase.set(PHASE_BACKUP); notifyProgress("开始备份数据..."); // backupDir = new File(cacheDir, "backup"); Log.i(TAG, "初始化备份目录为:" + backupDir.getAbsolutePath());//ZWX if (backupDir.exists()) { if (!FileUtils.deleteRecursive(backupDir)) { throw new IOException("删除备份文件失败: " + backupDir.getAbsolutePath()); } } if (!backupDir.mkdirs()) { throw new IOException("创建备份目录失败: " + backupDir.getAbsolutePath()); } // 计算实际备份大小 Log.i(TAG, "核对实际需要备份的数据大小"); // backupSize = estimateBackupSize(); backupSize = FileUtils.getDirectorySize(storageDir); Log.i(TAG, "需要备份的数据大小:[" + formatSize(backupSize) + "]"); Log.i(TAG, "storage目录为:" + storageDir.getAbsolutePath());//ZWX if (backupSize > 0) { Log.i(TAG, "开始进行数据备份"); try { // 执行目录复制 if (!singlecopydirectory.copyDirectoryWithProgress(storageDir, backupDir, (copied, total) -> { currentCopiedBytes = copied; notifyProgress("备份中: " + formatSize(copied) + "/" + formatSize(total)); })) { throw new IOException("备份失败: " + storageDir.getAbsolutePath() + " -> " + backupDir.getAbsolutePath()); } notifyProgress("数据备份完成"); } catch (Exception e) { Log.e(TAG, "备份过程中发生错误", e); // 可选：尝试二次备份或记录日志，这里直接抛出错误 return ERROR_COPY_FAILED; } } else { // 无数据需要备份，直接标记完成 Log.i(TAG, "无备份数据，直接进行数据更新"); currentCopiedBytes = 1; backupSize = 1; notifyProgress("无数据需要备份"); } //备份已经完成标志位 isBackupCompleted = true; Log.i(TAG, "开始删除storage"); FileUtils.deleteDirectoryContents(storageDir); // 检查是否被取消（场景1） if (isCancelled) { return ERROR_USER_CANCELED; } //zwx-end // 阶段2: 处理升级包 updatePackages = getUpdatePackages(); Log.i(TAG, "开始处理升级包【拷贝、解密验签、解压】"); for (currentPackageIndex = 0; currentPackageIndex < updatePackages.length; currentPackageIndex++) { if (isCancelled) return ERROR_USER_CANCELED; // 处理暂停状态 while (isPaused) { Thread.sleep(500); } File packageFile = updatePackages[currentPackageIndex]; UpdateSize = updatePackages[currentPackageIndex].length(); String packageName = packageFile.getName(); long packageSize = packageFile.length(); // 备份完成后重置拷贝计数器 currentCopiedBytes = 0; // 阶段3: 拷贝升级包 currentPhase.set(PHASE_COPYING); // File destFile = new File(storageDir, packageName); File destFile = new File(cacheDir, packageName);//zwx修改 // 拷贝时更新进度（修改） boolean copyResult = FileUtils.copyFileWithProgress( packageFile, destFile, (copied, total) -> { currentCopiedBytes = copied; notifyProgress(String.format("拷贝 %s: %s/%s", packageName, formatSize(copied), formatSize(total))); } ); if (!copyResult) { lastErrorMessage = "拷贝失败: " + packageName; return ERROR_COPY_FAILED; } // 阶段4：解密验签 currentPhase.set(PHASE_CHECKING); currentVerifiedBytes = 0; // 重置验签计数器 // 创建进度回调适配器 DecryptUtil.ProgressCallback decryptCallback = new DecryptUtil.ProgressCallback() { @Override public void onProgress(long processed, long total) { // 直接更新验签进度计数器 currentVerifiedBytes = processed; // 触发进度通知 notifyProgress(String.format("解密验签 %s: %s/%s", packageName, formatSize(processed), formatSize(total))); } }; // 执行解密验签（传入回调） if (!dataVerification(destFile.getAbsolutePath(), storageDir.getAbsolutePath(),decryptCallback)) { if (!isCancelled) { return ERROR_DECRYPT_OR_SIGN_FAILED; } } // 确保进度设置为100% currentVerifiedBytes = UpdateSize; // 阶段5: 解压升级包 currentPhase.set(PHASE_EXTRACTING); // 修复：重置解压计数器 currentExtractedBytes = 0; // 重置计数器 notifyProgress("解压升级包: " + packageName); // 解压时更新进度（修改） boolean extractResult = FileUtils.extractZipWithProgress( destFile, storageDir, (extracted, total) -> { currentExtractedBytes = extracted; notifyProgress(String.format("解压 %s: %s/%s", packageName, formatSize(extracted), formatSize(total))); } ); if (!extractResult) { lastErrorMessage = "解压失败: " + packageName; return ERROR_EXTRACT_FAILED; } // 删除已解压的升级包以节省空间 if (!destFile.delete()) { Log.w(TAG, "删除升级包失败: " + destFile.getName()); } // 更新解压进度（完成当前包） currentExtractedBytes += packageSize; } if (!mapDataController.checkInstallationStatus()) { notifyProgress("校验失败"); return ERROR_FILE_VERIFY_FAILED; } else { notifyProgress("校验成功"); } // MapDownloader.fromEngineAsync(sdkNativeEngine, new MapDownloaderConstructionCallback() { // @Override // public void onMapDownloaderConstructedCompleted(@NonNull MapDownloader downloader) { // Log.i(TAG, "数据同步成功"); // } // }); // 阶段5: 清理工作 currentPhase.set(PHASE_CLEANUP); notifyProgress("清理缓存..."); if (backupDir.exists() && !FileUtils.deleteRecursive(backupDir)) { Log.w(TAG, "删除备份文件失败"); } // 最终进度设为100% notifyProgress("更新完成"); return SUCCESS; } catch (InterruptedException e) { // 场景1：备份未完成时被取消 if (!isBackupCompleted &&backupDir != null && backupDir.exists()) { // backupFile.delete(); if (!FileUtils.deleteRecursive(backupDir)) { Log.w(TAG, "删除备份文件失败: " + backupDir.getAbsolutePath()); } } lastErrorMessage = "更新任务被中断"; return ERROR_USER_CANCELED; } catch (Exception e) { lastErrorMessage = "未知错误: " + e.getMessage(); Log.e(TAG, "更新失败", e); return ERROR_UNEXPECTED; } } @Override protected void onPostExecute(Integer resultCode) { if (resultCode == SUCCESS) { notifyListener(SUCCESS, "更新成功,请重启车机"); currentPhase.set(PHASE_IDLE); currentTask = null; } else { // 只有备份完成时才进行回滚（场景2） if (isBackupCompleted && backupDir != null && backupDir.exists()) { // 场景2：进入回滚流程 isRollingBack = true; currentPhase.set(PHASE_ROLLBACK); // 先发送回滚进度通知（99%） notifyProgress("更新失败，正在回滚数据..."); // 保存错误消息，因为回滚完成后还需要使用 final String errorMessage = lastErrorMessage; // 启动回滚线程 new Thread(new Runnable() { @Override public void run() { try { // 执行回滚 performRollback(backupDir); } finally { // 回滚完成后删除备份 // backupFile.delete(); if (backupDir.exists() && !FileUtils.deleteRecursive(backupDir)) { Log.w(TAG, "删除备份文件失败: " + backupDir.getAbsolutePath()); } if (!isCancelled) { // 回滚完成后发送最终结果 notifyListener(resultCode, getErrorMessage(resultCode)); } // 重置状态 currentPhase.set(PHASE_IDLE); currentTask = null; isRollingBack = false; } } }).start(); } else { // 场景1：没有备份文件，直接报告错误 notifyListener(resultCode, lastErrorMessage); currentPhase.set(PHASE_IDLE); currentTask = null; } } } } // ================== 启动时恢复检查 ================== private void checkRecoveryOnStartup() { // File backupFile = findLatestBackupFile(); Log.i(TAG, "=== 启动时初始化检查 ===" ); storageSize = FileUtils.getDirectorySize(storageDir); backupSize = FileUtils.getDirectorySize(backupDir); Log.i(TAG, "检测到备份数据大小为: " + backupSize); Log.i(TAG, "检测到storage数据大小为: " + storageSize); // 存在备份文件说明上次更新中断 if (backupDir != null && backupDir.exists()) { // long fileSize = backupFile.length(); // long fileSize = backupSize; //// long expectedSize = estimateBackupSize(); // long expectedSize = storageSize; // 场景3：备份未完成（文件大小小于预期大小的90%） if (backupSize < storageSize ) { isRollingBack = false; Log.i(TAG, "检测到未完成的备份，删除: " + backupDir.getName()); // backupFile.delete(); if (backupDir.exists() && !FileUtils.deleteRecursive(backupDir)) { Log.w(TAG, "删除备份文件失败: " + backupDir.getAbsolutePath()); } return; }else { // 场景4：备份已完成，启动回滚 Log.i(TAG, "检测到备份数据大小为: " + backupSize); Log.i(TAG, "检测到storage数据大小为: " + storageSize); Log.i(TAG, "检测到完整的备份，开始回滚: " + backupDir.getName()); currentPhase.set(PHASE_ROLLBACK); notifyProgress("检测到未完成更新，正在恢复数据..."); // 执行回滚 performRollback(backupDir); isRollingBack = true; // 删除备份文件 // backupFile.delete(); notifyProgress("数据恢复完成"); } } Log.i(TAG, "=== 初始化检查结束未发现备份 ===" ); isRollingBack = false; // this.updateListener = null;zwx } private void checkStoragePerformance() { long writeSpeed = StorageUtils.measureWriteSpeed(storageDir); Log.d(TAG, "存储写入速度: " + formatSize(writeSpeed) + "/s"); if (writeSpeed < 50 * 1024 * 1024) { // 低于 50MB/s Log.w(TAG, "检测到低速存储设备，还原操作可能较慢"); } } // 新增回滚方法-删除storage-复制备份目录到storage-删除备份目录 private void performRollback(File backupDir) { if (backupDir == null || !backupDir.exists() || !backupDir.isDirectory()) { Log.w(TAG,"error ：备份目录无效或不存在 " ); } currentPhase.set(PHASE_COPYING); try { // 1. 设置回滚进度为99% backupSize = FileUtils.getDirectorySize(backupDir); Log.w(TAG, "开始删除更新目录: " + storageDir.getAbsolutePath()); notifyProgress("开始删除更新目录"); // 2. 删除更新后的数据并且保留storageDir文件夹 FileUtils.deleteDirectoryContents(storageDir); notifyProgress("开始恢复备份目录"); Log.w(TAG, "开始恢复备份目录: " ); try { // 执行目录复制 if (!singlecopydirectory.copyDirectoryWithProgress(backupDir,storageDir, (copied, total) -> { rollBackCopiedBytes = copied; notifyProgress("回滚中: " + formatSize(copied) + "/" + formatSize(total)); })) { throw new IOException("回滚失败: " + storageDir.getAbsolutePath() + " -> " + backupDir.getAbsolutePath()); } notifyProgress("恢复数据完成开始删除备份目录"); //deleteRecursive:删除整个目录 if (backupDir.exists() && !FileUtils.deleteRecursive(backupDir)) { Log.w(TAG, "删除备份文件失败: " + backupDir.getAbsolutePath()); notifyProgress("恢复数据删除失败"); isBackupCompleted = false; } notifyProgress("回滚完成"); isBackupCompleted = false; } catch (Exception e) { Log.e(TAG, "回滚过程中发生错误", e); // 可选：尝试二次备份或记录日志，这里直接抛出错误 notifyProgress("回滚过程中发生错误"); } } catch (Exception e) { Log.e(TAG, "回滚过程中发生错误", e); } } // 释放资源 public void release() { try { context.unregisterReceiver(usbReceiver); context.unregisterReceiver(vehicleReceiver); } catch (Exception e) { Log.w(TAG, "释放资源时出错", e); } } // ================== 接口定义 ================== public interface UpdateListener { void onProgress(int phase, float progress, String message); void onResult(int resultCode, String message); } public interface ProgressCallback { void onProgress(long progress, long total) throws InterruptedException; } public File getUsbRoot() { return usbRoot; } public File getCacheDir() { return cacheDir; } public File getStorageDir() { return storageDir; } public String getErrorMessage(int code) { return switch (code) { case ERROR_NO_USB -> "未检测到USB设备，请检查连接状态或更换接口"; case ERROR_NO_UPDATE_PACKAGE -> "升级包文件缺失，请确认存储路径"; case ERROR_BATTERY_LOW -> "电池电量不足（需≥20%）"; case ERROR_STORAGE_INSUFFICIENT -> "存储空间不足（需预留20gb以上）"; case ERROR_UPDATE_IN_PROGRESS -> "系统正在执行其他升级任务"; case ERROR_COPY_FAILED -> "文件复制失败，请检查存储权限"; case ERROR_EXTRACT_FAILED -> "升级包解压失败（可能文件损坏）"; case ERROR_USER_CANCELED -> "用户已取消升级操作"; case ERROR_UNEXPECTED -> "发生未预期的系统异常"; case ERROR_USB_REMOVED -> "升级过程中USB设备被移除"; case ERROR_VEHICLE_SHIFTED -> "请将车辆档位切换至P档"; case ERROR_BATTERY_TOO_LOW -> "电池电量极低（需≥10%）"; case ERROR_FILE_VERIFY_FAILED -> "文件校验失败（MD5/SHA256不匹配）"; case ERROR_DECRYPT_OR_SIGN_FAILED -> "文件解密/验签失败"; default -> "未知错误导致更新失败"; }; } void removeLegacy() { if (storageDir == null || !storageDir.exists() || !storageDir.isDirectory()) { return; } Pattern pattern = Pattern.compile(FILE_NAME_PATTERN); File[] files = storageDir.listFiles(); if (files == null) return; for (File file : files) { if (file.isFile() && pattern.matcher(file.getName()).matches()) { // 删除匹配的文件 try { Files.deleteIfExists(file.toPath()); } catch (IOException | SecurityException e) { // 处理异常（记录日志等） } } } // 删除sign文件夹（如果存在） Path signDir = Paths.get(storageDir.getAbsolutePath(), "sign"); if (Files.exists(signDir)) { try { // 递归删除整个目录 deleteDirectoryRecursively(signDir); } catch (IOException | SecurityException e) { // 处理异常 } } } private void deleteDirectoryRecursively(Path path) throws IOException { if (Files.isDirectory(path)) { // 使用 try-with-resources 确保 Stream 关闭 try (Stream<Path> children = Files.list(path)) { children.forEach(child -> { try { deleteDirectoryRecursively(child); } catch (IOException e) { // 处理子项删除异常 throw new UncheckedIOException(e); // 转换为 RuntimeException 以便在 Stream 中抛出 } }); } catch (UncheckedIOException e) { // 重新抛出原始 IOException throw e.getCause(); } } // 删除空目录或文件 Files.deleteIfExists(path); } }
最新发布
09-02
从你提供的**日志信息**和**代码逻辑**来看，当前的进度计算存在**两个主要问题**： --- ## 🔥 问题 1：进度跳变（跳过了第二个 ZIP 包） ### 日志分析： ``` 11:39:54.596 I inputVerifyDataPath[/data/user/0/com.kotei.overseas.navi/cache/KVM_Navi_EU_148_3.zip] ... 11:39:54.686 I message: 解密验签 KVM_Navi_EU_148_3.zip: 338B/3.0GB progress：51.4 ``` 你当前处理的是第 **3 个 ZIP 包**（`KVM_Navi_EU_148_3.zip`），但跳过了第 2 个 ZIP 包（`KVM_Navi_EU_148_2.zip`）。 ### 问题定位： 在 `UpdateTask` 中的包处理逻辑如下： ```java for (currentPackageIndex = 0; currentPackageIndex < updatePackages.length; currentPackageIndex++) { ... } ``` 你没有对升级包进行排序，导致系统可能**按文件名顺序错误地处理了 ZIP 包**。例如： - `KVM_Navi_EU_148_1.zip` - `KVM_Navi_EU_148_3.zip` ✅（跳过了 2） - `KVM_Navi_EU_148_2.zip` ❌ 这会导致： - **进度异常跳变** - **某些包未被处理** - **最终数据不完整** --- ## 🔥 问题 2：`currentCopiedBytes` 被多个阶段复用 你当前的进度变量如下： ```java private long currentCopiedBytes = 0; // 当前已拷贝字节数 private long currentVerifiedBytes = 0; // 当前已验签字节数 private long currentExtractedBytes = 0; // 当前已解压字节数 ``` 它们被多个阶段复用： - 备份阶段使用 `currentCopiedBytes` - 升级包拷贝阶段也使用 `currentCopiedBytes` - 回滚阶段也使用 `rollBackCopiedBytes` 这会导致： - **进度混淆** - **计算逻辑错误** - **显示不准确** --- ## ✅ 解决方案 ### ✅ 1. **对升级包进行排序** 你需要在获取升级包后，**按编号排序**，确保按顺序处理： ```java // 修改 getUpdatePackages() private File[] getUpdatePackages() { if (usbRoot == null) return new File[0]; File[] packages = usbRoot.listFiles(file -> file.isFile() && file.getName().matches(FILE_NAME_PATTERN) ); if (packages == null || packages.length == 0) return packages; // 按文件名排序（使用正则提取编号） Arrays.sort(packages, (f1, f2) -> { int num1 = extractNumber(f1.getName()); int num2 = extractNumber(f2.getName()); return Integer.compare(num1, num2); }); return packages; } // 提取文件名中的数字编号 private int extractNumber(String filename) { Pattern pattern = Pattern.compile("_(\\d+)\\.zip"); Matcher matcher = pattern.matcher(filename); if (matcher.find()) { return Integer.parseInt(matcher.group(1)); } return Integer.MAX_VALUE; // 无法识别的排最后 } ``` --- ### ✅ 2. **拆分进度变量** 你应该为每个阶段定义独立变量，避免混淆： ```java private long backupCopiedBytes = 0; // 备份阶段专用 private long updateCopiedBytes = 0; // 升级包拷贝阶段专用 private long verifyProcessedBytes = 0; // 验签阶段专用 private long extractProcessedBytes = 0; // 解压阶段专用 private long rollbackCopiedBytes = 0; // 回滚阶段专用 ``` 然后在 `calculateOverallProgress()` 中分别使用这些变量： #### 修改 `PHASE_COPYING`： ```java float copyProgress = updateCopiedBytes / (float) UpdateSize; ``` #### 修改 `PHASE_CHECKING`： ```java float verifyProgress = verifyProcessedBytes / (float) UpdateSize; ``` #### 修改 `PHASE_EXTRACTING`： ```java float extractProgress = extractProcessedBytes / (float) UpdateSize; ``` --- ### ✅ 3. **修复回滚阶段进度** 目前回滚阶段使用的是： ```java mProgress = rollBackCopiedBytes / (float) backupSize; ``` 这没问题，但建议将回滚阶段也参与总进度计算，避免进度“突然跳到 100%”。 你可以将回滚阶段权重设为 `1%`，并在 `calculateOverallProgress()` 中单独处理： ```java case PHASE_ROLLBACK: mProgress = 0.99f + (rollBackCopiedBytes / (float) backupSize) * 0.01f; break; ``` --- ## ✅ 总结：当前进度逻辑问题 | 问题 | 原因 | 修复方式 | |------|------|----------| | 进度跳变，跳过第二个 ZIP 包 | 升级包未按编号排序 | 使用 `extractNumber` 排序 | | `currentCopiedBytes` 被多个阶段复用 | 变量复用导致进度混乱 | 拆分为 `backupCopiedBytes`、`updateCopiedBytes` 等 | | 回滚阶段进度不参与总进度 | 回滚阶段未分配权重 | 设置回滚阶段为 1%，按比例计算 | --- ##
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值