文档开发者中心
我的
|

HarmonyOS 6

HarmonyOS 5

播放视频时,拖动进度条结束后视频无法自动恢复播放

播放视频时,拖动进度条时视频暂停,拖动结束后视频无法自动恢复播放。 图一:期望效果。 图二:实际效果。 &&KNOWLEDGEIMGURLPREFIX&&/20251010/3b98478c-8d3e-4ccf-bf1f-c2418e8eb852.gif&&KNOWLEDGEIMGURLPREFIX&&/20251010/5bbf1cbf-e816-4483-b23b-1d01ac14eb5a.gif

点赞
收藏
回复
1
分享
举报
浏览155 发布于2025-10-16 12:45未知归属地
全部评论
最多点赞
最新发布
最早发布

【背景知识】

  • 使用AVPlayer可以实现端到端播放原始媒体资源。
  • XComponent提供用于图形绘制和媒体数据写入的Surface,XComponent负责将其嵌入到视图中,支持应用自定义Surface位置和大小。
  • play和pause可控制AVPlayer视频的播放和暂停。
  • Slider为滑动条组件,通常用于快速调节设置值,如音量调节、亮度调节等应用场景。
  • 设置onChange可在Slider拖动或点击时触发事件回调。

【问题定位】

  1. 使用DevEco Testing查看进度条组件,该组件为Slider组件。
  2. 查看该Slider组件的设置,拖动进度条时在onChange中使用pause方法暂停播放,且拖动结束后没有使用play方法恢复播放。
    收起
    自动换行
    深色代码主题
    复制
    import display from '@ohos.display';
    import emitter from '@ohos.events.emitter';
    import { common } from '@kit.AbilityKit';
    import media from '@ohos.multimedia.media';
    import { audio } from '@kit.AudioKit';
    import { window } from '@kit.ArkUI';
    
    const PROPORTION = 0.99; // 占屏幕比例
    const SURFACE_W = 0.9; // 表面宽比例
    const SURFACE_H = 1.78; // 表面高比例
    const SET_INTERVAL = 100; // interval间隔时间
    const TIME_ONE = 60000;
    const TIME_TWO = 1000;
    let innerEventFalse: emitter.InnerEvent = {
      eventId: 1,
      priority: emitter.EventPriority.HIGH
    };
    let innerEventTrue: emitter.InnerEvent = {
      eventId: 2,
      priority: emitter.EventPriority.HIGH
    };
    let innerEventWH: emitter.InnerEvent = {
      eventId: 3,
      priority: emitter.EventPriority.HIGH
    };
    
    @Entry
    @Component
    struct Index {
      tag: string = 'AVPlayManager';
      private xComponentController: XComponentController = new XComponentController();
      private avPlayer: media.AVPlayer | null = null;
      private surfaceId: string = '';
      private intervalID: number = -1;
      private seekTime: number = -1;
      private context: common.UIAbilityContext | undefined = undefined;
      @State fileName: string = 'video3.mp4'; // 'video3.mp4'需要在src/main/resources/rawfile中替换为开发者需要的视频资源文件
      @State isSwiping: boolean = false; // 用户滑动过程中
      @State isPaused: boolean = true; // 暂停播放
      @State xComponentFlag: boolean = false;
      @StorageLink('durationTime') durationTime: number = 0; // 视频总时长
      @StorageLink('currentTime') currentTime: number = 0; // 视频当前时间
      @State surfaceW: number | null = null;
      @State surfaceH: number | null = null;
      @State percent: number = 0;
      @State windowWidth: number = 300;
      @State windowHeight: number = 200;
      @State xHeight: string = '';
      @State xWidth: string = '';
      private panOption: PanGestureOptions = new PanGestureOptions({ direction: PanDirection.Horizontal });
      @State increaseTime: number = 0;
    
      getDurationTime(): number {
        return this.durationTime;
      }
    
      getCurrentTime(): number {
        return this.currentTime;
      }
    
      timeConvert(time: number): string {
        let min: number = Math.floor(time / TIME_ONE);
        let second: string = ((time % TIME_ONE) / TIME_TWO).toFixed(0);
        second = second.padStart(2, '0');
        return `${min}:${second}`;
      }
    
      async msleepAsync(ms: number): Promise<boolean> {
        return new Promise((resolve, reject) => {
          setTimeout(() => {
            resolve(true)
          }, ms)
        })
      }
    
      async avSetupVideo() {
        // 通过UIAbilityContext的resourceManager成员的getRawFd接口获取媒体资源播放地址。
        // 返回类型为{fd,offset,length},fd为HAP包fd地址,offset为媒体资源偏移量,length为播放长度。
        if (this.context === undefined) {
          return;
        }
        let fileDescriptor = await this.context.resourceManager.getRawFd(this.fileName);
        let avFileDescriptor: media.AVFileDescriptor =
          { fd: fileDescriptor.fd, offset: fileDescriptor.offset, length: fileDescriptor.length };
    
        if (this.avPlayer) {
          console.info(`${this.tag}: init avPlayer release2createNew`);
          this.avPlayer.release();
          await this.msleepAsync(1500);
        }
        // 创建avPlayer实例对象
        this.avPlayer = await media.createAVPlayer();
    
        // 创建状态机变化回调函数
        await this.setAVPlayerCallback((avPlayer: media.AVPlayer) => {
          this.percent = avPlayer.width / avPlayer.height;
          this.setVideoWH();
          this.durationTime = this.getDurationTime();
          setInterval(() => { // 更新当前时间
            if (!this.isSwiping) {
              this.currentTime = this.getCurrentTime();
            }
          }, SET_INTERVAL);
        });
    
        // 为fdSrc赋值触发initialized状态机上报
        this.avPlayer.fdSrc = avFileDescriptor;
    
        this.avPlayer.on('audioInterrupt', (interruptEvent: audio.InterruptEvent) => {
          if (interruptEvent.forceType === audio.InterruptForceType.INTERRUPT_FORCE) {
            // 强制打断类型(INTERRUPT_FORCE):音频相关处理已由系统执行,应用需更新自身状态,做相应调整。
            switch (interruptEvent.hintType) {
              case audio.InterruptHint.INTERRUPT_HINT_PAUSE:
                this.isPaused = true; // 应用切换至音频暂停状态
                let context: common.UIAbilityContext = this.getUIContext().getHostContext() as common.UIAbilityContext;
                // 调用该接口手动改变设备横竖屏状态
                window.getLastWindow(context).then((lastWindow) => {
                  lastWindow.setPreferredOrientation(window.Orientation.PORTRAIT)
                });
                break;
              case audio.InterruptHint.INTERRUPT_HINT_STOP:
                // 此分支表示系统已将音频流停止(永久失去焦点),为保持状态一致,应用需切换至音频暂停状态。
                this.isPaused = true; // 此句为简化处理,代表应用切换至音频暂停状态的若干操作。
                break;
              default:
                break;
            }
          }
        });
      }
    
      avPlay(): void {
        if (this.avPlayer) {
          try {
            this.avPlayer.play();
          } catch (e) {
            console.error(`${this.tag}: avPlay = ${JSON.stringify(e)}`);
          }
        }
      }
    
      avPause(): void {
        if (this.avPlayer) {
          try {
            this.avPlayer.pause();
            console.info(`${this.tag}: avPause==`);
          } catch (e) {
            console.error(`${this.tag}: avPause== ${JSON.stringify(e)}`);
          }
        }
      }
    
      async avSeek(seekTime: number): Promise<void> {
        if (this.avPlayer) {
          this.avPlayer?.seek(seekTime, 2);
          // 跳转到目的位置后未使用play方法恢复播放
        }
      }
    
      // 注册avplayer回调函数
      async setAVPlayerCallback(callback: (avPlayer: media.AVPlayer) => void, vType?: number): Promise<void> {
        // seek操作结果回调函数
        if (this.avPlayer == null) {
          console.error(`${this.tag}: avPlayer has not init!`);
          return;
        }
        this.avPlayer.on('seekDone', (seekDoneTime) => {
          console.info(`${this.tag}: setAVPlayerCallback AVPlayer seek succeeded, seek time is ${seekDoneTime}`);
        });
        this.avPlayer.on('speedDone', (speed) => {
          console.info(`${this.tag}: setAVPlayerCallback AVPlayer speedDone, speed is ${speed}`);
        });
        // error回调监听函数,当avPlayer在操作过程中出现错误时调用reset接口触发重置流程
        this.avPlayer.on('error', (err) => {
          console.error(`${this.tag}: setAVPlayerCallback Invoke avPlayer failed ${JSON.stringify(err)}`);
          if (this.avPlayer == null) {
            console.error(`${this.tag}: avPlayer has not init on error`);
            return;
          }
          this.avPlayer.reset();
        });
        // 状态机变化回调函数
        this.avPlayer.on('stateChange', async (state, reason) => {
          if (this.avPlayer == null) {
            console.info(`${this.tag}: avPlayer has not init on state change`);
            return;
          }
          switch (state) {
            case 'idle': // 成功调用reset接口后触发该状态机上报
              console.info(`${this.tag}: setAVPlayerCallback AVPlayer state idle called.`);
              break;
            case 'initialized': // avplayer设置播放源后触发该状态上报
              console.info(`${this.tag}: setAVPlayerCallback AVPlayer state initialized called.`);
              if (this.surfaceId) {
                this.avPlayer.surfaceId = this.surfaceId; // 设置显示画面,当播放的资源为纯音频时无需设置
                console.info(`${this.tag}: setAVPlayerCallback this.avPlayer.surfaceId = ${this.avPlayer.surfaceId}`);
                this.avPlayer.prepare();
              }
              break;
            case 'prepared': // prepare调用成功后上报该状态机
              console.info(`${this.tag}: setAVPlayerCallback AVPlayer state prepared called.`);
              this.avPlayer.on('bufferingUpdate', (infoType: media.BufferingInfoType, value: number) => {
                console.info(`${this.tag}: bufferingUpdate called, infoType value: ${infoType}, value:${value}}`);
              })
              this.durationTime = this.avPlayer.duration;
              this.currentTime = this.avPlayer.currentTime;
              this.avPlayer.play(); // 调用播放接口开始播放
              callback(this.avPlayer);
              break;
            case 'playing': // play成功调用后触发该状态机上报
              console.info(`${this.tag}: setAVPlayerCallback AVPlayer state playing called.`);
              if (this.intervalID !== -1) {
                clearInterval(this.intervalID)
              }
              this.intervalID = setInterval(() => { // 更新当前时间
                AppStorage.setOrCreate('durationTime', this.durationTime);
                AppStorage.setOrCreate('currentTime', this.currentTime);
              }, 100);
              // 根据播放状态提交相应事件
              let eventDataTrue: emitter.EventData = {
                data: {
                  'flag': true
                }
              };
              let innerEventTrue: emitter.InnerEvent = {
                eventId: 2,
                priority: emitter.EventPriority.HIGH
              };
              emitter.emit(innerEventTrue, eventDataTrue);
              break;
            case 'completed': // 播放结束后触发该状态机上报
              console.info(`${this.tag}: setAVPlayerCallback AVPlayer state completed called.`);
              let eventDataFalse: emitter.EventData = {
                data: {
                  'flag': false
                }
              };
              let innerEvent: emitter.InnerEvent = {
                eventId: 1,
                priority: emitter.EventPriority.HIGH
              };
              emitter.emit(innerEvent, eventDataFalse);
              if (this.intervalID !== -1) {
                clearInterval(this.intervalID)
              }
              this.avPlayer.off('bufferingUpdate')
              AppStorage.setOrCreate('currentTime', this.durationTime);
              break;
            case 'released':
              console.info(`${this.tag}: setAVPlayerCallback released called.`);
              break
            case 'stopped':
              console.info(`${this.tag}: setAVPlayerCallback AVPlayer state stopped called.`);
              break
            case 'error':
              console.error(`${this.tag}: setAVPlayerCallback AVPlayer state error called.`);
              break
            case 'paused':
              console.info(`${this.tag}: setAVPlayerCallback AVPlayer state paused called.`);
              break
            default:
              console.info(`${this.tag}: setAVPlayerCallback AVPlayer state unknown called.`);
              break;
          }
        });
        // 时间上报监听函数
        this.avPlayer.on('timeUpdate', (time: number) => {
          this.currentTime = time;
        });
      }
    
      aboutToAppear() {
        this.windowWidth = display.getDefaultDisplaySync().width;
        this.windowHeight = display.getDefaultDisplaySync().height;
        this.surfaceW = this.windowWidth * SURFACE_W;
        this.surfaceH = this.surfaceW / SURFACE_H;
        this.xHeight = this.surfaceH.toString() + 'px';
        this.xWidth = this.surfaceW.toString() + 'px';
        this.isPaused = true;
        this.context = this.getUIContext().getHostContext() as common.UIAbilityContext;
      }
    
      aboutToDisappear() {
        if (this.avPlayer == null) {
          console.info(`${this.tag}: avPlayer has not init aboutToDisappear`);
          return;
        }
        this.avPlayer.release((err) => {
          if (err == null) {
            console.info(`${this.tag}: videoRelease release success`);
          } else {
            console.error(`${this.tag}: videoRelease release failed, error message is = ${JSON.stringify(err.message)}`);
          }
        });
        emitter.off(innerEventFalse.eventId);
      }
    
      onPageHide() {
        this.avPause();
        this.isPaused = false;
      }
    
      onPageShow() {
        emitter.on(innerEventTrue, (res: emitter.EventData) => {
          if (res.data) {
            this.isPaused = res.data.flag;
            this.xComponentFlag = res.data.flag;
          }
        });
        emitter.on(innerEventFalse, (res: emitter.EventData) => {
          if (res.data) {
            this.isPaused = res.data.flag;
          }
        });
        emitter.on(innerEventWH, (res: emitter.EventData) => {
          if (res.data) {
            this.windowWidth = res.data.width;
            this.windowHeight = res.data.height;
            this.setVideoWH();
          }
        });
      }
    
      setVideoWH(): void {
        if (this.percent >= 1) { // 横向视频
          this.surfaceW = Math.round(this.windowWidth * PROPORTION);
          this.surfaceH = Math.round(this.surfaceW / this.percent);
        } else { // 纵向视频
          this.surfaceH = Math.round(this.windowHeight * PROPORTION);
          this.surfaceW = Math.round(this.surfaceH * this.percent);
        }
      }
    
      @Builder
      CoverXComponent() {
        XComponent({
          // 装载视频容器
          id: 'xComponent',
          type: XComponentType.SURFACE,
          controller: this.xComponentController
        })
          .id('VideoView')
          .visibility(this.xComponentFlag ? Visibility.Visible : Visibility.Hidden)
          .onLoad(() => {
            this.surfaceId = this.xComponentController.getXComponentSurfaceId();
            this.avSetupVideo();
          })
          .height(this.xHeight)
          .width(this.xWidth)
      }
    
      build() {
        Column() {
          Stack() {
            Stack() {
              this.CoverXComponent()
    
              if (this.isSwiping) {
                Text(this.timeConvert(this.currentTime + this.increaseTime) + '/' + this.timeConvert(this.durationTime))
                  .fontColor(Color.White)
              }
            }
            .alignContent(Alignment.Center)
            .id('VideoView')
            .height('100%')
            .width('100%')
    
            Column() {
              Blank()
              Column() {
                Row() {
                  Row() {
                    // $r('app.media.ic_video_play')和$r('app.media.ic_video_pause')需要替换为开发者需要的图片资源文件
                    Image(this.isPaused ? $r('app.media.ic_video_play') : $r('app.media.ic_video_pause')) // 暂停/播放
                      .id(this.isPaused ? 'pause' : 'play')
                      .width(40)
                      .height(40)
                      .onClick(() => {
                        if (this.isPaused) {
                          this.avPause();
                          this.isPaused = false;
                        } else {
                          this.avPlay();
                          this.isPaused = true;
                        }
                      })
                    // 左侧时间
                    Text(this.timeConvert(this.currentTime))
                      .id('currentTimeText')
                      .fontColor(Color.White)
                      .textAlign(TextAlign.End)
                      .fontWeight(FontWeight.Regular)
                      .margin({ left: 10 })
                  }
    
                  // 进度条
                  Row() {
                    Slider({
                      value: this.currentTime + this.increaseTime,
                      min: 0,
                      max: this.durationTime,
                      style: SliderStyle.OutSet
                    })
                      .id('Slider')
                      .blockColor(Color.White)
                      .trackColor(Color.Gray)
                      .selectedColor('#007DFF')
                      .showTips(false)
                      .onChange((value: number, mode: SliderChangeMode) => {
                        if (mode === SliderChangeMode.Begin) {
                          this.isSwiping = true;
                          this.avPause(); // 开始拖动进度条时暂停播放
                        } else if (mode === SliderChangeMode.End) {
                          this.isSwiping = false;
                          if (this.seekTime !== value) {
                            this.seekTime = value;
                            this.avSeek(Number.parseInt(value.toFixed(0))); // 停止拖动后跳转到目的位置
                          }
                        } else if (mode === SliderChangeMode.Moving) {
                          this.currentTime = value;
                        }
                      })
                  }
                  .layoutWeight(1)
                  .margin({ left: 5 })
    
                  Row() {
                    // 右侧时间
                    Text(this.timeConvert(this.durationTime))
                      .id('durationTimeText')
                      .fontColor(Color.White)
                      .fontWeight(FontWeight.Regular)
                  }
                }
                .justifyContent(FlexAlign.Center)
                .padding({ left: 10, right: 5 })
                .width('100%')
              }
              .width('100%')
              .justifyContent(FlexAlign.Center)
              .margin({ bottom: 10 })
            }
            .width('100%')
            .height('100%')
            .margin({ bottom: 20 })
          }
          .backgroundColor(Color.Black)
          .height('100%')
          .width('100%')
          .gesture(
            PanGesture(this.panOption)
              .onActionStart((event: GestureEvent) => {
                this.isSwiping = true;
                this.avPause();
              })
              .onActionUpdate((event: GestureEvent) => {
                if (event) {
                  this.increaseTime = event.offsetX * 5 / this.windowWidth * this.durationTime;
                  if (this.currentTime + this.increaseTime > this.durationTime) {
                    this.increaseTime = this.durationTime - this.currentTime;
                  } else if (this.currentTime + this.increaseTime < 0) {
                    this.increaseTime = -this.currentTime;
                  }
                }
              })
              .onActionEnd((event: GestureEvent) => {
                this.isSwiping = false;
                this.seekTime = this.currentTime;
                this.currentTime += this.increaseTime;
                this.increaseTime = 0;
                this.avSeek(Number.parseInt(this.currentTime.toFixed(0)));
              })
          )
        }
        .backgroundColor(Color.Black)
        .height('100%')
        .width('100%')
      }
    }
    

【分析结论】 拖动进度条时在onChange中使用pause方法暂停播放,且拖动结束后没有使用play方法恢复播放,导致拖动进度条结束后视频无法自动恢复播放。

【修改建议】 拖动进度条结束后使用play方法恢复播放。

收起
自动换行
深色代码主题
复制
import display from '@ohos.display';
import emitter from '@ohos.events.emitter';
import { common } from '@kit.AbilityKit';
import media from '@ohos.multimedia.media';
import { audio } from '@kit.AudioKit';
import { window } from '@kit.ArkUI';

const PROPORTION = 0.99; // 占屏幕比例
const SURFACE_W = 0.9; // 表面宽比例
const SURFACE_H = 1.78; // 表面高比例
const SET_INTERVAL = 100; // interval间隔时间
const TIME_ONE = 60000;
const TIME_TWO = 1000;
let innerEventFalse: emitter.InnerEvent = {
  eventId: 1,
  priority: emitter.EventPriority.HIGH
};
let innerEventTrue: emitter.InnerEvent = {
  eventId: 2,
  priority: emitter.EventPriority.HIGH
};
let innerEventWH: emitter.InnerEvent = {
  eventId: 3,
  priority: emitter.EventPriority.HIGH
};

@Entry
@Component
struct Index {
  tag: string = 'AVPlayManager';
  private xComponentController: XComponentController = new XComponentController();
  private avPlayer: media.AVPlayer | null = null;
  private surfaceId: string = '';
  private intervalID: number = -1;
  private seekTime: number = -1;
  private context: common.UIAbilityContext | undefined = undefined;
  @State fileName: string = 'video3.mp4'; // 'video3.mp4'需要在src/main/resources/rawfile中替换为开发者需要的视频资源文件
  @State isSwiping: boolean = false; // 用户滑动过程中
  @State isPaused: boolean = true; // 暂停播放
  @State xComponentFlag: boolean = false;
  @StorageLink('durationTime') durationTime: number = 0; // 视频总时长
  @StorageLink('currentTime') currentTime: number = 0; // 视频当前时间
  @State surfaceW: number | null = null;
  @State surfaceH: number | null = null;
  @State percent: number = 0;
  @State windowWidth: number = 300;
  @State windowHeight: number = 200;
  @State xHeight: string = '';
  @State xWidth: string = '';
  private panOption: PanGestureOptions = new PanGestureOptions({ direction: PanDirection.Horizontal });
  @State increaseTime: number = 0;

  getDurationTime(): number {
    return this.durationTime;
  }

  getCurrentTime(): number {
    return this.currentTime;
  }

  timeConvert(time: number): string {
    let min: number = Math.floor(time / TIME_ONE);
    let second: string = ((time % TIME_ONE) / TIME_TWO).toFixed(0);
    second = second.padStart(2, '0');
    return `${min}:${second}`;
  }

  async msleepAsync(ms: number): Promise<boolean> {
    return new Promise((resolve, reject) => {
      setTimeout(() => {
        resolve(true)
      }, ms)
    })
  }

  async avSetupVideo() {
    // 通过UIAbilityContext的resourceManager成员的getRawFd接口获取媒体资源播放地址。
    // 返回类型为{fd,offset,length},fd为HAP包fd地址,offset为媒体资源偏移量,length为播放长度。
    if (this.context === undefined) {
      return;
    }
    let fileDescriptor = await this.context.resourceManager.getRawFd(this.fileName);
    let avFileDescriptor: media.AVFileDescriptor =
      { fd: fileDescriptor.fd, offset: fileDescriptor.offset, length: fileDescriptor.length };

    if (this.avPlayer) {
      console.info(`${this.tag}: init avPlayer release2createNew`);
      this.avPlayer.release();
      await this.msleepAsync(1500);
    }
    // 创建avPlayer实例对象
    this.avPlayer = await media.createAVPlayer();

    // 创建状态机变化回调函数
    await this.setAVPlayerCallback((avPlayer: media.AVPlayer) => {
      this.percent = avPlayer.width / avPlayer.height;
      this.setVideoWH();
      this.durationTime = this.getDurationTime();
      setInterval(() => { // 更新当前时间
        if (!this.isSwiping) {
          this.currentTime = this.getCurrentTime();
        }
      }, SET_INTERVAL);
    });

    // 为fdSrc赋值触发initialized状态机上报
    this.avPlayer.fdSrc = avFileDescriptor;

    this.avPlayer.on('audioInterrupt', (interruptEvent: audio.InterruptEvent) => {
      if (interruptEvent.forceType === audio.InterruptForceType.INTERRUPT_FORCE) {
        // 强制打断类型(INTERRUPT_FORCE):音频相关处理已由系统执行,应用需更新自身状态,做相应调整。
        switch (interruptEvent.hintType) {
          case audio.InterruptHint.INTERRUPT_HINT_PAUSE:
            this.isPaused = true; // 应用切换至音频暂停状态
            let context: common.UIAbilityContext = this.getUIContext().getHostContext() as common.UIAbilityContext;
            // 调用该接口手动改变设备横竖屏状态
            window.getLastWindow(context).then((lastWindow) => {
              lastWindow.setPreferredOrientation(window.Orientation.PORTRAIT)
            });
            break;
          case audio.InterruptHint.INTERRUPT_HINT_STOP:
            // 此分支表示系统已将音频流停止(永久失去焦点),为保持状态一致,应用需切换至音频暂停状态。
            this.isPaused = true; // 此句为简化处理,代表应用切换至音频暂停状态的若干操作。
            break;
          default:
            break;
        }
      }
    });
  }

  avPlay(): void {
    if (this.avPlayer) {
      try {
        this.avPlayer.play();
      } catch (e) {
        console.error(`${this.tag}: avPlay = ${JSON.stringify(e)}`);
      }
    }
  }

  avPause(): void {
    if (this.avPlayer) {
      try {
        this.avPlayer.pause();
        console.info(`${this.tag}: avPause==`);
      } catch (e) {
        console.error(`${this.tag}: avPause== ${JSON.stringify(e)}`);
      }
    }
  }

  async avSeek(seekTime: number): Promise<void> {
    if (this.avPlayer) {
      this.avPlayer?.seek(seekTime, 2);
      this.avPlay(); // 跳转到目的位置后使用play方法恢复播放
    }
  }

  // 注册avplayer回调函数
  async setAVPlayerCallback(callback: (avPlayer: media.AVPlayer) => void, vType?: number): Promise<void> {
    // seek操作结果回调函数
    if (this.avPlayer == null) {
      console.error(`${this.tag}: avPlayer has not init!`);
      return;
    }
    this.avPlayer.on('seekDone', (seekDoneTime) => {
      console.info(`${this.tag}: setAVPlayerCallback AVPlayer seek succeeded, seek time is ${seekDoneTime}`);
    });
    this.avPlayer.on('speedDone', (speed) => {
      console.info(`${this.tag}: setAVPlayerCallback AVPlayer speedDone, speed is ${speed}`);
    });
    // error回调监听函数,当avPlayer在操作过程中出现错误时调用reset接口触发重置流程
    this.avPlayer.on('error', (err) => {
      console.error(`${this.tag}: setAVPlayerCallback Invoke avPlayer failed ${JSON.stringify(err)}`);
      if (this.avPlayer == null) {
        console.error(`${this.tag}: avPlayer has not init on error`);
        return;
      }
      this.avPlayer.reset();
    });
    // 状态机变化回调函数
    this.avPlayer.on('stateChange', async (state, reason) => {
      if (this.avPlayer == null) {
        console.info(`${this.tag}: avPlayer has not init on state change`);
        return;
      }
      switch (state) {
        case 'idle': // 成功调用reset接口后触发该状态机上报
          console.info(`${this.tag}: setAVPlayerCallback AVPlayer state idle called.`);
          break;
        case 'initialized': // avplayer设置播放源后触发该状态上报
          console.info(`${this.tag}: setAVPlayerCallback AVPlayer state initialized called.`);
          if (this.surfaceId) {
            this.avPlayer.surfaceId = this.surfaceId; // 设置显示画面,当播放的资源为纯音频时无需设置
            console.info(`${this.tag}: setAVPlayerCallback this.avPlayer.surfaceId = ${this.avPlayer.surfaceId}`);
            this.avPlayer.prepare();
          }
          break;
        case 'prepared': // prepare调用成功后上报该状态机
          console.info(`${this.tag}: setAVPlayerCallback AVPlayer state prepared called.`);
          this.avPlayer.on('bufferingUpdate', (infoType: media.BufferingInfoType, value: number) => {
            console.info(`${this.tag}: bufferingUpdate called, infoType value: ${infoType}, value:${value}}`);
          })
          this.durationTime = this.avPlayer.duration;
          this.currentTime = this.avPlayer.currentTime;
          this.avPlayer.play(); // 调用播放接口开始播放
          callback(this.avPlayer);
          break;
        case 'playing': // play成功调用后触发该状态机上报
          console.info(`${this.tag}: setAVPlayerCallback AVPlayer state playing called.`);
          if (this.intervalID !== -1) {
            clearInterval(this.intervalID)
          }
          this.intervalID = setInterval(() => { // 更新当前时间
            AppStorage.setOrCreate('durationTime', this.durationTime);
            AppStorage.setOrCreate('currentTime', this.currentTime);
          }, 100);
          // 根据播放状态提交相应事件
          let eventDataTrue: emitter.EventData = {
            data: {
              'flag': true
            }
          };
          let innerEventTrue: emitter.InnerEvent = {
            eventId: 2,
            priority: emitter.EventPriority.HIGH
          };
          emitter.emit(innerEventTrue, eventDataTrue);
          break;
        case 'completed': // 播放结束后触发该状态机上报
          console.info(`${this.tag}: setAVPlayerCallback AVPlayer state completed called.`);
          let eventDataFalse: emitter.EventData = {
            data: {
              'flag': false
            }
          };
          let innerEvent: emitter.InnerEvent = {
            eventId: 1,
            priority: emitter.EventPriority.HIGH
          };
          emitter.emit(innerEvent, eventDataFalse);
          if (this.intervalID !== -1) {
            clearInterval(this.intervalID)
          }
          this.avPlayer.off('bufferingUpdate')
          AppStorage.setOrCreate('currentTime', this.durationTime);
          break;
        case 'released':
          console.info(`${this.tag}: setAVPlayerCallback released called.`);
          break
        case 'stopped':
          console.info(`${this.tag}: setAVPlayerCallback AVPlayer state stopped called.`);
          break
        case 'error':
          console.error(`${this.tag}: setAVPlayerCallback AVPlayer state error called.`);
          break
        case 'paused':
          console.info(`${this.tag}: setAVPlayerCallback AVPlayer state paused called.`);
          break
        default:
          console.info(`${this.tag}: setAVPlayerCallback AVPlayer state unknown called.`);
          break;
      }
    });
    // 时间上报监听函数
    this.avPlayer.on('timeUpdate', (time: number) => {
      this.currentTime = time;
    });
  }

  aboutToAppear() {
    this.windowWidth = display.getDefaultDisplaySync().width;
    this.windowHeight = display.getDefaultDisplaySync().height;
    this.surfaceW = this.windowWidth * SURFACE_W;
    this.surfaceH = this.surfaceW / SURFACE_H;
    this.xHeight = this.surfaceH.toString() + 'px';
    this.xWidth = this.surfaceW.toString() + 'px';
    this.isPaused = true;
    this.context = this.getUIContext().getHostContext() as common.UIAbilityContext;
  }

  aboutToDisappear() {
    if (this.avPlayer == null) {
      console.info(`${this.tag}: avPlayer has not init aboutToDisappear`);
      return;
    }
    this.avPlayer.release((err) => {
      if (err == null) {
        console.info(`${this.tag}: videoRelease release success`);
      } else {
        console.error(`${this.tag}: videoRelease release failed, error message is = ${JSON.stringify(err.message)}`);
      }
    });
    emitter.off(innerEventFalse.eventId);
  }

  onPageHide() {
    this.avPause();
    this.isPaused = false;
  }

  onPageShow() {
    emitter.on(innerEventTrue, (res: emitter.EventData) => {
      if (res.data) {
        this.isPaused = res.data.flag;
        this.xComponentFlag = res.data.flag;
      }
    });
    emitter.on(innerEventFalse, (res: emitter.EventData) => {
      if (res.data) {
        this.isPaused = res.data.flag;
      }
    });
    emitter.on(innerEventWH, (res: emitter.EventData) => {
      if (res.data) {
        this.windowWidth = res.data.width;
        this.windowHeight = res.data.height;
        this.setVideoWH();
      }
    });
  }

  setVideoWH(): void {
    if (this.percent >= 1) { // 横向视频
      this.surfaceW = Math.round(this.windowWidth * PROPORTION);
      this.surfaceH = Math.round(this.surfaceW / this.percent);
    } else { // 纵向视频
      this.surfaceH = Math.round(this.windowHeight * PROPORTION);
      this.surfaceW = Math.round(this.surfaceH * this.percent);
    }
  }

  @Builder
  CoverXComponent() {
    XComponent({
      // 装载视频容器
      id: 'xComponent',
      type: XComponentType.SURFACE,
      controller: this.xComponentController
    })
      .id('VideoView')
      .visibility(this.xComponentFlag ? Visibility.Visible : Visibility.Hidden)
      .onLoad(() => {
        this.surfaceId = this.xComponentController.getXComponentSurfaceId();
        this.avSetupVideo();
      })
      .height(this.xHeight)
      .width(this.xWidth)
  }

  build() {
    Column() {
      Stack() {
        Stack() {
          this.CoverXComponent()

          if (this.isSwiping) {
            Text(this.timeConvert(this.currentTime + this.increaseTime) + '/' + this.timeConvert(this.durationTime))
              .fontColor(Color.White)
          }
        }
        .alignContent(Alignment.Center)
        .id('VideoView')
        .height('100%')
        .width('100%')

        Column() {
          Blank()
          Column() {
            Row() {
              Row() {
                // $r('app.media.ic_video_play')和$r('app.media.ic_video_pause')需要替换为开发者需要的图片资源文件
                Image(this.isPaused ? $r('app.media.ic_video_play') : $r('app.media.ic_video_pause')) // 暂停/播放
                  .id(this.isPaused ? 'pause' : 'play')
                  .width(40)
                  .height(40)
                  .onClick(() => {
                    if (this.isPaused) {
                      this.avPause();
                      this.isPaused = false;
                    } else {
                      this.avPlay();
                      this.isPaused = true;
                    }
                  })
                // 左侧时间
                Text(this.timeConvert(this.currentTime))
                  .id('currentTimeText')
                  .fontColor(Color.White)
                  .textAlign(TextAlign.End)
                  .fontWeight(FontWeight.Regular)
                  .margin({ left: 10 })
              }

              // 进度条
              Row() {
                Slider({
                  value: this.currentTime + this.increaseTime,
                  min: 0,
                  max: this.durationTime,
                  style: SliderStyle.OutSet
                })
                  .id('Slider')
                  .blockColor(Color.White)
                  .trackColor(Color.Gray)
                  .selectedColor('#007DFF')
                  .showTips(false)
                  .onChange((value: number, mode: SliderChangeMode) => {
                    if (mode === SliderChangeMode.Begin) {
                      this.isSwiping = true;
                      this.avPause(); // 开始拖动进度条时暂停播放
                    } else if (mode === SliderChangeMode.End) {
                      this.isSwiping = false;
                      if (this.seekTime !== value) {
                        this.seekTime = value;
                        this.avSeek(Number.parseInt(value.toFixed(0))); // 停止拖动后跳转到目的位置
                      }
                    } else if (mode === SliderChangeMode.Moving) {
                      this.currentTime = value;
                    }
                  })
              }
              .layoutWeight(1)
              .margin({ left: 5 })

              Row() {
                // 右侧时间
                Text(this.timeConvert(this.durationTime))
                  .id('durationTimeText')
                  .fontColor(Color.White)
                  .fontWeight(FontWeight.Regular)
              }
            }
            .justifyContent(FlexAlign.Center)
            .padding({ left: 10, right: 5 })
            .width('100%')
          }
          .width('100%')
          .justifyContent(FlexAlign.Center)
          .margin({ bottom: 10 })
        }
        .width('100%')
        .height('100%')
        .margin({ bottom: 20 })
      }
      .backgroundColor(Color.Black)
      .height('100%')
      .width('100%')
      .gesture(
        PanGesture(this.panOption)
          .onActionStart((event: GestureEvent) => {
            this.isSwiping = true;
            this.avPause();
          })
          .onActionUpdate((event: GestureEvent) => {
            if (event) {
              this.increaseTime = event.offsetX * 5 / this.windowWidth * this.durationTime;
              if (this.currentTime + this.increaseTime > this.durationTime) {
                this.increaseTime = this.durationTime - this.currentTime;
              } else if (this.currentTime + this.increaseTime < 0) {
                this.increaseTime = -this.currentTime;
              }
            }
          })
          .onActionEnd((event: GestureEvent) => {
            this.isSwiping = false;
            this.seekTime = this.currentTime;
            this.currentTime += this.increaseTime;
            this.increaseTime = 0;
            this.avSeek(Number.parseInt(this.currentTime.toFixed(0)));
          })
      )
    }
    .backgroundColor(Color.Black)
    .height('100%')
    .width('100%')
  }
}
展开全部
1楼回复于2025-10-16 12:45 未知归属地
写回答
新增插入模板功能
一键使用模板,快速填写内容,轻松发帖~
知道了
  • 为了保障您的信息安全,请勿上传您的敏感个人信息(如您的密码等信息)和您的敏感资产信息(如关键源代码、签名私钥、调试安装包、业务日志等信息),且您需自行承担由此产生的信息泄露等安全风险。
  • 如您发布的内容为转载内容,请注明内容来源。

我要提问题

了解社区公约,与您携手共创和谐专业的开发者社区。