376 lines
12 KiB
TypeScript
376 lines
12 KiB
TypeScript
import { defineStore } from 'pinia';
|
|
import { ref, shallowRef, watch } from 'vue';
|
|
import { MessagePlugin } from 'tdesign-vue-next';
|
|
import type { Song } from '../types/song';
|
|
|
|
export enum PlayMode {
|
|
List = 'list',
|
|
Single = 'single',
|
|
Random = 'random'
|
|
}
|
|
|
|
let audioElement: HTMLAudioElement | null = null;
|
|
let audioContext: AudioContext | null = null;
|
|
let analyser: AnalyserNode | null = null;
|
|
let animationFrameId: number | null = null;
|
|
|
|
export const usePlayerStore = defineStore('player', () => {
|
|
// State
|
|
const isPlaying = ref(false);
|
|
const currentSong = ref<Song | null>(null);
|
|
const savedVolume = localStorage.getItem('qz-player-volume');
|
|
const volume = ref(savedVolume ? Number(savedVolume) : 50); // 1~100
|
|
|
|
// Persistence & Sync
|
|
watch(volume, (newVol) => {
|
|
localStorage.setItem('qz-player-volume', newVol.toString());
|
|
if (audioElement) {
|
|
audioElement.volume = newVol / 100;
|
|
}
|
|
});
|
|
|
|
const duration = ref(0); //毫秒级
|
|
const currentTime = ref(0); //毫秒级
|
|
|
|
// Audio Visualization State
|
|
const loudness = ref(0);
|
|
const spectrum = ref<number[]>([]);
|
|
|
|
// UI State
|
|
const isPlayerFullScreen = ref(false);
|
|
const hideLyricView = ref(false);
|
|
|
|
// Playlist State
|
|
const savedPlaylist = localStorage.getItem('qz-player-playlist');
|
|
const savedIndex = localStorage.getItem('qz-player-index');
|
|
|
|
const playlist = ref<Song[]>(savedPlaylist ? JSON.parse(savedPlaylist) : []);
|
|
const currentIndex = ref(savedIndex ? Number(savedIndex) : -1);
|
|
const playMode = ref<PlayMode>(PlayMode.List);
|
|
const savedAddMode = localStorage.getItem('qz-player-add-mode');
|
|
const addListMode = ref<'replace' | 'append'>((savedAddMode as 'replace' | 'append') || 'replace');
|
|
|
|
// Error Handling
|
|
const playErrorCount = ref(0);
|
|
const MAX_RETRY_COUNT = 3;
|
|
|
|
// Lyrics State
|
|
const lyrics = shallowRef<{ lines: any[] }>({ lines: [] });
|
|
|
|
// Initialize audio element
|
|
const initAudio = () => {
|
|
if (!audioElement && typeof window !== 'undefined') {
|
|
audioElement = new Audio();
|
|
audioElement.volume = volume.value / 100;
|
|
|
|
// Setup audio context for visualization
|
|
if (window.AudioContext || (window as any).webkitAudioContext) {
|
|
audioContext = new (window.AudioContext || (window as any).webkitAudioContext)();
|
|
analyser = audioContext.createAnalyser();
|
|
analyser.fftSize = 256;
|
|
const source = audioContext.createMediaElementSource(audioElement);
|
|
source.connect(analyser);
|
|
analyser.connect(audioContext.destination);
|
|
}
|
|
|
|
// Event listeners
|
|
audioElement.addEventListener('loadedmetadata', () => {
|
|
if (audioElement) {
|
|
duration.value = audioElement.duration * 1000;
|
|
}
|
|
});
|
|
|
|
audioElement.addEventListener('timeupdate', () => {
|
|
if (audioElement) {
|
|
currentTime.value = audioElement.currentTime * 1000;
|
|
}
|
|
});
|
|
|
|
audioElement.addEventListener('play', () => {
|
|
isPlaying.value = true;
|
|
startVisualization();
|
|
if ('mediaSession' in navigator) {
|
|
navigator.mediaSession.playbackState = 'playing';
|
|
}
|
|
});
|
|
|
|
audioElement.addEventListener('pause', () => {
|
|
isPlaying.value = false;
|
|
stopVisualization();
|
|
if ('mediaSession' in navigator) {
|
|
navigator.mediaSession.playbackState = 'paused';
|
|
}
|
|
});
|
|
|
|
audioElement.addEventListener('ended', () => {
|
|
next(false);
|
|
});
|
|
|
|
audioElement.addEventListener('error', (e) => {
|
|
console.error('Audio error:', e);
|
|
handlePlayError();
|
|
});
|
|
}
|
|
};
|
|
|
|
const startVisualization = () => {
|
|
if (!analyser || !audioContext) return;
|
|
const bufferLength = analyser.frequencyBinCount;
|
|
const dataArray = new Uint8Array(bufferLength);
|
|
|
|
const animate = () => {
|
|
if (!isPlaying.value) return;
|
|
animationFrameId = requestAnimationFrame(animate);
|
|
analyser?.getByteFrequencyData(dataArray);
|
|
|
|
// Calculate average loudness
|
|
let sum = 0;
|
|
for (let i = 0; i < bufferLength; i++) {
|
|
sum += dataArray[i];
|
|
}
|
|
loudness.value = sum / bufferLength;
|
|
|
|
// Update spectrum
|
|
spectrum.value = Array.from(dataArray);
|
|
};
|
|
animate();
|
|
};
|
|
|
|
const stopVisualization = () => {
|
|
if (animationFrameId !== null) {
|
|
cancelAnimationFrame(animationFrameId);
|
|
animationFrameId = null;
|
|
}
|
|
};
|
|
|
|
// --- Actions ---
|
|
|
|
const setPlaylist = async (list: any[], startIndex = 0) => {
|
|
playlist.value = list;
|
|
currentIndex.value = startIndex;
|
|
if (list.length > 0 && startIndex >= 0 && startIndex < list.length) {
|
|
await playSong(list[startIndex]);
|
|
}
|
|
};
|
|
|
|
const playFromList = async (song: Song, contextList: Song[]) => {
|
|
if (addListMode.value === 'replace') {
|
|
const index = contextList.findIndex(s => s.id === song.id);
|
|
if (index !== -1) {
|
|
await setPlaylist(contextList, index);
|
|
} else {
|
|
await setPlaylist([song], 0);
|
|
}
|
|
} else {
|
|
playlist.value.push(song);
|
|
const newIndex = playlist.value.length - 1;
|
|
currentIndex.value = newIndex;
|
|
await playSong(song);
|
|
}
|
|
};
|
|
|
|
const playSong = async (song: Song, autoPlay = true) => {
|
|
if (!song) return;
|
|
initAudio();
|
|
|
|
console.log(song);
|
|
currentSong.value = song;
|
|
const foundIndex = playlist.value.findIndex(s => s.id === song.id);
|
|
if (foundIndex !== -1) {
|
|
currentIndex.value = foundIndex;
|
|
}
|
|
|
|
updateMediaSession(song);
|
|
fetchLyrics(song);
|
|
|
|
// Resume audio context if suspended (for autoplay policy)
|
|
if (audioContext && audioContext.state === 'suspended') {
|
|
await audioContext.resume();
|
|
}
|
|
|
|
let playUrl = song.url;
|
|
if (song.type === 'Remote' && song.source) {
|
|
const quality = 'hires';
|
|
playUrl = `http://localhost:5266/music?source=${song.source}&id=${song.id}&quality=${quality}`;
|
|
console.log('[Player] Using Proxy:', playUrl);
|
|
}
|
|
|
|
if (playUrl && audioElement) {
|
|
console.log('Playing:', song.name, 'AutoPlay:', autoPlay);
|
|
try {
|
|
audioElement.src = playUrl;
|
|
audioElement.load();
|
|
if (autoPlay) {
|
|
await audioElement.play();
|
|
}
|
|
song.url = playUrl;
|
|
playErrorCount.value = 0;
|
|
} catch (e) {
|
|
console.error("Play request failed:", e);
|
|
if (autoPlay) handlePlayError();
|
|
}
|
|
} else {
|
|
console.warn("Song has no URL");
|
|
if (autoPlay) handlePlayError();
|
|
}
|
|
};
|
|
|
|
const fetchLyrics = async (song: Song) => {
|
|
lyrics.value = { lines: [] };
|
|
if (!song || !song.id) return;
|
|
try {
|
|
// TODO: Implement web-based lyric fetching
|
|
MessagePlugin.info("网页版暂不支持歌词获取").then();
|
|
} catch (e) {
|
|
console.error('Failed to fetch lyrics:', e);
|
|
}
|
|
};
|
|
|
|
const updateMediaSession = (song: Song) => {
|
|
if (!('mediaSession' in navigator)) return;
|
|
|
|
navigator.mediaSession.metadata = new MediaMetadata({
|
|
title: song.name,
|
|
artist: song.artist,
|
|
album: song.albumName || '',
|
|
artwork: song.picUrl ? [{ src: song.picUrl, sizes: '512x512', type: 'image/png' }] : []
|
|
});
|
|
|
|
navigator.mediaSession.setActionHandler('play', () => togglePlay());
|
|
navigator.mediaSession.setActionHandler('pause', () => togglePlay());
|
|
navigator.mediaSession.setActionHandler('previoustrack', () => prev());
|
|
navigator.mediaSession.setActionHandler('nexttrack', () => next(true));
|
|
navigator.mediaSession.setActionHandler('seekto', (details) => {
|
|
if (details.seekTime != null) {
|
|
seek(details.seekTime);
|
|
}
|
|
});
|
|
};
|
|
|
|
const next = async (manual = true) => {
|
|
if (playlist.value.length === 0) return;
|
|
let nextIndex = currentIndex.value;
|
|
if (playMode.value === PlayMode.Single && !manual) {
|
|
nextIndex = currentIndex.value;
|
|
} else if (playMode.value === PlayMode.Random) {
|
|
nextIndex = Math.floor(Math.random() * playlist.value.length);
|
|
} else {
|
|
nextIndex = (currentIndex.value + 1) % playlist.value.length;
|
|
}
|
|
currentIndex.value = nextIndex;
|
|
await playSong(playlist.value[nextIndex]);
|
|
};
|
|
|
|
const prev = async () => {
|
|
if (playlist.value.length === 0) return;
|
|
let prevIndex = currentIndex.value;
|
|
if (playMode.value === PlayMode.Random) {
|
|
prevIndex = Math.floor(Math.random() * playlist.value.length);
|
|
} else {
|
|
prevIndex = (currentIndex.value - 1 + playlist.value.length) % playlist.value.length;
|
|
}
|
|
currentIndex.value = prevIndex;
|
|
await playSong(playlist.value[prevIndex]);
|
|
};
|
|
|
|
const handlePlayError = async () => {
|
|
playErrorCount.value++;
|
|
if (playlist.value.length === 0) {
|
|
isPlaying.value = false;
|
|
playErrorCount.value = 0;
|
|
return;
|
|
}
|
|
if (playErrorCount.value >= MAX_RETRY_COUNT) {
|
|
audioElement?.pause();
|
|
isPlaying.value = false;
|
|
MessagePlugin.error('连续多次播放失败，已停止播放').then();
|
|
playErrorCount.value = 0;
|
|
} else {
|
|
MessagePlugin.warning(`播放失败，尝试播放下一首 (${playErrorCount.value}/${MAX_RETRY_COUNT})`).then();
|
|
next(false);
|
|
}
|
|
};
|
|
|
|
const togglePlay = async () => {
|
|
if (!audioElement) {
|
|
initAudio();
|
|
}
|
|
if (audioElement) {
|
|
if (isPlaying.value) {
|
|
audioElement.pause();
|
|
} else {
|
|
await audioElement.play();
|
|
}
|
|
}
|
|
};
|
|
|
|
const setVolume = async (vol: number) => {
|
|
volume.value = vol;
|
|
if (audioElement) {
|
|
audioElement.volume = vol / 100;
|
|
}
|
|
};
|
|
|
|
const seek = async (time: number) => {
|
|
if (audioElement) {
|
|
audioElement.currentTime = time / 1000;
|
|
}
|
|
};
|
|
|
|
const toggleMode = () => {
|
|
if (playMode.value === PlayMode.List) playMode.value = PlayMode.Single;
|
|
else if (playMode.value === PlayMode.Single) playMode.value = PlayMode.Random;
|
|
else playMode.value = PlayMode.List;
|
|
};
|
|
|
|
const toggleFullScreen = () => {
|
|
isPlayerFullScreen.value = !isPlayerFullScreen.value;
|
|
};
|
|
|
|
// Persistence Listeners
|
|
watch(() => [playlist.value, currentIndex.value], () => {
|
|
localStorage.setItem('qz-player-playlist', JSON.stringify(playlist.value));
|
|
localStorage.setItem('qz-player-index', currentIndex.value.toString());
|
|
}, { deep: true });
|
|
|
|
watch(addListMode, (newMode) => {
|
|
localStorage.setItem('qz-player-add-mode', newMode);
|
|
});
|
|
|
|
// Restore initial state
|
|
if (playlist.value.length > 0 && currentIndex.value >= 0 && currentIndex.value < playlist.value.length) {
|
|
const restoredSong = playlist.value[currentIndex.value];
|
|
if (restoredSong) {
|
|
// Do not auto-play on restore
|
|
currentSong.value = restoredSong;
|
|
}
|
|
}
|
|
|
|
return {
|
|
isPlaying,
|
|
currentSong,
|
|
volume,
|
|
duration,
|
|
currentTime,
|
|
playlist,
|
|
playMode,
|
|
loudness,
|
|
spectrum,
|
|
isPlayerFullScreen,
|
|
setPlaylist,
|
|
playSong,
|
|
next,
|
|
prev,
|
|
togglePlay,
|
|
setVolume,
|
|
seek,
|
|
toggleMode,
|
|
toggleFullScreen,
|
|
lyrics,
|
|
fetchLyrics,
|
|
addListMode,
|
|
playFromList,
|
|
hideLyricView
|
|
};
|
|
});
|