HarmonyOS鸿蒙Next中使用AVRecorder录制音频的时长不正确

感谢您的提问，为了更快解决您的问题，麻烦请补充以下信息：

使用提供的demo并没有复现问题，这边显示的时长比计时器的时长短现象是什么样的，这边测试比如正在录音的时候是16s的时候duration返回的是16512ms，以下是测试使用的demo，api17的版本

import { AudioRecorder } from "./RecorderManager"
import { abilityAccessCtrl, PermissionRequestResult } from "[@kit](/user/kit).AbilityKit"


export class RecordingFileInfo {
  fileName: string = ''
  filePath: string = ''
  fileSize: number = 0
  createTime: string = ''
  duration: string = ''
}

@Component
@Entry
export struct MainPage {
  @State message: string = '录音Demo'
  @State isRecording: boolean = false
  @State isPaused: boolean = false
  @State recordTime: string = '00:00'
  @State recordStatus: string = '准备录音'
  @State recordingFiles: RecordingFileInfo[] = [] // 录音文件列表
  @State ButtonHovered: boolean = false
  // 计时器相关（示例实现）
  private timer: number = -1
  private seconds: number = 0
  // 录音管理器实例
  private audioRecorder: AudioRecorder = new AudioRecorder()

  // 页面显示时加载文件列表
  async aboutToAppear() {
    await this.refreshFileList()
  }

  // 刷新文件列表
  async refreshFileList() {
    try {
      this.recordingFiles = await this.audioRecorder.getRecordingFiles()
      console.log('文件列表刷新成功，共', this.recordingFiles.length, '个文件')
    } catch (error) {
      console.error('刷新文件列表失败:', error)
    }
  }

  // 权限申请
  async requestMicrophonePermission(): Promise<boolean> {
    try {
      const atManager = abilityAccessCtrl.createAtManager()
      const context = getContext(this)

      // 检查权限状态
      const grantStatus = await atManager.checkAccessToken(
        context.applicationInfo.accessTokenId,
        'ohos.permission.MICROPHONE',
      )

      if (grantStatus === abilityAccessCtrl.GrantStatus.PERMISSION_GRANTED) {
        console.log('麦克风权限已授予')
        return true
      }

      // 申请权限
      const requestResult: PermissionRequestResult = await atManager.requestPermissionsFromUser(
        context,
        ['ohos.permission.MICROPHONE'],
      )

      if (requestResult.authResults[0] === abilityAccessCtrl.GrantStatus.PERMISSION_GRANTED) {
        console.log('麦克风权限申请成功')
        return true
      } else {
        console.log('麦克风权限申请失败')
        return false
      }
    } catch (error) {
      console.error('权限申请过程中出错:', error)
      return false
    }
  }

  build() {
    Column({ space: 20 }) {
      // 标题
      Text(this.message)
        .fontSize(24)
        .fontWeight(FontWeight.Bold)
        .fontColor('#333333')
        .margin({ top: 40 })

      // 录音状态显示
      Column({ space: 10 }) {
        Text(this.recordStatus)
          .fontSize(16)
          .fontColor('#666666')

        Text(this.recordTime)
          .fontSize(32)
          .fontWeight(FontWeight.Bold)
          .fontColor(this.isRecording ? '#FF4444' : '#333333')
      }
      .margin({ top: 40 })

      // 录音控制区域
      Column({ space: 20 }) {
        // 主录音按钮
        Button() {
          Column() {
            Image(this.isRecording ? $r('app.media.startIcon') : $r('app.media.ic_widget_study'))
              .width(40)
              .height(40)
              .fillColor(Color.White)
            Text(this.isRecording ? '停止录音' : '开始录音')
              .fontSize(14)
              .fontColor(Color.White)
              .margin({ top: 8 })
          }
        }
        .width(120)
        .height(120)
        .backgroundColor(this.isRecording ? '#FF4444' : '#007DFF')
        .borderRadius(60)
        .onClick(async () => {
          if (!this.isRecording) {
            // 开始录音
            await this.startRecording()
          } else {
            // 停止录音
            await this.stopRecording()
          }
        })

        // 控制按钮组
        Row({ space: 20 }) {
          Button('暂停')
            .width(80)
            .height(40)
            .fontSize(14)
            .backgroundColor('#FFA500')
            .enabled(this.isRecording && !this.isPaused)
            .opacity(this.isRecording && !this.isPaused ? 1 : 0.5)
            .onClick(async () => {
              await this.pauseRecording()
            })

          Button('继续')
            .width(80)
            .height(40)
            .fontSize(14)
            .backgroundColor('#32CD32')
            .enabled(this.isPaused)
            .opacity(this.isPaused ? 1 : 0.5)
            .onClick(async () => {
              await this.resumeRecording()
            })
        }
      }
      .margin({ top: 60 })

      // 录音文件列表区域
      Column({ space: 10 }) {
        Row() {
          Text(`录音文件  共${this.recordingFiles.length}条`)
            .fontSize(18)
            .fontWeight(FontWeight.Medium)
            .layoutWeight(1)

          Button('刷新')
            .width(60)
            .height(32)
            .fontSize(12)
            .backgroundColor('#32CD32')
            .onClick(async () => {
              await this.refreshFileList()
            })
        }
        .width('100%')
        .padding({ left: 20, right: 20 })
        .alignItems(VerticalAlign.Center)

        if (this.recordingFiles.length > 0) {
          List({ space: 10 }) {
            ForEach(this.recordingFiles, (fileInfo: RecordingFileInfo, index: number) => {
              ListItem() {
                Row() {
                  Column({ space: 4 }) {
                    Text(`${index + 1}. ${fileInfo.fileName}`)
                      .fontSize(16)
                      .fontColor('#333333')
                      .maxLines(1)
                      .textOverflow({ overflow: TextOverflow.Ellipsis })

                    Row({ space: 10 }) {
                      Text(fileInfo.createTime)
                        .fontSize(12)
                        .fontColor('#999999')

                      Text(this.audioRecorder.formatFileSize(fileInfo.fileSize))
                        .fontSize(12)
                        .fontColor('#999999')

                      Text(fileInfo.duration)
                        .fontSize(12)
                        .fontColor('#999999')
                    }
                  }
                  .alignItems(HorizontalAlign.Start)
                  .layoutWeight(1)

                  Column({ space: 5 }) {
                    Button('上传', { buttonStyle: ButtonStyleMode.TEXTUAL }).onClick(() => {
                      console.log('上传文件:', JSON.stringify(fileInfo, null, 2))
                      // uploadFile(fileInfo.filePath)
                    })

                    Divider().width(30).strokeWidth(1)

                    Button('删除', { buttonStyle: ButtonStyleMode.TEXTUAL }).onClick(() => {
                      console.log('删除文件:', JSON.stringify(fileInfo, null, 2))
                      this.audioRecorder.deleteFile(fileInfo.filePath)
                    })
                  }
                }
                .width('100%')
                .padding({
                  left: 16,
                  right: 16,
                  top: 12,
                  bottom: 12,
                })
                .backgroundColor(Color.White)
                .borderRadius(8)
              }
            }, (fileInfo: RecordingFileInfo) => fileInfo.fileName)
          }
          .width('100%')
          .height(200)
          .padding({ left: 20, right: 20 })
        } else {
          Column() {
            Text('暂无录音文件')
              .fontSize(16)
              .fontColor('#999999')
              .margin({ top: 40 })
          }
          .width('100%')
          .height(200)
          .justifyContent(FlexAlign.Center)
        }
      }
      .margin({ top: 40 })
      .layoutWeight(1)
    }
    .width('100%')
    .height('100%')
    .backgroundColor('#F5F5F5')
    .justifyContent(FlexAlign.Start)
  }

  // 开始录音
  async startRecording() {
    try {
      // 1. 先申请权限
      const hasPermission = await this.requestMicrophonePermission()
      if (!hasPermission) {
        this.recordStatus = '麦克风权限未授予'
        return
      }

      // 2. 创建文件并设置文件描述符
      await this.audioRecorder.createAndSetFd()

      // 3. 开始录音流程
      await this.audioRecorder.startRecordingProcess()

      // 4. 更新UI状态
      this.isRecording = true
      this.isPaused = false
      this.recordStatus = '正在录音...'

      this.seconds = 0
      this.startTimer()

      console.log('录音开始成功')
    } catch (error) {
      console.error('开始录音失败:', error)
      this.recordStatus = '录音开始失败'
    }
  }

  // 停止录音
  async stopRecording() {
    try {
      // 停止录音流程
      await this.audioRecorder.stopRecordingProcess()

      // 更新UI状态
      this.isRecording = false
      this.isPaused = false
      this.recordStatus = '录音已停止'

      this.stopTimer()
      this.resetSeconds()

      // 刷新文件列表
      await this.refreshFileList()

      console.log('录音停止成功')
    } catch (error) {
      console.error('停止录音失败:', error)
      this.recordStatus = '录音停止失败'
    }
  }

  // 暂停录音
  async pauseRecording() {
    try {
      // 暂停录音流程
      await this.audioRecorder.pauseRecordingProcess()

      // 更新UI状态
      this.isPaused = true
      this.recordStatus = '录音已暂停'
      // 暂停计时器
      if (this.timer !== -1) {
        clearInterval(this.timer)
        this.timer = -1
      }

      console.log('录音暂停成功')
    } catch (error) {
      console.error('暂停录音失败:', error)
      this.recordStatus = '录音暂停失败'
    }
  }

  // 恢复录音
  async resumeRecording() {
    try {
      // 恢复录音流程
      await this.audioRecorder.resumeRecordingProcess()

      // 更新UI状态
      this.isPaused = false
      this.recordStatus = '正在录音...'
      // 恢复计时器
      this.startTimer()

      console.log('录音恢复成功')
    } catch (error) {
      console.error('恢复录音失败:', error)
      this.recordStatus = '录音恢复失败'
    }
  }

  startTimer() {
    this.timer = setInterval(() => {
      this.seconds++
      const minutes = Math.floor(this.seconds / 60)
      const secs = this.seconds % 60
      this.recordTime = `${minutes.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`
    }, 1000)
  }

  stopTimer() {
    if (this.timer !== -1) {
      clearInterval(this.timer)
      this.timer = -1
    }
  }

  resetSeconds() {
    this.seconds = 0
    this.recordTime = '00:00'
  }

  aboutToDisappear() {
    this.stopTimer()
    // 页面销毁时确保释放录音资源
    this.audioRecorder.stopRecordingProcess()
  }
}

import { media } from "[@kit](/user/kit).MediaKit"
import { common } from "[@kit](/user/kit).AbilityKit"
import { fileIo as fs } from '[@kit](/user/kit).CoreFileKit';
import { RecordingFileInfo } from "./Index";
import { BusinessError } from "[@kit](/user/kit).BasicServicesKit";


export class AudioRecorder {
  private avRecorder: media.AVRecorder | undefined = undefined
  private avProfile: media.AVRecorderProfile = {
    audioBitrate: 128000, // 音频比特率
    audioChannels: 1, // 音频声道数
    audioCodec: media.CodecMimeType.AUDIO_AAC, // 音频编码格式，当前支持ACC，MP3，G711MU
    audioSampleRate: 32000, // 音频采样率
    fileFormat: media.ContainerFormatType.CFT_MPEG_4A, // 封装格式，当前支持MP4，M4A，MP3，WAV
  }
  private avConfig: media.AVRecorderConfig = {
    audioSourceType: media.AudioSourceType.AUDIO_SOURCE_TYPE_MIC, // 音频输入源，这里设置为麦克风
    profile: this.avProfile,
    url: 'fd://35', // 参考应用文件访问与管理开发示例新建并读写一个文件
  }
  private uriPath: string = ''
  private filePath: string = ''

  /**
   * 创建文件以及设置avConfig.url
   */
  async createAndSetFd(): Promise<void> {
    try {
      const context: Context = getContext(this)
      const path: string = context.filesDir + `/${new Date()}.mp3` // 文件沙箱路径，文件后缀名应与封装格式对应
      const audioFile: fs.File = fs.openSync(path, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE)
      this.avConfig.url = 'fd://' + audioFile.fd // 更新url
      this.filePath = path

      console.log('创建文件成功, 文件路径为:', this.filePath)
    } catch (e) {
      console.log('创建文件失败:', e)
    }
  }

  /**
   * 获取录音文件列表
   */
  async getRecordingFiles(): Promise<RecordingFileInfo[]> {
    try {
      // const context: Context = getContext(this)
      const context: common.UIAbilityContext = getContext(this) as common.UIAbilityContext
      const recordingDir = context.filesDir

      // 读取目录下的所有文件
      const files = fs.listFileSync(recordingDir)
      const recordingFiles: RecordingFileInfo[] = []

      for (const fileName of files) {
        // 过滤音频文件（.mp3, .m4a）
        if (fileName.endsWith('.mp3') || fileName.endsWith('.m4a') || fileName.endsWith('.wav')) {
          const filePath = recordingDir + '/' + fileName
          const durationMs = await this.getAudioDuration(filePath)
          try {
            // 获取文件状态信息
            const stat = fs.statSync(filePath)

            // 解析时间戳文件名获取创建时间
            const createTime = this.parseFileNameToTime(fileName)

            const fileInfo: RecordingFileInfo = {
              fileName: fileName,
              filePath: filePath,
              fileSize: stat.size,
              createTime: createTime,
              duration:durationMs.toString(),
            }

            recordingFiles.push(fileInfo)
          } catch (statError) {
            console.error('获取文件状态失败:', fileName, statError)
          }
        }
      }

      // 按创建时间倒序排列（最新的在前面）
      recordingFiles.sort((a, b) => {
        return b.fileName.localeCompare(a.fileName)
      })

      console.log('扫描到录音文件:', recordingFiles.length, '个')
      return recordingFiles

    } catch (error) {
      console.error('扫描录音文件失败:', error)
      return []
    }
  }

  /**
   * 获取音频时长
   * [@param](/user/param) path 音频文件路径
   * [@returns](/user/returns) duration 音频时长（毫秒）
   */
  async getAudioDuration(path: string): Promise<number> {
    try {
      let fd = fs.openSync(path, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE).fd
      let state = fs.statSync(fd)
      let avFileDescriptor: media.AVFileDescriptor = {
        fd: fd,
        offset: 0,
        length: state.size,
      }

      let avMetadataExtractor = await media.createAVMetadataExtractor()
      avMetadataExtractor.fdSrc = avFileDescriptor

      const metadata = await avMetadataExtractor.fetchMetadata()

      // 关闭文件描述符
      fs.closeSync(fd)

      // 释放提取器资源
      await avMetadataExtractor.release()

      // 获取时长（毫秒）
      const duration = metadata.duration
      return duration ? parseInt(duration as string) : 0

    } catch (e) {
      console.log('获取元数据失败:', e)
      return 0
    }
  }

  /**
   * 删除音频
   * [@param](/user/param) path 文件路径
   */
  deleteFile(path: string) {

  }

  /**
   * 格式化文件大小
   * [@param](/user/param) bytes 字节数
   * [@returns](/user/returns) 文件大小
   */
  formatFileSize(bytes: number): string {
    if (bytes === 0) {
      return '0 B'
    }

    const k = 1024
    const sizes = ['B', 'KB', 'MB', 'GB']
    const i = Math.floor(Math.log(bytes) / Math.log(k))

    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i]
  }

  // 注册audioRecorder回调函数
  setAudioRecorderCallback() {
    if (this.avRecorder !== undefined) {
      // 状态机变化回调函数
      this.avRecorder.on('stateChange', (state: media.AVRecorderState, reason: media.StateChangeReason) => {
        console.log(`音频管理器当前状态为 ${state}`)
      })
      // 错误上报回调函数
      this.avRecorder.on('error', (err: BusinessError) => {
        console.error(`音频管理器出现错误, 错误码为 ${err.code}, 错误消息为 ${err.message}`)
      })
    }
  }

  // 开始录制对应的流程
  async startRecordingProcess() {
    try {
      if (this.av

这边又试了下，直接看显示的毫秒是没有问题的，看了下DateUtils.duration2Time(durationMs)这个好像是您这边自己封装的转时间的方法，是不是这边的问题呢，这边我通过自己的时间转换方法没有复现

// 时间转换（毫秒转换成时分秒）
function setMillis (millis:number) {
  let hours = Math.floor(millis / 3600000);
  let minutes = Math.floor((millis % 3600000) / 60000);
  let seconds = Math.floor((millis % 60000) / 1000);
  let millisecondsLeft = Math.floor(millis % 1000);
  let setTime = '';

  if (hours > 0) {
    setTime += `${hours}时`;
  }
  if (minutes > 0) {
    setTime += `${minutes}分`;
  }
  if (seconds > 0) {
    setTime += `${seconds}秒`;
  }
  if (millisecondsLeft > 0) {
    setTime += `${millisecondsLeft}毫秒`;
  }
  return setTime;
};