2394 lines
76 KiB
C#
2394 lines
76 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using System.IO;
|
||
using System.Linq;
|
||
using System.Text;
|
||
using UnityEngine;
|
||
|
||
/// <summary>
|
||
/// BFI测试历史记录管理服务
|
||
/// 负责保存、加载和管理历史测试记录
|
||
/// </summary>
|
||
public class BFIHistoryManager : MonoBehaviour
|
||
{
|
||
private const int MIN_HISTORY_RECORD_LIMIT = 1000;
|
||
private const string HISTORY_FILE_NAME = "bfi_history.json";
|
||
private const string HISTORY_BACKUP_FILE_NAME = "bfi_history_backup.json";
|
||
private const string HISTORY_RECORDS_DIR_NAME = "bfi_history_records";
|
||
private const string CURRENT_RECORDING_JOURNAL_FILE_NAME = "bfi_current_recording.jsonl";
|
||
private const int HISTORY_INDEX_VERSION = 2;
|
||
private const string HISTORY_STORAGE_MODE_PER_RECORD = "PerRecordFiles";
|
||
private const string RECORD_BACKUP_EXTENSION = ".bak";
|
||
private static readonly string[] HISTORY_CANDIDATE_FILE_NAMES = { HISTORY_FILE_NAME, HISTORY_BACKUP_FILE_NAME };
|
||
|
||
private static BFIHistoryManager _instance;
|
||
public static BFIHistoryManager Instance
|
||
{
|
||
get
|
||
{
|
||
if (_instance == null)
|
||
{
|
||
var go = new GameObject("BFIHistoryManager");
|
||
_instance = go.AddComponent<BFIHistoryManager>();
|
||
DontDestroyOnLoad(go);
|
||
}
|
||
return _instance;
|
||
}
|
||
}
|
||
|
||
[Header("配置")]
|
||
[SerializeField] private int maxHistoryRecords = 1000; // 最大历史记录数
|
||
[SerializeField] private bool autoSave = true; // 自动保存
|
||
[SerializeField] private float saveInterval = 60f; // 保存间隔（秒）
|
||
|
||
private List<BFITestRecord> historyRecords;
|
||
private string historyFilePath;
|
||
private string historyMirrorFilePath;
|
||
private string historyRecordsDirectoryPath;
|
||
private float lastSaveTime;
|
||
private bool historyFileLoadFailed;
|
||
private bool androidStoragePermissionRequested;
|
||
private bool historyIndexDirty;
|
||
|
||
// 事件
|
||
public event System.Action<BFITestRecord> OnRecordAdded;
|
||
public event System.Action<BFITestRecord> OnRecordUpdated;
|
||
public event System.Action<string> OnRecordRemoved;
|
||
public event System.Action OnHistoryLoaded;
|
||
// public bool LastSaveSucceeded { get; private set; }
|
||
|
||
private void Awake()
|
||
{
|
||
if (_instance == null)
|
||
{
|
||
_instance = this;
|
||
DontDestroyOnLoad(gameObject);
|
||
Initialize();
|
||
}
|
||
else if (_instance != this)
|
||
{
|
||
Destroy(gameObject);
|
||
}
|
||
}
|
||
|
||
private void Initialize()
|
||
{
|
||
maxHistoryRecords = Mathf.Max(maxHistoryRecords, MIN_HISTORY_RECORD_LIMIT);
|
||
historyRecords = new List<BFITestRecord>();
|
||
|
||
// 历史索引是导出面板的数据源，主文件使用Unity持久化目录，和报警记录一致。
|
||
// historyMirrorFilePath仅用于清理旧版本曾写入Download的镜像文件。
|
||
historyFilePath = ResolveHistoryFilePath();
|
||
historyMirrorFilePath = ResolveHistoryMirrorFilePath();
|
||
historyRecordsDirectoryPath = GetRecordFilesDirectory(historyFilePath);
|
||
EnsureHistoryDirectoryExists();
|
||
|
||
LoadHistoryRecords(true, true);
|
||
|
||
Debug.Log($"BFI历史管理器已初始化，历史文件路径: {historyFilePath}, 单条记录目录: {historyRecordsDirectoryPath}");
|
||
#if UNITY_ANDROID && !UNITY_EDITOR
|
||
AndroidFileLogger.Instance?.LogInfo("BFIHistory", $"历史文件路径: {historyFilePath}");
|
||
AndroidFileLogger.Instance?.LogInfo("BFIHistory", $"单条记录目录: {historyRecordsDirectoryPath}");
|
||
#endif
|
||
}
|
||
|
||
private string ResolveHistoryFilePath()
|
||
{
|
||
return Path.Combine(Application.persistentDataPath, HISTORY_FILE_NAME);
|
||
}
|
||
|
||
private string ResolveHistoryMirrorFilePath()
|
||
{
|
||
#if UNITY_ANDROID && !UNITY_EDITOR
|
||
return Path.Combine(GetAndroidPublicDownloadDirectory(), "DCX_Export", HISTORY_FILE_NAME);
|
||
#else
|
||
return null;
|
||
#endif
|
||
}
|
||
|
||
public string GetHistoryFilePath()
|
||
{
|
||
return historyFilePath;
|
||
}
|
||
|
||
public string GetHistoryMirrorFilePath()
|
||
{
|
||
return historyMirrorFilePath;
|
||
}
|
||
|
||
public string GetHistoryRecordsDirectoryPath()
|
||
{
|
||
return historyRecordsDirectoryPath;
|
||
}
|
||
|
||
#if UNITY_ANDROID && !UNITY_EDITOR
|
||
private string GetAndroidPublicDownloadDirectory()
|
||
{
|
||
try
|
||
{
|
||
using (var environment = new AndroidJavaClass("android.os.Environment"))
|
||
using (var downloadDir = environment.CallStatic<AndroidJavaObject>(
|
||
"getExternalStoragePublicDirectory",
|
||
environment.GetStatic<string>("DIRECTORY_DOWNLOADS")))
|
||
{
|
||
string path = downloadDir?.Call<string>("getAbsolutePath");
|
||
if (!string.IsNullOrEmpty(path))
|
||
{
|
||
return path;
|
||
}
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.LogWarning($"获取Android公共Download目录失败，回退persistentDataPath: {ex.Message}");
|
||
}
|
||
|
||
return Application.persistentDataPath;
|
||
}
|
||
#endif
|
||
|
||
private void EnsureHistoryDirectoryExists()
|
||
{
|
||
EnsureHistoryDirectoryExists(historyFilePath, false);
|
||
EnsureDirectoryExists(historyRecordsDirectoryPath);
|
||
}
|
||
|
||
private bool EnsureDirectoryExists(string directory)
|
||
{
|
||
try
|
||
{
|
||
if (string.IsNullOrEmpty(directory))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
if (!Directory.Exists(directory))
|
||
{
|
||
Directory.CreateDirectory(directory);
|
||
}
|
||
|
||
return true;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.LogWarning($"创建目录失败: {directory}, {ex.Message}");
|
||
return false;
|
||
}
|
||
}
|
||
|
||
private bool EnsureHistoryDirectoryExists(string filePath, bool requestExternalPermission)
|
||
{
|
||
try
|
||
{
|
||
if (string.IsNullOrEmpty(filePath))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
string dir = Path.GetDirectoryName(filePath);
|
||
#if UNITY_ANDROID && !UNITY_EDITOR
|
||
if (requestExternalPermission)
|
||
{
|
||
EnsureAndroidDownloadPermission(dir);
|
||
}
|
||
#endif
|
||
|
||
if (!string.IsNullOrEmpty(dir) && !Directory.Exists(dir))
|
||
{
|
||
Directory.CreateDirectory(dir);
|
||
}
|
||
|
||
return true;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.LogWarning($"创建历史记录目录失败: {filePath}, {ex.Message}");
|
||
return false;
|
||
}
|
||
}
|
||
|
||
#if UNITY_ANDROID && !UNITY_EDITOR
|
||
private void EnsureAndroidDownloadPermission(string directory)
|
||
{
|
||
if (string.IsNullOrEmpty(directory) || !directory.Contains("/Download"))
|
||
{
|
||
return;
|
||
}
|
||
|
||
try
|
||
{
|
||
using (var buildVersion = new AndroidJavaClass("android.os.Build$VERSION"))
|
||
{
|
||
int sdkInt = buildVersion.GetStatic<int>("SDK_INT");
|
||
if (sdkInt >= 30 && !AndroidExportPermissionManager.HasManageExternalStoragePermission())
|
||
{
|
||
Debug.LogWarning("BFI历史索引镜像保存到Download需要管理外部存储权限；主索引仍保存在应用内部目录");
|
||
if (!androidStoragePermissionRequested)
|
||
{
|
||
androidStoragePermissionRequested = true;
|
||
AndroidExportPermissionManager.RequestManageExternalStoragePermission();
|
||
}
|
||
}
|
||
else if (sdkInt <= 29 && !AndroidExportPermissionManager.HasWriteExternalStoragePermission())
|
||
{
|
||
Debug.LogWarning("BFI历史索引镜像保存到Download需要写入外部存储权限；主索引仍保存在应用内部目录");
|
||
if (!androidStoragePermissionRequested)
|
||
{
|
||
androidStoragePermissionRequested = true;
|
||
AndroidExportPermissionManager.RequestWriteExternalStoragePermission();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.LogWarning($"检查Download写入权限失败: {ex.Message}");
|
||
}
|
||
}
|
||
#endif
|
||
|
||
private void Update()
|
||
{
|
||
// 自动保存
|
||
if (autoSave && Time.time - lastSaveTime > saveInterval)
|
||
{
|
||
if (!historyIndexDirty || SaveHistoryIndex())
|
||
{
|
||
historyIndexDirty = false;
|
||
}
|
||
|
||
lastSaveTime = Time.time;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 添加新的测试记录
|
||
/// </summary>
|
||
public bool AddTestRecord(BFITestRecord record)
|
||
{
|
||
if (record == null)
|
||
{
|
||
Debug.LogWarning("尝试添加空的测试记录");
|
||
return false;
|
||
}
|
||
|
||
try
|
||
{
|
||
if (historyRecords == null)
|
||
{
|
||
historyRecords = new List<BFITestRecord>();
|
||
}
|
||
|
||
NormalizeRecordForStorage(record);
|
||
|
||
// 检查是否已存在
|
||
var existingRecord = historyRecords.FirstOrDefault(r => r.TestId == record.TestId);
|
||
if (existingRecord != null)
|
||
{
|
||
if (!ShouldReplaceRecord(existingRecord, record))
|
||
{
|
||
bool existingPersisted = IsRecordPersisted(existingRecord.TestId, existingRecord.DataPoints?.Count ?? 0);
|
||
if (!existingPersisted)
|
||
{
|
||
existingPersisted = SaveHistoryRecordFile(existingRecord);
|
||
}
|
||
|
||
SaveHistoryIndex();
|
||
Debug.Log($"忽略较旧的BFI记录快照: {record.TestName}");
|
||
return existingPersisted;
|
||
}
|
||
}
|
||
|
||
// 关键原则：先写实体文件，写成功后才进入内存历史，避免界面显示“假记录”。
|
||
bool recordSaved = SaveHistoryRecordFile(record);
|
||
if (!recordSaved)
|
||
{
|
||
Debug.LogError($"BFI记录实体文件保存失败，已拒绝加入内存历史: {record.TestName}");
|
||
return false;
|
||
}
|
||
|
||
if (existingRecord != null)
|
||
{
|
||
int index = historyRecords.IndexOf(existingRecord);
|
||
historyRecords[index] = record;
|
||
OnRecordUpdated?.Invoke(record);
|
||
Debug.Log($"更新测试记录: {record.TestName}");
|
||
}
|
||
else
|
||
{
|
||
// 添加新记录
|
||
historyRecords.Add(record);
|
||
OnRecordAdded?.Invoke(record);
|
||
Debug.Log($"添加新测试记录: {record.TestName}");
|
||
|
||
// 检查记录数量限制
|
||
if (historyRecords.Count > maxHistoryRecords)
|
||
{
|
||
RemoveOldestRecord();
|
||
}
|
||
}
|
||
|
||
// 刷新轻量索引。记录实体文件已经先保存，索引失败也不会丢失记录本体。
|
||
bool indexSaved = SaveHistoryIndex();
|
||
if (!indexSaved)
|
||
{
|
||
Debug.LogWarning($"BFI历史索引保存失败，但记录实体文件已保存: {record.TestName}");
|
||
}
|
||
|
||
return recordSaved;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.LogError($"添加测试记录失败: {ex.Message}");
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 保存自动记录中的中间快照。实时逐点日志已经承担断电恢复职责，
|
||
/// 这里避免每次快照都重写索引和反读整条记录，降低安卓板主线程IO压力。
|
||
/// </summary>
|
||
public bool AddTestRecordSnapshot(BFITestRecord record)
|
||
{
|
||
if (record == null)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
try
|
||
{
|
||
if (historyRecords == null)
|
||
{
|
||
historyRecords = new List<BFITestRecord>();
|
||
}
|
||
|
||
NormalizeRecordForStorage(record);
|
||
|
||
var existingRecord = historyRecords.FirstOrDefault(r => r.TestId == record.TestId);
|
||
if (existingRecord != null && !ShouldReplaceRecord(existingRecord, record))
|
||
{
|
||
return true;
|
||
}
|
||
|
||
bool recordSaved = SaveHistoryRecordFile(record, verifyAfterWrite: false, verboseLog: false);
|
||
if (!recordSaved)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
if (existingRecord != null)
|
||
{
|
||
int index = historyRecords.IndexOf(existingRecord);
|
||
historyRecords[index] = record;
|
||
OnRecordUpdated?.Invoke(record);
|
||
}
|
||
else
|
||
{
|
||
historyRecords.Add(record);
|
||
OnRecordAdded?.Invoke(record);
|
||
|
||
if (historyRecords.Count > maxHistoryRecords)
|
||
{
|
||
RemoveOldestRecord();
|
||
}
|
||
}
|
||
|
||
historyIndexDirty = true;
|
||
return true;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.LogWarning($"保存BFI记录快照失败: {record?.TestName}, {ex.Message}");
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 移除测试记录
|
||
/// </summary>
|
||
public bool RemoveTestRecord(string testId)
|
||
{
|
||
try
|
||
{
|
||
var record = historyRecords.FirstOrDefault(r => r.TestId == testId);
|
||
if (record != null)
|
||
{
|
||
historyRecords.Remove(record);
|
||
DeleteHistoryRecordFile(record);
|
||
OnRecordRemoved?.Invoke(testId);
|
||
SaveHistoryIndex();
|
||
Debug.Log($"移除测试记录: {record.TestName}");
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.LogError($"移除测试记录失败: {ex.Message}");
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取所有历史记录
|
||
/// </summary>
|
||
public List<BFITestRecord> GetAllRecords()
|
||
{
|
||
return GetRecordsSortedByRecentFirst(historyRecords);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据ID获取记录
|
||
/// </summary>
|
||
public BFITestRecord GetRecord(string testId)
|
||
{
|
||
return historyRecords.FirstOrDefault(r => r.TestId == testId);
|
||
}
|
||
|
||
public BFITestRecord GetFullRecord(string testId)
|
||
{
|
||
if (string.IsNullOrEmpty(testId))
|
||
{
|
||
return null;
|
||
}
|
||
|
||
var cachedRecord = GetRecord(testId);
|
||
if (cachedRecord != null && cachedRecord.DataPoints != null && cachedRecord.DataPoints.Count > 0)
|
||
{
|
||
return cachedRecord;
|
||
}
|
||
|
||
string defaultRecordFilePath = GetHistoryRecordFilePath(testId);
|
||
string recordFilePath = !string.IsNullOrEmpty(cachedRecord?.FilePath)
|
||
? cachedRecord.FilePath
|
||
: defaultRecordFilePath;
|
||
|
||
BFITestRecord bestRecord = cachedRecord;
|
||
if (TryReadHistoryRecord(recordFilePath, out var record))
|
||
{
|
||
bestRecord = ChooseRecordWithMoreData(bestRecord, record);
|
||
if (HasDataPoints(record))
|
||
{
|
||
AddOrReplaceRecoveredRecordToList(historyRecords, record);
|
||
return record;
|
||
}
|
||
}
|
||
|
||
if (!string.Equals(recordFilePath, defaultRecordFilePath, StringComparison.OrdinalIgnoreCase) &&
|
||
TryReadHistoryRecord(defaultRecordFilePath, out record))
|
||
{
|
||
bestRecord = ChooseRecordWithMoreData(bestRecord, record);
|
||
if (HasDataPoints(record))
|
||
{
|
||
AddOrReplaceRecoveredRecordToList(historyRecords, record);
|
||
return record;
|
||
}
|
||
}
|
||
|
||
if (TryFindBestHistoryRecordById(testId, out var recoveredRecord, out var recoveredPath))
|
||
{
|
||
recoveredRecord.FilePath = recoveredPath;
|
||
AddOrReplaceRecoveredRecordToList(historyRecords, recoveredRecord);
|
||
|
||
if (!string.Equals(recoveredPath, defaultRecordFilePath, StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
SaveHistoryRecordFile(recoveredRecord, verifyAfterWrite: true, verboseLog: false);
|
||
}
|
||
|
||
Debug.Log($"已为BFI导出恢复完整记录: {recoveredRecord.TestName}, 点数: {recoveredRecord.DataPoints?.Count ?? 0}");
|
||
return recoveredRecord;
|
||
}
|
||
|
||
if (bestRecord != null)
|
||
{
|
||
AddOrReplaceRecoveredRecordToList(historyRecords, bestRecord);
|
||
}
|
||
|
||
Debug.LogWarning($"未找到完整BFI记录明细: ID={testId}, 文件={recordFilePath}");
|
||
return bestRecord;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据日期范围获取记录
|
||
/// </summary>
|
||
public List<BFITestRecord> GetRecordsByDateRange(DateTime startDate, DateTime endDate)
|
||
{
|
||
return GetRecordsSortedByRecentFirst(historyRecords.Where(r => r.StartTime >= startDate && r.StartTime <= endDate));
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据患者ID获取记录
|
||
/// </summary>
|
||
public List<BFITestRecord> GetRecordsByPatient(string patientId)
|
||
{
|
||
return GetRecordsSortedByRecentFirst(historyRecords.Where(r => r.PatientId == patientId));
|
||
}
|
||
|
||
/// <summary>
|
||
/// 搜索记录
|
||
/// </summary>
|
||
public List<BFITestRecord> SearchRecords(string keyword)
|
||
{
|
||
if (string.IsNullOrEmpty(keyword))
|
||
return GetAllRecords();
|
||
|
||
keyword = keyword.ToLower();
|
||
return GetRecordsSortedByRecentFirst(historyRecords.Where(r =>
|
||
r.TestName.ToLower().Contains(keyword) ||
|
||
r.PatientName?.ToLower().Contains(keyword) == true ||
|
||
r.PatientId?.ToLower().Contains(keyword) == true
|
||
));
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取最近的记录
|
||
/// </summary>
|
||
public List<BFITestRecord> GetRecentRecords(int count = 10)
|
||
{
|
||
return GetRecordsSortedByRecentFirst(historyRecords).Take(count).ToList();
|
||
}
|
||
|
||
private List<BFITestRecord> GetRecordsSortedByRecentFirst(IEnumerable<BFITestRecord> records)
|
||
{
|
||
return (records ?? Enumerable.Empty<BFITestRecord>())
|
||
.Where(r => r != null)
|
||
.OrderByDescending(r => r.StartTime)
|
||
.ThenByDescending(r => r.EndTime)
|
||
.ToList();
|
||
}
|
||
|
||
/// <summary>
|
||
/// 清空历史记录
|
||
/// </summary>
|
||
public void ClearHistory()
|
||
{
|
||
try
|
||
{
|
||
historyRecords.Clear();
|
||
historyFileLoadFailed = false;
|
||
historyIndexDirty = false;
|
||
DeleteAllHistoryStorageFiles();
|
||
SaveHistoryRecords();
|
||
OnHistoryLoaded?.Invoke();
|
||
Debug.Log("历史记录已清空");
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.LogError($"清空历史记录失败: {ex.Message}");
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 保存历史记录到文件
|
||
/// </summary>
|
||
public bool SaveHistoryRecords()
|
||
{
|
||
try
|
||
{
|
||
if (historyFileLoadFailed && (historyRecords == null || historyRecords.Count == 0))
|
||
{
|
||
Debug.LogWarning("历史文件加载失败，跳过空历史保存，避免覆盖已有索引");
|
||
return false;
|
||
}
|
||
|
||
EnsureHistoryDirectoryExists();
|
||
|
||
bool allRecordsSaved = true;
|
||
if (historyRecords != null)
|
||
{
|
||
foreach (var record in historyRecords)
|
||
{
|
||
if (record == null)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
NormalizeRecordForStorage(record);
|
||
int pointCount = record.DataPoints?.Count ?? 0;
|
||
if (!IsRecordPersisted(record.TestId, pointCount))
|
||
{
|
||
allRecordsSaved &= SaveHistoryRecordFile(record);
|
||
}
|
||
}
|
||
}
|
||
|
||
bool indexSaved = SaveHistoryIndex();
|
||
historyFileLoadFailed = false;
|
||
// LastSaveSucceeded = true;
|
||
|
||
Debug.Log($"历史记录已保存，共 {historyRecords?.Count ?? 0} 条记录，单条文件目录: {historyRecordsDirectoryPath}");
|
||
return allRecordsSaved && indexSaved;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
// LastSaveSucceeded = false;
|
||
Debug.LogError($"保存历史记录失败: {ex.Message}");
|
||
return false;
|
||
}
|
||
}
|
||
|
||
private bool SaveHistoryIndex()
|
||
{
|
||
try
|
||
{
|
||
EnsureHistoryDirectoryExists();
|
||
|
||
var indexEntries = new List<BFIHistoryRecordIndexEntry>();
|
||
if (historyRecords != null)
|
||
{
|
||
foreach (var record in historyRecords.Where(r => r != null))
|
||
{
|
||
NormalizeRecordForStorage(record);
|
||
indexEntries.Add(CreateIndexEntry(record));
|
||
}
|
||
}
|
||
|
||
var wrapper = new BFIHistoryWrapper
|
||
{
|
||
Version = HISTORY_INDEX_VERSION,
|
||
StorageMode = HISTORY_STORAGE_MODE_PER_RECORD,
|
||
Records = new List<BFITestRecord>(),
|
||
RecordFiles = indexEntries
|
||
};
|
||
|
||
string json = JsonUtility.ToJson(wrapper, true);
|
||
WriteAllTextAtomic(historyFilePath, json);
|
||
historyIndexDirty = false;
|
||
return true;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.LogError($"保存BFI历史索引失败: {ex.Message}");
|
||
return false;
|
||
}
|
||
}
|
||
|
||
private BFIHistoryRecordIndexEntry CreateIndexEntry(BFITestRecord record)
|
||
{
|
||
string defaultFilePath = GetHistoryRecordFilePath(record);
|
||
string filePath = string.IsNullOrEmpty(record.FilePath) ? defaultFilePath : record.FilePath;
|
||
string fileName = GetIndexEntryFileName(filePath, defaultFilePath);
|
||
int pointCount = record.DataPoints?.Count ?? 0;
|
||
bool summaryOnlyRecord = pointCount == 0 && (record.Statistics?.Count ?? 0) > 0;
|
||
if (summaryOnlyRecord)
|
||
{
|
||
pointCount = record.Statistics.Count;
|
||
}
|
||
|
||
return new BFIHistoryRecordIndexEntry
|
||
{
|
||
TestId = record.TestId,
|
||
TestName = record.TestName,
|
||
PatientId = record.PatientId,
|
||
PatientName = record.PatientName,
|
||
FileName = fileName,
|
||
StartTimeTicks = record.StartTimeTicks,
|
||
EndTimeTicks = record.EndTimeTicks,
|
||
PointCount = pointCount,
|
||
MinValue = record.Statistics?.MinValue ?? 0f,
|
||
MaxValue = record.Statistics?.MaxValue ?? 0f,
|
||
Average = record.Statistics?.Average ?? 0f
|
||
};
|
||
}
|
||
|
||
private string GetIndexEntryFileName(string filePath, string defaultFilePath)
|
||
{
|
||
try
|
||
{
|
||
if (string.IsNullOrEmpty(filePath))
|
||
{
|
||
return Path.GetFileName(defaultFilePath);
|
||
}
|
||
|
||
string directory = Path.GetDirectoryName(filePath);
|
||
if (!string.IsNullOrEmpty(directory) &&
|
||
!string.IsNullOrEmpty(historyRecordsDirectoryPath) &&
|
||
string.Equals(
|
||
Path.GetFullPath(directory).TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar),
|
||
Path.GetFullPath(historyRecordsDirectoryPath).TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar),
|
||
StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
return Path.GetFileName(filePath);
|
||
}
|
||
|
||
return Path.IsPathRooted(filePath) ? filePath : Path.GetFileName(filePath);
|
||
}
|
||
catch
|
||
{
|
||
return Path.GetFileName(defaultFilePath);
|
||
}
|
||
}
|
||
|
||
private bool SaveHistoryRecordFile(BFITestRecord record, bool verifyAfterWrite = true, bool verboseLog = true)
|
||
{
|
||
try
|
||
{
|
||
if (record == null)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
NormalizeRecordForStorage(record);
|
||
string filePath = GetHistoryRecordFilePath(record);
|
||
record.FilePath = filePath;
|
||
|
||
if ((record.DataPoints == null || record.DataPoints.Count == 0) &&
|
||
(record.Statistics?.Count ?? 0) > 0)
|
||
{
|
||
if (TryFindBestHistoryRecordById(record.TestId, out var recoveredRecord, out var recoveredPath))
|
||
{
|
||
recoveredRecord.FilePath = recoveredPath;
|
||
MergeRecordMetadata(recoveredRecord, record);
|
||
|
||
if (!string.Equals(recoveredPath, filePath, StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
return SaveHistoryRecordFile(recoveredRecord, verifyAfterWrite, verboseLog);
|
||
}
|
||
|
||
MergeRecordMetadata(record, recoveredRecord);
|
||
return true;
|
||
}
|
||
|
||
Debug.LogWarning($"跳过保存仅摘要BFI记录实体文件，避免覆盖明细数据: {record.TestName}, {filePath}");
|
||
return IsRecordPersisted(record.TestId, 1);
|
||
}
|
||
|
||
if (TryPromoteExistingTempRecordFile(record, filePath))
|
||
{
|
||
return true;
|
||
}
|
||
|
||
string json = JsonUtility.ToJson(record, true);
|
||
WriteAllTextAtomic(filePath, json);
|
||
|
||
if (!verifyAfterWrite)
|
||
{
|
||
return true;
|
||
}
|
||
|
||
bool persisted = IsRecordPersisted(record.TestId, record.DataPoints?.Count ?? 0);
|
||
if (!persisted)
|
||
{
|
||
Debug.LogWarning($"BFI记录写入后校验失败: {record.TestName}, {filePath}");
|
||
}
|
||
else if (verboseLog)
|
||
{
|
||
Debug.Log($"BFI记录实体文件已保存: {filePath}");
|
||
#if UNITY_ANDROID && !UNITY_EDITOR
|
||
AndroidFileLogger.Instance?.LogInfo("BFIHistory", $"记录实体文件已保存: {filePath}, 点数: {record.DataPoints?.Count ?? 0}");
|
||
#endif
|
||
}
|
||
|
||
return persisted;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.LogError($"保存BFI单条历史记录失败: {record?.TestName}, {ex.Message}");
|
||
return false;
|
||
}
|
||
}
|
||
|
||
private bool TryPromoteExistingTempRecordFile(BFITestRecord record, string filePath)
|
||
{
|
||
try
|
||
{
|
||
if (record == null || string.IsNullOrEmpty(filePath))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
string tempPath = filePath + ".tmp";
|
||
if (!File.Exists(tempPath))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
if (!TryReadHistoryRecordFile(tempPath, out var tempRecord) ||
|
||
!string.Equals(tempRecord.TestId, record.TestId, StringComparison.Ordinal))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
int tempPointCount = tempRecord.DataPoints?.Count ?? 0;
|
||
int recordPointCount = record.DataPoints?.Count ?? 0;
|
||
if (tempPointCount < recordPointCount)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
if (File.Exists(filePath))
|
||
{
|
||
if (IsRecordPersisted(record.TestId, recordPointCount))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
TryCopyFile(filePath, filePath + RECORD_BACKUP_EXTENSION);
|
||
File.Copy(tempPath, filePath, true);
|
||
}
|
||
else
|
||
{
|
||
File.Move(tempPath, filePath);
|
||
}
|
||
|
||
bool persisted = IsRecordPersisted(record.TestId, recordPointCount);
|
||
if (persisted)
|
||
{
|
||
DeleteFileIfExists(tempPath);
|
||
Debug.Log($"已将断电遗留BFI临时记录转正: {filePath}");
|
||
#if UNITY_ANDROID && !UNITY_EDITOR
|
||
AndroidFileLogger.Instance?.LogInfo("BFIHistory", $"已将断电遗留BFI临时记录转正: {filePath}");
|
||
#endif
|
||
}
|
||
|
||
return persisted;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.LogWarning($"转正BFI临时记录失败，将尝试重新写入: {filePath}, {ex.Message}");
|
||
return false;
|
||
}
|
||
}
|
||
|
||
public bool IsRecordPersisted(string testId, int minPointCount = 0)
|
||
{
|
||
try
|
||
{
|
||
if (string.IsNullOrEmpty(testId))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
string filePath = GetHistoryRecordFilePath(testId);
|
||
if (!TryReadHistoryRecord(filePath, out var savedRecord))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
if (!string.Equals(savedRecord.TestId, testId, StringComparison.Ordinal))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
return (savedRecord.DataPoints?.Count ?? 0) >= minPointCount;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.LogWarning($"确认BFI记录持久化失败: {testId}, {ex.Message}");
|
||
return false;
|
||
}
|
||
}
|
||
|
||
private bool ShouldReplaceRecord(BFITestRecord existingRecord, BFITestRecord candidateRecord)
|
||
{
|
||
if (existingRecord == null)
|
||
{
|
||
return true;
|
||
}
|
||
|
||
if (candidateRecord == null)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
NormalizeRecordForStorage(existingRecord);
|
||
NormalizeRecordForStorage(candidateRecord);
|
||
|
||
int existingPointCount = existingRecord.DataPoints?.Count ?? 0;
|
||
int candidatePointCount = candidateRecord.DataPoints?.Count ?? 0;
|
||
if (candidatePointCount != existingPointCount)
|
||
{
|
||
return candidatePointCount > existingPointCount;
|
||
}
|
||
|
||
return candidateRecord.EndTime >= existingRecord.EndTime;
|
||
}
|
||
|
||
private bool HasDataPoints(BFITestRecord record)
|
||
{
|
||
return record?.DataPoints != null && record.DataPoints.Count > 0;
|
||
}
|
||
|
||
private BFITestRecord ChooseRecordWithMoreData(BFITestRecord current, BFITestRecord candidate)
|
||
{
|
||
if (current == null)
|
||
{
|
||
return candidate;
|
||
}
|
||
|
||
if (candidate == null)
|
||
{
|
||
return current;
|
||
}
|
||
|
||
int currentPointCount = current.DataPoints?.Count ?? 0;
|
||
int candidatePointCount = candidate.DataPoints?.Count ?? 0;
|
||
if (candidatePointCount != currentPointCount)
|
||
{
|
||
return candidatePointCount > currentPointCount ? candidate : current;
|
||
}
|
||
|
||
int currentSummaryCount = current.Statistics?.Count ?? 0;
|
||
int candidateSummaryCount = candidate.Statistics?.Count ?? 0;
|
||
if (candidateSummaryCount != currentSummaryCount)
|
||
{
|
||
return candidateSummaryCount > currentSummaryCount ? candidate : current;
|
||
}
|
||
|
||
return candidate.EndTime > current.EndTime ? candidate : current;
|
||
}
|
||
|
||
private bool TryFindBestHistoryRecordById(string testId, out BFITestRecord bestRecord, out string bestRecordPath)
|
||
{
|
||
bestRecord = null;
|
||
bestRecordPath = null;
|
||
|
||
if (string.IsNullOrEmpty(testId))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
try
|
||
{
|
||
int bestPointCount = 0;
|
||
foreach (var recordFilePath in FindHistoryRecordFiles(true))
|
||
{
|
||
if (!TryReadHistoryRecordFile(recordFilePath, out var candidate) ||
|
||
!string.Equals(candidate.TestId, testId, StringComparison.Ordinal))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
int candidatePointCount = candidate.DataPoints?.Count ?? 0;
|
||
if (candidatePointCount <= 0)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (bestRecord == null || candidatePointCount > bestPointCount)
|
||
{
|
||
bestRecord = candidate;
|
||
bestRecordPath = recordFilePath;
|
||
bestPointCount = candidatePointCount;
|
||
}
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.LogWarning($"搜索完整BFI记录失败: {testId}, {ex.Message}");
|
||
bestRecord = null;
|
||
bestRecordPath = null;
|
||
}
|
||
|
||
return bestRecord != null;
|
||
}
|
||
|
||
private bool AreAllHistoryRecordsPersistedAsFiles()
|
||
{
|
||
if (historyRecords == null || historyRecords.Count == 0)
|
||
{
|
||
return true;
|
||
}
|
||
|
||
foreach (var record in historyRecords)
|
||
{
|
||
if (record == null)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
NormalizeRecordForStorage(record);
|
||
if (!IsRecordPersisted(record.TestId, record.DataPoints?.Count ?? 0))
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
private void NormalizeRecordForStorage(BFITestRecord record)
|
||
{
|
||
if (record == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
if (record.DataPoints == null)
|
||
{
|
||
record.DataPoints = new List<BFIDataPoint>();
|
||
}
|
||
|
||
if (record.Statistics == null)
|
||
{
|
||
record.Statistics = new BFIStatistics();
|
||
}
|
||
|
||
bool hasSummaryStatisticsWithoutPoints =
|
||
record.DataPoints.Count == 0 &&
|
||
record.Statistics.Count > 0;
|
||
BFIStatistics preservedSummaryStatistics = hasSummaryStatisticsWithoutPoints
|
||
? CloneBFIStatistics(record.Statistics)
|
||
: null;
|
||
|
||
record.RestoreAfterDeserialization();
|
||
|
||
if (hasSummaryStatisticsWithoutPoints && record.DataPoints.Count == 0)
|
||
{
|
||
record.Statistics = preservedSummaryStatistics;
|
||
}
|
||
|
||
if (string.IsNullOrWhiteSpace(record.TestId))
|
||
{
|
||
record.TestId = GenerateStableRecordId(record);
|
||
}
|
||
|
||
if (string.IsNullOrWhiteSpace(record.TestName))
|
||
{
|
||
record.TestName = $"BFI测试_{record.StartTime:yyyyMMdd_HHmmss}";
|
||
}
|
||
|
||
record.PrepareForSerialization();
|
||
}
|
||
|
||
private BFIStatistics CloneBFIStatistics(BFIStatistics source)
|
||
{
|
||
if (source == null)
|
||
{
|
||
return new BFIStatistics();
|
||
}
|
||
|
||
return new BFIStatistics
|
||
{
|
||
Count = source.Count,
|
||
MinValue = source.MinValue,
|
||
MaxValue = source.MaxValue,
|
||
Average = source.Average,
|
||
StandardDeviation = source.StandardDeviation,
|
||
Duration = source.Duration,
|
||
LastUpdated = source.LastUpdated
|
||
};
|
||
}
|
||
|
||
private string GenerateStableRecordId(BFITestRecord record)
|
||
{
|
||
long startTicks = record.StartTimeTicks > 0 ? record.StartTimeTicks : record.StartTime.Ticks;
|
||
long endTicks = record.EndTimeTicks;
|
||
int pointCount = record.DataPoints?.Count ?? 0;
|
||
long firstPointTicks = 0;
|
||
long lastPointTicks = 0;
|
||
float firstBfi = 0f;
|
||
float lastBfi = 0f;
|
||
|
||
if (record.DataPoints != null && record.DataPoints.Count > 0)
|
||
{
|
||
var firstPoint = record.DataPoints.FirstOrDefault(p => p != null);
|
||
var lastPoint = record.DataPoints.LastOrDefault(p => p != null);
|
||
firstPointTicks = firstPoint?.TimestampTicks ?? 0;
|
||
lastPointTicks = lastPoint?.TimestampTicks ?? 0;
|
||
firstBfi = firstPoint?.BFI ?? 0f;
|
||
lastBfi = lastPoint?.BFI ?? 0f;
|
||
}
|
||
|
||
string identity = string.Join("|",
|
||
record.TestName ?? string.Empty,
|
||
record.PatientId ?? string.Empty,
|
||
record.PatientName ?? string.Empty,
|
||
startTicks.ToString(),
|
||
endTicks.ToString(),
|
||
pointCount.ToString(),
|
||
firstPointTicks.ToString(),
|
||
lastPointTicks.ToString(),
|
||
firstBfi.ToString("R"),
|
||
lastBfi.ToString("R"));
|
||
|
||
return $"legacy_{ComputeStableHash(identity):x16}";
|
||
}
|
||
|
||
private ulong ComputeStableHash(string value)
|
||
{
|
||
unchecked
|
||
{
|
||
const ulong offset = 14695981039346656037UL;
|
||
const ulong prime = 1099511628211UL;
|
||
ulong hash = offset;
|
||
|
||
foreach (char c in value ?? string.Empty)
|
||
{
|
||
hash ^= c;
|
||
hash *= prime;
|
||
}
|
||
|
||
return hash;
|
||
}
|
||
}
|
||
|
||
private string GetHistoryRecordFilePath(BFITestRecord record)
|
||
{
|
||
NormalizeRecordForStorage(record);
|
||
return GetHistoryRecordFilePath(record.TestId);
|
||
}
|
||
|
||
private string GetHistoryRecordFilePath(string testId)
|
||
{
|
||
if (string.IsNullOrEmpty(historyRecordsDirectoryPath))
|
||
{
|
||
historyRecordsDirectoryPath = GetRecordFilesDirectory(historyFilePath);
|
||
}
|
||
|
||
string safeId = SanitizeFileComponent(string.IsNullOrEmpty(testId) ? Guid.NewGuid().ToString() : testId);
|
||
return Path.Combine(historyRecordsDirectoryPath, $"{safeId}.json");
|
||
}
|
||
|
||
private string SanitizeFileComponent(string value)
|
||
{
|
||
if (string.IsNullOrEmpty(value))
|
||
{
|
||
return "unknown";
|
||
}
|
||
|
||
var invalidChars = new HashSet<char>(Path.GetInvalidFileNameChars());
|
||
var builder = new StringBuilder(value.Length);
|
||
foreach (char c in value)
|
||
{
|
||
if (invalidChars.Contains(c))
|
||
{
|
||
builder.Append('_');
|
||
}
|
||
else
|
||
{
|
||
builder.Append(c);
|
||
}
|
||
}
|
||
|
||
return builder.Length == 0 ? "unknown" : builder.ToString();
|
||
}
|
||
|
||
private void DeleteHistoryRecordFile(BFITestRecord record)
|
||
{
|
||
if (record == null || string.IsNullOrEmpty(record.TestId))
|
||
{
|
||
return;
|
||
}
|
||
|
||
DeleteHistoryRecordFile(record.TestId);
|
||
}
|
||
|
||
private void DeleteHistoryRecordFile(string testId)
|
||
{
|
||
string filePath = GetHistoryRecordFilePath(testId);
|
||
DeleteFileIfExists(filePath);
|
||
DeleteFileIfExists(filePath + RECORD_BACKUP_EXTENSION);
|
||
DeleteFileIfExists(filePath + ".tmp");
|
||
}
|
||
|
||
private void AddRecordsToMergeMap(Dictionary<string, BFITestRecord> recordsById, IEnumerable<BFITestRecord> records)
|
||
{
|
||
if (records == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
foreach (var record in records)
|
||
{
|
||
AddOrReplaceRecoveredRecord(recordsById, record);
|
||
}
|
||
}
|
||
|
||
private void DeleteAllHistoryStorageFiles()
|
||
{
|
||
var pathsToDelete = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
|
||
AddHistoryFileDeleteTargets(pathsToDelete, historyFilePath);
|
||
AddHistoryFileDeleteTargets(pathsToDelete, historyMirrorFilePath);
|
||
|
||
var indexPaths = new List<string>();
|
||
AddIndexPath(indexPaths, historyFilePath);
|
||
AddIndexPath(indexPaths, historyMirrorFilePath);
|
||
|
||
foreach (var indexPath in FindHistoryIndexFiles(true))
|
||
{
|
||
AddIndexPath(indexPaths, indexPath);
|
||
AddHistoryFileDeleteTargets(pathsToDelete, indexPath);
|
||
}
|
||
|
||
foreach (var filePath in pathsToDelete)
|
||
{
|
||
DeleteFileIfExists(filePath);
|
||
}
|
||
|
||
foreach (var indexPath in indexPaths)
|
||
{
|
||
DeleteRecordDirectoryForIndex(indexPath);
|
||
}
|
||
|
||
DeleteAllRecordDirectoriesFromSearchRoots();
|
||
}
|
||
|
||
private void AddIndexPath(List<string> indexPaths, string indexPath)
|
||
{
|
||
if (string.IsNullOrEmpty(indexPath))
|
||
{
|
||
return;
|
||
}
|
||
|
||
if (!indexPaths.Any(path => string.Equals(path, indexPath, StringComparison.OrdinalIgnoreCase)))
|
||
{
|
||
indexPaths.Add(indexPath);
|
||
}
|
||
}
|
||
|
||
private void AddHistoryFileDeleteTargets(HashSet<string> pathsToDelete, string indexFilePath)
|
||
{
|
||
if (string.IsNullOrEmpty(indexFilePath))
|
||
{
|
||
return;
|
||
}
|
||
|
||
pathsToDelete.Add(indexFilePath);
|
||
pathsToDelete.Add(indexFilePath + ".tmp");
|
||
pathsToDelete.Add(indexFilePath + RECORD_BACKUP_EXTENSION);
|
||
|
||
string directory = Path.GetDirectoryName(indexFilePath);
|
||
if (!string.IsNullOrEmpty(directory))
|
||
{
|
||
pathsToDelete.Add(Path.Combine(directory, HISTORY_BACKUP_FILE_NAME));
|
||
pathsToDelete.Add(Path.Combine(directory, CURRENT_RECORDING_JOURNAL_FILE_NAME));
|
||
}
|
||
}
|
||
|
||
private void DeleteRecordDirectoryForIndex(string indexFilePath)
|
||
{
|
||
try
|
||
{
|
||
string recordsDirectory = GetRecordFilesDirectory(indexFilePath);
|
||
if (!string.IsNullOrEmpty(recordsDirectory) && Directory.Exists(recordsDirectory))
|
||
{
|
||
Directory.Delete(recordsDirectory, true);
|
||
Debug.Log($"已删除BFI单条记录目录: {recordsDirectory}");
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.LogWarning($"删除BFI单条记录目录失败: {indexFilePath}, {ex.Message}");
|
||
}
|
||
}
|
||
|
||
private void DeleteAllRecordDirectoriesFromSearchRoots()
|
||
{
|
||
foreach (var root in GetHistoryIndexSearchRoots())
|
||
{
|
||
DeleteRecordDirectory(root);
|
||
TryDeleteRecordDirectoriesOneLevel(root);
|
||
}
|
||
}
|
||
|
||
private void TryDeleteRecordDirectoriesOneLevel(string root)
|
||
{
|
||
try
|
||
{
|
||
if (string.IsNullOrEmpty(root) || !Directory.Exists(root))
|
||
{
|
||
return;
|
||
}
|
||
|
||
foreach (var directory in Directory.GetDirectories(root))
|
||
{
|
||
DeleteRecordDirectory(directory);
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.LogWarning($"搜索待删除BFI单条记录目录失败: {root}, {ex.Message}");
|
||
}
|
||
}
|
||
|
||
private void DeleteRecordDirectory(string root)
|
||
{
|
||
try
|
||
{
|
||
if (string.IsNullOrEmpty(root))
|
||
{
|
||
return;
|
||
}
|
||
|
||
string recordsDirectory = Path.Combine(root, HISTORY_RECORDS_DIR_NAME);
|
||
if (Directory.Exists(recordsDirectory))
|
||
{
|
||
Directory.Delete(recordsDirectory, true);
|
||
Debug.Log($"已删除BFI单条记录目录: {recordsDirectory}");
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.LogWarning($"删除BFI单条记录目录失败: {root}, {ex.Message}");
|
||
}
|
||
}
|
||
|
||
private void DeleteFileIfExists(string filePath)
|
||
{
|
||
try
|
||
{
|
||
if (!string.IsNullOrEmpty(filePath) && File.Exists(filePath))
|
||
{
|
||
File.Delete(filePath);
|
||
Debug.Log($"已删除BFI历史文件: {filePath}");
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.LogWarning($"删除BFI历史文件失败: {filePath}, {ex.Message}");
|
||
}
|
||
}
|
||
|
||
private void WriteAllTextAtomic(string filePath, string content)
|
||
{
|
||
string directory = Path.GetDirectoryName(filePath);
|
||
if (!string.IsNullOrEmpty(directory) && !Directory.Exists(directory))
|
||
{
|
||
Directory.CreateDirectory(directory);
|
||
}
|
||
|
||
string tempPath = filePath + ".tmp";
|
||
string backupPath = filePath + RECORD_BACKUP_EXTENSION;
|
||
byte[] bytes = Encoding.UTF8.GetBytes(content ?? string.Empty);
|
||
EnsureEnoughFreeSpace(filePath, bytes.Length);
|
||
|
||
DeleteFileIfExists(tempPath);
|
||
|
||
using (var stream = new FileStream(tempPath, FileMode.Create, FileAccess.Write, FileShare.Read, 4096))
|
||
{
|
||
stream.Write(bytes, 0, bytes.Length);
|
||
FlushFileStream(stream);
|
||
}
|
||
|
||
if (File.Exists(filePath))
|
||
{
|
||
try
|
||
{
|
||
TryCopyFile(filePath, backupPath);
|
||
File.Delete(filePath);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.LogWarning($"备份旧BFI历史文件失败，将继续尝试覆盖: {filePath}, {ex.Message}");
|
||
DeleteFileIfExists(filePath);
|
||
}
|
||
}
|
||
|
||
File.Move(tempPath, filePath);
|
||
}
|
||
|
||
private void FlushFileStream(FileStream stream)
|
||
{
|
||
try
|
||
{
|
||
stream.Flush(true);
|
||
}
|
||
catch
|
||
{
|
||
stream.Flush();
|
||
}
|
||
}
|
||
|
||
private void TryCopyFile(string sourcePath, string targetPath)
|
||
{
|
||
try
|
||
{
|
||
if (!string.IsNullOrEmpty(sourcePath) && File.Exists(sourcePath))
|
||
{
|
||
File.Copy(sourcePath, targetPath, true);
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.LogWarning($"备份BFI历史文件失败: {sourcePath}, {ex.Message}");
|
||
}
|
||
}
|
||
|
||
private void EnsureEnoughFreeSpace(string filePath, long requiredBytes)
|
||
{
|
||
#if UNITY_ANDROID && !UNITY_EDITOR
|
||
// Android 的 /storage/emulated/0 路径在部分系统上通过 DriveInfo 会返回 0MB，
|
||
// 但实际 FileStream 仍然可以写入。这里不做硬拦截，真实空间不足交给实际写入报错。
|
||
return;
|
||
#else
|
||
try
|
||
{
|
||
string root = Path.GetPathRoot(Path.GetFullPath(filePath));
|
||
if (string.IsNullOrEmpty(root))
|
||
{
|
||
return;
|
||
}
|
||
|
||
var drive = new DriveInfo(root);
|
||
const long safetyReserveBytes = 10L * 1024L * 1024L;
|
||
long availableFreeSpace = drive.AvailableFreeSpace;
|
||
if (availableFreeSpace <= 0)
|
||
{
|
||
Debug.LogWarning($"无法可靠获取BFI历史存储剩余空间，将继续尝试写入: {filePath}");
|
||
return;
|
||
}
|
||
|
||
if (drive.IsReady && availableFreeSpace < requiredBytes + safetyReserveBytes)
|
||
{
|
||
throw new IOException($"BFI历史存储空间不足，剩余 {availableFreeSpace / 1024 / 1024}MB，需要至少 {(requiredBytes + safetyReserveBytes) / 1024 / 1024}MB");
|
||
}
|
||
}
|
||
catch (IOException)
|
||
{
|
||
throw;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.LogWarning($"检查BFI历史存储空间失败，将继续尝试写入: {ex.Message}");
|
||
}
|
||
#endif
|
||
}
|
||
|
||
private string GetRecordFilesDirectory(string indexFilePath)
|
||
{
|
||
if (string.IsNullOrEmpty(indexFilePath))
|
||
{
|
||
return null;
|
||
}
|
||
|
||
string indexDirectory = Path.GetDirectoryName(indexFilePath);
|
||
return string.IsNullOrEmpty(indexDirectory) ? null : Path.Combine(indexDirectory, HISTORY_RECORDS_DIR_NAME);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 从文件加载历史记录
|
||
/// </summary>
|
||
public void LoadHistoryRecords(bool notifyListeners = true, bool recoverMissingIndex = true)
|
||
{
|
||
try
|
||
{
|
||
maxHistoryRecords = Mathf.Max(maxHistoryRecords, MIN_HISTORY_RECORD_LIMIT);
|
||
|
||
if (!File.Exists(historyFilePath))
|
||
{
|
||
historyRecords = SafeRecoverHistoryRecordsFromIndexes(null, recoverMissingIndex);
|
||
historyFileLoadFailed = false;
|
||
Debug.Log($"历史索引文件不存在，{(historyRecords.Count > 0 ? "已从单条记录文件恢复" : "创建新列表")}");
|
||
if (historyRecords.Count > 0)
|
||
{
|
||
SaveHistoryRecords();
|
||
}
|
||
if (notifyListeners)
|
||
{
|
||
OnHistoryLoaded?.Invoke();
|
||
}
|
||
return;
|
||
}
|
||
|
||
if (TryReadHistoryRecords(historyFilePath, out var loadedRecords))
|
||
{
|
||
historyRecords = loadedRecords;
|
||
historyFileLoadFailed = false;
|
||
Debug.Log($"历史索引已加载，共 {historyRecords.Count} 条记录");
|
||
}
|
||
else
|
||
{
|
||
if (historyRecords == null)
|
||
{
|
||
historyRecords = new List<BFITestRecord>();
|
||
}
|
||
historyFileLoadFailed = false;
|
||
Debug.Log($"历史索引为空或无法解析，保留内存记录 {historyRecords.Count} 条");
|
||
}
|
||
|
||
int beforeCount = historyRecords.Count;
|
||
historyRecords = SafeRecoverHistoryRecordsFromIndexes(historyRecords, recoverMissingIndex);
|
||
if (historyRecords.Count != beforeCount || !AreAllHistoryRecordsPersistedAsFiles())
|
||
{
|
||
Debug.Log($"历史记录文件恢复完成，恢复前 {beforeCount} 条，恢复后 {historyRecords.Count} 条");
|
||
SaveHistoryRecords();
|
||
}
|
||
|
||
if (notifyListeners)
|
||
{
|
||
OnHistoryLoaded?.Invoke();
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.LogError($"加载历史记录失败: {ex.Message}");
|
||
historyRecords = SafeRecoverHistoryRecordsFromIndexes(null, recoverMissingIndex);
|
||
historyFileLoadFailed = historyRecords.Count == 0;
|
||
|
||
if (historyRecords.Count > 0)
|
||
{
|
||
SaveHistoryRecords();
|
||
if (notifyListeners)
|
||
{
|
||
OnHistoryLoaded?.Invoke();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
private List<BFITestRecord> SafeRecoverHistoryRecordsFromIndexes(List<BFITestRecord> baseRecords, bool includeSearchRoots)
|
||
{
|
||
try
|
||
{
|
||
return RecoverHistoryRecordsFromIndexes(baseRecords, includeSearchRoots);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.LogError($"恢复BFI历史索引失败: {ex.Message}");
|
||
return baseRecords != null ? new List<BFITestRecord>(baseRecords) : new List<BFITestRecord>();
|
||
}
|
||
}
|
||
|
||
private List<BFITestRecord> RecoverHistoryRecordsFromIndexes(List<BFITestRecord> baseRecords, bool includeSearchRoots)
|
||
{
|
||
var mergedRecords = new Dictionary<string, BFITestRecord>();
|
||
|
||
if (baseRecords != null)
|
||
{
|
||
foreach (var record in baseRecords)
|
||
{
|
||
AddOrReplaceRecoveredRecord(mergedRecords, record);
|
||
}
|
||
}
|
||
|
||
foreach (var indexPath in FindHistoryIndexFiles(includeSearchRoots))
|
||
{
|
||
if (!TryReadHistoryRecords(indexPath, out var recoveredRecords))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
foreach (var record in recoveredRecords)
|
||
{
|
||
AddOrReplaceRecoveredRecord(mergedRecords, record);
|
||
}
|
||
}
|
||
|
||
foreach (var recordFilePath in FindHistoryRecordFiles(includeSearchRoots))
|
||
{
|
||
if (TryReadHistoryRecord(recordFilePath, out var recoveredRecord))
|
||
{
|
||
AddOrReplaceRecoveredRecord(mergedRecords, recoveredRecord);
|
||
}
|
||
}
|
||
|
||
return mergedRecords.Values
|
||
.OrderByDescending(r => r.StartTime)
|
||
.Take(maxHistoryRecords)
|
||
.OrderBy(r => r.StartTime)
|
||
.ToList();
|
||
}
|
||
|
||
private bool TryReadHistoryRecords(string filePath, out List<BFITestRecord> records)
|
||
{
|
||
records = new List<BFITestRecord>();
|
||
|
||
try
|
||
{
|
||
if (string.IsNullOrEmpty(filePath) || !File.Exists(filePath))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
string json = File.ReadAllText(filePath);
|
||
if (string.IsNullOrWhiteSpace(json))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
var wrapper = JsonUtility.FromJson<BFIHistoryWrapper>(json);
|
||
if (wrapper == null)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
bool recognizedIndex = false;
|
||
if (wrapper.Records != null)
|
||
{
|
||
recognizedIndex = true;
|
||
foreach (var record in wrapper.Records.Where(record => record != null))
|
||
{
|
||
NormalizeRecordForStorage(record);
|
||
records.Add(record);
|
||
}
|
||
}
|
||
|
||
if (wrapper.RecordFiles != null)
|
||
{
|
||
recognizedIndex = true;
|
||
foreach (var entry in wrapper.RecordFiles.Where(entry => entry != null))
|
||
{
|
||
string recordPath = ResolveIndexedRecordPath(filePath, entry);
|
||
if (TryReadHistoryRecord(recordPath, out var record))
|
||
{
|
||
AddOrReplaceRecoveredRecordToList(records, record);
|
||
}
|
||
}
|
||
}
|
||
|
||
if (!recognizedIndex)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
Debug.Log($"读取BFI历史索引成功: {filePath}, 记录数: {records.Count}");
|
||
return true;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.LogWarning($"读取BFI历史索引失败: {filePath}, {ex.Message}");
|
||
records = new List<BFITestRecord>();
|
||
return false;
|
||
}
|
||
}
|
||
|
||
private bool TryReadHistoryRecordSummaries(string filePath, out List<BFITestRecord> records, out bool repairedSummaries)
|
||
{
|
||
records = new List<BFITestRecord>();
|
||
repairedSummaries = false;
|
||
|
||
try
|
||
{
|
||
if (string.IsNullOrEmpty(filePath) || !File.Exists(filePath))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
string json = File.ReadAllText(filePath);
|
||
if (string.IsNullOrWhiteSpace(json))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
var wrapper = JsonUtility.FromJson<BFIHistoryWrapper>(json);
|
||
if (wrapper == null)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
if (wrapper.RecordFiles != null && wrapper.RecordFiles.Count > 0)
|
||
{
|
||
foreach (var entry in wrapper.RecordFiles.Where(entry => entry != null))
|
||
{
|
||
var summary = CreateSummaryRecordFromIndexEntry(entry, filePath);
|
||
if (summary != null)
|
||
{
|
||
if (NeedsSummaryRepair(summary) && TryRepairSummaryFromRecordFile(summary, out var repairedSummary))
|
||
{
|
||
summary = repairedSummary;
|
||
repairedSummaries = true;
|
||
}
|
||
|
||
AddOrReplaceRecoveredRecordToList(records, summary);
|
||
}
|
||
}
|
||
|
||
Debug.Log($"读取BFI历史摘要成功: {filePath}, 记录数: {records.Count}");
|
||
return true;
|
||
}
|
||
|
||
if (wrapper.Records != null)
|
||
{
|
||
foreach (var record in wrapper.Records.Where(record => record != null))
|
||
{
|
||
NormalizeRecordForStorage(record);
|
||
records.Add(record);
|
||
}
|
||
|
||
Debug.Log($"读取旧版BFI历史摘要成功: {filePath}, 记录数: {records.Count}");
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.LogWarning($"读取BFI历史摘要失败: {filePath}, {ex.Message}");
|
||
records = new List<BFITestRecord>();
|
||
repairedSummaries = false;
|
||
return false;
|
||
}
|
||
}
|
||
|
||
private bool NeedsSummaryRepair(BFITestRecord summary)
|
||
{
|
||
if (summary == null)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
if (summary.DataPoints != null && summary.DataPoints.Count > 0)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
var stats = summary.Statistics;
|
||
if (stats == null || stats.Count <= 0)
|
||
{
|
||
return true;
|
||
}
|
||
|
||
return Mathf.Approximately(stats.MinValue, 0f) &&
|
||
Mathf.Approximately(stats.MaxValue, 0f) &&
|
||
Mathf.Approximately(stats.Average, 0f);
|
||
}
|
||
|
||
private bool TryRepairSummaryFromRecordFile(BFITestRecord summary, out BFITestRecord repairedSummary)
|
||
{
|
||
repairedSummary = null;
|
||
string recordPath = summary?.FilePath;
|
||
if (string.IsNullOrEmpty(recordPath))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
if (!TryReadHistoryRecord(recordPath, out var fullRecord) ||
|
||
fullRecord?.DataPoints == null ||
|
||
fullRecord.DataPoints.Count == 0)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
fullRecord.FilePath = recordPath;
|
||
repairedSummary = CreateSummaryRecordFromFullRecord(fullRecord);
|
||
Debug.Log($"已从实体文件修复BFI历史摘要: {fullRecord.TestName}, 点数: {fullRecord.DataPoints.Count}");
|
||
return true;
|
||
}
|
||
|
||
private BFITestRecord CreateSummaryRecordFromFullRecord(BFITestRecord fullRecord)
|
||
{
|
||
if (fullRecord == null)
|
||
{
|
||
return null;
|
||
}
|
||
|
||
NormalizeRecordForStorage(fullRecord);
|
||
return new BFITestRecord
|
||
{
|
||
TestId = fullRecord.TestId,
|
||
TestName = fullRecord.TestName,
|
||
PatientId = fullRecord.PatientId ?? string.Empty,
|
||
PatientName = fullRecord.PatientName ?? string.Empty,
|
||
PatientGender = fullRecord.PatientGender ?? string.Empty,
|
||
PatientAge = fullRecord.PatientAge,
|
||
PatientHeight = fullRecord.PatientHeight,
|
||
PatientWeight = fullRecord.PatientWeight,
|
||
StartTime = fullRecord.StartTime,
|
||
StartTimeTicks = fullRecord.StartTimeTicks,
|
||
EndTime = fullRecord.EndTime,
|
||
EndTimeTicks = fullRecord.EndTimeTicks,
|
||
FilePath = fullRecord.FilePath,
|
||
DataPoints = new List<BFIDataPoint>(),
|
||
Statistics = CloneBFIStatistics(fullRecord.Statistics)
|
||
};
|
||
}
|
||
|
||
private BFITestRecord CreateSummaryRecordFromIndexEntry(BFIHistoryRecordIndexEntry entry, string indexFilePath)
|
||
{
|
||
if (entry == null)
|
||
{
|
||
return null;
|
||
}
|
||
|
||
long startTicks = entry.StartTimeTicks > 0 ? entry.StartTimeTicks : DateTime.Now.Ticks;
|
||
long endTicks = entry.EndTimeTicks > 0 ? entry.EndTimeTicks : 0;
|
||
var startTime = new DateTime(startTicks, DateTimeKind.Local);
|
||
var endTime = endTicks > 0 ? new DateTime(endTicks, DateTimeKind.Local) : DateTime.MinValue;
|
||
|
||
var record = new BFITestRecord
|
||
{
|
||
TestId = string.IsNullOrEmpty(entry.TestId) ? Guid.NewGuid().ToString() : entry.TestId,
|
||
TestName = string.IsNullOrEmpty(entry.TestName) ? $"BFI测试_{startTime:yyyyMMdd_HHmmss}" : entry.TestName,
|
||
PatientId = entry.PatientId ?? string.Empty,
|
||
PatientName = entry.PatientName ?? string.Empty,
|
||
StartTime = startTime,
|
||
StartTimeTicks = startTicks,
|
||
EndTime = endTime,
|
||
EndTimeTicks = endTicks,
|
||
FilePath = ResolveIndexedRecordPath(indexFilePath, entry),
|
||
DataPoints = new List<BFIDataPoint>(),
|
||
Statistics = new BFIStatistics
|
||
{
|
||
Count = entry.PointCount,
|
||
MinValue = entry.MinValue,
|
||
MaxValue = entry.MaxValue,
|
||
Average = entry.Average,
|
||
Duration = endTime > startTime ? (endTime - startTime).TotalMinutes : 0,
|
||
LastUpdated = DateTime.Now
|
||
}
|
||
};
|
||
|
||
return record;
|
||
}
|
||
|
||
private void AddOrReplaceRecoveredRecordToList(List<BFITestRecord> records, BFITestRecord record)
|
||
{
|
||
if (records == null || record == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
NormalizeRecordForStorage(record);
|
||
var existingRecord = records.FirstOrDefault(r => r != null && r.TestId == record.TestId);
|
||
if (existingRecord == null)
|
||
{
|
||
records.Add(record);
|
||
return;
|
||
}
|
||
|
||
if (ShouldReplaceRecord(existingRecord, record))
|
||
{
|
||
int index = records.IndexOf(existingRecord);
|
||
records[index] = record;
|
||
return;
|
||
}
|
||
|
||
MergeRecordMetadata(existingRecord, record);
|
||
}
|
||
|
||
private void MergeRecordMetadata(BFITestRecord target, BFITestRecord source)
|
||
{
|
||
if (target == null || source == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
if (string.IsNullOrEmpty(target.FilePath) && !string.IsNullOrEmpty(source.FilePath))
|
||
{
|
||
target.FilePath = source.FilePath;
|
||
}
|
||
|
||
bool targetHasFullData = target.DataPoints != null && target.DataPoints.Count > 0;
|
||
bool sourceHasSummaryStats = source.Statistics != null && source.Statistics.Count > 0;
|
||
if (!targetHasFullData && sourceHasSummaryStats)
|
||
{
|
||
target.Statistics = CloneBFIStatistics(source.Statistics);
|
||
}
|
||
}
|
||
|
||
private string ResolveIndexedRecordPath(string indexFilePath, BFIHistoryRecordIndexEntry entry)
|
||
{
|
||
if (entry == null)
|
||
{
|
||
return null;
|
||
}
|
||
|
||
if (!string.IsNullOrEmpty(entry.FileName) && Path.IsPathRooted(entry.FileName))
|
||
{
|
||
return entry.FileName;
|
||
}
|
||
|
||
string recordsDirectory = GetRecordFilesDirectory(indexFilePath);
|
||
if (string.IsNullOrEmpty(recordsDirectory))
|
||
{
|
||
recordsDirectory = historyRecordsDirectoryPath;
|
||
}
|
||
|
||
string fileName = entry.FileName;
|
||
if (string.IsNullOrEmpty(fileName))
|
||
{
|
||
fileName = $"{SanitizeFileComponent(entry.TestId)}.json";
|
||
}
|
||
|
||
return Path.Combine(recordsDirectory, fileName);
|
||
}
|
||
|
||
private bool TryReadHistoryRecord(string filePath, out BFITestRecord record)
|
||
{
|
||
if (TryReadHistoryRecordFile(filePath, out record))
|
||
{
|
||
return true;
|
||
}
|
||
|
||
if (!string.IsNullOrEmpty(filePath) &&
|
||
!filePath.EndsWith(RECORD_BACKUP_EXTENSION, StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
string backupPath = filePath + RECORD_BACKUP_EXTENSION;
|
||
if (TryReadHistoryRecordFile(backupPath, out record))
|
||
{
|
||
Debug.LogWarning($"使用BFI单条记录备份恢复: {backupPath}");
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
private bool TryReadHistoryRecordFile(string filePath, out BFITestRecord record)
|
||
{
|
||
record = null;
|
||
|
||
try
|
||
{
|
||
if (string.IsNullOrEmpty(filePath) || !File.Exists(filePath))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
string json = File.ReadAllText(filePath);
|
||
if (string.IsNullOrWhiteSpace(json))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
record = JsonUtility.FromJson<BFITestRecord>(json);
|
||
if (record == null)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
record.RestoreAfterDeserialization();
|
||
NormalizeRecordForStorage(record);
|
||
return true;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.LogWarning($"读取BFI单条记录失败: {filePath}, {ex.Message}");
|
||
record = null;
|
||
return false;
|
||
}
|
||
}
|
||
|
||
private void AddOrReplaceRecoveredRecord(Dictionary<string, BFITestRecord> recordsById, BFITestRecord record)
|
||
{
|
||
if (record == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
NormalizeRecordForStorage(record);
|
||
|
||
if (!recordsById.TryGetValue(record.TestId, out var existingRecord))
|
||
{
|
||
recordsById[record.TestId] = record;
|
||
return;
|
||
}
|
||
|
||
if (ShouldReplaceRecord(existingRecord, record))
|
||
{
|
||
recordsById[record.TestId] = record;
|
||
return;
|
||
}
|
||
|
||
MergeRecordMetadata(existingRecord, record);
|
||
}
|
||
|
||
private List<string> FindHistoryIndexFiles(bool includeSearchRoots)
|
||
{
|
||
var result = new List<string>();
|
||
var visited = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
|
||
|
||
AddHistoryIndexFilesFromRoot(Path.GetDirectoryName(historyFilePath), 0, result, visited);
|
||
|
||
if (includeSearchRoots)
|
||
{
|
||
foreach (var root in GetHistoryIndexSearchRoots())
|
||
{
|
||
AddHistoryIndexFilesFromRoot(root, 2, result, visited);
|
||
}
|
||
}
|
||
|
||
Debug.Log($"BFI历史索引搜索完成，找到 {result.Count} 个候选文件");
|
||
return result;
|
||
}
|
||
|
||
private List<string> FindHistoryRecordFiles(bool includeSearchRoots)
|
||
{
|
||
var result = new List<string>();
|
||
var visited = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
|
||
|
||
AddHistoryRecordFilesFromDirectory(historyRecordsDirectoryPath, result, visited);
|
||
|
||
if (includeSearchRoots)
|
||
{
|
||
foreach (var root in GetHistoryIndexSearchRoots())
|
||
{
|
||
AddHistoryRecordFilesFromDirectory(Path.Combine(root, HISTORY_RECORDS_DIR_NAME), result, visited);
|
||
}
|
||
}
|
||
|
||
Debug.Log($"BFI单条历史记录搜索完成，找到 {result.Count} 个候选文件");
|
||
return result;
|
||
}
|
||
|
||
private void AddHistoryRecordFilesFromDirectory(string directory, List<string> result, HashSet<string> visited)
|
||
{
|
||
if (string.IsNullOrEmpty(directory))
|
||
{
|
||
return;
|
||
}
|
||
|
||
try
|
||
{
|
||
if (!Directory.Exists(directory))
|
||
{
|
||
return;
|
||
}
|
||
|
||
string fullDirectory = Path.GetFullPath(directory);
|
||
if (!visited.Add(fullDirectory))
|
||
{
|
||
return;
|
||
}
|
||
|
||
AddHistoryRecordFilesByPattern(fullDirectory, "*.json", result);
|
||
AddHistoryRecordFilesByPattern(fullDirectory, "*.json" + RECORD_BACKUP_EXTENSION, result);
|
||
AddHistoryRecordFilesByPattern(fullDirectory, "*.json.tmp", result);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.LogWarning($"搜索BFI单条历史记录目录失败: {directory}, {ex.Message}");
|
||
}
|
||
}
|
||
|
||
private void AddHistoryRecordFilesByPattern(string directory, string pattern, List<string> result)
|
||
{
|
||
foreach (var filePath in Directory.GetFiles(directory, pattern))
|
||
{
|
||
if (!result.Any(path => string.Equals(path, filePath, StringComparison.OrdinalIgnoreCase)))
|
||
{
|
||
result.Add(filePath);
|
||
}
|
||
}
|
||
}
|
||
|
||
public List<BFITestRecord> LoadHistoryRecordSummaries(bool recoverMissingIndex = false)
|
||
{
|
||
maxHistoryRecords = Mathf.Max(maxHistoryRecords, MIN_HISTORY_RECORD_LIMIT);
|
||
|
||
try
|
||
{
|
||
if (TryReadHistoryRecordSummaries(historyFilePath, out var summaries, out bool repairedSummaries))
|
||
{
|
||
historyRecords = GetRecordsSortedByRecentFirst(summaries)
|
||
.Take(maxHistoryRecords)
|
||
.ToList();
|
||
historyFileLoadFailed = false;
|
||
if (repairedSummaries)
|
||
{
|
||
Debug.Log("检测到BFI历史摘要缺少明细统计，已从实体文件修复并刷新索引");
|
||
SaveHistoryIndex();
|
||
}
|
||
return GetAllRecords();
|
||
}
|
||
|
||
LoadHistoryRecords(false, recoverMissingIndex);
|
||
return GetAllRecords();
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.LogWarning($"加载BFI历史摘要失败，回退完整加载: {ex.Message}");
|
||
LoadHistoryRecords(false, recoverMissingIndex);
|
||
return GetAllRecords();
|
||
}
|
||
}
|
||
|
||
private IEnumerable<string> GetHistoryIndexSearchRoots()
|
||
{
|
||
var roots = new List<string>();
|
||
AddSearchRoot(roots, Path.GetDirectoryName(historyFilePath));
|
||
if (!string.IsNullOrEmpty(historyMirrorFilePath))
|
||
{
|
||
AddSearchRoot(roots, Path.GetDirectoryName(historyMirrorFilePath));
|
||
}
|
||
AddSearchRoot(roots, Application.persistentDataPath);
|
||
AddSearchRoot(roots, Path.Combine(Application.dataPath, "..", "Exports"));
|
||
AddSearchRoot(roots, Path.Combine(Application.dataPath, "Exports"));
|
||
|
||
#if UNITY_ANDROID && !UNITY_EDITOR
|
||
AddSearchRoot(roots, AndroidExportPermissionManager.GetStableAppInternalDirectory());
|
||
AddSearchRoot(roots, GetAndroidFilesDirectory());
|
||
AddSearchRoot(roots, GetAndroidExternalFilesDirectory(null));
|
||
AddSearchRoot(roots, GetAndroidExternalFilesDirectory("Documents"));
|
||
string downloadDirectory = GetAndroidDownloadDirectory();
|
||
AddSearchRoot(roots, downloadDirectory);
|
||
if (!string.IsNullOrEmpty(downloadDirectory))
|
||
{
|
||
AddSearchRoot(roots, Path.Combine(downloadDirectory, "DCX_Export"));
|
||
}
|
||
#endif
|
||
|
||
return roots;
|
||
}
|
||
|
||
private void AddSearchRoot(List<string> roots, string root)
|
||
{
|
||
if (string.IsNullOrEmpty(root))
|
||
{
|
||
return;
|
||
}
|
||
|
||
try
|
||
{
|
||
string fullPath = Path.GetFullPath(root);
|
||
if (!roots.Any(existing => string.Equals(existing, fullPath, StringComparison.OrdinalIgnoreCase)))
|
||
{
|
||
roots.Add(fullPath);
|
||
}
|
||
}
|
||
catch
|
||
{
|
||
if (!roots.Contains(root))
|
||
{
|
||
roots.Add(root);
|
||
}
|
||
}
|
||
}
|
||
|
||
private void AddHistoryIndexFilesFromRoot(string root, int depth, List<string> result, HashSet<string> visited)
|
||
{
|
||
if (string.IsNullOrEmpty(root) || depth < 0)
|
||
{
|
||
return;
|
||
}
|
||
|
||
try
|
||
{
|
||
if (!Directory.Exists(root))
|
||
{
|
||
return;
|
||
}
|
||
|
||
string fullRoot = Path.GetFullPath(root);
|
||
if (!visited.Add(fullRoot))
|
||
{
|
||
return;
|
||
}
|
||
|
||
foreach (var candidateFileName in HISTORY_CANDIDATE_FILE_NAMES)
|
||
{
|
||
string directFile = Path.Combine(fullRoot, candidateFileName);
|
||
if (File.Exists(directFile) && !result.Any(path => string.Equals(path, directFile, StringComparison.OrdinalIgnoreCase)))
|
||
{
|
||
result.Add(directFile);
|
||
}
|
||
|
||
string backupFile = directFile + RECORD_BACKUP_EXTENSION;
|
||
if (File.Exists(backupFile) && !result.Any(path => string.Equals(path, backupFile, StringComparison.OrdinalIgnoreCase)))
|
||
{
|
||
result.Add(backupFile);
|
||
}
|
||
}
|
||
|
||
if (depth == 0)
|
||
{
|
||
return;
|
||
}
|
||
|
||
foreach (var directory in Directory.GetDirectories(fullRoot))
|
||
{
|
||
AddHistoryIndexFilesFromRoot(directory, depth - 1, result, visited);
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.LogWarning($"搜索BFI历史索引目录失败: {root}, {ex.Message}");
|
||
}
|
||
}
|
||
|
||
#if UNITY_ANDROID && !UNITY_EDITOR
|
||
private string GetAndroidFilesDirectory()
|
||
{
|
||
try
|
||
{
|
||
using (var unityClass = new AndroidJavaClass("com.unity3d.player.UnityPlayer"))
|
||
using (var activity = unityClass.GetStatic<AndroidJavaObject>("currentActivity"))
|
||
using (var context = activity.Call<AndroidJavaObject>("getApplicationContext"))
|
||
{
|
||
var filesDir = context.Call<AndroidJavaObject>("getFilesDir");
|
||
return filesDir?.Call<string>("getAbsolutePath");
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.LogWarning($"获取Android内部目录失败: {ex.Message}");
|
||
return null;
|
||
}
|
||
}
|
||
|
||
private string GetAndroidExternalFilesDirectory(string type)
|
||
{
|
||
try
|
||
{
|
||
using (var unityClass = new AndroidJavaClass("com.unity3d.player.UnityPlayer"))
|
||
using (var activity = unityClass.GetStatic<AndroidJavaObject>("currentActivity"))
|
||
using (var context = activity.Call<AndroidJavaObject>("getApplicationContext"))
|
||
{
|
||
var externalDir = context.Call<AndroidJavaObject>("getExternalFilesDir", type);
|
||
return externalDir?.Call<string>("getAbsolutePath");
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.LogWarning($"获取Android外部应用目录失败: {ex.Message}");
|
||
return null;
|
||
}
|
||
}
|
||
|
||
private string GetAndroidDownloadDirectory()
|
||
{
|
||
try
|
||
{
|
||
using (var environment = new AndroidJavaClass("android.os.Environment"))
|
||
using (var externalStorage = environment.CallStatic<AndroidJavaObject>("getExternalStorageDirectory"))
|
||
{
|
||
string storagePath = externalStorage?.Call<string>("getAbsolutePath");
|
||
return string.IsNullOrEmpty(storagePath) ? null : Path.Combine(storagePath, "Download");
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.LogWarning($"获取Android Download目录失败: {ex.Message}");
|
||
return null;
|
||
}
|
||
}
|
||
#endif
|
||
|
||
/// <summary>
|
||
/// 移除最旧的记录
|
||
/// </summary>
|
||
private void RemoveOldestRecord()
|
||
{
|
||
if (historyRecords.Count == 0) return;
|
||
|
||
var oldestRecord = historyRecords.OrderBy(r => r.StartTime).First();
|
||
historyRecords.Remove(oldestRecord);
|
||
DeleteHistoryRecordFile(oldestRecord);
|
||
Debug.Log($"移除最旧的记录: {oldestRecord.TestName}");
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取统计信息
|
||
/// </summary>
|
||
public BFIHistoryStatistics GetHistoryStatistics()
|
||
{
|
||
var stats = new BFIHistoryStatistics();
|
||
|
||
if (historyRecords == null || historyRecords.Count == 0)
|
||
return stats;
|
||
|
||
stats.TotalRecords = historyRecords.Count;
|
||
stats.TotalTestTime = historyRecords.Sum(r => r.GetDurationMinutes());
|
||
|
||
var today = DateTime.Today;
|
||
stats.TodayRecords = historyRecords.Count(r => r.StartTime.Date == today);
|
||
|
||
var thisWeek = today.AddDays(-(int)today.DayOfWeek);
|
||
stats.WeekRecords = historyRecords.Count(r => r.StartTime >= thisWeek);
|
||
|
||
var thisMonth = new DateTime(today.Year, today.Month, 1);
|
||
stats.MonthRecords = historyRecords.Count(r => r.StartTime >= thisMonth);
|
||
|
||
return stats;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 导出历史记录
|
||
/// </summary>
|
||
public bool ExportHistory(List<string> selectedRecordIds, ExportFormat format)
|
||
{
|
||
try
|
||
{
|
||
var selectedRecords = new List<BFITestRecord>();
|
||
|
||
if (selectedRecordIds == null || selectedRecordIds.Count == 0)
|
||
{
|
||
selectedRecords = GetAllRecords();
|
||
}
|
||
else
|
||
{
|
||
foreach (var id in selectedRecordIds)
|
||
{
|
||
var record = GetRecord(id);
|
||
if (record != null)
|
||
selectedRecords.Add(record);
|
||
}
|
||
}
|
||
|
||
if (selectedRecords.Count == 0)
|
||
{
|
||
Debug.LogWarning("没有可导出的记录");
|
||
return false;
|
||
}
|
||
|
||
var exportService = new DataExportService();
|
||
return exportService.ExportHistoryRecords(selectedRecords, format);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.LogError($"导出历史记录失败: {ex.Message}");
|
||
return false;
|
||
}
|
||
}
|
||
|
||
private void OnDestroy()
|
||
{
|
||
if (autoSave && historyRecords != null)
|
||
{
|
||
SaveHistoryIndex();
|
||
}
|
||
}
|
||
|
||
private void OnApplicationPause(bool pauseStatus)
|
||
{
|
||
if (pauseStatus && autoSave && historyIndexDirty)
|
||
{
|
||
SaveHistoryIndex();
|
||
}
|
||
}
|
||
|
||
private void OnApplicationFocus(bool hasFocus)
|
||
{
|
||
if (!hasFocus && autoSave && historyIndexDirty)
|
||
{
|
||
SaveHistoryIndex();
|
||
}
|
||
else if (hasFocus && historyRecords != null && historyRecords.Count == 0)
|
||
{
|
||
LoadHistoryRecords(true, false);
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 历史记录包装类（用于JSON序列化）
|
||
/// </summary>
|
||
[System.Serializable]
|
||
public class BFIHistoryWrapper
|
||
{
|
||
public int Version;
|
||
public string StorageMode;
|
||
public List<BFITestRecord> Records;
|
||
public List<BFIHistoryRecordIndexEntry> RecordFiles;
|
||
}
|
||
|
||
[System.Serializable]
|
||
public class BFIHistoryRecordIndexEntry
|
||
{
|
||
public string TestId;
|
||
public string TestName;
|
||
public string PatientId;
|
||
public string PatientName;
|
||
public string FileName;
|
||
public long StartTimeTicks;
|
||
public long EndTimeTicks;
|
||
public int PointCount;
|
||
public float MinValue;
|
||
public float MaxValue;
|
||
public float Average;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 历史记录统计信息
|
||
/// </summary>
|
||
[System.Serializable]
|
||
public class BFIHistoryStatistics
|
||
{
|
||
public int TotalRecords; // 总记录数
|
||
public double TotalTestTime; // 总测试时间（分钟）
|
||
public int TodayRecords; // 今日记录数
|
||
public int WeekRecords; // 本周记录数
|
||
public int MonthRecords; // 本月记录数
|
||
}
|