/**
|
* 语音合成工具类
|
* @class SpeechSynthesisUtil
|
* @description 用于处理文字转语音的工具类,包含音频播放、合成等功能
|
*/
|
|
// 事件类型枚举
|
export enum EventType {
|
STATE_CHANGE = 'stateChange',
|
SYNTHESIS_START = 'synthesisStart',
|
SYNTHESIS_END = 'synthesisEnd',
|
AUDIO_PLAY = 'audioPlay',
|
AUDIO_END = 'audioEnd',
|
ERROR = 'error',
|
PROGRESS = 'progress',
|
PAUSE = 'pause',
|
RESUME = 'resume'
|
}
|
|
// 状态接口
|
interface State {
|
isInterrupted: boolean;
|
isStartPlayQueue: boolean;
|
isPlaying: boolean;
|
isEnded: boolean;
|
isError: boolean;
|
isPaused: boolean;
|
isSynthesizing: boolean;
|
needsUserInteraction: boolean;
|
}
|
|
// 构造函数选项接口
|
interface SpeechSynthesisOptions {
|
API_KEY: string;
|
GroupId: string;
|
MAX_QUEUE_LENGTH?: number;
|
modelConfig?: any;
|
}
|
|
// 音频文本队列项接口
|
interface AudioTextQueueItem {
|
text: string;
|
audio: string;
|
}
|
|
// API响应接口
|
interface ApiResponse {
|
data: {
|
data: {
|
audio: string;
|
};
|
};
|
}
|
|
class SpeechSynthesisUtil {
|
private API_KEY: string;
|
private GroupId: string;
|
private modelConfig: any;
|
private audioContext: UniApp.InnerAudioContext | null = null;
|
private audioQueue: string[] = [];
|
private audioTextQueue: AudioTextQueueItem[] = [];
|
private state: State;
|
private fileManager: UniApp.FileSystemManager | null = null;
|
private pendingAudioUrl: string | null = null;
|
private eventListeners: Map<EventType, Set<Function>>;
|
private timer: { start: number; end: number };
|
private modelContent: string = '';
|
private MAX_QUEUE_LENGTH: number;
|
private totalAudioCount: number = 0; // 记录总的音频数量
|
|
constructor(options: SpeechSynthesisOptions) {
|
this.API_KEY = options.API_KEY;
|
this.GroupId = options.GroupId;
|
this.MAX_QUEUE_LENGTH = options.MAX_QUEUE_LENGTH || 3;
|
this.modelConfig = options.modelConfig || {};
|
this.state = {
|
isInterrupted: false,
|
isStartPlayQueue: false,
|
isPlaying: false,
|
isEnded: false,
|
isError: false,
|
isPaused: false,
|
isSynthesizing: false,
|
needsUserInteraction: false
|
};
|
|
try {
|
if (typeof uni !== 'undefined' && uni.getFileSystemManager) {
|
this.fileManager = uni.getFileSystemManager();
|
}
|
} catch (error) {
|
console.warn('文件系统管理器初始化失败，将使用临时文件存储');
|
}
|
|
this.eventListeners = new Map();
|
this.timer = { start: 0, end: 0 };
|
|
// 绑定方法
|
this.handleAudioPlay = this.handleAudioPlay.bind(this);
|
this.handleAudioEnd = this.handleAudioEnd.bind(this);
|
this.handleAudioError = this.handleAudioError.bind(this);
|
}
|
|
/**
|
* 文字转语音方法
|
* @param text - 需要转换的文本
|
*/
|
public async textToSpeech(text: string): Promise<void> {
|
if (!text) return;
|
|
// 检查是否已经在队列中
|
if (this.audioTextQueue.some(item => item.text === text)) {
|
return;
|
}
|
|
this.emit(EventType.SYNTHESIS_START, { text });
|
|
if (this.audioQueue.length === 0) {
|
this.startTimer();
|
this.totalAudioCount = 0;
|
}
|
|
// 等待之前的合成完成
|
if (this.state.isSynthesizing) {
|
await new Promise<void>((resolve) => {
|
const checkSynthesis = setInterval(() => {
|
if (!this.state.isSynthesizing) {
|
clearInterval(checkSynthesis);
|
resolve();
|
}
|
}, 100);
|
});
|
}
|
|
this.setState({ isSynthesizing: true, isError: false });
|
|
try {
|
const response = await this.requestSynthesis(text);
|
await this.processAudioResponse(response, text);
|
await this.startPlayingIfNeeded();
|
this.emit(EventType.SYNTHESIS_END, { text });
|
} catch (error) {
|
this.emit(EventType.ERROR, { error, text });
|
throw error;
|
} finally {
|
this.setState({ isSynthesizing: false });
|
}
|
}
|
|
/**
|
* 请求语音合成
|
* @param text - 需要合成的文本
|
* @private
|
*/
|
private async requestSynthesis(text: string): Promise<ApiResponse> {
|
try {
|
return new Promise((resolve, reject) => {
|
uni.request({
|
url: `https://api.minimax.chat/v1/t2a_v2?GroupId=${this.GroupId}`,
|
method: 'POST',
|
header: {
|
"Authorization": `Bearer ${this.API_KEY}`,
|
"Content-Type": "application/json;charset=utf-8"
|
},
|
data: {
|
// 默认配置
|
model: "speech-01-turbo-240228",
|
text,
|
stream: false,
|
voice_setting: {
|
voice_id: 'female-yujie',
|
speed: 1.2,
|
vol: 1.0,
|
...(this.modelConfig?.voice_setting || {}) // 合并用户配置的voice_setting
|
},
|
audio_setting: {
|
audio_sample_rate: 32000,
|
bitrate: 128000,
|
format: "mp3",
|
channel: 2,
|
...(this.modelConfig?.audio_setting || {}) // 合并用户配置的audio_setting
|
},
|
...(this.modelConfig || {}) // 合并其他用户配置
|
},
|
success: (res: ApiResponse) => {
|
if (!res.data?.data?.audio) {
|
reject(new Error('API 响应格式错误: ' + JSON.stringify(res.data)));
|
return;
|
}
|
resolve(res);
|
},
|
fail: (error: any) => {
|
reject(new Error('请求失败: ' + JSON.stringify(error)));
|
}
|
});
|
});
|
} catch (error) {
|
console.error('语音合成请求失败:', error);
|
throw error;
|
}
|
}
|
|
/**
|
* 处理音频响应数据
|
* @param response - 响应数据
|
* @param text - 对应的文本内容
|
* @private
|
*/
|
private async processAudioResponse(response: ApiResponse, text: string): Promise<void> {
|
if (!response?.data?.data?.audio) {
|
throw new Error('无效的音频数据应答');
|
}
|
|
try {
|
// 检查是否已经存在相同的文本
|
if (this.audioTextQueue.some(item => item.text === text)) {
|
return;
|
}
|
|
const audio = response.data.data.audio;
|
if (typeof audio !== 'string' || audio.length === 0) {
|
throw new Error('无效的音频数据格式');
|
}
|
|
const binaryArray = new Uint8Array(audio.match(/.{1,2}/g)!.map(byte => parseInt(byte, 16)));
|
|
let tempFilePath: string;
|
if (this.fileManager) {
|
tempFilePath = `${uni.env.USER_DATA_PATH}/audio-${Date.now()}.mp3`;
|
await this.writeAudioFile(tempFilePath, binaryArray.buffer);
|
} else {
|
const blob = new Blob([binaryArray], { type: 'audio/mp3' });
|
tempFilePath = URL.createObjectURL(blob);
|
}
|
|
this.audioQueue.push(tempFilePath);
|
this.audioTextQueue.push({
|
text,
|
audio: tempFilePath
|
});
|
this.totalAudioCount++; // 增加总数计数
|
} catch (error) {
|
console.error('处理音频数据失败:', error);
|
throw new Error(`音频数据处理失败: ${error}`);
|
}
|
}
|
|
/**
|
* 写入音频文件
|
* @param filePath - 文件路径
|
* @param buffer - 音频数据
|
* @private
|
*/
|
private writeAudioFile(filePath: string, buffer: ArrayBuffer): Promise<void> {
|
if (!this.fileManager) {
|
return Promise.resolve();
|
}
|
|
return new Promise((resolve, reject) => {
|
this.fileManager!.writeFile({
|
filePath,
|
data: buffer,
|
encoding: 'binary',
|
success: () => resolve(),
|
fail: reject
|
});
|
});
|
}
|
|
/**
|
* 开始播放音频队列
|
* @private
|
*/
|
private async playAudioQueue(): Promise<void> {
|
if (this.audioQueue.length === 0) {
|
this.setState({
|
isStartPlayQueue: false,
|
isEnded: true,
|
isPlaying: false
|
});
|
return;
|
}
|
|
if (this.state.isPlaying) return;
|
|
// 销毁旧的音频上下文（如果存在）
|
this.destroyAudioContext();
|
|
// 创建新的音频上下文
|
this.audioContext = uni.createInnerAudioContext();
|
this.bindAudioEvents();
|
|
this.setState({
|
isStartPlayQueue: true,
|
isPlaying: true,
|
isEnded: false
|
});
|
|
const currentAudio = this.audioQueue[0];
|
const currentItem = this.audioTextQueue[0];
|
|
this.audioContext.src = currentAudio;
|
|
try {
|
await this.safePlay();
|
} catch (error) {
|
console.warn('播放失败:', error);
|
this.audioQueue.shift();
|
this.audioTextQueue.shift();
|
this.setState({
|
isPlaying: false,
|
needsUserInteraction: true
|
});
|
this.pendingAudioUrl = currentAudio;
|
this.destroyAudioContext();
|
}
|
}
|
|
/**
|
* 安全播放方法
|
* @private
|
*/
|
private async safePlay(): Promise<void> {
|
return new Promise((resolve, reject) => {
|
try {
|
this.audioContext!.play();
|
resolve();
|
} catch (error) {
|
console.error('播放失败:', error);
|
reject(error);
|
}
|
});
|
}
|
|
/**
|
* 手动触发播放
|
*/
|
public async manualPlay(): Promise<void> {
|
if (this.state.needsUserInteraction && this.pendingAudioUrl) {
|
this.state.needsUserInteraction = false;
|
if (!this.audioContext) {
|
this.audioContext = uni.createInnerAudioContext();
|
this.bindAudioEvents();
|
}
|
this.audioContext.src = this.pendingAudioUrl;
|
try {
|
await this.safePlay();
|
this.pendingAudioUrl = null;
|
} catch (error) {
|
console.error('手动播放失败:', error);
|
this.handleError(error);
|
}
|
}
|
}
|
|
/**
|
* 绑定音频事件
|
* @private
|
*/
|
private bindAudioEvents(): void {
|
if (!this.audioContext) return;
|
|
// 先解绑之前的事件（如果有的话）
|
try {
|
this.audioContext.offPlay(this.handleAudioPlay);
|
} catch (e) {
|
console.warn('移除播放事件监听失败:', e);
|
}
|
|
// 重新绑定事件
|
this.audioContext.onPlay(this.handleAudioPlay);
|
this.audioContext.onEnded(this.handleAudioEnd);
|
this.audioContext.onError(this.handleAudioError);
|
}
|
|
/**
|
* 处理音频播放开始事件
|
* @private
|
*/
|
private handleAudioPlay(): void {
|
const currentAudio = this.audioQueue[0];
|
const currentItem = this.audioTextQueue[0];
|
|
// 确保只有在真正开始播放时才更新状态和触发事件
|
if (currentAudio && currentItem) {
|
this.setState({ isPlaying: true, isPaused: false });
|
this.emit(EventType.AUDIO_PLAY, {
|
currentAudio,
|
currentText: currentItem.text,
|
remainingCount: this.audioQueue.length - 1,
|
totalCount: this.totalAudioCount,
|
progress: this.calculateProgress()
|
});
|
}
|
}
|
|
/**
|
* 处理音频播放结束事件
|
* @private
|
*/
|
private handleAudioEnd(): void {
|
const finishedAudio = this.audioQueue[0];
|
const finishedItem = this.audioTextQueue[0];
|
|
if (!finishedAudio || !finishedItem) return;
|
|
// 先设置播放状态为 false
|
this.setState({ isPlaying: false });
|
|
// 检查是否还有待播放的音频
|
if (this.audioQueue.length > 1) {
|
// 移除当前音频
|
this.audioQueue.shift();
|
this.audioTextQueue.shift();
|
|
// 发送进度事件
|
this.emit(EventType.PROGRESS, {
|
progress: this.calculateProgress(),
|
playedCount: this.totalAudioCount - this.audioQueue.length,
|
totalCount: this.totalAudioCount,
|
currentText: finishedItem.text,
|
remainingCount: this.audioQueue.length - 1
|
});
|
|
// 确保在开始下一个播放前销毁当前上下文
|
this.destroyAudioContext();
|
|
// 使用 setTimeout 确保异步执行下一个播放
|
setTimeout(() => {
|
this.playAudioQueue();
|
}, 0);
|
} else {
|
// 最后一个音频播放完成
|
this.audioQueue.shift();
|
this.audioTextQueue.shift();
|
|
this.setState({
|
isEnded: true,
|
isStartPlayQueue: false,
|
isPlaying: false,
|
isPaused: false
|
});
|
|
this.emit(EventType.AUDIO_END, {
|
finishedAudio,
|
finishedText: finishedItem.text,
|
remainingCount: 0,
|
isComplete: true,
|
progress: 100,
|
totalCount: this.totalAudioCount,
|
playedCount: this.totalAudioCount
|
});
|
|
this.destroyAudioContext();
|
this.resetTextProcessor();
|
}
|
}
|
|
/**
|
* 处理音频错误事件
|
* @private
|
*/
|
private handleAudioError(res: any): void {
|
console.error('音频播放错误:', res);
|
this.state.isError = true;
|
this.destroyAudioContext();
|
}
|
|
/**
|
* 销毁音频上下文
|
* @private
|
*/
|
private destroyAudioContext(): void {
|
if (this.audioContext) {
|
// 在销毁前先停止播放
|
try {
|
this.audioContext.stop();
|
} catch (e) {
|
console.warn('停止音频播放失败:', e);
|
}
|
|
// 移除事件监听 (只使用 offPlay，因为其他的 off 方法不存在)
|
try {
|
this.audioContext.offPlay(this.handleAudioPlay);
|
} catch (e) {
|
console.warn('移除播放事件监听失败:', e);
|
}
|
|
// 销毁音频上下文
|
this.audioContext.destroy();
|
this.audioContext = null;
|
}
|
}
|
|
/**
|
* 设置状态
|
* @private
|
*/
|
private setState(newState: Partial<State>): void {
|
const oldState = { ...this.state };
|
this.state = { ...this.state, ...newState };
|
|
this.emit(EventType.STATE_CHANGE, {
|
oldState,
|
newState: this.getState(),
|
changes: Object.keys(newState)
|
});
|
}
|
|
/**
|
* 获取当前状态
|
*/
|
public getState(): State {
|
return { ...this.state };
|
}
|
|
/**
|
* 重置所有状态
|
*/
|
public reset(): void {
|
Object.keys(this.state).forEach(key => {
|
(this.state as any)[key] = false;
|
});
|
this.audioQueue = [];
|
this.audioTextQueue = [];
|
this.totalAudioCount = 0; // 重置总数计数
|
this.destroyAudioContext();
|
this.setState({ isEnded: false });
|
}
|
|
/**
|
* 添加事件监听
|
*/
|
public on(event: EventType, callback: Function): void {
|
if (!this.eventListeners.has(event)) {
|
this.eventListeners.set(event, new Set());
|
}
|
this.eventListeners.get(event)!.add(callback);
|
}
|
|
/**
|
* 移除事件监听
|
*/
|
public off(event: EventType, callback: Function): void {
|
const listeners = this.eventListeners.get(event);
|
if (listeners) {
|
listeners.delete(callback);
|
}
|
}
|
|
/**
|
* 触发事件
|
* @private
|
*/
|
private emit(event: EventType, data: any): void {
|
const listeners = this.eventListeners.get(event);
|
if (listeners) {
|
listeners.forEach(callback => callback(data));
|
}
|
}
|
|
/**
|
* 开始计时
|
* @private
|
*/
|
private startTimer(): void {
|
this.timer.start = performance.now();
|
}
|
|
/**
|
* 结束计时并返回时（毫秒）
|
* @private
|
*/
|
private endTimer(): number {
|
this.timer.end = performance.now();
|
return this.timer.end - this.timer.start;
|
}
|
|
/**
|
* 批量处理文本
|
*/
|
public async processText(text: string): Promise<void> {
|
if (!text.trim()) return;
|
|
// 累积文本到 modelContent
|
this.modelContent += text;
|
|
// 检查是否有完整的句子（以句号、感叹号、问号结尾）
|
const endPunctuations = ['。', '！', '？'];
|
let hasCompleteSegment = endPunctuations.some(punct => this.modelContent.includes(punct));
|
|
// 如果没有完整的句子，继续累积
|
if (!hasCompleteSegment) {
|
return;
|
}
|
|
// 获取分段
|
const segments = this.processContent(this.modelContent);
|
this.modelContent = ''; // 清空累积的内容
|
|
if (segments.length === 0) return;
|
|
// 创建已处理文本集合
|
const processedTexts = new Set<string>();
|
|
// 处理每个分段
|
for (const segment of segments) {
|
// 检查是否已经处理过
|
if (processedTexts.has(segment) ||
|
this.audioTextQueue.some(item => item.text === segment)) {
|
continue;
|
}
|
|
// 添加到已处理集合
|
processedTexts.add(segment);
|
|
// 合成语音
|
await this.textToSpeech(segment);
|
}
|
}
|
|
/**
|
* 处理文本分段
|
* @private
|
*/
|
private processContent(inputText: string): string[] {
|
// 定义标点符号及其优先级
|
const punctuationGroups = [
|
['。', '！', '？'], // 高优先级
|
['；', '：'], // 中优先级
|
['，', '、'] // 低优先级
|
];
|
|
// 最大分段长度（字符数）
|
const MAX_SEGMENT_LENGTH = 100;
|
|
let currentText = inputText;
|
const segments: string[] = [];
|
|
// 如果文本很短，直接作为一个分段
|
if (currentText.length <= MAX_SEGMENT_LENGTH) {
|
if (currentText.trim()) {
|
segments.push(currentText.trim());
|
}
|
return segments;
|
}
|
|
// 处理长文本
|
while (currentText.length > 0) {
|
let segmentEnd = -1;
|
let foundPunctuation = '';
|
|
// 按优先级查找标点符号
|
for (const punctuationGroup of punctuationGroups) {
|
for (const punctuation of punctuationGroup) {
|
const index = currentText.indexOf(punctuation);
|
if (index !== -1 && (index <= MAX_SEGMENT_LENGTH || segmentEnd === -1)) {
|
segmentEnd = index;
|
foundPunctuation = punctuation;
|
break;
|
}
|
}
|
if (segmentEnd !== -1 && segmentEnd <= MAX_SEGMENT_LENGTH) break;
|
}
|
|
// 如果找到的分段点超过最大长度，或者没找到分段点
|
if (segmentEnd === -1 || segmentEnd > MAX_SEGMENT_LENGTH) {
|
segmentEnd = Math.min(MAX_SEGMENT_LENGTH, currentText.length);
|
// 向前查找合适的分段点
|
while (segmentEnd > MAX_SEGMENT_LENGTH * 0.8) {
|
if (this.isGoodSplitPoint(currentText, segmentEnd)) {
|
break;
|
}
|
segmentEnd--;
|
}
|
}
|
|
// 提取分段
|
const segment = currentText.substring(0, segmentEnd + 1);
|
if (segment.trim()) {
|
segments.push(segment.trim());
|
}
|
|
// 更新剩余文本
|
currentText = currentText.substring(segmentEnd + 1);
|
}
|
|
return segments;
|
}
|
|
/**
|
* 强制处理剩余文本
|
*/
|
public async flushRemainingText(): Promise<void> {
|
if (this.modelContent.trim()) {
|
const segments = this.processContent(this.modelContent);
|
this.modelContent = '';
|
|
for (const segment of segments) {
|
if (segment.trim() && !this.audioTextQueue.some(item => item.text === segment)) {
|
await this.textToSpeech(segment);
|
}
|
}
|
}
|
}
|
|
/**
|
* 重置文本处理状态
|
*/
|
public resetTextProcessor(): void {
|
this.modelContent = '';
|
}
|
|
/**
|
* 暂停播放
|
*/
|
public pause(): void {
|
if (this.audioContext && this.state.isPlaying) {
|
this.audioContext.pause();
|
this.setState({
|
isPaused: true,
|
isPlaying: false
|
});
|
this.emit(EventType.PAUSE, {});
|
}
|
}
|
|
/**
|
* 恢复播放
|
*/
|
public resume(): void {
|
if (this.audioContext && this.state.isPaused) {
|
this.audioContext.play();
|
this.setState({
|
isPaused: false,
|
isPlaying: true
|
});
|
this.emit(EventType.RESUME, {});
|
}
|
}
|
|
/**
|
* 切换播放/暂停状态
|
*/
|
public togglePlay(): void {
|
if (this.state.isPaused) {
|
this.resume();
|
} else if (this.state.isPlaying) {
|
this.pause();
|
}
|
}
|
|
/**
|
* 如果需要，开始播放音频
|
* @private
|
*/
|
private async startPlayingIfNeeded(): Promise<void> {
|
if (!this.state.isStartPlayQueue) {
|
await this.playAudioQueue();
|
}
|
}
|
|
/**
|
* 处理错误
|
* @private
|
*/
|
private handleError(error: any): void {
|
console.error('语音合成错误:', error);
|
this.setState({ isError: true });
|
this.destroyAudioContext();
|
|
// 清理队列的所有文件
|
if (this.fileManager) {
|
this.audioQueue.forEach(filePath => {
|
try {
|
this.fileManager!.unlinkSync(filePath);
|
} catch (e) {
|
console.warn('清理音频文件失败:', e);
|
}
|
});
|
}
|
|
this.audioQueue = [];
|
throw error;
|
}
|
|
// 添加进度计算辅助方法
|
private calculateProgress(): number {
|
if (this.totalAudioCount === 0) return 0;
|
const playedCount = this.totalAudioCount - this.audioQueue.length;
|
return Math.round((playedCount / this.totalAudioCount) * 100);
|
}
|
|
/**
|
* 判断是否是合适的分段点
|
* @private
|
*/
|
private isGoodSplitPoint(text: string, index: number): boolean {
|
// 检查前后字符，避免切断词语
|
const prevChar = text[index - 1];
|
const nextChar = text[index];
|
|
// 定义可以作为分段点的字符
|
const splitChars = new Set([' ', '，', '、', '。', '！', '？', '；', '：']);
|
|
// 如果当前位置是标点符号，可以分段
|
if (splitChars.has(prevChar) || splitChars.has(nextChar)) {
|
return true;
|
}
|
|
// 检查是否会切断英文单词
|
const isPartOfEnglishWord = (char: string) => /[a-zA-Z]/.test(char);
|
if (isPartOfEnglishWord(prevChar) && isPartOfEnglishWord(nextChar)) {
|
return false;
|
}
|
|
// 检查是否会切断数字
|
const isPartOfNumber = (char: string) => /[0-9]/.test(char);
|
if (isPartOfNumber(prevChar) && isPartOfNumber(nextChar)) {
|
return false;
|
}
|
|
// 其他情况，可以分段
|
return true;
|
}
|
}
|
|
export default SpeechSynthesisUtil;
|
