Source: ZegoExpressMediaPlayer.js

  3. const EventEmitter = require('events').EventEmitter;
  4. const WebGLRender = require('./ZegoExpressWebgl');
  5. const {ZegoViewMode} = require('./ZegoExpressDefines');
  7. /**
  8.  * ZegoMediaPlayer
  9.  */
  10. class ZegoMediaPlayer extends EventEmitter {
  12.     /**
  13.      * Start playing.
  14.      *
  15.      * You need to load resources before playing
  16.      */
  17.     start(){
  18.         this.nativeMediaPlayer.start({});
  19.     }
  21.     /**
  22.      * Stop playing.
  23.      */
  24.     stop(){
  25.         this.nativeMediaPlayer.stop({});
  26.     }
  28.     /**
  29.      * Pause playing.
  30.      */
  31.     pause(){
  32.         this.nativeMediaPlayer.pause({});
  33.     }
  35.     /**
  36.      * Resume playing.
  37.      */
  38.     resume(){
  39.         this.nativeMediaPlayer.resume({});
  40.     }
  42.     /**
  43.      * Load media resource.
  44.      *
  45.      * Yon can pass the absolute path of the local resource or the URL of the network resource
  46.      * @param {string} path - the absolute path of the local resource or the URL of the network resource
  47.      * @return {Promise<number>} - load resource result
  48.      */
  49.     loadResource(path){
  50.         return this.nativeMediaPlayer.loadResource({path});
  51.     }
  53.     /**
  54.      * Get the current playback status.
  55.      *
  56.      * @return {ZegoMediaPlayerState} - current state
  57.      */
  58.     getCurrentState(){
  59.         return this.nativeMediaPlayer.getCurrentState({});
  60.     }
  62.     /**
  63.      * Set the specified playback progress.
  64.      *
  65.      * Unit is millisecond
  66.      * @param {number} millisecond - Point in time of specified playback progress
  67.      * @return {Promise<number>} - seek result
  68.      */
  69.     seekTo(millisecond){
  70.         return this.nativeMediaPlayer.seekTo({millisecond});
  71.     }
  73.     /**
  74.      * Set mediaplayer volume. Both the local play volume and the publish volume are set.
  75.      *
  76.      * @param {number} volume - The range is 0 ~ 200. The default is 60.
  77.      */
  78.     setVolume(volume){
  79.         this.nativeMediaPlayer.setVolume({volume});
  80.     }
  82.     /**
  83.      * Set mediaplayer local playback volume.
  84.      *
  85.      * @param {number} volume - The range is 0 ~ 200. The default is 60.
  86.      */
  87.     setPlayVolume(volume){
  88.         this.nativeMediaPlayer.setPlayVolume({volume});
  89.     }
  91.     /**
  92.      * Set mediaplayer publish volume.
  93.      *
  94.      * @param {number} volume - The range is 0 ~ 200. The default is 60.
  95.      */
  96.     setPublishVolume(volume){
  97.         this.nativeMediaPlayer.setPublishVolume({volume});
  98.     }
  100.     /**
  101.      * Gets the current local playback volume of the mediaplayer, the range is 0 ~ 200, with the default value of 60.
  102.      *
  103.      * @return {number} - current volume
  104.      */
  105.     getPlayVolume(){
  106.         return this.nativeMediaPlayer.getPlayVolume({});
  107.     }
  109.     /**
  110.      * Gets the current publish volume of the mediaplayer, the range is 0 ~ 200, with the default value of 60.
  111.      *
  112.      * @return {number} - current volume
  113.      */
  114.     getPublishVolume(){
  115.         return this.nativeMediaPlayer.getPublishVolume({});
  116.     }
  118.     /**
  119.      * Get the total progress of your media resources.
  120.      *
  121.      * You should load resource before invoking this function, otherwise the return value is 0
  122.      * @return {number} - Unit is millisecond
  123.      */
  124.     getTotalDuration(){
  125.         return this.nativeMediaPlayer.getTotalDuration({});
  126.     }
  128.     /**
  129.      * Get current playing progress.
  130.      *
  131.      * You should load resource before invoking this function, otherwise the return value is 0
  132.      * @return {number} - current progress
  133.      */
  134.     getCurrentProgress(){
  135.         return this.nativeMediaPlayer.getCurrentProgress({});
  136.     }
  138.     /**
  139.      * Whether to play locally silently.
  140.      *
  141.      * If [enableAux] switch is turned on, there is still sound in the publishing stream. The default is false.
  142.      * @param {boolean} mute - Mute local audio flag, The default is false.
  143.      */
  144.     muteLocal(mute){
  145.         this.nativeMediaPlayer.muteLocal({mute});
  146.     }
  148.     /**
  149.      * Set the view of the player playing video.
  150.      *
  151.      * @param {ZegoView} view - Video rendered view object
  152.      */
  153.     setPlayerView(view){
  154.         if(view == null){
  155.             this.localGLRender = null;
  156.         }
  157.         else{
  158.             view = Object.assign({ viewMode: ZegoViewMode.AspectFit, backgroundColor: 0x000000, preserveDrawingBuffer: false}, view);
  159.             this.localGLRender = new WebGLRender();
  160.             this.localGLRender.setViewMode(view.viewMode);
  161.             this.localGLRender.enablePreserveDrawingBuffer(view.preserveDrawingBuffer);
  162.             this.localGLRender.initBkColor(view.backgroundColor);
  163.             this.localGLRender.initGLfromCanvas(view.canvas);
  164.             
  165.             this.nativeMediaPlayer.setPlayerCanvas({});
  166.         }
  167.     }
  169.     /**
  170.      * Whether to mix the player's sound into the stream being published.
  171.      *
  172.      * @param {boolean} enable - Aux audio flag. The default is false.
  173.      */
  174.     enableAux(enable){
  175.         this.nativeMediaPlayer.enableAux({enable});
  176.     }
  178.     /**
  179.      * Whether to mix the player's video into the stream being published.
  180.      *
  181.      * @param {boolean} enable - enable publish video
  182.      * @param {number} channel - channel
  183.      */
  184.     enablePublishVideo(enable, channel){
  185.         this.nativeMediaPlayer.enablePublishVideo({enable, channel});
  186.     }
  188.     /**
  189.      * Whether to repeat playback.
  190.      *
  191.      * @param {boolean} enable - repeat playback flag. The default is false.
  192.      */
  193.     enableRepeat(enable){
  194.         this.nativeMediaPlayer.enableRepeat({enable});
  195.     }
  197.     /**
  198.      * Set playback progress callback interval.
  199.      *
  200.      * This function can control the callback frequency of [onMediaPlayerPlayingProgress]. When the callback interval is set to 0, the callback is stopped. The default callback interval is 1s
  201.      * This callback are not returned exactly at the set callback interval, but rather at the frequency at which the audio or video frames are processed to determine whether the callback is needed to call
  202.      * @param {number} millisecond - Interval of playback progress callback in milliseconds
  203.      */
  204.     setProgressInterval(millisecond){
  205.         this.nativeMediaPlayer.setProgressInterval({millisecond});
  206.     }
  208.     /**
  209.      * Get the number of audio tracks of the playback file.
  210.      *
  211.      * @return {number} - Number of audio tracks
  212.      */
  213.     getAudioTrackCount(){
  214.         return this.nativeMediaPlayer.getAudioTrackCount({});
  215.     }
  217.     /**
  218.      * Set the audio track of the playback file.
  219.      *
  220.      * @param {number} index - Audio track index, the number of audio tracks can be obtained through the [getAudioTrackCount] function.
  221.      */
  222.     setAudioTrackIndex(index){
  223.         this.nativeMediaPlayer.setAudioTrackIndex({index});
  224.     }
  226.     /**
  227.      * Setting up the specific voice changer parameters.
  228.      *
  229.      * @param {ZegoMediaPlayerAudioChannel} audioChannel - The audio channel to be voice changed
  230.      * @param {ZegoVoiceChangerParam} param - Voice changer parameters
  231.      */
  232.     setVoiceChangerParam(audioChannel, param){
  233.         this.nativeMediaPlayer.setVoiceChangerParam({audioChannel, param});
  234.     }
  236.     /**
  237.      * Take a screenshot of the current playing screen of the media player.
  238.      *
  239.      * Only in the case of calling `setPlayerCanvas` to set the display controls and the playback state, can the screenshot be taken normally
  240.      * @return {Promise<number, string>} - snapshot error code(errorCode) and base64 string of the image in jpg format(image)
  241.      */
  242.     takeSnapshot(){
  243.         return this.nativeMediaPlayer.takeSnapshot({});
  244.     }
  246.     getCustomVideoCapturePlugin(){
  247.         return this.nativeMediaPlayer.getCustomVideoCapturePlugin();
  248.     }
  250.     /**
  251.      * @event ZegoMediaPlayer#onMediaPlayerStateUpdate
  252.      * @desc The callback triggered when the state of the media player changes.
  253.      *
  254.      * @property {object} result - param object
  255.      * @property {ZegoMediaPlayerState} result.state - Media player status
  256.      * @property {number} result.errorCode - Error code, please refer to the error codes document https://doc-en.zego.im/en/5548.html for details.
  257.      */
  259.     /**
  260.      * @event ZegoMediaPlayer#onMediaPlayerNetworkEvent
  261.      * @desc The callback triggered when the network status of the media player changes.
  262.      *
  263.      * @property {object} result - param object
  264.      * @property {ZegoMediaPlayerNetworkEvent} result.networkEvent - Network status event
  265.      */
  267.     /**
  268.      * @event ZegoMediaPlayer#onMediaPlayerPlayingProgress
  269.      * @desc The callback to report the current playback progress of the media player.
  270.      *
  271.      * @property {object} result - param object
  272.      * @property {number} result.millisecond - Progress in milliseconds
  273.      */
  276.     callEmit() {
  277.         try {
  278.             if (arguments[0] === "onVideoData") {
  279.                 if(this.localGLRender){
  280.                     let videoFrame = {
  281.                         "videoFrameParam": arguments[1]["videoFrameParam"],
  282.                         "videoFrameBuffer": Buffer.from(arguments[1]["videoFrameBuffer"])
  283.                         }
  284.                         this.localGLRender.drawVideoFrame(videoFrame);
  285.                 }
  286.             }
  287.         } catch (error) {
  288.             // console.log("callEmit: ", error);
  289.         }
  290.         try {
  291.             this.emit(arguments[0], arguments[1]);
  292.         } catch (error) {
  293.             console.log(`error catched in your callback ${arguments[0]} : ${error}`)
  294.         }
  295.     }
  296. }
  298. module.exports = ZegoMediaPlayer;