Socket
Socket
Sign inDemoInstall

bigscreen-player

Package Overview
Dependencies
Maintainers
3
Versions
189
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

bigscreen-player - npm Package Compare versions

Comparing version 3.14.1 to 3.14.2

19

package.json
{
"name": "bigscreen-player",
"version": "3.14.1",
"version": "3.14.2",
"description": "Simplified media playback for bigscreen devices.",

@@ -19,8 +19,8 @@ "main": "script/bigscreenplayer.js",

},
"pre-commit": [
"test"
],
"pre-push": [
"test"
],
"husky": {
"hooks": {
"pre-commit": "npm test",
"pre-push": "npm test"
}
},
"devDependencies": {

@@ -31,3 +31,3 @@ "@babel/core": "^7.9.6",

"clean-webpack-plugin": "^3.0.0",
"eslint": "^3.0.0",
"eslint": "^7.2.0",
"eslint-plugin-es5": "1.3.1",

@@ -42,5 +42,4 @@ "eslint-plugin-jasmine": "2.10.1",

"html-webpack-plugin": "^4.3.0",
"husky": "^4.2.5",
"jasmine": "3.2.0",
"pre-commit": "^1.2.2",
"pre-push": "^0.1.1",
"requirejs": "2.0.0",

@@ -47,0 +46,0 @@ "sinon": "^7.3.2",

1382

script-test/bigscreenplayertest.js

@@ -12,897 +12,851 @@ require(

],
function (Squire, MediaState, WindowTypes, PauseTriggers, PluginEnums, Plugins, TransferFormats, LiveSupport) {
var injector = new Squire();
var bigscreenPlayer;
var bigscreenPlayerData;
var playbackElement;
var manifestData;
var liveSupport;
var successCallback;
var errorCallback;
var noCallbacks = false;
function (Squire, MediaState, WindowTypes, PauseTriggers, PluginEnums, Plugins, TransferFormats, LiveSupport) {
var injector = new Squire();
var bigscreenPlayer;
var bigscreenPlayerData;
var playbackElement;
var manifestData;
var liveSupport;
var successCallback;
var errorCallback;
var noCallbacks = false;
var mockEventHook;
var mockPlayerComponentInstance;
var mockEventHook;
var mockPlayerComponentInstance;
var mockPlayerComponent = function (playbackElement, bigscreenPlayerData, mediaSources, windowType, enableSubtitles, callback, device) {
mockEventHook = callback;
return mockPlayerComponentInstance;
};
var mockPlayerComponent = function (playbackElement, bigscreenPlayerData, mediaSources, windowType, enableSubtitles, callback, device) {
mockEventHook = callback;
return mockPlayerComponentInstance;
};
mockPlayerComponent.getLiveSupport = function () {
return liveSupport;
mockPlayerComponent.getLiveSupport = function () {
return liveSupport;
};
function setupManifestData (options) {
manifestData = {
time: options && options.time || {
windowStartTime: 724000,
windowEndTime: 4324000,
correction: 0
}
};
}
function setupManifestData (options) {
manifestData = {
time: options && options.time || {
windowStartTime: 724000,
windowEndTime: 4324000,
correction: 0
}
};
}
var mediaSourcesMock;
var mediaSourcesCallbackSuccessSpy;
var mediaSourcesCallbackErrorSpy;
var forceMediaSourcesConstructionFailure = false;
var mediaSourcesMock;
var mediaSourcesCallbackSuccessSpy;
var mediaSourcesCallbackErrorSpy;
var forceMediaSourcesConstructionFailure = false;
function initialiseBigscreenPlayer (options) {
// options = subtitlesAvailable, windowType, windowStartTime, windowEndTime
options = options || {};
function initialiseBigscreenPlayer (options) {
// options = subtitlesAvailable, windowType, windowStartTime, windowEndTime
options = options || {};
var windowType = options.windowType || WindowTypes.STATIC;
var device = options.device;
var subtitlesEnabled = options.subtitlesEnabled || false;
var windowType = options.windowType || WindowTypes.STATIC;
var device = options.device;
var subtitlesEnabled = options.subtitlesEnabled || false;
playbackElement = document.createElement('div');
playbackElement.id = 'app';
playbackElement = document.createElement('div');
playbackElement.id = 'app';
bigscreenPlayerData = {
media: {
codec: 'codec',
urls: [{url: 'videoUrl', cdn: 'cdn'}],
kind: options.mediaKind || 'video',
type: 'mimeType',
bitrate: 'bitrate',
transferFormat: options.transferFormat
},
serverDate: options.serverDate,
initialPlaybackTime: options.initialPlaybackTime
};
bigscreenPlayerData = {
media: {
codec: 'codec',
urls: [{url: 'videoUrl', cdn: 'cdn'}],
kind: options.mediaKind || 'video',
type: 'mimeType',
bitrate: 'bitrate',
transferFormat: options.transferFormat
},
serverDate: options.serverDate,
initialPlaybackTime: options.initialPlaybackTime
if (options.windowStartTime && options.windowEndTime) {
manifestData.time = {
windowStartTime: options.windowStartTime,
windowEndTime: options.windowEndTime
};
}
if (options.windowStartTime && options.windowEndTime) {
manifestData.time = {
windowStartTime: options.windowStartTime,
windowEndTime: options.windowEndTime
};
}
if (options.subtitlesAvailable) {
bigscreenPlayerData.media.captionsUrl = 'captions';
}
if (options.subtitlesAvailable) {
bigscreenPlayerData.media.captionsUrl = 'captions';
}
var callbacks;
if (!noCallbacks) {
callbacks = {onSuccess: successCallback, onError: errorCallback};
}
bigscreenPlayer.init(playbackElement, bigscreenPlayerData, windowType, subtitlesEnabled, device, callbacks);
var callbacks;
if (!noCallbacks) {
callbacks = {onSuccess: successCallback, onError: errorCallback};
}
bigscreenPlayer.init(playbackElement, bigscreenPlayerData, windowType, subtitlesEnabled, device, callbacks);
}
describe('Bigscreen Player', function () {
beforeEach(function (done) {
mediaSourcesMock = function () {
return {
init: function (urls, serverDate, windowType, liveSupport, callbacks) {
mediaSourcesCallbackSuccessSpy = spyOn(callbacks, 'onSuccess').and.callThrough();
mediaSourcesCallbackErrorSpy = spyOn(callbacks, 'onError').and.callThrough();
if (forceMediaSourcesConstructionFailure) {
callbacks.onError();
} else {
callbacks.onSuccess();
}
},
describe('Bigscreen Player', function () {
beforeEach(function (done) {
mediaSourcesMock = function () {
return {
init: function (urls, serverDate, windowType, liveSupport, callbacks) {
mediaSourcesCallbackSuccessSpy = spyOn(callbacks, 'onSuccess').and.callThrough();
mediaSourcesCallbackErrorSpy = spyOn(callbacks, 'onError').and.callThrough();
if (forceMediaSourcesConstructionFailure) {
callbacks.onError();
} else {
callbacks.onSuccess();
}
},
time: function () {
return manifestData.time;
}
};
time: function () {
return manifestData.time;
}
};
};
var mockDebugTool = jasmine.createSpyObj('mockDebugTool', ['apicall', 'time', 'event', 'keyValue', 'tearDown', 'setRootElement']);
mockPlayerComponentInstance = jasmine.createSpyObj('playerComponentMock', [
'play', 'pause', 'isEnded', 'isPaused', 'setCurrentTime', 'getCurrentTime', 'getDuration', 'getSeekableRange',
'getPlayerElement', 'isSubtitlesAvailable', 'isSubtitlesEnabled', 'setSubtitlesEnabled', 'tearDown',
'getWindowStartTime', 'getWindowEndTime']);
successCallback = jasmine.createSpy('successCallback');
errorCallback = jasmine.createSpy('errorCallback');
setupManifestData();
liveSupport = LiveSupport.SEEKABLE;
noCallbacks = false;
var mockDebugTool = jasmine.createSpyObj('mockDebugTool', ['apicall', 'time', 'event', 'keyValue', 'tearDown', 'setRootElement']);
mockPlayerComponentInstance = jasmine.createSpyObj('playerComponentMock', [
'play', 'pause', 'isEnded', 'isPaused', 'setCurrentTime', 'getCurrentTime', 'getDuration', 'getSeekableRange',
'getPlayerElement', 'isSubtitlesAvailable', 'isSubtitlesEnabled', 'setSubtitlesEnabled', 'tearDown',
'getWindowStartTime', 'getWindowEndTime']);
successCallback = jasmine.createSpy('successCallback');
errorCallback = jasmine.createSpy('errorCallback');
setupManifestData();
liveSupport = LiveSupport.SEEKABLE;
noCallbacks = false;
injector.mock({
'bigscreenplayer/mediasources': mediaSourcesMock,
'bigscreenplayer/playercomponent': mockPlayerComponent,
'bigscreenplayer/plugins': Plugins,
'bigscreenplayer/debugger/debugtool': mockDebugTool
});
injector.mock({
'bigscreenplayer/mediasources': mediaSourcesMock,
'bigscreenplayer/playercomponent': mockPlayerComponent,
'bigscreenplayer/plugins': Plugins,
'bigscreenplayer/debugger/debugtool': mockDebugTool
});
injector.require(['bigscreenplayer/bigscreenplayer'], function (bigscreenPlayerReference) {
bigscreenPlayer = bigscreenPlayerReference();
done();
});
injector.require(['bigscreenplayer/bigscreenplayer'], function (bigscreenPlayerReference) {
bigscreenPlayer = bigscreenPlayerReference();
done();
});
});
afterEach(function () {
Object.keys(mockPlayerComponentInstance).forEach(function (spyFunction) {
mockPlayerComponentInstance[spyFunction].calls.reset();
});
successCallback.calls.reset();
errorCallback.calls.reset();
forceMediaSourcesConstructionFailure = false;
afterEach(function () {
Object.keys(mockPlayerComponentInstance).forEach(function (spyFunction) {
mockPlayerComponentInstance[spyFunction].calls.reset();
});
successCallback.calls.reset();
errorCallback.calls.reset();
forceMediaSourcesConstructionFailure = false;
mediaSourcesCallbackSuccessSpy && mediaSourcesCallbackSuccessSpy.calls && mediaSourcesCallbackSuccessSpy.calls.reset();
mediaSourcesCallbackErrorSpy && mediaSourcesCallbackErrorSpy.calls && mediaSourcesCallbackErrorSpy.calls.reset();
mediaSourcesCallbackSuccessSpy && mediaSourcesCallbackSuccessSpy.calls && mediaSourcesCallbackSuccessSpy.calls.reset();
mediaSourcesCallbackErrorSpy && mediaSourcesCallbackErrorSpy.calls && mediaSourcesCallbackErrorSpy.calls.reset();
bigscreenPlayer.tearDown();
});
describe('init', function () {
beforeEach(function () {
bigscreenPlayer.tearDown();
});
describe('init', function () {
beforeEach(function () {
bigscreenPlayer.tearDown();
});
it('should set endOfStream to true when playing live and no initial playback time is set', function () {
mockPlayerComponentInstance.getCurrentTime.and.returnValue(30);
it('should set endOfStream to true when playing live and no initial playback time is set', function () {
mockPlayerComponentInstance.getCurrentTime.and.returnValue(30);
var callback = jasmine.createSpy();
var callback = jasmine.createSpy();
initialiseBigscreenPlayer({windowType: WindowTypes.SLIDING});
bigscreenPlayer.registerForTimeUpdates(callback);
initialiseBigscreenPlayer({windowType: WindowTypes.SLIDING});
bigscreenPlayer.registerForTimeUpdates(callback);
mockEventHook({data: {currentTime: 30}, timeUpdate: true, isBufferingTimeoutError: false});
mockEventHook({data: {currentTime: 30}, timeUpdate: true, isBufferingTimeoutError: false});
expect(callback).toHaveBeenCalledWith({currentTime: 30, endOfStream: true});
});
expect(callback).toHaveBeenCalledWith({currentTime: 30, endOfStream: true});
});
it('should set endOfStream to false when playing live and initialPlaybackTime is 0', function () {
mockPlayerComponentInstance.getCurrentTime.and.returnValue(0);
it('should set endOfStream to false when playing live and initialPlaybackTime is 0', function () {
mockPlayerComponentInstance.getCurrentTime.and.returnValue(0);
var callback = jasmine.createSpy('listenerSimulcast');
var callback = jasmine.createSpy('listenerSimulcast');
initialiseBigscreenPlayer({windowType: WindowTypes.SLIDING, initialPlaybackTime: 0});
initialiseBigscreenPlayer({windowType: WindowTypes.SLIDING, initialPlaybackTime: 0});
bigscreenPlayer.registerForTimeUpdates(callback);
bigscreenPlayer.registerForTimeUpdates(callback);
mockEventHook({data: {currentTime: 0}, timeUpdate: true, isBufferingTimeoutError: false});
mockEventHook({data: {currentTime: 0}, timeUpdate: true, isBufferingTimeoutError: false});
expect(callback).toHaveBeenCalledWith({currentTime: 0, endOfStream: false});
});
expect(callback).toHaveBeenCalledWith({currentTime: 0, endOfStream: false});
});
it('should call the suppiled success callback if playing VOD', function () {
initialiseBigscreenPlayer();
it('should call the suppiled success callback if playing VOD', function () {
initialiseBigscreenPlayer();
expect(successCallback).toHaveBeenCalledWith();
expect(errorCallback).not.toHaveBeenCalled();
});
expect(successCallback).toHaveBeenCalledWith();
expect(errorCallback).not.toHaveBeenCalled();
});
it('should call the suppiled success callback if playing LIVE and the manifest loads', function () {
initialiseBigscreenPlayer({windowType: WindowTypes.SLIDING});
it('should call the suppiled success callback if playing LIVE and the manifest loads', function () {
initialiseBigscreenPlayer({windowType: WindowTypes.SLIDING});
expect(mediaSourcesCallbackSuccessSpy).toHaveBeenCalledTimes(1);
expect(successCallback).toHaveBeenCalledWith();
expect(errorCallback).not.toHaveBeenCalled();
});
expect(mediaSourcesCallbackSuccessSpy).toHaveBeenCalledTimes(1);
expect(successCallback).toHaveBeenCalledWith();
expect(errorCallback).not.toHaveBeenCalled();
});
it('should call the supplied error callback if manifest fails to load', function () {
forceMediaSourcesConstructionFailure = true;
initialiseBigscreenPlayer({windowType: WindowTypes.SLIDING});
it('should call the supplied error callback if manifest fails to load', function () {
forceMediaSourcesConstructionFailure = true;
initialiseBigscreenPlayer({windowType: WindowTypes.SLIDING});
expect(mediaSourcesCallbackErrorSpy).toHaveBeenCalledTimes(1);
expect(errorCallback).toHaveBeenCalledTimes(1);
expect(successCallback).not.toHaveBeenCalled();
});
expect(mediaSourcesCallbackErrorSpy).toHaveBeenCalledTimes(1);
expect(errorCallback).toHaveBeenCalledTimes(1);
expect(successCallback).not.toHaveBeenCalled();
});
it('should not attempt to call onSuccess callback if one is not provided', function () {
noCallbacks = true;
initialiseBigscreenPlayer();
it('should not attempt to call onSuccess callback if one is not provided', function () {
noCallbacks = true;
initialiseBigscreenPlayer();
expect(successCallback).not.toHaveBeenCalled();
});
expect(successCallback).not.toHaveBeenCalled();
});
it('should not attempt to call onError callback if one is not provided', function () {
noCallbacks = true;
it('should not attempt to call onError callback if one is not provided', function () {
noCallbacks = true;
initialiseBigscreenPlayer({windowType: WindowTypes.SLIDING});
initialiseBigscreenPlayer({windowType: WindowTypes.SLIDING});
expect(errorCallback).not.toHaveBeenCalled();
});
expect(errorCallback).not.toHaveBeenCalled();
});
});
describe('getPlayerElement', function () {
it('Should call through to getPlayerElement on the playback strategy', function () {
initialiseBigscreenPlayer();
describe('getPlayerElement', function () {
it('Should call through to getPlayerElement on the playback strategy', function () {
initialiseBigscreenPlayer();
var mockedVideo = jasmine.createSpy('mockVideoElement');
var mockedVideo = jasmine.createSpy('mockVideoElement');
mockPlayerComponentInstance.getPlayerElement.and.returnValue(mockedVideo);
mockPlayerComponentInstance.getPlayerElement.and.returnValue(mockedVideo);
bigscreenPlayer.getPlayerElement();
bigscreenPlayer.getPlayerElement();
expect(bigscreenPlayer.getPlayerElement()).toBe(mockedVideo);
});
expect(bigscreenPlayer.getPlayerElement()).toBe(mockedVideo);
});
});
describe('registerForStateChanges', function () {
var callback;
beforeEach(function () {
callback = jasmine.createSpy();
bigscreenPlayer.registerForStateChanges(callback);
initialiseBigscreenPlayer();
});
describe('registerForStateChanges', function () {
var callback;
beforeEach(function () {
callback = jasmine.createSpy();
bigscreenPlayer.registerForStateChanges(callback);
initialiseBigscreenPlayer();
});
it('should fire the callback when a state event comes back from the strategy', function () {
mockEventHook({data: {state: MediaState.PLAYING}});
it('should fire the callback when a state event comes back from the strategy', function () {
mockEventHook({data: {state: MediaState.PLAYING}});
expect(callback).toHaveBeenCalledWith({state: MediaState.PLAYING, endOfStream: false});
expect(callback).toHaveBeenCalledWith({state: MediaState.PLAYING, endOfStream: false});
callback.calls.reset();
callback.calls.reset();
mockEventHook({data: {state: MediaState.WAITING}});
mockEventHook({data: {state: MediaState.WAITING}});
expect(callback).toHaveBeenCalledWith({state: MediaState.WAITING, isSeeking: false, endOfStream: false});
});
expect(callback).toHaveBeenCalledWith({state: MediaState.WAITING, isSeeking: false, endOfStream: false});
});
it('should set the isPaused flag to true when waiting after a setCurrentTime', function () {
mockEventHook({data: {state: MediaState.PLAYING}});
it('should set the isPaused flag to true when waiting after a setCurrentTime', function () {
mockEventHook({data: {state: MediaState.PLAYING}});
expect(callback).toHaveBeenCalledWith({state: MediaState.PLAYING, endOfStream: false});
expect(callback).toHaveBeenCalledWith({state: MediaState.PLAYING, endOfStream: false});
callback.calls.reset();
callback.calls.reset();
bigscreenPlayer.setCurrentTime(60);
mockEventHook({data: {state: MediaState.WAITING}});
bigscreenPlayer.setCurrentTime(60);
mockEventHook({data: {state: MediaState.WAITING}});
expect(callback).toHaveBeenCalledWith({state: MediaState.WAITING, isSeeking: true, endOfStream: false});
});
expect(callback).toHaveBeenCalledWith({state: MediaState.WAITING, isSeeking: true, endOfStream: false});
});
it('should set clear the isPaused flag after a waiting event is fired', function () {
mockEventHook({data: {state: MediaState.PLAYING}});
it('should set clear the isPaused flag after a waiting event is fired', function () {
mockEventHook({data: {state: MediaState.PLAYING}});
bigscreenPlayer.setCurrentTime(60);
mockEventHook({data: {state: MediaState.WAITING}});
bigscreenPlayer.setCurrentTime(60);
mockEventHook({data: {state: MediaState.WAITING}});
expect(callback).toHaveBeenCalledWith({state: MediaState.WAITING, isSeeking: true, endOfStream: false});
expect(callback).toHaveBeenCalledWith({state: MediaState.WAITING, isSeeking: true, endOfStream: false});
callback.calls.reset();
callback.calls.reset();
mockEventHook({data: {state: MediaState.WAITING}});
mockEventHook({data: {state: MediaState.WAITING}});
expect(callback).toHaveBeenCalledWith({state: MediaState.WAITING, isSeeking: false, endOfStream: false});
});
expect(callback).toHaveBeenCalledWith({state: MediaState.WAITING, isSeeking: false, endOfStream: false});
});
it('should set the pause trigger to the one set when a pause event comes back from strategy', function () {
bigscreenPlayer.pause();
it('should set the pause trigger to the one set when a pause event comes back from strategy', function () {
bigscreenPlayer.pause();
mockEventHook({data: {state: MediaState.PAUSED}});
mockEventHook({data: {state: MediaState.PAUSED}});
expect(callback).toHaveBeenCalledWith({state: MediaState.PAUSED, trigger: PauseTriggers.USER, endOfStream: false});
});
expect(callback).toHaveBeenCalledWith({state: MediaState.PAUSED, trigger: PauseTriggers.USER, endOfStream: false});
});
it('should set the pause trigger to device when a pause event comes back from strategy and a trigger is not set', function () {
mockEventHook({data: {state: MediaState.PAUSED}});
it('should set the pause trigger to device when a pause event comes back from strategy and a trigger is not set', function () {
mockEventHook({data: {state: MediaState.PAUSED}});
expect(callback).toHaveBeenCalledWith({state: MediaState.PAUSED, trigger: PauseTriggers.DEVICE, endOfStream: false});
});
expect(callback).toHaveBeenCalledWith({state: MediaState.PAUSED, trigger: PauseTriggers.DEVICE, endOfStream: false});
});
it('should set isBufferingTimeoutError when a fatal error event comes back from strategy', function () {
mockEventHook({data: {state: MediaState.FATAL_ERROR}, isBufferingTimeoutError: false});
it('should set isBufferingTimeoutError when a fatal error event comes back from strategy', function () {
mockEventHook({data: {state: MediaState.FATAL_ERROR}, isBufferingTimeoutError: false});
expect(callback).toHaveBeenCalledWith({state: MediaState.FATAL_ERROR, isBufferingTimeoutError: false, endOfStream: false});
});
expect(callback).toHaveBeenCalledWith({state: MediaState.FATAL_ERROR, isBufferingTimeoutError: false, endOfStream: false});
});
it('should return a reference to the callback passed in', function () {
var reference = bigscreenPlayer.registerForStateChanges(callback);
it('should return a reference to the callback passed in', function () {
var reference = bigscreenPlayer.registerForStateChanges(callback);
expect(reference).toBe(callback);
});
expect(reference).toBe(callback);
});
});
describe('unregisterForStateChanges', function () {
it('should remove callback from stateChangeCallbacks', function () {
var listener1 = jasmine.createSpy('listener1');
var listener2 = jasmine.createSpy('listener2');
var listener3 = jasmine.createSpy('listener3');
describe('unregisterForStateChanges', function () {
it('should remove callback from stateChangeCallbacks', function () {
var listener1 = jasmine.createSpy('listener1');
var listener2 = jasmine.createSpy('listener2');
var listener3 = jasmine.createSpy('listener3');
initialiseBigscreenPlayer();
initialiseBigscreenPlayer();
bigscreenPlayer.registerForStateChanges(listener1);
bigscreenPlayer.registerForStateChanges(listener2);
bigscreenPlayer.registerForStateChanges(listener3);
bigscreenPlayer.registerForStateChanges(listener1);
bigscreenPlayer.registerForStateChanges(listener2);
bigscreenPlayer.registerForStateChanges(listener3);
mockEventHook({data: {state: MediaState.PLAYING}});
mockEventHook({data: {state: MediaState.PLAYING}});
bigscreenPlayer.unregisterForStateChanges(listener2);
bigscreenPlayer.unregisterForStateChanges(listener2);
mockEventHook({data: {state: MediaState.PLAYING}});
mockEventHook({data: {state: MediaState.PLAYING}});
expect(listener1).toHaveBeenCalledTimes(2);
expect(listener2).toHaveBeenCalledTimes(1);
expect(listener3).toHaveBeenCalledTimes(2);
});
expect(listener1).toHaveBeenCalledTimes(2);
expect(listener2).toHaveBeenCalledTimes(1);
expect(listener3).toHaveBeenCalledTimes(2);
});
it('should only remove existing callbacks from stateChangeCallbacks', function () {
initialiseBigscreenPlayer();
it('should only remove existing callbacks from stateChangeCallbacks', function () {
initialiseBigscreenPlayer();
var listener1 = jasmine.createSpy('listener1');
var listener2 = jasmine.createSpy('listener2');
var listener1 = jasmine.createSpy('listener1');
var listener2 = jasmine.createSpy('listener2');
bigscreenPlayer.registerForStateChanges(listener1);
bigscreenPlayer.unregisterForStateChanges(listener2);
bigscreenPlayer.registerForStateChanges(listener1);
bigscreenPlayer.unregisterForStateChanges(listener2);
mockEventHook({data: {state: MediaState.PLAYING}});
mockEventHook({data: {state: MediaState.PLAYING}});
expect(listener1).toHaveBeenCalledWith({state: MediaState.PLAYING, endOfStream: false});
});
expect(listener1).toHaveBeenCalledWith({state: MediaState.PLAYING, endOfStream: false});
});
});
describe('registerForTimeUpdates', function () {
it('should call the callback when we get a timeupdate event from the strategy', function () {
var callback = jasmine.createSpy('listener1');
initialiseBigscreenPlayer();
bigscreenPlayer.registerForTimeUpdates(callback);
describe('registerForTimeUpdates', function () {
it('should call the callback when we get a timeupdate event from the strategy', function () {
var callback = jasmine.createSpy('listener1');
initialiseBigscreenPlayer();
bigscreenPlayer.registerForTimeUpdates(callback);
expect(callback).not.toHaveBeenCalled();
expect(callback).not.toHaveBeenCalled();
mockEventHook({data: {currentTime: 60}, timeUpdate: true});
mockEventHook({data: {currentTime: 60}, timeUpdate: true});
expect(callback).toHaveBeenCalledWith({currentTime: 60, endOfStream: false});
});
expect(callback).toHaveBeenCalledWith({currentTime: 60, endOfStream: false});
});
it('returns a reference to the callback passed in', function () {
var callback = jasmine.createSpy();
var reference = bigscreenPlayer.registerForTimeUpdates(callback);
it('returns a reference to the callback passed in', function () {
var callback = jasmine.createSpy();
var reference = bigscreenPlayer.registerForTimeUpdates(callback);
expect(reference).toBe(callback);
});
expect(reference).toBe(callback);
});
});
describe('unregisterForTimeUpdates', function () {
it('should remove callback from timeUpdateCallbacks', function () {
initialiseBigscreenPlayer();
describe('unregisterForTimeUpdates', function () {
it('should remove callback from timeUpdateCallbacks', function () {
initialiseBigscreenPlayer();
var listener1 = jasmine.createSpy('listener1');
var listener2 = jasmine.createSpy('listener2');
var listener3 = jasmine.createSpy('listener3');
var listener1 = jasmine.createSpy('listener1');
var listener2 = jasmine.createSpy('listener2');
var listener3 = jasmine.createSpy('listener3');
bigscreenPlayer.registerForTimeUpdates(listener1);
bigscreenPlayer.registerForTimeUpdates(listener2);
bigscreenPlayer.registerForTimeUpdates(listener3);
bigscreenPlayer.registerForTimeUpdates(listener1);
bigscreenPlayer.registerForTimeUpdates(listener2);
bigscreenPlayer.registerForTimeUpdates(listener3);
mockEventHook({data: {currentTime: 0}, timeUpdate: true});
mockEventHook({data: {currentTime: 0}, timeUpdate: true});
bigscreenPlayer.unregisterForTimeUpdates(listener2);
bigscreenPlayer.unregisterForTimeUpdates(listener2);
mockEventHook({data: {currentTime: 1}, timeUpdate: true});
mockEventHook({data: {currentTime: 1}, timeUpdate: true});
expect(listener1).toHaveBeenCalledTimes(2);
expect(listener2).toHaveBeenCalledTimes(1);
expect(listener3).toHaveBeenCalledTimes(2);
});
expect(listener1).toHaveBeenCalledTimes(2);
expect(listener2).toHaveBeenCalledTimes(1);
expect(listener3).toHaveBeenCalledTimes(2);
});
it('should only remove existing callbacks from timeUpdateCallbacks', function () {
initialiseBigscreenPlayer();
it('should only remove existing callbacks from timeUpdateCallbacks', function () {
initialiseBigscreenPlayer();
var listener1 = jasmine.createSpy('listener1');
var listener2 = jasmine.createSpy('listener2');
var listener1 = jasmine.createSpy('listener1');
var listener2 = jasmine.createSpy('listener2');
bigscreenPlayer.registerForTimeUpdates(listener1);
bigscreenPlayer.unregisterForTimeUpdates(listener2);
bigscreenPlayer.registerForTimeUpdates(listener1);
bigscreenPlayer.unregisterForTimeUpdates(listener2);
mockEventHook({data: {currentTime: 60}, timeUpdate: true});
mockEventHook({data: {currentTime: 60}, timeUpdate: true});
expect(listener1).toHaveBeenCalledWith({currentTime: 60, endOfStream: false});
});
expect(listener1).toHaveBeenCalledWith({currentTime: 60, endOfStream: false});
});
});
describe('registerForSubtitleChanges', function () {
it('should call the callback when we subtitles are turned on/off', function () {
var callback = jasmine.createSpy('listener1');
initialiseBigscreenPlayer();
bigscreenPlayer.registerForSubtitleChanges(callback);
describe('registerForSubtitleChanges', function () {
it('should call the callback when we subtitles are turned on/off', function () {
var callback = jasmine.createSpy('listener1');
initialiseBigscreenPlayer();
bigscreenPlayer.registerForSubtitleChanges(callback);
expect(callback).not.toHaveBeenCalled();
expect(callback).not.toHaveBeenCalled();
bigscreenPlayer.setSubtitlesEnabled(true);
bigscreenPlayer.setSubtitlesEnabled(true);
expect(callback).toHaveBeenCalledWith({enabled: true});
expect(callback).toHaveBeenCalledWith({enabled: true});
bigscreenPlayer.setSubtitlesEnabled(false);
bigscreenPlayer.setSubtitlesEnabled(false);
expect(callback).toHaveBeenCalledWith({enabled: false});
});
expect(callback).toHaveBeenCalledWith({enabled: false});
});
it('should call the callback when init() is called with subtitles enabled', function () {
var callback = jasmine.createSpy('listener1');
it('should call the callback when init() is called with subtitles enabled', function () {
var callback = jasmine.createSpy('listener1');
bigscreenPlayer.registerForSubtitleChanges(callback);
initialiseBigscreenPlayer({ subtitlesEnabled: true });
bigscreenPlayer.registerForSubtitleChanges(callback);
initialiseBigscreenPlayer({ subtitlesEnabled: true });
expect(callback).toHaveBeenCalledWith({enabled: true});
});
expect(callback).toHaveBeenCalledWith({enabled: true});
});
it('should not call the callback when init() is called without subtitles enabled', function () {
var callback = jasmine.createSpy('listener1');
it('should not call the callback when init() is called without subtitles enabled', function () {
var callback = jasmine.createSpy('listener1');
bigscreenPlayer.registerForSubtitleChanges(callback);
initialiseBigscreenPlayer();
bigscreenPlayer.registerForSubtitleChanges(callback);
initialiseBigscreenPlayer();
expect(callback).not.toHaveBeenCalled();
});
expect(callback).not.toHaveBeenCalled();
});
it('returns a reference to the callback passed in', function () {
var callback = jasmine.createSpy();
var reference = bigscreenPlayer.registerForSubtitleChanges(callback);
it('returns a reference to the callback passed in', function () {
var callback = jasmine.createSpy();
var reference = bigscreenPlayer.registerForSubtitleChanges(callback);
expect(reference).toBe(callback);
});
expect(reference).toBe(callback);
});
});
describe('unregisterForSubtitleChanges', function () {
it('should remove callback from subtitleCallbacks', function () {
initialiseBigscreenPlayer();
describe('unregisterForSubtitleChanges', function () {
it('should remove callback from subtitleCallbacks', function () {
initialiseBigscreenPlayer();
var listener1 = jasmine.createSpy('listener1');
var listener2 = jasmine.createSpy('listener2');
var listener3 = jasmine.createSpy('listener3');
var listener1 = jasmine.createSpy('listener1');
var listener2 = jasmine.createSpy('listener2');
var listener3 = jasmine.createSpy('listener3');
bigscreenPlayer.registerForSubtitleChanges(listener1);
bigscreenPlayer.registerForSubtitleChanges(listener2);
bigscreenPlayer.registerForSubtitleChanges(listener3);
bigscreenPlayer.registerForSubtitleChanges(listener1);
bigscreenPlayer.registerForSubtitleChanges(listener2);
bigscreenPlayer.registerForSubtitleChanges(listener3);
bigscreenPlayer.setSubtitlesEnabled(true);
bigscreenPlayer.setSubtitlesEnabled(true);
bigscreenPlayer.unregisterForSubtitleChanges(listener2);
bigscreenPlayer.unregisterForSubtitleChanges(listener2);
bigscreenPlayer.setSubtitlesEnabled(false);
bigscreenPlayer.setSubtitlesEnabled(false);
expect(listener1).toHaveBeenCalledTimes(2);
expect(listener2).toHaveBeenCalledTimes(1);
expect(listener3).toHaveBeenCalledTimes(2);
});
expect(listener1).toHaveBeenCalledTimes(2);
expect(listener2).toHaveBeenCalledTimes(1);
expect(listener3).toHaveBeenCalledTimes(2);
});
it('should only remove existing callbacks from subtitleCallbacks', function () {
initialiseBigscreenPlayer();
it('should only remove existing callbacks from subtitleCallbacks', function () {
initialiseBigscreenPlayer();
var listener1 = jasmine.createSpy('listener1');
var listener2 = jasmine.createSpy('listener2');
var listener1 = jasmine.createSpy('listener1');
var listener2 = jasmine.createSpy('listener2');
bigscreenPlayer.registerForSubtitleChanges(listener1);
bigscreenPlayer.unregisterForSubtitleChanges(listener2);
bigscreenPlayer.registerForSubtitleChanges(listener1);
bigscreenPlayer.unregisterForSubtitleChanges(listener2);
bigscreenPlayer.setSubtitlesEnabled(true);
bigscreenPlayer.setSubtitlesEnabled(true);
expect(listener1).toHaveBeenCalledWith({enabled: true});
});
expect(listener1).toHaveBeenCalledWith({enabled: true});
});
});
describe('setCurrentTime', function () {
it('should setCurrentTime on the strategy/playerComponent', function () {
initialiseBigscreenPlayer();
describe('setCurrentTime', function () {
it('should setCurrentTime on the strategy/playerComponent', function () {
initialiseBigscreenPlayer();
bigscreenPlayer.setCurrentTime(60);
bigscreenPlayer.setCurrentTime(60);
expect(mockPlayerComponentInstance.setCurrentTime).toHaveBeenCalledWith(60);
});
expect(mockPlayerComponentInstance.setCurrentTime).toHaveBeenCalledWith(60);
});
it('should not set current time on the strategy/playerComponent if bigscreen player is not initialised', function () {
bigscreenPlayer.setCurrentTime(60);
it('should not set current time on the strategy/playerComponent if bigscreen player is not initialised', function () {
bigscreenPlayer.setCurrentTime(60);
expect(mockPlayerComponentInstance.setCurrentTime).not.toHaveBeenCalled();
expect(mockPlayerComponentInstance.setCurrentTime).not.toHaveBeenCalled();
});
it('should set endOfStream to true when seeking to the end of a simulcast', function () {
setupManifestData({
transferFormat: TransferFormats.DASH,
time: {
windowStartTime: 10,
windowEndTime: 100
}
});
it('should set endOfStream to true when seeking to the end of a simulcast', function () {
setupManifestData({
transferFormat: TransferFormats.DASH,
time: {
windowStartTime: 10,
windowEndTime: 100
}
});
initialiseBigscreenPlayer({windowType: WindowTypes.SLIDING});
initialiseBigscreenPlayer({windowType: WindowTypes.SLIDING});
var callback = jasmine.createSpy();
var endOfStreamWindow = bigscreenPlayerData.time.windowEndTime - 2;
var callback = jasmine.createSpy();
var endOfStreamWindow = bigscreenPlayerData.time.windowEndTime - 2;
bigscreenPlayer.registerForTimeUpdates(callback);
bigscreenPlayer.registerForTimeUpdates(callback);
mockPlayerComponentInstance.getSeekableRange.and.returnValue({start: bigscreenPlayerData.time.windowStartTime, end: bigscreenPlayerData.time.windowEndTime});
mockPlayerComponentInstance.getCurrentTime.and.returnValue(endOfStreamWindow);
mockPlayerComponentInstance.getSeekableRange.and.returnValue({start: bigscreenPlayerData.time.windowStartTime, end: bigscreenPlayerData.time.windowEndTime});
mockPlayerComponentInstance.getCurrentTime.and.returnValue(endOfStreamWindow);
bigscreenPlayer.setCurrentTime(endOfStreamWindow);
bigscreenPlayer.setCurrentTime(endOfStreamWindow);
mockEventHook({data: {currentTime: endOfStreamWindow}, timeUpdate: true});
mockEventHook({data: {currentTime: endOfStreamWindow}, timeUpdate: true});
expect(callback).toHaveBeenCalledWith({currentTime: endOfStreamWindow, endOfStream: true});
});
expect(callback).toHaveBeenCalledWith({currentTime: endOfStreamWindow, endOfStream: true});
it('should set endOfStream to false when seeking into a simulcast', function () {
setupManifestData({
transferFormat: TransferFormats.DASH,
time: {
windowStartTime: 10,
windowEndTime: 100
}
});
it('should set endOfStream to false when seeking into a simulcast', function () {
setupManifestData({
transferFormat: TransferFormats.DASH,
time: {
windowStartTime: 10,
windowEndTime: 100
}
});
initialiseBigscreenPlayer({windowType: WindowTypes.SLIDING});
initialiseBigscreenPlayer({windowType: WindowTypes.SLIDING});
var callback = jasmine.createSpy();
bigscreenPlayer.registerForTimeUpdates(callback);
var callback = jasmine.createSpy();
bigscreenPlayer.registerForTimeUpdates(callback);
var middleOfStreamWindow = bigscreenPlayerData.time.windowEndTime / 2;
var middleOfStreamWindow = bigscreenPlayerData.time.windowEndTime / 2;
mockPlayerComponentInstance.getSeekableRange.and.returnValue({start: bigscreenPlayerData.time.windowStartTime, end: bigscreenPlayerData.time.windowEndTime});
mockPlayerComponentInstance.getCurrentTime.and.returnValue(middleOfStreamWindow);
mockPlayerComponentInstance.getSeekableRange.and.returnValue({start: bigscreenPlayerData.time.windowStartTime, end: bigscreenPlayerData.time.windowEndTime});
mockPlayerComponentInstance.getCurrentTime.and.returnValue(middleOfStreamWindow);
bigscreenPlayer.setCurrentTime(middleOfStreamWindow);
bigscreenPlayer.setCurrentTime(middleOfStreamWindow);
mockEventHook({data: {currentTime: middleOfStreamWindow}, timeUpdate: true});
mockEventHook({data: {currentTime: middleOfStreamWindow}, timeUpdate: true});
expect(callback).toHaveBeenCalledWith({currentTime: middleOfStreamWindow, endOfStream: false});
});
expect(callback).toHaveBeenCalledWith({currentTime: middleOfStreamWindow, endOfStream: false});
});
});
describe('getCurrentTime', function () {
it('should return the current time from the strategy', function () {
initialiseBigscreenPlayer();
describe('getCurrentTime', function () {
it('should return the current time from the strategy', function () {
initialiseBigscreenPlayer();
mockPlayerComponentInstance.getCurrentTime.and.returnValue(10);
mockPlayerComponentInstance.getCurrentTime.and.returnValue(10);
expect(bigscreenPlayer.getCurrentTime()).toBe(10);
});
expect(bigscreenPlayer.getCurrentTime()).toBe(10);
});
it('should return 0 if bigscreenPlayer is not initialised', function () {
expect(bigscreenPlayer.getCurrentTime()).toBe(0);
});
it('should return 0 if bigscreenPlayer is not initialised', function () {
expect(bigscreenPlayer.getCurrentTime()).toBe(0);
});
});
describe('getMediaKind', function () {
it('should return the media kind', function () {
initialiseBigscreenPlayer({mediaKind: 'audio'});
describe('getMediaKind', function () {
it('should return the media kind', function () {
initialiseBigscreenPlayer({mediaKind: 'audio'});
expect(bigscreenPlayer.getMediaKind()).toBe('audio');
});
expect(bigscreenPlayer.getMediaKind()).toBe('audio');
});
});
describe('getWindowType', function () {
it('should return the window type', function () {
initialiseBigscreenPlayer({windowType: WindowTypes.SLIDING});
describe('getWindowType', function () {
it('should return the window type', function () {
initialiseBigscreenPlayer({windowType: WindowTypes.SLIDING});
expect(bigscreenPlayer.getWindowType()).toBe(WindowTypes.SLIDING);
});
expect(bigscreenPlayer.getWindowType()).toBe(WindowTypes.SLIDING);
});
});
describe('getSeekableRange', function () {
it('should return the seekable range from the strategy', function () {
initialiseBigscreenPlayer();
describe('getSeekableRange', function () {
it('should return the seekable range from the strategy', function () {
initialiseBigscreenPlayer();
mockPlayerComponentInstance.getSeekableRange.and.returnValue({start: 0, end: 10});
mockPlayerComponentInstance.getSeekableRange.and.returnValue({start: 0, end: 10});
expect(bigscreenPlayer.getSeekableRange().start).toEqual(0);
expect(bigscreenPlayer.getSeekableRange().end).toEqual(10);
});
expect(bigscreenPlayer.getSeekableRange().start).toEqual(0);
expect(bigscreenPlayer.getSeekableRange().end).toEqual(10);
});
it('should return an empty object when bigscreen player has not been initialised', function () {
expect(bigscreenPlayer.getSeekableRange()).toEqual({});
});
it('should return an empty object when bigscreen player has not been initialised', function () {
expect(bigscreenPlayer.getSeekableRange()).toEqual({});
});
});
describe('isAtLiveEdge', function () {
it('should return false when playing on demand content', function () {
initialiseBigscreenPlayer();
describe('isAtLiveEdge', function () {
it('should return false when playing on demand content', function () {
initialiseBigscreenPlayer();
expect(bigscreenPlayer.isPlayingAtLiveEdge()).toEqual(false);
});
expect(bigscreenPlayer.isPlayingAtLiveEdge()).toEqual(false);
});
it('should return false when bigscreen-player has not been initialised', function () {
expect(bigscreenPlayer.isPlayingAtLiveEdge()).toEqual(false);
});
it('should return false when bigscreen-player has not been initialised', function () {
expect(bigscreenPlayer.isPlayingAtLiveEdge()).toEqual(false);
});
it('should return true when playing live and current time is within tolerance of seekable range end', function () {
initialiseBigscreenPlayer({windowType: WindowTypes.SLIDING});
it('should return true when playing live and current time is within tolerance of seekable range end', function () {
initialiseBigscreenPlayer({windowType: WindowTypes.SLIDING});
mockPlayerComponentInstance.getCurrentTime.and.returnValue(100);
mockPlayerComponentInstance.getSeekableRange.and.returnValue({start: 0, end: 105});
mockPlayerComponentInstance.getCurrentTime.and.returnValue(100);
mockPlayerComponentInstance.getSeekableRange.and.returnValue({start: 0, end: 105});
expect(bigscreenPlayer.isPlayingAtLiveEdge()).toEqual(true);
});
expect(bigscreenPlayer.isPlayingAtLiveEdge()).toEqual(true);
});
it('should return false when playing live and current time is outside the tolerance of seekable range end', function () {
initialiseBigscreenPlayer({windowType: WindowTypes.SLIDING});
it('should return false when playing live and current time is outside the tolerance of seekable range end', function () {
initialiseBigscreenPlayer({windowType: WindowTypes.SLIDING});
mockPlayerComponentInstance.getCurrentTime.and.returnValue(95);
mockPlayerComponentInstance.getSeekableRange.and.returnValue({start: 0, end: 105});
mockPlayerComponentInstance.getCurrentTime.and.returnValue(95);
mockPlayerComponentInstance.getSeekableRange.and.returnValue({start: 0, end: 105});
expect(bigscreenPlayer.isPlayingAtLiveEdge()).toEqual(false);
});
expect(bigscreenPlayer.isPlayingAtLiveEdge()).toEqual(false);
});
});
describe('getLiveWindowData', function () {
it('should return undefined values when windowType is static', function () {
initialiseBigscreenPlayer({windowType: WindowTypes.STATIC});
describe('getLiveWindowData', function () {
it('should return undefined values when windowType is static', function () {
initialiseBigscreenPlayer({windowType: WindowTypes.STATIC});
expect(bigscreenPlayer.getLiveWindowData()).toEqual({});
expect(bigscreenPlayer.getLiveWindowData()).toEqual({});
});
it('should return liveWindowData when the windowType is sliding and manifest is loaded', function () {
setupManifestData({
transferFormat: TransferFormats.DASH,
time: {
windowStartTime: 1,
windowEndTime: 2
}
});
it('should return liveWindowData when the windowType is sliding and manifest is loaded', function () {
setupManifestData({
transferFormat: TransferFormats.DASH,
time: {
windowStartTime: 1,
windowEndTime: 2
}
});
var initialisationData = {windowType: WindowTypes.SLIDING, serverDate: new Date(), initialPlaybackTime: new Date().getTime()};
initialiseBigscreenPlayer(initialisationData);
var initialisationData = {windowType: WindowTypes.SLIDING, serverDate: new Date(), initialPlaybackTime: new Date().getTime()};
initialiseBigscreenPlayer(initialisationData);
expect(bigscreenPlayer.getLiveWindowData()).toEqual({windowStartTime: 1, windowEndTime: 2, serverDate: initialisationData.serverDate, initialPlaybackTime: initialisationData.initialPlaybackTime});
});
expect(bigscreenPlayer.getLiveWindowData()).toEqual({windowStartTime: 1, windowEndTime: 2, serverDate: initialisationData.serverDate, initialPlaybackTime: initialisationData.initialPlaybackTime});
});
it('should return a subset of liveWindowData when the windowType is sliding and time block is provided', function () {
var initialisationData = {windowType: WindowTypes.SLIDING, windowStartTime: 1, windowEndTime: 2, initialPlaybackTime: new Date().getTime()};
initialiseBigscreenPlayer(initialisationData);
it('should return a subset of liveWindowData when the windowType is sliding and time block is provided', function () {
var initialisationData = {windowType: WindowTypes.SLIDING, windowStartTime: 1, windowEndTime: 2, initialPlaybackTime: new Date().getTime()};
initialiseBigscreenPlayer(initialisationData);
expect(bigscreenPlayer.getLiveWindowData()).toEqual({serverDate: undefined, windowStartTime: 1, windowEndTime: 2, initialPlaybackTime: initialisationData.initialPlaybackTime});
});
expect(bigscreenPlayer.getLiveWindowData()).toEqual({serverDate: undefined, windowStartTime: 1, windowEndTime: 2, initialPlaybackTime: initialisationData.initialPlaybackTime});
});
});
describe('getDuration', function () {
it('should get the duration from the strategy', function () {
initialiseBigscreenPlayer();
describe('getDuration', function () {
it('should get the duration from the strategy', function () {
initialiseBigscreenPlayer();
mockPlayerComponentInstance.getDuration.and.returnValue(10);
mockPlayerComponentInstance.getDuration.and.returnValue(10);
expect(bigscreenPlayer.getDuration()).toEqual(10);
});
expect(bigscreenPlayer.getDuration()).toEqual(10);
});
it('should return undefined when not initialised', function () {
expect(bigscreenPlayer.getDuration()).toBeUndefined();
});
it('should return undefined when not initialised', function () {
expect(bigscreenPlayer.getDuration()).toBeUndefined();
});
});
describe('isPaused', function () {
it('should get the paused state from the strategy', function () {
initialiseBigscreenPlayer();
describe('isPaused', function () {
it('should get the paused state from the strategy', function () {
initialiseBigscreenPlayer();
mockPlayerComponentInstance.isPaused.and.returnValue(true);
mockPlayerComponentInstance.isPaused.and.returnValue(true);
expect(bigscreenPlayer.isPaused()).toBe(true);
});
expect(bigscreenPlayer.isPaused()).toBe(true);
});
it('should return true if bigscreenPlayer has not been initialised', function () {
expect(bigscreenPlayer.isPaused()).toBe(true);
});
it('should return true if bigscreenPlayer has not been initialised', function () {
expect(bigscreenPlayer.isPaused()).toBe(true);
});
});
describe('isEnded', function () {
it('should get the ended state from the strategy', function () {
initialiseBigscreenPlayer();
describe('isEnded', function () {
it('should get the ended state from the strategy', function () {
initialiseBigscreenPlayer();
mockPlayerComponentInstance.isEnded.and.returnValue(true);
mockPlayerComponentInstance.isEnded.and.returnValue(true);
expect(bigscreenPlayer.isEnded()).toBe(true);
});
expect(bigscreenPlayer.isEnded()).toBe(true);
});
it('should return false if bigscreenPlayer has not been initialised', function () {
expect(bigscreenPlayer.isEnded()).toBe(false);
});
it('should return false if bigscreenPlayer has not been initialised', function () {
expect(bigscreenPlayer.isEnded()).toBe(false);
});
});
describe('play', function () {
it('should call play on the strategy', function () {
initialiseBigscreenPlayer();
describe('play', function () {
it('should call play on the strategy', function () {
initialiseBigscreenPlayer();
bigscreenPlayer.play();
bigscreenPlayer.play();
expect(mockPlayerComponentInstance.play).toHaveBeenCalledWith();
});
expect(mockPlayerComponentInstance.play).toHaveBeenCalledWith();
});
});
describe('pause', function () {
it('should call pause on the strategy', function () {
var opts = {disableAutoResume: true};
describe('pause', function () {
it('should call pause on the strategy', function () {
var opts = {disableAutoResume: true};
initialiseBigscreenPlayer();
initialiseBigscreenPlayer();
bigscreenPlayer.pause(opts);
bigscreenPlayer.pause(opts);
expect(mockPlayerComponentInstance.pause).toHaveBeenCalledWith(jasmine.objectContaining({disableAutoResume: true}));
});
expect(mockPlayerComponentInstance.pause).toHaveBeenCalledWith(jasmine.objectContaining({disableAutoResume: true}));
});
it('should set pauseTrigger to an app pause if user pause is false', function () {
var opts = {userPause: false};
it('should set pauseTrigger to an app pause if user pause is false', function () {
var opts = {userPause: false};
initialiseBigscreenPlayer();
initialiseBigscreenPlayer();
var callback = jasmine.createSpy();
var callback = jasmine.createSpy();
bigscreenPlayer.registerForStateChanges(callback);
bigscreenPlayer.registerForStateChanges(callback);
bigscreenPlayer.pause(opts);
bigscreenPlayer.pause(opts);
mockEventHook({data: {state: MediaState.PAUSED}});
mockEventHook({data: {state: MediaState.PAUSED}});
expect(callback).toHaveBeenCalledWith(jasmine.objectContaining({trigger: PauseTriggers.APP}));
});
expect(callback).toHaveBeenCalledWith(jasmine.objectContaining({trigger: PauseTriggers.APP}));
});
it('should set pauseTrigger to a user pause if user pause is true', function () {
var opts = {userPause: true};
it('should set pauseTrigger to a user pause if user pause is true', function () {
var opts = {userPause: true};
initialiseBigscreenPlayer();
initialiseBigscreenPlayer();
var callback = jasmine.createSpy();
var callback = jasmine.createSpy();
bigscreenPlayer.registerForStateChanges(callback);
bigscreenPlayer.registerForStateChanges(callback);
bigscreenPlayer.pause(opts);
bigscreenPlayer.pause(opts);
mockEventHook({data: {state: MediaState.PAUSED}});
mockEventHook({data: {state: MediaState.PAUSED}});
expect(callback).toHaveBeenCalledWith(jasmine.objectContaining({trigger: PauseTriggers.USER}));
});
expect(callback).toHaveBeenCalledWith(jasmine.objectContaining({trigger: PauseTriggers.USER}));
});
});
describe('setSubtitlesEnabled', function () {
it('should turn subtitles on/off when a value is passed in and they are available', function () {
initialiseBigscreenPlayer({ subtitlesAvailable: true });
describe('setSubtitlesEnabled', function () {
it('should turn subtitles on/off when a value is passed in and they are available', function () {
initialiseBigscreenPlayer({ subtitlesAvailable: true });
bigscreenPlayer.setSubtitlesEnabled(true);
bigscreenPlayer.setSubtitlesEnabled(true);
expect(mockPlayerComponentInstance.setSubtitlesEnabled).toHaveBeenCalledWith(true);
expect(mockPlayerComponentInstance.setSubtitlesEnabled).toHaveBeenCalledWith(true);
bigscreenPlayer.setSubtitlesEnabled(false);
bigscreenPlayer.setSubtitlesEnabled(false);
expect(mockPlayerComponentInstance.setSubtitlesEnabled).toHaveBeenCalledWith(false);
});
expect(mockPlayerComponentInstance.setSubtitlesEnabled).toHaveBeenCalledWith(false);
});
});
describe('isSubtitlesEnabled', function () {
it('calls through to playerComponent isSubtitlesEnabled when called', function () {
initialiseBigscreenPlayer();
describe('isSubtitlesEnabled', function () {
it('calls through to playerComponent isSubtitlesEnabled when called', function () {
initialiseBigscreenPlayer();
bigscreenPlayer.isSubtitlesEnabled();
bigscreenPlayer.isSubtitlesEnabled();
expect(mockPlayerComponentInstance.isSubtitlesEnabled).toHaveBeenCalledWith();
});
expect(mockPlayerComponentInstance.isSubtitlesEnabled).toHaveBeenCalledWith();
});
});
describe('isSubtitlesAvailable', function () {
it('calls through to playerComponent isSubtitlesAvailable when called', function () {
initialiseBigscreenPlayer();
describe('isSubtitlesAvailable', function () {
it('calls through to playerComponent isSubtitlesAvailable when called', function () {
initialiseBigscreenPlayer();
bigscreenPlayer.isSubtitlesAvailable();
bigscreenPlayer.isSubtitlesAvailable();
expect(mockPlayerComponentInstance.isSubtitlesAvailable).toHaveBeenCalledWith();
});
expect(mockPlayerComponentInstance.isSubtitlesAvailable).toHaveBeenCalledWith();
});
});
describe('canSeek', function () {
it('should return true when in VOD playback', function () {
initialiseBigscreenPlayer();
describe('canSeek', function () {
it('should return true when in VOD playback', function () {
initialiseBigscreenPlayer();
expect(bigscreenPlayer.canSeek()).toBe(true);
});
expect(bigscreenPlayer.canSeek()).toBe(true);
});
describe('live', function () {
it('should return true when it can seek', function () {
mockPlayerComponentInstance.getSeekableRange.and.returnValue({start: 0, end: 60});
describe('live', function () {
it('should return true when it can seek', function () {
mockPlayerComponentInstance.getSeekableRange.and.returnValue({start: 0, end: 60});
initialiseBigscreenPlayer({
windowType: WindowTypes.SLIDING
});
expect(bigscreenPlayer.canSeek()).toBe(true);
initialiseBigscreenPlayer({
windowType: WindowTypes.SLIDING
});
it('should return false when seekable range is infinite', function () {
mockPlayerComponentInstance.getSeekableRange.and.returnValue({start: 0, end: Infinity});
expect(bigscreenPlayer.canSeek()).toBe(true);
});
initialiseBigscreenPlayer({
windowType: WindowTypes.SLIDING
});
it('should return false when seekable range is infinite', function () {
mockPlayerComponentInstance.getSeekableRange.and.returnValue({start: 0, end: Infinity});
expect(bigscreenPlayer.canSeek()).toBe(false);
initialiseBigscreenPlayer({
windowType: WindowTypes.SLIDING
});
it('should return false when window length less than four minutes', function () {
setupManifestData({
transferFormat: 'dash',
time: {
windowStartTime: 0,
windowEndTime: 239999,
correction: 0
}
});
mockPlayerComponentInstance.getSeekableRange.and.returnValue({start: 0, end: 60});
expect(bigscreenPlayer.canSeek()).toBe(false);
});
initialiseBigscreenPlayer({
windowType: WindowTypes.SLIDING
});
expect(bigscreenPlayer.canSeek()).toBe(false);
it('should return false when window length less than four minutes', function () {
setupManifestData({
transferFormat: 'dash',
time: {
windowStartTime: 0,
windowEndTime: 239999,
correction: 0
}
});
mockPlayerComponentInstance.getSeekableRange.and.returnValue({start: 0, end: 60});
it('should return false when device does not support seeking', function () {
mockPlayerComponentInstance.getSeekableRange.and.returnValue({start: 0, end: 60});
liveSupport = LiveSupport.PLAYABLE;
initialiseBigscreenPlayer({
windowType: WindowTypes.SLIDING
});
expect(bigscreenPlayer.canSeek()).toBe(false);
initialiseBigscreenPlayer({
windowType: WindowTypes.SLIDING
});
});
});
describe('canPause', function () {
it('VOD should return true', function () {
initialiseBigscreenPlayer();
expect(bigscreenPlayer.canPause()).toBe(true);
expect(bigscreenPlayer.canSeek()).toBe(false);
});
describe('LIVE', function () {
it('should return true when it can pause', function () {
liveSupport = LiveSupport.RESTARTABLE;
it('should return false when device does not support seeking', function () {
mockPlayerComponentInstance.getSeekableRange.and.returnValue({start: 0, end: 60});
initialiseBigscreenPlayer({
windowType: WindowTypes.SLIDING
});
liveSupport = LiveSupport.PLAYABLE;
expect(bigscreenPlayer.canPause()).toBe(true);
initialiseBigscreenPlayer({
windowType: WindowTypes.SLIDING
});
it('should be false when window length less than four minutes', function () {
setupManifestData({
transferFormat: TransferFormats.DASH,
time: {
windowStartTime: 0,
windowEndTime: 239999,
correction: 0
}
});
liveSupport = LiveSupport.RESTARTABLE;
expect(bigscreenPlayer.canSeek()).toBe(false);
});
});
});
initialiseBigscreenPlayer({
windowType: WindowTypes.SLIDING
});
describe('canPause', function () {
it('VOD should return true', function () {
initialiseBigscreenPlayer();
expect(bigscreenPlayer.canPause()).toBe(false);
});
it('should return false when device does not support pausing', function () {
liveSupport = LiveSupport.PLAYABLE;
initialiseBigscreenPlayer({
windowType: WindowTypes.SLIDING
});
expect(bigscreenPlayer.canPause()).toBe(false);
});
});
expect(bigscreenPlayer.canPause()).toBe(true);
});
describe('convertVideoTimeSecondsToEpochMs', function () {
it('converts video time to epoch time when windowStartTime is supplied', function () {
setupManifestData({
time: {
windowStartTime: 4200,
windowEndTime: 150000000
}
});
describe('LIVE', function () {
it('should return true when it can pause', function () {
liveSupport = LiveSupport.RESTARTABLE;

@@ -913,29 +867,25 @@ initialiseBigscreenPlayer({

expect(bigscreenPlayer.convertVideoTimeSecondsToEpochMs(1000)).toBe(4200 + 1000000);
expect(bigscreenPlayer.canPause()).toBe(true);
});
it('does not convert video time to epoch time when windowStartTime is not supplied', function () {
it('should be false when window length less than four minutes', function () {
setupManifestData({
transferFormat: TransferFormats.DASH,
time: {
windowStartTime: undefined,
windowEndTime: undefined
windowStartTime: 0,
windowEndTime: 239999,
correction: 0
}
});
liveSupport = LiveSupport.RESTARTABLE;
initialiseBigscreenPlayer();
initialiseBigscreenPlayer({
windowType: WindowTypes.SLIDING
});
expect(bigscreenPlayer.convertVideoTimeSecondsToEpochMs(1000)).toBeUndefined();
expect(bigscreenPlayer.canPause()).toBe(false);
});
});
describe('covertEpochMsToVideoTimeSeconds', function () {
it('converts epoch time to video time when windowStartTime is available', function () {
// windowStartTime - 16 January 2019 12:00:00
// windowEndTime - 16 January 2019 14:00:00
setupManifestData({
time: {
windowStartTime: 1547640000000,
windowEndTime: 1547647200000
}
});
it('should return false when device does not support pausing', function () {
liveSupport = LiveSupport.PLAYABLE;

@@ -946,81 +896,131 @@ initialiseBigscreenPlayer({

// Time to convert - 16 January 2019 13:00:00 - one hour (3600 seconds)
expect(bigscreenPlayer.convertEpochMsToVideoTimeSeconds(1547643600000)).toBe(3600);
expect(bigscreenPlayer.canPause()).toBe(false);
});
});
});
it('does not convert epoch time to video time when windowStartTime is not available', function () {
setupManifestData({
time: {
windowStartTime: undefined,
windowEndTime: undefined
}
});
describe('convertVideoTimeSecondsToEpochMs', function () {
it('converts video time to epoch time when windowStartTime is supplied', function () {
setupManifestData({
time: {
windowStartTime: 4200,
windowEndTime: 150000000
}
});
initialiseBigscreenPlayer();
initialiseBigscreenPlayer({
windowType: WindowTypes.SLIDING
});
expect(bigscreenPlayer.convertEpochMsToVideoTimeSeconds(1547643600000)).toBeUndefined();
expect(bigscreenPlayer.convertVideoTimeSecondsToEpochMs(1000)).toBe(4200 + 1000000);
});
it('does not convert video time to epoch time when windowStartTime is not supplied', function () {
setupManifestData({
time: {
windowStartTime: undefined,
windowEndTime: undefined
}
});
initialiseBigscreenPlayer();
expect(bigscreenPlayer.convertVideoTimeSecondsToEpochMs(1000)).toBeUndefined();
});
});
describe('registerPlugin', function () {
beforeEach(function () {
jasmine.clock().install();
describe('covertEpochMsToVideoTimeSeconds', function () {
it('converts epoch time to video time when windowStartTime is available', function () {
// windowStartTime - 16 January 2019 12:00:00
// windowEndTime - 16 January 2019 14:00:00
setupManifestData({
time: {
windowStartTime: 1547640000000,
windowEndTime: 1547647200000
}
});
var callback = jasmine.createSpy(callback);
bigscreenPlayer.registerForStateChanges(callback);
initialiseBigscreenPlayer({
windowType: WindowTypes.SLIDING
});
afterEach(function () {
jasmine.clock().uninstall();
// Time to convert - 16 January 2019 13:00:00 - one hour (3600 seconds)
expect(bigscreenPlayer.convertEpochMsToVideoTimeSeconds(1547643600000)).toBe(3600);
});
it('does not convert epoch time to video time when windowStartTime is not available', function () {
setupManifestData({
time: {
windowStartTime: undefined,
windowEndTime: undefined
}
});
it('should register a specific plugin', function () {
var mockPlugin = jasmine.createSpyObj('plugin', ['onError']);
initialiseBigscreenPlayer();
bigscreenPlayer.registerPlugin(mockPlugin);
initialiseBigscreenPlayer();
Plugins.interface.onError();
expect(bigscreenPlayer.convertEpochMsToVideoTimeSeconds(1547643600000)).toBeUndefined();
});
});
expect(mockPlugin.onError).toHaveBeenCalled();
});
describe('registerPlugin', function () {
beforeEach(function () {
jasmine.clock().install();
var callback = jasmine.createSpy(callback);
bigscreenPlayer.registerForStateChanges(callback);
});
describe('unregister plugin', function () {
var mockPlugin;
var mockPluginTwo;
beforeEach(function () {
jasmine.clock().install();
mockPlugin = jasmine.createSpyObj('plugin', ['onError']);
mockPluginTwo = jasmine.createSpyObj('pluginTwo', ['onError']);
initialiseBigscreenPlayer();
bigscreenPlayer.registerPlugin(mockPlugin);
bigscreenPlayer.registerPlugin(mockPluginTwo);
});
afterEach(function () {
jasmine.clock().uninstall();
});
afterEach(function () {
jasmine.clock().uninstall();
mockPlugin.onError.calls.reset();
mockPluginTwo.onError.calls.reset();
});
it('should register a specific plugin', function () {
var mockPlugin = jasmine.createSpyObj('plugin', ['onError']);
initialiseBigscreenPlayer();
bigscreenPlayer.registerPlugin(mockPlugin);
it('should remove a specific plugin', function () {
bigscreenPlayer.unregisterPlugin(mockPlugin);
Plugins.interface.onError();
Plugins.interface.onError();
expect(mockPlugin.onError).toHaveBeenCalled();
});
});
expect(mockPlugin.onError).not.toHaveBeenCalled();
expect(mockPluginTwo.onError).toHaveBeenCalled();
});
describe('unregister plugin', function () {
var mockPlugin;
var mockPluginTwo;
beforeEach(function () {
jasmine.clock().install();
mockPlugin = jasmine.createSpyObj('plugin', ['onError']);
mockPluginTwo = jasmine.createSpyObj('pluginTwo', ['onError']);
initialiseBigscreenPlayer();
bigscreenPlayer.registerPlugin(mockPlugin);
bigscreenPlayer.registerPlugin(mockPluginTwo);
});
it('should remove all plugins', function () {
bigscreenPlayer.unregisterPlugin();
afterEach(function () {
jasmine.clock().uninstall();
mockPlugin.onError.calls.reset();
mockPluginTwo.onError.calls.reset();
});
Plugins.interface.onError();
it('should remove a specific plugin', function () {
bigscreenPlayer.unregisterPlugin(mockPlugin);
expect(mockPlugin.onError).not.toHaveBeenCalled();
expect(mockPluginTwo.onError).not.toHaveBeenCalled();
});
Plugins.interface.onError();
expect(mockPlugin.onError).not.toHaveBeenCalled();
expect(mockPluginTwo.onError).toHaveBeenCalled();
});
it('should remove all plugins', function () {
bigscreenPlayer.unregisterPlugin();
Plugins.interface.onError();
expect(mockPlugin.onError).not.toHaveBeenCalled();
expect(mockPluginTwo.onError).not.toHaveBeenCalled();
});
});
}
);
});
}
);

394

script-test/debugger/debugpresentertest.js

@@ -6,225 +6,225 @@ require(

],
function (DebugPresenter, MediaState) {
describe('Debug Presenter', function () {
var presenter;
var viewMock;
function (DebugPresenter, MediaState) {
describe('Debug Presenter', function () {
var presenter;
var viewMock;
beforeEach(function () {
viewMock = jasmine.createSpyObj('view', ['render']);
presenter = DebugPresenter;
presenter.init(viewMock);
});
beforeEach(function () {
viewMock = jasmine.createSpyObj('view', ['render']);
presenter = DebugPresenter;
presenter.init(viewMock);
});
it('parses static info from an array of chronicle values', function () {
presenter.update([{type: 'keyvalue', keyvalue: {key: 'bitrate', value: '1000'}, timestamp: 1518018558259}]);
var expectedObject = {
static: [
{
key: 'bitrate',
value: '1000'
}
],
dynamic: [
]
};
it('parses static info from an array of chronicle values', function () {
presenter.update([{type: 'keyvalue', keyvalue: {key: 'bitrate', value: '1000'}, timestamp: 1518018558259}]);
var expectedObject = {
static: [
{
key: 'bitrate',
value: '1000'
}
],
dynamic: [
]
};
expect(viewMock.render).toHaveBeenCalledWith(expectedObject);
});
expect(viewMock.render).toHaveBeenCalledWith(expectedObject);
});
it('converts any static field Date object into human readable time string', function () {
var testDate = new Date(1518018558259);
presenter.update([{type: 'keyvalue', keyvalue: {key: 'anything', value: testDate}, timestamp: 1518018558259}]);
var expectedObject = {
static: [
{
key: 'anything',
value: '15:49:18'
}
],
dynamic: [
]
};
it('converts any static field Date object into human readable time string', function () {
var testDate = new Date(1518018558259);
presenter.update([{type: 'keyvalue', keyvalue: {key: 'anything', value: testDate}, timestamp: 1518018558259}]);
var expectedObject = {
static: [
{
key: 'anything',
value: '15:49:18'
}
],
dynamic: [
]
};
expect(viewMock.render).toHaveBeenCalledWith(expectedObject);
});
expect(viewMock.render).toHaveBeenCalledWith(expectedObject);
});
it('parses dynamic info from an array of chronicle values', function () {
presenter.update([{type: 'info', message: 'A string info message', timestamp: 1518018558259}]);
var expectedObject = {
static: [
],
dynamic: [
'2018-02-07T15:49:18.259Z - Info: A string info message'
]
};
it('parses dynamic info from an array of chronicle values', function () {
presenter.update([{type: 'info', message: 'A string info message', timestamp: 1518018558259}]);
var expectedObject = {
static: [
],
dynamic: [
'2018-02-07T15:49:18.259Z - Info: A string info message'
]
};
expect(viewMock.render).toHaveBeenCalledWith(expectedObject);
});
expect(viewMock.render).toHaveBeenCalledWith(expectedObject);
});
it('parses multiple dynamic events from an array of chronicle values', function () {
presenter.update([
{type: 'info', message: 'A string info message', timestamp: 1518018558259},
{type: 'info', message: 'Another info message', timestamp: 1518018558259}
]);
var expectedObject = {
static: [
],
dynamic: [
'2018-02-07T15:49:18.259Z - Info: A string info message',
'2018-02-07T15:49:18.259Z - Info: Another info message'
]
};
it('parses multiple dynamic events from an array of chronicle values', function () {
presenter.update([
{type: 'info', message: 'A string info message', timestamp: 1518018558259},
{type: 'info', message: 'Another info message', timestamp: 1518018558259}
]);
var expectedObject = {
static: [
],
dynamic: [
'2018-02-07T15:49:18.259Z - Info: A string info message',
'2018-02-07T15:49:18.259Z - Info: Another info message'
]
};
expect(viewMock.render).toHaveBeenCalledWith(expectedObject);
});
expect(viewMock.render).toHaveBeenCalledWith(expectedObject);
});
it('parses error events to simple string representation', function () {
presenter.update([
{type: 'error',
error: {
errorId: '1',
message: 'An error has occurred'
},
timestamp: 1518018558259}
]);
var expectedObject = {
static: [
],
dynamic: [
'2018-02-07T15:49:18.259Z - Error: 1 | An error has occurred'
]
};
it('parses error events to simple string representation', function () {
presenter.update([
{type: 'error',
error: {
errorId: '1',
message: 'An error has occurred'
},
timestamp: 1518018558259}
]);
var expectedObject = {
static: [
],
dynamic: [
'2018-02-07T15:49:18.259Z - Error: 1 | An error has occurred'
]
};
expect(viewMock.render).toHaveBeenCalledWith(expectedObject);
});
expect(viewMock.render).toHaveBeenCalledWith(expectedObject);
});
it('parses events to readable representation', function () {
presenter.update([
{type: 'event', event: {state: MediaState.PLAYING}, timestamp: 1518018558259}
]);
var expectedObject = {
static: [
],
dynamic: [
'2018-02-07T15:49:18.259Z - Event: PLAYING'
]
};
it('parses events to readable representation', function () {
presenter.update([
{type: 'event', event: {state: MediaState.PLAYING}, timestamp: 1518018558259}
]);
var expectedObject = {
static: [
],
dynamic: [
'2018-02-07T15:49:18.259Z - Event: PLAYING'
]
};
expect(viewMock.render).toHaveBeenCalledWith(expectedObject);
});
expect(viewMock.render).toHaveBeenCalledWith(expectedObject);
});
it('parses time to formatted string representation', function () {
presenter.update([
{type: 'time', currentTime: 12.3433, timestamp: 1518018558259}
]);
var expectedObject = {
static: [
],
dynamic: [
'2018-02-07T15:49:18.259Z - Video time: 12.34'
]
};
it('parses time to formatted string representation', function () {
presenter.update([
{type: 'time', currentTime: 12.3433, timestamp: 1518018558259}
]);
var expectedObject = {
static: [
],
dynamic: [
'2018-02-07T15:49:18.259Z - Video time: 12.34'
]
};
expect(viewMock.render).toHaveBeenCalledWith(expectedObject);
});
expect(viewMock.render).toHaveBeenCalledWith(expectedObject);
});
it('parses long time to formatted string representation', function () {
presenter.update([
{type: 'time', currentTime: 788.9999, timestamp: 1518018558259}
]);
var expectedObject = {
static: [
],
dynamic: [
'2018-02-07T15:49:18.259Z - Video time: 789.00'
]
};
it('parses long time to formatted string representation', function () {
presenter.update([
{type: 'time', currentTime: 788.9999, timestamp: 1518018558259}
]);
var expectedObject = {
static: [
],
dynamic: [
'2018-02-07T15:49:18.259Z - Video time: 789.00'
]
};
expect(viewMock.render).toHaveBeenCalledWith(expectedObject);
});
expect(viewMock.render).toHaveBeenCalledWith(expectedObject);
});
it('parses apicall to a formatted string representation', function () {
presenter.update([
{type: 'apicall', calltype: 'Play', timestamp: 1518018558259}
]);
var expectedObject = {
static: [
],
dynamic: [
'2018-02-07T15:49:18.259Z - Api call: Play'
]
};
it('parses apicall to a formatted string representation', function () {
presenter.update([
{type: 'apicall', calltype: 'Play', timestamp: 1518018558259}
]);
var expectedObject = {
static: [
],
dynamic: [
'2018-02-07T15:49:18.259Z - Api call: Play'
]
};
expect(viewMock.render).toHaveBeenCalledWith(expectedObject);
});
expect(viewMock.render).toHaveBeenCalledWith(expectedObject);
});
it('When the log object does not contain a valid type', function () {
presenter.update([
{type: 'blah', someobject: {thing: ''}, timestamp: 1518018558259}
]);
var expectedObject = {
static: [
],
dynamic: [
'2018-02-07T15:49:18.259Z - Unknown log format'
]
};
it('When the log object does not contain a valid type', function () {
presenter.update([
{type: 'blah', someobject: {thing: ''}, timestamp: 1518018558259}
]);
var expectedObject = {
static: [
],
dynamic: [
'2018-02-07T15:49:18.259Z - Unknown log format'
]
};
expect(viewMock.render).toHaveBeenCalledWith(expectedObject);
});
expect(viewMock.render).toHaveBeenCalledWith(expectedObject);
});
it('Only uses the the latest value when updating static fields', function () {
presenter.update([
{type: 'keyvalue', keyvalue: {key: 'bitrate', value: '1000'}, timestamp: 1518018558259},
{type: 'keyvalue', keyvalue: {key: 'bitrate', value: '2000'}, timestamp: 1518018558259}
]);
var expectedObject = {
static: [
{
key: 'bitrate',
value: '2000'
}
],
dynamic: [
]
};
it('Only uses the the latest value when updating static fields', function () {
presenter.update([
{type: 'keyvalue', keyvalue: {key: 'bitrate', value: '1000'}, timestamp: 1518018558259},
{type: 'keyvalue', keyvalue: {key: 'bitrate', value: '2000'}, timestamp: 1518018558259}
]);
var expectedObject = {
static: [
{
key: 'bitrate',
value: '2000'
}
],
dynamic: [
]
};
expect(viewMock.render).toHaveBeenCalledWith(expectedObject);
});
expect(viewMock.render).toHaveBeenCalledWith(expectedObject);
});
it('Only uses the the latest value when updating static fields with multiple fields', function () {
presenter.update([
{type: 'keyvalue', keyvalue: {key: 'bitrate', value: '1000'}, timestamp: 1518018558259},
{type: 'keyvalue', keyvalue: {key: 'duration', value: '12345'}, timestamp: 1518018558259},
{type: 'keyvalue', keyvalue: {key: 'bitrate', value: '2000'}, timestamp: 1518018558259},
{type: 'keyvalue', keyvalue: {key: 'duration', value: '12346'}, timestamp: 1518018558259},
{type: 'keyvalue', keyvalue: {key: 'seekableRangeStart', value: '0'}, timestamp: 1518018558259},
{type: 'keyvalue', keyvalue: {key: 'seekableRangeEnd', value: '12346'}, timestamp: 1518018558259}
]);
var expectedObject = {
static: [
{
key: 'bitrate',
value: '2000'
},
{
key: 'duration',
value: '12346'
},
{
key: 'seekable range start',
value: '0'
},
{
key: 'seekable range end',
value: '12346'
}
],
dynamic: [
]
};
it('Only uses the the latest value when updating static fields with multiple fields', function () {
presenter.update([
{type: 'keyvalue', keyvalue: {key: 'bitrate', value: '1000'}, timestamp: 1518018558259},
{type: 'keyvalue', keyvalue: {key: 'duration', value: '12345'}, timestamp: 1518018558259},
{type: 'keyvalue', keyvalue: {key: 'bitrate', value: '2000'}, timestamp: 1518018558259},
{type: 'keyvalue', keyvalue: {key: 'duration', value: '12346'}, timestamp: 1518018558259},
{type: 'keyvalue', keyvalue: {key: 'seekableRangeStart', value: '0'}, timestamp: 1518018558259},
{type: 'keyvalue', keyvalue: {key: 'seekableRangeEnd', value: '12346'}, timestamp: 1518018558259}
]);
var expectedObject = {
static: [
{
key: 'bitrate',
value: '2000'
},
{
key: 'duration',
value: '12346'
},
{
key: 'seekable range start',
value: '0'
},
{
key: 'seekable range end',
value: '12346'
}
],
dynamic: [
]
};
expect(viewMock.render).toHaveBeenCalledWith(expectedObject);
});
expect(viewMock.render).toHaveBeenCalledWith(expectedObject);
});
});
});

80

script-test/debugger/debugtooltest.js

@@ -6,55 +6,55 @@ require(

],
function (Chronicle, DebugTool) {
describe('Debug Tool, when intercepting keyValue calls,', function () {
beforeEach(function () {
Chronicle.init();
spyOn(window, 'Date').and.callFake(function () {
return {getTime: function () { return 1234; }};
});
function (Chronicle, DebugTool) {
describe('Debug Tool, when intercepting keyValue calls,', function () {
beforeEach(function () {
Chronicle.init();
spyOn(window, 'Date').and.callFake(function () {
return {getTime: function () { return 1234; }};
});
});
afterEach(function () {
DebugTool.tearDown();
Chronicle.tearDown();
});
afterEach(function () {
DebugTool.tearDown();
Chronicle.tearDown();
});
it('should always add entry to chronicle if the key does not match one of the defined static keys', function () {
var testObj1 = {key: 'bitrate', value: '1000'};
var testObj2 = {key: 'imNotSpecial', value: 'nobodylovesme'};
var testObj3 = {key: 'idontmatch', value: 'pleaseaddme'};
it('should always add entry to chronicle if the key does not match one of the defined static keys', function () {
var testObj1 = {key: 'bitrate', value: '1000'};
var testObj2 = {key: 'imNotSpecial', value: 'nobodylovesme'};
var testObj3 = {key: 'idontmatch', value: 'pleaseaddme'};
var expectedArray = [
{type: 'keyvalue', keyvalue: testObj1, timestamp: 1234},
{type: 'keyvalue', keyvalue: testObj2, timestamp: 1234},
{type: 'keyvalue', keyvalue: testObj3, timestamp: 1234}
];
var expectedArray = [
{type: 'keyvalue', keyvalue: testObj1, timestamp: 1234},
{type: 'keyvalue', keyvalue: testObj2, timestamp: 1234},
{type: 'keyvalue', keyvalue: testObj3, timestamp: 1234}
];
DebugTool.keyValue(testObj1);
DebugTool.keyValue(testObj2);
DebugTool.keyValue(testObj3);
DebugTool.keyValue(testObj1);
DebugTool.keyValue(testObj2);
DebugTool.keyValue(testObj3);
var chronicle = Chronicle.retrieve();
var chronicle = Chronicle.retrieve();
expect(chronicle).toEqual(expectedArray);
});
expect(chronicle).toEqual(expectedArray);
});
it('overwrites a keyvalue entry to the chronicle if that keyvalue already exists', function () {
var testObj = {key: 'akey', value: 'something'};
var testObj1 = {key: 'bitrate', value: '1000'};
var testObj2 = {key: 'bitrate', value: '1001'};
it('overwrites a keyvalue entry to the chronicle if that keyvalue already exists', function () {
var testObj = {key: 'akey', value: 'something'};
var testObj1 = {key: 'bitrate', value: '1000'};
var testObj2 = {key: 'bitrate', value: '1001'};
var expectedArray = [
{type: 'keyvalue', keyvalue: {key: 'akey', value: 'something'}, timestamp: 1234},
{type: 'keyvalue', keyvalue: {key: 'bitrate', value: '1001'}, timestamp: 1234}
];
var expectedArray = [
{type: 'keyvalue', keyvalue: {key: 'akey', value: 'something'}, timestamp: 1234},
{type: 'keyvalue', keyvalue: {key: 'bitrate', value: '1001'}, timestamp: 1234}
];
DebugTool.keyValue(testObj);
DebugTool.keyValue(testObj1);
DebugTool.keyValue(testObj2);
DebugTool.keyValue(testObj);
DebugTool.keyValue(testObj1);
DebugTool.keyValue(testObj2);
var chronicle = Chronicle.retrieve();
var chronicle = Chronicle.retrieve();
expect(chronicle).toEqual(expectedArray);
});
expect(chronicle).toEqual(expectedArray);
});
});
});

164

script-test/dynamicwindowutilstest.js

@@ -5,118 +5,118 @@ require(

],
function (DynamicWindowUtils) {
describe('shouldAutoResume', function () {
it('returns true if we are at the beginning of the playback range', function () {
var isAtStart = DynamicWindowUtils.shouldAutoResume(10, 10);
function (DynamicWindowUtils) {
describe('shouldAutoResume', function () {
it('returns true if we are at the beginning of the playback range', function () {
var isAtStart = DynamicWindowUtils.shouldAutoResume(10, 10);
expect(isAtStart).toBeTrue();
});
expect(isAtStart).toBeTrue();
});
it('returns true if we are at the beginning of the playback range within a threshhold', function () {
var isAtStart = DynamicWindowUtils.shouldAutoResume(15, 10);
it('returns true if we are at the beginning of the playback range within a threshhold', function () {
var isAtStart = DynamicWindowUtils.shouldAutoResume(15, 10);
expect(isAtStart).toBeTrue();
});
expect(isAtStart).toBeTrue();
});
it('returns true if we are at the beginning of the playback range at the threshhold', function () {
var isAtStart = DynamicWindowUtils.shouldAutoResume(18, 10);
it('returns true if we are at the beginning of the playback range at the threshhold', function () {
var isAtStart = DynamicWindowUtils.shouldAutoResume(18, 10);
expect(isAtStart).toBeTrue();
});
expect(isAtStart).toBeTrue();
});
it('returns false if we are after the beginning and the threshhold', function () {
var isAtStart = DynamicWindowUtils.shouldAutoResume(20, 10);
it('returns false if we are after the beginning and the threshhold', function () {
var isAtStart = DynamicWindowUtils.shouldAutoResume(20, 10);
expect(isAtStart).toBeFalse();
});
expect(isAtStart).toBeFalse();
});
});
describe('autoResumeAtStartOfRange', function () {
var resume;
var addEventCallback;
var removeEventCallback;
var checkNotPauseEvent;
var currentTime = 20;
var seekableRange = {
start: 0
};
describe('autoResumeAtStartOfRange', function () {
var resume;
var addEventCallback;
var removeEventCallback;
var checkNotPauseEvent;
var currentTime = 20;
var seekableRange = {
start: 0
};
beforeEach(function () {
jasmine.clock().install();
resume = jasmine.createSpy('resume');
addEventCallback = jasmine.createSpy('addEventCallback');
removeEventCallback = jasmine.createSpy('removeEventCallback');
checkNotPauseEvent = jasmine.createSpy('checkNotPauseEvent');
});
beforeEach(function () {
jasmine.clock().install();
resume = jasmine.createSpy('resume');
addEventCallback = jasmine.createSpy('addEventCallback');
removeEventCallback = jasmine.createSpy('removeEventCallback');
checkNotPauseEvent = jasmine.createSpy('checkNotPauseEvent');
});
afterEach(function () {
jasmine.clock().uninstall();
});
afterEach(function () {
jasmine.clock().uninstall();
});
it('resumes play when the current time is equal to the start of the seekable range', function () {
DynamicWindowUtils.autoResumeAtStartOfRange(currentTime, seekableRange, addEventCallback, removeEventCallback, undefined, resume);
it('resumes play when the current time is equal to the start of the seekable range', function () {
DynamicWindowUtils.autoResumeAtStartOfRange(currentTime, seekableRange, addEventCallback, removeEventCallback, undefined, resume);
jasmine.clock().tick(20000);
jasmine.clock().tick(20000);
expect(addEventCallback).toHaveBeenCalledTimes(1);
expect(removeEventCallback).toHaveBeenCalledTimes(1);
expect(resume).toHaveBeenCalledTimes(1);
});
expect(addEventCallback).toHaveBeenCalledTimes(1);
expect(removeEventCallback).toHaveBeenCalledTimes(1);
expect(resume).toHaveBeenCalledTimes(1);
});
it('resumes play when the current time at the start of the seekable range within a threshold', function () {
DynamicWindowUtils.autoResumeAtStartOfRange(currentTime, seekableRange, addEventCallback, removeEventCallback, undefined, resume);
it('resumes play when the current time at the start of the seekable range within a threshold', function () {
DynamicWindowUtils.autoResumeAtStartOfRange(currentTime, seekableRange, addEventCallback, removeEventCallback, undefined, resume);
jasmine.clock().tick(15000);
jasmine.clock().tick(15000);
expect(addEventCallback).toHaveBeenCalledTimes(1);
expect(removeEventCallback).toHaveBeenCalledTimes(1);
expect(resume).toHaveBeenCalledTimes(1);
});
expect(addEventCallback).toHaveBeenCalledTimes(1);
expect(removeEventCallback).toHaveBeenCalledTimes(1);
expect(resume).toHaveBeenCalledTimes(1);
});
it('resumes play when the current time at the start of the seekable range at the threshold', function () {
DynamicWindowUtils.autoResumeAtStartOfRange(currentTime, seekableRange, addEventCallback, removeEventCallback, undefined, resume);
it('resumes play when the current time at the start of the seekable range at the threshold', function () {
DynamicWindowUtils.autoResumeAtStartOfRange(currentTime, seekableRange, addEventCallback, removeEventCallback, undefined, resume);
jasmine.clock().tick(12000);
jasmine.clock().tick(12000);
expect(addEventCallback).toHaveBeenCalledTimes(1);
expect(removeEventCallback).toHaveBeenCalledTimes(1);
expect(resume).toHaveBeenCalledTimes(1);
});
expect(addEventCallback).toHaveBeenCalledTimes(1);
expect(removeEventCallback).toHaveBeenCalledTimes(1);
expect(resume).toHaveBeenCalledTimes(1);
});
it('does not resume play when the current time is past the start of the seekable range plus the threshold', function () {
DynamicWindowUtils.autoResumeAtStartOfRange(currentTime, seekableRange, addEventCallback, removeEventCallback, undefined, resume);
it('does not resume play when the current time is past the start of the seekable range plus the threshold', function () {
DynamicWindowUtils.autoResumeAtStartOfRange(currentTime, seekableRange, addEventCallback, removeEventCallback, undefined, resume);
jasmine.clock().tick(10000);
jasmine.clock().tick(10000);
expect(addEventCallback).toHaveBeenCalledTimes(1);
expect(removeEventCallback).toHaveBeenCalledTimes(0);
expect(resume).toHaveBeenCalledTimes(0);
});
expect(addEventCallback).toHaveBeenCalledTimes(1);
expect(removeEventCallback).toHaveBeenCalledTimes(0);
expect(resume).toHaveBeenCalledTimes(0);
});
it('non pause event stops autoresume', function () {
checkNotPauseEvent.and.returnValue(true);
it('non pause event stops autoresume', function () {
checkNotPauseEvent.and.returnValue(true);
addEventCallback.and.callFake(function (context, callback) { callback(); });
addEventCallback.and.callFake(function (context, callback) { callback(); });
DynamicWindowUtils.autoResumeAtStartOfRange(currentTime, seekableRange, addEventCallback, removeEventCallback, checkNotPauseEvent, resume);
DynamicWindowUtils.autoResumeAtStartOfRange(currentTime, seekableRange, addEventCallback, removeEventCallback, checkNotPauseEvent, resume);
jasmine.clock().tick(20000);
jasmine.clock().tick(20000);
expect(removeEventCallback).toHaveBeenCalledTimes(1);
expect(resume).toHaveBeenCalledTimes(0);
});
expect(removeEventCallback).toHaveBeenCalledTimes(1);
expect(resume).toHaveBeenCalledTimes(0);
});
it('pause event does not stop autoresume', function () {
checkNotPauseEvent.and.returnValue(false);
it('pause event does not stop autoresume', function () {
checkNotPauseEvent.and.returnValue(false);
addEventCallback.and.callFake(function (context, callback) { callback(); });
addEventCallback.and.callFake(function (context, callback) { callback(); });
DynamicWindowUtils.autoResumeAtStartOfRange(currentTime, seekableRange, addEventCallback, removeEventCallback, checkNotPauseEvent, resume);
DynamicWindowUtils.autoResumeAtStartOfRange(currentTime, seekableRange, addEventCallback, removeEventCallback, checkNotPauseEvent, resume);
jasmine.clock().tick(20000);
jasmine.clock().tick(20000);
expect(removeEventCallback).toHaveBeenCalledTimes(1);
expect(resume).toHaveBeenCalledTimes(1);
});
expect(removeEventCallback).toHaveBeenCalledTimes(1);
expect(resume).toHaveBeenCalledTimes(1);
});
}
});
}
);

70

script-test/playbackstrategies/growingwindowrefreshertest.js

@@ -5,49 +5,49 @@ require(

],
function (GrowingWindowRefresher) {
describe('GrowingWindowRefresher', function () {
var mediaPlayerSpy;
var eventHandlers;
var dashEventCallback;
var seekCallbacksSpy;
function (GrowingWindowRefresher) {
describe('GrowingWindowRefresher', function () {
var mediaPlayerSpy;
var eventHandlers;
var dashEventCallback;
var seekCallbacksSpy;
var dashjsMediaPlayerEvents = {
ERROR: 'error',
MANIFEST_LOADED: 'manifestLoaded'
};
var dashjsMediaPlayerEvents = {
ERROR: 'error',
MANIFEST_LOADED: 'manifestLoaded'
};
beforeEach(function () {
eventHandlers = {};
mediaPlayerSpy = jasmine.createSpyObj('mediaPlayer', ['refreshManifest', 'on', 'off']);
mediaPlayerSpy.on.and.callFake(function (eventType, handler) {
eventHandlers[eventType] = handler;
});
beforeEach(function () {
eventHandlers = {};
mediaPlayerSpy = jasmine.createSpyObj('mediaPlayer', ['refreshManifest', 'on', 'off']);
mediaPlayerSpy.on.and.callFake(function (eventType, handler) {
eventHandlers[eventType] = handler;
});
dashEventCallback = function (eventType, event) {
eventHandlers[eventType](event);
};
dashEventCallback = function (eventType, event) {
eventHandlers[eventType](event);
};
seekCallbacksSpy = jasmine.createSpy('seekCallbacksSpy');
});
seekCallbacksSpy = jasmine.createSpy('seekCallbacksSpy');
});
it('should instruct the media player to refresh the manifest', function () {
GrowingWindowRefresher(mediaPlayerSpy, seekCallbacksSpy);
it('should instruct the media player to refresh the manifest', function () {
GrowingWindowRefresher(mediaPlayerSpy, seekCallbacksSpy);
expect(mediaPlayerSpy.refreshManifest).toHaveBeenCalledTimes(1);
});
expect(mediaPlayerSpy.refreshManifest).toHaveBeenCalledTimes(1);
});
it('calls the given callback on media player MANIFEST_LOADED event', function () {
GrowingWindowRefresher(mediaPlayerSpy, seekCallbacksSpy);
dashEventCallback(dashjsMediaPlayerEvents.MANIFEST_LOADED, {data: {mediaPresentationDuration: 100}});
it('calls the given callback on media player MANIFEST_LOADED event', function () {
GrowingWindowRefresher(mediaPlayerSpy, seekCallbacksSpy);
dashEventCallback(dashjsMediaPlayerEvents.MANIFEST_LOADED, {data: {mediaPresentationDuration: 100}});
expect(seekCallbacksSpy).toHaveBeenCalled();
});
expect(seekCallbacksSpy).toHaveBeenCalled();
});
it('removes MANIFEST_LOADED listener following manifest load event', function () {
GrowingWindowRefresher(mediaPlayerSpy, seekCallbacksSpy);
dashEventCallback(dashjsMediaPlayerEvents.MANIFEST_LOADED, {data: {mediaPresentationDuration: 100}});
it('removes MANIFEST_LOADED listener following manifest load event', function () {
GrowingWindowRefresher(mediaPlayerSpy, seekCallbacksSpy);
dashEventCallback(dashjsMediaPlayerEvents.MANIFEST_LOADED, {data: {mediaPresentationDuration: 100}});
expect(mediaPlayerSpy.off).toHaveBeenCalledWith('manifestLoaded', eventHandlers.manifestLoaded);
});
expect(mediaPlayerSpy.off).toHaveBeenCalledWith('manifestLoaded', eventHandlers.manifestLoaded);
});
});
});

26

script-test/playbackstrategies/legacyplayeradaptortest.js

@@ -11,21 +11,21 @@ require(

var MediaPlayerEvent = {
STOPPED: 'stopped', // Event fired when playback is stopped
STOPPED: 'stopped', // Event fired when playback is stopped
BUFFERING: 'buffering', // Event fired when playback has to suspend due to buffering
PLAYING: 'playing', // Event fired when starting (or resuming) playing of the media
PAUSED: 'paused', // Event fired when media playback pauses
COMPLETE: 'complete', // Event fired when media playback has reached the end of the media
ERROR: 'error', // Event fired when an error condition occurs
STATUS: 'status', // Event fired regularly during play
PLAYING: 'playing', // Event fired when starting (or resuming) playing of the media
PAUSED: 'paused', // Event fired when media playback pauses
COMPLETE: 'complete', // Event fired when media playback has reached the end of the media
ERROR: 'error', // Event fired when an error condition occurs
STATUS: 'status', // Event fired regularly during play
SEEK_ATTEMPTED: 'seek-attempted', // Event fired when a device using a seekfinishedemitevent modifier sets the source
SEEK_FINISHED: 'seek-finished' // Event fired when a device using a seekfinishedemitevent modifier has seeked successfully
SEEK_FINISHED: 'seek-finished' // Event fired when a device using a seekfinishedemitevent modifier has seeked successfully
};
var MediaPlayerState = {
EMPTY: 'EMPTY', // No source set
STOPPED: 'STOPPED', // Source set but no playback
EMPTY: 'EMPTY', // No source set
STOPPED: 'STOPPED', // Source set but no playback
BUFFERING: 'BUFFERING', // Not enough data to play, waiting to download more
PLAYING: 'PLAYING', // Media is playing
PAUSED: 'PAUSED', // Media is paused
COMPLETE: 'COMPLETE', // Media has reached its end point
ERROR: 'ERROR' // An error occurred
PLAYING: 'PLAYING', // Media is playing
PAUSED: 'PAUSED', // Media is paused
COMPLETE: 'COMPLETE', // Media has reached its end point
ERROR: 'ERROR' // An error occurred
};

@@ -32,0 +32,0 @@

540

script-test/playbackstrategies/modifiers/cehtmltests.js

@@ -6,387 +6,387 @@ require(

],
function (CehtmlMediaPlayer, MediaPlayerBase) {
describe('cehtml Base', function () {
var player;
var mockMediaElement;
var sourceContainer;
function (CehtmlMediaPlayer, MediaPlayerBase) {
describe('cehtml Base', function () {
var player;
var mockMediaElement;
var sourceContainer;
var recentEvents;
var recentEvents;
function eventCallbackReporter (event) {
recentEvents.push(event.type);
}
function eventCallbackReporter (event) {
recentEvents.push(event.type);
}
var config = {
streaming: {
overrides: {
forceBeginPlaybackToEndOfWindow: true
}
var config = {
streaming: {
overrides: {
forceBeginPlaybackToEndOfWindow: true
}
};
}
};
beforeEach(function () {
jasmine.clock().install();
jasmine.clock().mockDate();
beforeEach(function () {
jasmine.clock().install();
jasmine.clock().mockDate();
mockMediaElement = jasmine.createSpyObj('mediaElement', ['play', 'seek', 'remove', 'stop']);
mockMediaElement.style = {};
spyOn(document, 'createElement').and.returnValue(mockMediaElement);
spyOn(document, 'getElementsByTagName').and.returnValue([jasmine.createSpyObj('body', ['insertBefore'])]);
mockMediaElement = jasmine.createSpyObj('mediaElement', ['play', 'seek', 'remove', 'stop']);
mockMediaElement.style = {};
spyOn(document, 'createElement').and.returnValue(mockMediaElement);
spyOn(document, 'getElementsByTagName').and.returnValue([jasmine.createSpyObj('body', ['insertBefore'])]);
sourceContainer = document.createElement('div');
sourceContainer = document.createElement('div');
recentEvents = [];
recentEvents = [];
player = CehtmlMediaPlayer(config);
player.addEventCallback(this, eventCallbackReporter);
player.initialiseMedia(MediaPlayerBase.TYPE.VIDEO, 'testUrl', 'testMimeType', sourceContainer, {});
});
player = CehtmlMediaPlayer(config);
player.addEventCallback(this, eventCallbackReporter);
player.initialiseMedia(MediaPlayerBase.TYPE.VIDEO, 'testUrl', 'testMimeType', sourceContainer, {});
});
afterEach(function () {
jasmine.clock().uninstall();
afterEach(function () {
jasmine.clock().uninstall();
});
describe('Seek attempted and finished events', function () {
it('Seek Attempted Event Emitted On Initialise Media If The State Is Empty', function () {
expect(recentEvents).toContain(MediaPlayerBase.EVENT.SEEK_ATTEMPTED);
});
describe('Seek attempted and finished events', function () {
it('Seek Attempted Event Emitted On Initialise Media If The State Is Empty', function () {
expect(recentEvents).toContain(MediaPlayerBase.EVENT.SEEK_ATTEMPTED);
});
it('Seek Finished Event Emitted On Status Update When Time is Within Sentinel Threshold And The State is Playing', function () {
expect(recentEvents).toContain(MediaPlayerBase.EVENT.SEEK_ATTEMPTED);
it('Seek Finished Event Emitted On Status Update When Time is Within Sentinel Threshold And The State is Playing', function () {
expect(recentEvents).toContain(MediaPlayerBase.EVENT.SEEK_ATTEMPTED);
player.beginPlaybackFrom(0);
player.beginPlaybackFrom(0);
mockMediaElement.playState = 4; // BUFFERING
mockMediaElement.onPlayStateChange();
mockMediaElement.playState = 4; // BUFFERING
mockMediaElement.onPlayStateChange();
mockMediaElement.playState = 1; // PLAYING
mockMediaElement.onPlayStateChange();
mockMediaElement.playState = 1; // PLAYING
mockMediaElement.onPlayStateChange();
mockMediaElement.playPosition = 0;
for (var i = 0; i < 6; i++) {
mockMediaElement.playPosition += 500;
jasmine.clock().tick(500);
}
mockMediaElement.playPosition = 0;
for (var i = 0; i < 6; i++) {
mockMediaElement.playPosition += 500;
jasmine.clock().tick(500);
}
expect(recentEvents).toContain(MediaPlayerBase.EVENT.SEEK_FINISHED);
});
expect(recentEvents).toContain(MediaPlayerBase.EVENT.SEEK_FINISHED);
});
it('Seek Finished Event Is Emitted Only Once', function () {
player.beginPlaybackFrom(0);
it('Seek Finished Event Is Emitted Only Once', function () {
player.beginPlaybackFrom(0);
mockMediaElement.playState = 4; // BUFFERING
mockMediaElement.onPlayStateChange();
mockMediaElement.playState = 4; // BUFFERING
mockMediaElement.onPlayStateChange();
mockMediaElement.playState = 1; // PLAYING
mockMediaElement.onPlayStateChange();
mockMediaElement.playState = 1; // PLAYING
mockMediaElement.onPlayStateChange();
mockMediaElement.playPosition = 0;
for (var i = 0; i < 6; i++) {
mockMediaElement.playPosition += 500;
jasmine.clock().tick(500);
}
mockMediaElement.playPosition = 0;
for (var i = 0; i < 6; i++) {
mockMediaElement.playPosition += 500;
jasmine.clock().tick(500);
}
expect(recentEvents).toContain(MediaPlayerBase.EVENT.SEEK_FINISHED);
expect(recentEvents).toContain(MediaPlayerBase.EVENT.SEEK_FINISHED);
recentEvents = [];
mockMediaElement.playPosition += 500;
jasmine.clock().tick(500);
recentEvents = [];
mockMediaElement.playPosition += 500;
jasmine.clock().tick(500);
expect(recentEvents).not.toContain(MediaPlayerBase.EVENT.SEEK_FINISHED);
});
expect(recentEvents).not.toContain(MediaPlayerBase.EVENT.SEEK_FINISHED);
});
it('Seek Finished Event Is Emitted After restartTimeout When Enabled', function () {
var restartTimeoutConfig = {
streaming: {
overrides: {
forceBeginPlaybackToEndOfWindow: true
}
},
restartTimeout: 10000
};
it('Seek Finished Event Is Emitted After restartTimeout When Enabled', function () {
var restartTimeoutConfig = {
streaming: {
overrides: {
forceBeginPlaybackToEndOfWindow: true
}
},
restartTimeout: 10000
};
player = CehtmlMediaPlayer(restartTimeoutConfig);
player.addEventCallback(this, eventCallbackReporter);
player.initialiseMedia(MediaPlayerBase.TYPE.VIDEO, 'testUrl', 'testMimeType', sourceContainer, {});
player = CehtmlMediaPlayer(restartTimeoutConfig);
player.addEventCallback(this, eventCallbackReporter);
player.initialiseMedia(MediaPlayerBase.TYPE.VIDEO, 'testUrl', 'testMimeType', sourceContainer, {});
expect(recentEvents).toContain(MediaPlayerBase.EVENT.SEEK_ATTEMPTED);
expect(recentEvents).toContain(MediaPlayerBase.EVENT.SEEK_ATTEMPTED);
player.beginPlaybackFrom(0);
player.beginPlaybackFrom(0);
mockMediaElement.playState = 4; // BUFFERING
mockMediaElement.onPlayStateChange();
mockMediaElement.playState = 4; // BUFFERING
mockMediaElement.onPlayStateChange();
mockMediaElement.playState = 1; // PLAYING
mockMediaElement.onPlayStateChange();
mockMediaElement.playState = 1; // PLAYING
mockMediaElement.onPlayStateChange();
mockMediaElement.playPosition = 0;
var numberOfLoops = 10000 / 500;
for (var i = 0; i < numberOfLoops - 1; i++) {
mockMediaElement.playPosition += 500;
jasmine.clock().tick(500);
mockMediaElement.playPosition = 0;
var numberOfLoops = 10000 / 500;
for (var i = 0; i < numberOfLoops - 1; i++) {
mockMediaElement.playPosition += 500;
jasmine.clock().tick(500);
expect(recentEvents).not.toContain(MediaPlayerBase.EVENT.SEEK_FINISHED);
}
expect(recentEvents).not.toContain(MediaPlayerBase.EVENT.SEEK_FINISHED);
}
mockMediaElement.playPosition += 1000;
jasmine.clock().tick(1000);
mockMediaElement.playPosition += 1000;
jasmine.clock().tick(1000);
expect(recentEvents).toContain(MediaPlayerBase.EVENT.SEEK_FINISHED);
});
expect(recentEvents).toContain(MediaPlayerBase.EVENT.SEEK_FINISHED);
});
});
describe('addEventCallback', function () {
it('should call the callback on update', function () {
var spy = jasmine.createSpy('callback');
describe('addEventCallback', function () {
it('should call the callback on update', function () {
var spy = jasmine.createSpy('callback');
player.addEventCallback(this, spy);
player.beginPlayback();
player.addEventCallback(this, spy);
player.beginPlayback();
expect(spy).toHaveBeenCalledWith(jasmine.objectContaining({ type: 'buffering' }));
});
expect(spy).toHaveBeenCalledWith(jasmine.objectContaining({ type: 'buffering' }));
});
});
describe('removeEventCallback', function () {
it('should remove the callback', function () {
var spy = jasmine.createSpy('callback');
describe('removeEventCallback', function () {
it('should remove the callback', function () {
var spy = jasmine.createSpy('callback');
player.addEventCallback(this, spy);
player.removeEventCallback(this, spy);
player.beginPlayback();
player.addEventCallback(this, spy);
player.removeEventCallback(this, spy);
player.beginPlayback();
expect(spy).not.toHaveBeenCalled();
});
expect(spy).not.toHaveBeenCalled();
});
});
describe('removeAllEventCallbacks', function () {
it('should remove all the callbacks', function () {
var spy = jasmine.createSpy('callback');
describe('removeAllEventCallbacks', function () {
it('should remove all the callbacks', function () {
var spy = jasmine.createSpy('callback');
player.addEventCallback(this, spy);
player.removeAllEventCallbacks();
player.beginPlayback();
player.addEventCallback(this, spy);
player.removeAllEventCallbacks();
player.beginPlayback();
expect(spy).not.toHaveBeenCalled();
});
expect(spy).not.toHaveBeenCalled();
});
});
describe('resume', function () {
it('should call through to play if paused', function () {
player.beginPlayback();
mockMediaElement.playState = 1;
mockMediaElement.onPlayStateChange();
player.pause();
describe('resume', function () {
it('should call through to play if paused', function () {
player.beginPlayback();
mockMediaElement.playState = 1;
mockMediaElement.onPlayStateChange();
player.pause();
mockMediaElement.play.calls.reset();
mockMediaElement.play.calls.reset();
expect(mockMediaElement.play).not.toHaveBeenCalled();
expect(mockMediaElement.play).not.toHaveBeenCalled();
player.resume();
player.resume();
expect(mockMediaElement.play).toHaveBeenCalledWith(1);
});
expect(mockMediaElement.play).toHaveBeenCalledWith(1);
});
it('should do nothing if playing', function () {
player.beginPlayback();
mockMediaElement.playState = 1;
mockMediaElement.onPlayStateChange();
it('should do nothing if playing', function () {
player.beginPlayback();
mockMediaElement.playState = 1;
mockMediaElement.onPlayStateChange();
mockMediaElement.play.calls.reset();
mockMediaElement.play.calls.reset();
player.resume();
player.resume();
expect(mockMediaElement.play).not.toHaveBeenCalled();
});
expect(mockMediaElement.play).not.toHaveBeenCalled();
});
});
describe('playFrom', function () {
it('should seek to the required time', function () {
player.beginPlayback();
mockMediaElement.playState = 1;
mockMediaElement.onPlayStateChange();
describe('playFrom', function () {
it('should seek to the required time', function () {
player.beginPlayback();
mockMediaElement.playState = 1;
mockMediaElement.onPlayStateChange();
player.playFrom(10);
player.playFrom(10);
expect(mockMediaElement.seek).toHaveBeenCalledWith(10000);
});
expect(mockMediaElement.seek).toHaveBeenCalledWith(10000);
});
it('should clamp to within the seekable range', function () {
player.beginPlayback();
mockMediaElement.playState = 1;
mockMediaElement.playTime = 10000;
mockMediaElement.onPlayStateChange();
it('should clamp to within the seekable range', function () {
player.beginPlayback();
mockMediaElement.playState = 1;
mockMediaElement.playTime = 10000;
mockMediaElement.onPlayStateChange();
player.playFrom(1000000000);
player.playFrom(1000000000);
expect(mockMediaElement.seek).toHaveBeenCalledWith(8900);
});
expect(mockMediaElement.seek).toHaveBeenCalledWith(8900);
});
});
describe('beginPlayback', function () {
it('should call play on the media element', function () {
player.beginPlayback();
describe('beginPlayback', function () {
it('should call play on the media element', function () {
player.beginPlayback();
expect(mockMediaElement.play).toHaveBeenCalledWith(1);
});
expect(mockMediaElement.play).toHaveBeenCalledWith(1);
});
it('should not call play if playing', function () {
player.beginPlayback();
it('should not call play if playing', function () {
player.beginPlayback();
mockMediaElement.play.calls.reset();
mockMediaElement.play.calls.reset();
player.beginPlayback();
player.beginPlayback();
expect(mockMediaElement.play).not.toHaveBeenCalled();
});
expect(mockMediaElement.play).not.toHaveBeenCalled();
});
});
describe('beginPlaybackFrom', function () {
it('should call play and then seek on the media element', function () {
player.beginPlaybackFrom(10);
mockMediaElement.playState = 1;
mockMediaElement.onPlayStateChange();
describe('beginPlaybackFrom', function () {
it('should call play and then seek on the media element', function () {
player.beginPlaybackFrom(10);
mockMediaElement.playState = 1;
mockMediaElement.onPlayStateChange();
expect(mockMediaElement.play).toHaveBeenCalledWith(1);
expect(mockMediaElement.seek).toHaveBeenCalledWith(10000);
});
expect(mockMediaElement.play).toHaveBeenCalledWith(1);
expect(mockMediaElement.seek).toHaveBeenCalledWith(10000);
});
it('should call play or seek if playing', function () {
player.beginPlaybackFrom(10);
mockMediaElement.playState = 1;
mockMediaElement.onPlayStateChange();
it('should call play or seek if playing', function () {
player.beginPlaybackFrom(10);
mockMediaElement.playState = 1;
mockMediaElement.onPlayStateChange();
mockMediaElement.play.calls.reset();
mockMediaElement.seek.calls.reset();
mockMediaElement.play.calls.reset();
mockMediaElement.seek.calls.reset();
player.beginPlaybackFrom(10);
player.beginPlaybackFrom(10);
expect(mockMediaElement.play).not.toHaveBeenCalledWith();
expect(mockMediaElement.seek).not.toHaveBeenCalledWith();
});
expect(mockMediaElement.play).not.toHaveBeenCalledWith();
expect(mockMediaElement.seek).not.toHaveBeenCalledWith();
});
});
describe('pause', function () {
it('should call pause on the media element', function () {
player.beginPlayback();
mockMediaElement.playState = 1;
mockMediaElement.onPlayStateChange();
describe('pause', function () {
it('should call pause on the media element', function () {
player.beginPlayback();
mockMediaElement.playState = 1;
mockMediaElement.onPlayStateChange();
mockMediaElement.play.calls.reset();
player.pause();
mockMediaElement.play.calls.reset();
player.pause();
expect(mockMediaElement.play).toHaveBeenCalledWith(0);
});
expect(mockMediaElement.play).toHaveBeenCalledWith(0);
});
it('should not call pause if paused', function () {
player.beginPlayback();
mockMediaElement.playState = 1;
mockMediaElement.onPlayStateChange();
it('should not call pause if paused', function () {
player.beginPlayback();
mockMediaElement.playState = 1;
mockMediaElement.onPlayStateChange();
player.pause();
player.pause();
mockMediaElement.play.calls.reset();
player.pause();
mockMediaElement.play.calls.reset();
player.pause();
expect(mockMediaElement.play).not.toHaveBeenCalled();
});
expect(mockMediaElement.play).not.toHaveBeenCalled();
});
});
describe('stop', function () {
it('should call stop on the media element', function () {
player.beginPlayback();
player.stop();
describe('stop', function () {
it('should call stop on the media element', function () {
player.beginPlayback();
player.stop();
expect(mockMediaElement.stop).toHaveBeenCalledWith();
});
expect(mockMediaElement.stop).toHaveBeenCalledWith();
});
it('should not call stop if playback has not started', function () {
player.stop();
it('should not call stop if playback has not started', function () {
player.stop();
expect(mockMediaElement.stop).not.toHaveBeenCalled();
});
expect(mockMediaElement.stop).not.toHaveBeenCalled();
});
it('should not call stop if already stopped', function () {
player.beginPlayback();
player.stop();
it('should not call stop if already stopped', function () {
player.beginPlayback();
player.stop();
mockMediaElement.stop.calls.reset();
player.stop();
mockMediaElement.stop.calls.reset();
player.stop();
expect(mockMediaElement.stop).not.toHaveBeenCalled();
});
expect(mockMediaElement.stop).not.toHaveBeenCalled();
});
});
describe('getSource', function () {
it('should return the source', function () {
expect(player.getSource()).toBe('testUrl');
});
describe('getSource', function () {
it('should return the source', function () {
expect(player.getSource()).toBe('testUrl');
});
});
describe('getMimeType', function () {
it('should return the mimeType', function () {
expect(player.getMimeType()).toBe('testMimeType');
});
describe('getMimeType', function () {
it('should return the mimeType', function () {
expect(player.getMimeType()).toBe('testMimeType');
});
});
describe('getSeekableRange', function () {
it('should return the seekable range', function () {
player.beginPlayback();
mockMediaElement.playState = 1;
mockMediaElement.playTime = 10000;
mockMediaElement.onPlayStateChange();
describe('getSeekableRange', function () {
it('should return the seekable range', function () {
player.beginPlayback();
mockMediaElement.playState = 1;
mockMediaElement.playTime = 10000;
mockMediaElement.onPlayStateChange();
expect(player.getSeekableRange()).toEqual({start: 0, end: 10});
});
expect(player.getSeekableRange()).toEqual({start: 0, end: 10});
});
});
describe('getMediaDuration', function () {
it('should return the media duration', function () {
player.beginPlayback();
mockMediaElement.playState = 1;
mockMediaElement.playTime = 10000;
mockMediaElement.onPlayStateChange();
describe('getMediaDuration', function () {
it('should return the media duration', function () {
player.beginPlayback();
mockMediaElement.playState = 1;
mockMediaElement.playTime = 10000;
mockMediaElement.onPlayStateChange();
expect(player.getMediaDuration()).toEqual(10);
});
expect(player.getMediaDuration()).toEqual(10);
});
});
describe('getState', function () {
it('should return the state', function () {
expect(player.getState()).toEqual(MediaPlayerBase.STATE.STOPPED);
player.beginPlayback();
mockMediaElement.playState = 1;
mockMediaElement.onPlayStateChange();
describe('getState', function () {
it('should return the state', function () {
expect(player.getState()).toEqual(MediaPlayerBase.STATE.STOPPED);
player.beginPlayback();
mockMediaElement.playState = 1;
mockMediaElement.onPlayStateChange();
expect(player.getState()).toEqual(MediaPlayerBase.STATE.PLAYING);
});
expect(player.getState()).toEqual(MediaPlayerBase.STATE.PLAYING);
});
});
describe('getPlayerElement', function () {
it('should return the media element', function () {
expect(player.getPlayerElement()).toBe(mockMediaElement);
});
describe('getPlayerElement', function () {
it('should return the media element', function () {
expect(player.getPlayerElement()).toBe(mockMediaElement);
});
});
describe('getDuration', function () {
it('should retrun the media duration for vod', function () {
player.beginPlayback();
mockMediaElement.playState = 1;
mockMediaElement.playTime = 10000;
mockMediaElement.onPlayStateChange();
describe('getDuration', function () {
it('should retrun the media duration for vod', function () {
player.beginPlayback();
mockMediaElement.playState = 1;
mockMediaElement.playTime = 10000;
mockMediaElement.onPlayStateChange();
expect(player.getDuration()).toBe(10);
});
expect(player.getDuration()).toBe(10);
});
it('should retrun the inifinty for live', function () {
player.reset();
player.initialiseMedia(MediaPlayerBase.TYPE.LIVE_VIDEO, 'testUrl', 'testMimeType', sourceContainer, {});
player.beginPlayback();
mockMediaElement.playState = 1;
mockMediaElement.playTime = 10000;
mockMediaElement.onPlayStateChange();
it('should retrun the inifinty for live', function () {
player.reset();
player.initialiseMedia(MediaPlayerBase.TYPE.LIVE_VIDEO, 'testUrl', 'testMimeType', sourceContainer, {});
player.beginPlayback();
mockMediaElement.playState = 1;
mockMediaElement.playTime = 10000;
mockMediaElement.onPlayStateChange();
expect(player.getDuration()).toBe(Infinity);
});
expect(player.getDuration()).toBe(Infinity);
});
});
});
});

182

script-test/playbackstrategies/modifiers/live/playabletest.js

@@ -12,126 +12,126 @@ /*

],
function (MediaPlayerBase, PlayableMediaPlayer) {
var sourceContainer = document.createElement('div');
var player;
var playableMediaPlayer;
function (MediaPlayerBase, PlayableMediaPlayer) {
var sourceContainer = document.createElement('div');
var player;
var playableMediaPlayer;
function wrapperTests (action, expectedReturn) {
if (expectedReturn) {
player[action].and.returnValue(expectedReturn);
function wrapperTests (action, expectedReturn) {
if (expectedReturn) {
player[action].and.returnValue(expectedReturn);
expect(playableMediaPlayer[action]()).toBe(expectedReturn);
} else {
playableMediaPlayer[action]();
expect(playableMediaPlayer[action]()).toBe(expectedReturn);
} else {
playableMediaPlayer[action]();
expect(player[action]).toHaveBeenCalledTimes(1);
}
expect(player[action]).toHaveBeenCalledTimes(1);
}
}
function isUndefined (action) {
expect(playableMediaPlayer[action]).not.toBeDefined();
}
function isUndefined (action) {
expect(playableMediaPlayer[action]).not.toBeDefined();
}
describe('Playable HMTL5 Live Player', function () {
beforeEach(function () {
player = jasmine.createSpyObj('player',
['beginPlayback', 'initialiseMedia', 'stop', 'reset', 'getState', 'getSource', 'getMimeType',
'addEventCallback', 'removeEventCallback', 'removeAllEventCallbacks', 'getPlayerElement']);
describe('Playable HMTL5 Live Player', function () {
beforeEach(function () {
player = jasmine.createSpyObj('player',
['beginPlayback', 'initialiseMedia', 'stop', 'reset', 'getState', 'getSource', 'getMimeType',
'addEventCallback', 'removeEventCallback', 'removeAllEventCallbacks', 'getPlayerElement']);
playableMediaPlayer = PlayableMediaPlayer(player);
});
playableMediaPlayer = PlayableMediaPlayer(player);
});
it('calls beginPlayback on the media player', function () {
wrapperTests('beginPlayback');
});
it('calls beginPlayback on the media player', function () {
wrapperTests('beginPlayback');
});
it('calls initialiseMedia on the media player', function () {
wrapperTests('initialiseMedia');
});
it('calls initialiseMedia on the media player', function () {
wrapperTests('initialiseMedia');
});
it('calls stop on the media player', function () {
wrapperTests('stop');
});
it('calls stop on the media player', function () {
wrapperTests('stop');
});
it('calls reset on the media player', function () {
wrapperTests('reset');
});
it('calls reset on the media player', function () {
wrapperTests('reset');
});
it('calls getState on the media player', function () {
wrapperTests('getState', 'thisState');
});
it('calls getState on the media player', function () {
wrapperTests('getState', 'thisState');
});
it('calls getSource on the media player', function () {
wrapperTests('getSource', 'thisSource');
});
it('calls getSource on the media player', function () {
wrapperTests('getSource', 'thisSource');
});
it('calls getMimeType on the media player', function () {
wrapperTests('getMimeType', 'thisMimeType');
});
it('calls getMimeType on the media player', function () {
wrapperTests('getMimeType', 'thisMimeType');
});
it('calls addEventCallback on the media player', function () {
var thisArg = 'arg';
var callback = function () { return; };
playableMediaPlayer.addEventCallback(thisArg, callback);
it('calls addEventCallback on the media player', function () {
var thisArg = 'arg';
var callback = function () { return; };
playableMediaPlayer.addEventCallback(thisArg, callback);
expect(player.addEventCallback).toHaveBeenCalledWith(thisArg, callback);
});
expect(player.addEventCallback).toHaveBeenCalledWith(thisArg, callback);
});
it('calls removeEventCallback on the media player', function () {
var thisArg = 'arg';
var callback = function () { return; };
playableMediaPlayer.removeEventCallback(thisArg, callback);
it('calls removeEventCallback on the media player', function () {
var thisArg = 'arg';
var callback = function () { return; };
playableMediaPlayer.removeEventCallback(thisArg, callback);
expect(player.removeEventCallback).toHaveBeenCalledWith(thisArg, callback);
expect(player.removeEventCallback).toHaveBeenCalledWith(thisArg, callback);
});
it('calls removeAllEventCallbacks on the media player', function () {
wrapperTests('removeAllEventCallbacks');
});
it('calls getPlayerElement on the media player', function () {
wrapperTests('getPlayerElement', 'thisPlayerElement');
});
describe('should not have methods for', function () {
it('beginPlaybackFrom', function () {
isUndefined('beginPlaybackFrom');
});
it('calls removeAllEventCallbacks on the media player', function () {
wrapperTests('removeAllEventCallbacks');
it('playFrom', function () {
isUndefined('playFrom');
});
it('calls getPlayerElement on the media player', function () {
wrapperTests('getPlayerElement', 'thisPlayerElement');
it('pause', function () {
isUndefined('pause');
});
describe('should not have methods for', function () {
it('beginPlaybackFrom', function () {
isUndefined('beginPlaybackFrom');
});
it('resume', function () {
isUndefined('resume');
});
it('playFrom', function () {
isUndefined('playFrom');
});
it('getCurrentTime', function () {
isUndefined('getCurrentTime');
});
it('pause', function () {
isUndefined('pause');
});
it('getSeekableRange', function () {
isUndefined('getSeekableRange');
});
});
it('resume', function () {
isUndefined('resume');
});
describe('calls the mediaplayer with the correct media Type', function () {
it('when is an audio stream', function () {
var mediaType = MediaPlayerBase.TYPE.AUDIO;
playableMediaPlayer.initialiseMedia(mediaType, null, null, sourceContainer, null);
it('getCurrentTime', function () {
isUndefined('getCurrentTime');
});
it('getSeekableRange', function () {
isUndefined('getSeekableRange');
});
expect(player.initialiseMedia).toHaveBeenCalledWith(MediaPlayerBase.TYPE.LIVE_AUDIO, null, null, sourceContainer, null);
});
describe('calls the mediaplayer with the correct media Type', function () {
it('when is an audio stream', function () {
var mediaType = MediaPlayerBase.TYPE.AUDIO;
playableMediaPlayer.initialiseMedia(mediaType, null, null, sourceContainer, null);
it('when is an video stream', function () {
var mediaType = MediaPlayerBase.TYPE.VIDEO;
playableMediaPlayer.initialiseMedia(mediaType, null, null, sourceContainer, null);
expect(player.initialiseMedia).toHaveBeenCalledWith(MediaPlayerBase.TYPE.LIVE_AUDIO, null, null, sourceContainer, null);
});
it('when is an video stream', function () {
var mediaType = MediaPlayerBase.TYPE.VIDEO;
playableMediaPlayer.initialiseMedia(mediaType, null, null, sourceContainer, null);
expect(player.initialiseMedia).toHaveBeenCalledWith(MediaPlayerBase.TYPE.LIVE_VIDEO, null, null, sourceContainer, null);
});
expect(player.initialiseMedia).toHaveBeenCalledWith(MediaPlayerBase.TYPE.LIVE_VIDEO, null, null, sourceContainer, null);
});
});
});
});

602

script-test/playbackstrategies/modifiers/live/restartabletest.js

@@ -7,421 +7,421 @@ require(

],
function (MediaPlayerBase, RestartableMediaPlayer, WindowTypes) {
var sourceContainer = document.createElement('div');
var player;
var restartableMediaPlayer;
var testTime = {
windowStartTime: 0,
windowEndTime: 100000,
correction: 0
};
function (MediaPlayerBase, RestartableMediaPlayer, WindowTypes) {
var sourceContainer = document.createElement('div');
var player;
var restartableMediaPlayer;
var testTime = {
windowStartTime: 0,
windowEndTime: 100000,
correction: 0
};
var mockMediaSources = {
time: function () {
return testTime;
},
refresh: function (successCallback, errorCallback) {
successCallback();
}
};
var mockMediaSources = {
time: function () {
return testTime;
},
refresh: function (successCallback, errorCallback) {
successCallback();
}
};
function initialiseRestartableMediaPlayer (config, windowType) {
windowType = windowType || WindowTypes.SLIDING;
restartableMediaPlayer = RestartableMediaPlayer(player, config, windowType, mockMediaSources);
}
function initialiseRestartableMediaPlayer (config, windowType) {
windowType = windowType || WindowTypes.SLIDING;
restartableMediaPlayer = RestartableMediaPlayer(player, config, windowType, mockMediaSources);
}
describe('restartable HMTL5 Live Player', function () {
function wrapperTests (action, expectedReturn) {
if (expectedReturn) {
player[action].and.returnValue(expectedReturn);
describe('restartable HMTL5 Live Player', function () {
function wrapperTests (action, expectedReturn) {
if (expectedReturn) {
player[action].and.returnValue(expectedReturn);
expect(restartableMediaPlayer[action]()).toBe(expectedReturn);
} else {
restartableMediaPlayer[action]();
expect(restartableMediaPlayer[action]()).toBe(expectedReturn);
} else {
restartableMediaPlayer[action]();
expect(player[action]).toHaveBeenCalledTimes(1);
}
}
expect(player[action]).toHaveBeenCalledTimes(1);
}
}
beforeEach(function () {
player = jasmine.createSpyObj('player',
['beginPlayback', 'initialiseMedia', 'stop', 'reset', 'getState', 'getSource', 'getMimeType',
'addEventCallback', 'removeEventCallback', 'removeAllEventCallbacks', 'getPlayerElement', 'pause',
'resume', 'beginPlaybackFrom']);
});
beforeEach(function () {
player = jasmine.createSpyObj('player',
['beginPlayback', 'initialiseMedia', 'stop', 'reset', 'getState', 'getSource', 'getMimeType',
'addEventCallback', 'removeEventCallback', 'removeAllEventCallbacks', 'getPlayerElement', 'pause',
'resume', 'beginPlaybackFrom']);
});
describe('methods call the appropriate media player methods', function () {
beforeEach(function () {
initialiseRestartableMediaPlayer();
});
describe('methods call the appropriate media player methods', function () {
beforeEach(function () {
initialiseRestartableMediaPlayer();
});
it('calls beginPlayback on the media player', function () {
wrapperTests('beginPlayback');
});
it('calls beginPlayback on the media player', function () {
wrapperTests('beginPlayback');
});
it('calls initialiseMedia on the media player', function () {
wrapperTests('initialiseMedia');
});
it('calls initialiseMedia on the media player', function () {
wrapperTests('initialiseMedia');
});
it('calls stop on the media player', function () {
wrapperTests('stop');
});
it('calls stop on the media player', function () {
wrapperTests('stop');
});
it('calls reset on the media player', function () {
wrapperTests('reset');
});
it('calls reset on the media player', function () {
wrapperTests('reset');
});
it('calls getState on the media player', function () {
wrapperTests('getState', 'thisState');
});
it('calls getState on the media player', function () {
wrapperTests('getState', 'thisState');
});
it('calls getSource on the media player', function () {
wrapperTests('getSource', 'thisSource');
});
it('calls getSource on the media player', function () {
wrapperTests('getSource', 'thisSource');
});
it('calls getMimeType on the media player', function () {
wrapperTests('getMimeType', 'thisMimeType');
});
it('calls getMimeType on the media player', function () {
wrapperTests('getMimeType', 'thisMimeType');
});
it('calls addEventCallback on the media player', function () {
var thisArg = 'arg';
var callback = function () { return; };
restartableMediaPlayer.addEventCallback(thisArg, callback);
it('calls addEventCallback on the media player', function () {
var thisArg = 'arg';
var callback = function () { return; };
restartableMediaPlayer.addEventCallback(thisArg, callback);
expect(player.addEventCallback).toHaveBeenCalledWith(thisArg, jasmine.any(Function));
});
expect(player.addEventCallback).toHaveBeenCalledWith(thisArg, jasmine.any(Function));
});
it('calls removeEventCallback on the media player', function () {
var thisArg = 'arg';
var callback = function () { return; };
restartableMediaPlayer.addEventCallback(thisArg, callback);
restartableMediaPlayer.removeEventCallback(thisArg, callback);
it('calls removeEventCallback on the media player', function () {
var thisArg = 'arg';
var callback = function () { return; };
restartableMediaPlayer.addEventCallback(thisArg, callback);
restartableMediaPlayer.removeEventCallback(thisArg, callback);
expect(player.removeEventCallback).toHaveBeenCalledWith(thisArg, jasmine.any(Function));
});
expect(player.removeEventCallback).toHaveBeenCalledWith(thisArg, jasmine.any(Function));
});
it('calls removeAllEventCallbacks on the media player', function () {
wrapperTests('removeAllEventCallbacks');
});
it('calls removeAllEventCallbacks on the media player', function () {
wrapperTests('removeAllEventCallbacks');
});
it('calls getPlayerElement on the media player', function () {
wrapperTests('getPlayerElement', 'thisPlayerElement');
});
it('calls getPlayerElement on the media player', function () {
wrapperTests('getPlayerElement', 'thisPlayerElement');
});
it('calls pause on the media player', function () {
wrapperTests('pause');
});
});
it('calls pause on the media player', function () {
wrapperTests('pause');
});
});
describe('should not have methods for', function () {
function isUndefined (action) {
expect(restartableMediaPlayer[action]).not.toBeDefined();
}
describe('should not have methods for', function () {
function isUndefined (action) {
expect(restartableMediaPlayer[action]).not.toBeDefined();
}
beforeEach(function () {
initialiseRestartableMediaPlayer();
});
beforeEach(function () {
initialiseRestartableMediaPlayer();
});
it('playFrom', function () {
isUndefined('playFrom');
});
});
it('playFrom', function () {
isUndefined('playFrom');
});
});
describe('should use fake time for', function () {
var timeUpdates = [];
function timeUpdate (opts) {
timeUpdates.forEach(function (fn) { fn(opts); });
}
describe('should use fake time for', function () {
var timeUpdates = [];
function timeUpdate (opts) {
timeUpdates.forEach(function (fn) { fn(opts); });
}
beforeEach(function () {
jasmine.clock().install();
jasmine.clock().mockDate();
beforeEach(function () {
jasmine.clock().install();
jasmine.clock().mockDate();
player.addEventCallback.and.callFake(function (self, callback) {
timeUpdates.push(callback);
});
player.addEventCallback.and.callFake(function (self, callback) {
timeUpdates.push(callback);
});
initialiseRestartableMediaPlayer();
});
initialiseRestartableMediaPlayer();
});
afterEach(function () {
jasmine.clock().uninstall();
});
afterEach(function () {
jasmine.clock().uninstall();
});
describe('getCurrentTime', function () {
it('should be set on to the window length on beginPlayback', function () {
restartableMediaPlayer.beginPlayback();
describe('getCurrentTime', function () {
it('should be set on to the window length on beginPlayback', function () {
restartableMediaPlayer.beginPlayback();
expect(restartableMediaPlayer.getCurrentTime()).toBe(100);
});
expect(restartableMediaPlayer.getCurrentTime()).toBe(100);
});
it('should start at supplied time', function () {
restartableMediaPlayer.beginPlaybackFrom(10);
it('should start at supplied time', function () {
restartableMediaPlayer.beginPlaybackFrom(10);
expect(restartableMediaPlayer.getCurrentTime()).toBe(10);
});
expect(restartableMediaPlayer.getCurrentTime()).toBe(10);
});
it('should increase when playing', function () {
restartableMediaPlayer.beginPlaybackFrom(10);
it('should increase when playing', function () {
restartableMediaPlayer.beginPlaybackFrom(10);
timeUpdate({ state: MediaPlayerBase.STATE.PLAYING });
timeUpdate({ state: MediaPlayerBase.STATE.PLAYING });
jasmine.clock().tick(1000);
jasmine.clock().tick(1000);
timeUpdate({ state: MediaPlayerBase.STATE.PLAYING });
timeUpdate({ state: MediaPlayerBase.STATE.PLAYING });
expect(restartableMediaPlayer.getCurrentTime()).toBe(11);
});
expect(restartableMediaPlayer.getCurrentTime()).toBe(11);
});
it('should not increase when paused', function () {
restartableMediaPlayer.beginPlaybackFrom(10);
timeUpdate({ state: MediaPlayerBase.STATE.PAUSED });
it('should not increase when paused', function () {
restartableMediaPlayer.beginPlaybackFrom(10);
timeUpdate({ state: MediaPlayerBase.STATE.PAUSED });
jasmine.clock().tick(1000);
jasmine.clock().tick(1000);
timeUpdate({ state: MediaPlayerBase.STATE.PLAYING });
timeUpdate({ state: MediaPlayerBase.STATE.PLAYING });
expect(restartableMediaPlayer.getCurrentTime()).toBe(10);
});
});
expect(restartableMediaPlayer.getCurrentTime()).toBe(10);
});
});
describe('getSeekableRange', function () {
it('should start at the window time', function () {
restartableMediaPlayer.beginPlaybackFrom(0);
describe('getSeekableRange', function () {
it('should start at the window time', function () {
restartableMediaPlayer.beginPlaybackFrom(0);
timeUpdate({ state: MediaPlayerBase.STATE.PLAYING });
timeUpdate({ state: MediaPlayerBase.STATE.PLAYING });
expect(restartableMediaPlayer.getSeekableRange()).toEqual({ start: 0, end: 100 });
});
expect(restartableMediaPlayer.getSeekableRange()).toEqual({ start: 0, end: 100 });
});
it('should increase start and end for a sliding window', function () {
restartableMediaPlayer.beginPlaybackFrom(0);
it('should increase start and end for a sliding window', function () {
restartableMediaPlayer.beginPlaybackFrom(0);
timeUpdate({ state: MediaPlayerBase.STATE.PLAYING });
timeUpdate({ state: MediaPlayerBase.STATE.PLAYING });
jasmine.clock().tick(1000);
jasmine.clock().tick(1000);
expect(restartableMediaPlayer.getSeekableRange()).toEqual({ start: 1, end: 101 });
});
expect(restartableMediaPlayer.getSeekableRange()).toEqual({ start: 1, end: 101 });
});
it('should only increase end for a growing window', function () {
initialiseRestartableMediaPlayer({}, WindowTypes.GROWING);
restartableMediaPlayer.beginPlaybackFrom(0);
timeUpdate({ state: MediaPlayerBase.STATE.PLAYING });
jasmine.clock().tick(1000);
it('should only increase end for a growing window', function () {
initialiseRestartableMediaPlayer({}, WindowTypes.GROWING);
restartableMediaPlayer.beginPlaybackFrom(0);
timeUpdate({ state: MediaPlayerBase.STATE.PLAYING });
jasmine.clock().tick(1000);
expect(restartableMediaPlayer.getSeekableRange()).toEqual({ start: 0, end: 101 });
});
});
expect(restartableMediaPlayer.getSeekableRange()).toEqual({ start: 0, end: 101 });
});
});
});
describe('calls the mediaplayer with the correct media Type', function () {
beforeEach(function () {
initialiseRestartableMediaPlayer();
});
describe('calls the mediaplayer with the correct media Type', function () {
beforeEach(function () {
initialiseRestartableMediaPlayer();
});
it('for static video', function () {
restartableMediaPlayer.initialiseMedia(MediaPlayerBase.TYPE.VIDEO, '', '', sourceContainer);
it('for static video', function () {
restartableMediaPlayer.initialiseMedia(MediaPlayerBase.TYPE.VIDEO, '', '', sourceContainer);
expect(player.initialiseMedia).toHaveBeenCalledWith(MediaPlayerBase.TYPE.LIVE_VIDEO, '', '', sourceContainer, undefined);
});
expect(player.initialiseMedia).toHaveBeenCalledWith(MediaPlayerBase.TYPE.LIVE_VIDEO, '', '', sourceContainer, undefined);
});
it('for live video', function () {
restartableMediaPlayer.initialiseMedia(MediaPlayerBase.TYPE.LIVE_VIDEO, '', '', sourceContainer);
it('for live video', function () {
restartableMediaPlayer.initialiseMedia(MediaPlayerBase.TYPE.LIVE_VIDEO, '', '', sourceContainer);
expect(player.initialiseMedia).toHaveBeenCalledWith(MediaPlayerBase.TYPE.LIVE_VIDEO, '', '', sourceContainer, undefined);
});
expect(player.initialiseMedia).toHaveBeenCalledWith(MediaPlayerBase.TYPE.LIVE_VIDEO, '', '', sourceContainer, undefined);
});
it('for static audio', function () {
restartableMediaPlayer.initialiseMedia(MediaPlayerBase.TYPE.AUDIO, '', '', sourceContainer);
it('for static audio', function () {
restartableMediaPlayer.initialiseMedia(MediaPlayerBase.TYPE.AUDIO, '', '', sourceContainer);
expect(player.initialiseMedia).toHaveBeenCalledWith(MediaPlayerBase.TYPE.LIVE_AUDIO, '', '', sourceContainer, undefined);
});
});
expect(player.initialiseMedia).toHaveBeenCalledWith(MediaPlayerBase.TYPE.LIVE_AUDIO, '', '', sourceContainer, undefined);
});
});
describe('Restartable features', function () {
it('begins playback with the desired offset', function () {
initialiseRestartableMediaPlayer();
var offset = 10;
describe('Restartable features', function () {
it('begins playback with the desired offset', function () {
initialiseRestartableMediaPlayer();
var offset = 10;
restartableMediaPlayer.beginPlaybackFrom(offset);
restartableMediaPlayer.beginPlaybackFrom(offset);
expect(player.beginPlaybackFrom).toHaveBeenCalledWith(offset);
});
expect(player.beginPlaybackFrom).toHaveBeenCalledWith(offset);
});
it('should respect config forcing playback from the end of the window', function () {
var config = {
streaming: {
overrides: {
forceBeginPlaybackToEndOfWindow: true
}
}
};
initialiseRestartableMediaPlayer(config);
it('should respect config forcing playback from the end of the window', function () {
var config = {
streaming: {
overrides: {
forceBeginPlaybackToEndOfWindow: true
}
}
};
initialiseRestartableMediaPlayer(config);
restartableMediaPlayer.beginPlayback();
restartableMediaPlayer.beginPlayback();
expect(player.beginPlaybackFrom).toHaveBeenCalledWith(Infinity);
});
});
expect(player.beginPlaybackFrom).toHaveBeenCalledWith(Infinity);
});
});
describe('Pausing and Auto-Resume', function () {
var mockCallback = [];
describe('Pausing and Auto-Resume', function () {
var mockCallback = [];
function startPlaybackAndPause (startTime, disableAutoResume) {
restartableMediaPlayer.beginPlaybackFrom(startTime);
function startPlaybackAndPause (startTime, disableAutoResume) {
restartableMediaPlayer.beginPlaybackFrom(startTime);
for (var index = 0; index < mockCallback.length; index++) {
mockCallback[index]({state: MediaPlayerBase.STATE.PLAYING});
}
for (var index = 0; index < mockCallback.length; index++) {
mockCallback[index]({state: MediaPlayerBase.STATE.PLAYING});
}
restartableMediaPlayer.pause({disableAutoResume: disableAutoResume});
restartableMediaPlayer.pause({disableAutoResume: disableAutoResume});
for (index = 0; index < mockCallback.length; index++) {
mockCallback[index]({state: MediaPlayerBase.STATE.PAUSED});
}
}
for (index = 0; index < mockCallback.length; index++) {
mockCallback[index]({state: MediaPlayerBase.STATE.PAUSED});
}
}
beforeEach(function () {
jasmine.clock().install();
jasmine.clock().mockDate();
beforeEach(function () {
jasmine.clock().install();
jasmine.clock().mockDate();
player.addEventCallback.and.callFake(function (self, callback) {
mockCallback.push(callback);
});
player.addEventCallback.and.callFake(function (self, callback) {
mockCallback.push(callback);
});
initialiseRestartableMediaPlayer();
initialiseRestartableMediaPlayer();
for (var index = 0; index < mockCallback.length; index++) {
mockCallback[index]({state: MediaPlayerBase.STATE.PLAYING});
}
});
for (var index = 0; index < mockCallback.length; index++) {
mockCallback[index]({state: MediaPlayerBase.STATE.PLAYING});
}
});
afterEach(function () {
jasmine.clock().uninstall();
mockCallback = [];
});
afterEach(function () {
jasmine.clock().uninstall();
mockCallback = [];
});
it('calls resume when approaching the start of the buffer', function () {
startPlaybackAndPause(20, false);
it('calls resume when approaching the start of the buffer', function () {
startPlaybackAndPause(20, false);
jasmine.clock().tick(12 * 1000);
jasmine.clock().tick(12 * 1000);
expect(player.resume).toHaveBeenCalledWith();
});
expect(player.resume).toHaveBeenCalledWith();
});
it('does not call resume when approaching the start of the buffer with the disableAutoResume option', function () {
startPlaybackAndPause(20, true);
it('does not call resume when approaching the start of the buffer with the disableAutoResume option', function () {
startPlaybackAndPause(20, true);
jasmine.clock().tick(12 * 1000);
jasmine.clock().tick(12 * 1000);
expect(player.resume).not.toHaveBeenCalledWith();
});
expect(player.resume).not.toHaveBeenCalledWith();
});
it('does not call resume if paused after the autoresume point', function () {
startPlaybackAndPause(20, false);
it('does not call resume if paused after the autoresume point', function () {
startPlaybackAndPause(20, false);
jasmine.clock().tick(11 * 1000);
jasmine.clock().tick(11 * 1000);
expect(player.resume).not.toHaveBeenCalledWith();
});
expect(player.resume).not.toHaveBeenCalledWith();
});
it('does not auto-resume if the video is no longer paused', function () {
startPlaybackAndPause(20, false);
it('does not auto-resume if the video is no longer paused', function () {
startPlaybackAndPause(20, false);
for (var index = 0; index < mockCallback.length; index++) {
mockCallback[index]({state: MediaPlayerBase.STATE.PLAYING});
}
for (var index = 0; index < mockCallback.length; index++) {
mockCallback[index]({state: MediaPlayerBase.STATE.PLAYING});
}
jasmine.clock().tick(12 * 1000);
jasmine.clock().tick(12 * 1000);
expect(player.resume).not.toHaveBeenCalledTimes(2);
});
expect(player.resume).not.toHaveBeenCalledTimes(2);
});
it('Calls resume when paused is called multiple times', function () {
startPlaybackAndPause(0, false);
it('Calls resume when paused is called multiple times', function () {
startPlaybackAndPause(0, false);
var event = {state: MediaPlayerBase.STATE.PLAYING, currentTime: 25};
for (var index = 0; index < mockCallback.length; index++) {
mockCallback[index](event);
}
var event = {state: MediaPlayerBase.STATE.PLAYING, currentTime: 25};
for (var index = 0; index < mockCallback.length; index++) {
mockCallback[index](event);
}
restartableMediaPlayer.pause();
restartableMediaPlayer.pause();
event.currentTime = 30;
for (index = 0; index < mockCallback.length; index++) {
mockCallback[index](event);
}
event.currentTime = 30;
for (index = 0; index < mockCallback.length; index++) {
mockCallback[index](event);
}
restartableMediaPlayer.pause();
// uses real time to determine pause intervals
// if debugging the time to the buffer will be decreased by the time spent.
jasmine.clock().tick(22 * 1000);
restartableMediaPlayer.pause();
// uses real time to determine pause intervals
// if debugging the time to the buffer will be decreased by the time spent.
jasmine.clock().tick(22 * 1000);
expect(player.resume).toHaveBeenCalledTimes(1);
});
expect(player.resume).toHaveBeenCalledTimes(1);
});
it('calls auto-resume immeditetly if paused after an autoresume', function () {
startPlaybackAndPause(20, false);
it('calls auto-resume immeditetly if paused after an autoresume', function () {
startPlaybackAndPause(20, false);
jasmine.clock().tick(12 * 1000);
jasmine.clock().tick(12 * 1000);
restartableMediaPlayer.pause();
restartableMediaPlayer.pause();
jasmine.clock().tick(1);
jasmine.clock().tick(1);
expect(player.resume).toHaveBeenCalledTimes(2);
});
expect(player.resume).toHaveBeenCalledTimes(2);
});
it('auto-resume is not cancelled by a paused event state', function () {
startPlaybackAndPause(20, false);
it('auto-resume is not cancelled by a paused event state', function () {
startPlaybackAndPause(20, false);
for (var index = 0; index < mockCallback.length; index++) {
mockCallback[index]({state: MediaPlayerBase.STATE.PAUSED});
}
for (var index = 0; index < mockCallback.length; index++) {
mockCallback[index]({state: MediaPlayerBase.STATE.PAUSED});
}
jasmine.clock().tick(12 * 1000);
jasmine.clock().tick(12 * 1000);
expect(player.resume).toHaveBeenCalledTimes(1);
});
expect(player.resume).toHaveBeenCalledTimes(1);
});
it('will fake pause if attempting to pause at the start of playback ', function () {
startPlaybackAndPause(0, false);
it('will fake pause if attempting to pause at the start of playback ', function () {
startPlaybackAndPause(0, false);
jasmine.clock().tick(1);
jasmine.clock().tick(1);
expect(player.pause).toHaveBeenCalledTimes(1);
expect(player.resume).toHaveBeenCalledTimes(1);
});
expect(player.pause).toHaveBeenCalledTimes(1);
expect(player.resume).toHaveBeenCalledTimes(1);
});
it('does not calls autoresume immeditetly if paused after an auto-resume with disableAutoResume options', function () {
startPlaybackAndPause(20, true);
it('does not calls autoresume immeditetly if paused after an auto-resume with disableAutoResume options', function () {
startPlaybackAndPause(20, true);
jasmine.clock().tick(12 * 1000);
jasmine.clock().tick(12 * 1000);
jasmine.clock().tick(1);
jasmine.clock().tick(1);
expect(player.resume).not.toHaveBeenCalledTimes(1);
});
expect(player.resume).not.toHaveBeenCalledTimes(1);
});
it('time spend buffering is deducted when considering time to auto-resume', function () {
restartableMediaPlayer.beginPlaybackFrom(20);
it('time spend buffering is deducted when considering time to auto-resume', function () {
restartableMediaPlayer.beginPlaybackFrom(20);
for (var index = 0; index < mockCallback.length; index++) {
mockCallback[index]({state: MediaPlayerBase.STATE.BUFFERING, currentTime: 20});
}
for (var index = 0; index < mockCallback.length; index++) {
mockCallback[index]({state: MediaPlayerBase.STATE.BUFFERING, currentTime: 20});
}
jasmine.clock().tick(11 * 1000);
jasmine.clock().tick(11 * 1000);
for (index = 0; index < mockCallback.length; index++) {
mockCallback[index]({state: MediaPlayerBase.STATE.PLAYING, currentTime: 20});
}
for (index = 0; index < mockCallback.length; index++) {
mockCallback[index]({state: MediaPlayerBase.STATE.PLAYING, currentTime: 20});
}
restartableMediaPlayer.pause();
restartableMediaPlayer.pause();
jasmine.clock().tick(3 * 1000);
jasmine.clock().tick(3 * 1000);
expect(player.resume).toHaveBeenCalledTimes(1);
});
});
expect(player.resume).toHaveBeenCalledTimes(1);
});
});
});
});

450

script-test/playbackstrategies/modifiers/live/seekabletest.js

@@ -6,328 +6,328 @@ require(

],
function (MediaPlayerBase, SeekableMediaPlayer) {
var sourceContainer = document.createElement('div');
var player;
var seekableMediaPlayer;
function (MediaPlayerBase, SeekableMediaPlayer) {
var sourceContainer = document.createElement('div');
var player;
var seekableMediaPlayer;
function wrapperTests (action, expectedReturn) {
if (expectedReturn) {
player[action].and.returnValue(expectedReturn);
function wrapperTests (action, expectedReturn) {
if (expectedReturn) {
player[action].and.returnValue(expectedReturn);
expect(seekableMediaPlayer[action]()).toBe(expectedReturn);
} else {
seekableMediaPlayer[action]();
expect(seekableMediaPlayer[action]()).toBe(expectedReturn);
} else {
seekableMediaPlayer[action]();
expect(player[action]).toHaveBeenCalledTimes(1);
}
expect(player[action]).toHaveBeenCalledTimes(1);
}
}
function initialiseSeekableMediaPlayer (config) {
seekableMediaPlayer = SeekableMediaPlayer(player, config);
}
function initialiseSeekableMediaPlayer (config) {
seekableMediaPlayer = SeekableMediaPlayer(player, config);
}
describe('Seekable HMTL5 Live Player', function () {
describe('Seekable HMTL5 Live Player', function () {
beforeEach(function () {
player = jasmine.createSpyObj('player',
['beginPlayback', 'initialiseMedia', 'stop', 'reset', 'getState', 'getSource', 'getMimeType',
'addEventCallback', 'removeEventCallback', 'removeAllEventCallbacks', 'getPlayerElement', 'pause',
'resume', 'beginPlaybackFrom', 'playFrom', 'getCurrentTime', 'getSeekableRange', 'toPaused',
'toPlaying']);
});
describe('methods call the appropriate media player methods', function () {
beforeEach(function () {
player = jasmine.createSpyObj('player',
['beginPlayback', 'initialiseMedia', 'stop', 'reset', 'getState', 'getSource', 'getMimeType',
'addEventCallback', 'removeEventCallback', 'removeAllEventCallbacks', 'getPlayerElement', 'pause',
'resume', 'beginPlaybackFrom', 'playFrom', 'getCurrentTime', 'getSeekableRange', 'toPaused',
'toPlaying']);
initialiseSeekableMediaPlayer();
});
describe('methods call the appropriate media player methods', function () {
beforeEach(function () {
initialiseSeekableMediaPlayer();
});
it('calls beginPlayback on the media player', function () {
wrapperTests('beginPlayback');
});
it('calls beginPlayback on the media player', function () {
wrapperTests('beginPlayback');
});
it('calls initialiseMedia on the media player', function () {
wrapperTests('initialiseMedia');
});
it('calls initialiseMedia on the media player', function () {
wrapperTests('initialiseMedia');
});
it('calls beginPlayingFrom on the media player', function () {
var arg = 0;
seekableMediaPlayer.beginPlaybackFrom(arg);
it('calls beginPlayingFrom on the media player', function () {
var arg = 0;
seekableMediaPlayer.beginPlaybackFrom(arg);
expect(player.beginPlaybackFrom).toHaveBeenCalledWith(arg);
});
expect(player.beginPlaybackFrom).toHaveBeenCalledWith(arg);
});
it('calls playFrom on the media player', function () {
var arg = 0;
seekableMediaPlayer.playFrom(arg);
it('calls playFrom on the media player', function () {
var arg = 0;
seekableMediaPlayer.playFrom(arg);
expect(player.playFrom).toHaveBeenCalledWith(arg);
});
expect(player.playFrom).toHaveBeenCalledWith(arg);
});
it('calls stop on the media player', function () {
wrapperTests('stop');
});
it('calls stop on the media player', function () {
wrapperTests('stop');
});
it('calls reset on the media player', function () {
wrapperTests('reset');
});
it('calls reset on the media player', function () {
wrapperTests('reset');
});
it('calls getState on the media player', function () {
wrapperTests('getState', 'thisState');
});
it('calls getState on the media player', function () {
wrapperTests('getState', 'thisState');
});
it('calls getSource on the media player', function () {
wrapperTests('getSource', 'thisSource');
});
it('calls getSource on the media player', function () {
wrapperTests('getSource', 'thisSource');
});
it('calls getMimeType on the media player', function () {
wrapperTests('getMimeType', 'thisMimeType');
});
it('calls getMimeType on the media player', function () {
wrapperTests('getMimeType', 'thisMimeType');
});
it('calls addEventCallback on the media player', function () {
var thisArg = 'arg';
var callback = function () { return; };
seekableMediaPlayer.addEventCallback(thisArg, callback);
it('calls addEventCallback on the media player', function () {
var thisArg = 'arg';
var callback = function () { return; };
seekableMediaPlayer.addEventCallback(thisArg, callback);
expect(player.addEventCallback).toHaveBeenCalledWith(thisArg, callback);
});
expect(player.addEventCallback).toHaveBeenCalledWith(thisArg, callback);
});
it('calls removeEventCallback on the media player', function () {
var thisArg = 'arg';
var callback = function () { return; };
seekableMediaPlayer.removeEventCallback(thisArg, callback);
it('calls removeEventCallback on the media player', function () {
var thisArg = 'arg';
var callback = function () { return; };
seekableMediaPlayer.removeEventCallback(thisArg, callback);
expect(player.removeEventCallback).toHaveBeenCalledWith(thisArg, callback);
});
expect(player.removeEventCallback).toHaveBeenCalledWith(thisArg, callback);
});
it('calls removeAllEventCallbacks on the media player', function () {
wrapperTests('removeAllEventCallbacks');
});
it('calls removeAllEventCallbacks on the media player', function () {
wrapperTests('removeAllEventCallbacks');
});
it('calls getPlayerElement on the media player', function () {
wrapperTests('getPlayerElement');
});
it('calls getPlayerElement on the media player', function () {
wrapperTests('getPlayerElement');
});
it('calls pause on the media player', function () {
player.getSeekableRange.and.returnValue({start: 0});
it('calls pause on the media player', function () {
player.getSeekableRange.and.returnValue({start: 0});
wrapperTests('pause');
});
wrapperTests('pause');
});
it('calls getCurrentTime on media player', function () {
wrapperTests('getCurrentTime', 'thisTime');
});
it('calls getCurrentTime on media player', function () {
wrapperTests('getCurrentTime', 'thisTime');
});
it('calls getSeekableRange on media player', function () {
wrapperTests('getSeekableRange', 'thisRange');
});
it('calls getSeekableRange on media player', function () {
wrapperTests('getSeekableRange', 'thisRange');
});
});
describe('Seekable features', function () {
it('should respect config forcing playback from the end of the window', function () {
var config = {
streaming: {
overrides: {
forceBeginPlaybackToEndOfWindow: true
}
describe('Seekable features', function () {
it('should respect config forcing playback from the end of the window', function () {
var config = {
streaming: {
overrides: {
forceBeginPlaybackToEndOfWindow: true
}
};
initialiseSeekableMediaPlayer(config);
}
};
initialiseSeekableMediaPlayer(config);
seekableMediaPlayer.beginPlayback();
seekableMediaPlayer.beginPlayback();
expect(player.beginPlaybackFrom).toHaveBeenCalledWith(Infinity);
});
expect(player.beginPlaybackFrom).toHaveBeenCalledWith(Infinity);
});
});
describe('calls the mediaplayer with the correct media Type', function () {
beforeEach(function () {
initialiseSeekableMediaPlayer();
});
describe('calls the mediaplayer with the correct media Type', function () {
beforeEach(function () {
initialiseSeekableMediaPlayer();
});
it('for static video', function () {
seekableMediaPlayer.initialiseMedia(MediaPlayerBase.TYPE.VIDEO, '', '', sourceContainer);
it('for static video', function () {
seekableMediaPlayer.initialiseMedia(MediaPlayerBase.TYPE.VIDEO, '', '', sourceContainer);
expect(player.initialiseMedia).toHaveBeenCalledWith(MediaPlayerBase.TYPE.LIVE_VIDEO, '', '', sourceContainer, undefined);
});
expect(player.initialiseMedia).toHaveBeenCalledWith(MediaPlayerBase.TYPE.LIVE_VIDEO, '', '', sourceContainer, undefined);
});
it('for live video', function () {
seekableMediaPlayer.initialiseMedia(MediaPlayerBase.TYPE.LIVE_VIDEO, '', '', sourceContainer);
it('for live video', function () {
seekableMediaPlayer.initialiseMedia(MediaPlayerBase.TYPE.LIVE_VIDEO, '', '', sourceContainer);
expect(player.initialiseMedia).toHaveBeenCalledWith(MediaPlayerBase.TYPE.LIVE_VIDEO, '', '', sourceContainer, undefined);
});
expect(player.initialiseMedia).toHaveBeenCalledWith(MediaPlayerBase.TYPE.LIVE_VIDEO, '', '', sourceContainer, undefined);
});
it('for static audio', function () {
seekableMediaPlayer.initialiseMedia(MediaPlayerBase.TYPE.AUDIO, '', '', sourceContainer);
it('for static audio', function () {
seekableMediaPlayer.initialiseMedia(MediaPlayerBase.TYPE.AUDIO, '', '', sourceContainer);
expect(player.initialiseMedia).toHaveBeenCalledWith(MediaPlayerBase.TYPE.LIVE_AUDIO, '', '', sourceContainer, undefined);
});
expect(player.initialiseMedia).toHaveBeenCalledWith(MediaPlayerBase.TYPE.LIVE_AUDIO, '', '', sourceContainer, undefined);
});
});
describe('Pausing and Auto-Resume', function () {
var mockCallback = [];
describe('Pausing and Auto-Resume', function () {
var mockCallback = [];
function startPlaybackAndPause (startTime, disableAutoResume) {
seekableMediaPlayer.beginPlaybackFrom(startTime || 0);
seekableMediaPlayer.pause({disableAutoResume: disableAutoResume});
}
function startPlaybackAndPause (startTime, disableAutoResume) {
seekableMediaPlayer.beginPlaybackFrom(startTime || 0);
seekableMediaPlayer.pause({disableAutoResume: disableAutoResume});
}
beforeEach(function () {
jasmine.clock().install();
jasmine.clock().mockDate();
beforeEach(function () {
jasmine.clock().install();
jasmine.clock().mockDate();
initialiseSeekableMediaPlayer();
initialiseSeekableMediaPlayer();
player.getSeekableRange.and.returnValue({start: 0});
player.getCurrentTime.and.returnValue(20);
player.getSeekableRange.and.returnValue({start: 0});
player.getCurrentTime.and.returnValue(20);
player.addEventCallback.and.callFake(function (self, callback) {
mockCallback.push(callback);
});
player.addEventCallback.and.callFake(function (self, callback) {
mockCallback.push(callback);
});
});
afterEach(function () {
jasmine.clock().uninstall();
mockCallback = [];
});
afterEach(function () {
jasmine.clock().uninstall();
mockCallback = [];
});
it('calls resume when approaching the start of the buffer', function () {
startPlaybackAndPause(20, false);
it('calls resume when approaching the start of the buffer', function () {
startPlaybackAndPause(20, false);
jasmine.clock().tick(12 * 1000);
jasmine.clock().tick(12 * 1000);
expect(player.resume).toHaveBeenCalledWith();
});
expect(player.resume).toHaveBeenCalledWith();
});
it('does not call resume when approaching the start of the buffer with the disableAutoResume option', function () {
startPlaybackAndPause(20, true);
it('does not call resume when approaching the start of the buffer with the disableAutoResume option', function () {
startPlaybackAndPause(20, true);
jasmine.clock().tick(11 * 1000);
jasmine.clock().tick(11 * 1000);
expect(player.resume).not.toHaveBeenCalledWith();
});
expect(player.resume).not.toHaveBeenCalledWith();
});
it('does not call resume if paused after the auto resume point', function () {
startPlaybackAndPause(20, false);
it('does not call resume if paused after the auto resume point', function () {
startPlaybackAndPause(20, false);
jasmine.clock().tick(11 * 1000);
jasmine.clock().tick(11 * 1000);
expect(player.resume).not.toHaveBeenCalledWith();
});
expect(player.resume).not.toHaveBeenCalledWith();
});
it('does not auto-resume if the video is no longer paused', function () {
startPlaybackAndPause(20, false);
it('does not auto-resume if the video is no longer paused', function () {
startPlaybackAndPause(20, false);
for (var index = 0; index < mockCallback.length; index++) {
mockCallback[index]({state: MediaPlayerBase.STATE.PLAYING});
}
for (var index = 0; index < mockCallback.length; index++) {
mockCallback[index]({state: MediaPlayerBase.STATE.PLAYING});
}
jasmine.clock().tick(12 * 1000);
jasmine.clock().tick(12 * 1000);
expect(player.resume).not.toHaveBeenCalled();
});
expect(player.resume).not.toHaveBeenCalled();
});
it('Calls resume when paused is called multiple times', function () {
startPlaybackAndPause(0, false);
it('Calls resume when paused is called multiple times', function () {
startPlaybackAndPause(0, false);
var event = {state: MediaPlayerBase.STATE.PLAYING, currentTime: 25};
for (var index = 0; index < mockCallback.length; index++) {
mockCallback[index](event);
}
var event = {state: MediaPlayerBase.STATE.PLAYING, currentTime: 25};
for (var index = 0; index < mockCallback.length; index++) {
mockCallback[index](event);
}
seekableMediaPlayer.pause();
seekableMediaPlayer.pause();
event.currentTime = 30;
for (index = 0; index < mockCallback.length; index++) {
mockCallback[index](event);
}
event.currentTime = 30;
for (index = 0; index < mockCallback.length; index++) {
mockCallback[index](event);
}
seekableMediaPlayer.pause();
// uses real time to determine pause intervals
// if debugging the time to the buffer will be decreased by the time spent.
jasmine.clock().tick(22 * 1000);
seekableMediaPlayer.pause();
// uses real time to determine pause intervals
// if debugging the time to the buffer will be decreased by the time spent.
jasmine.clock().tick(22 * 1000);
expect(player.resume).toHaveBeenCalledTimes(1);
});
expect(player.resume).toHaveBeenCalledTimes(1);
});
it('calls auto-resume immeditetly if paused after an autoresume', function () {
startPlaybackAndPause(20, false);
it('calls auto-resume immeditetly if paused after an autoresume', function () {
startPlaybackAndPause(20, false);
jasmine.clock().tick(12 * 1000);
jasmine.clock().tick(12 * 1000);
player.getSeekableRange.and.returnValue({start: 12});
player.getSeekableRange.and.returnValue({start: 12});
seekableMediaPlayer.pause();
seekableMediaPlayer.pause();
jasmine.clock().tick(1);
jasmine.clock().tick(1);
expect(player.resume).toHaveBeenCalledTimes(1);
expect(player.toPaused).toHaveBeenCalledTimes(1);
expect(player.toPlaying).toHaveBeenCalledTimes(1);
});
expect(player.resume).toHaveBeenCalledTimes(1);
expect(player.toPaused).toHaveBeenCalledTimes(1);
expect(player.toPlaying).toHaveBeenCalledTimes(1);
});
it('does not calls autoresume immeditetly if paused after an auto-resume with disableAutoResume options', function () {
startPlaybackAndPause(20, true);
it('does not calls autoresume immeditetly if paused after an auto-resume with disableAutoResume options', function () {
startPlaybackAndPause(20, true);
jasmine.clock().tick(12 * 1000);
player.getSeekableRange.and.returnValue({start: 12});
jasmine.clock().tick(12 * 1000);
player.getSeekableRange.and.returnValue({start: 12});
jasmine.clock().tick(1);
jasmine.clock().tick(1);
expect(player.resume).not.toHaveBeenCalledTimes(1);
});
expect(player.resume).not.toHaveBeenCalledTimes(1);
});
it('auto-resume is not cancelled by a paused event state', function () {
startPlaybackAndPause(20, false);
it('auto-resume is not cancelled by a paused event state', function () {
startPlaybackAndPause(20, false);
for (var index = 0; index < mockCallback.length; index++) {
mockCallback[index]({state: MediaPlayerBase.STATE.PAUSED});
}
for (var index = 0; index < mockCallback.length; index++) {
mockCallback[index]({state: MediaPlayerBase.STATE.PAUSED});
}
jasmine.clock().tick(12 * 1000);
jasmine.clock().tick(12 * 1000);
expect(player.resume).toHaveBeenCalledTimes(1);
});
expect(player.resume).toHaveBeenCalledTimes(1);
});
it('will fake pause if attempting to pause at the start of playback ', function () {
player.getCurrentTime.and.returnValue(0);
startPlaybackAndPause(0, false);
it('will fake pause if attempting to pause at the start of playback ', function () {
player.getCurrentTime.and.returnValue(0);
startPlaybackAndPause(0, false);
expect(player.toPaused).toHaveBeenCalledTimes(1);
expect(player.toPlaying).toHaveBeenCalledTimes(1);
});
expect(player.toPaused).toHaveBeenCalledTimes(1);
expect(player.toPlaying).toHaveBeenCalledTimes(1);
});
it('time spend buffering is deducted when considering time to auto-resume', function () {
startPlaybackAndPause(0, false);
it('time spend buffering is deducted when considering time to auto-resume', function () {
startPlaybackAndPause(0, false);
seekableMediaPlayer.resume();
player.resume.calls.reset();
seekableMediaPlayer.resume();
player.resume.calls.reset();
for (var index = 0; index < mockCallback.length; index++) {
mockCallback[index]({state: MediaPlayerBase.STATE.BUFFERING, currentTime: 20});
}
for (var index = 0; index < mockCallback.length; index++) {
mockCallback[index]({state: MediaPlayerBase.STATE.BUFFERING, currentTime: 20});
}
jasmine.clock().tick(11 * 1000);
jasmine.clock().tick(11 * 1000);
for (index = 0; index < mockCallback.length; index++) {
mockCallback[index]({state: MediaPlayerBase.STATE.PLAYING, currentTime: 20});
}
player.getSeekableRange.and.returnValue({start: 20});
for (index = 0; index < mockCallback.length; index++) {
mockCallback[index]({state: MediaPlayerBase.STATE.PLAYING, currentTime: 20});
}
player.getSeekableRange.and.returnValue({start: 20});
seekableMediaPlayer.pause();
seekableMediaPlayer.pause();
jasmine.clock().tick(3 * 1000);
jasmine.clock().tick(3 * 1000);
expect(player.toPlaying).toHaveBeenCalledTimes(1);
});
expect(player.toPlaying).toHaveBeenCalledTimes(1);
});
it('does not calls autoresume immeditetly if paused after an auto-resume with disableAutoResume options', function () {
startPlaybackAndPause(20, true);
it('does not calls autoresume immeditetly if paused after an auto-resume with disableAutoResume options', function () {
startPlaybackAndPause(20, true);
jasmine.clock().tick(12 * 1000);
jasmine.clock().tick(12 * 1000);
jasmine.clock().tick(1);
jasmine.clock().tick(1);
expect(player.resume).not.toHaveBeenCalledTimes(1);
});
expect(player.resume).not.toHaveBeenCalledTimes(1);
});
});
});
});

118

script-test/playbackstrategies/nativestrategytest.js

@@ -8,83 +8,83 @@ require(

],
function (WindowTypes, LiveSupport, MediaSources, Squire) {
describe('Native Strategy', function () {
var nativeStrategy;
var html5player;
var livePlayer;
var mediaPlayer;
function (WindowTypes, LiveSupport, MediaSources, Squire) {
describe('Native Strategy', function () {
var nativeStrategy;
var html5player;
var livePlayer;
var mediaPlayer;
var mockLegacyAdapter;
var mockDevice;
var mockConfig = 'config';
var mockLegacyAdapter;
var mockDevice;
var mockConfig = 'config';
var mediaKind = 'mediaKind';
var playbackElement = 'playbackElement';
var isUHD = 'isUHD';
var mediaSources;
var mediaKind = 'mediaKind';
var playbackElement = 'playbackElement';
var isUHD = 'isUHD';
var mediaSources;
beforeEach(function (done) {
var mediaSourceCallbacks = jasmine.createSpyObj('mediaSourceCallbacks', ['onSuccess', 'onError']);
mediaSources = new MediaSources([{url: 'http://a', cdn: 'supplierA'}], new Date(), WindowTypes.STATIC, LiveSupport.SEEKABLE, mediaSourceCallbacks);
beforeEach(function (done) {
var mediaSourceCallbacks = jasmine.createSpyObj('mediaSourceCallbacks', ['onSuccess', 'onError']);
mediaSources = new MediaSources([{url: 'http://a', cdn: 'supplierA'}], new Date(), WindowTypes.STATIC, LiveSupport.SEEKABLE, mediaSourceCallbacks);
var injector = new Squire();
var injector = new Squire();
mockDevice = jasmine.createSpyObj('mockDevice', ['getConfig', 'getLogger']);
mockDevice = jasmine.createSpyObj('mockDevice', ['getConfig', 'getLogger']);
mockLegacyAdapter = jasmine.createSpy('LegacyAdapter');
mediaPlayer = jasmine.createSpy('MediaPlayer');
html5player = jasmine.createSpy('Html5Player');
livePlayer = jasmine.createSpy('LivePlayer');
mockLegacyAdapter = jasmine.createSpy('LegacyAdapter');
mediaPlayer = jasmine.createSpy('MediaPlayer');
html5player = jasmine.createSpy('Html5Player');
livePlayer = jasmine.createSpy('LivePlayer');
html5player.and.returnValue(mediaPlayer);
livePlayer.and.returnValue(mediaPlayer);
html5player.and.returnValue(mediaPlayer);
livePlayer.and.returnValue(mediaPlayer);
mockDevice.getConfig.and.returnValue(
mockConfig
);
mockDevice.getConfig.and.returnValue(
mockConfig
);
injector.mock({
'bigscreenplayer/playbackstrategy/legacyplayeradapter': mockLegacyAdapter,
'bigscreenplayer/playbackstrategy/modifiers/html5': html5player,
'bigscreenplayer/playbackstrategy/modifiers/live/playable': livePlayer
});
injector.require(['bigscreenplayer/playbackstrategy/nativestrategy'], function (strategy) {
nativeStrategy = strategy;
done();
});
injector.mock({
'bigscreenplayer/playbackstrategy/legacyplayeradapter': mockLegacyAdapter,
'bigscreenplayer/playbackstrategy/modifiers/html5': html5player,
'bigscreenplayer/playbackstrategy/modifiers/live/playable': livePlayer
});
afterEach(function () {
window.bigscreenPlayer.liveSupport = LiveSupport.PLAYABLE;
injector.require(['bigscreenplayer/playbackstrategy/nativestrategy'], function (strategy) {
nativeStrategy = strategy;
done();
});
});
it('calls LegacyAdapter with a static media player when called for STATIC window', function () {
var windowType = WindowTypes.STATIC;
nativeStrategy(mediaSources, windowType, mediaKind, playbackElement, isUHD, mockDevice);
afterEach(function () {
window.bigscreenPlayer.liveSupport = LiveSupport.PLAYABLE;
});
expect(html5player).toHaveBeenCalledWith(mockConfig);
it('calls LegacyAdapter with a static media player when called for STATIC window', function () {
var windowType = WindowTypes.STATIC;
nativeStrategy(mediaSources, windowType, mediaKind, playbackElement, isUHD, mockDevice);
expect(mockLegacyAdapter).toHaveBeenCalledWith(mediaSources, windowType, playbackElement, isUHD, mockConfig, mediaPlayer);
});
expect(html5player).toHaveBeenCalledWith(mockConfig);
it('calls LegacyAdapter with a live media player when called for a GROWING window', function () {
var windowType = WindowTypes.GROWING;
nativeStrategy(mediaSources, windowType, mediaKind, playbackElement, isUHD, mockDevice);
expect(mockLegacyAdapter).toHaveBeenCalledWith(mediaSources, windowType, playbackElement, isUHD, mockConfig, mediaPlayer);
});
expect(html5player).toHaveBeenCalledWith(mockConfig);
expect(livePlayer).toHaveBeenCalledWith(mediaPlayer, mockConfig, WindowTypes.GROWING, mediaSources);
it('calls LegacyAdapter with a live media player when called for a GROWING window', function () {
var windowType = WindowTypes.GROWING;
nativeStrategy(mediaSources, windowType, mediaKind, playbackElement, isUHD, mockDevice);
expect(mockLegacyAdapter).toHaveBeenCalledWith(mediaSources, windowType, playbackElement, isUHD, mockConfig, mediaPlayer);
});
expect(html5player).toHaveBeenCalledWith(mockConfig);
expect(livePlayer).toHaveBeenCalledWith(mediaPlayer, mockConfig, WindowTypes.GROWING, mediaSources);
it('calls LegacyAdapter with a live media player when called for a SLIDING window', function () {
var windowType = WindowTypes.SLIDING;
nativeStrategy(mediaSources, windowType, mediaKind, playbackElement, isUHD, mockDevice);
expect(mockLegacyAdapter).toHaveBeenCalledWith(mediaSources, windowType, playbackElement, isUHD, mockConfig, mediaPlayer);
});
expect(html5player).toHaveBeenCalledWith(mockConfig);
expect(livePlayer).toHaveBeenCalledWith(mediaPlayer, mockConfig, WindowTypes.SLIDING, mediaSources);
it('calls LegacyAdapter with a live media player when called for a SLIDING window', function () {
var windowType = WindowTypes.SLIDING;
nativeStrategy(mediaSources, windowType, mediaKind, playbackElement, isUHD, mockDevice);
expect(mockLegacyAdapter).toHaveBeenCalledWith(mediaSources, windowType, playbackElement, isUHD, mockConfig, mediaPlayer);
});
expect(html5player).toHaveBeenCalledWith(mockConfig);
expect(livePlayer).toHaveBeenCalledWith(mediaPlayer, mockConfig, WindowTypes.SLIDING, mediaSources);
expect(mockLegacyAdapter).toHaveBeenCalledWith(mediaSources, windowType, playbackElement, isUHD, mockConfig, mediaPlayer);
});
});
});

16

script-test/version.js
require(
['bigscreenplayer/version'],
function (Version) {
'use strict';
describe('Version ', function () {
it('should return a semver string', function () {
expect(Version).toMatch(/^[0-9]+\.[0-9]+\.[0-9]+$/);
});
['bigscreenplayer/version'],
function (Version) {
'use strict';
describe('Version ', function () {
it('should return a semver string', function () {
expect(Version).toMatch(/^[0-9]+\.[0-9]+\.[0-9]+$/);
});
}
});
}
);

12

script/allowedmediatransitions.js

@@ -10,9 +10,9 @@ define(

var MediaPlayerState = {
EMPTY: 'EMPTY', // No source set
STOPPED: 'STOPPED', // Source set but no playback
EMPTY: 'EMPTY', // No source set
STOPPED: 'STOPPED', // Source set but no playback
BUFFERING: 'BUFFERING', // Not enough data to play, waiting to download more
PLAYING: 'PLAYING', // Media is playing
PAUSED: 'PAUSED', // Media is paused
COMPLETE: 'COMPLETE', // Media has reached its end point
ERROR: 'ERROR' // An error occurred
PLAYING: 'PLAYING', // Media is playing
PAUSED: 'PAUSED', // Media is paused
COMPLETE: 'COMPLETE', // Media has reached its end point
ERROR: 'ERROR' // An error occurred
};

@@ -19,0 +19,0 @@

190

script/debugger/chronicle.js
define('bigscreenplayer/debugger/chronicle',
function () {
'use strict';
var chronicle = [];
var firstTimeElement;
var compressTime;
var updateCallbacks = [];
function () {
'use strict';
var chronicle = [];
var firstTimeElement;
var compressTime;
var updateCallbacks = [];
var TYPES = {
INFO: 'info',
ERROR: 'error',
EVENT: 'event',
APICALL: 'apicall',
TIME: 'time',
KEYVALUE: 'keyvalue'
};
var TYPES = {
INFO: 'info',
ERROR: 'error',
EVENT: 'event',
APICALL: 'apicall',
TIME: 'time',
KEYVALUE: 'keyvalue'
};
function init () {
clear();
}
function init () {
clear();
}
function clear () {
firstTimeElement = true;
compressTime = false;
chronicle = [];
}
function clear () {
firstTimeElement = true;
compressTime = false;
chronicle = [];
}
function registerForUpdates (callback) {
updateCallbacks.push(callback);
}
function registerForUpdates (callback) {
updateCallbacks.push(callback);
}
function unregisterForUpdates (callback) {
var indexOf = updateCallbacks.indexOf(callback);
if (indexOf !== -1) {
updateCallbacks.splice(indexOf, 1);
function unregisterForUpdates (callback) {
var indexOf = updateCallbacks.indexOf(callback);
if (indexOf !== -1) {
updateCallbacks.splice(indexOf, 1);
}
}
}
function info (message) {
pushToChronicle({type: TYPES.INFO, message: message});
}
function info (message) {
pushToChronicle({type: TYPES.INFO, message: message});
}
function error (err) {
pushToChronicle({type: TYPES.ERROR, error: err});
}
function error (err) {
pushToChronicle({type: TYPES.ERROR, error: err});
}
function event (event) {
pushToChronicle({type: TYPES.EVENT, event: event});
}
function event (event) {
pushToChronicle({type: TYPES.EVENT, event: event});
}
function apicall (callType) {
pushToChronicle({type: TYPES.APICALL, calltype: callType});
}
function apicall (callType) {
pushToChronicle({type: TYPES.APICALL, calltype: callType});
}
function time (time) {
if (firstTimeElement) {
pushToChronicle({type: TYPES.TIME, currentTime: time});
firstTimeElement = false;
} else if (!compressTime) {
pushToChronicle({type: TYPES.TIME, currentTime: time});
compressTime = true;
} else {
var lastElement = chronicle.pop();
lastElement.currentTime = time;
pushToChronicle(lastElement);
function time (time) {
if (firstTimeElement) {
pushToChronicle({type: TYPES.TIME, currentTime: time});
firstTimeElement = false;
} else if (!compressTime) {
pushToChronicle({type: TYPES.TIME, currentTime: time});
compressTime = true;
} else {
var lastElement = chronicle.pop();
lastElement.currentTime = time;
pushToChronicle(lastElement);
}
}
}
function keyValue (obj) {
pushToChronicle({type: TYPES.KEYVALUE, keyvalue: obj});
}
function keyValue (obj) {
pushToChronicle({type: TYPES.KEYVALUE, keyvalue: obj});
}
function retrieve () {
return chronicle.slice();
}
function retrieve () {
return chronicle.slice();
}
function timestamp (obj) {
obj.timestamp = new Date().getTime();
}
function timestamp (obj) {
obj.timestamp = new Date().getTime();
}
function pushToChronicle (obj) {
if (obj.type !== TYPES.TIME) {
firstTimeElement = true;
compressTime = false;
function pushToChronicle (obj) {
if (obj.type !== TYPES.TIME) {
firstTimeElement = true;
compressTime = false;
}
timestamp(obj);
chronicle.push(obj);
updates();
}
timestamp(obj);
chronicle.push(obj);
updates();
}
function updates () {
updateCallbacks.forEach(function (callback) {
callback(retrieve());
});
}
function updates () {
updateCallbacks.forEach(function (callback) {
callback(retrieve());
});
}
function tearDown () {
clear();
}
function tearDown () {
clear();
}
return {
init: init,
TYPES: TYPES,
clear: clear,
info: info,
error: error,
event: event,
apicall: apicall,
time: time,
keyValue: keyValue,
retrieve: retrieve,
tearDown: tearDown,
registerForUpdates: registerForUpdates,
unregisterForUpdates: unregisterForUpdates
};
});
return {
init: init,
TYPES: TYPES,
clear: clear,
info: info,
error: error,
event: event,
apicall: apicall,
time: time,
keyValue: keyValue,
retrieve: retrieve,
tearDown: tearDown,
registerForUpdates: registerForUpdates,
unregisterForUpdates: unregisterForUpdates
};
});

176

script/debugger/debugpresenter.js

@@ -6,104 +6,104 @@ define('bigscreenplayer/debugger/debugpresenter',

],
function (MediaState, Chronicle) {
'use strict';
var view;
function (MediaState, Chronicle) {
'use strict';
var view;
function init (newView) {
view = newView;
}
function init (newView) {
view = newView;
}
function update (logs) {
view.render({ static: parseStaticFields(logs), dynamic: parseDynamicFields(logs) });
}
function update (logs) {
view.render({ static: parseStaticFields(logs), dynamic: parseDynamicFields(logs) });
}
function parseStaticFields (logs) {
var latestStaticFields = [];
var staticFields = logs.filter(function (log) {
return isStaticLog(log);
});
function parseStaticFields (logs) {
var latestStaticFields = [];
var staticFields = logs.filter(function (log) {
return isStaticLog(log);
});
var uniqueKeys = findUniqueKeys(staticFields);
uniqueKeys.forEach(function (key) {
var matchingStaticLogs = staticFields.filter(function (log) {
return log.keyvalue.key === key;
});
latestStaticFields.push(matchingStaticLogs.pop());
});
var uniqueKeys = findUniqueKeys(staticFields);
uniqueKeys.forEach(function (key) {
var matchingStaticLogs = staticFields.filter(function (log) {
return log.keyvalue.key === key;
});
latestStaticFields.push(matchingStaticLogs.pop());
});
return latestStaticFields.map(function (field) {
return {key: sanitiseKeyString(field.keyvalue.key), value: sanitiseValueString(field.keyvalue.value)};
});
}
return latestStaticFields.map(function (field) {
return {key: sanitiseKeyString(field.keyvalue.key), value: sanitiseValueString(field.keyvalue.value)};
});
}
function parseDynamicFields (logs) {
var dynamicLogs;
function parseDynamicFields (logs) {
var dynamicLogs;
dynamicLogs = logs.filter(function (log) {
return !isStaticLog(log);
}).map(function (log) {
var dateString = new Date(log.timestamp).toISOString();
switch (log.type) {
case Chronicle.TYPES.INFO:
return dateString + ' - Info: ' + log.message;
case Chronicle.TYPES.TIME:
return dateString + ' - Video time: ' + parseFloat(log.currentTime).toFixed(2);
case Chronicle.TYPES.EVENT:
return dateString + ' - Event: ' + convertToReadableEvent(log.event.state);
case Chronicle.TYPES.ERROR:
return dateString + ' - Error: ' + log.error.errorId + ' | ' + log.error.message;
case Chronicle.TYPES.APICALL:
return dateString + ' - Api call: ' + log.calltype;
default:
return dateString + ' - Unknown log format';
}
});
dynamicLogs = logs.filter(function (log) {
return !isStaticLog(log);
}).map(function (log) {
var dateString = new Date(log.timestamp).toISOString();
switch (log.type) {
case Chronicle.TYPES.INFO:
return dateString + ' - Info: ' + log.message;
case Chronicle.TYPES.TIME:
return dateString + ' - Video time: ' + parseFloat(log.currentTime).toFixed(2);
case Chronicle.TYPES.EVENT:
return dateString + ' - Event: ' + convertToReadableEvent(log.event.state);
case Chronicle.TYPES.ERROR:
return dateString + ' - Error: ' + log.error.errorId + ' | ' + log.error.message;
case Chronicle.TYPES.APICALL:
return dateString + ' - Api call: ' + log.calltype;
default:
return dateString + ' - Unknown log format';
}
});
return dynamicLogs;
}
return dynamicLogs;
}
function isStaticLog (log) {
return log.type === Chronicle.TYPES.KEYVALUE;
}
function isStaticLog (log) {
return log.type === Chronicle.TYPES.KEYVALUE;
}
function findUniqueKeys (logs) {
var uniqueKeys = [];
logs.forEach(function (log) {
if (uniqueKeys.indexOf(log.keyvalue.key) === -1) {
uniqueKeys.push(log.keyvalue.key);
}
});
return uniqueKeys;
}
function findUniqueKeys (logs) {
var uniqueKeys = [];
logs.forEach(function (log) {
if (uniqueKeys.indexOf(log.keyvalue.key) === -1) {
uniqueKeys.push(log.keyvalue.key);
}
});
return uniqueKeys;
}
function sanitiseKeyString (key) {
return key.replace(/([A-Z])/g, ' $1').toLowerCase();
}
function sanitiseKeyString (key) {
return key.replace(/([A-Z])/g, ' $1').toLowerCase();
}
function sanitiseValueString (value) {
if (value instanceof Date) {
var hours = zeroPadTimeUnits(value.getHours()) + value.getHours();
var mins = zeroPadTimeUnits(value.getMinutes()) + value.getMinutes();
var secs = zeroPadTimeUnits(value.getSeconds()) + value.getSeconds();
return hours + ':' + mins + ':' + secs;
}
return value;
}
function sanitiseValueString (value) {
if (value instanceof Date) {
var hours = zeroPadTimeUnits(value.getHours()) + value.getHours();
var mins = zeroPadTimeUnits(value.getMinutes()) + value.getMinutes();
var secs = zeroPadTimeUnits(value.getSeconds()) + value.getSeconds();
return hours + ':' + mins + ':' + secs;
}
return value;
}
function zeroPadTimeUnits (unit) {
return (unit < 10 ? '0' : '');
}
function zeroPadTimeUnits (unit) {
return (unit < 10 ? '0' : '');
}
function convertToReadableEvent (type) {
for (var key in MediaState) {
if (MediaState[key] === type) {
return key;
}
}
return type;
}
function convertToReadableEvent (type) {
for (var key in MediaState) {
if (MediaState[key] === type) {
return key;
}
}
return type;
}
return {
init: init,
update: update
};
});
return {
init: init,
update: update
};
});

136

script/debugger/debugtool.js

@@ -7,81 +7,81 @@ define('bigscreenplayer/debugger/debugtool',

],
function (Chronicle, DebugPresenter, DebugView) {
'use strict';
function DebugTool () {
var rootElement;
var presenter = DebugPresenter;
var view;
var visible = false;
function (Chronicle, DebugPresenter, DebugView) {
'use strict';
function DebugTool () {
var rootElement;
var presenter = DebugPresenter;
var view;
var visible = false;
var staticFieldValues = {};
var staticFieldValues = {};
function toggleVisibility () {
if (visible) {
hide();
} else {
show();
}
}
function toggleVisibility () {
if (visible) {
hide();
} else {
show();
}
}
function show () {
view = DebugView;
view.setRootElement(rootElement);
view.init();
presenter.init(view);
presenter.update(Chronicle.retrieve());
Chronicle.registerForUpdates(presenter.update);
visible = true;
}
function show () {
view = DebugView;
view.setRootElement(rootElement);
view.init();
presenter.init(view);
presenter.update(Chronicle.retrieve());
Chronicle.registerForUpdates(presenter.update);
visible = true;
}
function hide () {
view.tearDown();
Chronicle.unregisterForUpdates(presenter.update);
visible = false;
}
function hide () {
view.tearDown();
Chronicle.unregisterForUpdates(presenter.update);
visible = false;
}
function updateKeyValue (message) {
var staticFieldValue = staticFieldValues[message.key];
function updateKeyValue (message) {
var staticFieldValue = staticFieldValues[message.key];
if (staticFieldValue) {
var entry = Chronicle.retrieve()[staticFieldValue.index];
if (entry) {
entry.keyvalue = message;
}
} else {
staticFieldValues[message.key] = {value: message.value, index: Chronicle.retrieve().length};
Chronicle.keyValue(message);
}
}
if (staticFieldValue) {
var entry = Chronicle.retrieve()[staticFieldValue.index];
if (entry) {
entry.keyvalue = message;
}
} else {
staticFieldValues[message.key] = {value: message.value, index: Chronicle.retrieve().length};
Chronicle.keyValue(message);
}
}
function setRootElement (element) {
rootElement = element;
}
function setRootElement (element) {
rootElement = element;
}
function tearDown () {
staticFieldValues = {};
if (visible) {
hide();
}
}
function tearDown () {
staticFieldValues = {};
if (visible) {
hide();
}
}
return {
toggleVisibility: toggleVisibility,
setRootElement: setRootElement,
info: Chronicle.info,
error: Chronicle.error,
event: Chronicle.event,
time: Chronicle.time,
apicall: Chronicle.apicall,
keyValue: updateKeyValue,
tearDown: tearDown
};
}
return {
toggleVisibility: toggleVisibility,
setRootElement: setRootElement,
info: Chronicle.info,
error: Chronicle.error,
event: Chronicle.event,
time: Chronicle.time,
apicall: Chronicle.apicall,
keyValue: updateKeyValue,
tearDown: tearDown
};
}
var instance;
var instance;
if (instance === undefined) {
instance = new DebugTool();
}
if (instance === undefined) {
instance = new DebugTool();
}
return instance;
});
return instance;
});

170

script/debugger/debugview.js
define('bigscreenplayer/debugger/debugview',
function () {
'use strict';
var appElement, logBox, logContainer, staticContainer, staticBox;
function () {
'use strict';
var appElement, logBox, logContainer, staticContainer, staticBox;
function init () {
logBox = document.createElement('div');
logContainer = document.createElement('span');
staticBox = document.createElement('div');
staticContainer = document.createElement('span');
function init () {
logBox = document.createElement('div');
logContainer = document.createElement('span');
staticBox = document.createElement('div');
staticContainer = document.createElement('span');
if (appElement === undefined) {
appElement = document.body;
}
if (appElement === undefined) {
appElement = document.body;
}
logBox.id = 'logBox';
logBox.style.position = 'absolute';
logBox.style.width = '63%';
logBox.style.left = '5%';
logBox.style.top = '15%';
logBox.style.bottom = '25%';
logBox.style.backgroundColor = '#1D1D1D';
logBox.style.opacity = 0.9;
logBox.style.overflow = 'hidden';
logBox.id = 'logBox';
logBox.style.position = 'absolute';
logBox.style.width = '63%';
logBox.style.left = '5%';
logBox.style.top = '15%';
logBox.style.bottom = '25%';
logBox.style.backgroundColor = '#1D1D1D';
logBox.style.opacity = 0.9;
logBox.style.overflow = 'hidden';
staticBox.id = 'staticBox';
staticBox.style.position = 'absolute';
staticBox.style.width = '26%';
staticBox.style.right = '5%';
staticBox.style.top = '15%';
staticBox.style.bottom = '25%';
staticBox.style.backgroundColor = '#1D1D1D';
staticBox.style.opacity = 0.9;
staticBox.style.overflow = 'hidden';
staticBox.id = 'staticBox';
staticBox.style.position = 'absolute';
staticBox.style.width = '26%';
staticBox.style.right = '5%';
staticBox.style.top = '15%';
staticBox.style.bottom = '25%';
staticBox.style.backgroundColor = '#1D1D1D';
staticBox.style.opacity = 0.9;
staticBox.style.overflow = 'hidden';
logContainer.id = 'logContainer';
logContainer.style.color = '#ffffff';
logContainer.style.fontSize = '11pt';
logContainer.style.position = 'absolute';
logContainer.style.bottom = '1%';
logContainer.style.left = '1%';
logContainer.style.wordWrap = 'break-word';
logContainer.style.whiteSpace = 'pre-line';
logContainer.id = 'logContainer';
logContainer.style.color = '#ffffff';
logContainer.style.fontSize = '11pt';
logContainer.style.position = 'absolute';
logContainer.style.bottom = '1%';
logContainer.style.left = '1%';
logContainer.style.wordWrap = 'break-word';
logContainer.style.whiteSpace = 'pre-line';
staticContainer.id = 'staticContainer';
staticContainer.style.color = '#ffffff';
staticContainer.style.fontSize = '11pt';
staticContainer.style.wordWrap = 'break-word';
staticContainer.style.left = '1%';
staticContainer.style.whiteSpace = 'pre-line';
staticContainer.id = 'staticContainer';
staticContainer.style.color = '#ffffff';
staticContainer.style.fontSize = '11pt';
staticContainer.style.wordWrap = 'break-word';
staticContainer.style.left = '1%';
staticContainer.style.whiteSpace = 'pre-line';
logBox.appendChild(logContainer);
staticBox.appendChild(staticContainer);
appElement.appendChild(logBox);
appElement.appendChild(staticBox);
}
logBox.appendChild(logContainer);
staticBox.appendChild(staticContainer);
appElement.appendChild(logBox);
appElement.appendChild(staticBox);
}
function setRootElement (root) {
if (root) {
appElement = root;
}
}
function setRootElement (root) {
if (root) {
appElement = root;
}
}
function render (logData) {
var dynamicLogs = logData.dynamic;
var LINES_TO_DISPLAY = 29;
if (dynamicLogs.length === 0) {
logContainer.innerHTML = '';
}
function render (logData) {
var dynamicLogs = logData.dynamic;
var LINES_TO_DISPLAY = 29;
if (dynamicLogs.length === 0) {
logContainer.innerHTML = '';
}
dynamicLogs = dynamicLogs.slice(-LINES_TO_DISPLAY);
logContainer.innerHTML = dynamicLogs.join('\n');
dynamicLogs = dynamicLogs.slice(-LINES_TO_DISPLAY);
logContainer.innerHTML = dynamicLogs.join('\n');
var staticLogString = '';
logData.static.forEach(function (log) {
staticLogString = staticLogString + log.key + ': ' + log.value + '\n\n';
});
var staticLogString = '';
logData.static.forEach(function (log) {
staticLogString = staticLogString + log.key + ': ' + log.value + '\n\n';
});
staticContainer.innerHTML = staticLogString;
}
staticContainer.innerHTML = staticLogString;
}
function tearDown () {
if (appElement) {
appElement.removeChild(document.getElementById('logBox'));
appElement.removeChild(document.getElementById('staticBox'));
appElement = undefined;
}
staticContainer = undefined;
logContainer = undefined;
logBox = undefined;
staticBox = undefined;
}
function tearDown () {
if (appElement) {
appElement.removeChild(document.getElementById('logBox'));
appElement.removeChild(document.getElementById('staticBox'));
appElement = undefined;
}
staticContainer = undefined;
logContainer = undefined;
logBox = undefined;
staticBox = undefined;
}
return {
init: init,
setRootElement: setRootElement,
render: render,
tearDown: tearDown
};
});
return {
init: init,
setRootElement: setRootElement,
render: render,
tearDown: tearDown
};
});

300

script/mediasources.js

@@ -14,196 +14,196 @@ define('bigscreenplayer/mediasources',

],
function (PlaybackUtils, WindowTypes, Plugins, PluginEnums, PluginData, DebugTool, ManifestLoader, PlaybackStrategy, TransferFormats, LiveSupport) {
'use strict';
return function () {
var mediaSources;
var windowType;
var liveSupport;
var serverDate;
var time = {};
var transferFormat;
function (PlaybackUtils, WindowTypes, Plugins, PluginEnums, PluginData, DebugTool, ManifestLoader, PlaybackStrategy, TransferFormats, LiveSupport) {
'use strict';
return function () {
var mediaSources;
var windowType;
var liveSupport;
var serverDate;
var time = {};
var transferFormat;
function init (urls, newServerDate, newWindowType, newLiveSupport, callbacks) {
if (urls === undefined || urls.length === 0) {
throw new Error('Media Sources urls are undefined');
}
function init (urls, newServerDate, newWindowType, newLiveSupport, callbacks) {
if (urls === undefined || urls.length === 0) {
throw new Error('Media Sources urls are undefined');
}
if (callbacks === undefined ||
if (callbacks === undefined ||
callbacks.onSuccess === undefined ||
callbacks.onError === undefined) {
throw new Error('Media Sources callbacks are undefined');
}
throw new Error('Media Sources callbacks are undefined');
}
windowType = newWindowType;
liveSupport = newLiveSupport;
serverDate = newServerDate;
mediaSources = PlaybackUtils.cloneArray(urls);
updateDebugOutput();
windowType = newWindowType;
liveSupport = newLiveSupport;
serverDate = newServerDate;
mediaSources = PlaybackUtils.cloneArray(urls);
updateDebugOutput();
if (needToGetManifest(windowType, liveSupport)) {
loadManifest(serverDate, callbacks);
} else {
callbacks.onSuccess();
if (needToGetManifest(windowType, liveSupport)) {
loadManifest(serverDate, callbacks);
} else {
callbacks.onSuccess();
}
}
}
function failover (postFailoverAction, failoverErrorAction, failoverParams) {
if (shouldFailover(failoverParams)) {
emitCdnFailover(failoverParams);
updateCdns();
updateDebugOutput();
function failover (postFailoverAction, failoverErrorAction, failoverParams) {
if (shouldFailover(failoverParams)) {
emitCdnFailover(failoverParams);
updateCdns();
updateDebugOutput();
if (needToGetManifest(windowType, liveSupport)) {
loadManifest(serverDate, { onSuccess: postFailoverAction, onError: failoverErrorAction });
if (needToGetManifest(windowType, liveSupport)) {
loadManifest(serverDate, { onSuccess: postFailoverAction, onError: failoverErrorAction });
} else {
postFailoverAction();
}
} else {
postFailoverAction();
failoverErrorAction();
}
} else {
failoverErrorAction();
}
}
function shouldFailover (failoverParams) {
if (isFirstManifest(failoverParams.serviceLocation)) {
return false;
function shouldFailover (failoverParams) {
if (isFirstManifest(failoverParams.serviceLocation)) {
return false;
}
var talRestartable = window.bigscreenPlayer.playbackStrategy === PlaybackStrategy.TAL && liveSupport === LiveSupport.RESTARTABLE;
var aboutToEnd = failoverParams.duration && failoverParams.currentTime > failoverParams.duration - 5;
var shouldStaticFailover = windowType === WindowTypes.STATIC && !aboutToEnd;
var shouldLiveFailover = windowType !== WindowTypes.STATIC && !talRestartable;
return isFailoverInfoValid(failoverParams) && hasSourcesToFailoverTo() && (shouldStaticFailover || shouldLiveFailover);
}
var talRestartable = window.bigscreenPlayer.playbackStrategy === PlaybackStrategy.TAL && liveSupport === LiveSupport.RESTARTABLE;
var aboutToEnd = failoverParams.duration && failoverParams.currentTime > failoverParams.duration - 5;
var shouldStaticFailover = windowType === WindowTypes.STATIC && !aboutToEnd;
var shouldLiveFailover = windowType !== WindowTypes.STATIC && !talRestartable;
return isFailoverInfoValid(failoverParams) && hasSourcesToFailoverTo() && (shouldStaticFailover || shouldLiveFailover);
}
// we don't want to failover on the first playback
// the serviceLocation is set to our first cdn url
// see manifest modifier - generateBaseUrls
function isFirstManifest (serviceLocation) {
return serviceLocation === getCurrentUrl();
}
// we don't want to failover on the first playback
// the serviceLocation is set to our first cdn url
// see manifest modifier - generateBaseUrls
function isFirstManifest (serviceLocation) {
return serviceLocation === getCurrentUrl();
}
function isFailoverInfoValid (failoverParams) {
var infoValid = typeof failoverParams === 'object' &&
function isFailoverInfoValid (failoverParams) {
var infoValid = typeof failoverParams === 'object' &&
typeof failoverParams.errorMessage === 'string' &&
typeof failoverParams.isBufferingTimeoutError === 'boolean';
if (!infoValid) {
DebugTool.error('failoverInfo is not valid');
if (!infoValid) {
DebugTool.error('failoverInfo is not valid');
}
return infoValid;
}
return infoValid;
}
function needToGetManifest (windowType, liveSupport) {
var requiresManifestLoad = {
restartable: true,
seekable: true,
playable: false,
none: false
};
function needToGetManifest (windowType, liveSupport) {
var requiresManifestLoad = {
restartable: true,
seekable: true,
playable: false,
none: false
};
var requiredTransferFormat = transferFormat === TransferFormats.HLS || transferFormat === undefined;
return requiredTransferFormat && windowType !== WindowTypes.STATIC && requiresManifestLoad[liveSupport];
}
var requiredTransferFormat = transferFormat === TransferFormats.HLS || transferFormat === undefined;
return requiredTransferFormat && windowType !== WindowTypes.STATIC && requiresManifestLoad[liveSupport];
}
function refresh (onSuccess, onError) {
loadManifest(serverDate, {onSuccess: onSuccess, onError: onError});
}
function refresh (onSuccess, onError) {
loadManifest(serverDate, {onSuccess: onSuccess, onError: onError});
}
function loadManifest (serverDate, callbacks) {
var onManifestLoadSuccess = function (manifestData) {
time = manifestData.time;
transferFormat = manifestData.transferFormat;
callbacks.onSuccess();
};
function loadManifest (serverDate, callbacks) {
var onManifestLoadSuccess = function (manifestData) {
time = manifestData.time;
transferFormat = manifestData.transferFormat;
callbacks.onSuccess();
};
var failoverError = function () {
callbacks.onError({error: 'manifest'});
};
var failoverError = function () {
callbacks.onError({error: 'manifest'});
};
var onManifestLoadError = function () {
failover(load, failoverError, {errorMessage: 'manifest-load', isBufferingTimeoutError: false});
};
var onManifestLoadError = function () {
failover(load, failoverError, {errorMessage: 'manifest-load', isBufferingTimeoutError: false});
};
function load () {
ManifestLoader.load(
getCurrentUrl(),
serverDate,
{
onSuccess: onManifestLoadSuccess,
onError: onManifestLoadError
}
);
}
function load () {
ManifestLoader.load(
getCurrentUrl(),
serverDate,
{
onSuccess: onManifestLoadSuccess,
onError: onManifestLoadError
}
);
load();
}
load();
}
function getCurrentUrl () {
if (mediaSources.length > 0) {
return mediaSources[0].url.toString();
}
function getCurrentUrl () {
if (mediaSources.length > 0) {
return mediaSources[0].url.toString();
return '';
}
return '';
}
function availableUrls () {
return mediaSources.map(function (mediaSource) {
return mediaSource.url;
});
}
function availableUrls () {
return mediaSources.map(function (mediaSource) {
return mediaSource.url;
});
}
function generateTime () {
return time;
}
function generateTime () {
return time;
}
function updateCdns () {
if (hasSourcesToFailoverTo()) {
mediaSources.shift();
}
}
function updateCdns () {
if (hasSourcesToFailoverTo()) {
mediaSources.shift();
function hasSourcesToFailoverTo () {
return mediaSources.length > 1;
}
}
function hasSourcesToFailoverTo () {
return mediaSources.length > 1;
}
function emitCdnFailover (failoverInfo) {
var evt = new PluginData({
status: PluginEnums.STATUS.FAILOVER,
stateType: PluginEnums.TYPE.ERROR,
isBufferingTimeoutError: failoverInfo.isBufferingTimeoutError,
cdn: mediaSources[0].cdn,
newCdn: mediaSources[1].cdn
});
Plugins.interface.onErrorHandled(evt);
}
function emitCdnFailover (failoverInfo) {
var evt = new PluginData({
status: PluginEnums.STATUS.FAILOVER,
stateType: PluginEnums.TYPE.ERROR,
isBufferingTimeoutError: failoverInfo.isBufferingTimeoutError,
cdn: mediaSources[0].cdn,
newCdn: mediaSources[1].cdn
});
Plugins.interface.onErrorHandled(evt);
}
function getCurrentCdn () {
if (mediaSources.length > 0) {
return mediaSources[0].cdn.toString();
}
function getCurrentCdn () {
if (mediaSources.length > 0) {
return mediaSources[0].cdn.toString();
return '';
}
return '';
}
function availableCdns () {
return mediaSources.map(function (mediaSource) {
return mediaSource.cdn;
});
}
function availableCdns () {
return mediaSources.map(function (mediaSource) {
return mediaSource.cdn;
});
}
function updateDebugOutput () {
DebugTool.keyValue({key: 'available cdns', value: availableCdns()});
DebugTool.keyValue({key: 'current cdn', value: getCurrentCdn()});
DebugTool.keyValue({key: 'url', value: getCurrentUrl()});
}
function updateDebugOutput () {
DebugTool.keyValue({key: 'available cdns', value: availableCdns()});
DebugTool.keyValue({key: 'current cdn', value: getCurrentCdn()});
DebugTool.keyValue({key: 'url', value: getCurrentUrl()});
}
return {
init: init,
failover: failover,
refresh: refresh,
currentSource: getCurrentUrl,
availableSources: availableUrls,
time: generateTime
return {
init: init,
failover: failover,
refresh: refresh,
currentSource: getCurrentUrl,
availableSources: availableUrls,
time: generateTime
};
};
};
});
});

22

script/models/pausetriggers.js
define(
'bigscreenplayer/models/pausetriggers',
function () {
'use strict';
'bigscreenplayer/models/pausetriggers',
function () {
'use strict';
var PauseTriggers = {
USER: 1,
APP: 2,
DEVICE: 3
};
var PauseTriggers = {
USER: 1,
APP: 2,
DEVICE: 3
};
return PauseTriggers;
}
);
return PauseTriggers;
}
);

20

script/models/playbackstrategy.js
define(
'bigscreenplayer/models/playbackstrategy', [],
function () {
'use strict';
return {
MSE: 'msestrategy',
HYBRID: 'hybridstrategy',
NATIVE: 'nativestrategy',
TAL: 'talstrategy'
};
});
'bigscreenplayer/models/playbackstrategy', [],
function () {
'use strict';
return {
MSE: 'msestrategy',
HYBRID: 'hybridstrategy',
NATIVE: 'nativestrategy',
TAL: 'talstrategy'
};
});

1212

script/playbackstrategy/modifiers/cehtml.js
define(
'bigscreenplayer/playbackstrategy/modifiers/cehtml',
'bigscreenplayer/playbackstrategy/modifiers/cehtml',
[

@@ -7,760 +7,760 @@ 'bigscreenplayer/playbackstrategy/modifiers/mediaplayerbase',

],
function (MediaPlayerBase, DebugTool) {
'use strict';
var CLAMP_OFFSET_FROM_END_OF_RANGE = 1.1;
function (MediaPlayerBase, DebugTool) {
'use strict';
var CLAMP_OFFSET_FROM_END_OF_RANGE = 1.1;
var STATE = {
STOPPED: 0,
PLAYING: 1,
PAUSED: 2,
CONNECTING: 3,
BUFFERING: 4,
FINISHED: 5,
ERROR: 6
};
var STATE = {
STOPPED: 0,
PLAYING: 1,
PAUSED: 2,
CONNECTING: 3,
BUFFERING: 4,
FINISHED: 5,
ERROR: 6
};
return function (deviceConfig) {
var eventCallbacks = [];
var state = MediaPlayerBase.STATE.EMPTY;
return function (deviceConfig) {
var eventCallbacks = [];
var state = MediaPlayerBase.STATE.EMPTY;
var mediaElement;
var updateInterval;
var mediaElement;
var updateInterval;
var mediaType;
var source;
var mimeType;
var mediaType;
var source;
var mimeType;
var deferSeekingTo;
var range;
var deferSeekingTo;
var range;
var postBufferingState;
var seekFinished;
var count;
var timeoutHappened;
var postBufferingState;
var seekFinished;
var count;
var timeoutHappened;
var disableSentinels;
var disableSentinels;
var sentinelSeekTime;
var seekSentinelTolerance;
var sentinelInterval;
var sentinelIntervalNumber;
var timeAtLastSentinelInterval;
var sentinelSeekTime;
var seekSentinelTolerance;
var sentinelInterval;
var sentinelIntervalNumber;
var timeAtLastSentinelInterval;
var sentinelTimeIsNearEnd;
var timeHasAdvanced;
var sentinelTimeIsNearEnd;
var timeHasAdvanced;
var sentinelLimits = {
pause: {
maximumAttempts: 2,
successEvent: MediaPlayerBase.EVENT.SENTINEL_PAUSE,
failureEvent: MediaPlayerBase.EVENT.SENTINEL_PAUSE_FAILURE,
currentAttemptCount: 0
},
seek: {
maximumAttempts: 2,
successEvent: MediaPlayerBase.EVENT.SENTINEL_SEEK,
failureEvent: MediaPlayerBase.EVENT.SENTINEL_SEEK_FAILURE,
currentAttemptCount: 0
}
var sentinelLimits = {
pause: {
maximumAttempts: 2,
successEvent: MediaPlayerBase.EVENT.SENTINEL_PAUSE,
failureEvent: MediaPlayerBase.EVENT.SENTINEL_PAUSE_FAILURE,
currentAttemptCount: 0
},
seek: {
maximumAttempts: 2,
successEvent: MediaPlayerBase.EVENT.SENTINEL_SEEK,
failureEvent: MediaPlayerBase.EVENT.SENTINEL_SEEK_FAILURE,
currentAttemptCount: 0
}
};
function addEventCallback (thisArg, callback) {
var eventCallback = function (event) {
callback.call(thisArg, event);
};
function addEventCallback (thisArg, callback) {
var eventCallback = function (event) {
callback.call(thisArg, event);
};
eventCallbacks.push({ from: callback, to: eventCallback });
}
eventCallbacks.push({ from: callback, to: eventCallback });
}
function removeEventCallback (thisArg, callback) {
eventCallbacks = eventCallbacks.filter(function (cb) {
return cb.from !== callback;
});
}
function removeEventCallback (thisArg, callback) {
eventCallbacks = eventCallbacks.filter(function (cb) {
return cb.from !== callback;
});
}
function removeAllEventCallbacks () {
eventCallbacks = [];
}
function removeAllEventCallbacks () {
eventCallbacks = [];
}
function emitEvent (eventType, eventLabels) {
var event = {
type: eventType,
currentTime: getCurrentTime(),
seekableRange: getSeekableRange(),
duration: getDuration(),
url: getSource(),
mimeType: getMimeType(),
state: getState()
};
function emitEvent (eventType, eventLabels) {
var event = {
type: eventType,
currentTime: getCurrentTime(),
seekableRange: getSeekableRange(),
duration: getDuration(),
url: getSource(),
mimeType: getMimeType(),
state: getState()
};
if (eventLabels) {
for (var key in eventLabels) {
if (eventLabels.hasOwnProperty(key)) {
event[key] = eventLabels[key];
}
if (eventLabels) {
for (var key in eventLabels) {
if (eventLabels.hasOwnProperty(key)) {
event[key] = eventLabels[key];
}
}
eventCallbacks.forEach(function (callback) {
callback.to(event);
});
}
function getClampedTime (seconds) {
var range = getSeekableRange();
var offsetFromEnd = getClampOffsetFromConfig();
var nearToEnd = Math.max(range.end - offsetFromEnd, range.start);
if (seconds < range.start) {
return range.start;
} else if (seconds > nearToEnd) {
return nearToEnd;
} else {
return seconds;
}
eventCallbacks.forEach(function (callback) {
callback.to(event);
});
}
function getClampedTime (seconds) {
var range = getSeekableRange();
var offsetFromEnd = getClampOffsetFromConfig();
var nearToEnd = Math.max(range.end - offsetFromEnd, range.start);
if (seconds < range.start) {
return range.start;
} else if (seconds > nearToEnd) {
return nearToEnd;
} else {
return seconds;
}
}
function getClampOffsetFromConfig () {
var clampOffsetFromEndOfRange;
function getClampOffsetFromConfig () {
var clampOffsetFromEndOfRange;
// TODO: can we tidy this, is it needed any more? If so we can combine it into bigscreen-player configs
// if (config && config.streaming && config.streaming.overrides) {
// clampOffsetFromEndOfRange = config.streaming.overrides.clampOffsetFromEndOfRange;
// }
// TODO: can we tidy this, is it needed any more? If so we can combine it into bigscreen-player configs
// if (config && config.streaming && config.streaming.overrides) {
// clampOffsetFromEndOfRange = config.streaming.overrides.clampOffsetFromEndOfRange;
// }
if (clampOffsetFromEndOfRange !== undefined) {
return clampOffsetFromEndOfRange;
} else {
return CLAMP_OFFSET_FROM_END_OF_RANGE;
}
if (clampOffsetFromEndOfRange !== undefined) {
return clampOffsetFromEndOfRange;
} else {
return CLAMP_OFFSET_FROM_END_OF_RANGE;
}
}
function isLiveMedia () {
return (mediaType === MediaPlayerBase.TYPE.LIVE_VIDEO) || (mediaType === MediaPlayerBase.TYPE.LIVE_AUDIO);
}
function isLiveMedia () {
return (mediaType === MediaPlayerBase.TYPE.LIVE_VIDEO) || (mediaType === MediaPlayerBase.TYPE.LIVE_AUDIO);
}
function getSource () {
return source;
}
function getSource () {
return source;
}
function getMimeType () {
return mimeType;
}
function getMimeType () {
return mimeType;
}
function getState () {
return state;
}
function getState () {
return state;
}
function setSeekSentinelTolerance () {
var ON_DEMAND_SEEK_SENTINEL_TOLERANCE = 15;
var LIVE_SEEK_SENTINEL_TOLERANCE = 30;
function setSeekSentinelTolerance () {
var ON_DEMAND_SEEK_SENTINEL_TOLERANCE = 15;
var LIVE_SEEK_SENTINEL_TOLERANCE = 30;
seekSentinelTolerance = ON_DEMAND_SEEK_SENTINEL_TOLERANCE;
if (isLiveMedia()) {
seekSentinelTolerance = LIVE_SEEK_SENTINEL_TOLERANCE;
}
seekSentinelTolerance = ON_DEMAND_SEEK_SENTINEL_TOLERANCE;
if (isLiveMedia()) {
seekSentinelTolerance = LIVE_SEEK_SENTINEL_TOLERANCE;
}
}
function initialiseMedia (type, url, mediaMimeType, sourceContainer, opts) {
disableSentinels = opts.disableSentinels;
mediaType = type;
source = url;
mimeType = mediaMimeType;
opts = opts || {};
function initialiseMedia (type, url, mediaMimeType, sourceContainer, opts) {
disableSentinels = opts.disableSentinels;
mediaType = type;
source = url;
mimeType = mediaMimeType;
opts = opts || {};
emitSeekAttempted();
emitSeekAttempted();
if (getState() === MediaPlayerBase.STATE.EMPTY) {
timeAtLastSentinelInterval = 0;
setSeekSentinelTolerance();
createElement();
addElementToDOM();
mediaElement.data = source;
registerEventHandlers();
toStopped();
} else {
toError('Cannot set source unless in the \'' + MediaPlayerBase.STATE.EMPTY + '\' state');
}
if (getState() === MediaPlayerBase.STATE.EMPTY) {
timeAtLastSentinelInterval = 0;
setSeekSentinelTolerance();
createElement();
addElementToDOM();
mediaElement.data = source;
registerEventHandlers();
toStopped();
} else {
toError('Cannot set source unless in the \'' + MediaPlayerBase.STATE.EMPTY + '\' state');
}
}
function resume () {
postBufferingState = MediaPlayerBase.STATE.PLAYING;
switch (getState()) {
case MediaPlayerBase.STATE.PLAYING:
case MediaPlayerBase.STATE.BUFFERING:
break;
function resume () {
postBufferingState = MediaPlayerBase.STATE.PLAYING;
switch (getState()) {
case MediaPlayerBase.STATE.PLAYING:
case MediaPlayerBase.STATE.BUFFERING:
break;
case MediaPlayerBase.STATE.PAUSED:
mediaElement.play(1);
toPlaying();
break;
case MediaPlayerBase.STATE.PAUSED:
mediaElement.play(1);
toPlaying();
break;
default:
toError('Cannot resume while in the \'' + getState() + '\' state');
break;
}
default:
toError('Cannot resume while in the \'' + getState() + '\' state');
break;
}
}
function playFrom (seconds) {
postBufferingState = MediaPlayerBase.STATE.PLAYING;
sentinelLimits.seek.currentAttemptCount = 0;
switch (getState()) {
case MediaPlayerBase.STATE.BUFFERING:
deferSeekingTo = seconds;
break;
function playFrom (seconds) {
postBufferingState = MediaPlayerBase.STATE.PLAYING;
sentinelLimits.seek.currentAttemptCount = 0;
switch (getState()) {
case MediaPlayerBase.STATE.BUFFERING:
deferSeekingTo = seconds;
break;
case MediaPlayerBase.STATE.COMPLETE:
toBuffering();
mediaElement.stop();
playAndSetDeferredSeek(seconds);
break;
case MediaPlayerBase.STATE.COMPLETE:
toBuffering();
mediaElement.stop();
playAndSetDeferredSeek(seconds);
break;
case MediaPlayerBase.STATE.PLAYING:
toBuffering();
var seekResult = seekTo(seconds);
if (seekResult === false) {
toPlaying();
}
break;
case MediaPlayerBase.STATE.PLAYING:
toBuffering();
var seekResult = seekTo(seconds);
if (seekResult === false) {
toPlaying();
}
break;
case MediaPlayerBase.STATE.PAUSED:
toBuffering();
seekTo(seconds);
mediaElement.play(1);
break;
case MediaPlayerBase.STATE.PAUSED:
toBuffering();
seekTo(seconds);
mediaElement.play(1);
break;
default:
toError('Cannot playFrom while in the \'' + getState() + '\' state');
break;
}
default:
toError('Cannot playFrom while in the \'' + getState() + '\' state');
break;
}
}
function getDuration () {
switch (getState()) {
case MediaPlayerBase.STATE.STOPPED:
case MediaPlayerBase.STATE.ERROR:
return undefined;
default:
if (isLiveMedia()) {
return Infinity;
}
return getMediaDuration();
}
function getDuration () {
switch (getState()) {
case MediaPlayerBase.STATE.STOPPED:
case MediaPlayerBase.STATE.ERROR:
return undefined;
default:
if (isLiveMedia()) {
return Infinity;
}
return getMediaDuration();
}
}
function beginPlayback () {
postBufferingState = MediaPlayerBase.STATE.PLAYING;
switch (getState()) {
case MediaPlayerBase.STATE.STOPPED:
toBuffering();
mediaElement.play(1);
break;
function beginPlayback () {
postBufferingState = MediaPlayerBase.STATE.PLAYING;
switch (getState()) {
case MediaPlayerBase.STATE.STOPPED:
toBuffering();
mediaElement.play(1);
break;
default:
toError('Cannot beginPlayback while in the \'' + getState() + '\' state');
break;
}
default:
toError('Cannot beginPlayback while in the \'' + getState() + '\' state');
break;
}
}
function beginPlaybackFrom (seconds) {
postBufferingState = MediaPlayerBase.STATE.PLAYING;
sentinelLimits.seek.currentAttemptCount = 0;
function beginPlaybackFrom (seconds) {
postBufferingState = MediaPlayerBase.STATE.PLAYING;
sentinelLimits.seek.currentAttemptCount = 0;
switch (getState()) {
case MediaPlayerBase.STATE.STOPPED:
// Seeking past 0 requires calling play first when media has not been loaded
toBuffering();
playAndSetDeferredSeek(seconds);
break;
switch (getState()) {
case MediaPlayerBase.STATE.STOPPED:
// Seeking past 0 requires calling play first when media has not been loaded
toBuffering();
playAndSetDeferredSeek(seconds);
break;
default:
toError('Cannot beginPlayback while in the \'' + getState() + '\' state');
break;
}
default:
toError('Cannot beginPlayback while in the \'' + getState() + '\' state');
break;
}
}
function pause () {
postBufferingState = MediaPlayerBase.STATE.PAUSED;
switch (getState()) {
case MediaPlayerBase.STATE.BUFFERING:
case MediaPlayerBase.STATE.PAUSED:
break;
function pause () {
postBufferingState = MediaPlayerBase.STATE.PAUSED;
switch (getState()) {
case MediaPlayerBase.STATE.BUFFERING:
case MediaPlayerBase.STATE.PAUSED:
break;
case MediaPlayerBase.STATE.PLAYING:
mediaElement.play(0);
toPaused();
break;
case MediaPlayerBase.STATE.PLAYING:
mediaElement.play(0);
toPaused();
break;
default:
toError('Cannot pause while in the \'' + getState() + '\' state');
break;
}
default:
toError('Cannot pause while in the \'' + getState() + '\' state');
break;
}
}
function stop () {
switch (getState()) {
case MediaPlayerBase.STATE.STOPPED:
break;
function stop () {
switch (getState()) {
case MediaPlayerBase.STATE.STOPPED:
break;
case MediaPlayerBase.STATE.BUFFERING:
case MediaPlayerBase.STATE.PLAYING:
case MediaPlayerBase.STATE.PAUSED:
case MediaPlayerBase.STATE.COMPLETE:
sentinelSeekTime = undefined;
if (mediaElement.stop) {
mediaElement.stop();
toStopped();
} else {
toError('mediaElement.stop is not a function : failed to stop the media player');
}
break;
case MediaPlayerBase.STATE.BUFFERING:
case MediaPlayerBase.STATE.PLAYING:
case MediaPlayerBase.STATE.PAUSED:
case MediaPlayerBase.STATE.COMPLETE:
sentinelSeekTime = undefined;
if (mediaElement.stop) {
mediaElement.stop();
toStopped();
} else {
toError('mediaElement.stop is not a function : failed to stop the media player');
}
break;
default:
toError('Cannot stop while in the \'' + getState() + '\' state');
break;
}
default:
toError('Cannot stop while in the \'' + getState() + '\' state');
break;
}
}
function reset () {
switch (getState()) {
case MediaPlayerBase.STATE.EMPTY:
break;
function reset () {
switch (getState()) {
case MediaPlayerBase.STATE.EMPTY:
break;
case MediaPlayerBase.STATE.STOPPED:
case MediaPlayerBase.STATE.ERROR:
toEmpty();
break;
case MediaPlayerBase.STATE.STOPPED:
case MediaPlayerBase.STATE.ERROR:
toEmpty();
break;
default:
toError('Cannot reset while in the \'' + getState() + '\' state');
break;
}
default:
toError('Cannot reset while in the \'' + getState() + '\' state');
break;
}
}
function getCurrentTime () {
switch (getState()) {
case MediaPlayerBase.STATE.STOPPED:
case MediaPlayerBase.STATE.ERROR:
break;
function getCurrentTime () {
switch (getState()) {
case MediaPlayerBase.STATE.STOPPED:
case MediaPlayerBase.STATE.ERROR:
break;
case MediaPlayerBase.STATE.COMPLETE:
if (range) {
return range.end;
}
break;
case MediaPlayerBase.STATE.COMPLETE:
if (range) {
return range.end;
}
break;
default:
if (mediaElement) {
return mediaElement.playPosition / 1000;
}
break;
}
return undefined;
default:
if (mediaElement) {
return mediaElement.playPosition / 1000;
}
break;
}
return undefined;
}
function getSeekableRange () {
switch (getState()) {
case MediaPlayerBase.STATE.STOPPED:
case MediaPlayerBase.STATE.ERROR:
break;
function getSeekableRange () {
switch (getState()) {
case MediaPlayerBase.STATE.STOPPED:
case MediaPlayerBase.STATE.ERROR:
break;
default:
return range;
}
return undefined;
default:
return range;
}
return undefined;
}
function getMediaDuration () {
if (range) {
return range.end;
}
return undefined;
function getMediaDuration () {
if (range) {
return range.end;
}
return undefined;
}
function getPlayerElement () {
return mediaElement;
}
function getPlayerElement () {
return mediaElement;
}
function onFinishedBuffering () {
cacheRange();
function onFinishedBuffering () {
cacheRange();
if (getState() !== MediaPlayerBase.STATE.BUFFERING) {
return;
}
if (getState() !== MediaPlayerBase.STATE.BUFFERING) {
return;
}
if (waitingToSeek()) {
toBuffering();
performDeferredSeek();
} else if (waitingToPause()) {
toPaused();
mediaElement.play(0);
} else {
toPlaying();
}
if (waitingToSeek()) {
toBuffering();
performDeferredSeek();
} else if (waitingToPause()) {
toPaused();
mediaElement.play(0);
} else {
toPlaying();
}
}
function onDeviceError () {
reportError('Media element error code: ' + mediaElement.error);
function onDeviceError () {
reportError('Media element error code: ' + mediaElement.error);
}
function onDeviceBuffering () {
if (getState() === MediaPlayerBase.STATE.PLAYING) {
toBuffering();
}
}
function onDeviceBuffering () {
if (getState() === MediaPlayerBase.STATE.PLAYING) {
toBuffering();
}
function onEndOfMedia () {
if (getState() !== MediaPlayerBase.STATE.COMPLETE) {
toComplete();
}
}
function onEndOfMedia () {
if (getState() !== MediaPlayerBase.STATE.COMPLETE) {
toComplete();
}
function emitSeekAttempted () {
if (getState() === MediaPlayerBase.STATE.EMPTY) {
emitEvent(MediaPlayerBase.EVENT.SEEK_ATTEMPTED);
seekFinished = false;
}
function emitSeekAttempted () {
if (getState() === MediaPlayerBase.STATE.EMPTY) {
emitEvent(MediaPlayerBase.EVENT.SEEK_ATTEMPTED);
seekFinished = false;
}
count = 0;
timeoutHappened = false;
if (deviceConfig.restartTimeout) {
setTimeout(function () {
timeoutHappened = true;
}, deviceConfig.restartTimeout);
} else {
count = 0;
timeoutHappened = false;
if (deviceConfig.restartTimeout) {
setTimeout(function () {
timeoutHappened = true;
}
}, deviceConfig.restartTimeout);
} else {
timeoutHappened = true;
}
}
function emitSeekFinishedAtCorrectStartingPoint () {
var isAtCorrectStartingPoint = Math.abs(getCurrentTime() - sentinelSeekTime) <= seekSentinelTolerance;
function emitSeekFinishedAtCorrectStartingPoint () {
var isAtCorrectStartingPoint = Math.abs(getCurrentTime() - sentinelSeekTime) <= seekSentinelTolerance;
if (sentinelSeekTime === undefined) {
isAtCorrectStartingPoint = true;
}
var isPlayingAtCorrectTime = getState() === MediaPlayerBase.STATE.PLAYING && isAtCorrectStartingPoint;
if (isPlayingAtCorrectTime && count >= 5 && timeoutHappened && !seekFinished) {
emitEvent(MediaPlayerBase.EVENT.SEEK_FINISHED);
seekFinished = true;
} else if (isPlayingAtCorrectTime) {
count++;
} else {
count = 0;
}
if (sentinelSeekTime === undefined) {
isAtCorrectStartingPoint = true;
}
function onStatus () {
if (getState() === MediaPlayerBase.STATE.PLAYING) {
emitEvent(MediaPlayerBase.EVENT.STATUS);
}
var isPlayingAtCorrectTime = getState() === MediaPlayerBase.STATE.PLAYING && isAtCorrectStartingPoint;
emitSeekFinishedAtCorrectStartingPoint();
if (isPlayingAtCorrectTime && count >= 5 && timeoutHappened && !seekFinished) {
emitEvent(MediaPlayerBase.EVENT.SEEK_FINISHED);
seekFinished = true;
} else if (isPlayingAtCorrectTime) {
count++;
} else {
count = 0;
}
}
function createElement () {
mediaElement = document.createElement('object', 'mediaPlayer');
mediaElement.type = mimeType;
mediaElement.style.position = 'absolute';
mediaElement.style.top = '0px';
mediaElement.style.left = '0px';
mediaElement.style.width = '100%';
mediaElement.style.height = '100%';
function onStatus () {
if (getState() === MediaPlayerBase.STATE.PLAYING) {
emitEvent(MediaPlayerBase.EVENT.STATUS);
}
function registerEventHandlers () {
var DEVICE_UPDATE_PERIOD_MS = 500;
emitSeekFinishedAtCorrectStartingPoint();
}
mediaElement.onPlayStateChange = function () {
switch (mediaElement.playState) {
case STATE.STOPPED:
break;
case STATE.PLAYING:
onFinishedBuffering();
break;
case STATE.PAUSED:
break;
case STATE.CONNECTING:
break;
case STATE.BUFFERING:
onDeviceBuffering();
break;
case STATE.FINISHED:
onEndOfMedia();
break;
case STATE.ERROR:
onDeviceError();
break;
default:
// do nothing
break;
}
};
function createElement () {
mediaElement = document.createElement('object', 'mediaPlayer');
mediaElement.type = mimeType;
mediaElement.style.position = 'absolute';
mediaElement.style.top = '0px';
mediaElement.style.left = '0px';
mediaElement.style.width = '100%';
mediaElement.style.height = '100%';
}
updateInterval = setInterval(function () {
onStatus();
}, DEVICE_UPDATE_PERIOD_MS);
}
function registerEventHandlers () {
var DEVICE_UPDATE_PERIOD_MS = 500;
function addElementToDOM () {
var body = document.getElementsByTagName('body')[0];
body.insertBefore(mediaElement, body.firstChild);
}
function cacheRange () {
if (mediaElement) {
range = {
start: 0,
end: mediaElement.playTime / 1000
};
mediaElement.onPlayStateChange = function () {
switch (mediaElement.playState) {
case STATE.STOPPED:
break;
case STATE.PLAYING:
onFinishedBuffering();
break;
case STATE.PAUSED:
break;
case STATE.CONNECTING:
break;
case STATE.BUFFERING:
onDeviceBuffering();
break;
case STATE.FINISHED:
onEndOfMedia();
break;
case STATE.ERROR:
onDeviceError();
break;
default:
// do nothing
break;
}
}
};
function playAndSetDeferredSeek (seconds) {
mediaElement.play(1);
if (seconds > 0) {
deferSeekingTo = seconds;
}
}
updateInterval = setInterval(function () {
onStatus();
}, DEVICE_UPDATE_PERIOD_MS);
}
function waitingToSeek () {
return (deferSeekingTo !== undefined);
}
function addElementToDOM () {
var body = document.getElementsByTagName('body')[0];
body.insertBefore(mediaElement, body.firstChild);
}
function performDeferredSeek () {
seekTo(deferSeekingTo);
deferSeekingTo = undefined;
function cacheRange () {
if (mediaElement) {
range = {
start: 0,
end: mediaElement.playTime / 1000
};
}
}
function seekTo (seconds) {
var clampedTime = getClampedTime(seconds);
if (clampedTime !== seconds) {
DebugTool.info('playFrom ' + seconds + ' clamped to ' + clampedTime + ' - seekable range is { start: ' + range.start + ', end: ' + range.end + ' }');
}
sentinelSeekTime = clampedTime;
return mediaElement.seek(clampedTime * 1000);
function playAndSetDeferredSeek (seconds) {
mediaElement.play(1);
if (seconds > 0) {
deferSeekingTo = seconds;
}
}
function waitingToPause () {
return (postBufferingState === MediaPlayerBase.STATE.PAUSED);
}
function waitingToSeek () {
return (deferSeekingTo !== undefined);
}
function wipe () {
mediaType = undefined;
source = undefined;
mimeType = undefined;
sentinelSeekTime = undefined;
range = undefined;
if (mediaElement) {
clearInterval(updateInterval);
clearSentinels();
destroyMediaElement();
} else {
}
}
function performDeferredSeek () {
seekTo(deferSeekingTo);
deferSeekingTo = undefined;
}
function destroyMediaElement () {
delete mediaElement.onPlayStateChange;
if (mediaElement.parentElement) {
mediaElement.parentElement.removeChild(mediaElement);
} else {
}
mediaElement = undefined;
function seekTo (seconds) {
var clampedTime = getClampedTime(seconds);
if (clampedTime !== seconds) {
DebugTool.info('playFrom ' + seconds + ' clamped to ' + clampedTime + ' - seekable range is { start: ' + range.start + ', end: ' + range.end + ' }');
}
sentinelSeekTime = clampedTime;
return mediaElement.seek(clampedTime * 1000);
}
function reportError (errorMessage) {
DebugTool.info(errorMessage);
emitEvent(MediaPlayerBase.EVENT.ERROR, {'errorMessage': errorMessage});
}
function waitingToPause () {
return (postBufferingState === MediaPlayerBase.STATE.PAUSED);
}
function toStopped () {
state = MediaPlayerBase.STATE.STOPPED;
emitEvent(MediaPlayerBase.EVENT.STOPPED);
if (sentinelInterval) {
clearSentinels();
}
function wipe () {
mediaType = undefined;
source = undefined;
mimeType = undefined;
sentinelSeekTime = undefined;
range = undefined;
if (mediaElement) {
clearInterval(updateInterval);
clearSentinels();
destroyMediaElement();
} else {
}
}
function toBuffering () {
state = MediaPlayerBase.STATE.BUFFERING;
emitEvent(MediaPlayerBase.EVENT.BUFFERING);
setSentinels([exitBufferingSentinel]);
function destroyMediaElement () {
delete mediaElement.onPlayStateChange;
if (mediaElement.parentElement) {
mediaElement.parentElement.removeChild(mediaElement);
} else {
}
mediaElement = undefined;
}
function toPlaying () {
state = MediaPlayerBase.STATE.PLAYING;
emitEvent(MediaPlayerBase.EVENT.PLAYING);
setSentinels([
shouldBeSeekedSentinel,
enterCompleteSentinel,
enterBufferingSentinel
]);
}
function reportError (errorMessage) {
DebugTool.info(errorMessage);
emitEvent(MediaPlayerBase.EVENT.ERROR, {'errorMessage': errorMessage});
}
function toPaused () {
state = MediaPlayerBase.STATE.PAUSED;
emitEvent(MediaPlayerBase.EVENT.PAUSED);
setSentinels([
shouldBePausedSentinel,
shouldBeSeekedSentinel
]);
}
function toComplete () {
state = MediaPlayerBase.STATE.COMPLETE;
emitEvent(MediaPlayerBase.EVENT.COMPLETE);
function toStopped () {
state = MediaPlayerBase.STATE.STOPPED;
emitEvent(MediaPlayerBase.EVENT.STOPPED);
if (sentinelInterval) {
clearSentinels();
}
}
function toEmpty () {
wipe();
state = MediaPlayerBase.STATE.EMPTY;
}
function toBuffering () {
state = MediaPlayerBase.STATE.BUFFERING;
emitEvent(MediaPlayerBase.EVENT.BUFFERING);
setSentinels([exitBufferingSentinel]);
}
function toError (errorMessage) {
wipe();
state = MediaPlayerBase.STATE.ERROR;
reportError(errorMessage);
}
function toPlaying () {
state = MediaPlayerBase.STATE.PLAYING;
emitEvent(MediaPlayerBase.EVENT.PLAYING);
setSentinels([
shouldBeSeekedSentinel,
enterCompleteSentinel,
enterBufferingSentinel
]);
}
function isNearToEnd (seconds) {
return (getDuration() - seconds <= 1);
}
function toPaused () {
state = MediaPlayerBase.STATE.PAUSED;
emitEvent(MediaPlayerBase.EVENT.PAUSED);
setSentinels([
shouldBePausedSentinel,
shouldBeSeekedSentinel
]);
}
function setSentinels (sentinels) {
if (disableSentinels) {
return;
}
function toComplete () {
state = MediaPlayerBase.STATE.COMPLETE;
emitEvent(MediaPlayerBase.EVENT.COMPLETE);
clearSentinels();
}
sentinelLimits.pause.currentAttemptCount = 0;
timeAtLastSentinelInterval = getCurrentTime();
clearSentinels();
sentinelIntervalNumber = 0;
sentinelInterval = setInterval(function () {
var newTime = getCurrentTime();
sentinelIntervalNumber++;
function toEmpty () {
wipe();
state = MediaPlayerBase.STATE.EMPTY;
}
timeHasAdvanced = newTime ? (newTime > (timeAtLastSentinelInterval + 0.2)) : false;
sentinelTimeIsNearEnd = isNearToEnd(newTime || timeAtLastSentinelInterval);
function toError (errorMessage) {
wipe();
state = MediaPlayerBase.STATE.ERROR;
reportError(errorMessage);
}
for (var i = 0; i < sentinels.length; i++) {
var sentinelActionPerformed = sentinels[i].call(this);
if (sentinelActionPerformed) {
break;
}
}
function isNearToEnd (seconds) {
return (getDuration() - seconds <= 1);
}
timeAtLastSentinelInterval = newTime;
}, 1100);
function setSentinels (sentinels) {
if (disableSentinels) {
return;
}
function clearSentinels () {
clearInterval(sentinelInterval);
}
sentinelLimits.pause.currentAttemptCount = 0;
timeAtLastSentinelInterval = getCurrentTime();
clearSentinels();
sentinelIntervalNumber = 0;
sentinelInterval = setInterval(function () {
var newTime = getCurrentTime();
sentinelIntervalNumber++;
function enterBufferingSentinel () {
var sentinelBufferingRequired = !timeHasAdvanced && !sentinelTimeIsNearEnd && (sentinelIntervalNumber > 1);
if (sentinelBufferingRequired) {
emitEvent(MediaPlayerBase.EVENT.SENTINEL_ENTER_BUFFERING);
toBuffering();
timeHasAdvanced = newTime ? (newTime > (timeAtLastSentinelInterval + 0.2)) : false;
sentinelTimeIsNearEnd = isNearToEnd(newTime || timeAtLastSentinelInterval);
for (var i = 0; i < sentinels.length; i++) {
var sentinelActionPerformed = sentinels[i].call(this);
if (sentinelActionPerformed) {
break;
}
}
return sentinelBufferingRequired;
timeAtLastSentinelInterval = newTime;
}, 1100);
}
function clearSentinels () {
clearInterval(sentinelInterval);
}
function enterBufferingSentinel () {
var sentinelBufferingRequired = !timeHasAdvanced && !sentinelTimeIsNearEnd && (sentinelIntervalNumber > 1);
if (sentinelBufferingRequired) {
emitEvent(MediaPlayerBase.EVENT.SENTINEL_ENTER_BUFFERING);
toBuffering();
}
return sentinelBufferingRequired;
}
function exitBufferingSentinel () {
var sentinelExitBufferingRequired = timeHasAdvanced;
if (sentinelExitBufferingRequired) {
emitEvent(MediaPlayerBase.EVENT.SENTINEL_EXIT_BUFFERING);
onFinishedBuffering();
}
return sentinelExitBufferingRequired;
function exitBufferingSentinel () {
var sentinelExitBufferingRequired = timeHasAdvanced;
if (sentinelExitBufferingRequired) {
emitEvent(MediaPlayerBase.EVENT.SENTINEL_EXIT_BUFFERING);
onFinishedBuffering();
}
return sentinelExitBufferingRequired;
}
function shouldBeSeekedSentinel () {
if (sentinelSeekTime === undefined) {
return false;
}
function shouldBeSeekedSentinel () {
if (sentinelSeekTime === undefined) {
return false;
}
var currentTime = getCurrentTime();
var currentTime = getCurrentTime();
var clampedSentinelSeekTime = getClampedTime(sentinelSeekTime);
var clampedSentinelSeekTime = getClampedTime(sentinelSeekTime);
var sentinelSeekRequired = Math.abs(clampedSentinelSeekTime - currentTime) > seekSentinelTolerance;
var sentinelActionTaken = false;
var sentinelSeekRequired = Math.abs(clampedSentinelSeekTime - currentTime) > seekSentinelTolerance;
var sentinelActionTaken = false;
if (sentinelSeekRequired) {
var mediaElement = mediaElement;
sentinelActionTaken = nextSentinelAttempt(sentinelLimits.seek, function () {
mediaElement.seek(clampedSentinelSeekTime * 1000);
});
} else if (sentinelIntervalNumber < 3) {
sentinelSeekTime = currentTime;
} else {
sentinelSeekTime = undefined;
}
return sentinelActionTaken;
if (sentinelSeekRequired) {
var mediaElement = mediaElement;
sentinelActionTaken = nextSentinelAttempt(sentinelLimits.seek, function () {
mediaElement.seek(clampedSentinelSeekTime * 1000);
});
} else if (sentinelIntervalNumber < 3) {
sentinelSeekTime = currentTime;
} else {
sentinelSeekTime = undefined;
}
return sentinelActionTaken;
}
function shouldBePausedSentinel () {
var sentinelPauseRequired = timeHasAdvanced;
var sentinelActionTaken = false;
if (sentinelPauseRequired) {
var mediaElement = mediaElement;
sentinelActionTaken = nextSentinelAttempt(sentinelLimits.pause, function () {
mediaElement.play(0);
});
}
return sentinelActionTaken;
function shouldBePausedSentinel () {
var sentinelPauseRequired = timeHasAdvanced;
var sentinelActionTaken = false;
if (sentinelPauseRequired) {
var mediaElement = mediaElement;
sentinelActionTaken = nextSentinelAttempt(sentinelLimits.pause, function () {
mediaElement.play(0);
});
}
return sentinelActionTaken;
}
function enterCompleteSentinel () {
var sentinelCompleteRequired = !timeHasAdvanced && sentinelTimeIsNearEnd;
if (sentinelCompleteRequired) {
emitEvent(MediaPlayerBase.EVENT.SENTINEL_COMPLETE);
onEndOfMedia();
}
return sentinelCompleteRequired;
function enterCompleteSentinel () {
var sentinelCompleteRequired = !timeHasAdvanced && sentinelTimeIsNearEnd;
if (sentinelCompleteRequired) {
emitEvent(MediaPlayerBase.EVENT.SENTINEL_COMPLETE);
onEndOfMedia();
}
return sentinelCompleteRequired;
}
function nextSentinelAttempt (sentinelInfo, attemptFn) {
var currentAttemptCount, maxAttemptCount;
function nextSentinelAttempt (sentinelInfo, attemptFn) {
var currentAttemptCount, maxAttemptCount;
sentinelInfo.currentAttemptCount += 1;
currentAttemptCount = sentinelInfo.currentAttemptCount;
maxAttemptCount = sentinelInfo.maximumAttempts;
sentinelInfo.currentAttemptCount += 1;
currentAttemptCount = sentinelInfo.currentAttemptCount;
maxAttemptCount = sentinelInfo.maximumAttempts;
if (currentAttemptCount === maxAttemptCount + 1) {
emitEvent(sentinelInfo.failureEvent);
}
if (currentAttemptCount === maxAttemptCount + 1) {
emitEvent(sentinelInfo.failureEvent);
}
if (currentAttemptCount <= maxAttemptCount) {
attemptFn();
emitEvent(sentinelInfo.successEvent);
return true;
}
return false;
if (currentAttemptCount <= maxAttemptCount) {
attemptFn();
emitEvent(sentinelInfo.successEvent);
return true;
}
return {
addEventCallback: addEventCallback,
removeEventCallback: removeEventCallback,
removeAllEventCallbacks: removeAllEventCallbacks,
initialiseMedia: initialiseMedia,
resume: resume,
playFrom: playFrom,
beginPlayback: beginPlayback,
beginPlaybackFrom: beginPlaybackFrom,
pause: pause,
stop: stop,
reset: reset,
getSource: getSource,
getMimeType: getMimeType,
getSeekableRange: getSeekableRange,
getMediaDuration: getMediaDuration,
getState: getState,
getPlayerElement: getPlayerElement,
getDuration: getDuration
};
return false;
}
return {
addEventCallback: addEventCallback,
removeEventCallback: removeEventCallback,
removeAllEventCallbacks: removeAllEventCallbacks,
initialiseMedia: initialiseMedia,
resume: resume,
playFrom: playFrom,
beginPlayback: beginPlayback,
beginPlaybackFrom: beginPlaybackFrom,
pause: pause,
stop: stop,
reset: reset,
getSource: getSource,
getMimeType: getMimeType,
getSeekableRange: getSeekableRange,
getMediaDuration: getMediaDuration,
getState: getState,
getPlayerElement: getPlayerElement,
getDuration: getDuration
};
});
};
});

94

script/playbackstrategy/modifiers/live/playable.js
define(
'bigscreenplayer/playbackstrategy/modifiers/live/playable',
'bigscreenplayer/playbackstrategy/modifiers/live/playable',
[
'bigscreenplayer/playbackstrategy/modifiers/mediaplayerbase'
],
function (MediaPlayerBase) {
'use strict';
function PlayableLivePlayer (mediaPlayer) {
return {
beginPlayback: function beginPlayback () {
mediaPlayer.beginPlayback();
},
function (MediaPlayerBase) {
'use strict';
function PlayableLivePlayer (mediaPlayer) {
return {
beginPlayback: function beginPlayback () {
mediaPlayer.beginPlayback();
},
initialiseMedia: function initialiseMedia (mediaType, sourceUrl, mimeType, sourceContainer, opts) {
if (mediaType === MediaPlayerBase.TYPE.AUDIO) {
mediaType = MediaPlayerBase.TYPE.LIVE_AUDIO;
} else {
mediaType = MediaPlayerBase.TYPE.LIVE_VIDEO;
}
initialiseMedia: function initialiseMedia (mediaType, sourceUrl, mimeType, sourceContainer, opts) {
if (mediaType === MediaPlayerBase.TYPE.AUDIO) {
mediaType = MediaPlayerBase.TYPE.LIVE_AUDIO;
} else {
mediaType = MediaPlayerBase.TYPE.LIVE_VIDEO;
}
mediaPlayer.initialiseMedia(mediaType, sourceUrl, mimeType, sourceContainer, opts);
},
mediaPlayer.initialiseMedia(mediaType, sourceUrl, mimeType, sourceContainer, opts);
},
stop: function stop () {
mediaPlayer.stop();
},
stop: function stop () {
mediaPlayer.stop();
},
reset: function reset () {
mediaPlayer.reset();
},
reset: function reset () {
mediaPlayer.reset();
},
getState: function getState () {
return mediaPlayer.getState();
},
getState: function getState () {
return mediaPlayer.getState();
},
getSource: function getSource () {
return mediaPlayer.getSource();
},
getSource: function getSource () {
return mediaPlayer.getSource();
},
getMimeType: function getMimeType () {
return mediaPlayer.getMimeType();
},
getMimeType: function getMimeType () {
return mediaPlayer.getMimeType();
},
addEventCallback: function addEventCallback (thisArg, callback) {
mediaPlayer.addEventCallback(thisArg, callback);
},
addEventCallback: function addEventCallback (thisArg, callback) {
mediaPlayer.addEventCallback(thisArg, callback);
},
removeEventCallback: function removeEventCallback (thisArg, callback) {
mediaPlayer.removeEventCallback(thisArg, callback);
},
removeEventCallback: function removeEventCallback (thisArg, callback) {
mediaPlayer.removeEventCallback(thisArg, callback);
},
removeAllEventCallbacks: function removeAllEventCallbacks () {
mediaPlayer.removeAllEventCallbacks();
},
removeAllEventCallbacks: function removeAllEventCallbacks () {
mediaPlayer.removeAllEventCallbacks();
},
getPlayerElement: function getPlayerElement () {
return mediaPlayer.getPlayerElement();
}
};
}
getPlayerElement: function getPlayerElement () {
return mediaPlayer.getPlayerElement();
}
};
}
return PlayableLivePlayer;
}
return PlayableLivePlayer;
}
);

226

script/playbackstrategy/modifiers/live/restartable.js
define(
'bigscreenplayer/playbackstrategy/modifiers/live/restartable',
'bigscreenplayer/playbackstrategy/modifiers/live/restartable',
[

@@ -8,151 +8,151 @@ 'bigscreenplayer/playbackstrategy/modifiers/mediaplayerbase',

],
function (MediaPlayerBase, WindowTypes, DynamicWindowUtils) {
'use strict';
function (MediaPlayerBase, WindowTypes, DynamicWindowUtils) {
'use strict';
function RestartableLivePlayer (mediaPlayer, deviceConfig, windowType, mediaSources) {
var callbacksMap = [];
var startTime;
var fakeTimer = {};
var timeCorrection = mediaSources.time().correction || 0;
addEventCallback(this, updateFakeTimer);
function RestartableLivePlayer (mediaPlayer, deviceConfig, windowType, mediaSources) {
var callbacksMap = [];
var startTime;
var fakeTimer = {};
var timeCorrection = mediaSources.time().correction || 0;
addEventCallback(this, updateFakeTimer);
function updateFakeTimer (event) {
if (fakeTimer.wasPlaying && fakeTimer.runningTime) {
fakeTimer.currentTime += (Date.now() - fakeTimer.runningTime) / 1000;
}
fakeTimer.runningTime = Date.now();
fakeTimer.wasPlaying = event.state === MediaPlayerBase.STATE.PLAYING;
function updateFakeTimer (event) {
if (fakeTimer.wasPlaying && fakeTimer.runningTime) {
fakeTimer.currentTime += (Date.now() - fakeTimer.runningTime) / 1000;
}
function addEventCallback (thisArg, callback) {
function newCallback (event) {
event.currentTime = getCurrentTime();
event.seekableRange = getSeekableRange();
callback(event);
}
callbacksMap.push({ from: callback, to: newCallback });
mediaPlayer.addEventCallback(thisArg, newCallback);
fakeTimer.runningTime = Date.now();
fakeTimer.wasPlaying = event.state === MediaPlayerBase.STATE.PLAYING;
}
function addEventCallback (thisArg, callback) {
function newCallback (event) {
event.currentTime = getCurrentTime();
event.seekableRange = getSeekableRange();
callback(event);
}
callbacksMap.push({ from: callback, to: newCallback });
mediaPlayer.addEventCallback(thisArg, newCallback);
}
function removeEventCallback (thisArg, callback) {
var filteredCallbacks = callbacksMap.filter(function (cb) {
return cb.from === callback;
});
function removeEventCallback (thisArg, callback) {
var filteredCallbacks = callbacksMap.filter(function (cb) {
return cb.from === callback;
});
if (filteredCallbacks.length > 0) {
callbacksMap = callbacksMap.splice(callbacksMap.indexOf(filteredCallbacks[0]));
if (filteredCallbacks.length > 0) {
callbacksMap = callbacksMap.splice(callbacksMap.indexOf(filteredCallbacks[0]));
mediaPlayer.removeEventCallback(thisArg, filteredCallbacks[0].to);
}
mediaPlayer.removeEventCallback(thisArg, filteredCallbacks[0].to);
}
}
function removeAllEventCallbacks () {
mediaPlayer.removeAllEventCallbacks();
}
function removeAllEventCallbacks () {
mediaPlayer.removeAllEventCallbacks();
}
function resume () {
mediaPlayer.resume();
}
function resume () {
mediaPlayer.resume();
}
function pause (opts) {
mediaPlayer.pause();
opts = opts || {};
if (opts.disableAutoResume !== true) {
DynamicWindowUtils.autoResumeAtStartOfRange(
getCurrentTime(),
getSeekableRange(),
addEventCallback,
removeEventCallback,
MediaPlayerBase.unpausedEventCheck,
resume);
}
function pause (opts) {
mediaPlayer.pause();
opts = opts || {};
if (opts.disableAutoResume !== true) {
DynamicWindowUtils.autoResumeAtStartOfRange(
getCurrentTime(),
getSeekableRange(),
addEventCallback,
removeEventCallback,
MediaPlayerBase.unpausedEventCheck,
resume);
}
}
function getCurrentTime () {
return fakeTimer.currentTime + timeCorrection;
}
function getCurrentTime () {
return fakeTimer.currentTime + timeCorrection;
}
function getSeekableRange () {
var windowLength = (mediaSources.time().windowEndTime - mediaSources.time().windowStartTime) / 1000;
var delta = (Date.now() - startTime) / 1000;
return {
start: (windowType === WindowTypes.SLIDING ? delta : 0) + timeCorrection,
end: windowLength + delta + timeCorrection
};
}
function getSeekableRange () {
var windowLength = (mediaSources.time().windowEndTime - mediaSources.time().windowStartTime) / 1000;
var delta = (Date.now() - startTime) / 1000;
return {
beginPlayback: function () {
var config = deviceConfig;
start: (windowType === WindowTypes.SLIDING ? delta : 0) + timeCorrection,
end: windowLength + delta + timeCorrection
};
}
startTime = Date.now();
fakeTimer.currentTime = (mediaSources.time().windowEndTime - mediaSources.time().windowStartTime) / 1000;
return {
beginPlayback: function () {
var config = deviceConfig;
if (config && config.streaming && config.streaming.overrides && config.streaming.overrides.forceBeginPlaybackToEndOfWindow) {
mediaPlayer.beginPlaybackFrom(Infinity);
} else {
mediaPlayer.beginPlayback();
}
},
startTime = Date.now();
fakeTimer.currentTime = (mediaSources.time().windowEndTime - mediaSources.time().windowStartTime) / 1000;
beginPlaybackFrom: function (offset) {
startTime = Date.now();
fakeTimer.currentTime = offset;
mediaPlayer.beginPlaybackFrom(offset);
},
if (config && config.streaming && config.streaming.overrides && config.streaming.overrides.forceBeginPlaybackToEndOfWindow) {
mediaPlayer.beginPlaybackFrom(Infinity);
} else {
mediaPlayer.beginPlayback();
}
},
initialiseMedia: function (mediaType, sourceUrl, mimeType, sourceContainer, opts) {
if (mediaType === MediaPlayerBase.TYPE.AUDIO) {
mediaType = MediaPlayerBase.TYPE.LIVE_AUDIO;
} else {
mediaType = MediaPlayerBase.TYPE.LIVE_VIDEO;
}
beginPlaybackFrom: function (offset) {
startTime = Date.now();
fakeTimer.currentTime = offset;
mediaPlayer.beginPlaybackFrom(offset);
},
mediaPlayer.initialiseMedia(mediaType, sourceUrl, mimeType, sourceContainer, opts);
},
initialiseMedia: function (mediaType, sourceUrl, mimeType, sourceContainer, opts) {
if (mediaType === MediaPlayerBase.TYPE.AUDIO) {
mediaType = MediaPlayerBase.TYPE.LIVE_AUDIO;
} else {
mediaType = MediaPlayerBase.TYPE.LIVE_VIDEO;
}
pause: pause,
mediaPlayer.initialiseMedia(mediaType, sourceUrl, mimeType, sourceContainer, opts);
},
resume: resume,
pause: pause,
stop: function () {
mediaPlayer.stop();
},
resume: resume,
reset: function () {
mediaPlayer.reset();
},
stop: function () {
mediaPlayer.stop();
},
getState: function () {
return mediaPlayer.getState();
},
reset: function () {
mediaPlayer.reset();
},
getSource: function () {
return mediaPlayer.getSource();
},
getState: function () {
return mediaPlayer.getState();
},
getMimeType: function () {
return mediaPlayer.getMimeType();
},
getSource: function () {
return mediaPlayer.getSource();
},
addEventCallback: addEventCallback,
getMimeType: function () {
return mediaPlayer.getMimeType();
},
removeEventCallback: removeEventCallback,
addEventCallback: addEventCallback,
removeAllEventCallbacks: removeAllEventCallbacks,
removeEventCallback: removeEventCallback,
getPlayerElement: function () {
return mediaPlayer.getPlayerElement();
},
removeAllEventCallbacks: removeAllEventCallbacks,
getCurrentTime: getCurrentTime,
getPlayerElement: function () {
return mediaPlayer.getPlayerElement();
},
getSeekableRange: getSeekableRange
getCurrentTime: getCurrentTime,
};
}
getSeekableRange: getSeekableRange
return RestartableLivePlayer;
};
}
return RestartableLivePlayer;
}
);

188

script/playbackstrategy/modifiers/live/seekable.js
define(
'bigscreenplayer/playbackstrategy/modifiers/live/seekable',
'bigscreenplayer/playbackstrategy/modifiers/live/seekable',
[

@@ -7,120 +7,120 @@ 'bigscreenplayer/playbackstrategy/modifiers/mediaplayerbase',

],
function (MediaPlayerBase, DynamicWindowUtils) {
'use strict';
function (MediaPlayerBase, DynamicWindowUtils) {
'use strict';
function SeekableLivePlayer (mediaPlayer, deviceConfig) {
var AUTO_RESUME_WINDOW_START_CUSHION_SECONDS = 8;
function SeekableLivePlayer (mediaPlayer, deviceConfig) {
var AUTO_RESUME_WINDOW_START_CUSHION_SECONDS = 8;
function addEventCallback (thisArg, callback) {
mediaPlayer.addEventCallback(thisArg, callback);
}
function addEventCallback (thisArg, callback) {
mediaPlayer.addEventCallback(thisArg, callback);
}
function removeEventCallback (thisArg, callback) {
mediaPlayer.removeEventCallback(thisArg, callback);
}
function removeEventCallback (thisArg, callback) {
mediaPlayer.removeEventCallback(thisArg, callback);
}
function removeAllEventCallbacks () {
mediaPlayer.removeAllEventCallbacks();
}
function removeAllEventCallbacks () {
mediaPlayer.removeAllEventCallbacks();
}
function resume () {
mediaPlayer.resume();
}
function resume () {
mediaPlayer.resume();
}
return ({
initialiseMedia: function initialiseMedia (mediaType, sourceUrl, mimeType, sourceContainer, opts) {
if (mediaType === MediaPlayerBase.TYPE.AUDIO) {
mediaType = MediaPlayerBase.TYPE.LIVE_AUDIO;
} else {
mediaType = MediaPlayerBase.TYPE.LIVE_VIDEO;
}
return ({
initialiseMedia: function initialiseMedia (mediaType, sourceUrl, mimeType, sourceContainer, opts) {
if (mediaType === MediaPlayerBase.TYPE.AUDIO) {
mediaType = MediaPlayerBase.TYPE.LIVE_AUDIO;
} else {
mediaType = MediaPlayerBase.TYPE.LIVE_VIDEO;
}
mediaPlayer.initialiseMedia(mediaType, sourceUrl, mimeType, sourceContainer, opts);
},
mediaPlayer.initialiseMedia(mediaType, sourceUrl, mimeType, sourceContainer, opts);
},
beginPlayback: function beginPlayback () {
var config = deviceConfig;
if (config && config.streaming && config.streaming.overrides && config.streaming.overrides.forceBeginPlaybackToEndOfWindow) {
mediaPlayer.beginPlaybackFrom(Infinity);
} else {
mediaPlayer.beginPlayback();
}
},
beginPlayback: function beginPlayback () {
var config = deviceConfig;
if (config && config.streaming && config.streaming.overrides && config.streaming.overrides.forceBeginPlaybackToEndOfWindow) {
mediaPlayer.beginPlaybackFrom(Infinity);
} else {
mediaPlayer.beginPlayback();
}
},
beginPlaybackFrom: function beginPlaybackFrom (offset) {
mediaPlayer.beginPlaybackFrom(offset);
},
beginPlaybackFrom: function beginPlaybackFrom (offset) {
mediaPlayer.beginPlaybackFrom(offset);
},
playFrom: function playFrom (offset) {
mediaPlayer.playFrom(offset);
},
playFrom: function playFrom (offset) {
mediaPlayer.playFrom(offset);
},
pause: function pause (opts) {
opts = opts || {};
var secondsUntilStartOfWindow = mediaPlayer.getCurrentTime() - mediaPlayer.getSeekableRange().start;
pause: function pause (opts) {
opts = opts || {};
var secondsUntilStartOfWindow = mediaPlayer.getCurrentTime() - mediaPlayer.getSeekableRange().start;
if (opts.disableAutoResume) {
mediaPlayer.pause();
} else if (secondsUntilStartOfWindow <= AUTO_RESUME_WINDOW_START_CUSHION_SECONDS) {
mediaPlayer.toPaused();
mediaPlayer.toPlaying();
} else {
mediaPlayer.pause();
DynamicWindowUtils.autoResumeAtStartOfRange(
mediaPlayer.getCurrentTime(),
mediaPlayer.getSeekableRange(),
addEventCallback,
removeEventCallback,
MediaPlayerBase.unpausedEventCheck,
resume);
}
},
resume: resume,
if (opts.disableAutoResume) {
mediaPlayer.pause();
} else if (secondsUntilStartOfWindow <= AUTO_RESUME_WINDOW_START_CUSHION_SECONDS) {
mediaPlayer.toPaused();
mediaPlayer.toPlaying();
} else {
mediaPlayer.pause();
DynamicWindowUtils.autoResumeAtStartOfRange(
mediaPlayer.getCurrentTime(),
mediaPlayer.getSeekableRange(),
addEventCallback,
removeEventCallback,
MediaPlayerBase.unpausedEventCheck,
resume);
}
},
resume: resume,
stop: function stop () {
mediaPlayer.stop();
},
stop: function stop () {
mediaPlayer.stop();
},
reset: function reset () {
mediaPlayer.reset();
},
reset: function reset () {
mediaPlayer.reset();
},
getState: function getState () {
return mediaPlayer.getState();
},
getState: function getState () {
return mediaPlayer.getState();
},
getSource: function getSource () {
return mediaPlayer.getSource();
},
getSource: function getSource () {
return mediaPlayer.getSource();
},
getCurrentTime: function getCurrentTime () {
return mediaPlayer.getCurrentTime();
},
getCurrentTime: function getCurrentTime () {
return mediaPlayer.getCurrentTime();
},
getSeekableRange: function getSeekableRange () {
return mediaPlayer.getSeekableRange();
},
getSeekableRange: function getSeekableRange () {
return mediaPlayer.getSeekableRange();
},
getMimeType: function getMimeType () {
return mediaPlayer.getMimeType();
},
getMimeType: function getMimeType () {
return mediaPlayer.getMimeType();
},
addEventCallback: addEventCallback,
addEventCallback: addEventCallback,
removeEventCallback: removeEventCallback,
removeEventCallback: removeEventCallback,
removeAllEventCallbacks: removeAllEventCallbacks,
removeAllEventCallbacks: removeAllEventCallbacks,
getPlayerElement: function getPlayerElement () {
return mediaPlayer.getPlayerElement();
},
getPlayerElement: function getPlayerElement () {
return mediaPlayer.getPlayerElement();
},
getLiveSupport: function getLiveSupport () {
return MediaPlayerBase.LIVE_SUPPORT.SEEKABLE;
}
getLiveSupport: function getLiveSupport () {
return MediaPlayerBase.LIVE_SUPPORT.SEEKABLE;
}
});
}
});
}
return SeekableLivePlayer;
});
return SeekableLivePlayer;
});

98

script/playbackstrategy/modifiers/mediaplayerbase.js
define(
'bigscreenplayer/playbackstrategy/modifiers/mediaplayerbase',
function () {
var STATE = {
EMPTY: 'EMPTY', // No source set
STOPPED: 'STOPPED', // Source set but no playback
BUFFERING: 'BUFFERING', // Not enough data to play, waiting to download more
PLAYING: 'PLAYING', // Media is playing
PAUSED: 'PAUSED', // Media is paused
COMPLETE: 'COMPLETE', // Media has reached its end point
ERROR: 'ERROR' // An error occurred
};
'bigscreenplayer/playbackstrategy/modifiers/mediaplayerbase',
function () {
var STATE = {
EMPTY: 'EMPTY', // No source set
STOPPED: 'STOPPED', // Source set but no playback
BUFFERING: 'BUFFERING', // Not enough data to play, waiting to download more
PLAYING: 'PLAYING', // Media is playing
PAUSED: 'PAUSED', // Media is paused
COMPLETE: 'COMPLETE', // Media has reached its end point
ERROR: 'ERROR' // An error occurred
};
var EVENT = {
STOPPED: 'stopped', // Event fired when playback is stopped
BUFFERING: 'buffering', // Event fired when playback has to suspend due to buffering
PLAYING: 'playing', // Event fired when starting (or resuming) playing of the media
PAUSED: 'paused', // Event fired when media playback pauses
COMPLETE: 'complete', // Event fired when media playback has reached the end of the media
ERROR: 'error', // Event fired when an error condition occurs
STATUS: 'status', // Event fired regularly during play
SENTINEL_ENTER_BUFFERING: 'sentinel-enter-buffering', // Event fired when a sentinel has to act because the device has started buffering but not reported it
SENTINEL_EXIT_BUFFERING: 'sentinel-exit-buffering', // Event fired when a sentinel has to act because the device has finished buffering but not reported it
SENTINEL_PAUSE: 'sentinel-pause', // Event fired when a sentinel has to act because the device has failed to pause when expected
SENTINEL_PLAY: 'sentinel-play', // Event fired when a sentinel has to act because the device has failed to play when expected
SENTINEL_SEEK: 'sentinel-seek', // Event fired when a sentinel has to act because the device has failed to seek to the correct location
SENTINEL_COMPLETE: 'sentinel-complete', // Event fired when a sentinel has to act because the device has completed the media but not reported it
SENTINEL_PAUSE_FAILURE: 'sentinel-pause-failure', // Event fired when the pause sentinel has failed twice, so it is giving up
SENTINEL_SEEK_FAILURE: 'sentinel-seek-failure', // Event fired when the seek sentinel has failed twice, so it is giving up
SEEK_ATTEMPTED: 'seek-attempted', // Event fired when a device using a seekfinishedemitevent modifier sets the source
SEEK_FINISHED: 'seek-finished' // Event fired when a device using a seekfinishedemitevent modifier has seeked successfully
};
var EVENT = {
STOPPED: 'stopped', // Event fired when playback is stopped
BUFFERING: 'buffering', // Event fired when playback has to suspend due to buffering
PLAYING: 'playing', // Event fired when starting (or resuming) playing of the media
PAUSED: 'paused', // Event fired when media playback pauses
COMPLETE: 'complete', // Event fired when media playback has reached the end of the media
ERROR: 'error', // Event fired when an error condition occurs
STATUS: 'status', // Event fired regularly during play
SENTINEL_ENTER_BUFFERING: 'sentinel-enter-buffering', // Event fired when a sentinel has to act because the device has started buffering but not reported it
SENTINEL_EXIT_BUFFERING: 'sentinel-exit-buffering', // Event fired when a sentinel has to act because the device has finished buffering but not reported it
SENTINEL_PAUSE: 'sentinel-pause', // Event fired when a sentinel has to act because the device has failed to pause when expected
SENTINEL_PLAY: 'sentinel-play', // Event fired when a sentinel has to act because the device has failed to play when expected
SENTINEL_SEEK: 'sentinel-seek', // Event fired when a sentinel has to act because the device has failed to seek to the correct location
SENTINEL_COMPLETE: 'sentinel-complete', // Event fired when a sentinel has to act because the device has completed the media but not reported it
SENTINEL_PAUSE_FAILURE: 'sentinel-pause-failure', // Event fired when the pause sentinel has failed twice, so it is giving up
SENTINEL_SEEK_FAILURE: 'sentinel-seek-failure', // Event fired when the seek sentinel has failed twice, so it is giving up
SEEK_ATTEMPTED: 'seek-attempted', // Event fired when a device using a seekfinishedemitevent modifier sets the source
SEEK_FINISHED: 'seek-finished' // Event fired when a device using a seekfinishedemitevent modifier has seeked successfully
};
var TYPE = {
VIDEO: 'video',
AUDIO: 'audio',
LIVE_VIDEO: 'live-video',
LIVE_AUDIO: 'live-audio'
};
var TYPE = {
VIDEO: 'video',
AUDIO: 'audio',
LIVE_VIDEO: 'live-video',
LIVE_AUDIO: 'live-audio'
};
function unpausedEventCheck (event) {
if (event && event.state) {
return event.state !== STATE.PAUSED;
} else {
return undefined;
}
function unpausedEventCheck (event) {
if (event && event.state) {
return event.state !== STATE.PAUSED;
} else {
return undefined;
}
}
return {
STATE: STATE,
EVENT: EVENT,
TYPE: TYPE,
unpausedEventCheck: unpausedEventCheck
};
}
return {
STATE: STATE,
EVENT: EVENT,
TYPE: TYPE,
unpausedEventCheck: unpausedEventCheck
};
}
);

28

script/plugindata.js
define(
'bigscreenplayer/plugindata',
function () {
'use strict';
'bigscreenplayer/plugindata',
function () {
'use strict';
function PluginData (args) {
this.status = args.status;
this.stateType = args.stateType;
this.isBufferingTimeoutError = args.isBufferingTimeoutError || false;
this.isInitialPlay = args.isInitialPlay;
this.cdn = args.cdn;
this.newCdn = args.newCdn;
this.timeStamp = new Date();
}
function PluginData (args) {
this.status = args.status;
this.stateType = args.stateType;
this.isBufferingTimeoutError = args.isBufferingTimeoutError || false;
this.isInitialPlay = args.isInitialPlay;
this.cdn = args.cdn;
this.newCdn = args.newCdn;
this.timeStamp = new Date();
}
return PluginData;
}
return PluginData;
}
);

32

script/pluginenums.js
define(
'bigscreenplayer/pluginenums',
function () {
'use strict';
'bigscreenplayer/pluginenums',
function () {
'use strict';
return {
STATUS: {
STARTED: 'started',
DISMISSED: 'dismissed',
FATAL: 'fatal',
FAILOVER: 'failover'
},
TYPE: {
BUFFERING: 'buffering',
ERROR: 'error'
}
};
}
return {
STATUS: {
STARTED: 'started',
DISMISSED: 'dismissed',
FATAL: 'fatal',
FAILOVER: 'failover'
},
TYPE: {
BUFFERING: 'buffering',
ERROR: 'error'
}
};
}
);

236

script/utils/playbackutils.js
define(
'bigscreenplayer/utils/playbackutils',
function () {
'use strict';
'bigscreenplayer/utils/playbackutils',
function () {
'use strict';
return {
clone: function (args) {
var clone = {};
for (var prop in args) {
if (args.hasOwnProperty(prop)) {
clone[prop] = args[prop];
}
return {
clone: function (args) {
var clone = {};
for (var prop in args) {
if (args.hasOwnProperty(prop)) {
clone[prop] = args[prop];
}
return clone;
},
}
return clone;
},
deepClone: function (objectToClone) {
if (!objectToClone) {
return objectToClone;
}
deepClone: function (objectToClone) {
if (!objectToClone) {
return objectToClone;
}
var clone, propValue, propName;
clone = Array.isArray(objectToClone) ? [] : {};
for (propName in objectToClone) {
propValue = objectToClone[propName];
var clone, propValue, propName;
clone = Array.isArray(objectToClone) ? [] : {};
for (propName in objectToClone) {
propValue = objectToClone[propName];
// check for date
if (propValue && Object.prototype.toString.call(propValue) === '[object Date]') {
clone[propName] = new Date(propValue);
continue;
}
clone[propName] = (typeof propValue === 'object') ? this.deepClone(propValue) : propValue;
// check for date
if (propValue && Object.prototype.toString.call(propValue) === '[object Date]') {
clone[propName] = new Date(propValue);
continue;
}
return clone;
},
cloneArray: function (arr) {
var clone = [];
clone[propName] = (typeof propValue === 'object') ? this.deepClone(propValue) : propValue;
}
return clone;
},
for (var i = 0, n = arr.length; i < n; i++) {
clone.push(this.clone(arr[i]));
}
cloneArray: function (arr) {
var clone = [];
return clone;
},
for (var i = 0, n = arr.length; i < n; i++) {
clone.push(this.clone(arr[i]));
}
merge: function () {
var merged = {};
return clone;
},
for (var i = 0; i < arguments.length; i++) {
var obj = arguments[i];
for (var param in obj) {
merged[param] = obj[param];
}
merge: function () {
var merged = {};
for (var i = 0; i < arguments.length; i++) {
var obj = arguments[i];
for (var param in obj) {
merged[param] = obj[param];
}
}
return merged;
},
return merged;
},
arrayStartsWith: function (array, partial) {
for (var i = 0; i < partial.length; i++) {
if (array[i] !== partial[i]) {
return false;
}
arrayStartsWith: function (array, partial) {
for (var i = 0; i < partial.length; i++) {
if (array[i] !== partial[i]) {
return false;
}
}
return true;
},
return true;
},
find: function (array, predicate) {
return array.reduce(function (acc, it, i) {
return acc !== false ? acc : predicate(it) && it;
}, false);
},
find: function (array, predicate) {
return array.reduce(function (acc, it, i) {
return acc !== false ? acc : predicate(it) && it;
}, false);
},
findIndex: function (array, predicate) {
return array.reduce(function (acc, it, i) {
return acc !== false ? acc : predicate(it) && i;
}, false);
},
findIndex: function (array, predicate) {
return array.reduce(function (acc, it, i) {
return acc !== false ? acc : predicate(it) && i;
}, false);
},
swap: function (array, i, j) {
var arr = array.slice();
var temp = arr[i];
swap: function (array, i, j) {
var arr = array.slice();
var temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
arr[i] = arr[j];
arr[j] = temp;
return arr;
},
return arr;
},
pluck: function (array, property) {
var plucked = [];
pluck: function (array, property) {
var plucked = [];
for (var i = 0; i < array.length; i++) {
plucked.push(array[i][property]);
}
for (var i = 0; i < array.length; i++) {
plucked.push(array[i][property]);
}
return plucked;
},
return plucked;
},
flatten: function (arr) {
return [].concat.apply([], arr);
},
flatten: function (arr) {
return [].concat.apply([], arr);
},
without: function (arr, value) {
var newArray = [];
without: function (arr, value) {
var newArray = [];
for (var i = 0; i < arr.length; i++) {
if (arr[i] !== value) {
newArray.push(arr[i]);
}
for (var i = 0; i < arr.length; i++) {
if (arr[i] !== value) {
newArray.push(arr[i]);
}
}
return newArray;
},
return newArray;
},
contains: function (arr, subset) {
return [].concat(subset).every(function (item) { return [].concat(arr).indexOf(item) > -1; });
},
contains: function (arr, subset) {
return [].concat(subset).every(function (item) { return [].concat(arr).indexOf(item) > -1; });
},
pickRandomFromArray: function (arr) {
return arr[Math.floor(Math.random() * arr.length)];
},
pickRandomFromArray: function (arr) {
return arr[Math.floor(Math.random() * arr.length)];
},
filter: function (arr, predicate) {
var filteredArray = [];
filter: function (arr, predicate) {
var filteredArray = [];
for (var i = 0; i < arr.length; i++) {
if (predicate(arr[i])) {
filteredArray.push(arr[i]);
}
for (var i = 0; i < arr.length; i++) {
if (predicate(arr[i])) {
filteredArray.push(arr[i]);
}
}
return filteredArray;
},
return filteredArray;
},
noop: function () {},
noop: function () {},
generateUUID: function () {
var d = new Date().getTime();
generateUUID: function () {
var d = new Date().getTime();
return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
var r = (d + Math.random() * 16) % 16 | 0;
d = Math.floor(d / 16);
return (c === 'x' ? r : (r & 0x3 | 0x8)).toString(16);
});
},
return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
var r = (d + Math.random() * 16) % 16 | 0;
d = Math.floor(d / 16);
return (c === 'x' ? r : (r & 0x3 | 0x8)).toString(16);
});
},
path: function (object, keys) {
return (keys || []).reduce(function (accum, key) {
return (accum || {})[key];
}, object || {});
}
};
}
);
path: function (object, keys) {
return (keys || []).reduce(function (accum, key) {
return (accum || {})[key];
}, object || {});
}
};
}
);

2

script/version.js
define('bigscreenplayer/version',
function () {
return '3.14.1';
return '3.14.2';
}
);
.eslintrc

Sorry, the diff of this file is not supported yet

.travis.yml

Sorry, the diff of this file is not supported yet

docs/example-app/package-lock.json

Sorry, the diff of this file is too big to display

script-test/playbackstrategies/modifiers/html5tests.js

Sorry, the diff of this file is too big to display

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc