/**
|
* 音频管理工具
|
* 负责语音播放、音频队列管理等功能
|
*/
|
|
export class AudioManager {
|
constructor() {
|
this.audioContext = null;
|
this.audioTimer = null;
|
this.audioInterval = 3000;
|
this.isAudioPlaying = false;
|
this.audioQueue = [];
|
this.audioPlayEnabled = true;
|
this.language = 'zh';
|
|
// 多语言语音文件配置
|
this.audioFiles = {
|
zh: {
|
red: '/static/chvoice/voice2/red.mp3',
|
yellow: '/static/chvoice/voice2/yellow.mp3',
|
green: '/static/chvoice/voice2/green.mp3'
|
},
|
en: {
|
red: '/static/envoice/voice2/red.mp3',
|
yellow: '/static/envoice/voice2/yellow.mp3',
|
green: '/static/envoice/voice2/green.mp3'
|
},
|
ru: {
|
red: '/static/pyvoice/voice2/red.mp3',
|
yellow: '/static/pyvoice/voice2/yellow.mp3',
|
green: '/static/pyvoice/voice2/green.mp3'
|
}
|
};
|
}
|
|
/**
|
* 初始化音频上下文
|
*/
|
initAudioContext() {
|
try {
|
this.audioContext = uni.createInnerAudioContext();
|
this.audioContext.onError((res) => {
|
console.error('音频播放失败:', res);
|
this.isAudioPlaying = false;
|
this.playNextInQueue();
|
});
|
this.audioContext.onEnded(() => {
|
this.isAudioPlaying = false;
|
this.playNextInQueue();
|
});
|
console.log('音频上下文初始化成功');
|
} catch (error) {
|
console.error('音频上下文初始化失败:', error);
|
}
|
}
|
|
/**
|
* 检查音频播放状态
|
*/
|
checkAudioPlaybackStatus() {
|
try {
|
if (this.audioContext) {
|
this.audioContext.destroy();
|
}
|
this.initAudioContext();
|
} catch (error) {
|
console.error('检查音频播放状态失败:', error);
|
}
|
}
|
|
/**
|
* 播放语音
|
*/
|
playVoice(layer, language = null) {
|
if (!this.audioPlayEnabled || this.isAudioPlaying) {
|
return;
|
}
|
|
const lang = language || this.language;
|
const audioFile = this.audioFiles[lang]?.[layer];
|
|
if (!audioFile) {
|
console.error('语音文件不存在:', layer, lang);
|
return;
|
}
|
|
this.playAudioFile(audioFile);
|
}
|
|
/**
|
* 播放音频文件
|
*/
|
playAudioFile(audioFile) {
|
if (!this.audioContext || this.isAudioPlaying) {
|
return;
|
}
|
|
try {
|
this.isAudioPlaying = true;
|
this.audioContext.src = audioFile;
|
this.audioContext.play();
|
console.log('开始播放音频:', audioFile);
|
} catch (error) {
|
console.error('播放音频失败:', error);
|
this.isAudioPlaying = false;
|
}
|
}
|
|
/**
|
* 添加音频到播放队列
|
*/
|
addToAudioQueue(layer, language = null) {
|
if (!this.audioPlayEnabled) return;
|
|
const lang = language || this.language;
|
const audioFile = this.audioFiles[lang]?.[layer];
|
|
if (audioFile) {
|
this.audioQueue.push(audioFile);
|
console.log('添加音频到队列:', audioFile);
|
|
if (!this.isAudioPlaying) {
|
this.playNextInQueue();
|
}
|
}
|
}
|
|
/**
|
* 播放队列中的下一个音频
|
*/
|
playNextInQueue() {
|
if (this.audioQueue.length === 0 || this.isAudioPlaying) {
|
return;
|
}
|
|
const nextAudio = this.audioQueue.shift();
|
this.playAudioFile(nextAudio);
|
}
|
|
/**
|
* 清空音频队列
|
*/
|
clearAudioQueue() {
|
this.audioQueue = [];
|
console.log('音频队列已清空');
|
}
|
|
/**
|
* 停止音频播放
|
*/
|
stopAudio() {
|
if (this.audioContext) {
|
this.audioContext.stop();
|
this.isAudioPlaying = false;
|
}
|
this.clearAudioQueue();
|
}
|
|
/**
|
* 设置语言
|
*/
|
setLanguage(language) {
|
this.language = language;
|
console.log('音频语言已设置为:', language);
|
}
|
|
/**
|
* 设置音频播放开关
|
*/
|
setAudioEnabled(enabled) {
|
this.audioPlayEnabled = enabled;
|
if (!enabled) {
|
this.stopAudio();
|
}
|
console.log('音频播放开关:', enabled ? '开启' : '关闭');
|
}
|
|
/**
|
* 设置音频播放间隔
|
*/
|
setAudioInterval(interval) {
|
this.audioInterval = interval;
|
console.log('音频播放间隔已设置为:', interval, 'ms');
|
}
|
|
/**
|
* 销毁音频上下文
|
*/
|
destroy() {
|
if (this.audioContext) {
|
this.audioContext.destroy();
|
this.audioContext = null;
|
}
|
this.isAudioPlaying = false;
|
this.clearAudioQueue();
|
console.log('音频管理器已销毁');
|
}
|
}
|
|
/**
|
* 扇形状态管理工具类
|
*/
|
export class SectorStateManager {
|
constructor() {
|
this.activeSectors = new Map();
|
this.updateTimer = null;
|
this.updateInterval = APP_CONFIG.SECTOR.UPDATE_INTERVAL;
|
}
|
|
/**
|
* 启动扇形更新定时器
|
*/
|
startSectorUpdateTimer() {
|
// 清除之前的定时器
|
if (this.updateTimer) {
|
clearInterval(this.updateTimer);
|
}
|
|
// 启动扇形更新定时器
|
this.updateTimer = setInterval(() => {
|
this.updateSectorDisplay();
|
}, this.updateInterval);
|
|
console.log('扇形更新定时器已启动');
|
}
|
|
/**
|
* 更新活跃扇形状态
|
* @param {Map} newSectors - 新的扇形状态
|
*/
|
updateActiveSectors(newSectors) {
|
// 清空当前活跃扇形
|
this.activeSectors.clear();
|
|
// 添加新的活跃扇形
|
newSectors.forEach((sectorInfo, sectorKey) => {
|
this.activeSectors.set(sectorKey, sectorInfo);
|
});
|
|
console.log('活跃扇形状态已更新，当前活跃扇形数量:', this.activeSectors.size);
|
}
|
|
/**
|
* 更新扇形显示
|
* @param {Array} circleColors - 扇形颜色数组
|
* @param {boolean} isOffline - 是否离线
|
* @param {Function} updateCallback - 更新回调函数
|
*/
|
updateSectorDisplay(circleColors, isOffline, updateCallback) {
|
// 先重置所有扇形为灰色
|
this.resetAllColors(circleColors);
|
|
// 如果处于离线状态，保持灰色
|
if (isOffline) {
|
console.log('离线状态，保持扇形灰色');
|
return;
|
}
|
|
// 显示当前活跃的扇形
|
let updatedCount = 0;
|
this.activeSectors.forEach((sectorInfo, sectorKey) => {
|
const { layerIndex, sectorIndex, color } = sectorInfo;
|
|
// 验证索引有效性
|
if (layerIndex >= 0 && layerIndex < circleColors.length &&
|
sectorIndex >= 0 && sectorIndex < circleColors[layerIndex].length) {
|
|
// 更新扇形颜色
|
updateCallback(layerIndex, sectorIndex, color);
|
updatedCount++;
|
} else {
|
console.warn('扇形索引无效:', { layerIndex, sectorIndex, sectorKey });
|
}
|
});
|
|
if (updatedCount > 0) {
|
console.log(`扇形显示已更新，更新了${updatedCount}个扇形`);
|
}
|
}
|
|
/**
|
* 重置所有扇形为灰色
|
* @param {Array} circleColors - 扇形颜色数组
|
*/
|
resetAllColors(circleColors) {
|
for (let layerIndex = 0; layerIndex < circleColors.length; layerIndex++) {
|
for (let sectorIndex = 0; sectorIndex < circleColors[layerIndex].length; sectorIndex++) {
|
circleColors[layerIndex][sectorIndex] = APP_CONFIG.COLORS.DEFAULT_SECTOR;
|
}
|
}
|
}
|
|
/**
|
* 清空所有扇形
|
*/
|
clearAllSectors() {
|
// 清空活跃扇形状态
|
this.activeSectors.clear();
|
console.log('所有扇形已清空');
|
}
|
|
/**
|
* 强制触发扇形更新
|
* @param {Array} circleColors - 扇形颜色数组
|
* @param {boolean} isOffline - 是否离线
|
* @param {Function} updateCallback - 更新回调函数
|
*/
|
forceUpdateSectors(circleColors, isOffline, updateCallback) {
|
console.log('强制触发扇形更新');
|
this.updateSectorDisplay(circleColors, isOffline, updateCallback);
|
}
|
|
/**
|
* 销毁扇形状态管理器
|
*/
|
destroy() {
|
if (this.updateTimer) {
|
clearInterval(this.updateTimer);
|
this.updateTimer = null;
|
}
|
this.activeSectors.clear();
|
}
|
}
|
|
/**
|
* 离线检测管理工具类
|
*/
|
export class OfflineDetectionManager {
|
constructor() {
|
this.lastDataTime = 0;
|
this.offlineTimer = null;
|
this.offlineTimeout = APP_CONFIG.OFFLINE.TIMEOUT;
|
this.checkInterval = APP_CONFIG.OFFLINE.CHECK_INTERVAL;
|
this.isOffline = false;
|
}
|
|
/**
|
* 启动离线检测机制
|
*/
|
startOfflineDetection() {
|
// 清除之前的定时器
|
if (this.offlineTimer) {
|
clearInterval(this.offlineTimer);
|
}
|
|
// 启动离线检测定时器
|
this.offlineTimer = setInterval(() => {
|
const currentTime = Date.now();
|
const timeSinceLastData = currentTime - this.lastDataTime;
|
|
// 如果超过超时时间没有收到数据，判定为离线
|
if (timeSinceLastData > this.offlineTimeout && !this.isOffline) {
|
console.log('检测到离线状态，清空所有扇形');
|
this.isOffline = true;
|
this.onOfflineDetected();
|
}
|
}, this.checkInterval);
|
|
console.log('离线检测机制已启动');
|
}
|
|
/**
|
* 更新最后数据接收时间
|
*/
|
updateLastDataTime() {
|
this.lastDataTime = Date.now();
|
this.isOffline = false;
|
}
|
|
/**
|
* 离线检测回调
|
* @param {Function} callback - 离线检测回调函数
|
*/
|
setOfflineCallback(callback) {
|
this.onOfflineDetected = callback;
|
}
|
|
/**
|
* 重置离线状态
|
*/
|
resetOfflineState() {
|
this.isOffline = false;
|
this.lastDataTime = Date.now();
|
}
|
|
/**
|
* 销毁离线检测管理器
|
*/
|
destroy() {
|
if (this.offlineTimer) {
|
clearInterval(this.offlineTimer);
|
this.offlineTimer = null;
|
}
|
}
|
}
|
|
/**
|
* 获取当前时间字符串
|
* @returns {string} 时间字符串
|
*/
|
export function getTime() {
|
const now = new Date();
|
const hour = String(now.getHours()).padStart(2, '0');
|
const minute = String(now.getMinutes()).padStart(2, '0');
|
const second = String(now.getSeconds()).padStart(2, '0');
|
return `${hour}:${minute}:${second}`;
|
}
|
