025-09-01 17
:44
:48
.561 7064-7064 VRI[MainAc
...y]@44606a7 com
.kotei
.overseas
.navi I ViewPostIme pointer 1
2025-09-01 17
:44
:48
.592 7064-7064 USBOfflineUpdater com
.kotei
.overseas
.navi I 触发取消按钮
2025-09-01 17
:44
:48
.636 7064-7114 USBOfflineUpdater com
.kotei
.overseas
.navi I resultCode
: 8 message：用户取消更新
2025-09-01 17
:44
:48
.637 7064-7114 USBOfflineUpdater com
.kotei
.overseas
.navi I resultCode
: 8 message：用户取消更新
2025-09-01 17
:44
:48
.965 1360-7895 WindowManager system_server V Relayout Window{7b6553a u0 com
.kotei
.overseas
.navi/com
.kotei
.overseas
.navi
.base
.MainActivity}
: viewV
isibility=0 req=1920x1200 ty=1 d0
2025-09-01 17
:44
:48
.966 7064-7064 BLASTBufferQueue_
Java com
.kotei
.overseas
.navi I update, w= 1920 h= 1200 m
Name = VRI[MainActivity]@44606a7 mNativeObject= 0xb400007ba48a3e00 sc
.mNativeObject= 0xb400007b45297940 format= -3 caller= android
.view
.ViewRootImpl
.updateBlastSurfaceIfNeeded
:3386 android
.view
.ViewRootImpl
.relayoutWindow
:11361 android
.view
.ViewRootImpl
.performTraversals
:4544 android
.view
.ViewRootImpl
.doTraversal
:3708 android
.view
.ViewRootImpl$TraversalRunnable
.run
:12542 android
.view
.Choreographer$CallbackRecord
.run
:1751
2025-09-01 17
:44
:48
.966 7064-7064 VRI[MainAc
...y]@44606a7 com
.kotei
.overseas
.navi I Relayout returned
: old=
(0,0,1920,1200
) new=
(0,0,1920,1200
) relayoutAsync=true req=
(1920,1200
)0 dur=2 res=0x0 s={true 0xb400007b452aa000} ch=false seqId=0
2025-09-01 17
:44
:48
.968 7064-7064 VRI[MainAc
...y]@44606a7 com
.kotei
.overseas
.navi I reg
isterCallbackForPendingTransactions
2025-09-01 17
:44
:49
.018 7064-7249 VRI[MainAc
...y]@44606a7 com
.kotei
.overseas
.navi I mWNT
: t=0xb400007b45163800 mBlastBufferQueue=0xb400007ba48a3e00 fn= 287 HdrRenderState mRenderHdrSdrRatio=1
.0 caller= android
.view
.ViewRootImpl$9
.onFrameDraw
:6276 android
.view
.ViewRootImpl$3
.onFrameDraw
:2440 android
.view
.ThreadedRenderer$1
.onFrameDraw
:761
2025-09-01 17
:44
:49
.040 7064-7073 i
.overseas
.navi com
.kotei
.overseas
.navi I Background young concurrent copying GC freed 13MB AllocSpace
bytes, 195
(35MB
) LOS objects, 13% free, 310MB/358MB, paused 7
.854ms,31us total 55
.152ms
2025-09-01 17
:44
:49
.995 7064-7654 USBOfflineUpdater com
.kotei
.overseas
.navi E 回滚过程中发生错误
java.io
.IOException
: 恢复备份失败
at com
.kotei
.overseas
.navi
.update
.USBOfflineUpdater
.performRollback
(USBOfflineUpdater
.java:1006
)
at com
.kotei
.overseas
.navi
.update
.USBOfflineUpdater
.lambda$handleFailure$4
(USBOfflineUpdater
.java:948
)
at com
.kotei
.overseas
.navi
.update
.USBOfflineUpdater
.$r8$lambda$4A3kBcDZRqXtj4NYCAXzEAyH3F8
(Unknown Source
:0
)
at com
.kotei
.overseas
.navi
.update
.USBOfflineUpdater$$ExternalSyntheticLambda2
.run
(D8$$SyntheticClass
:0
)
at
java.lang.Thread
.run
(Thread
.java:1012
)
2025-09-01 17
:44
:51
.562 7064-7064 VRI[MainAc
...y]@44606a7 com
.kotei
.overseas
.navi I call setFrameRateCategory for touch hint category=no preference, reason=boost timeout, vri=VRI[MainActivity]@44606a7
2025-09-01 17
:44
:52
.837 7064-7064 VRI[MainAc
...y]@44606a7 com
.kotei
.overseas
.navi I onD
isplayChanged oldD
isplayState=2 newD
isplayState=2
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 UpdateL
istener updateL
istener;
private SDKNativeEngine sdkNativeEngine;
private MapDataController mapDataController;
// 目录配置
private
File usbRoot;
private
File cacheDir;
private
File storageDir;//
private
File backupDir; //
private
File backupAlreadyDir;
// 更新控制
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 currentCopied
Bytes = 0; // 当前已拷贝字节数
private
long currentVerified
Bytes = 0; // 当前已验签字节数
private
long currentExtracted
Bytes = 0; // 当前已解压字节数
private
long backupSize = 0; // 备份数据大小
private
long storageSize = 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 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
.ex
ists
() && 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
) {
th
is.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 = th
is.context
.getCacheDir
();
storageDir = new
File(sdkNativeEngine
.getOptions
().pers
istentMapStoragePath
);
// ✅ 初始化 backupDir
backupDir = new
File(cacheDir, "backup"
); // ✅ 基于 cacheDir 固定路径
backupAlreadyDir = new
File(cacheDir, "backupAlready"
);
// 注册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
.reg
isterReceiver
(usbReceiver, usbFilter
);
// 注册车辆状态监听器（模拟）
IntentFilter vehicleFilter = new IntentFilter
("com
.example
.ACTION_SHIFT_CHANGE"
);
context
.reg
isterReceiver
(vehicleReceiver, vehicleFilter
);
//清除数据存储目录下的预留数据
removeLegacy
();
}
public void initialization
(UpdateL
istener l
istener
) {
isRollingBack = false;
th
is.updateL
istener = l
istener;
Thread USBOfflineUpdaterInitialization = new Thread
(new Runnable
() {
@Override
public void run
() {
// 启动时检查恢复
checkRecoveryOnStartup
();
}
}
);
USBOfflineUpdaterInitialization
.set
Name("USBOfflineUpdaterInitialization"
);
USBOfflineUpdaterInitialization
.start
();
}
// 动态设置目录
public void setDirectories
(File usbRoot,
File cacheDir,
File storageDir
) {
if
(usbRoot != null
) {
th
is.usbRoot = usbRoot;
}
if
(cacheDir != null
) {
th
is.cacheDir = cacheDir;
}
if
(storageDir != null
) {
th
is.storageDir = storageDir;
}
}
/**
* 检测升级包
*
* @return 状态码
(SUCCESS 或错误码
)
*/
public int detectUpdatePackages
() {
//zwxtest
// 1
. 检测USB是否插入
File usbPath = new
File("/data/data/com
.kotei
.overseas
.navi/
files"
);
if
(usbPath
.ex
ists
() && usbPath
.canRead
()) {
usbRoot = usbPath;
Log
.i
(TAG, "USB mounted
: " + usbRoot
.getAbsolutePath
());
}
//zwxtest
if
(usbRoot == null || !usbRoot
.ex
ists
() || !usbRoot
.isDirectory
()) {
return ERROR_NO_USB;
}
File[] tempPackages = usbRoot
.l
ist
Files
();
// 2
. 查找升级包
(命名格式
: update_v{版本号}_{日期}
.zip
)
File[] packages = usbRoot
.l
ist
Files
(file ->
file.isFile() &&
file.get
Name().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
(UpdateL
istener l
istener
) {
th
is.updateL
istener = l
istener;
int result = checkEnvironment
();
if
(result != SUCCESS
) {
notifyL
istener
(result, "环境检测不合格"
);
return;
}
if
(isRollingBack
) {
notifyL
istener
(ERROR_UPDATE_IN_PROGRESS, "正在进行数据回滚"
);
return;
}
if
(isOfflineUpdate
()) {
notifyL
istener
(ERROR_UPDATE_IN_PROGRESS, "已有更新任务正在进行"
);
return;
}
Log
.i
(TAG, "检测到更新任务触发，开始进行地图更新"
);
// 计算总工作量（新增）
calculateTotalWorkload
();//p3-2
notifyProgress
("开始进行更新"
);
th
is.updateL
istener = l
istener;//zwx-恢复
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
));
}
// // 估算备份大小方法（避免返回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
.l
ist
Files
(file ->
file.isFile() &&
file.get
Name().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;
// notifyL
istener
(errorCode, message
);
// }
public void cancelUpdate
(int errorCode, String message
) {
Log
.i
(TAG,"触发取消按钮"
);
isCancelled = true;
lastErrorMessage = message;
//zwx-focus-p3-回滚触发了计算总进度
if
(currentTask != null
) {
currentTask
.cancel
(true
); // 请求中断线程
}
//
notifyL
istener
(errorCode, message
);
handleFailure
(ERROR_USER_CANCELED
);//p4-3
}
// 进度通知
// private void notifyProgress
(String message
) {
// new Handler
(Looper
.getMainLooper
()).post
(() -> {
// if
(updateL
istener != null
) {
// // 计算当前总进度（修改）
// float progress = calculateOverallProgress
();
// updateL
istener
.onProgress
(currentPhase
.get
(), progress, message
);
// }
// }
);
// }
//p3-4-回滚使用自定义进度计算
private void notifyProgress
(String message
) {
new Handler
(Looper
.getMainLooper
()).post
(() -> {
if
(updateL
istener != null
) {
float progress;
if
(isRollingBack
) {
progress =
(float
) (rollbackProcessedSize *
100) / rollbackTotalSize;
} else {
progress = calculateOverallProgress
();
}
updateL
istener
.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
) {
// throw new IllegalStateException
("totalPackageCount should not be 0 here!"
);
// }//p3-3
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 *
(currentCopied
Bytes /
(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 = currentCopied
Bytes /
(float
) UpdateSize;
mProgress = copyBase + packageCopyWeight * copyProgress;
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 +
VERIFICATION_WEIGHT *
(currentVerified
Bytes /
(float
) totalUpdateSize
);
break;
case PHASE_CLEANUP
:
// case PHASE_ROLLBACK
:
// mProgress = 0
.99f;
// p3-5 break;
}
return Math
.min
(Math
.round
(mProgress *
10000
) /
100.00f,
100.00f
);
}
// 结果通知
private void notifyL
istener
(int resultCode, String message
) {
new Handler
(Looper
.getMainLooper
()).post
(() -> {
if
(updateL
istener != null
) {
updateL
istener
.onResult
(resultCode, message
);
}
}
);
}
// 获取当前进度百分比
private int getCurrentProgress
() {
// 此处可添加子任务进度计算
return
(int
) mProgress;
}
// ================== 核心更新逻辑 ==================
private class UpdateTask extends AsyncTask<Void, Void, Integer> {
// private
File backup
File;//zwx-s
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 {
// 阶段1
: 备份数据
currentPhase
.set
(PHASE_BACKUP
);
notifyProgress
("开始备份数据
..."
);
backupDir = new
File(cacheDir, "backup"
);
Log
.i
(TAG, "初始化备份目录为
:" + backupDir
.getAbsolutePath
());//ZWX
if
(backupDir
.ex
ists
()) {
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
) -> {
currentCopied
Bytes = copied;
notifyProgress
("备份中
: " + formatSize
(copied
) + "/" + formatSize
(total
));
}
)) {
throw new IOException
("备份失败
: " + storageDir
.getAbsolutePath
() + " -> " + backupDir
.getAbsolutePath
());
}
notifyProgress
("数据备份完成"
);//P4
if
(!backupDir
.re
nameTo
(backupAlreadyDir
)) {
throw new IOException
("重命名备份目录失败
: " + backupDir
.getAbsolutePath
() + " -> " + backupAlreadyDir
.getAbsolutePath
());
}
Log
.i
(TAG, "重命名备份目录成功"
);
} catch
(Exception e
) {
Log
.e
(TAG, "备份过程中发生错误", e
);
// 可选：尝试二次备份或记录日志，这里直接抛出错误
return ERROR_COPY_FAILED;
}
} else {
// 无数据需要备份，直接标记完成
Log
.i
(TAG, "无备份数据，直接进行数据更新"
);
currentCopied
Bytes = 1;
backupSize = 1;
notifyProgress
("无数据需要备份"
);
}
// 检查是否被取消（场景1）
if
(isCancelled
) {
return ERROR_USER_CANCELED;
}
//zwx-end
//p6
// 阶段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 package
File = updatePackages[currentPackageIndex];
UpdateSize = updatePackages[currentPackageIndex]
.length
();
String package
Name = package
File.get
Name();
long packageSize = package
File.length
();
// 备份完成后重置拷贝计数器
currentCopied
Bytes = 0;
// 阶段3
: 拷贝升级包
currentPhase
.set
(PHASE_COPYING
);
File dest
File = new
File(storageDir, package
Name);
// 拷贝时更新进度（修改）
boolean copyResult =
FileUtils
.copy
FileWithProgress
(
package
File,
dest
File,
(copied, total
) -> {
currentCopied
Bytes = copied;
notifyProgress
(String
.format
("拷贝 %s
: %s/%s",
package
Name,
formatSize
(copied
),
formatSize
(total
)));
}
);
if
(!copyResult
) {
lastErrorMessage = "拷贝失败
: " + package
Name;
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",
package
Name,
formatSize
(processed
),
formatSize
(total
)));
}
};
// 执行解密验签（传入回调）
if
(!dataVerification
(dest
File.getAbsolutePath
(), decryptCallback
)) {
if
(!
isCancelled
) {
return ERROR_DECRYPT_OR_SIGN_FAILED;
}
}
// 确保进度设置为
100%
currentVerified
Bytes = UpdateSize;
// 阶段5
: 解压升级包
currentPhase
.set
(PHASE_EXTRACTING
);
// 修复：重置解压计数器
currentExtracted
Bytes = 0; // 重置计数器
notifyProgress
("解压升级包
: " + package
Name);
// 解压时更新进度（修改）
boolean extractResult =
FileUtils
.extractZipWithProgress
(
dest
File,
storageDir,
(extracted, total
) -> {
currentExtracted
Bytes = extracted;
notifyProgress
(String
.format
("解压 %s
: %s/%s",
package
Name,
formatSize
(extracted
),
formatSize
(total
)));
}
);
if
(!extractResult
) {
lastErrorMessage = "解压失败
: " + package
Name;
return ERROR_EXTRACT_FAILED;
}
// 删除已解压的升级包以节省空间
if
(!dest
File.delete
()) {
Log
.w
(TAG, "删除升级包失败
: " + dest
File.get
Name());
}
// 更新解压进度（完成当前包）
currentExtracted
Bytes += 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
.ex
ists
() && !
FileUtils
.deleteRecursive
(backupDir
)) {
Log
.w
(TAG, "删除备份文件失败"
);
}
// 最终进度设为
100%
notifyProgress
("更新完成"
);
return SUCCESS;
} catch
(InterruptedException e
) {
// 场景1：备份未完成时被取消
if
(backupDir != null && backupDir
.ex
ists
()) {
// backup
File.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
) {
notifyL
istener
(SUCCESS, "更新成功,请重启车机"
);
currentPhase
.set
(PHASE_IDLE
);
currentTask = null;
} else {
handleFailure
(resultCode
);//p4-1
}
}
}
// ================== 启动时恢复检查 ==================
private void checkRecoveryOnStartup
() {
//
File backup
File = findLatestBackup
File();
Log
.i
(TAG, "=== 启动时恢复检查 ==="
);
// storageSize =
FileUtils
.getDirectorySize
(storageDir
);
// backupSize =
FileUtils
.getDirectorySize
(backupDir
);
handleFailure
(PHASE_IDLE
);//p4
notifyProgress
("数据恢复完成"
);
th
is.updateL
istener = 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 backupDir
) {
// try {
// // 1
. 设置回滚进度为99%
// backupSize =
FileUtils
.getDirectorySize
(storageDir
);
// rollbackProcessedSize = backupSize * 99 /
100;
// notifyProgress
("开始恢复备份
..."
);
//
// // 2
. 删除更新后的数据
//
FileUtils
.deleteDirectoryContents
(storageDir
);
//
// // 3
. 恢复备份
// rollbackTotalSize = backupSize ;
// rollbackProcessedSize = 0;
//
//
// // 执行目录复制
// if
(!singlecopydirectory
.copyDirectoryWithProgress
(backupDir , storageDir ,
(copied, total
) -> {
// currentCopied
Bytes = copied;
// notifyProgress
("恢复中
: " + formatSize
(copied
) + "/" + formatSize
(total
));
// }
)) {
// throw new IOException
("恢复备份失败
: " + storageDir
.getAbsolutePath
() + " -> " + backupDir
.getAbsolutePath
());
// }
// notifyProgress
("数据备份完成"
);
// } catch
(Exception e
) {
// Log
.e
(TAG, "回滚过程中发生错误", e
);
// }
// }
//p3-7 p4-2
protected void handleFailure
(Integer resultCode
) {
//
long resultCode = 1;
if
(backupDir != null && backupDir
.ex
ists
()) {
// 场景1：存在未完成的备份目录（backup）
Log
.w
(TAG, "检测到残留备份目录
: " + backupDir
.getAbsolutePath
() + "，该目录将被删除"
);
// 删除未完成的备份目录
if
(!
FileUtils
.deleteRecursive
(backupDir
)) {
Log
.e
(TAG, "无法删除未完成的备份目录
: " + backupDir
.getAbsolutePath
());
}
}
if
(backupAlreadyDir != null && backupAlreadyDir
.ex
ists
()) {
// 场景2：进入回滚流程
isRollingBack = true;
currentPhase
.set
(PHASE_ROLLBACK
);
// 先发送回滚进度通知（99%）
notifyProgress
("更新失败，正在回滚数据
..."
);
Log
.w
(TAG, "更新失败，正在回滚数据，回滚目录
: " + backupAlreadyDir
.getAbsolutePath
());
// 启动回滚线程
new Thread
(() -> {
try {
// 执行回滚
performRollback
(backupAlreadyDir
);
} finally {
// 回滚完成后删除备份
// backup
File.delete
();
if
(backupAlreadyDir
.ex
ists
() && !
FileUtils
.deleteRecursive
(backupAlreadyDir
)) {
Log
.w
(TAG, "删除备份文件失败
: " + backupAlreadyDir
.getAbsolutePath
());
}
if
(!
isCancelled
) {
// 回滚完成后发送最终结果
notifyL
istener
(resultCode, getErrorMessage
(resultCode
));
}
// 重置状态
currentPhase
.set
(PHASE_IDLE
);
currentTask = null;
isRollingBack = false;
}
}
).start
();
} else {
// 场景1：没有备份文件，直接报告错误
notifyL
istener
(resultCode, lastErrorMessage
);
currentPhase
.set
(PHASE_IDLE
);
currentTask = null;
}
}
//p3-6
private void performRollback
(File backupAlreadyDir
) {
try {
// 设置回滚标志
// 获取备份大小
long backupAlreadyDirSize =
FileUtils
.getDirectorySize
(backupAlreadyDir
);
if
(backupAlreadyDirSize <= 0
) {
throw new IOException
("备份目录为空或不可读
: " + backupAlreadyDir
.getAbsolutePath
());
}
// 设置回滚总大小
rollbackTotalSize = backupAlreadyDirSize;
rollbackProcessedSize = 0;
// 删除当前升级后的数据
if
(storageDir
.ex
ists
() && storageDir
.isDirectory
()) {
if
(!
FileUtils
.deleteDirectoryContents
(storageDir
)) {
throw new IOException
("无法清空目标目录
: " + storageDir
.getAbsolutePath
());
}
}
// 开始恢复备份
notifyProgress
("开始恢复备份
..."
);
// 执行目录复制并监听进度
boolean success = singlecopydirectory
.copyDirectoryWithProgress
(backupAlreadyDir, storageDir,
(copied, total
) -> {
rollbackProcessedSize = copied;
notifyProgress
("恢复中
: " + formatSize
(copied
) + "/" + formatSize
(total
));
}
);
if
(!success
) {
throw new IOException
("恢复备份失败"
);
}
// 回滚完成
rollbackProcessedSize = backupAlreadyDirSize;
notifyProgress
("数据恢复完成"
);
} catch
(Exception e
) {
Log
.e
(TAG, "回滚过程中发生错误", e
);
}
}
// 释放资源
public void release
() {
try {
context
.unreg
isterReceiver
(usbReceiver
);
context
.unreg
isterReceiver
(vehicleReceiver
);
} catch
(Exception e
) {
Log
.w
(TAG, "释放资源时出错", e
);
}
}
// ================== 接口定义 ==================
public interface UpdateL
istener {
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
.ex
ists
() || !storageDir
.isDirectory
()) {
return;
}
Pattern pattern = Pattern
.compile
(FILE_
NAME_PATTERN
);
File[]
files = storageDir
.l
ist
Files
();
if
(files == null
) return;
for
(File file : files
) {
if
(file.isFile() && pattern
.matcher
(file.get
Name()).matches
()) {
// 删除匹配的文件
try {
Files
.deleteIfEx
ists
(file.toPath
());
} catch
(IOException | SecurityException e
) {
// 处理
异常（记录日志等）
}
}
}
// 删除sign文件夹（如果存在）
Path signDir = Paths
.get
(storageDir
.getAbsolutePath
(), "sign"
);
if
(Files
.ex
ists
(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
.l
ist
(path
)) {
children
.forEach
(child -> {
try {
deleteDirectoryRecursively
(child
);
} catch
(IOException e
) {
// 处理子项删除
异常
throw new UncheckedIOException
(e
); // 转换为
RuntimeException 以便在 Stream 中抛出
}
}
);
} catch
(UncheckedIOException e
) {
// 重新抛出原始 IOException
throw e
.getCause
();
}
}
// 删除空目录或文件
Files
.deleteIfEx
ists
(path
);
}
}
本文介绍了解决在使用Apache Commons Compress进行Tar归档时遇到的长文件名问题的方法。通过设置TarOutputStream的LongFileMode为LONGFILE_GNU，可以启用GNU扩展来存储超过100字符的长文件名。
扫一扫
3901
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
