@npo/player 1.26.0 → 1.27.0

package/README.md

@@ -11,7 +11,7 @@ Extensive and up-to-date documentation is available at https://docs.npoplayer.nl
 Code quality is analysed by SonarCloud. The project can be found at https://sonarcloud.io/project/overview?id=NPOstart_npo-player
 
 # Changelog
-Current version: v1.26.0
+Current version: v1.27.0
 
 The changelog is available at https://docs.npoplayer.nl/implementation/web/changelog/
 

package/lib/js/playeractions/handlers/mediasessionactions.js

@@ -91,7 +91,7 @@ export function setupMediaSessionActionHandlers(player, sourceConfig, _streamObj
             },
             {
                 action: 'play',
-                handler: () => player.play()
+                handler: () => void player.play()
             },
             {
                 action: 'pause',
@@ -99,7 +99,7 @@ export function setupMediaSessionActionHandlers(player, sourceConfig, _streamObj
             },
             {
                 action: 'stop',
-                handler: () => player.unload()
+                handler: () => void player.unload()
             }
         ];
         for (const { action, handler } of actionHandlers) {

package/lib/js/playeractions/playeractions.d.ts

@@ -1,4 +1,3 @@
 export { handleStartOffset, handleLiveOffsetLogic, shiftToProgramStart } from './handlers/handleoffsets';
-export { handlePlayerError } from './handlers/error';
 export { processPlayerConfig } from './handlers/processplayerconfig';
 export { processSourceConfig } from './handlers/processsourceconfig';

package/lib/js/playeractions/playeractions.js

@@ -1,4 +1,3 @@
 export { handleStartOffset, handleLiveOffsetLogic, shiftToProgramStart } from './handlers/handleoffsets';
-export { handlePlayerError } from './handlers/error';
 export { processPlayerConfig } from './handlers/processplayerconfig';
 export { processSourceConfig } from './handlers/processsourceconfig';

package/lib/js/utilities/utilities.prid.d.ts

@@ -0,0 +1,6 @@
+import { SourceConfig, StreamObject } from 'types/interfaces';
+export declare function getAnalyticsPrid(params: {
+    source: string;
+    sourceConfig?: SourceConfig;
+    streamObject?: StreamObject;
+}): string;

package/lib/js/utilities/utilities.prid.js

@@ -0,0 +1,8 @@
+import { isJWTToken } from './utilities.jwt';
+export function getAnalyticsPrid(params) {
+    const { source, sourceConfig, streamObject } = params;
+    if (isJWTToken(source)) {
+        return streamObject?.metadata?.prid ?? '';
+    }
+    return sourceConfig?.metadata?.prid ?? source;
+}

package/lib/js/utilities/utilities.prid.test.js

@@ -0,0 +1,46 @@
+import { mockStreamObject } from '../../../tests/mocks/mockStreamObject';
+import { getAnalyticsPrid } from './utilities.prid';
+describe('getAnalyticsPrid', () => {
+    it('should return the prid from streamObject if the source is a JWT token', () => {
+        const result = getAnalyticsPrid({
+            source: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c',
+            sourceConfig: undefined,
+            streamObject: {
+                ...mockStreamObject,
+                metadata: {
+                    ...mockStreamObject.metadata,
+                    prid: '123'
+                }
+            }
+        });
+        expect(result).toBe('123');
+    });
+    it('should return an empty string if the source is a JWT token but no prid is present in streamObject', () => {
+        const result = getAnalyticsPrid({
+            source: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c',
+            sourceConfig: undefined,
+            streamObject: {
+                ...mockStreamObject
+            }
+        });
+        expect(result).toBe('');
+    });
+    it('should return the prid from sourceConfig if the source is a media file URL', () => {
+        const result = getAnalyticsPrid({
+            source: 'https://example.com/media/video.mp4',
+            sourceConfig: { metadata: { prid: '456' } },
+            streamObject: undefined
+        });
+        expect(result).toBe('456');
+    });
+    it('should return the source (media file URL) if no prid is found', () => {
+        const result = getAnalyticsPrid({
+            source: 'https://example.com/media/audio.mp3',
+            sourceConfig: undefined,
+            streamObject: {
+                ...mockStreamObject
+            }
+        });
+        expect(result).toBe('https://example.com/media/audio.mp3');
+    });
+});

package/lib/npoplayer.d.ts

@@ -41,9 +41,9 @@ export default class NpoPlayer {
         variant?: NpoPlayerUIVariants;
         npoTagPageTracker?: PageTracker | undefined;
     }, playerConfig?: PlayerConfig | undefined, npoTag?: InitialisationProps | undefined, npoTagInstance?: NPOTag | undefined, variant?: NpoPlayerUIVariants, npoTagPageTracker?: PageTracker | undefined);
+    keydownHandler: (e: KeyboardEvent) => void;
     initPlayer(_container: HTMLElement, playerConfig: PlayerConfig): void;
     loadStream(source: string, options?: StreamOptions): Promise<void>;
-    doError(input: any, status?: number): void;
     play(): Promise<void>;
     pause(): void;
     setVolume(volume: number): void;

package/lib/npoplayer.js

@@ -1,15 +1,12 @@
 import { NpoPlayerServices } from './services/services';
 import { Player, PlayerEvent } from 'bitmovin-player';
 import AdsModuleBM from 'bitmovin-player/modules/bitmovinplayer-advertising-bitmovin';
-import { logEvent, initPlayerTracker, startPlayerTracker } from './js/tracking/playertracker';
 import { hidePlayNextScreen, showPlayNextScreenIfNeeded } from './ui/handlers/playnextscreen';
 import * as playerAction from './js/playeractions/playeractions';
 import { getModuleExport } from './js/utilities/utilities.module';
-import { getStreamObject } from './js/api/getstreamobject';
 import { isJWTToken } from './js/utilities/utilities.jwt';
 import { isMediaUrl, isUrl } from './js/utilities/utilities.url';
 import { logVersion } from './js/utilities/utilities.version';
-import { getStreamDurationInSeconds } from './js/utilities/utilities.stream';
 import { LogEmitter } from './types/classes';
 import pkg from '../package.json';
 import { NpoPlayerUIVariants } from './types/interfaces';
@@ -18,16 +15,12 @@ import { setupMediaSessionActionHandlers } from './js/playeractions/handlers/med
 import { removeReplayClass } from './js/playeractions/handlers/removereplayclass';
 import { updateLiveMarkers } from './js/markers/updateLiveMarkers';
 import { NpoPlayerAPI } from './services/npoPlayerAPI/npoPlayerAPI';
+import { emptyStreamObject } from './services/npoPlayerAPI/contants';
 export { NpoPlayerUIVariants };
 export default class NpoPlayer {
     constructor(container, playerConfig, npoTag, npoTagInstance, variant, npoTagPageTracker) {
         this.sourceConfig = {};
-        this.streamObject = {
-            stream: { drmType: '', streamProfile: '', streamURL: '', avType: '', sourceProfile: '' },
-            metadata: { title: '', description: '' },
-            assets: { scrubbingThumbnail: '', subtitles: [] },
-            user: { type: 'anonymous' }
-        };
+        this.streamObject = emptyStreamObject;
         this.player = undefined;
         this.uiManager = undefined;
         this.npoTagInitialisation = undefined;
@@ -47,6 +40,11 @@ export default class NpoPlayer {
         this.playerContext = undefined;
         this.npoPlayerServices = new NpoPlayerServices();
         this.eventListeners = undefined;
+        this.keydownHandler = (e) => {
+            if (!this.playerContext)
+                return;
+            this.npoPlayerServices.keyboardHandler(this.playerContext, e);
+        };
         if (typeof container === 'object' && !(container instanceof HTMLElement)) {
             const params = container;
             this.container = params.container;
@@ -69,9 +67,6 @@ export default class NpoPlayer {
             console.error('Player configuration is missing. Ensure that playerConfig is properly initialized before using the player.');
             return;
         }
-        if (this.npoTagInstance) {
-            initPlayerTracker(this, this.npoTagInitialisation, this.npoTagInstance, this.npoTagPageTracker);
-        }
         this.initPlayer(this.container, this.playerConfig);
     }
     initPlayer(_container, playerConfig) {
@@ -80,36 +75,30 @@ export default class NpoPlayer {
         Player.addModule(getModuleExport(AdsModuleBM));
         const npoPlayerAPI = new NpoPlayerAPI(this.player);
         this.playerContext = { player: npoPlayerAPI, npoPlayer: this };
+        this.npoPlayerServices.initPlayerTracker(this.playerContext);
         this.npoPlayerServices.handleUserPrefs(this.playerContext);
         this.npoPlayerServices.setAccessibilityAttributes(this.playerContext);
         this.npoPlayerServices.handlePreferences(this.playerContext);
-        this.container.addEventListener('keydown', (e) => {
-            if (!this.playerContext)
-                return;
-            this.npoPlayerServices.keyboardHandler(this.playerContext, e);
-        }, true);
+        this.container.addEventListener('keydown', this.keydownHandler, true);
     }
     async loadStream(source, options = {}) {
-        if (!this.playerContext)
-            return;
-        this.streamOptions = options;
-        if (!this.player) {
+        if (!this.playerContext || !this.player) {
             console.error('Er is nog geen player geladen.');
             return;
         }
+        this.streamOptions = options;
+        this.playerContext.player.removeClassFromNpoPlayerElement('npo-player-error');
         this.npoPlayerServices.discardAdBreak(this.playerContext);
         let _streamObject;
         const sourceIsUrl = isUrl(source);
         const sourceIsMedia = await isMediaUrl(source);
         const sourceIsJWTToken = isJWTToken(source);
-        const getDurationAndStartPlayerTracker = function () {
-            if (this.player === null)
-                return;
-            const prid = (isJWTToken(source) ? this.streamObject?.metadata.prid : source) || 'unknown';
-            const duration = this.player ? this.player.getDuration() : undefined;
-            startPlayerTracker(this, getStreamDurationInSeconds({ duration: duration }), this.version, prid);
-        }.bind(this);
+        if (this.streamOptions.npoTagPageTracker) {
+            this.npoTagPageTracker = this.streamOptions.npoTagPageTracker;
+        }
         if (sourceIsUrl && sourceIsMedia) {
+            _streamObject = emptyStreamObject;
+            this.streamObject = _streamObject;
             this.sourceConfig = {
                 ...options.sourceConfig,
                 progressive: source,
@@ -120,9 +109,13 @@ export default class NpoPlayer {
                     customData5: this.version
                 }
             };
-            await this.playerContext.player.createUIManager(this.playerContext, this.variant);
+            void this.playerContext.player.createUIManager(this.playerContext, this.variant);
             await this.playerContext.player?.load(this.sourceConfig);
-            getDurationAndStartPlayerTracker();
+            this.npoPlayerServices.startPlayerTracker({
+                playerContext: this.playerContext,
+                source: source,
+                duration: undefined
+            });
         }
         else if (sourceIsJWTToken) {
             this.jwt = source;
@@ -143,37 +136,37 @@ export default class NpoPlayer {
                     }
                 }
             };
-            await this.playerContext.player.createUIManager(this.playerContext, this.variant);
+            void this.playerContext.player.createUIManager(this.playerContext, this.variant);
             try {
-                _streamObject = await getStreamObject(this, payload);
+                _streamObject = await this.npoPlayerServices.fetchStream(this.playerContext, payload);
                 this.streamObject = _streamObject;
             }
-            catch (error) {
-                this.doError('Het is niet gelukt de stream op te halen. \n' + error);
+            catch {
                 this.player.pause();
                 return;
             }
             if (this.streamObject?.stream == undefined)
                 return;
             const drmType = this.streamObject.stream.drmType ?? undefined;
+            if (drmType !== undefined && drmType !== profile.drm) {
+                await this.npoPlayerServices.handleError(this.playerContext, 2007);
+                return;
+            }
             this.sourceConfig = await playerAction.processSourceConfig(this.npoPlayerServices, source, options.sourceConfig ?? {}, this.streamObject, drmType && drmType.length > 0 ? profile.drm : undefined, this.streamOptions, this.version, this.npoTag?.npoTagInstance);
             await this.npoPlayerServices.verifyDRM(this.playerContext, payload);
             setupMediaSessionActionHandlers(this.player, this.sourceConfig, _streamObject);
-            logEvent(this, 'load');
-            let streamDuration = _streamObject.metadata.duration;
-            const streamPrid = this.streamObject.metadata.prid || _streamObject.metadata.prid;
-            if (this.isShowingPlayNextScreen) {
-                this.hidePlayNextScreen();
-            }
+            this.hidePlayNextScreen();
+            const streamDuration = _streamObject.metadata.duration;
             const initAndStartTracker = () => {
-                if (this.player === null)
+                if (!this.playerContext || !this.player)
                     return;
                 this.player?.off(PlayerEvent.AdBreakFinished, initAndStartTracker);
                 this.player?.off(PlayerEvent.AdError, initAndStartTracker);
-                streamDuration =
-                    streamDuration == undefined
-                        ? getDurationAndStartPlayerTracker()
-                        : startPlayerTracker(this, getStreamDurationInSeconds({ duration: streamDuration, durationIsInMs: true }), this.version, streamPrid);
+                this.npoPlayerServices.startPlayerTracker({
+                    playerContext: this.playerContext,
+                    source: source,
+                    duration: streamDuration ? Number(streamDuration) : undefined
+                });
             };
             if (this.variant === NpoPlayerUIVariants.DEFAULT &&
                 this.streamObject.metadata.hasPreroll === 'true' &&
@@ -187,14 +180,14 @@ export default class NpoPlayer {
             }
         }
         else {
-            this.doError(`Het is niet gelukt de stream op te halen: \n Input is geen valide token of media object.`, 500);
+            await this.npoPlayerServices.handleError(this.playerContext, 500);
         }
         this.npoPlayerServices.handleStreamOptions(this.playerContext);
         this.npoPlayerServices.setupNicamKijkwijzerIcons(this.playerContext);
-        this.player.on(PlayerEvent.Ready, () => {
-            this.npoPlayerServices.showNicamAfterUiDelay(this.playerContext);
-        });
-        this.npoPlayerServices.handleVerticalVideoControls(this.playerContext, this.variant);
+        if (this.variant === NpoPlayerUIVariants.VERTICAL) {
+            this.npoPlayerServices.handleVerticalVideoControls(this.playerContext);
+            this.npoPlayerServices.handleVerticalVideoSettings(this.playerContext);
+        }
         this.player.on(PlayerEvent.Seek, () => {
             removeReplayClass(this.player);
         });
@@ -214,14 +207,6 @@ export default class NpoPlayer {
         }.bind(this);
         this.player.on(PlayerEvent.Ready, setLiveOffsetListener);
     }
-    doError(input, status) {
-        if (!this.player)
-            return;
-        if (status) {
-            this.logEmitter.emit('logError', status);
-        }
-        playerAction.handlePlayerError(this.player, this.uiComponents, input);
-    }
     async play() {
         await this.playerContext?.player.play();
     }
@@ -300,6 +285,8 @@ export default class NpoPlayer {
         this.streamOptions.playNext?.cancelCallback?.();
     }
     hidePlayNextScreen() {
+        if (!this.isShowingPlayNextScreen)
+            return;
         this.player?.off(PlayerEvent.Paused, () => {
             this.hidePlayNextScreen();
         });
@@ -316,12 +303,16 @@ export default class NpoPlayer {
                 if (this.npoTag != undefined) {
                     clearInterval(this.npoTag?.heartbeatInterval);
                 }
-                logEvent(this, 'stop');
                 if (this.playerContext) {
+                    this.npoPlayerServices.logEvent({
+                        playerContext: this.playerContext,
+                        event: 'stop'
+                    });
                     this.npoPlayerServices.removeUivisiblityHandlers(this.playerContext);
                 }
                 this.uiManager?.release();
                 this.uiManager = undefined;
+                this.container.removeEventListener('keydown', this.keydownHandler, true);
                 await this.player?.destroy();
                 return true;
             }

package/lib/npoplayer.test.js

@@ -7,12 +7,12 @@ jest.mock('./services/streamoptionsHandlers/streamOptionsHandler', () => ({
     handleStreamOptions: jest.fn()
 }));
 let player;
-test('player init with parameters', async () => {
+test('player init with parameters', () => {
     player = new NpoPlayer(div, testPlayerConfig);
     expect(player).toBeInstanceOf(NpoPlayer);
     expect(player.playerConfig?.key).toBe(testPlayerConfig.key);
 });
-test('player init with parameters', async () => {
+test('player init with parameters', () => {
     player = new NpoPlayer({
         container: div,
         playerConfig: testPlayerConfig

package/lib/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@npo/player",
-  "version": "1.26.0",
+  "version": "1.27.0",
   "description": "NPO Player",
   "author": "Publieke Omroep <player@npo.nl>",
   "contributors": [

package/lib/services/a11y/setup.test.js

@@ -41,7 +41,6 @@ describe('setupAccessibilityAttributes', () => {
                 playerConfig: {},
                 initPlayer: () => { },
                 loadStream: () => Promise.resolve(),
-                doError: () => { },
                 play: async () => { },
                 pause: () => { },
                 setVolume: () => { },

package/lib/services/advertHandlers/discardAdBreak.js

@@ -1,8 +1,10 @@
+import { NpoPlayerUIVariants } from '../../types/interfaces';
 export function discardAdBreak(playerContext) {
     const { npoPlayer, player } = playerContext;
     const { adBreakActive } = npoPlayer;
     if (!player || adBreakActive === false)
         return;
+    void playerContext.player.createUIManager(playerContext, NpoPlayerUIVariants.DEFAULT);
     const activeAdBreak = player.getActiveAdBreak();
     if (activeAdBreak?.id) {
         player.playerAPI.ads.discardAdBreak(activeAdBreak.id);

package/lib/services/advertHandlers/discardAdBreak.test.js

@@ -1,4 +1,5 @@
 import createPlayerContextMock, { createMockNpoPlayer, createMockNpoPlayerAPI } from '../../../tests/mocks/playerContextMock';
+import { NpoPlayerUIVariants } from '../../types/interfaces';
 import { discardAdBreak } from './discardAdBreak';
 describe('discardAdBreak', () => {
     let mockNpoPlayerAPI;
@@ -34,11 +35,13 @@ describe('discardAdBreak', () => {
         expect(mockNpoPlayerAPI.getActiveAdBreak).not.toHaveBeenCalled();
         expect(mockNpoPlayerAPI.playerAPI.ads.discardAdBreak).not.toHaveBeenCalled();
         expect(npoPlayerMock.adBreakActive).toBe(false);
+        expect(playerContextMock.player.createUIManager).not.toHaveBeenCalled();
     });
     it('should discard active ad break if adBreakActive is true and ad break exists', () => {
         mockNpoPlayerAPI = createMockNpoPlayerAPI({
             getActiveAdBreak: jest.fn().mockReturnValue(activeAdBreakMock),
-            discardAdBreak: jest.fn()
+            discardAdBreak: jest.fn(),
+            variant: NpoPlayerUIVariants.AD
         });
         npoPlayerMock = createMockNpoPlayer({
             adBreakActive: true
@@ -51,6 +54,7 @@ describe('discardAdBreak', () => {
         expect(mockNpoPlayerAPI.getActiveAdBreak).toHaveBeenCalled();
         expect(mockNpoPlayerAPI.playerAPI.ads.discardAdBreak).toHaveBeenCalledWith(activeAdBreakMock.id);
         expect(npoPlayerMock.adBreakActive).toBe(false);
+        expect(playerContextMock.player.createUIManager).toHaveBeenCalledWith(playerContextMock, NpoPlayerUIVariants.DEFAULT);
     });
     it('should not discard ad break if active ad break does not exist', () => {
         mockNpoPlayerAPI = createMockNpoPlayerAPI({
@@ -68,5 +72,6 @@ describe('discardAdBreak', () => {
         expect(mockNpoPlayerAPI.getActiveAdBreak).toHaveBeenCalled();
         expect(mockNpoPlayerAPI.playerAPI.ads.discardAdBreak).not.toHaveBeenCalled();
         expect(npoPlayerMock.adBreakActive).toBe(false);
+        expect(playerContextMock.player.createUIManager).toHaveBeenCalledWith(playerContextMock, NpoPlayerUIVariants.DEFAULT);
     });
 });

package/lib/services/advertHandlers/handlePreRolls.js

@@ -26,7 +26,7 @@ export async function handlePreRolls(playerContext) {
             await playerContext.player.scheduleAds(advertConfig);
         }
         playerContext.player.on(NpoPlayerEvent.Ready, handleReady);
-        async function handlePlay() {
+        function handlePlay() {
             playerContext.player.off(NpoPlayerEvent.Play, handlePlay);
             attemptSetAdUi();
         }
@@ -37,9 +37,7 @@ export async function handlePreRolls(playerContext) {
                 return false;
             playerContext.npoPlayer.uiManager?.release();
             playerContext.npoPlayer.uiManager = undefined;
-            if (playerContext.npoPlayer.playerContext) {
-                void playerContext.player.createUIManager(playerContext, NpoPlayerUIVariants.AD);
-            }
+            void playerContext.player.createUIManager(playerContext, NpoPlayerUIVariants.AD);
             adUiSet = true;
             const adButton = playerContext.npoPlayer.uiComponents.adbutton;
             const currentAd = activeAdBreak.ads[0];

package/lib/services/advertHandlers/handlePrerolls.test.js

@@ -1,4 +1,5 @@
 import { handlePreRolls } from './handlePreRolls';
+import { PlayerEvent } from 'bitmovin-player/modules/bitmovinplayer-core';
 import { createMockNpoPlayer, createPlayerContextMock } from '../../../tests/mocks/playerContextMock';
 jest.mock('bitmovin-player');
 jest.mock('../../npoplayer');
@@ -11,7 +12,8 @@ describe('handlePreRolls', () => {
                 getActiveAdBreak: jest.fn()
             },
             on: jest.fn(),
-            off: jest.fn()
+            off: jest.fn(),
+            scheduleAds: jest.fn()
         };
     });
     it('should not schedule ads when hasPreroll is false', async () => {
@@ -49,4 +51,63 @@ describe('handlePreRolls', () => {
     afterEach(() => {
         jest.clearAllMocks();
     });
+    it('should schedule ads when hasPreroll is true and preroll URL exists', async () => {
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        const npoPlayerMock = createMockNpoPlayer({
+            streamObject: {
+                metadata: {
+                    hasPreroll: 'true'
+                },
+                assets: {
+                    preroll: 'sample_url'
+                }
+            }
+        });
+        const playerContextMock = createPlayerContextMock({
+            npoPlayer: npoPlayerMock,
+            player: mockPlayerAPI
+        });
+        const readyCallback = jest.fn();
+        mockPlayerAPI.on.mockImplementation((event, callback) => {
+            if (event === PlayerEvent.Ready) {
+                readyCallback.mockImplementation(callback);
+            }
+        });
+        void handlePreRolls(playerContextMock);
+        readyCallback();
+        expect(playerContextMock.player.scheduleAds).toHaveBeenCalledWith({
+            tag: {
+                url: 'sample_url',
+                type: 'vast'
+            },
+            id: 'Ad',
+            position: 'pre'
+        });
+    });
+    it('should cleanup UI and resolve when AdBreakFinished event occurs', async () => {
+        const npoPlayerMock = createMockNpoPlayer({
+            streamObject: {
+                metadata: {
+                    hasPreroll: 'true'
+                },
+                assets: {
+                    preroll: 'sample_url'
+                }
+            }
+        });
+        const playerContextMock = createPlayerContextMock({
+            npoPlayer: npoPlayerMock,
+            player: mockPlayerAPI
+        });
+        const adBreakFinishedHandler = jest.fn();
+        mockPlayerAPI.on.mockImplementation((event, handler) => {
+            if (event === PlayerEvent.AdBreakFinished) {
+                adBreakFinishedHandler.mockImplementation(handler);
+            }
+        });
+        const handlePromise = handlePreRolls(playerContextMock);
+        adBreakFinishedHandler();
+        await handlePromise;
+        expect(playerContextMock.npoPlayer.uiManager).toBeUndefined();
+    });
 });

package/lib/services/drmHandlers/decideprofile.js

@@ -15,7 +15,7 @@ export async function decideProfile(playerContext, preferredDRM = '') {
     }
     const { bestWithDRM, bestDRM } = determineBestWithDRM(supportedTech, { supportedDRM, preferredDRM });
     const bestWithoutDRM = determineBestWithoutDRM(supportedTech);
-    return bestWithDRM ? { profileName: bestWithDRM, drm: bestDRM } : { profileName: bestWithoutDRM, drm: bestDRM };
+    return bestWithDRM ? { profileName: bestWithDRM, drm: bestDRM } : { profileName: bestWithoutDRM, drm: '' };
 }
 function determineBestWithDRM(supportedTech, drmInfo) {
     let bestWithDRM = '';
@@ -33,6 +33,12 @@ function determineBestWithDRM(supportedTech, drmInfo) {
             continue;
         if (techMap[tech.streaming]) {
             const { drm, stream } = techMap[tech.streaming];
+            if ((drmInfo.preferredDRM === DRM_TYPES.PLAYREADY || drmInfo.supportedDRM.includes(DRM_TYPES.PLAYREADY)) &&
+                tech.streaming === STREAM_TYPES.DASH) {
+                bestWithDRM = STREAM_TYPES.DASH;
+                bestDRM = DRM_TYPES.PLAYREADY;
+                break;
+            }
             if (drmInfo.preferredDRM !== drm) {
                 bestDRM =
                     tech.streaming === STREAM_TYPES.DASH ? getBestDRMForDash(drmInfo) : getBestDRMForHls(drmInfo);

package/lib/services/drmHandlers/decideprofile.test.js

@@ -31,4 +31,8 @@ describe('decideProfile', () => {
         const result = await decideProfile(mockPlayerContext, DRM_TYPES.FAIRPLAY);
         expect(result).toEqual({ profileName: STREAM_TYPES.HLS, drm: DRM_TYPES.FAIRPLAY });
     });
+    it('should return profile with dash streaming and playready DRM when preferred DRM is PlayReady', async () => {
+        const result = await decideProfile(mockPlayerContext, DRM_TYPES.PLAYREADY);
+        expect(result).toEqual({ profileName: STREAM_TYPES.DASH, drm: DRM_TYPES.PLAYREADY });
+    });
 });

package/lib/services/drmHandlers/verifydrm.js

@@ -1,5 +1,4 @@
 import { convertJwtToBase64, convertBase64ToObject } from '../../js/utilities/utilities.jwt';
-import { getStreamObject } from '../../js/api/getstreamobject';
 export async function verifyDRM(playerContext, payload) {
     try {
         const { player, npoPlayer: { streamObject, sourceConfig } } = playerContext;
@@ -29,12 +28,12 @@ function getDRMTokenTimestamp(drmToken) {
     return convertBase64ToObject(drmBase64).iat;
 }
 async function refreshDRMToken(playerContext, payload) {
-    const backupStreamObject = await getStreamObject(playerContext.npoPlayer, payload);
-    const newDrmToken = backupStreamObject.stream.drmToken;
+    const { npoPlayer: { npoPlayerServices, streamObject, sourceConfig } } = playerContext;
+    const { stream: { drmToken: newDrmToken } } = await npoPlayerServices.fetchStream(playerContext, payload);
     const clonedStreamObject = {
-        ...playerContext.npoPlayer.streamObject,
-        stream: { ...playerContext.npoPlayer.streamObject.stream, drmToken: newDrmToken }
+        ...streamObject,
+        stream: { ...streamObject.stream, drmToken: newDrmToken }
     };
     playerContext.npoPlayer.streamObject = clonedStreamObject;
-    await loadPlayer(playerContext, playerContext.npoPlayer.sourceConfig);
+    await loadPlayer(playerContext, sourceConfig);
 }

package/lib/services/drmHandlers/verifydrm.test.js

@@ -1,23 +1,41 @@
 import { verifyDRM } from './verifydrm';
 import { mockNpoPlayer } from '../../../tests/mocks/mockNpoplayer';
 import { convertBase64ToObject, convertJwtToBase64 } from '../../js/utilities/utilities.jwt';
-import { getStreamObject } from '../../js/api/getstreamobject';
 jest.mock('../../js/utilities/utilities.jwt', () => ({
     convertBase64ToObject: jest.fn(),
     convertJwtToBase64: jest.fn()
 }));
-jest.mock('../../js/api/getstreamobject', () => ({
-    getStreamObject: jest.fn()
+jest.mock('../streamFetchHandler/fetchStream', () => ({
+    fetchStream: jest.fn()
 }));
 let mockPlayer;
 const mockNpoplayer = mockNpoPlayer;
 let mockPlayerContext;
+function createMockStreamObject(overrides = {}) {
+    return {
+        stream: {
+            avType: '',
+            drmType: '',
+            streamProfile: '',
+            sourceProfile: '',
+            streamURL: '',
+            drmToken: 'newToken'
+        },
+        metadata: { description: 'default description', title: 'default title' },
+        assets: { scrubbingThumbnail: 'thumbnail.jpg', subtitles: [] },
+        user: { type: 'anonymous' },
+        ...overrides
+    };
+}
 beforeEach(() => {
     jest.clearAllMocks();
     mockPlayer = {
         streamObject: { stream: { drmToken: undefined } },
         load: jest.fn()
     };
+    mockNpoplayer.npoPlayerServices = {
+        fetchStream: jest.fn()
+    };
     mockPlayerContext = { player: mockPlayer, npoPlayer: mockNpoplayer };
 });
 afterEach(() => {
@@ -66,10 +84,15 @@ describe('Test DRM verification', () => {
         jest.spyOn(global.Date, 'now').mockImplementation(() => currentTime * 1000);
         convertJwtToBase64.mockReturnValue(JSON.stringify({ iat: drmJsonTimestamp }));
         convertBase64ToObject.mockReturnValue({ iat: drmJsonTimestamp });
-        getStreamObject.mockResolvedValue({ stream: { drmToken: 'newToken' } });
+        jest.spyOn(mockNpoplayer.npoPlayerServices, 'fetchStream').mockResolvedValue(createMockStreamObject({
+            stream: {
+                ...createMockStreamObject().stream,
+                drmToken: 'overriddenToken'
+            }
+        }));
         jest.spyOn(mockPlayerContext.player, 'load').mockResolvedValue(undefined);
         await verifyDRM(mockPlayerContext, payload);
-        expect(getStreamObject).toHaveBeenCalledWith(mockPlayerContext.npoPlayer, payload);
+        expect(mockNpoplayer.npoPlayerServices.fetchStream).toHaveBeenCalledWith(mockPlayerContext, payload);
         expect(mockPlayerContext.player.load).toHaveBeenCalledWith(sourceConfig);
     });
     it('should call loadPlayer when the drmToken is null', async () => {