@gumlet/insights-js-core 1.1.4 → 1.1.6

package/js/analyticsStateMachines/VideoJsAnalyticsStateMachine.js

@@ -1,503 +0,0 @@
-import logger from '../utils/Logger';
-import StateMachine from 'javascript-state-machine';
-import Events from '../enums/Events';
-import {HEARTBEAT_THRESHOLD} from '../utils/Settings';
-import {Players} from '../enums/Players';
-
-
-export class VideojsAnalyticsStateMachine {
-  static PAUSE_SEEK_DELAY = 200;
-  static SEEKED_PAUSE_DELAY = 300;
-
-  constructor(stateMachineCallbacks, opts = {}) {
-    this.stateMachineCallbacks = stateMachineCallbacks;
-
-    this.pausedTimestamp       = null;
-    this.seekTimestamp         = 0;
-    this.seekedTimestamp       = 0;
-    this.seekedTimeout         = 0;
-    this.onEnterStateTimestamp = 0;
-    this.lastPlayHeadDuration  = 0;
-    this.autoPlay              = false;
-
-    this.States = {
-      SETUP                    : 'SETUP',
-      STARTUP                  : 'STARTUP',
-      READY                    : 'READY',
-      PLAYING                  : 'PLAYING',
-      REBUFFERING              : 'REBUFFERING',
-      PAUSE                    : 'PAUSE',
-      QUALITYCHANGE            : 'QUALITYCHANGE',
-      PAUSED_SEEKING           : 'PAUSED_SEEKING',
-      PLAY_SEEKING             : 'PLAY_SEEKING',
-      END_PLAY_SEEKING         : 'END_PLAY_SEEKING',
-      QUALITYCHANGE_PAUSE      : 'QUALITYCHANGE_PAUSE',
-      QUALITYCHANGE_REBUFFERING: 'QUALITYCHANGE_REBUFFERING',
-      END                      : 'END',
-      ERROR                    : 'ERROR',
-      MUTING_READY             : 'MUTING_READY',
-      MUTING_PLAY              : 'MUTING_PLAY',
-      MUTING_PAUSE             : 'MUTING_PAUSE',
-      CASTING                  : 'CASTING'
-    };
-
-    this.createStateMachine(opts);
-  }
-
-  getAllStates() {
-    return [
-      ...Object.keys(this.States).map(key => this.States[key]),
-      'FINISH_PLAY_SEEKING',
-      'PLAY_SEEK',
-      'FINISH_QUALITYCHANGE_PAUSE',
-      'FINISH_QUALITYCHANGE',
-      'FINISH_QUALITYCHANGE_REBUFFERING'];
-  }
-
-  createStateMachine(opts = {}) {
-    this.stateMachine = StateMachine.create({
-      initial  : this.States.SETUP,
-      error: (eventName, from, to, args, errorCode, errorMessage) => {
-        logger.error('Error in statemachine: ' + errorMessage);
-      },
-      events   : [
-        {name: Events.TIMECHANGED, from: this.States.SETUP, to: this.States.SETUP},
-        {name: Events.READY, from: [this.States.SETUP, this.States.ERROR], to: this.States.READY},
-        {name: Events.PLAY, from: this.States.READY, to: this.States.STARTUP},
-        // For autoplay
-        {name: Events.PLAY, from: this.States.SETUP, to: this.States.SETUP},
-        {name: Events.TIMECHANGED, from: this.States.READY, to: this.States.STARTUP},
-
-        {name: Events.START_BUFFERING, from: this.States.STARTUP, to: this.States.STARTUP},
-        {name: Events.END_BUFFERING, from: this.States.STARTUP, to: this.States.STARTUP},
-        {name: Events.VIDEO_CHANGE, from: this.States.STARTUP, to: this.States.STARTUP},
-        {name: Events.AUDIO_CHANGE, from: this.States.STARTUP, to: this.States.STARTUP},
-        {name: Events.TIMECHANGED, from: this.States.STARTUP, to: this.States.PLAYING},
-
-        {name: Events.TIMECHANGED, from: this.States.PLAYING, to: this.States.PLAYING},
-        {name: Events.END_BUFFERING, from: this.States.PLAYING, to: this.States.PLAYING},
-        {name: Events.START_BUFFERING, from: this.States.PLAYING, to: this.States.REBUFFERING},
-        {name: Events.START_BUFFERING, from: this.States.REBUFFERING, to: this.States.REBUFFERING},
-        {name: Events.TIMECHANGED, from: this.States.REBUFFERING, to: this.States.PLAYING},
-
-        // Ignoring since it's pushed in a live stream
-        {name: Events.SEEK, from: this.States.STARTUP, to: this.States.STARTUP},
-        {name: Events.SEEK, from: this.States.PLAYING, to: this.States.PLAY_SEEKING },
-        {name: Events.TIMECHANGED, from: this.States.PLAY_SEEKING, to: this.States.PLAY_SEEKING },
-        {name: Events.TIMECHANGED, from: this.States.PAUSED_SEEKING, to: this.States.PAUSED_SEEKING },
-
-        {name: Events.PAUSE, from: this.States.PLAYING, to: this.States.PAUSE},
-        {name: Events.PAUSE, from: this.States.REBUFFERING, to: this.States.PAUSE},
-        {name: Events.TIMECHANGED, from: this.States.PAUSE, to: this.States.PAUSE},
-        {name: Events.PLAY, from: this.States.PAUSE, to: this.States.PLAYING},
-
-        {name: Events.VIDEO_CHANGE, from: this.States.PLAYING, to: this.States.QUALITYCHANGE},
-        {name: Events.AUDIO_CHANGE, from: this.States.PLAYING, to: this.States.QUALITYCHANGE},
-        {name: Events.VIDEO_CHANGE, from: this.States.QUALITYCHANGE, to: this.States.QUALITYCHANGE},
-        {name: Events.AUDIO_CHANGE, from: this.States.QUALITYCHANGE, to: this.States.QUALITYCHANGE},
-        {name: 'FINISH_QUALITYCHANGE', from: this.States.QUALITYCHANGE, to: this.States.PLAYING},
-
-        {name: Events.VIDEO_CHANGE, from: this.States.PAUSE, to: this.States.QUALITYCHANGE_PAUSE},
-        {name: Events.AUDIO_CHANGE, from: this.States.PAUSE, to: this.States.QUALITYCHANGE_PAUSE},
-        {
-          name: Events.VIDEO_CHANGE,
-          from: this.States.QUALITYCHANGE_PAUSE,
-          to  : this.States.QUALITYCHANGE_PAUSE
-        },
-        {
-          name: Events.AUDIO_CHANGE,
-          from: this.States.QUALITYCHANGE_PAUSE,
-          to  : this.States.QUALITYCHANGE_PAUSE
-        },
-        {name: 'FINISH_QUALITYCHANGE_PAUSE', from: this.States.QUALITYCHANGE_PAUSE, to: this.States.PAUSE},
-
-        {name: Events.SEEK, from: this.States.PAUSE, to: this.States.PAUSED_SEEKING},
-        {name: Events.SEEK, from: this.States.PAUSED_SEEKING, to: this.States.PAUSED_SEEKING},
-        {name: Events.AUDIO_CHANGE, from: this.States.PAUSED_SEEKING, to: this.States.PAUSED_SEEKING},
-        {name: Events.VIDEO_CHANGE, from: this.States.PAUSED_SEEKING, to: this.States.PAUSED_SEEKING},
-        {name: Events.START_BUFFERING, from: this.States.PAUSED_SEEKING, to: this.States.PAUSED_SEEKING},
-        {name: Events.END_BUFFERING, from: this.States.PAUSED_SEEKING, to: this.States.PAUSED_SEEKING},
-        {name: Events.SEEKED, from: this.States.PAUSED_SEEKING, to: this.States.PAUSE},
-        {name: Events.PLAY, from: this.States.PAUSED_SEEKING, to: this.States.PLAYING},
-        {name: Events.PAUSE, from: this.States.PAUSED_SEEKING, to: this.States.PAUSE},
-
-        {name: 'PLAY_SEEK', from: this.States.PAUSE, to: this.States.PLAY_SEEKING},
-        {name: 'PLAY_SEEK', from: this.States.PAUSED_SEEKING, to: this.States.PLAY_SEEKING},
-        {name: 'PLAY_SEEK', from: this.States.PLAY_SEEKING, to: this.States.PLAY_SEEKING},
-        {name: Events.SEEK, from: this.States.PLAY_SEEKING, to: this.States.PLAY_SEEKING},
-        {name: Events.AUDIO_CHANGE, from: this.States.PLAY_SEEKING, to: this.States.PLAY_SEEKING},
-        {name: Events.VIDEO_CHANGE, from: this.States.PLAY_SEEKING, to: this.States.PLAY_SEEKING},
-        {name: Events.START_BUFFERING, from: this.States.PLAY_SEEKING, to: this.States.PLAY_SEEKING},
-        {name: Events.END_BUFFERING, from: this.States.PLAY_SEEKING, to: this.States.PLAY_SEEKING},
-        {name: Events.SEEKED, from: this.States.PLAY_SEEKING, to: this.States.PLAY_SEEKING},
-        // {name: Events.PAUSE, from: this.States.PLAY_SEEKING, to: this.States.PLAY_SEEKING},
-
-        // We are ending the seek
-        {name: Events.SEEKED, from: this.States.PLAY_SEEKING, to: this.States.END_PLAY_SEEKING},
-        // {name: Events.PLAY, from: this.States.PLAY_SEEKING, to: this.States.END_PLAY_SEEKING},
-
-        {name: Events.START_BUFFERING, from: this.States.END_PLAY_SEEKING, to: this.States.END_PLAY_SEEKING},
-        {name: Events.END_BUFFERING, from: this.States.END_PLAY_SEEKING, to: this.States.END_PLAY_SEEKING},
-        {name: Events.SEEKED, from: this.States.END_PLAY_SEEKING, to: this.States.END_PLAY_SEEKING},
-        {name: Events.TIMECHANGED, from: this.States.END_PLAY_SEEKING, to: this.States.PLAYING},
-
-        {name: Events.END, from: this.States.PLAY_SEEKING, to: this.States.END},
-        {name: Events.END, from: this.States.PAUSED_SEEKING, to: this.States.END},
-        {name: Events.END, from: this.States.PLAYING, to: this.States.END},
-        {name: Events.END, from: this.States.PAUSE, to: this.States.END},
-        {name: Events.SEEK, from: this.States.END, to: this.States.END},
-        {name: Events.SEEKED, from: this.States.END, to: this.States.END},
-        {name: Events.TIMECHANGED, from: this.States.END, to: this.States.END},
-        {name: Events.END_BUFFERING, from: this.States.END, to: this.States.END},
-        {name: Events.START_BUFFERING, from: this.States.END, to: this.States.END},
-        {name: Events.END, from: this.States.END, to: this.States.END},
-
-        //Ignored - Livestreams do a Seek during startup and SEEKED once playback started
-        {name: Events.SEEKED, from: this.States.PLAYING, to: this.States.PLAYING},
-
-        {name: Events.PLAY, from: this.States.END, to: this.States.PLAYING},
-
-        {name: Events.ERROR, from: this.getAllStates(), to: this.States.ERROR},
-        {name: Events.PAUSE, from: this.States.ERROR, to: this.States.ERROR},
-
-        {name: Events.SEEK, from: this.States.END_PLAY_SEEKING, to: this.States.PLAY_SEEKING},
-        {name: 'FINISH_PLAY_SEEKING', from: this.States.END_PLAY_SEEKING, to: this.States.PLAYING},
-
-        {name: Events.UNLOAD, from: this.getAllStates(), to: this.States.END},
-
-        {name: Events.START_AD, from: this.States.PLAYING, to: this.States.AD},
-        {name: Events.END_AD, from: this.States.AD, to: this.States.PLAYING},
-
-        {name: Events.MUTE, from: this.States.READY, to: this.States.MUTING_READY},
-        {name: Events.UN_MUTE, from: this.States.READY, to: this.States.MUTING_READY},
-        {name: 'FINISH_MUTING', from: this.States.MUTING_READY, to: this.States.READY},
-
-        {name: Events.MUTE, from: this.States.PLAYING, to: this.States.MUTING_PLAY},
-        {name: Events.UN_MUTE, from: this.States.PLAYING, to: this.States.MUTING_PLAY},
-        {name: 'FINISH_MUTING', from: this.States.MUTING_PLAY, to: this.States.PLAYING},
-
-        {name: Events.MUTE, from: this.States.PAUSE, to: this.States.MUTING_PAUSE},
-        {name: Events.UN_MUTE, from: this.States.PAUSE, to: this.States.MUTING_PAUSE},
-        {name: 'FINISH_MUTING', from: this.States.MUTING_PAUSE, to: this.States.PAUSE},
-
-        {name: Events.START_CAST, from: [this.States.READY, this.States.PAUSE], to: this.States.CASTING},
-        {name: Events.PAUSE, from: this.States.CASTING, to: this.States.CASTING},
-        {name: Events.PLAY, from: this.States.CASTING, to: this.States.CASTING},
-        {name: Events.TIMECHANGED, from: this.States.CASTING, to: this.States.CASTING},
-        {name: Events.MUTE, from: this.States.CASTING, to: this.States.CASTING},
-        {name: Events.SEEK, from: this.States.CASTING, to: this.States.CASTING},
-        {name: Events.SEEKED, from: this.States.CASTING, to: this.States.CASTING},
-        {name: Events.END_CAST, from: this.States.CASTING, to: this.States.READY},
-
-        {name: Events.SEEK, from: this.States.READY, to: this.States.READY},
-        {name: Events.SEEKED, from: this.States.READY, to: this.States.READY},
-        {name: Events.SEEKED, from: this.States.STARTUP, to: this.States.STARTUP},
-
-        {name: Events.SOURCE_LOADED, from: this.getAllStates(), to: this.States.SETUP},
-
-        {name: Events.SOURCE_LOADED, from: this.States.SETUP, to: this.States.SETUP},
-        {name: Events.SOURCE_LOADED, from: this.States.READY, to: this.States.READY},
-
-        {name: Events.VIDEO_CHANGE, from: this.States.REBUFFERING, to: this.States.QUALITYCHANGE_REBUFFERING},
-        {name: Events.AUDIO_CHANGE, from: this.States.REBUFFERING, to: this.States.QUALITYCHANGE_REBUFFERING},
-        {name: Events.VIDEO_CHANGE, from: this.States.QUALITYCHANGE_REBUFFERING, to: this.States.QUALITYCHANGE_REBUFFERING},
-        {name: Events.AUDIO_CHANGE, from: this.States.QUALITYCHANGE_REBUFFERING, to: this.States.QUALITYCHANGE_REBUFFERING},
-        {name: 'FINISH_QUALITYCHANGE_REBUFFERING', from: this.States.QUALITYCHANGE_REBUFFERING, to: this.States.REBUFFERING},
-      ],
-      callbacks: {
-        onpause      : (event, from, to, timestamp) => {
-          if (from === this.States.PLAYING) {
-            this.pausedTimestamp = timestamp;
-          }
-        },
-        onbeforeevent: (event, from, to, timestamp, eventObject) => {
-          if (event === Events.PLAY && from === this.States.SETUP && to === this.States.SETUP) {
-            this.autoPlay = true;
-          }
-
-          if (event === Events.SEEK && (from === this.States.PAUSE || from === this.States.PLAYING)) {
-            this.seekedFrom = this.lastPlayHeadDuration;
-            this.seekTimestamp = timestamp;
-            if (timestamp - this.pausedTimestamp < VideojsAnalyticsStateMachine.PAUSE_SEEK_DELAY) {
-              this.stateMachine.PLAY_SEEK(timestamp);
-              return false;
-            }
-          }
-
-          if (event === Events.SEEK) {
-             clearTimeout(this.seekedTimeout);
-          }
-          
-
-    
-
-
-          if (event === Events.SOURCE_LOADED) {
-            // event = sourceLoaded
-            // from = Ready/Setup
-            // to = Ready/Setup i.e. current event
-            // timestamp is current Timestamp
-            // eventObject = {} event obbject is there
-
-            this.stateMachineCallbacks.loaded(timestamp, this.States.READY, eventObject);
-            return;
-          }
-
-          if ((event === Events.SEEKED && from === this.States.PAUSED_SEEKING)) {
-            this.seekedTimestamp = timestamp;
-            this.seekedTimeout   = setTimeout(() => {
-             this.stateMachine.pause(timestamp, eventObject);
-             }, VideojsAnalyticsStateMachine.SEEKED_PAUSE_DELAY);
-             return false;
-          }
-
-          if (from === this.States.REBUFFERING && to === this.States.QUALITYCHANGE_REBUFFERING) {
-            return false;
-          }
-
-          if (eventObject) {
-            this.lastPlayHeadDuration = eventObject.currentTime*1000;
-          }
-
-        },
-        onenterstate : (event, from, to, timestamp, eventObject) => {
-          if (to === this.States.SETUP) {
-            // event = startup
-            // from = none as it is the initial/first event
-            // to = SETUP
-            // timestamp is undefined
-            // eventObject is undefined
-            this.stateMachineCallbacks.setup(timestamp, this.States.SETUP, eventObject);
-          }
-          else if (to === this.States.READY) {
-            // event = ready
-            // from = SETUP
-            // to = Ready i.e. current event
-            // timestamp is current Timestamp
-            // eventObject = {} event obbject is there
-            eventObject.playerSoftware = Players.VIDEOJS;
-            this.stateMachineCallbacks.ready(timestamp, this.States.READY, eventObject);
-          }
-          else if (event === "play" && to === this.States.STARTUP) {
-            // Video is played for the first time after player iinitialisation
-
-            // event = play
-            // from = READY
-            // to = STARTUP i.e. current event
-            // timestamp is current Timestamp
-            // eventObject = {} event obbject is there
-            this.stateMachineCallbacks.first_play(timestamp, this.States.PLAY, eventObject);
-          }
-          else if (event === "timechanged" && from === this.States.STARTUP && to === this.States.PLAYING && this.autoPlay) {
-            // Video has started playing for the first time after player initialisation
-
-            // event = timechanged
-            // from = STARTUP
-            // to = PLAYING i.e. current event
-            // timestamp is current Timestamp
-            // eventObject = {} event obbject is there
-            this.stateMachineCallbacks.first_play(timestamp, this.States.PLAY, eventObject);
-            this.stateMachineCallbacks.playing(timestamp, this.States.PLAYING, eventObject);
-            this.stateMachineCallbacks.playback_started(eventObject);
-          }
-          else if (event === "play" && from === this.States.PAUSE) {
-            // Video is played after being paused
-
-            // event = play
-            // from = PAUSE
-            // to = PLAYING i.e. current event
-            // timestamp is current Timestamp
-            // eventObject = {} event obbject is there
-            this.stateMachineCallbacks.play(timestamp, this.States.PLAY, eventObject);
-            this.stateMachineCallbacks.playing(timestamp, this.States.PLAYING, eventObject);
-          }
-          else if (event === "timechanged" && from === this.States.STARTUP && to === this.States.PLAYING && !this.autoPlay) {
-            // Video has started playing for the first time after player initialisation
-
-            // event = timechanged
-            // from = STARTUP
-            // to = PLAYING i.e. current event
-            // timestamp is current Timestamp
-            // eventObject = {} event obbject is there
-            this.stateMachineCallbacks.playing(timestamp, this.States.PLAYING, eventObject);
-            this.stateMachineCallbacks.playback_started(eventObject);
-          }
-          else if (to === this.States.PAUSE && from === this.States.PLAYING) {
-            // Only fire pause event if the the video was playing
-
-            // event = pause
-            // from = PLAYING
-            // to = PAUSE i.e. current event
-            // timestamp is current Timestamp
-            // eventObject = {} event obbject is there
-            this.stateMachineCallbacks.pause(timestamp, this.States.PAUSE, eventObject);
-          }
-          else if (to === this.States.END) {
-            // event = end
-            // from = PLAYING
-            // to = END i.e. current event
-            // timestamp is current Timestamp
-            // eventObject = {} event obbject is there
-
-            this.stateMachineCallbacks.end(timestamp, this.States.END, eventObject);
-          }
-          else if (to === this.States.END) {
-            // event = mute
-            // from = PLAYING/PAUSE etc
-            // to = MUTING_PAUSE/etc i.e. current event
-            // timestamp is current Timestamp
-            // eventObject = {} event obbject is there
-
-            this.stateMachineCallbacks.mute(timestamp, eventObject);
-          }
-          else if (event === Events.START_BUFFERING) {
-            // event = startBuffering
-            // from = PLAYING etc
-            // to = REBUFFERING/etc i.e. current event
-            // timestamp is current Timestamp
-            // eventObject = {} event obbject is there
-
-            this.stateMachineCallbacks.start_rebuffer(timestamp, this.States.REBUFFERING, eventObject);
-          }
-          else if (event === "timechanged" && from === this.States.REBUFFERING && to === this.States.PLAYING) {
-            // event = endBuffering
-            // from = REBUFFERING
-            // to = PLAYING/etc i.e. current event
-            // timestamp is current Timestamp
-            // eventObject = {} event obbject is there
-
-            this.stateMachineCallbacks.end_rebuffer(timestamp, this.States.REBUFFERING, eventObject);
-          }
-
-
-          if (from === 'none' && opts.starttime) {
-            this.onEnterStateTimestamp = opts.starttime;
-          } else {
-            this.onEnterStateTimestamp = timestamp || new Date().getTime();
-          }
-
-          // logger.log('[' + from + '] => ' + event + ' => [' + to + ']');
-          //logger.log('Entering State ' + to + ' with ' + event + ' from ' + from);
-          if (eventObject && to !== this.States.PAUSED_SEEKING && to !== this.States.PLAY_SEEKING && to !== this.States.END_PLAY_SEEKING) {
-            //logger.log('Setting video time start to ' + eventObject.currentTime + ', going to ' + to);
-            this.stateMachineCallbacks.setVideoTimeStartFromEvent(eventObject);
-          }
-
-          if (event === 'PLAY_SEEK' && to === this.States.PLAY_SEEKING && to !== this.States.PLAY_SEEKING && to !== this.States.END_PLAY_SEEKING) {
-            this.seekTimestamp = this.onEnterStateTimestamp;
-          }
-
-          // if (event === Events.START_CAST && to === this.States.CASTING) {
-          //   this.stateMachineCallbacks.startCasting(timestamp, eventObject);
-          // }
-        },
-        onafterevent : (event, from, to, timestamp) => {
-          if (to === this.States.QUALITYCHANGE) {
-            this.stateMachine.FINISH_QUALITYCHANGE(timestamp);
-          }
-          if (to === this.States.MUTING_READY || to === this.States.MUTING_PLAY || to === this.States.MUTING_PAUSE) {
-            this.stateMachine.FINISH_MUTING(timestamp);
-          }
-        },
-        onleavestate : (event, from, to, timestamp, eventObject) => {
-          this.stateMachineCallbacks.resetSessionExpiry();
-
-          if (!timestamp) {
-            return;
-          }
-
-          const stateDuration = timestamp - this.onEnterStateTimestamp;
-          //logger.log('State ' + from + ' was ' + stateDuration + ' ms event:' + event);
-
-          if (eventObject && to !== this.States.PAUSED_SEEKING && to !== this.States.PLAY_SEEKING && to !== this.States.END_PLAY_SEEKING) {
-            logger.log('Setting video time end to ' + eventObject.currentTime + ', going to ' + to);
-            this.stateMachineCallbacks.setVideoTimeEndFromEvent(eventObject);
-          }
-
-          if (event === 'PLAY_SEEK' && from === this.States.PAUSE) {
-            return true;
-          }
-
-          // Similar to bitmovin, copy the logic
-          const fnName = from.toLowerCase();
-          if (from === this.States.END_PLAY_SEEKING || from === this.States.PAUSED_SEEKING) {
-            const seekDuration = this.seekedTimestamp - this.seekTimestamp;
-            this.stateMachineCallbacks.playback_seeked(this.seekedFrom, eventObject.currentTime*1000, seekDuration, to);
-            logger.log('Seek was ' + seekDuration + 'ms');
-          } else if (event === Events.UNLOAD && from === this.States.PLAYING) {
-            this.stateMachineCallbacks.playingAndBye(stateDuration, fnName, eventObject);
-          } else if (from === this.States.PAUSE && to !== this.States.PAUSED_SEEKING) {
-            this.stateMachineCallbacks.setVideoTimeStartFromEvent(event);
-            // this.stateMachineCallbacks.pause(stateDuration, fnName, eventObject);
-          } else {
-            // const callbackFunction = this.stateMachineCallbacks[fnName];
-            // if (typeof callbackFunction === 'function') {
-            //   callbackFunction(stateDuration, fnName, eventObject);
-            // } else {
-            //   logger.error('Could not find callback function for ' + fnName);
-            // }
-          }
-
-          // if (eventObject && to !== this.States.PAUSED_SEEKING && to !== this.States.PLAY_SEEKING && to !== this.States.END_PLAY_SEEKING) {
-          //   //logger.log('Setting video time start to ' + eventObject.currentTime + ', going to ' + to);
-          //   this.stateMachineCallbacks.setVideoTimeStartFromEvent(eventObject);
-          // }
-
-          if (event === Events.VIDEO_CHANGE) {
-            this.stateMachineCallbacks.videoChange(eventObject);
-          } else if (event === Events.AUDIO_CHANGE) {
-            this.stateMachineCallbacks.audioChange(eventObject);
-          } else if (event === Events.MUTE) {
-            logger.log('Setting sample to muted');
-            this.stateMachineCallbacks.mute();
-          } else if (event === Events.UN_MUTE) {
-            logger.log('Setting sample to unmuted');
-            this.stateMachineCallbacks.unMute();
-          }
-        },
-        onseek       : (event, from, to, timestamp) => {
-          this.seekTimestamp = timestamp;
-        },
-        onseeked     : (event, from, to, timestamp) => {
-          this.seekedTimestamp = timestamp;
-        },
-        ontimechanged: (event, from, to, timestamp, eventObject) => {
-          const stateDuration = timestamp - this.onEnterStateTimestamp;
-
-          if (stateDuration > HEARTBEAT_THRESHOLD) {
-            this.stateMachineCallbacks.setVideoTimeEndFromEvent(eventObject);
-
-            logger.log('Sending heartbeat');
-            this.stateMachineCallbacks.heartbeat(stateDuration, from.toLowerCase(), eventObject);
-            this.onEnterStateTimestamp = timestamp;
-
-            this.stateMachineCallbacks.setVideoTimeStartFromEvent(eventObject);
-            this.stateMachineCallbacks.resetSessionExpiry();
-          }
-        },
-        onplayerError: (event, from, to, timestamp, eventObject) => {
-          this.stateMachineCallbacks.error(eventObject);
-        }
-      }
-    });
-  }
-
-  callEvent(eventType, eventObject, timestamp) {
-    const exec = this.stateMachine[eventType];
-
-    if (exec) {
-      exec.call(this.stateMachine, timestamp, eventObject);
-    } else {
-      logger.log('Ignored Event: ' + eventType);
-    }
-  }
-
-  updateMetadata(metadata) {
-    this.stateMachineCallbacks.updateSample(metadata);
-  }
-
-  static pad(str, length) {
-    const padStr = new Array(length).join(' ');
-    return (str + padStr).slice(0, length);
-  }
-}

package/js/cast/CastClient.js

@@ -1,50 +0,0 @@
-import {MESSAGE_NAMESPACE} from '../utils/Settings';
-import logger from '../utils/Logger';
-
-/* global cast */
-
-class CastClient {
-  setUp() {
-    logger.log('setting up cast session');
-    this.castSession = cast.framework.CastContext.getInstance().getCurrentSession();
-    this.addMessageListener();
-  }
-
-  addMessageListener() {
-    const applicationMetadata = this.castSession.getApplicationMetadata();
-    if (!applicationMetadata || applicationMetadata.namespaces.indexOf(MESSAGE_NAMESPACE) < 0) {
-      logger.log('No analytics on chrome cast receiver enabled!');
-      return;
-    }
-
-    logger.log('adding message listener');
-    this.castSession.addMessageListener(MESSAGE_NAMESPACE, (ns, message) => {
-      logger.log('Received: ' + ns + ' ' + message);
-
-      try {
-        const receiverMessage = JSON.parse(message);
-        this.handleReceiverMessage(receiverMessage);
-
-      } catch (error) {
-        logger.error('Message parsing failed ' + message);
-      }
-    });
-  }
-
-  handleReceiverMessage(message) {
-    logger.log(message);
-  }
-
-  sendMessage(message) {
-    const applicationMetadata = this.castSession.getApplicationMetadata();
-    if (!applicationMetadata || applicationMetadata.namespaces.indexOf(MESSAGE_NAMESPACE) < 0) {
-      logger.log('No analytics on chrome cast receiver enabled!');
-      return;
-    }
-
-    logger.log('Sending message: ' + JSON.stringify(message));
-    this.castSession.sendMessage(MESSAGE_NAMESPACE, message);
-  }
-}
-
-export default CastClient;

package/js/cast/CastReceiver.js

@@ -1,37 +0,0 @@
-import {MESSAGE_NAMESPACE} from '../utils/Settings';
-import logger from '../utils/Logger';
-
-/* global cast */
-
-class CastReceiver {
-  setUp() {
-    const castReceiverManager = cast.receiver.CastReceiverManager.getInstance();
-    this.messageBus = castReceiverManager.getCastMessageBus(
-      MESSAGE_NAMESPACE,
-      cast.receiver.CastMessageBus.MessageType.JSON
-    );
-
-    logger.log(this.messageBus);
-
-    this.messageBus.onMessage = (message) => {
-      logger.log('Received message from cast client: ' + JSON.stringify(message));
-
-      const castClientMessage = message.data;
-      this.handleClientMessage(castClientMessage);
-    };
-  }
-
-  setCallback(callback) {
-    this.callback = callback;
-  }
-
-  handleClientMessage(event) {
-    this.callback(event);
-  }
-
-  sendMessage(message) {
-    this.messageBus.broadcast(message);
-  }
-}
-
-export default CastReceiver;

package/js/core/AdapterFactory.js

@@ -1,41 +0,0 @@
-import PlayerDetector from '../utils/PlayerDetector';
-
-import BitmovinAdapter from '../adapters/BitmovinAdapter';
-import Bitmovin7Adapter from '../adapters/Bitmovin7Adapter';
-import VideoJsAdapter from '../adapters/VideoJsAdapter';
-
-import {HlsjsAdapter} from '../adapters/HlsjsAdapter';
-import {ShakaAdapter} from '../adapters/ShakaAdapter';
-import {DashjsAdapter} from '../adapters/DashjsAdapter';
-import {HTML5Adapter} from '../adapters/HTML5Adapter';
-
-/**
- * Stateless. Auto-maps given player instance to new adapter instances.
- * @class
- */
-class AdapterFactory {
-  /**
-   * @param {object} player
-   * @param {AnalyticsEventCallback} eventCallback
-   * @param {AnalyticsStateMachine} stateMachine
-   */
-  static getAdapter(player, eventCallback, stateMachine, mediaElement=null) {
-    if (PlayerDetector.isBitmovinVersionPre7(player)) {
-      return new BitmovinAdapter(player, eventCallback);
-    } else if (PlayerDetector.isBitmovinVersion7Plus(player)) {
-      return new Bitmovin7Adapter(player, eventCallback);
-    } else if (PlayerDetector.isVideoJs(player)) {
-      return new VideoJsAdapter(player, eventCallback, stateMachine);
-    } else if(PlayerDetector.isHlsjs(player)) {
-      return new HlsjsAdapter(player, eventCallback, stateMachine);
-    } else if(PlayerDetector.isShaka(player)) {
-      return new ShakaAdapter(player, eventCallback, stateMachine, mediaElement);
-    } else if (PlayerDetector.isDashjs(player)) {
-      return new DashjsAdapter(player, eventCallback, stateMachine);
-    }else{
-      return new HTML5Adapter(player, eventCallback, stateMachine)
-    }
-  }
-}
-
-export default AdapterFactory;