lxh2875931338/QingTing-Player
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

现在的问题比较大，因为metadata的引入导致原有的部分播放进度信息推送错误

Browse Source
This commit is contained in:
lxh2875931338
2026-08-23 20:29:31 +08:00
parent 9a60441e04
commit d593ce05a1
9 changed files with 203 additions and 167 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lib/metadata/file_provider.dart
+28
View File
@@ -0,0 +1,28 @@
// lib/metadata/file_provider.dart
import 'dart:io';
abstract class FileProvider {
/// 获取文件，如果是远程文件则先下载到本地缓存
Future<File?> getFile(String url);
}
class LocalFileProvider implements FileProvider {
@override
Future<File?> getFile(String url) async {
final file = File(url);
if (await file.exists()) {
return file;
}
return null;
}
}
class WebDAVFileProvider implements FileProvider {
@override
Future<File?> getFile(String url) async {
// 🔴 第一阶段：先不实现下载，返回 null
// 这样 WebDAV 文件会 fallback 到文件名
// 等核心播放逻辑稳定后，再实现真正的下载缓存
return null;
}
}
lib/metadata/metadata_cache.dart
-9
View File
@@ -1,35 +1,26 @@
// lib/metadata/metadata_cache.dart
import 'metadata_model.dart';
/// 本地缓存接口（先用内存缓存，后续升级为 SQLite）
class MetadataCache {
// 内存缓存：Map<fileId, FinalMetadata>
final Map<String, FinalMetadata> _cache = {};
/// 获取缓存
Future<FinalMetadata?> get(String fileId) async {
return _cache[fileId];
}
/// 存入缓存
Future<void> put(String fileId, FinalMetadata metadata) async {
_cache[fileId] = metadata;
}
/// 更新缓存（同 put）
Future<void> update(String fileId, FinalMetadata metadata) async {
_cache[fileId] = metadata;
}
/// 根据 artist 获取历史记录（用于证据收集）
/// 实际项目中需要从数据库查询，目前返回空列表
Future<List<Map<String, dynamic>>> getHistory(String artist,
{int limit = 10}) async {
// TODO: 从 SQLite 查询
return [];
}
/// 清空缓存
Future<void> clear() async {
_cache.clear();
}
lib/metadata/metadata_model.dart
+56 -54
View File
@@ -1,71 +1,74 @@
// lib/metadata/metadata_model.dart
import 'dart:typed_data';
/// 从音频文件读取的原始元数据（未经任何处理）
/// 从音频文件读取的原始元数据
class RawMetadata {
final String title;
final String artist;
final String album;
final String albumArtist;
final String composer;
final String genre;
final List<String> genres; // ⬅️ 改为 List<String>
final List<String> performers; // ⬅️ 新增
final int year;
final int trackNumber;
final int trackTotal;
final int discNumber;
final int totalDisc;
final Duration? duration;
final Uint8List? artwork;
const RawMetadata({
this.title = '',
this.artist = '',
this.album = '',
this.albumArtist = '',
this.composer = '',
this.genre = '',
this.genres = const [],
this.performers = const [],
this.year = 0,
this.trackNumber = 0,
this.trackTotal = 0,
this.discNumber = 0,
this.totalDisc = 0,
this.duration,
this.artwork,
});
/// 判断是否为空（没有任何有效信息）
bool get isEmpty =>
title.isEmpty &&
artist.isEmpty &&
album.isEmpty &&
albumArtist.isEmpty &&
composer.isEmpty &&
genre.isEmpty &&
year == 0 &&
trackNumber == 0 &&
discNumber == 0 &&
artwork == null;
genres.isEmpty &&
performers.isEmpty &&
year == 0;
bool get isNotEmpty => !isEmpty;
}
/// 经过标准化处理后的元数据
/// 标准化后的元数据
class NormalizedMetadata {
final String title;
final String artist;
final String album;
final String albumArtist;
final String composer;
final String genre;
final List<String> genres;
final List<String> performers;
final int year;
final int trackNumber;
final int trackTotal;
final int discNumber;
final int totalDisc;
final Duration? duration;
final Uint8List? artwork;
const NormalizedMetadata({
this.title = '',
this.artist = '',
this.album = '',
this.albumArtist = '',
this.composer = '',
this.genre = '',
this.genres = const [],
this.performers = const [],
this.year = 0,
this.trackNumber = 0,
this.trackTotal = 0,
this.discNumber = 0,
this.totalDisc = 0,
this.duration,
this.artwork,
});
@@ -73,54 +76,43 @@ class NormalizedMetadata {
title.isEmpty &&
artist.isEmpty &&
album.isEmpty &&
albumArtist.isEmpty &&
composer.isEmpty &&
genre.isEmpty &&
year == 0 &&
trackNumber == 0 &&
discNumber == 0 &&
artwork == null;
genres.isEmpty &&
performers.isEmpty &&
year == 0;
bool get isNotEmpty => !isEmpty;
}
/// 带置信度的候选元数据
class CandidateMetadata {
final NormalizedMetadata metadata;
final double confidence; // 0.0 ~ 1.0
final Map<String, double> evidence; // 证据来源权重
const CandidateMetadata({
required this.metadata,
required this.confidence,
this.evidence = const {},
});
}
/// 最终确认的元数据
class FinalMetadata {
final String title;
final String artist;
final String album;
final String albumArtist;
final String composer;
final String genre;
final String genre; // ⬅️ 简化为单个流派（取第一个）
final List<String> genres; // ⬅️ 保留完整列表
final List<String> performers;
final int year;
final int trackNumber;
final int trackTotal;
final int discNumber;
final int totalDisc;
final Duration? duration;
final Uint8List? artwork;
final String source; // 'file_tag', 'filename', 'cache', 'user_corrected'
final String source;
const FinalMetadata({
this.title = '',
this.artist = '',
this.album = '',
this.albumArtist = '',
this.composer = '',
this.genre = '',
this.genres = const [],
this.performers = const [],
this.year = 0,
this.trackNumber = 0,
this.trackTotal = 0,
this.discNumber = 0,
this.totalDisc = 0,
this.duration,
this.artwork,
this.source = 'unknown',
});
@@ -129,13 +121,23 @@ class FinalMetadata {
title.isEmpty &&
artist.isEmpty &&
album.isEmpty &&
albumArtist.isEmpty &&
composer.isEmpty &&
genre.isEmpty &&
year == 0 &&
trackNumber == 0 &&
discNumber == 0 &&
artwork == null;
genres.isEmpty &&
performers.isEmpty &&
year == 0;
bool get isNotEmpty => !isEmpty;
}
/// 候选元数据
class CandidateMetadata {
final NormalizedMetadata metadata;
final double confidence;
final Map<String, double> evidence;
const CandidateMetadata({
required this.metadata,
required this.confidence,
this.evidence = const {},
});
}
lib/metadata/metadata_normalizer.dart
+21 -17
View File
@@ -2,39 +2,43 @@
import 'metadata_model.dart';
class MetadataNormalizer {
/// 标准化原始数据（清洗空格、推断、fallback）
NormalizedMetadata normalize(RawMetadata raw,
{String fileName = '', String filePath = ''}) {
// 1. 修剪空格
final title = raw.title.trim();
final artist = raw.artist.trim();
final album = raw.album.trim();
final albumArtist = raw.albumArtist.trim();
// 2. 如果 title 为空，尝试从文件名推断
// 2. 如果 title 为空，从文件名推断
final finalTitle =
title.isNotEmpty ? title : _inferTitleFromFileName(fileName);
// 3. 如果 artist 为空，尝试从路径推断或使用默认值
// 3. 如果 artist 为空，从路径推断或使用默认值
final finalArtist =
artist.isNotEmpty ? artist : _inferArtistFromPath(filePath);
// 4. 如果 performers 不为空且 artist 为空，用 performers 的第一个
final finalArtist2 = finalArtist.isNotEmpty
? finalArtist
: (raw.performers.isNotEmpty ? raw.performers.first : '未知艺术家');
return NormalizedMetadata(
title: finalTitle,
artist: finalArtist,
artist: finalArtist2,
album: album,
albumArtist: albumArtist,
composer: raw.composer.trim(),
genre: raw.genre.trim(),
genres: raw.genres,
performers: raw.performers,
year: raw.year,
trackNumber: raw.trackNumber,
trackTotal: raw.trackTotal,
discNumber: raw.discNumber,
totalDisc: raw.totalDisc,
duration: raw.duration,
artwork: raw.artwork,
);
}
String _inferTitleFromFileName(String fileName) {
// 去掉扩展名
final dotIndex = fileName.lastIndexOf('.');
if (dotIndex > 0) {
return fileName.substring(0, dotIndex).trim();
@@ -43,10 +47,8 @@ class MetadataNormalizer {
}
String _inferArtistFromPath(String filePath) {
// 简单推断：尝试从路径中的文件夹名获取
final parts = filePath.split(RegExp(r'[/\\]'));
if (parts.length >= 2) {
// 倒数第二个文件夹可能是艺术家
final candidate = parts[parts.length - 2].trim();
if (candidate.isNotEmpty && !candidate.contains(' ')) {
return candidate;
@@ -55,10 +57,8 @@ class MetadataNormalizer {
return '未知艺术家';
}
/// 评估候选元数据（第一阶段：直接接受，不纠错）
CandidateMetadata evaluate(
NormalizedMetadata normalized, List<Map<String, dynamic>> history) {
// 第一阶段：置信度固定为 0.8（文件名+标签混合）
return CandidateMetadata(
metadata: normalized,
confidence: 0.8,
@@ -66,18 +66,22 @@ class MetadataNormalizer {
);
}
/// 决策是否修正（第一阶段：直接接受）
FinalMetadata decide(CandidateMetadata candidate, {double threshold = 0.6}) {
return FinalMetadata(
title: candidate.metadata.title,
artist: candidate.metadata.artist,
album: candidate.metadata.album,
albumArtist: candidate.metadata.albumArtist,
composer: candidate.metadata.composer,
genre: candidate.metadata.genre,
genre: candidate.metadata.genres.isNotEmpty
? candidate.metadata.genres.first
: '',
genres: candidate.metadata.genres,
performers: candidate.metadata.performers,
year: candidate.metadata.year,
trackNumber: candidate.metadata.trackNumber,
trackTotal: candidate.metadata.trackTotal,
discNumber: candidate.metadata.discNumber,
totalDisc: candidate.metadata.totalDisc,
duration: candidate.metadata.duration,
artwork: candidate.metadata.artwork,
source: 'normalized',
);
lib/metadata/metadata_reader.dart
+26 -17
View File
@@ -1,30 +1,39 @@
// lib/metadata/metadata_reader.dart
import 'dart:io';
import 'package:audio_metadata_reader/audio_metadata_reader.dart' as amr;
import 'metadata_model.dart';
/// 底层元数据读取器（封装 audio_metadata_reader）
class MetadataReader {
/// 从本地文件读取原始元数据
Future<RawMetadata> readRawMetadata(File file) async {
try {
// TODO: 安装 audio_metadata_reader 后实现
// final meta = await amr.readMetadata(file, getImage: false);
// return RawMetadata(
// title: meta.title ?? '',
// artist: meta.artist ?? '',
// album: meta.album ?? '',
// albumArtist: meta.albumArtist ?? '',
// composer: meta.composer ?? '',
// genre: meta.genre ?? '',
// year: meta.year ?? 0,
// trackNumber: meta.trackNumber ?? 0,
// discNumber: meta.discNumber ?? 0,
// );
final meta = amr.readMetadata(file, getImage: false);
// 临时返回空，等待接入 audio_metadata_reader
return const RawMetadata();
return RawMetadata(
title: meta.title ?? '',
artist: meta.artist ?? '',
album: meta.album ?? '',
// ⭐ genres 和 performers 是非空 List<String>，直接使用
genres: meta.genres,
performers: meta.performers,
year: _toInt(meta.year),
trackNumber: _toInt(meta.trackNumber),
trackTotal: _toInt(meta.trackTotal),
discNumber: _toInt(meta.discNumber),
totalDisc: _toInt(meta.totalDisc),
duration: meta.duration,
);
} catch (e) {
return const RawMetadata();
}
}
/// 安全转换为 int，处理 Object 类型
int _toInt(dynamic value) {
if (value == null) return 0;
if (value is int) return value;
if (value is String) return int.tryParse(value) ?? 0;
// 有些字段可能是 double 或 num
if (value is num) return value.toInt();
return 0;
}
}
lib/metadata/metadata_service.dart
+10 -37
View File
@@ -1,8 +1,5 @@
// lib/metadata/metadata_service.dart
import 'dart:io';
import 'metadata_model.dart';
import 'metadata_reader.dart';
import 'metadata_normalizer.dart';
import 'metadata_cache.dart';
class MetadataService {
@@ -10,18 +7,16 @@ class MetadataService {
factory MetadataService() => _instance;
MetadataService._internal();
final MetadataReader _reader = MetadataReader();
final MetadataNormalizer _normalizer = MetadataNormalizer();
final MetadataCache _cache = MetadataCache();
/// 获取歌曲的最终元数据（优先缓存，否则读取文件）
/// 临时版本：不进行实际文件读取，只返回基于文件名的 fallback
Future<FinalMetadata> getMetadata({
required String filePath,
required String url,
required String fileName,
required String fileId,
bool forceRefresh = false,
}) async {
// 1. 尝试从缓存读取
// 1. 检查缓存（如果有）
if (!forceRefresh) {
final cached = await _cache.get(fileId);
if (cached != null && cached.isNotEmpty) {
@@ -29,39 +24,17 @@ class MetadataService {
}
}
// 2. 检查文件是否存在
final file = File(filePath);
if (!await file.exists()) {
// 文件不存在，返回基于文件名的推断
return _fallbackFromFileName(fileName);
// 2. 暂时不读取文件，直接 fallback
final fallback = _fallbackFromFileName(fileName);
// 3. 缓存结果（即使 fallback 也缓存，避免频繁调用）
if (fallback.isNotEmpty) {
await _cache.put(fileId, fallback);
}
// 3. 从文件读取原始元数据
final raw = await _reader.readRawMetadata(file);
// 4. 标准化
final normalized = _normalizer.normalize(
raw,
fileName: fileName,
filePath: filePath,
);
// 5. 评估（第一阶段直接接受）
final history = await _cache.getHistory(normalized.artist, limit: 10);
final candidate = _normalizer.evaluate(normalized, history);
// 6. 决策
final finalMetadata = _normalizer.decide(candidate);
// 7. 写入缓存
if (finalMetadata.isNotEmpty) {
await _cache.put(fileId, finalMetadata);
}
return finalMetadata;
return fallback;
}
/// Fallback：从文件名推断
FinalMetadata _fallbackFromFileName(String fileName) {
final dotIndex = fileName.lastIndexOf('.');
final title = dotIndex > 0 ? fileName.substring(0, dotIndex) : fileName;