HarmonyOS鸿蒙Next中请教下如何间隔播放音频

import { AudioContext, OscillatorNode, GainNode } from '@ohos/audio'; // 鸿蒙AudioContext API（若为前端则直接使用浏览器原生API）

class AudioScheduler {
  private audioContext: AudioContext | null = null;
  private currentIndex = 0;
  private isPlaying = false;
  private totalDuration = 0; // 所有音频段总时长（ms）
  private scheduledNodes: (OscillatorNode | GainNode)[] = []; // 存储已调度的音频节点，用于暂停时销毁
  private notes: Array<{ time: number; note: number[] }> = []; // 数据源

  constructor(notes: Array<{ time: number; note: number[] }>) {
    this.notes = notes.filter(step => step.time > 0); // 过滤time=0的循环标记
    // 计算总时长（用于循环）
    this.totalDuration = this.notes.reduce((sum, step) => sum + step.time, 0);
  }

  // 初始化AudioContext（需用户交互后调用，如点击按钮）
  async init() {
    if (!this.audioContext) {
      this.audioContext = new AudioContext();
      await this.audioContext.resume(); // 激活AudioContext（浏览器/鸿蒙均需）
    }
  }

  // 开始播放（核心调度逻辑）
  start() {
    if (!this.audioContext || this.isPlaying) return;
    this.isPlaying = true;
    this.currentIndex = 0;
    this.scheduleAll(this.audioContext.currentTime); // 基于当前绝对时间开始调度
  }

  // 递归调度所有音频段
  private scheduleAll(startTime: number) {
    if (!this.isPlaying || !this.audioContext) return;

    const step = this.notes[this.currentIndex];
    if (!step) {
      // 播放完一轮，无缝循环
      this.currentIndex = 0;
      this.scheduleAll(startTime + this.totalDuration / 1000); // 总时长转秒
      return;
    }

    // 计算当前段的播放时间（绝对时间，无延迟）
    const playTime = startTime + (this.currentIndex > 0 
      ? this.notes.slice(0, this.currentIndex).reduce((sum, s) => sum + s.time, 0) / 1000 
      : 0);

    // 播放当前段的所有音符
    step.note.forEach(note => {
      this.playNote(note, playTime, step.time / 1000); // time转秒
    });

    // 调度下一段
    this.currentIndex++;
    // 用requestAnimationFrame确保调度不阻塞主线程（比setTimeout更精准）
    requestAnimationFrame(() => this.scheduleAll(startTime));
  }

  // 播放单个音符（通过AudioContext生成音频，替代SoundPool）
  private playNote(note: number, playTime: number, duration: number) {
    if (!this.audioContext) return;

    // 创建音频节点（OscillatorNode生成音调，GainNode控制音量）
    const oscillator = this.audioContext.createOscillator();
    const gainNode = this.audioContext.createGain();

    // 设置音调（根据note映射频率，示例：note=1→220Hz，可自定义映射表）
    oscillator.frequency.value = 220 * Math.pow(2, (note - 1) / 12); // 十二平均律
    // 设置音量
    gainNode.gain.value = 0.3;

    // 连接节点
    oscillator.connect(gainNode);
    gainNode.connect(this.audioContext.destination);

    // 调度播放和停止时间（绝对时间，精确到毫秒）
    oscillator.start(playTime);
    oscillator.stop(playTime + duration);

    // 存储节点，用于暂停时销毁
    this.scheduledNodes.push(oscillator, gainNode);

    // 播放结束后移除节点（避免内存泄漏）
    oscillator.onended = () => {
      const index = this.scheduledNodes.indexOf(oscillator);
      if (index !== -1) {
        this.scheduledNodes.splice(index, 2);
      }
    };
  }

  // 暂停播放（立即停止所有音频）
  pause() {
    this.isPlaying = false;
    // 销毁所有已调度的音频节点，直接停止播放
    this.scheduledNodes.forEach(node => {
      if (node instanceof OscillatorNode) {
        node.stop();
      }
      node.disconnect();
    });
    this.scheduledNodes = [];
  }

  // 停止播放（重置状态）
  stop() {
    this.pause();
    this.currentIndex = 0;
    if (this.audioContext) {
      this.audioContext.suspend(); // 暂停AudioContext，节省资源
    }
  }
}

// 使用示例
const notesData = [
  {"time": 250,"note": [1,2]}, {"time": 250,"note": [1]}, {"time": 250,"note": [2]},
  {"time": 250,"note": [2]}, {"time": 250,"note": [1]}, {"time": 250,"note": [1]},
  {"time": 250,"note": [2]}, {"time": 250,"note": [12]}, {"time": 0,"note": [0]}
];

// 初始化调度器
const audioScheduler = new AudioScheduler(notesData);

// 需用户交互触发（如按钮点击）
async function onStartClick() {
  await audioScheduler.init();
  audioScheduler.start();
}

// 暂停按钮点击
function onPauseClick() {
  audioScheduler.pause();
}

// 停止按钮点击
function onStopClick() {
  audioScheduler.stop();
}