1751 lines
61 KiB
TypeScript
1751 lines
61 KiB
TypeScript
/**
|
||
* 音源管理器 Composable
|
||
* 提供多音源搜索、故障转移和状态监控功能
|
||
*/
|
||
|
||
import {
|
||
getEnabledSources,
|
||
getSourceById,
|
||
MUSIC_SOURCE_CONFIG,
|
||
type MusicSearchParams,
|
||
type MusicSearchResult,
|
||
type MusicSource,
|
||
type MusicSourceConfig,
|
||
type SongDetailParams,
|
||
type SongDetailResult,
|
||
type SourceStatus
|
||
} from '~/utils/musicSources'
|
||
import { getBilibiliTrackUrl, searchBilibili, parseBilibiliId } from '~/utils/bilibiliSource'
|
||
|
||
/**
|
||
* 音源管理器 Composable
|
||
*/
|
||
export const useMusicSources = () => {
|
||
// 配置
|
||
const config = ref<MusicSourceConfig>(MUSIC_SOURCE_CONFIG)
|
||
|
||
// 当前使用的音源
|
||
const currentSource = ref<string>(config.value.primarySource)
|
||
|
||
// 音源状态
|
||
const sourceStatus = ref<Record<string, SourceStatus>>({})
|
||
|
||
/**
|
||
* 使用 Meting API 获取歌曲信息
|
||
* @param id 歌曲ID
|
||
* @param source Meting API 音源
|
||
* @returns Promise<{success: boolean, data?: any, error?: string}>
|
||
*/
|
||
const getMetingSongInfo = async (
|
||
id: string | number,
|
||
source: MusicSource
|
||
): Promise<{
|
||
success: boolean
|
||
data?: any
|
||
error?: string
|
||
}> => {
|
||
try {
|
||
const metingUrl = `${source.baseUrl}/?server=netease&type=song&id=${id}`
|
||
|
||
const response = await $fetch(metingUrl, {
|
||
timeout: source.timeout || 8000,
|
||
headers: source.headers
|
||
})
|
||
|
||
// Meting API 返回歌曲信息数组
|
||
if (Array.isArray(response) && response.length > 0) {
|
||
const songInfo = response[0]
|
||
return {
|
||
success: true,
|
||
data: {
|
||
name: songInfo.name,
|
||
artist: songInfo.artist,
|
||
url: songInfo.url,
|
||
pic: songInfo.pic,
|
||
lrc: songInfo.lrc
|
||
}
|
||
}
|
||
}
|
||
|
||
return { success: false, error: 'Meting API 未返回有效数据' }
|
||
} catch (error: any) {
|
||
return { success: false, error: error?.message || '未知错误' }
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 验证播放链接的有效性
|
||
* @param url 播放链接
|
||
* @returns Promise<{valid: boolean, duration?: number, error?: string}>
|
||
*/
|
||
const validatePlayUrl = async (
|
||
url: string
|
||
): Promise<{
|
||
valid: boolean
|
||
duration?: number
|
||
error?: string
|
||
}> => {
|
||
try {
|
||
// 修复HTTP/HTTPS协议问题
|
||
let validatedUrl = url
|
||
if (url.startsWith('http://')) {
|
||
validatedUrl = url.replace('http://', 'https://')
|
||
}
|
||
|
||
// 使用HEAD请求检查链接可用性，避免下载整个文件
|
||
const response = await fetch(validatedUrl, {
|
||
method: 'HEAD',
|
||
signal: AbortSignal.timeout(5000) // 5秒超时
|
||
})
|
||
|
||
if (!response.ok) {
|
||
return {
|
||
valid: false,
|
||
error: `HTTP ${response.status}: ${response.statusText}`
|
||
}
|
||
}
|
||
|
||
// 检查Content-Type是否为音频文件
|
||
const contentType = response.headers.get('content-type')
|
||
if (contentType && !contentType.includes('audio') && !contentType.includes('video')) {
|
||
return {
|
||
valid: false,
|
||
error: `不是音频文件: ${contentType}`
|
||
}
|
||
}
|
||
|
||
// 尝试获取文件大小来估算时长
|
||
const contentLength = response.headers.get('content-length')
|
||
let estimatedDuration = 0
|
||
|
||
if (contentLength) {
|
||
const fileSizeBytes = parseInt(contentLength)
|
||
// 粗略估算：假设128kbps的音质，1MB约为64秒
|
||
estimatedDuration = (fileSizeBytes / 1024 / 1024) * 64
|
||
|
||
if (estimatedDuration < 5) {
|
||
return {
|
||
valid: false,
|
||
duration: estimatedDuration,
|
||
error: `歌曲时长过短: ${estimatedDuration.toFixed(1)}秒`
|
||
}
|
||
}
|
||
}
|
||
|
||
return {
|
||
valid: true,
|
||
duration: estimatedDuration
|
||
}
|
||
} catch (error: any) {
|
||
return {
|
||
valid: false,
|
||
error: error.message || '链接验证失败'
|
||
}
|
||
}
|
||
}
|
||
|
||
// 是否正在搜索
|
||
const isSearching = ref(false)
|
||
|
||
// 最后一次搜索的音源
|
||
const lastUsedSource = ref<string>('')
|
||
|
||
/**
|
||
* 使用 Native Music API 搜索
|
||
*/
|
||
const searchNativeMusic = async (params: MusicSearchParams): Promise<any[]> => {
|
||
const platform = params.platform || 'netease'
|
||
if (platform !== 'netease' && platform !== 'tencent') {
|
||
return []
|
||
}
|
||
|
||
const endpoint = platform === 'netease' ? 'wy' : 'tx'
|
||
const url = `/api/native-api/search/${endpoint}`
|
||
|
||
try {
|
||
console.log(`[searchNativeMusic] Requesting ${platform} search: ${params.keywords}`)
|
||
const response: any = await $fetch(url, {
|
||
params: {
|
||
str: params.keywords,
|
||
page: Math.floor((params.offset || 0) / (params.limit || 30)) + 1,
|
||
limit: params.limit || 30
|
||
}
|
||
})
|
||
|
||
if (!response || !response.list) {
|
||
return []
|
||
}
|
||
|
||
return response.list.map((item: any) => {
|
||
const isNetease = platform === 'netease'
|
||
// 统一使用 songmid 作为 ID
|
||
// 网易云: songmid 为数字 ID (e.g. 123456)
|
||
// QQ音乐: songmid 为字符串 MID (e.g. 004MmF3024567)，这对 vkeys 接口更友好
|
||
const mid = item.songmid
|
||
// VoiceHub 内部 ID: 网易云使用数字ID，QQ音乐优先使用数字ID(songId)以便vkeys使用
|
||
const id = isNetease ? item.songmid : item.songId || item.songmid
|
||
|
||
return {
|
||
id: id?.toString(),
|
||
title: item.name,
|
||
artist: item.singer?.replace(/、/g, '/') || '未知艺术家',
|
||
cover: item.img,
|
||
album: item.albumName,
|
||
duration: isNetease ? item.duration * 1000 : item.duration, // Netease uses ms, Tencent uses s
|
||
musicPlatform: platform,
|
||
musicId: id?.toString(),
|
||
url: undefined,
|
||
hasUrl: false,
|
||
sourceInfo: {
|
||
// 伪装源名称，以便兼容后续的播放逻辑
|
||
// 网易云使用 netease-backup，QQ音乐使用 vkeys
|
||
source: isNetease ? 'netease-backup' : 'vkeys',
|
||
originalId: id?.toString(),
|
||
fetchedAt: new Date(),
|
||
mid: mid,
|
||
strMediaMid: item.strMediaMid, // Add strMediaMid
|
||
quality: item._types, // Store quality info from LX
|
||
types: item.types
|
||
}
|
||
}
|
||
})
|
||
} catch (error: any) {
|
||
console.warn(`[searchNativeMusic] Failed:`, error)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
// 服务器是否在中国
|
||
const isServerInChina = ref<boolean | null>(null)
|
||
|
||
// 检测服务器位置
|
||
const checkServerLocation = async () => {
|
||
if (isServerInChina.value !== null) return
|
||
|
||
try {
|
||
const data = await $fetch('/api/system/location')
|
||
if (data && data.success) {
|
||
isServerInChina.value = data.data.isInChina
|
||
console.log(`[useMusicSources] 服务器位置检测: ${isServerInChina.value ? '中国' : '海外'}`)
|
||
}
|
||
} catch (e) {
|
||
console.warn('[useMusicSources] 服务器位置检测失败，默认为海外:', e)
|
||
isServerInChina.value = false
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 搜索歌曲（带故障转移）
|
||
*/
|
||
const searchSongs = async (
|
||
params: MusicSearchParams,
|
||
signal?: AbortSignal
|
||
): Promise<MusicSearchResult> => {
|
||
// 检查请求是否已被取消
|
||
if (signal?.aborted) {
|
||
throw new DOMException('搜索请求已被取消', 'AbortError')
|
||
}
|
||
|
||
isSearching.value = true
|
||
|
||
// 确保已检测服务器位置
|
||
if (isServerInChina.value === null) {
|
||
await checkServerLocation()
|
||
}
|
||
|
||
try {
|
||
// 优先尝试 Native Music 本地集成搜索 (仅支持网易云和QQ音乐)
|
||
// 只有当不是播客搜索时才使用
|
||
// 策略调整：如果服务器在中国，优先使用 Native Music；如果在海外，跳过 Native Music 直接使用第三方 API (除非第三方都失败)
|
||
const platform = params.platform || 'netease'
|
||
const shouldUseNativeFirst = isServerInChina.value === true
|
||
|
||
if (
|
||
shouldUseNativeFirst &&
|
||
(platform === 'netease' || platform === 'tencent') &&
|
||
params.type !== 1009
|
||
) {
|
||
try {
|
||
console.log(`[searchSongs] 服务器位于国内，优先尝试 Native Music 搜索...`)
|
||
const result = await searchNativeMusic(params)
|
||
if (result && result.length > 0) {
|
||
currentSource.value = 'native-music'
|
||
// 这里不再将 lastUsedSource 设置为 'native-music'，
|
||
// 而是根据平台回退到能提供播放链接的音源ID（如 netease-backup 或 vkeys）。
|
||
// 这样 getSongUrl 等后续方法就会使用该音源进行播放链接获取。
|
||
lastUsedSource.value = platform === 'netease' ? 'netease-backup' : 'vkeys'
|
||
return {
|
||
success: true,
|
||
source: 'native-music',
|
||
data: result,
|
||
error: undefined
|
||
}
|
||
}
|
||
} catch (e) {
|
||
console.warn('[searchSongs] Native Music 搜索失败，回退到其他音源:', e)
|
||
}
|
||
} else if (!shouldUseNativeFirst) {
|
||
console.log(`[searchSongs] 服务器位于海外，跳过 Native Music 优先使用第三方音源`)
|
||
}
|
||
|
||
const enabledSources = getEnabledSources()
|
||
const errors: any[] = []
|
||
|
||
if (enabledSources.length === 0) {
|
||
throw new Error('没有可用的音源')
|
||
}
|
||
|
||
// 根据平台选择合适的音源顺序
|
||
let sourcesToTry: MusicSource[]
|
||
|
||
if (params.type === 1009) {
|
||
// 播客/电台搜索：只允许使用 netease-backup 源
|
||
sourcesToTry = enabledSources.filter((s) => s.id.includes('netease-backup'))
|
||
if (sourcesToTry.length === 0) {
|
||
throw new Error('未找到支持播客搜索的音源(需网易云备用源)')
|
||
}
|
||
} else if (params.platform === 'bilibili') {
|
||
const bilibiliSource = enabledSources.find((s) => s.id === 'bilibili')
|
||
if (bilibiliSource) {
|
||
sourcesToTry = [bilibiliSource]
|
||
} else {
|
||
throw new Error('未启用哔哩哔哩音源')
|
||
}
|
||
} else if (params.platform === 'tencent') {
|
||
// QQ音乐平台：优先使用 vkeys v3，其次 vkeys v2；若全部失败，再尝试其他平台
|
||
const v3 = enabledSources.find((s) => s.id === 'vkeys-v3')
|
||
const v2 = enabledSources.find((s) => s.id === 'vkeys')
|
||
const tencentSources: MusicSource[] = []
|
||
if (v3) tencentSources.push(v3)
|
||
if (v2) tencentSources.push(v2)
|
||
console.log('QQ音乐平台搜索，优先使用 vkeys v3，失败回退到 v2')
|
||
|
||
// 第一阶段：仅尝试腾讯专用源
|
||
sourcesToTry = tencentSources
|
||
} else {
|
||
// 网易云音乐平台（默认）：优先使用netease-backup系列，vkeys作为备用
|
||
const neteaseSources = enabledSources.filter((s) => s.id.includes('netease-backup'))
|
||
const vkeysSource = enabledSources.find((s) => s.id === 'vkeys')
|
||
const otherSources = enabledSources.filter(
|
||
(s) => !s.id.includes('netease-backup') && s.id !== 'vkeys'
|
||
)
|
||
|
||
sourcesToTry = [...neteaseSources, ...(vkeysSource ? [vkeysSource] : []), ...otherSources]
|
||
console.log('网易云音乐平台搜索，优先使用netease-backup系列音源')
|
||
}
|
||
|
||
// 按选定的顺序尝试每个音源
|
||
for (const source of sourcesToTry) {
|
||
// 在每次尝试前检查请求是否已被取消
|
||
if (signal?.aborted) {
|
||
throw new DOMException('搜索请求已被取消', 'AbortError')
|
||
}
|
||
|
||
try {
|
||
console.log(`尝试使用音源: ${source.name} (${source.id})`)
|
||
const result = await searchWithSource(source, params, signal)
|
||
|
||
// 更新状态
|
||
currentSource.value = source.id
|
||
lastUsedSource.value = source.id
|
||
updateSourceStatus(source.id, 'online')
|
||
|
||
return {
|
||
success: true,
|
||
source: source.id,
|
||
data: result,
|
||
error: undefined
|
||
}
|
||
} catch (error: any) {
|
||
console.warn(`音源 ${source.name} 搜索失败:`, error.message)
|
||
updateSourceStatus(source.id, 'error', error.message)
|
||
errors.push(error) // 收集错误
|
||
|
||
// 如果不是最后一个音源，继续尝试下一个
|
||
if (source !== sourcesToTry[sourcesToTry.length - 1]) {
|
||
console.log(`继续尝试下一个音源...`)
|
||
}
|
||
}
|
||
}
|
||
|
||
// 若为QQ音乐平台，尝试完腾讯源后允许作为最后手段切换到其他平台
|
||
if (params.platform === 'tencent') {
|
||
const otherSources = enabledSources.filter((s) => s.id !== 'vkeys-v3' && s.id !== 'vkeys')
|
||
if (otherSources.length) {
|
||
console.log('QQ音乐平台所有专用源失败，作为最后手段尝试其他平台音源')
|
||
for (const source of otherSources) {
|
||
if (signal?.aborted) {
|
||
throw new DOMException('搜索请求已被取消', 'AbortError')
|
||
}
|
||
try {
|
||
console.log(`尝试使用音源: ${source.name} (${source.id})`)
|
||
const result = await searchWithSource(source, params, signal)
|
||
currentSource.value = source.id
|
||
lastUsedSource.value = source.id
|
||
updateSourceStatus(source.id, 'online')
|
||
return { success: true, source: source.id, data: result, error: undefined }
|
||
} catch (error: any) {
|
||
console.warn(`音源 ${source.name} 搜索失败:`, error.message)
|
||
updateSourceStatus(source.id, 'error', error.message)
|
||
errors.push(error) // 收集错误
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 所有音源都失败了
|
||
if (errors.length > 0) {
|
||
const errorDetails = errors.map((e) => e.message || '未知错误').join('; ')
|
||
throw new Error(`所有音源均不可用: ${errorDetails}`)
|
||
}
|
||
throw new Error('所有音源均不可用，请稍后重试')
|
||
} finally {
|
||
isSearching.value = false
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 使用指定音源搜索
|
||
*/
|
||
const searchWithSource = async (
|
||
source: MusicSource,
|
||
params: MusicSearchParams,
|
||
signal?: AbortSignal
|
||
): Promise<any[]> => {
|
||
const startTime = Date.now()
|
||
|
||
let url: string
|
||
let transformResponse: (data: any) => any[]
|
||
|
||
if (source.id === 'bilibili') {
|
||
try {
|
||
const result = await searchBilibili(params.keywords)
|
||
updateSourceStatus(source.id, 'online', undefined, Date.now() - startTime)
|
||
return result
|
||
} catch (error: any) {
|
||
updateSourceStatus(source.id, 'error', error.message, Date.now() - startTime)
|
||
throw error
|
||
}
|
||
} else if (source.id === 'vkeys-v3') {
|
||
// Vkeys v3 API（仅支持QQ音乐搜索）
|
||
const platform = params.platform || 'tencent'
|
||
if (platform !== 'tencent') {
|
||
throw new Error('vkeys v3 仅支持QQ音乐搜索')
|
||
}
|
||
|
||
const page = Math.floor((params.offset || 0) / (params.limit || 10)) + 1
|
||
const limit = params.limit || 10
|
||
url = `${source.baseUrl}/tencent/search/song?keyword=${encodeURIComponent(params.keywords)}&page=${page}&limit=${limit}`
|
||
transformResponse = (data: any) => transformVkeysV3TencentSearch(data)
|
||
} else if (source.id === 'vkeys') {
|
||
// Vkeys API - 根据用户选择的平台使用对应的API
|
||
const platform = params.platform || 'netease' // 使用用户选择的平台，默认网易云
|
||
|
||
// 根据平台使用不同的端点，都使用word参数
|
||
if (platform === 'tencent') {
|
||
// QQ音乐使用word参数和tencent端点
|
||
url = `${source.baseUrl}/tencent?word=${encodeURIComponent(params.keywords)}&num=${params.limit || 30}`
|
||
} else {
|
||
// 网易云使用word参数和netease端点
|
||
url = `${source.baseUrl}/netease?word=${encodeURIComponent(params.keywords)}&num=${params.limit || 30}&page=${Math.floor((params.offset || 0) / (params.limit || 30)) + 1}`
|
||
}
|
||
|
||
transformResponse = (data: any) => transformVkeysResponse(data, platform)
|
||
} else {
|
||
// 网易云备用API
|
||
// 如果提供了cookie，添加到查询参数中
|
||
let cookieParam = ''
|
||
if (params.cookie) {
|
||
// 将cookie编码后作为参数传递
|
||
cookieParam = `&cookie=${encodeURIComponent(params.cookie)}`
|
||
}
|
||
|
||
// 如果是播客/电台搜索 (type === 1009)，使用 /cloudsearch 接口
|
||
if (params.type === 1009) {
|
||
// 播客/电台搜索接口参数：keywords=关键词, limit=数量, offset=偏移量, type=1009
|
||
url = `${source.baseUrl}/cloudsearch?keywords=${encodeURIComponent(params.keywords)}&limit=${params.limit || 20}&offset=${params.offset || 0}&type=1009${cookieParam}`
|
||
transformResponse = async (data: any) => await transformNeteaseResponse(data)
|
||
} else {
|
||
// 默认使用 cloudsearch 接口
|
||
url = `${source.baseUrl}/cloudsearch?keywords=${encodeURIComponent(params.keywords)}&limit=${params.limit || 30}&offset=${params.offset || 0}&type=${params.type || 1}${cookieParam}`
|
||
transformResponse = async (data: any) => await transformNeteaseResponse(data)
|
||
}
|
||
}
|
||
|
||
let response: any
|
||
let finalUrl = url
|
||
|
||
try {
|
||
console.log(`[${source.name}] 请求URL:`, finalUrl)
|
||
// v3 请求使用简单请求，不携带任何会触发预检的自定义头
|
||
const requestHeaders =
|
||
source.id === 'vkeys-v3'
|
||
? undefined
|
||
: ({
|
||
'Content-Type': 'application/json',
|
||
...source.headers
|
||
} as Record<string, string>)
|
||
|
||
response = await $fetch(finalUrl, {
|
||
timeout: source.timeout || config.value.timeout,
|
||
signal,
|
||
headers: requestHeaders
|
||
})
|
||
console.log(`[${source.name}] API响应:`, response)
|
||
|
||
const responseTime = Date.now() - startTime
|
||
updateSourceStatus(source.id, 'online', undefined, responseTime)
|
||
} catch (error: any) {
|
||
// 如果是网易云备用源且使用的是cloudsearch接口，尝试切换到search接口
|
||
if (source.id !== 'vkeys' && finalUrl.includes('/cloudsearch')) {
|
||
console.warn(`[${source.name}] cloudsearch接口失败，尝试使用search接口:`, error.message)
|
||
|
||
// 如果提供了cookie，添加到查询参数中
|
||
let cookieParam = ''
|
||
if (params.cookie) {
|
||
cookieParam = `&cookie=${encodeURIComponent(params.cookie)}`
|
||
}
|
||
|
||
const fallbackUrl = `${source.baseUrl}/search?keywords=${encodeURIComponent(params.keywords)}&limit=${params.limit || 30}&offset=${params.offset || 0}&type=${params.type || 1}${cookieParam}`
|
||
|
||
try {
|
||
console.log(`[${source.name}] 备用请求URL:`, fallbackUrl)
|
||
response = await $fetch(fallbackUrl, {
|
||
timeout: source.timeout || config.value.timeout,
|
||
signal,
|
||
headers: {
|
||
'Content-Type': 'application/json',
|
||
...source.headers
|
||
}
|
||
})
|
||
console.log(`[${source.name}] 备用API响应:`, response)
|
||
|
||
const responseTime = Date.now() - startTime
|
||
updateSourceStatus(source.id, 'online', undefined, responseTime)
|
||
finalUrl = fallbackUrl // 更新最终使用的URL
|
||
} catch (fallbackError: any) {
|
||
const responseTime = Date.now() - startTime
|
||
console.error(`[${source.name}] 备用接口也失败:`, fallbackError.message)
|
||
updateSourceStatus(
|
||
source.id,
|
||
'error',
|
||
`cloudsearch和search接口均失败: ${error.message}, ${fallbackError.message}`,
|
||
responseTime
|
||
)
|
||
throw fallbackError
|
||
}
|
||
} else {
|
||
const responseTime = Date.now() - startTime
|
||
console.error(`[${source.name}] 网络请求失败:`, error.message)
|
||
updateSourceStatus(source.id, 'error', error.message, responseTime)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
// 单独处理数据转换，避免网络成功但转换失败的情况
|
||
try {
|
||
const result = await transformResponse(response)
|
||
console.log(`[${source.name}] 转换后的数据:`, result)
|
||
return result
|
||
} catch (error: any) {
|
||
console.error(`[${source.name}] 数据转换失败:`, error.message)
|
||
console.error(`[${source.name}] 原始响应数据:`, response)
|
||
throw new Error(`数据转换失败: ${error.message}`)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 获取歌曲详情
|
||
*/
|
||
const getSongDetail = async (params: SongDetailParams): Promise<SongDetailResult> => {
|
||
const enabledSources = getEnabledSources()
|
||
|
||
for (const source of enabledSources) {
|
||
try {
|
||
const result = await getSongDetailWithSource(source, params)
|
||
|
||
updateSourceStatus(source.id, 'online')
|
||
|
||
return {
|
||
success: true,
|
||
source: source.id,
|
||
data: { songs: result },
|
||
error: undefined
|
||
}
|
||
} catch (error: any) {
|
||
console.warn(`音源 ${source.name} 获取歌曲详情失败:`, error.message)
|
||
updateSourceStatus(source.id, 'error', error.message)
|
||
}
|
||
}
|
||
|
||
throw new Error('所有音源均不可用')
|
||
}
|
||
|
||
/**
|
||
* 使用指定音源获取歌曲详情
|
||
*/
|
||
const getSongDetailWithSource = async (
|
||
source: MusicSource,
|
||
params: SongDetailParams
|
||
): Promise<any[]> => {
|
||
const startTime = Date.now()
|
||
|
||
// 验证参数
|
||
if (!params.ids || (Array.isArray(params.ids) && params.ids.length === 0)) {
|
||
throw new Error('歌曲ID参数不能为空')
|
||
}
|
||
|
||
const ids = Array.isArray(params.ids) ? params.ids.join(',') : params.ids
|
||
|
||
// 再次验证处理后的ids
|
||
if (!ids || ids === 'undefined' || ids === 'null') {
|
||
throw new Error(`无效的歌曲ID: ${ids}`)
|
||
}
|
||
|
||
let url: string
|
||
let transformResponse: (data: any) => any[]
|
||
|
||
if (source.id === 'vkeys') {
|
||
// Vkeys API - 使用搜索接口，包含了歌曲详情
|
||
// 默认使用网易云端点进行详情搜索
|
||
url = `${source.baseUrl}/netease?word=${encodeURIComponent(ids)}&num=50`
|
||
transformResponse = (data: any) => transformVkeysResponse(data, 'netease')
|
||
} else {
|
||
// 网易云备用API
|
||
url = `${source.baseUrl}/song/detail?ids=${ids}`
|
||
transformResponse = (response: any) => {
|
||
if (response.code !== 200 || !response.songs) {
|
||
throw new Error(`API响应错误: ${response.message || '未知错误'}`)
|
||
}
|
||
return transformNeteaseDetailResponse(response)
|
||
}
|
||
}
|
||
|
||
try {
|
||
const response = await $fetch(url, {
|
||
timeout: source.timeout || config.value.timeout,
|
||
headers: {
|
||
'Content-Type': 'application/json',
|
||
...source.headers
|
||
}
|
||
})
|
||
|
||
const responseTime = Date.now() - startTime
|
||
updateSourceStatus(source.id, 'online', undefined, responseTime)
|
||
|
||
return transformResponse(response)
|
||
} catch (error: any) {
|
||
const responseTime = Date.now() - startTime
|
||
updateSourceStatus(source.id, 'error', error.message, responseTime)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 更新音源状态
|
||
*/
|
||
const updateSourceStatus = (
|
||
sourceId: string,
|
||
status: SourceStatus['status'],
|
||
errorMessage?: string,
|
||
responseTime?: number
|
||
) => {
|
||
sourceStatus.value[sourceId] = {
|
||
status,
|
||
responseTime,
|
||
lastCheck: new Date(),
|
||
errorMessage
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 获取歌曲封面URL（网易云备用源）
|
||
* 实现两步搜索：先通过歌曲ID获取详情，然后提取封面URL
|
||
*/
|
||
const getSongPicUrl = async (id: number): Promise<string> => {
|
||
try {
|
||
// 获取网易云备用源
|
||
const enabledSources = getEnabledSources()
|
||
const neteaseSource = enabledSources.find((source) => source.id.includes('netease-backup'))
|
||
|
||
if (!neteaseSource) {
|
||
console.error('[getSongPicUrl] 未找到网易云备用源')
|
||
return ''
|
||
}
|
||
|
||
// 直接调用/song/detail接口获取歌曲详情
|
||
const response = await $fetch(`${neteaseSource.baseUrl}/song/detail`, {
|
||
params: { ids: id },
|
||
timeout: neteaseSource.timeout || 8000
|
||
})
|
||
|
||
// 从响应中提取封面URL
|
||
return response.songs?.[0]?.al?.picUrl || ''
|
||
} catch (error) {
|
||
console.error('[getSongPicUrl] 获取封面失败:', error)
|
||
return ''
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 将VoiceHub音质数值映射到网易云API的level参数
|
||
*/
|
||
const mapQualityToLevel = (quality: number): string => {
|
||
// 根据网易云API文档映射音质等级
|
||
switch (quality) {
|
||
case 2:
|
||
return 'standard' // 标准 (128k)
|
||
case 3:
|
||
return 'higher' // 较高 (192k)
|
||
case 4:
|
||
return 'exhigh' // HQ极高 (320k)
|
||
case 5:
|
||
return 'lossless' // SQ无损
|
||
case 6:
|
||
return 'hires' // Hi-Res
|
||
case 9:
|
||
return 'jymaster' // 超清母带
|
||
default:
|
||
return 'exhigh' // 默认极高音质
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 获取歌曲播放URL
|
||
* 根据平台选择合适的音源：网易云优先使用netease-backup；QQ音乐仅使用vkeys系（不跨平台）
|
||
*/
|
||
const getSongUrl = async (
|
||
id: number | string,
|
||
quality?: number,
|
||
platform?: string,
|
||
cookie?: string,
|
||
options?: {
|
||
unblock?: boolean
|
||
bilibiliCid?: string
|
||
}
|
||
): Promise<{
|
||
success: boolean
|
||
url?: string
|
||
error?: string
|
||
}> => {
|
||
// 特殊处理 netease-podcast 平台：使用网易云逻辑但禁用 unblock
|
||
if (platform === 'netease-podcast') {
|
||
platform = 'netease'
|
||
if (!options) {
|
||
options = {}
|
||
}
|
||
// 只有在未明确指定 unblock 时才强制设为 false
|
||
if (options.unblock === undefined) {
|
||
options.unblock = false
|
||
}
|
||
}
|
||
|
||
// 如果没有提供cookie且在客户端环境，尝试从localStorage获取
|
||
if (!cookie && import.meta.client) {
|
||
try {
|
||
const storedCookie = localStorage.getItem('netease_cookie')
|
||
if (storedCookie) {
|
||
cookie = storedCookie
|
||
}
|
||
} catch (e) {
|
||
// Ignore localStorage errors
|
||
}
|
||
}
|
||
|
||
try {
|
||
// 获取所有启用的音源
|
||
const enabledSources = getEnabledSources()
|
||
|
||
// 支持多个ID的批量查询（用逗号分隔）
|
||
let idParam = Array.isArray(id) ? id.join(',') : id.toString()
|
||
|
||
// 如果是 bilibili 平台且 id 包含 cid，解析出来
|
||
if (platform === 'bilibili' && !Array.isArray(id)) {
|
||
const parsed = parseBilibiliId(id)
|
||
idParam = parsed.bvid
|
||
if (parsed.cid) {
|
||
if (!options) {
|
||
options = {}
|
||
}
|
||
if (!options.bilibiliCid) {
|
||
options.bilibiliCid = parsed.cid
|
||
}
|
||
}
|
||
}
|
||
|
||
const hasNeteaseLogin = !!cookie
|
||
const requestedQuality =
|
||
quality !== undefined && quality !== null && quality !== '' ? Number(quality) : NaN
|
||
|
||
// 定义音源尝试顺序
|
||
const sourcesToTry: Array<{ source: MusicSource; type: 'netease' | 'tencent' | 'bilibili' }> =
|
||
[]
|
||
|
||
if (platform === 'bilibili') {
|
||
const bilibiliSource = enabledSources.find((source) => source.id === 'bilibili')
|
||
if (bilibiliSource) {
|
||
sourcesToTry.push({ source: bilibiliSource, type: 'bilibili' })
|
||
}
|
||
} else if (platform === 'tencent') {
|
||
// QQ音乐平台：优先 vkeys v3（获取音质列表并选择可用项），然后回退到 vkeys v2
|
||
|
||
const v3 = enabledSources.find((source) => source.id === 'vkeys-v3')
|
||
const v2 = enabledSources.find((source) => source.id === 'vkeys')
|
||
if (v3) {
|
||
sourcesToTry.push({ source: v3, type: 'tencent' })
|
||
}
|
||
if (v2) {
|
||
sourcesToTry.push({ source: v2, type: 'tencent' })
|
||
}
|
||
} else {
|
||
// 网易云音乐平台（默认）：未登录优先 vkeys，已登录优先 netease-backup
|
||
const neteaseSource = enabledSources.find((source) => source.id.includes('netease-backup'))
|
||
const vkeysSource = enabledSources.find((source) => source.id === 'vkeys')
|
||
|
||
const orderedSources = hasNeteaseLogin
|
||
? [neteaseSource, vkeysSource]
|
||
: [vkeysSource, neteaseSource]
|
||
|
||
for (const source of orderedSources) {
|
||
if (source) {
|
||
sourcesToTry.push({ source, type: 'netease' })
|
||
}
|
||
}
|
||
|
||
// 添加 Meting API 备用源
|
||
const metingSources = enabledSources.filter((source) => source.id.startsWith('meting-'))
|
||
metingSources.forEach((source) => {
|
||
sourcesToTry.push({ source, type: 'netease' })
|
||
})
|
||
|
||
// 添加其他备用音源
|
||
const otherSources = enabledSources.filter(
|
||
(source) =>
|
||
source.id !== 'vkeys' &&
|
||
!source.id.includes('netease-backup') &&
|
||
!source.id.startsWith('meting-')
|
||
)
|
||
otherSources.forEach((source) => {
|
||
sourcesToTry.push({ source, type: 'netease' })
|
||
})
|
||
}
|
||
|
||
// 逐个尝试音源
|
||
for (const { source, type } of sourcesToTry) {
|
||
try {
|
||
let url: string | null = null
|
||
|
||
if (source.id === 'bilibili') {
|
||
const result = await getBilibiliTrackUrl(idParam, options?.bilibiliCid)
|
||
url = result.url
|
||
} else if (source.id === 'vkeys') {
|
||
// Vkeys API
|
||
const endpoint = type === 'tencent' ? 'tencent' : 'netease'
|
||
const qualityCandidates =
|
||
type === 'tencent'
|
||
? [!isNaN(requestedQuality) ? requestedQuality : 8]
|
||
: [
|
||
...new Set(
|
||
[
|
||
!isNaN(requestedQuality) ? requestedQuality : 0,
|
||
!hasNeteaseLogin && requestedQuality > 4 ? 4 : null
|
||
].filter((value): value is number => typeof value === 'number')
|
||
)
|
||
]
|
||
|
||
for (const candidateQuality of qualityCandidates) {
|
||
const vkeysUrl = `${source.baseUrl}/${endpoint}?id=${idParam}&quality=${candidateQuality}`
|
||
const vkeysResp = await $fetch(vkeysUrl, { timeout: source.timeout || 8000 })
|
||
|
||
if (vkeysResp?.code === 200 && vkeysResp?.data?.url) {
|
||
url = String(vkeysResp.data.url)
|
||
break
|
||
}
|
||
}
|
||
} else if (source.id === 'vkeys-v3') {
|
||
// Vkeys v3：先获取歌曲信息与音质列表，再按可用音质选择并调用 v2 获取可播放URL
|
||
try {
|
||
const infoUrl = `${source.baseUrl}/tencent/song/info?id=${encodeURIComponent(idParam)}`
|
||
const infoResp = await $fetch(infoUrl, { timeout: source.timeout || 8000 })
|
||
|
||
// v3 成功码为 0
|
||
if (typeof infoResp?.code !== 'number' || infoResp.code !== 0 || !infoResp?.data) {
|
||
throw new Error(
|
||
`v3 歌曲信息接口错误: ${infoResp?.message || '未知错误'} (code: ${infoResp?.code})`
|
||
)
|
||
}
|
||
|
||
const qualityInfo: Array<{
|
||
type: number
|
||
size: number
|
||
file: string
|
||
quality: string
|
||
}> = infoResp.data.qualityInfo || []
|
||
if (!Array.isArray(qualityInfo) || qualityInfo.length === 0) {
|
||
throw new Error('v3 歌曲信息缺少音质列表')
|
||
}
|
||
|
||
// 目标音质：优先使用传入quality，否则读取设置
|
||
let targetQuality: number
|
||
const numQuality =
|
||
quality !== undefined && quality !== null && quality !== '' ? Number(quality) : NaN
|
||
|
||
if (!isNaN(numQuality)) {
|
||
targetQuality = numQuality
|
||
} else {
|
||
try {
|
||
const { getQuality } = await import('./useAudioQuality')
|
||
const setting = getQuality('tencent')
|
||
targetQuality = Number(setting)
|
||
if (isNaN(targetQuality)) targetQuality = 8
|
||
} catch {
|
||
targetQuality = 8 // 默认 HQ 高音质
|
||
}
|
||
}
|
||
|
||
// 构造腾讯音质优先序列：以目标为首，其次按 QUALITY_OPTIONS.tencent 顺序降级，最后兜底常见音质
|
||
let fallbackList: number[] = []
|
||
try {
|
||
const { QUALITY_OPTIONS } = await import('./useAudioQuality')
|
||
const optionValues =
|
||
(QUALITY_OPTIONS as any)?.tencent?.map((o: any) => o.value) || []
|
||
fallbackList = optionValues.filter((v: number) => v !== targetQuality)
|
||
} catch {
|
||
// 兜底序列
|
||
fallbackList = [8, 4, 10, 11, 14]
|
||
}
|
||
const tryQualities = [targetQuality, ...fallbackList]
|
||
|
||
// 在 v3 音质列表中选择第一个 size>0 的可用音质
|
||
const available = tryQualities.find((q) =>
|
||
qualityInfo.some((qi) => qi.type === q && Number(qi.size) > 0)
|
||
)
|
||
const selectedQuality = available ?? targetQuality
|
||
|
||
// 使用 vkeys v2 点歌接口获取可播放URL（v3 不直接返回 URL）
|
||
const v2Source = getEnabledSources().find((s) => s.id === 'vkeys')
|
||
if (!v2Source) {
|
||
throw new Error('未配置 vkeys v2 音源以获取播放链接')
|
||
}
|
||
|
||
const v2Url = `${v2Source.baseUrl}/tencent?id=${idParam}&quality=${selectedQuality}`
|
||
const v2Resp = await $fetch(v2Url, { timeout: v2Source.timeout || 8000 })
|
||
if (v2Resp?.code === 200 && v2Resp?.data?.url) {
|
||
url = String(v2Resp.data.url)
|
||
} else {
|
||
// 如果首选失败，尝试在可用音质上继续降级（排除已尝试项）
|
||
for (const q of tryQualities.filter((q) => q !== selectedQuality)) {
|
||
const hasQuality = qualityInfo.some((qi) => qi.type === q && Number(qi.size) > 0)
|
||
if (!hasQuality) continue
|
||
|
||
const altUrl = `${v2Source.baseUrl}/tencent?id=${idParam}&quality=${q}`
|
||
const altResp = await $fetch(altUrl, { timeout: v2Source.timeout || 8000 })
|
||
if (altResp?.code === 200 && altResp?.data?.url) {
|
||
url = String(altResp.data.url)
|
||
break
|
||
}
|
||
}
|
||
}
|
||
|
||
// 若仍未拿到URL，抛出错误以便外层继续按源回退
|
||
if (!url) {
|
||
throw new Error('v3 信息+v2 点歌未获取到有效播放链接')
|
||
}
|
||
} catch (error: any) {
|
||
// vkeys v3 路径失败，继续回退其它音源
|
||
}
|
||
} else if (source.id.startsWith('meting-')) {
|
||
// Meting API - 获取播放链接
|
||
try {
|
||
// 首先尝试获取歌曲信息，包含播放链接
|
||
const songInfo = await getMetingSongInfo(idParam, source)
|
||
|
||
if (songInfo.success && songInfo.data?.url) {
|
||
// 从歌曲信息中提取播放链接
|
||
url = songInfo.data.url
|
||
} else {
|
||
// 如果获取歌曲信息失败，直接使用 URL 类型的 API
|
||
const metingUrl = `${source.baseUrl}/?server=netease&type=url&id=${idParam}`
|
||
|
||
// 对于 Meting API，我们需要处理重定向
|
||
const response = await fetch(metingUrl, {
|
||
method: 'GET',
|
||
headers: source.headers || {},
|
||
redirect: 'follow'
|
||
})
|
||
|
||
if (response.ok && response.url) {
|
||
url = response.url
|
||
}
|
||
}
|
||
} catch (error: any) {
|
||
// Meting API 获取失败，继续回退其它音源
|
||
}
|
||
} else {
|
||
// 网易云备用API
|
||
let neteaseQuality: number | null = null
|
||
|
||
// 优先使用传入的 quality 参数
|
||
if (quality !== undefined && quality !== null) {
|
||
neteaseQuality = Number(quality)
|
||
} else {
|
||
// 否则回退到全局设置
|
||
try {
|
||
const { getQuality } = await import('./useAudioQuality')
|
||
neteaseQuality = Number(getQuality('netease'))
|
||
} catch (error) {
|
||
// 无法获取音质设置，使用默认音质
|
||
}
|
||
}
|
||
|
||
if (
|
||
neteaseQuality === null ||
|
||
Number.isNaN(neteaseQuality) ||
|
||
(!hasNeteaseLogin && neteaseQuality > 4)
|
||
) {
|
||
neteaseQuality = 4
|
||
}
|
||
|
||
const level = mapQualityToLevel(neteaseQuality)
|
||
|
||
// 如果提供了cookie，添加到请求参数中
|
||
const params: any = {
|
||
id: idParam,
|
||
level: level,
|
||
// 如果用户已登录（有cookie），默认不启用 unblock（false），否则启用（true）
|
||
unblock: options?.unblock ?? (!cookie)
|
||
}
|
||
if (cookie) {
|
||
params.cookie = cookie
|
||
}
|
||
|
||
const response = await $fetch(`${source.baseUrl}/song/url/v1`, {
|
||
params,
|
||
timeout: source.timeout || 8000
|
||
})
|
||
|
||
if (response?.code === 200 && Array.isArray(response.data) && response.data[0]?.url) {
|
||
url = response.data[0].url as string
|
||
}
|
||
}
|
||
|
||
if (url) {
|
||
// 修复HTTP/HTTPS协议问题
|
||
if (url.startsWith('http://')) {
|
||
url = url.replace('http://', 'https://')
|
||
}
|
||
|
||
// 验证播放链接
|
||
const validation = await validatePlayUrl(url)
|
||
|
||
if (validation.valid) {
|
||
return { success: true, url }
|
||
} else {
|
||
// 继续尝试下一个音源
|
||
}
|
||
} else {
|
||
// 未返回有效链接，继续尝试下一个音源
|
||
}
|
||
} catch (error: any) {
|
||
// 当前音源获取失败，继续尝试下一个音源
|
||
// 继续尝试下一个音源
|
||
}
|
||
}
|
||
|
||
return { success: false, error: '所有音源均无法获取有效的播放链接' }
|
||
} catch (error: any) {
|
||
return { success: false, error: error?.message || '未知错误' }
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 获取歌词（统一调度，支持优先级策略）
|
||
* NeteaseCloudMusicApi 优先，其次 vkeys；腾讯仅 vkeys
|
||
*/
|
||
const getLyrics = async (
|
||
platform: 'netease' | 'tencent',
|
||
id: number | string
|
||
): Promise<{
|
||
success: boolean
|
||
data?: { lrc: string; trans?: string; yrc?: string; ttml?: string }
|
||
error?: string
|
||
}> => {
|
||
try {
|
||
const settings = useLyricSettings()
|
||
const enabledSources = getEnabledSources()
|
||
const neteaseSource = enabledSources.find((source) => source.id.includes('netease-backup'))
|
||
const vkeysSource = enabledSources.find((source) => source.id === 'vkeys')
|
||
|
||
// 结果容器
|
||
const resultData = { lrc: '', trans: '', yrc: '', ttml: '' }
|
||
let hasResult = false
|
||
|
||
// 辅助函数：获取官方歌词 (网易云)
|
||
const fetchOfficial = async () => {
|
||
if (platform !== 'netease' || !neteaseSource) return
|
||
try {
|
||
const [lrcResp, yrcResp, ttmlResp] = await Promise.allSettled([
|
||
$fetch(`${neteaseSource.baseUrl}/lyric`, {
|
||
params: { id: id.toString() },
|
||
timeout: neteaseSource.timeout || 8000
|
||
}),
|
||
$fetch(`${neteaseSource.baseUrl}/lyric/new`, {
|
||
params: { id: id.toString() },
|
||
timeout: neteaseSource.timeout || 8000
|
||
}),
|
||
// 尝试获取 TTML 歌词
|
||
$fetch(`${neteaseSource.baseUrl}/lyric/ttml`, {
|
||
params: { id: id.toString() },
|
||
timeout: neteaseSource.timeout || 8000
|
||
}).catch(() => null)
|
||
])
|
||
|
||
if (lrcResp.status === 'fulfilled' && lrcResp.value?.code === 200) {
|
||
const lr = lrcResp.value
|
||
if (lr?.lrc?.lyric) resultData.lrc = lr.lrc.lyric
|
||
if (lr?.tlyric?.lyric) resultData.trans = lr.tlyric.lyric
|
||
}
|
||
if (yrcResp.status === 'fulfilled' && yrcResp.value?.code === 200) {
|
||
const yr = yrcResp.value
|
||
if (yr?.yrc?.lyric) resultData.yrc = yr.yrc.lyric
|
||
}
|
||
if (ttmlResp.status === 'fulfilled' && ttmlResp.value?.code === 200) {
|
||
const tr = ttmlResp.value
|
||
if (tr?.ttml && !resultData.ttml) resultData.ttml = tr.ttml
|
||
}
|
||
|
||
if (resultData.lrc || resultData.yrc || resultData.ttml) hasResult = true
|
||
} catch (e: any) {
|
||
console.warn('[getLyrics] NeteaseCloudMusicApi 获取失败:', e?.message || e)
|
||
}
|
||
}
|
||
|
||
// 辅助函数：获取 AMLL DB Server TTML
|
||
const fetchAMLL = async () => {
|
||
if (platform !== 'netease' || !settings.enableOnlineTTMLLyric.value) return
|
||
const serverUrl = settings.amllDbServer.value
|
||
if (!serverUrl) return
|
||
|
||
try {
|
||
const url = serverUrl.replace('%s', id.toString())
|
||
const ttml = await $fetch(url, { responseType: 'text' })
|
||
if (ttml && typeof ttml === 'string' && ttml.includes('<tt')) {
|
||
resultData.ttml = ttml
|
||
hasResult = true
|
||
}
|
||
} catch (e) {
|
||
// console.warn('[getLyrics] AMLL DB Server 获取失败')
|
||
}
|
||
}
|
||
|
||
// 辅助函数：获取 QQ 音乐 (vkeys)
|
||
const fetchQM = async () => {
|
||
if (!vkeysSource) return
|
||
// 如果禁用了 QM 歌词且不是强制 QM 模式，则跳过
|
||
if (!settings.enableQQMusicLyric.value && settings.lyricPriority.value !== 'qm') return
|
||
|
||
try {
|
||
let url: string
|
||
if (platform === 'netease') {
|
||
url = `${vkeysSource.baseUrl}/netease/lyric?id=${id}`
|
||
} else if (platform === 'tencent') {
|
||
url = `${vkeysSource.baseUrl}/tencent/lyric?id=${id}`
|
||
} else {
|
||
return
|
||
}
|
||
|
||
const resp = await $fetch(url, {
|
||
timeout: vkeysSource.timeout || 8000,
|
||
headers: {
|
||
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
|
||
}
|
||
})
|
||
if (resp?.code === 200 && resp?.data) {
|
||
const d = resp.data
|
||
if (d.lrc) resultData.lrc = d.lrc
|
||
if (d.trans) resultData.trans = d.trans
|
||
if (d.yrc) resultData.yrc = d.yrc // QRC
|
||
if (d.lrc || d.yrc) hasResult = true
|
||
}
|
||
} catch (e) {
|
||
console.warn('[getLyrics] vkeys 获取失败:', e)
|
||
}
|
||
}
|
||
|
||
// 优先级策略执行
|
||
const priority = settings.lyricPriority.value
|
||
console.log(`[getLyrics] 使用策略: ${priority}, 平台: ${platform}, ID: ${id}`)
|
||
|
||
if (priority === 'qm') {
|
||
await fetchQM()
|
||
if (!hasResult) {
|
||
await Promise.all([fetchAMLL(), fetchOfficial()])
|
||
}
|
||
} else if (priority === 'ttml') {
|
||
await fetchAMLL()
|
||
// 如果 AMLL 没拿到 TTML，尝试官方
|
||
if (!resultData.ttml) {
|
||
await fetchOfficial()
|
||
} else {
|
||
// 即使拿到了 TTML，也可能需要官方的 LRC/翻译 作为补充（如果 AMLL 只有 TTML）
|
||
// 但通常 TTML 足够了。为了保险起见，如果缺 LRC，可以去官方拿一下？
|
||
// SPlayer 逻辑是：fetchTTMLLyric -> fetchOfficialLyric -> fetchQQMusicLyric
|
||
// 这里简化：如果 fetchAMLL 成功，我们认为主要任务完成，但为了完整性（如翻译），可以尝试官方
|
||
if (!resultData.lrc || !resultData.trans) {
|
||
await fetchOfficial()
|
||
}
|
||
}
|
||
|
||
if (!hasResult) {
|
||
await fetchQM()
|
||
}
|
||
} else if (priority === 'official') {
|
||
await fetchOfficial()
|
||
} else {
|
||
// auto / default
|
||
if (settings.enableQQMusicLyric.value) {
|
||
await fetchQM()
|
||
}
|
||
await Promise.all([fetchAMLL(), fetchOfficial()])
|
||
}
|
||
|
||
// 检查是否有结果
|
||
if (hasResult) {
|
||
return { success: true, data: resultData }
|
||
}
|
||
|
||
// 最后尝试 Meting API（仅支持网易云，作为最后的 Fallback）
|
||
if (platform === 'netease') {
|
||
const metingSources = enabledSources.filter((source) => source.id.startsWith('meting-'))
|
||
|
||
for (const metingSource of metingSources) {
|
||
try {
|
||
const metingUrl = `${metingSource.baseUrl}/?server=netease&type=lrc&id=${id}`
|
||
const resp = await $fetch(metingUrl, {
|
||
timeout: metingSource.timeout || 8000,
|
||
headers: metingSource.headers
|
||
})
|
||
|
||
// Meting API 直接返回歌词文本
|
||
if (resp && typeof resp === 'string' && resp.trim()) {
|
||
return {
|
||
success: true,
|
||
data: {
|
||
lrc: resp,
|
||
trans: '',
|
||
yrc: '',
|
||
ttml: ''
|
||
}
|
||
}
|
||
}
|
||
} catch (error: any) {
|
||
console.warn(
|
||
`[getLyrics] Meting API ${metingSource.name} 获取失败:`,
|
||
error?.message || error
|
||
)
|
||
}
|
||
}
|
||
}
|
||
|
||
return { success: false, error: '未获取到歌词' }
|
||
} catch (error: any) {
|
||
console.error('[getLyrics] 获取歌词失败:', error)
|
||
return { success: false, error: error?.message || '未知错误' }
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 转换 Vkeys API 响应
|
||
*/
|
||
const transformVkeysResponse = (response: any, platform: string = 'netease'): any[] => {
|
||
console.log('[transformVkeysResponse] 开始转换数据:', { platform, response })
|
||
|
||
if (!response) {
|
||
console.log('[transformVkeysResponse] 响应为空')
|
||
throw new Error('API响应为空')
|
||
}
|
||
|
||
// 检查错误码，非200状态码抛出错误以触发备用源重试
|
||
if (response.code !== 200) {
|
||
const errorMessage = `vkeys API错误: ${response.message || '未知错误'} (code: ${response.code})`
|
||
console.log('[transformVkeysResponse] API错误:', errorMessage)
|
||
throw new Error(errorMessage)
|
||
}
|
||
|
||
if (!response.data) {
|
||
console.log('[transformVkeysResponse] 响应数据为空')
|
||
throw new Error('API响应数据为空')
|
||
}
|
||
|
||
if (platform === 'tencent') {
|
||
// QQ音乐返回数组格式
|
||
const songs = Array.isArray(response.data) ? response.data : [response.data]
|
||
console.log(`[transformVkeysResponse] QQ音乐处理 ${songs.length} 首歌曲`)
|
||
|
||
return songs.map((song: any, index: number) => {
|
||
const transformedSong = {
|
||
id: song.id || song.musicId,
|
||
title: song.song || song.name || song.title,
|
||
artist: song.singer || song.artist || '未知艺术家',
|
||
cover: song.cover,
|
||
album: song.album,
|
||
duration: song.duration || song.dt,
|
||
musicPlatform: 'tencent',
|
||
musicId: (song.id || song.musicId)?.toString(),
|
||
url: song.url, // 添加vkeys API返回的播放链接
|
||
hasUrl: !!song.url, // 标记是否有播放链接
|
||
sourceInfo: {
|
||
source: 'vkeys',
|
||
originalId: (song.id || song.musicId)?.toString(),
|
||
fetchedAt: new Date(),
|
||
mid: song.mid, // QQ音乐特有的mid字段
|
||
vid: song.vid, // QQ音乐特有的vid字段
|
||
quality: song.quality,
|
||
pay: song.pay,
|
||
subtitle: song.subtitle,
|
||
time: song.time,
|
||
type: song.type,
|
||
bpm: song.bpm,
|
||
grp: song.grp
|
||
}
|
||
}
|
||
console.log(`[transformVkeysResponse] QQ音乐转换歌曲 ${index + 1}:`, transformedSong)
|
||
return transformedSong
|
||
})
|
||
} else {
|
||
// 网易云返回数组格式
|
||
const songs = Array.isArray(response.data) ? response.data : [response.data]
|
||
console.log(`[transformVkeysResponse] 网易云处理 ${songs.length} 首歌曲`)
|
||
|
||
return songs.map((song: any, index: number) => {
|
||
const transformedSong = {
|
||
id: song.id,
|
||
title: song.song,
|
||
artist: song.singer || '未知艺术家',
|
||
cover: song.cover?.trim(), // 去除可能的空格
|
||
album: song.album,
|
||
duration: song.interval || song.time, // 网易云使用interval字段表示时长，备用time字段
|
||
musicPlatform: 'netease',
|
||
musicId: song.id?.toString(),
|
||
url: song.url, // 添加vkeys API返回的播放链接
|
||
hasUrl: !!song.url, // 标记是否有播放链接
|
||
sourceInfo: {
|
||
source: 'vkeys',
|
||
originalId: song.id?.toString(),
|
||
fetchedAt: new Date(),
|
||
quality: song.quality,
|
||
size: song.size,
|
||
kbps: song.kbps,
|
||
url: song.url,
|
||
link: song.link,
|
||
time: song.time
|
||
}
|
||
}
|
||
console.log(`[transformVkeysResponse] 网易云转换歌曲 ${index + 1}:`, transformedSong)
|
||
return transformedSong
|
||
})
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 转换 Vkeys v3 QQ音乐搜索响应
|
||
* 文档: https://doc.vkeys.cn/v3/音乐模块/QQ音乐/搜索相关接口/2-song.html
|
||
*/
|
||
const transformVkeysV3TencentSearch = (response: any): any[] => {
|
||
if (!response) throw new Error('API响应为空')
|
||
if (typeof response.code !== 'number') throw new Error('响应缺少状态码')
|
||
|
||
// v3 成功码为 0
|
||
if (response.code !== 0) {
|
||
const msg = `vkeys v3 API错误: ${response.message || '未知错误'} (code: ${response.code})`
|
||
throw new Error(msg)
|
||
}
|
||
|
||
const data = response.data
|
||
if (!data || !Array.isArray(data.list)) {
|
||
throw new Error('v3 响应数据格式不正确')
|
||
}
|
||
|
||
return data.list.map((item: any) => {
|
||
const id = item.songID ?? item.songId ?? item.id
|
||
const duration = item.interval ?? item.duration
|
||
return {
|
||
id,
|
||
title: item.title,
|
||
artist: Array.isArray(item.singerList)
|
||
? item.singerList.map((s: any) => s.name).join('/')
|
||
: item.singer || '',
|
||
cover: item.albumImage || item.cover || '',
|
||
album: item.album || '',
|
||
duration,
|
||
musicPlatform: 'tencent',
|
||
musicId: id?.toString(),
|
||
url: undefined,
|
||
hasUrl: false,
|
||
sourceInfo: {
|
||
source: 'vkeys-v3',
|
||
originalId: id?.toString(),
|
||
fetchedAt: new Date(),
|
||
mid: item.songMID || item.mid,
|
||
vid: item.vid,
|
||
quality: item.quality,
|
||
pay: item.pay,
|
||
subtitle: item.subtitle,
|
||
time: item.time,
|
||
type: item.type,
|
||
bpm: item.bpm,
|
||
grp: item.grp
|
||
}
|
||
}
|
||
})
|
||
}
|
||
|
||
/**
|
||
* 转换网易云 API 搜索响应
|
||
* 实现两步搜索：处理搜索结果，然后批量获取歌曲详情和封面
|
||
*/
|
||
const transformNeteaseResponse = async (response: any): Promise<any[]> => {
|
||
console.log('[transformNeteaseResponse] 开始转换数据:', response)
|
||
|
||
// 检查响应是否存在
|
||
if (!response) {
|
||
throw new Error('API响应为空')
|
||
}
|
||
|
||
// 检查API响应状态码
|
||
if (response.code !== undefined && response.code !== 200) {
|
||
throw new Error(`API响应错误: ${response.message || '未知错误'} (code: ${response.code})`)
|
||
}
|
||
|
||
// 尝试获取结果列表，支持多种类型（单曲、电台、声音等）
|
||
const result = response.result || response.data
|
||
if (!result) {
|
||
throw new Error('API响应格式错误: 缺少result/data字段')
|
||
}
|
||
|
||
let items =
|
||
result.songs || result.djRadios || result.resources || result.voices || result.list || []
|
||
|
||
// 如果是声音搜索(type=2000)，结果可能在 data.resources 或 data.list 中
|
||
if (!items || items.length === 0) {
|
||
if (result.data?.resources) {
|
||
items = result.data.resources
|
||
} else if (result.list) {
|
||
items = result.list
|
||
} else if (Array.isArray(result)) {
|
||
items = result
|
||
}
|
||
}
|
||
|
||
if (!Array.isArray(items)) {
|
||
console.error('[transformNeteaseResponse] 无效的响应结构:', {
|
||
keys: Object.keys(result),
|
||
itemsType: typeof items
|
||
})
|
||
// 如果找不到列表但也不是错误，可能就是没结果
|
||
return []
|
||
}
|
||
|
||
console.log(`[transformNeteaseResponse] 找到 ${items.length} 个结果`)
|
||
|
||
if (items.length === 0) {
|
||
return []
|
||
}
|
||
|
||
// 检查是否是歌曲类型的完整信息
|
||
// 只有当 items 是 songs 且包含 al.picUrl 时才认为是完整信息的歌曲
|
||
const isSongType = !!result.songs
|
||
const hasCompleteInfo = isSongType && items.some((item: any) => item.al?.picUrl)
|
||
console.log(
|
||
`[transformNeteaseResponse] 结果类型: ${isSongType ? '歌曲' : '其他'}, 完整信息: ${hasCompleteInfo}`
|
||
)
|
||
|
||
let detailResponse: any = null
|
||
const detailMap = new Map()
|
||
|
||
// 如果是search接口响应的歌曲（缺少完整信息），则需要获取详情
|
||
if (isSongType && !hasCompleteInfo) {
|
||
// 获取网易云备用源
|
||
const enabledSources = getEnabledSources()
|
||
const neteaseSource = enabledSources.find((source) => source.id.includes('netease-backup'))
|
||
|
||
if (neteaseSource) {
|
||
// 提取所有歌曲ID，准备批量获取详情
|
||
const songIds = items.map((song: any) => song.id).filter((id: any) => id)
|
||
console.log(`[transformNeteaseResponse] 准备批量获取 ${songIds.length} 首歌曲的详情`)
|
||
|
||
if (songIds.length > 0) {
|
||
try {
|
||
// 批量获取歌曲详情，包含封面信息
|
||
detailResponse = await $fetch(`${neteaseSource.baseUrl}/song/detail`, {
|
||
params: { ids: songIds.join(',') },
|
||
timeout: neteaseSource.timeout || 8000
|
||
})
|
||
console.log(`[transformNeteaseResponse] 批量获取详情成功`)
|
||
} catch (error) {
|
||
console.warn(
|
||
'[transformNeteaseResponse] 批量获取详情失败，将使用搜索结果的基本信息:',
|
||
error
|
||
)
|
||
}
|
||
}
|
||
|
||
// 创建详情映射，方便查找
|
||
if (detailResponse?.songs) {
|
||
detailResponse.songs.forEach((song: any) => {
|
||
detailMap.set(song.id, song)
|
||
})
|
||
}
|
||
}
|
||
}
|
||
|
||
// 转换搜索结果，根据接口类型使用不同的数据提取策略
|
||
return items
|
||
.map((item: any, index: number) => {
|
||
try {
|
||
let id = item.id
|
||
let title = item.name
|
||
let cover: string | null = null
|
||
let artist: string = '未知艺术家'
|
||
let album: string | undefined
|
||
let duration: number = 0
|
||
let musicId = item.id?.toString()
|
||
|
||
// 处理不同类型的数据结构
|
||
if (isSongType) {
|
||
// 歌曲类型处理
|
||
if (hasCompleteInfo) {
|
||
// cloudsearch接口响应，包含完整信息
|
||
cover = item.al?.picUrl || null
|
||
artist = item.ar?.map((a: any) => a.name).join('/') || '未知艺术家'
|
||
album = item.al?.name
|
||
duration = item.dt || 0
|
||
} else {
|
||
// search接口响应，需要从详情中获取信息
|
||
const detail = detailMap.get(item.id)
|
||
cover =
|
||
detail?.al?.picUrl ||
|
||
(item.album?.picId
|
||
? `https://p1.music.126.net/${item.album.picId}/${item.album.picId}.jpg`
|
||
: null)
|
||
artist = item.artists?.map((a: any) => a.name).join('/') || '未知艺术家'
|
||
album = item.album?.name
|
||
duration = item.duration || 0
|
||
}
|
||
} else {
|
||
// 其他类型（如声音、电台等）
|
||
// 尝试适配声音/播客结构
|
||
const baseInfo = item.baseInfo || item
|
||
|
||
// 优先使用 mainSong.id (声音) 或 mainTrackId (电台节目) 作为歌曲ID，以便能通过 song/url 接口播放
|
||
// 如果都没有，才使用 baseInfo.id (节目ID)
|
||
const songId = baseInfo.mainSong?.id || baseInfo.mainTrackId || baseInfo.id
|
||
id = songId || id
|
||
|
||
title = baseInfo.name || title
|
||
cover = baseInfo.coverUrl || baseInfo.picUrl || item.picUrl || null
|
||
|
||
// 尝试获取艺术家/主播信息
|
||
if (baseInfo.dj) {
|
||
artist = baseInfo.dj.nickname
|
||
} else if (item.dj) {
|
||
artist = item.dj.nickname
|
||
} else if (baseInfo.artist) {
|
||
artist = baseInfo.artist.name
|
||
}
|
||
|
||
// 尝试获取专辑/电台信息
|
||
if (baseInfo.radio) {
|
||
album = baseInfo.radio.name
|
||
} else if (item.radio) {
|
||
album = item.radio.name
|
||
}
|
||
|
||
duration = baseInfo.duration || item.duration || 0
|
||
|
||
// 声音ID
|
||
musicId = id?.toString()
|
||
}
|
||
|
||
const transformedSong = {
|
||
id: id,
|
||
title: title,
|
||
artist,
|
||
cover,
|
||
album,
|
||
duration,
|
||
musicPlatform: isSongType ? 'netease' : 'netease-podcast',
|
||
musicId: musicId,
|
||
sourceInfo: {
|
||
source: 'netease-backup',
|
||
originalId: musicId,
|
||
fetchedAt: new Date(),
|
||
hasDetail: hasCompleteInfo || !!detailMap.get(item.id),
|
||
interface: hasCompleteInfo ? 'cloudsearch' : 'search',
|
||
type: isSongType ? 'song' : 'voice'
|
||
}
|
||
}
|
||
// 只打印前几个结果，避免日志过多
|
||
if (index < 3) {
|
||
console.log(`[transformNeteaseResponse] 转换结果 ${index + 1}:`, transformedSong)
|
||
}
|
||
return transformedSong
|
||
} catch (error: any) {
|
||
console.error(
|
||
`[transformNeteaseResponse] 转换第 ${index + 1} 个结果失败:`,
|
||
error.message,
|
||
item
|
||
)
|
||
// 不抛出错误，而是跳过该项
|
||
return null
|
||
}
|
||
})
|
||
.filter((item: any) => item !== null)
|
||
}
|
||
|
||
/**
|
||
* 转换网易云 API 详情响应
|
||
*/
|
||
const transformNeteaseDetailResponse = (response: any): any[] => {
|
||
return response.songs.map((song: any) => ({
|
||
id: song.id,
|
||
title: song.name,
|
||
artist: song.ar?.map((artist: any) => artist.name).join('/') || '未知艺术家',
|
||
cover: song.al?.picUrl,
|
||
album: song.al?.name,
|
||
duration: song.dt,
|
||
fee: song.fee,
|
||
privilege: song.privilege,
|
||
musicPlatform: 'netease',
|
||
musicId: song.id.toString(),
|
||
sourceInfo: {
|
||
source: 'netease-backup',
|
||
originalId: song.id.toString(),
|
||
fetchedAt: new Date()
|
||
}
|
||
}))
|
||
}
|
||
|
||
/**
|
||
* 获取音源状态摘要
|
||
*/
|
||
const getSourceStatusSummary = computed(() => {
|
||
const summary = {
|
||
total: config.value.sources.length,
|
||
online: 0,
|
||
offline: 0,
|
||
error: 0,
|
||
unknown: 0
|
||
}
|
||
|
||
config.value.sources.forEach((source) => {
|
||
const status = sourceStatus.value[source.id]
|
||
if (!status) {
|
||
summary.unknown++
|
||
} else {
|
||
summary[status.status]++
|
||
}
|
||
})
|
||
|
||
return summary
|
||
})
|
||
|
||
/**
|
||
* 获取当前音源信息
|
||
*/
|
||
const getCurrentSourceInfo = computed(() => {
|
||
const source = getSourceById(currentSource.value)
|
||
const status = sourceStatus.value[currentSource.value]
|
||
|
||
return {
|
||
source,
|
||
status,
|
||
isHealthy: status?.status === 'online'
|
||
}
|
||
})
|
||
|
||
/**
|
||
* 获取电台/播客节目列表
|
||
*/
|
||
const getDjPrograms = async (
|
||
radioId: string | number,
|
||
limit: number = 20,
|
||
offset: number = 0,
|
||
cookie?: string
|
||
): Promise<{
|
||
success: boolean
|
||
programs: any[]
|
||
count: number
|
||
more: boolean
|
||
error?: string
|
||
}> => {
|
||
const enabledSources = getEnabledSources()
|
||
// 优先使用网易云备用源
|
||
const neteaseSources = enabledSources.filter((source) => source.id.includes('netease-backup'))
|
||
|
||
// 如果没有找到网易云备用源，尝试其他可能支持的源（虽然目前只有备用源支持此接口）
|
||
if (neteaseSources.length === 0) {
|
||
return {
|
||
success: false,
|
||
programs: [],
|
||
count: 0,
|
||
more: false,
|
||
error: '未找到可用的网易云音源'
|
||
}
|
||
}
|
||
|
||
// 尝试所有网易云源
|
||
for (const source of neteaseSources) {
|
||
try {
|
||
let cookieParam = ''
|
||
if (cookie) {
|
||
cookieParam = `&cookie=${encodeURIComponent(cookie)}`
|
||
}
|
||
|
||
const url = `${source.baseUrl}/dj/program?rid=${radioId}&limit=${limit}&offset=${offset}${cookieParam}`
|
||
console.log(`[getDjPrograms] Requesting: ${url}`)
|
||
|
||
const response: any = await $fetch(url, {
|
||
timeout: source.timeout || 8000
|
||
})
|
||
|
||
if (response.code === 200) {
|
||
return {
|
||
success: true,
|
||
programs: response.programs || [],
|
||
count: response.count || 0,
|
||
more: response.more || false
|
||
}
|
||
}
|
||
} catch (e: any) {
|
||
console.warn(`[getDjPrograms] Source ${source.id} failed:`, e.message)
|
||
}
|
||
}
|
||
|
||
return { success: false, programs: [], count: 0, more: false, error: '获取节目列表失败' }
|
||
}
|
||
|
||
return {
|
||
// 状态
|
||
config: readonly(config),
|
||
currentSource: readonly(currentSource),
|
||
sourceStatus: readonly(sourceStatus),
|
||
isSearching: readonly(isSearching),
|
||
lastUsedSource: readonly(lastUsedSource),
|
||
|
||
// 计算属性
|
||
sourceStatusSummary: getSourceStatusSummary,
|
||
currentSourceInfo: getCurrentSourceInfo,
|
||
|
||
// 方法
|
||
searchSongs,
|
||
getSongDetail,
|
||
getSongUrl,
|
||
getLyrics,
|
||
getMetingSongInfo,
|
||
updateSourceStatus,
|
||
validatePlayUrl,
|
||
getDjPrograms
|
||
}
|
||
}
|