package com
.kotei
.overseas
.navi
.update;
import static com
.kotei
.overseas
.navi
.security
.DecryptUtil
.dataVerificat
ion;
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
.annotat
ion
.NonNull;
import com
.here
.sdk.core
.engine
.SDKNativeEngine;
import com
.here
.sdk.maploader
.MapDownloader;
import com
.here
.sdk.maploader
.MapDownloaderConstruct
ionCallback;
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.Unchecked
IOException;
import
java.n
io.file
.Files;
import
java.n
io.file
.Path;
import
java.n
io.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 VERIFICAT
ION_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; // 备份目录（直接重命名storageDir）
// 更新控制
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_"
+ "(?<vers
ion>\\d{1,3})" // 版本号(1-3位数字)
+ "_"
+ "(?<serial>\\d{1,2})" // 1-2位数字编号
+ "(\\
.\\w+)?$"; // 可选的文件扩展名
// 进度计算相关变量（新增）
private long totalUpdateSize = 0; // 所有升级包总大小
private long UpdateSize = 0; // 当前升级包大小
private long currentCopied
Bytes = 0; // 当前已拷贝字节数
private long currentVerified
Bytes = 0; // 当前已验签字节数
private long currentExtracted
Bytes = 0; // 当前已解压字节数
private long backupSize = 0; // 备份数据大小
private int currentPackageIndex = 0; // 当前处理的升级包索引
private int totalPackageCount = 0; // 总升级包数量
// 用于跟踪回滚状态
public boolean isRollingBack = false;
private long rollbackTotalSize = 0;
private long rollbackProcessedSize = 0;
// USB监听器
private final BroadcastReceiver usbReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
String act
ion = intent
.getAct
ion();
if (Intent
.ACT
ION_MEDIA_MOUNTED
.equals(act
ion)) {
File usbPath = new File(intent
.getData()
.getPath());
if (usbPath
.exists() && usbPath
.canRead()) {
usbRoot = usbPath;
Log
.i(TAG, "USB mounted
: " + usbRoot
.getAbsolutePath());
}
} else if (Intent
.ACT
ION_MEDIA_EJECT
.equals(act
ion) ||
Intent
.ACT
ION_MEDIA_UNMOUNTED
.equals(act
ion)) {
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
.ACT
ION_SHIFT_CHANGE"
.equals(intent
.getAct
ion())) {
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
.getApplicat
ionContext();
// 初始化
SDK
sdkNativeEngine =
SDKNativeEngine
.getSharedInstance();
mapDataController = MapDataController
.getInstance();
try {
DfCert
.getInstance()
.getService();
} catch (Except
ion e) {
Log
.e(TAG, "Except
ion
:" + e
.toString());
}
// 初始化目录（默认值）
cacheDir = this
.context
.getCacheDir();
storageDir = new File(
sdkNativeEngine
.getOpt
ions()
.persistentMapStoragePath);
// 注册USB监听器
IntentFilter usbFilter = new IntentFilter();
usbFilter
.addAct
ion(Intent
.ACT
ION_MEDIA_MOUNTED);
usbFilter
.addAct
ion(Intent
.ACT
ION_MEDIA_EJECT);
usbFilter
.addAct
ion(Intent
.ACT
ION_MEDIA_UNMOUNTED);
usbFilter
.addDataScheme("file");
context
.registerReceiver(usbReceiver, usbFilter);
// 注册车辆状态监听器（模拟）
IntentFilter vehicleFilter = new IntentFilter("com
.example
.ACT
ION_SHIFT_CHANGE");
context
.registerReceiver(vehicleReceiver, vehicleFilter);
//清除数据存储目录下的预留数据
removeLegacy();
}
public void initializat
ion(UpdateListener listener) {
isRollingBack = true;
this
.updateListener = listener;
Thread USBOfflineUpdaterInitializat
ion = new Thread(new Runnable() {
@Override
public void run() {
// 启动时检查恢复
checkRecoveryOnStartup();
}
});
USBOfflineUpdaterInitializat
ion
.setName("USBOfflineUpdaterInitializat
ion");
USBOfflineUpdaterInitializat
ion
.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() {
// 1
. 检测USB是否插入
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();
}
/**
* 开始更新
*/
public void startUpdate(UpdateListener listener) {
int result = checkEnvironment();
if (result != SUCCESS) {
notifyListener(result, "环境检测不合格");
return;
}
if (isOfflineUpdate()) {
notifyListener(ERROR_UPDATE_IN_PROGRESS, "已有更新任务正在进行");
return;
}
if (isRollingBack) {
notifyListener(ERROR_UPDATE_IN_PROGRESS, "正在进行数据回滚");
return;
}
Log
.i(TAG, "检测到更新任务触发，开始进行地图更新");
notifyProgress("开始进行更新");
// 计算总工作量（新增）
calculateTotalWorkload();
this
.updateListener = listener;
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();
Log
.i(TAG, "总工作量计算
: 升级包数量=" + totalPackageCount +
", 升级包大小=" + formatSize(totalUpdateSize) +
", 备份大小=" + formatSize(backupSize));
}
// 估算备份大小方法（避免返回0导致除0错误）
private long estimateBackupSize() {
long storageSize = FileUtils
.getDirectorySize(storageDir);
long size = (long) (storageSize * 1
.2);
return size > 0 ? size
: 1; // 确保不为0
}
// 获取更新包（新增）
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, "用户取消更新");
}
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);
}
});
}
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 IllegalStateExcept
ion("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 * (currentCopied
Bytes / (float) backupSize);
} else {
mProgress = BACKUP_WEIGHT;
}
if (mProgress > BACKUP_WEIGHT) {
mProgress = BACKUP_WEIGHT;
}
break;
case PHASE_CHECKING
:
// 基础：备份 + 已完成包的完整进度 + 当前包拷贝完成
float verifyBase = BACKUP_WEIGHT +
(packageTotalWeight * currentPackageIndex) / totalPackageCount +
packageCopyWeight;
// 增量：当前包验签进度
float verifyProgress = currentVerified
Bytes / (float) UpdateSize;
mProgress = verifyBase + packageVerifyWeight * verifyProgress;
break;
case PHASE_EXTRACTING
:
// 修复：添加当前包验签完成
float extractBase = BACKUP_WEIGHT +
(packageTotalWeight * currentPackageIndex) / totalPackageCount +
packageCopyWeight +
packageVerifyWeight; // 添加这行
// 增量：当前包解压进度
float extractProgress = currentExtracted
Bytes / (float) UpdateSize;
mProgress = extractBase + packageExtractWeight * extractProgress;
break;
case PHASE_DETECTING
:
mProgress = BACKUP_WEIGHT + packageTotalWeight +
VERIFICAT
ION_WEIGHT * (currentVerified
Bytes / (float) totalUpdateSize);
break;
case PHASE_CLEANUP
:
case PHASE_ROLLBACK
:
mProgress = 0
.99f;
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;
// private File[] updatePackages;
private File backupDir; // 替换 backupFile 为 backupDir
private File[] updatePackages;
@Override
protected void onPreExecute() {
currentPhase
.set(PHASE_DETECTING);
isCancelled = false;
isPaused = false;
currentCopied
Bytes = 0;
currentExtracted
Bytes = 0;
mProgress = 0; // 重置进度为0
}
@Override
protected Integer doInBackground(Void
... voids) {
try {
//---------- 新备份阶段（目录重命名方案）------------------
currentPhase
.set(PHASE_BACKUP);
notifyProgress("开始备份数据
...");
// 1
. 定义备份目录（与原storageDir同级）
backupDir = new File(storageDir
.getParent(), storageDir
.getName() + "_backup");
// 2
. 删除旧备份目录（如果存在）
if (backupDir
.exists()) {
if (!FileUtils
.deleteRecursive(backupDir)) {
throw new
IOException("删除旧备份目录失败
: " + backupDir
.getAbsolutePath());
}
}
// 3
. 检查原目录是否存在
if (!storageDir
.exists()) {
throw new
IOException("原数据目录不存在
: " + storageDir
.getAbsolutePath());
}
// 4
. 计算实际备份数据量（可选：用于进度显示兼容性）
Log
.i(TAG, "核对实际需要备份的数据大小");
backupSize = estimateBackupSize(); // 保留用于日志统计
Log
.i(TAG, "需要备份的数据大小
:[" + formatSize(backupSize) + "]");
// 5
. 执行目录重命名（原子操作）
try {
// 5
.1 检查目录是否被占用（可选增强）
// 5
. 执行目录重命名（原子操作）
// 5
. 执行目录复制（备份）
// 5
. 执行目录复制（备份，带进度回调）
if (!FileUtilszwx
.copyDirectoryWithProgress(storageDir, backupDir, (copied, total) -> {
currentCopied
Bytes = copied;
notifyProgress("备份中
: " + formatSize(copied) + "/" + formatSize(total));
})) {
throw new
IOException("备份失败
: " + storageDir
.getAbsolutePath() + " -> " + backupDir
.getAbsolutePath());
}
// 5
.4 通知进度完成
currentCopied
Bytes = 1; // 保持参数兼容
backupSize = 1; // 保持参数兼容
notifyProgress("数据备份完成");
} catch (Except
ion e) {
Log
.e(TAG, "备份过程中发生错误", e);
// 可选：尝试二次备份（如目录复制）
}
// 6
. 特殊情况处理
if (backupSize == 0) {
Log
.i(TAG, "无备份数据，直接进行数据更新");
notifyProgress("无数据需要备份");
}
// 检查是否被取消（场景1）
if (isCancelled) {
return ERROR_USER_CANCELED;
}
// 阶段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();
// 备份完成后重置拷贝计数器
currentCopied
Bytes = 0;
// 阶段3
: 拷贝升级包
currentPhase
.set(PHASE_COPYING);
File destFile = new File(storageDir, packageName);
// 拷贝时更新进度（修改）
boolean copyResult = FileUtils
.copyFileWithProgress(
packageFile,
destFile,
(copied, total) -> {
currentCopied
Bytes = 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);
currentVerified
Bytes = 0; // 重置验签计数器
// 创建进度回调适配器
DecryptUtil
.ProgressCallback decryptCallback = new DecryptUtil
.ProgressCallback() {
@Override
public void onProgress(long processed, long total) {
// 直接更新验签进度计数器
currentVerified
Bytes = processed;
// 触发进度通知
notifyProgress(String
.format("解密验签 %s
: %s/%s",
packageName,
formatSize(processed),
formatSize(total)));
}
};
// 执行解密验签（传入回调）
if (!dataVerificat
ion(destFile
.getAbsolutePath(), decryptCallback)) {
if (!isCancelled) {
return ERROR_DECRYPT_OR_SIGN_FAILED;
}
}
// 确保进度设置为100%
currentVerified
Bytes = UpdateSize;
// 阶段5
: 解压升级包
currentPhase
.set(PHASE_EXTRACTING);
// 修复：重置解压计数器
currentExtracted
Bytes = 0; // 重置计数器
notifyProgress("解压升级包
: " + packageName);
// 解压时更新进度（修改）
boolean extractResult = FileUtils
.extractZipWithProgress(
destFile,
storageDir,
(extracted, total) -> {
currentExtracted
Bytes = 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());
}
// 更新解压进度（完成当前包）
currentExtracted
Bytes += packageSize;
}
if (!mapDataController
.checkInstallat
ionStatus()) {
notifyProgress("校验失败");
return ERROR_FILE_VERIFY_FAILED;
} else {
notifyProgress("校验成功");
}
MapDownloader
.fromEngineAsync(
sdkNativeEngine, new MapDownloaderConstruct
ionCallback() {
@Override
public void onMapDownloaderConstructedCompleted(@NonNull MapDownloader downloader) {
Log
.i(TAG, "数据同步成功");
}
});
// 阶段5
: 清理工作（不再删除备份目录）
currentPhase
.set(PHASE_CLEANUP);
notifyProgress("清理缓存
...");
// 新增：删除临时文件（可选）
File[] tempFiles = storageDir
.listFiles((dir, name) -> name
.endsWith("
.tmp"));
if (tempFiles != null) {
for (File tempFile
: tempFiles) {
if (!tempFile
.delete()) {
Log
.w(TAG, "删除临时文件失败
: " + tempFile
.getAbsolutePath());
}
}
}
// 最终进度设为100%
notifyProgress("更新完成");
return SUCCESS;
} catch (InterruptedExcept
ion e) {
// 场景1：备份未完成时被取消（无备份目录，无需处理）
lastErrorMessage = "更新任务被中断";
return ERROR_USER_CANCELED;
} catch (Except
ion e) {
lastErrorMessage = "未知错误
: " + e
.getMessage();
Log
.e(TAG, "更新失败", e);
return ERROR_UNEXPECTED;
}
}
@Override
protected void onPostExecute(Integer resultCode) {
if (resultCode == SUCCESS) {
//
... 成功处理
...
} else {
// 使用 backupDir 而不是 backupFile
if (this
.backupDir != null && this
.backupDir
.exists()) {
isRollingBack = true;
currentPhase
.set(PHASE_ROLLBACK);
notifyProgress("更新失败，正在回滚数据
...");
final File rollbackDir = this
.backupDir; // 保留引用
new Thread(() -> {
try {
performRollback(rollbackDir); // 传递目录
} finally {
if (rollbackDir
.exists() && !FileUtils
.deleteRecursive(rollbackDir)) {
Log
.w(TAG, "删除备份目录失败
: " + rollbackDir
.getAbsolutePath());
}
if (!isCancelled) {
notifyListener(resultCode, getErrorMessage(resultCode));
}
currentPhase
.set(PHASE_IDLE);
currentTask = null;
isRollingBack = false;
}
})
.start();
} else {
notifyListener(resultCode, lastErrorMessage);
currentPhase
.set(PHASE_IDLE);
currentTask = null;
}
}
}
}
// ================== 启动时恢复检查 ==================
private void checkRecoveryOnStartup() {
File backupDir = findLatestBackupFile(); // 使用新方法
if (backupDir != null && backupDir
.exists()) {
long dirSize = FileUtils
.getDirectorySize(backupDir); // 使用目录大小
long expectedSize = estimateBackupSize();
if (dirSize < expectedSize * 0
.9) {
isRollingBack = true;
Log
.i(TAG, "检测到不完整的备份，删除
: " + backupDir
.getName());
if (!FileUtils
.deleteRecursive(backupDir)) {
Log
.w(TAG, "删除备份目录失败
: " + backupDir
.getAbsolutePath());
}
return;
} else {
Log
.i(TAG, "检测到完整备份，开始回滚
: " + backupDir
.getName());
currentPhase
.set(PHASE_ROLLBACK);
notifyProgress("检测到未完成更新，正在恢复数据
...");
performRollback(backupDir); // 直接传递目录
if (!FileUtils
.deleteRecursive(backupDir)) {
Log
.w(TAG, "删除备份目录失败
: " + backupDir
.getAbsolutePath());
}
notifyProgress("数据恢复完成");
}
}
isRollingBack = false;
this
.updateListener = null;
}
private void checkStoragePerformance() {
long writeSpeed = StorageUtils
.measureWriteSpeed(storageDir);
Log
.d(TAG, "存储写入速度
: " + formatSize(writeSpeed) + "/s");
if (writeSpeed < 50 * 1024 * 1024) { // 低于 50MB/s
Log
.w(TAG, "检测到低速存储设备，还原操作可能较慢");
}
}
// 新增回滚方法
// private void performRollback(File backupFile) {
// try {
// // 1
. 设置回滚进度为99%
// rollbackProcessedSize = backupFile
.length() * 99 / 100;
// notifyProgress("开始恢复备份
...");
//
// // 2
. 删除更新后的数据
// FileUtils
.deleteRecursive(storageDir);
// if (!storageDir
.mkdirs()) {
// Log
.w(TAG, "创建存储目录失败");
// }
//
// // 3
. 恢复备份
// rollbackTotalSize = backupFile
.length();
// rollbackProcessedSize = 0;
//
// boolean restoreSuccess = FileUtils
.extractZipWithProgress(
// backupFile,
// storageDir,
// (extracted, total) -> {
// rollbackProcessedSize = extracted;
// notifyProgress(String
.format("恢复备份 %s
: %s/%s",
// backupFile
.getName(),
// formatSize(extracted),
// formatSize(total)));
// }
// );
//
// if (!restoreSuccess) {
// Log
.e(TAG, "备份恢复失败");
// }
// } catch (Except
ion e) {
// Log
.e(TAG, "回滚过程中发生错误", e);
// }
// }
private void performRollback(File backupDir) {
try {
// 1
. 删除当前目录（如果存在）
if (storageDir
.exists()) {
FileUtils
.deleteRecursive(storageDir);
}
// 2
. 创建目标目录
if (!storageDir
.mkdirs()) {
throw new
IOException("无法创建目标目录");
}
// 3
. 复制备份目录到原位置
if (!FileUtilszwx
.copyDirectoryWithProgress(backupDir, storageDir, (copied, total) -> {
notifyProgress("恢复备份
: " + formatSize(copied) + "/" + formatSize(total));
})) {
throw new
IOException("数据恢复失败");
}
} catch (Except
ion e) {
Log
.e(TAG, "回滚过程中发生错误", e);
}
}
private File findLatestBackupFile() {
// 查找备份目录（原目录名 + "_backup"）
File candidateDir = new File(storageDir
.getParent(), storageDir
.getName() + "_backup");
// 检查目录是否存在且有效
if (candidateDir
.exists() && candidateDir
.isDirectory()) {
return candidateDir;
}
return null;
}
// 释放资源
public void release() {
try {
context
.unregisterReceiver(usbReceiver);
context
.unregisterReceiver(vehicleReceiver);
} catch (Except
ion 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 InterruptedExcept
ion;
}
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 -> "存储空间不足（需预留500MB以上）";
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 | SecurityExcept
ion e) {
// 处理
异常（记录日志等）
}
}
}
// 删除sign文件夹（如果存在）
Path signDir = Paths
.get(storageDir
.getAbsolutePath(), "sign");
if (Files
.exists(signDir)) {
try {
// 递归删除整个目录
deleteDirectoryRecursively(signDir);
} catch (
IOException | SecurityExcept
ion 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 Unchecked
IOException(e); // 转换为 RuntimeExcept
ion 以便在 Stream 中抛出
}
});
} catch (Unchecked
IOException e) {
// 重新抛出原始
IOException
throw e
.getCause();
}
}
// 删除空目录或文件
Files
.deleteIfExists(path);
}
}
目前完成备份之后，是否会删除storagedir。我期望是删除的
本文针对在接入SDK过程中遇到的ADB连接异常问题进行了详细说明，并提供了包括重启设备、重置ADB服务及杀死相关进程等有效解决方案。
扫一扫
1514
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
