359 lines
12 KiB
Dart
359 lines
12 KiB
Dart
// lib/database/song_database.dart
|
|
import 'package:path/path.dart';
|
|
import 'package:sqflite/sqflite.dart';
|
|
import 'package:path_provider/path_provider.dart';
|
|
|
|
class SongDatabase {
|
|
static final SongDatabase _instance = SongDatabase._internal();
|
|
factory SongDatabase() => _instance;
|
|
SongDatabase._internal();
|
|
|
|
static Database? _database;
|
|
|
|
Future<Database> get database async {
|
|
if (_database != null) return _database!;
|
|
_database = await _initDatabase();
|
|
return _database!;
|
|
}
|
|
|
|
Future<Database> _initDatabase() async {
|
|
final dir = await getApplicationDocumentsDirectory();
|
|
final path = join(dir.path, 'qingting_songs.db');
|
|
return await openDatabase(
|
|
path,
|
|
version: 2,
|
|
onCreate: _onCreate,
|
|
onUpgrade: _onUpgrade,
|
|
);
|
|
}
|
|
|
|
// ⭐ 新增：检查表是否存在
|
|
Future<bool> _tableExists(Database db, String tableName) async {
|
|
final result = await db.query(
|
|
'sqlite_master',
|
|
where: 'type = ? AND name = ?',
|
|
whereArgs: ['table', tableName],
|
|
);
|
|
return result.isNotEmpty;
|
|
}
|
|
|
|
Future<void> _onCreate(Database db, int version) async {
|
|
await _createSongsTable(db);
|
|
await _createMetadataCacheTable(db);
|
|
await _createPlaylistsTable(db);
|
|
await _createPlaylistSongsTable(db);
|
|
await _createFavoritesTable(db);
|
|
await _createIndexes(db);
|
|
}
|
|
|
|
// ⭐ 升级逻辑（从版本 1 升级到 2）
|
|
Future<void> _onUpgrade(Database db, int oldVersion, int newVersion) async {
|
|
if (oldVersion < 2) {
|
|
// 检查 playlists 表是否存在
|
|
final playlistsExists = await _tableExists(db, 'playlists');
|
|
|
|
if (!playlistsExists) {
|
|
// 表不存在 → 创建所有新表
|
|
await _createPlaylistsTable(db);
|
|
await _createPlaylistSongsTable(db);
|
|
await _createFavoritesTable(db);
|
|
await _createIndexes(db);
|
|
} else {
|
|
// 表已存在 → 只添加新字段
|
|
await db.execute(
|
|
'ALTER TABLE playlists ADD COLUMN play_mode TEXT DEFAULT "sequential"');
|
|
}
|
|
}
|
|
}
|
|
|
|
Future<void> _createSongsTable(Database db) async {
|
|
await db.execute('''
|
|
CREATE TABLE songs (
|
|
song_key TEXT PRIMARY KEY,
|
|
remote_path TEXT,
|
|
content_hash TEXT,
|
|
file_size INTEGER,
|
|
modified_time INTEGER,
|
|
etag TEXT,
|
|
title TEXT,
|
|
artist TEXT,
|
|
album TEXT,
|
|
genre TEXT,
|
|
artwork_path TEXT,
|
|
confidence REAL DEFAULT 0.0,
|
|
validation_count INTEGER DEFAULT 0,
|
|
first_scan INTEGER,
|
|
last_scan INTEGER,
|
|
metadata_status TEXT DEFAULT 'pending'
|
|
)
|
|
''');
|
|
}
|
|
|
|
Future<void> _createMetadataCacheTable(Database db) async {
|
|
await db.execute('''
|
|
CREATE TABLE metadata_cache (
|
|
song_key TEXT PRIMARY KEY,
|
|
cache_path TEXT,
|
|
cache_created_at INTEGER,
|
|
cache_size INTEGER,
|
|
FOREIGN KEY (song_key) REFERENCES songs(song_key) ON DELETE CASCADE
|
|
)
|
|
''');
|
|
}
|
|
|
|
Future<void> _createPlaylistsTable(Database db) async {
|
|
await db.execute('''
|
|
CREATE TABLE playlists (
|
|
id TEXT PRIMARY KEY,
|
|
name TEXT NOT NULL,
|
|
play_mode TEXT DEFAULT 'sequential',
|
|
created_at INTEGER,
|
|
updated_at INTEGER
|
|
)
|
|
''');
|
|
}
|
|
|
|
Future<void> _createPlaylistSongsTable(Database db) async {
|
|
await db.execute('''
|
|
CREATE TABLE playlist_songs (
|
|
playlist_id TEXT,
|
|
song_id TEXT,
|
|
order_index INTEGER,
|
|
added_at INTEGER,
|
|
PRIMARY KEY (playlist_id, song_id),
|
|
FOREIGN KEY (playlist_id) REFERENCES playlists(id) ON DELETE CASCADE
|
|
)
|
|
''');
|
|
}
|
|
|
|
Future<void> _createFavoritesTable(Database db) async {
|
|
await db.execute('''
|
|
CREATE TABLE favorites (
|
|
song_id TEXT PRIMARY KEY,
|
|
favorited_at INTEGER,
|
|
FOREIGN KEY (song_id) REFERENCES songs(remote_path) ON DELETE CASCADE
|
|
)
|
|
''');
|
|
}
|
|
|
|
Future<void> _createIndexes(Database db) async {
|
|
await db.execute(
|
|
'CREATE INDEX IF NOT EXISTS idx_songs_artist ON songs(artist)');
|
|
await db
|
|
.execute('CREATE INDEX IF NOT EXISTS idx_songs_title ON songs(title)');
|
|
await db.execute(
|
|
'CREATE INDEX IF NOT EXISTS idx_songs_content_hash ON songs(content_hash)');
|
|
await db.execute(
|
|
'CREATE INDEX IF NOT EXISTS idx_playlist_songs_playlist ON playlist_songs(playlist_id)');
|
|
await db.execute(
|
|
'CREATE INDEX IF NOT EXISTS idx_playlist_songs_order ON playlist_songs(order_index)');
|
|
}
|
|
|
|
// ════════════════════════════════════════════════════════════
|
|
// 查询方法（保持不变）
|
|
// ════════════════════════════════════════════════════════════
|
|
Future<Map<String, dynamic>?> getSong(String songKey) async {
|
|
final db = await database;
|
|
final result =
|
|
await db.query('songs', where: 'song_key = ?', whereArgs: [songKey]);
|
|
return result.isNotEmpty ? result.first : null;
|
|
}
|
|
|
|
Future<Map<String, dynamic>?> getSongByPath(String remotePath) async {
|
|
final db = await database;
|
|
final result = await db
|
|
.query('songs', where: 'remote_path = ?', whereArgs: [remotePath]);
|
|
return result.isNotEmpty ? result.first : null;
|
|
}
|
|
|
|
Future<Map<String, dynamic>?> getSongByHash(String contentHash) async {
|
|
final db = await database;
|
|
final result = await db
|
|
.query('songs', where: 'content_hash = ?', whereArgs: [contentHash]);
|
|
return result.isNotEmpty ? result.first : null;
|
|
}
|
|
|
|
Future<List<Map<String, dynamic>>> getSongsByArtist(String artist,
|
|
{int limit = 20}) async {
|
|
if (artist.isEmpty) return [];
|
|
final db = await database;
|
|
return await db.query(
|
|
'songs',
|
|
where: 'artist = ?',
|
|
whereArgs: [artist],
|
|
limit: limit,
|
|
);
|
|
}
|
|
|
|
// ════════════════════════════════════════════════════════════
|
|
// 播放列表 CRUD（保持不变）
|
|
// ════════════════════════════════════════════════════════════
|
|
Future<List<Map<String, dynamic>>> getAllPlaylists() async {
|
|
final db = await database;
|
|
return await db.query('playlists', orderBy: 'created_at DESC');
|
|
}
|
|
|
|
Future<Map<String, dynamic>?> getPlaylist(String id) async {
|
|
final db = await database;
|
|
final result =
|
|
await db.query('playlists', where: 'id = ?', whereArgs: [id]);
|
|
return result.isNotEmpty ? result.first : null;
|
|
}
|
|
|
|
Future<void> insertPlaylist(Map<String, dynamic> playlist) async {
|
|
final db = await database;
|
|
await db.insert('playlists', playlist,
|
|
conflictAlgorithm: ConflictAlgorithm.replace);
|
|
}
|
|
|
|
Future<void> updatePlaylist(String id, Map<String, dynamic> updates) async {
|
|
final db = await database;
|
|
await db.update('playlists', updates, where: 'id = ?', whereArgs: [id]);
|
|
}
|
|
|
|
Future<void> deletePlaylist(String id) async {
|
|
final db = await database;
|
|
await db.delete('playlists', where: 'id = ?', whereArgs: [id]);
|
|
}
|
|
|
|
// ════════════════════════════════════════════════════════════
|
|
// 播放列表歌曲操作（保持不变）
|
|
// ════════════════════════════════════════════════════════════
|
|
Future<List<Map<String, dynamic>>> getPlaylistSongs(String playlistId) async {
|
|
final db = await database;
|
|
return await db.query(
|
|
'playlist_songs',
|
|
where: 'playlist_id = ?',
|
|
whereArgs: [playlistId],
|
|
orderBy: 'order_index ASC',
|
|
);
|
|
}
|
|
|
|
Future<void> addSongToPlaylist(String playlistId, String songId,
|
|
{int? orderIndex}) async {
|
|
final db = await database;
|
|
int finalOrder = orderIndex ?? 0;
|
|
if (orderIndex == null) {
|
|
final existing = await db.query(
|
|
'playlist_songs',
|
|
where: 'playlist_id = ?',
|
|
whereArgs: [playlistId],
|
|
orderBy: 'order_index DESC',
|
|
limit: 1,
|
|
);
|
|
finalOrder =
|
|
existing.isNotEmpty ? (existing.first['order_index'] as int) + 1 : 0;
|
|
}
|
|
await db.insert(
|
|
'playlist_songs',
|
|
{
|
|
'playlist_id': playlistId,
|
|
'song_id': songId,
|
|
'order_index': finalOrder,
|
|
'added_at': DateTime.now().millisecondsSinceEpoch,
|
|
},
|
|
conflictAlgorithm: ConflictAlgorithm.replace,
|
|
);
|
|
}
|
|
|
|
Future<void> removeSongFromPlaylist(String playlistId, String songId) async {
|
|
final db = await database;
|
|
await db.delete(
|
|
'playlist_songs',
|
|
where: 'playlist_id = ? AND song_id = ?',
|
|
whereArgs: [playlistId, songId],
|
|
);
|
|
}
|
|
|
|
Future<void> clearPlaylist(String playlistId) async {
|
|
final db = await database;
|
|
await db.delete('playlist_songs',
|
|
where: 'playlist_id = ?', whereArgs: [playlistId]);
|
|
}
|
|
|
|
// ════════════════════════════════════════════════════════════
|
|
// 收藏操作（保持不变）
|
|
// ════════════════════════════════════════════════════════════
|
|
Future<List<Map<String, dynamic>>> getFavorites() async {
|
|
final db = await database;
|
|
return await db.query('favorites', orderBy: 'favorited_at DESC');
|
|
}
|
|
|
|
Future<bool> isFavorite(String songId) async {
|
|
final db = await database;
|
|
final result =
|
|
await db.query('favorites', where: 'song_id = ?', whereArgs: [songId]);
|
|
return result.isNotEmpty;
|
|
}
|
|
|
|
Future<void> addFavorite(String songId) async {
|
|
final db = await database;
|
|
await db.insert(
|
|
'favorites',
|
|
{
|
|
'song_id': songId,
|
|
'favorited_at': DateTime.now().millisecondsSinceEpoch,
|
|
},
|
|
conflictAlgorithm: ConflictAlgorithm.replace,
|
|
);
|
|
}
|
|
|
|
Future<void> removeFavorite(String songId) async {
|
|
final db = await database;
|
|
await db.delete('favorites', where: 'song_id = ?', whereArgs: [songId]);
|
|
}
|
|
|
|
Future<void> toggleFavorite(String songId) async {
|
|
if (await isFavorite(songId)) {
|
|
await removeFavorite(songId);
|
|
} else {
|
|
await addFavorite(songId);
|
|
}
|
|
}
|
|
|
|
// ════════════════════════════════════════════════════════════
|
|
// 原有写入/删除方法（保持不变）
|
|
// ════════════════════════════════════════════════════════════
|
|
Future<void> insertSong(Map<String, dynamic> song) async {
|
|
final db = await database;
|
|
await db.insert('songs', song,
|
|
conflictAlgorithm: ConflictAlgorithm.replace);
|
|
}
|
|
|
|
Future<void> updateSong(String songKey, Map<String, dynamic> updates) async {
|
|
final db = await database;
|
|
await db
|
|
.update('songs', updates, where: 'song_key = ?', whereArgs: [songKey]);
|
|
}
|
|
|
|
Future<void> deleteSong(String songKey) async {
|
|
final db = await database;
|
|
await db.delete('songs', where: 'song_key = ?', whereArgs: [songKey]);
|
|
}
|
|
|
|
Future<void> deleteCache(String songKey) async {
|
|
final db = await database;
|
|
await db
|
|
.delete('metadata_cache', where: 'song_key = ?', whereArgs: [songKey]);
|
|
}
|
|
|
|
Future<void> insertCache(Map<String, dynamic> cache) async {
|
|
final db = await database;
|
|
await db.insert('metadata_cache', cache,
|
|
conflictAlgorithm: ConflictAlgorithm.replace);
|
|
}
|
|
|
|
Future<Map<String, dynamic>?> getCache(String songKey) async {
|
|
final db = await database;
|
|
final result = await db
|
|
.query('metadata_cache', where: 'song_key = ?', whereArgs: [songKey]);
|
|
return result.isNotEmpty ? result.first : null;
|
|
}
|
|
|
|
Future<void> close() async {
|
|
final db = await database;
|
|
await db.close();
|
|
_database = null;
|
|
}
|
|
}
|