/**
|
* 语音合成工具类
|
* @class SpeechSynthesisUtil
|
* @description 用于处理文字转语音的工具类,包含音频播放、合成等功能
|
*/
|
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
|
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
return new (P || (P = Promise))(function (resolve, reject) {
|
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
});
|
};
|
// 事件类型枚举
|
export var EventType;
|
(function (EventType) {
|
EventType["STATE_CHANGE"] = "stateChange";
|
EventType["SYNTHESIS_START"] = "synthesisStart";
|
EventType["SYNTHESIS_END"] = "synthesisEnd";
|
EventType["AUDIO_PLAY"] = "audioPlay";
|
EventType["AUDIO_END"] = "audioEnd";
|
EventType["ERROR"] = "error";
|
EventType["PROGRESS"] = "progress";
|
EventType["PAUSE"] = "pause";
|
EventType["RESUME"] = "resume";
|
})(EventType || (EventType = {}));
|
class SpeechSynthesisUtil {
|
constructor(options) {
|
this.audioContext = null;
|
this.audioQueue = [];
|
this.audioTextQueue = [];
|
this.fileManager = null;
|
this.pendingAudioUrl = null;
|
this.modelContent = '';
|
this.totalAudioCount = 0; // 记录总的音频数量
|
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 - 需要转换的文本
|
*/
|
textToSpeech(text) {
|
return __awaiter(this, void 0, void 0, function* () {
|
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) {
|
yield new Promise((resolve) => {
|
const checkSynthesis = setInterval(() => {
|
if (!this.state.isSynthesizing) {
|
clearInterval(checkSynthesis);
|
resolve();
|
}
|
}, 100);
|
});
|
}
|
this.setState({ isSynthesizing: true, isError: false });
|
try {
|
const response = yield this.requestSynthesis(text);
|
yield this.processAudioResponse(response, text);
|
yield 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
|
*/
|
requestSynthesis(text) {
|
return __awaiter(this, void 0, void 0, function* () {
|
try {
|
return new Promise((resolve, reject) => {
|
var _a, _b;
|
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: Object.assign({
|
// 默认配置
|
model: "speech-01-turbo-240228", text, stream: false, voice_setting: Object.assign({ voice_id: 'female-yujie', speed: 1.2, vol: 1.0 }, (((_a = this.modelConfig) === null || _a === void 0 ? void 0 : _a.voice_setting) || {}) // 合并用户配置的voice_setting
|
), audio_setting: Object.assign({ audio_sample_rate: 32000, bitrate: 128000, format: "mp3", channel: 2 }, (((_b = this.modelConfig) === null || _b === void 0 ? void 0 : _b.audio_setting) || {}) // 合并用户配置的audio_setting
|
) }, (this.modelConfig || {}) // 合并其他用户配置
|
),
|
success: (res) => {
|
var _a, _b;
|
if (!((_b = (_a = res.data) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.audio)) {
|
reject(new Error('API 响应格式错误: ' + JSON.stringify(res.data)));
|
return;
|
}
|
resolve(res);
|
},
|
fail: (error) => {
|
reject(new Error('请求失败: ' + JSON.stringify(error)));
|
}
|
});
|
});
|
}
|
catch (error) {
|
console.error('语音合成请求失败:', error);
|
throw error;
|
}
|
});
|
}
|
/**
|
* 处理音频响应数据
|
* @param response - 响应数据
|
* @param text - 对应的文本内容
|
* @private
|
*/
|
processAudioResponse(response, text) {
|
return __awaiter(this, void 0, void 0, function* () {
|
var _a, _b;
|
if (!((_b = (_a = response === null || response === void 0 ? void 0 : response.data) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.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;
|
if (this.fileManager) {
|
tempFilePath = `${uni.env.USER_DATA_PATH}/audio-${Date.now()}.mp3`;
|
yield 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
|
*/
|
writeAudioFile(filePath, buffer) {
|
if (!this.fileManager) {
|
return Promise.resolve();
|
}
|
return new Promise((resolve, reject) => {
|
this.fileManager.writeFile({
|
filePath,
|
data: buffer,
|
encoding: 'binary',
|
success: () => resolve(),
|
fail: reject
|
});
|
});
|
}
|
/**
|
* 开始播放音频队列
|
* @private
|
*/
|
playAudioQueue() {
|
return __awaiter(this, void 0, void 0, function* () {
|
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 {
|
yield 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
|
*/
|
safePlay() {
|
return __awaiter(this, void 0, void 0, function* () {
|
return new Promise((resolve, reject) => {
|
try {
|
this.audioContext.play();
|
resolve();
|
}
|
catch (error) {
|
console.error('播放失败:', error);
|
reject(error);
|
}
|
});
|
});
|
}
|
/**
|
* 手动触发播放
|
*/
|
manualPlay() {
|
return __awaiter(this, void 0, void 0, function* () {
|
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 {
|
yield this.safePlay();
|
this.pendingAudioUrl = null;
|
}
|
catch (error) {
|
console.error('手动播放失败:', error);
|
this.handleError(error);
|
}
|
}
|
});
|
}
|
/**
|
* 绑定音频事件
|
* @private
|
*/
|
bindAudioEvents() {
|
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
|
*/
|
handleAudioPlay() {
|
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
|
*/
|
handleAudioEnd() {
|
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
|
*/
|
handleAudioError(res) {
|
console.error('音频播放错误:', res);
|
this.state.isError = true;
|
this.destroyAudioContext();
|
}
|
/**
|
* 销毁音频上下文
|
* @private
|
*/
|
destroyAudioContext() {
|
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
|
*/
|
setState(newState) {
|
const oldState = Object.assign({}, this.state);
|
this.state = Object.assign(Object.assign({}, this.state), newState);
|
this.emit(EventType.STATE_CHANGE, {
|
oldState,
|
newState: this.getState(),
|
changes: Object.keys(newState)
|
});
|
}
|
/**
|
* 获取当前状态
|
*/
|
getState() {
|
return Object.assign({}, this.state);
|
}
|
/**
|
* 重置所有状态
|
*/
|
reset() {
|
Object.keys(this.state).forEach(key => {
|
this.state[key] = false;
|
});
|
this.audioQueue = [];
|
this.audioTextQueue = [];
|
this.totalAudioCount = 0; // 重置总数计数
|
this.destroyAudioContext();
|
this.setState({ isEnded: false });
|
}
|
/**
|
* 添加事件监听
|
*/
|
on(event, callback) {
|
if (!this.eventListeners.has(event)) {
|
this.eventListeners.set(event, new Set());
|
}
|
this.eventListeners.get(event).add(callback);
|
}
|
/**
|
* 移除事件监听
|
*/
|
off(event, callback) {
|
const listeners = this.eventListeners.get(event);
|
if (listeners) {
|
listeners.delete(callback);
|
}
|
}
|
/**
|
* 触发事件
|
* @private
|
*/
|
emit(event, data) {
|
const listeners = this.eventListeners.get(event);
|
if (listeners) {
|
listeners.forEach(callback => callback(data));
|
}
|
}
|
/**
|
* 开始计时
|
* @private
|
*/
|
startTimer() {
|
this.timer.start = performance.now();
|
}
|
/**
|
* 结束计时并返回时（毫秒）
|
* @private
|
*/
|
endTimer() {
|
this.timer.end = performance.now();
|
return this.timer.end - this.timer.start;
|
}
|
/**
|
* 批量处理文本
|
*/
|
processText(text) {
|
return __awaiter(this, void 0, void 0, function* () {
|
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();
|
// 处理每个分段
|
for (const segment of segments) {
|
// 检查是否已经处理过
|
if (processedTexts.has(segment) ||
|
this.audioTextQueue.some(item => item.text === segment)) {
|
continue;
|
}
|
// 添加到已处理集合
|
processedTexts.add(segment);
|
// 合成语音
|
yield this.textToSpeech(segment);
|
}
|
});
|
}
|
/**
|
* 处理文本分段
|
* @private
|
*/
|
processContent(inputText) {
|
// 定义标点符号及其优先级
|
const punctuationGroups = [
|
['。', '！', '？'], // 高优先级
|
['；', '：'], // 中优先级
|
['，', '、'] // 低优先级
|
];
|
// 最大分段长度（字符数）
|
const MAX_SEGMENT_LENGTH = 100;
|
let currentText = inputText;
|
const segments = [];
|
// 如果文本很短，直接作为一个分段
|
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;
|
}
|
/**
|
* 强制处理剩余文本
|
*/
|
flushRemainingText() {
|
return __awaiter(this, void 0, void 0, function* () {
|
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)) {
|
yield this.textToSpeech(segment);
|
}
|
}
|
}
|
});
|
}
|
/**
|
* 重置文本处理状态
|
*/
|
resetTextProcessor() {
|
this.modelContent = '';
|
}
|
/**
|
* 暂停播放
|
*/
|
pause() {
|
if (this.audioContext && this.state.isPlaying) {
|
this.audioContext.pause();
|
this.setState({
|
isPaused: true,
|
isPlaying: false
|
});
|
this.emit(EventType.PAUSE, {});
|
}
|
}
|
/**
|
* 恢复播放
|
*/
|
resume() {
|
if (this.audioContext && this.state.isPaused) {
|
this.audioContext.play();
|
this.setState({
|
isPaused: false,
|
isPlaying: true
|
});
|
this.emit(EventType.RESUME, {});
|
}
|
}
|
/**
|
* 切换播放/暂停状态
|
*/
|
togglePlay() {
|
if (this.state.isPaused) {
|
this.resume();
|
}
|
else if (this.state.isPlaying) {
|
this.pause();
|
}
|
}
|
/**
|
* 如果需要，开始播放音频
|
* @private
|
*/
|
startPlayingIfNeeded() {
|
return __awaiter(this, void 0, void 0, function* () {
|
if (!this.state.isStartPlayQueue) {
|
yield this.playAudioQueue();
|
}
|
});
|
}
|
/**
|
* 处理错误
|
* @private
|
*/
|
handleError(error) {
|
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;
|
}
|
// 添加进度计算辅助方法
|
calculateProgress() {
|
if (this.totalAudioCount === 0)
|
return 0;
|
const playedCount = this.totalAudioCount - this.audioQueue.length;
|
return Math.round((playedCount / this.totalAudioCount) * 100);
|
}
|
/**
|
* 判断是否是合适的分段点
|
* @private
|
*/
|
isGoodSplitPoint(text, index) {
|
// 检查前后字符，避免切断词语
|
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) => /[a-zA-Z]/.test(char);
|
if (isPartOfEnglishWord(prevChar) && isPartOfEnglishWord(nextChar)) {
|
return false;
|
}
|
// 检查是否会切断数字
|
const isPartOfNumber = (char) => /[0-9]/.test(char);
|
if (isPartOfNumber(prevChar) && isPartOfNumber(nextChar)) {
|
return false;
|
}
|
// 其他情况，可以分段
|
return true;
|
}
|
}
|
export default SpeechSynthesisUtil;
|
