@npo/player 1.27.5 → 1.27.7

package/lib/js/playeractions/handlers/handleoffsets.js

@@ -8,16 +8,23 @@ export function handleStartOffset(playerContext, offset) {
         return;
     }
     const seek = () => {
-        player.off(NpoPlayerEvent.Ready, seek);
-        player.off(NpoPlayerEvent.SourceLoaded, seek);
-        player.off(NpoPlayerEvent.AdBreakFinished, seek);
-        player.off(NpoPlayerEvent.AdError, seek);
         player.seek(offset);
     };
-    player.on(NpoPlayerEvent.Ready, seek);
-    player.on(NpoPlayerEvent.SourceLoaded, seek);
-    player.on(NpoPlayerEvent.AdBreakFinished, seek);
-    player.on(NpoPlayerEvent.AdError, seek);
+    const handleStartOffsetCallbackOnReady = () => seek();
+    const handleStartOffsetCallbackOnSourceLoaded = () => seek();
+    const handleStartOffsetCallbackOnAdBreakFinished = () => seek();
+    const handleStartOffsetCallbackOnAdError = () => seek();
+    playerContext.player.on(NpoPlayerEvent.Ready, handleStartOffsetCallbackOnReady);
+    playerContext.player.on(NpoPlayerEvent.SourceLoaded, handleStartOffsetCallbackOnSourceLoaded);
+    playerContext.player.on(NpoPlayerEvent.AdBreakFinished, handleStartOffsetCallbackOnAdBreakFinished);
+    playerContext.player.on(NpoPlayerEvent.AdError, handleStartOffsetCallbackOnAdError);
+    playerContext.npoPlayer.eventListeners = {
+        ...playerContext.npoPlayer.eventListeners,
+        handleStartOffsetCallbackOnReady,
+        handleStartOffsetCallbackOnSourceLoaded,
+        handleStartOffsetCallbackOnAdBreakFinished,
+        handleStartOffsetCallbackOnAdError
+    };
 }
 export function shiftToProgramStart(playerContext, timestamp) {
     const { player } = playerContext;

package/lib/npoplayer.js

@@ -114,12 +114,12 @@ export default class NpoPlayer {
                     customData5: this.version
                 }
             };
+            this.npoPlayerServices.handleStreamOptions(this.playerContext);
             void this.playerContext.player.createUIManager(this.playerContext, this.variant);
             await this.playerContext.player?.load(this.sourceConfig);
             this.npoPlayerServices.startPlayerTracker({
                 playerContext: this.playerContext,
-                source: source,
-                duration: undefined
+                source: source
             });
         }
         else if (sourceIsJWTToken) {
@@ -158,6 +158,7 @@ export default class NpoPlayer {
                 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);
+            this.npoPlayerServices.handleStreamOptions(this.playerContext);
             await this.npoPlayerServices.verifyDRM(this.playerContext, payload);
             const streamDuration = _streamObject.metadata.duration;
             this.npoPlayerServices.startPlayerTracker({
@@ -169,7 +170,6 @@ export default class NpoPlayer {
         else {
             await this.npoPlayerServices.handleError(this.playerContext, 500);
         }
-        this.npoPlayerServices.handleStreamOptions(this.playerContext);
         this.npoPlayerServices.setupNicamKijkwijzerIcons(this.playerContext);
         setupMediaSessionActionHandlers(this.player, this.sourceConfig, this.streamObject);
         this.hidePlayNextScreen();

package/lib/package.json

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

package/lib/services/eventListenerHandlers/removeEventListeners.js

@@ -2,13 +2,17 @@ import { NpoPlayerEvent } from '../../types/events';
 export const removeEventListeners = (playerContext) => {
     const { eventListeners } = playerContext.npoPlayer;
     if (eventListeners) {
-        const { segmentHandleTimeChangedCallback, segmentSeekFunctionCallback, liveStreamHandleTimeChangedCallback, adBreakFinishedCallback, adErrorCallback } = eventListeners;
+        const { segmentHandleTimeChangedCallback, segmentSeekFunctionCallback, liveStreamHandleTimeChangedCallback, adBreakFinishedCallback, adErrorCallback, handleStartOffsetCallbackOnReady, handleStartOffsetCallbackOnSourceLoaded, handleStartOffsetCallbackOnAdBreakFinished, handleStartOffsetCallbackOnAdError } = eventListeners;
         const eventMapping = [
             { event: NpoPlayerEvent.TimeChanged, callback: liveStreamHandleTimeChangedCallback },
             { event: NpoPlayerEvent.TimeChanged, callback: segmentHandleTimeChangedCallback },
             { event: NpoPlayerEvent.Seek, callback: segmentSeekFunctionCallback },
             { event: NpoPlayerEvent.AdBreakFinished, callback: adBreakFinishedCallback },
-            { event: NpoPlayerEvent.AdError, callback: adErrorCallback }
+            { event: NpoPlayerEvent.AdError, callback: adErrorCallback },
+            { event: NpoPlayerEvent.Ready, callback: handleStartOffsetCallbackOnReady },
+            { event: NpoPlayerEvent.SourceLoaded, callback: handleStartOffsetCallbackOnSourceLoaded },
+            { event: NpoPlayerEvent.AdBreakFinished, callback: handleStartOffsetCallbackOnAdBreakFinished },
+            { event: NpoPlayerEvent.AdError, callback: handleStartOffsetCallbackOnAdError }
         ];
         for (const { event, callback } of eventMapping) {
             if (callback) {

package/lib/services/eventListenerHandlers/removeEventListeners.test.js

@@ -7,36 +7,30 @@ describe('removeEventListeners', () => {
         jest.clearAllMocks();
         mockPlayerContext = createPlayerContextMock();
     });
-    it('should remove TimeChanged event listener if exists', () => {
-        mockPlayerContext.npoPlayer.eventListeners = {
+    it('should remove all event listeners if they exist', () => {
+        const eventListeners = {
             segmentHandleTimeChangedCallback: jest.fn(),
             liveStreamHandleTimeChangedCallback: jest.fn(),
-            segmentSeekFunctionCallback: jest.fn()
-        };
-        removeEventListeners(mockPlayerContext);
-        if (mockPlayerContext.npoPlayer.eventListeners) {
-            expect(mockPlayerContext.player.off).toHaveBeenCalledWith(NpoPlayerEvent.TimeChanged, mockPlayerContext.npoPlayer.eventListeners.segmentHandleTimeChangedCallback);
-            expect(mockPlayerContext.player.off).toHaveBeenCalledWith(NpoPlayerEvent.TimeChanged, mockPlayerContext.npoPlayer.eventListeners.liveStreamHandleTimeChangedCallback);
-        }
-    });
-    it('should remove Seek event listener if exists', () => {
-        mockPlayerContext.npoPlayer.eventListeners = {
-            segmentHandleTimeChangedCallback: jest.fn(),
-            liveStreamHandleTimeChangedCallback: jest.fn(),
-            segmentSeekFunctionCallback: jest.fn()
-        };
-        removeEventListeners(mockPlayerContext);
-        if (mockPlayerContext.npoPlayer.eventListeners) {
-            expect(mockPlayerContext.player.off).toHaveBeenCalledWith(NpoPlayerEvent.Seek, mockPlayerContext.npoPlayer.eventListeners.segmentSeekFunctionCallback);
-        }
-    });
-    it('should reset EventListeners in playerContext', () => {
-        mockPlayerContext.npoPlayer.eventListeners = {
-            segmentHandleTimeChangedCallback: jest.fn(),
-            liveStreamHandleTimeChangedCallback: jest.fn(),
-            segmentSeekFunctionCallback: jest.fn()
+            segmentSeekFunctionCallback: jest.fn(),
+            adBreakFinishedCallback: jest.fn(),
+            adErrorCallback: jest.fn(),
+            handleStartOffsetCallbackOnReady: jest.fn(),
+            handleStartOffsetCallbackOnSourceLoaded: jest.fn(),
+            handleStartOffsetCallbackOnAdBreakFinished: jest.fn(),
+            handleStartOffsetCallbackOnAdError: jest.fn()
         };
+        mockPlayerContext.npoPlayer.eventListeners = { ...eventListeners };
         removeEventListeners(mockPlayerContext);
+        expect(mockPlayerContext.player.off).toHaveBeenCalledTimes(9);
+        expect(mockPlayerContext.player.off).toHaveBeenCalledWith(NpoPlayerEvent.TimeChanged, eventListeners.liveStreamHandleTimeChangedCallback);
+        expect(mockPlayerContext.player.off).toHaveBeenCalledWith(NpoPlayerEvent.TimeChanged, eventListeners.segmentHandleTimeChangedCallback);
+        expect(mockPlayerContext.player.off).toHaveBeenCalledWith(NpoPlayerEvent.Seek, eventListeners.segmentSeekFunctionCallback);
+        expect(mockPlayerContext.player.off).toHaveBeenCalledWith(NpoPlayerEvent.AdBreakFinished, eventListeners.adBreakFinishedCallback);
+        expect(mockPlayerContext.player.off).toHaveBeenCalledWith(NpoPlayerEvent.AdError, eventListeners.adErrorCallback);
+        expect(mockPlayerContext.player.off).toHaveBeenCalledWith(NpoPlayerEvent.Ready, eventListeners.handleStartOffsetCallbackOnReady);
+        expect(mockPlayerContext.player.off).toHaveBeenCalledWith(NpoPlayerEvent.SourceLoaded, eventListeners.handleStartOffsetCallbackOnSourceLoaded);
+        expect(mockPlayerContext.player.off).toHaveBeenCalledWith(NpoPlayerEvent.AdBreakFinished, eventListeners.handleStartOffsetCallbackOnAdBreakFinished);
+        expect(mockPlayerContext.player.off).toHaveBeenCalledWith(NpoPlayerEvent.AdError, eventListeners.handleStartOffsetCallbackOnAdError);
         expect(mockPlayerContext.npoPlayer.eventListeners).toBeUndefined();
     });
 });

package/lib/services/npoPlayerAPI/npoPlayerAPI.js

@@ -172,6 +172,7 @@ export class NpoPlayerAPI {
             playerContext.npoPlayer.uiManager = uiManager;
             playerContext.npoPlayer.variant = variant;
             npoPlayerServices.addUivisiblityHandlers(playerContext);
+            npoPlayerServices.setupNicamKijkwijzerIcons(playerContext);
             npoPlayerServices.showNicamAfterUiDelay(playerContext);
         }
     }

package/lib/services/streamoptionsHandlers/streamOptionsHandler.js

@@ -70,7 +70,8 @@ export function setupAutoplay(playerContext) {
     };
     const doAutoPlay = async () => {
         player.off(NpoPlayerEvent.Ready, handleAutoPlay);
+        player.off(NpoPlayerEvent.SourceLoaded, handleAutoPlay);
         await player.play();
     };
-    player.on(NpoPlayerEvent.Ready, handleAutoPlay);
+    player.on(NpoPlayerEvent.SourceLoaded, handleAutoPlay);
 }

package/lib/services/streamoptionsHandlers/streamOptionsHandler.test.js

@@ -178,7 +178,7 @@ describe('handleStreamOptions', () => {
                 player: mockNpoPlayerAPI
             });
             setupAutoplay(playerContextMock);
-            expect(playerContextMock.player.on).toHaveBeenCalledWith(NpoPlayerEvent.Ready, expect.any(Function));
+            expect(playerContextMock.player.on).toHaveBeenCalledWith(NpoPlayerEvent.SourceLoaded, expect.any(Function));
             const handleAutoPlay = playerContextMock.player.on.mock.calls[0][1];
             await handleAutoPlay();
             expect(playerContextMock.player.play).toHaveBeenCalled();

package/lib/services/trackingHandlers/playerTrackerStart.js

@@ -17,7 +17,7 @@ export const startPlayerTracker = function ({ playerContext, source, duration })
     }) || 'unknown';
     npoPlayer.streamTracker = initStreamTracker({
         playerContext: playerContext,
-        duration: getStreamDurationInSeconds({ duration: playerDuration }),
+        duration: getStreamDurationInSeconds({ duration: playerDuration, durationIsInMs: !!duration }),
         source: analyticsPrid
     });
     bindPlayerEvents(playerContext);

package/lib/services/trackingHandlers/playerTrackerStart.test.js

@@ -22,31 +22,32 @@ jest.mock('./eventLogging', () => ({
 }));
 describe('startPlayerTracker', () => {
     let playerContextMock;
+    let playerMock;
     beforeEach(() => {
+        playerMock = { getDuration: jest.fn().mockReturnValue(200) };
         playerContextMock = createPlayerContextMock({
             npoPlayer: {
-                npoTag: undefined,
-                npoTagInitialisation: undefined,
-                npoTagInstance: undefined,
-                npoTagPageTracker: undefined
+                player: playerMock,
+                sourceConfig: {},
+                streamObject: {}
             }
         });
         jest.clearAllMocks();
     });
-    it('should initialize the stream tracker with correct parameters', () => {
+    it('should initialize the stream tracker with the provided duration', () => {
         const source = 'some-source';
         const duration = 150;
         getAnalyticsPrid.mockReturnValue('some-prid');
         getStreamDurationInSeconds.mockReturnValue(duration);
-        startPlayerTracker({
-            playerContext: playerContextMock,
-            source,
-            duration
-        });
+        startPlayerTracker({ playerContext: playerContextMock, source, duration });
         expect(getAnalyticsPrid).toHaveBeenCalledWith({
             source,
-            sourceConfig: undefined,
-            streamObject: undefined
+            sourceConfig: {},
+            streamObject: {}
+        });
+        expect(getStreamDurationInSeconds).toHaveBeenCalledWith({
+            duration,
+            durationIsInMs: true
         });
         expect(initStreamTracker).toHaveBeenCalledWith({
             playerContext: playerContextMock,
@@ -56,4 +57,20 @@ describe('startPlayerTracker', () => {
         expect(bindPlayerEvents).toHaveBeenCalledWith(playerContextMock);
         expect(logEvent).toHaveBeenCalledWith({ playerContext: playerContextMock, event: 'load' });
     });
+    it('should fallback to player.getDuration() if duration is not provided', () => {
+        const source = 'some-source';
+        const fallbackDuration = 200;
+        getAnalyticsPrid.mockReturnValue('some-prid');
+        getStreamDurationInSeconds.mockReturnValue(fallbackDuration);
+        startPlayerTracker({ playerContext: playerContextMock, source });
+        expect(getStreamDurationInSeconds).toHaveBeenCalledWith({
+            duration: fallbackDuration,
+            durationIsInMs: false
+        });
+        expect(initStreamTracker).toHaveBeenCalledWith({
+            playerContext: playerContextMock,
+            duration: fallbackDuration,
+            source: 'some-prid'
+        });
+    });
 });

package/lib/src/types/interfaces.d.ts

@@ -21,6 +21,10 @@ export interface EventListeners {
     segmentSeekFunctionCallback?: NpoPlayerEventCallback;
     adBreakFinishedCallback?: NpoPlayerEventCallback;
     adErrorCallback?: NpoPlayerEventCallback;
+    handleStartOffsetCallbackOnReady?: NpoPlayerEventCallback;
+    handleStartOffsetCallbackOnSourceLoaded?: NpoPlayerEventCallback;
+    handleStartOffsetCallbackOnAdBreakFinished?: NpoPlayerEventCallback;
+    handleStartOffsetCallbackOnAdError?: NpoPlayerEventCallback;
 }
 export interface StreamObject {
     stream: StreamObject_Stream;
@@ -230,8 +234,8 @@ export type LocalStorageData = Partial<Record<LocalStorageValues, string | numbe
 export type NPOGoogleCastRemoteControlConfig = GoogleCastRemoteControlConfig;
 export interface PlayerTrackerParams {
     playerContext: PlayerContext;
-    duration: number | undefined;
-    source: string | undefined;
+    duration?: number;
+    source?: string;
 }
 export interface LogEventParams {
     playerContext: PlayerContext;

package/lib/types/interfaces.d.ts

@@ -21,6 +21,10 @@ export interface EventListeners {
     segmentSeekFunctionCallback?: NpoPlayerEventCallback;
     adBreakFinishedCallback?: NpoPlayerEventCallback;
     adErrorCallback?: NpoPlayerEventCallback;
+    handleStartOffsetCallbackOnReady?: NpoPlayerEventCallback;
+    handleStartOffsetCallbackOnSourceLoaded?: NpoPlayerEventCallback;
+    handleStartOffsetCallbackOnAdBreakFinished?: NpoPlayerEventCallback;
+    handleStartOffsetCallbackOnAdError?: NpoPlayerEventCallback;
 }
 export interface StreamObject {
     stream: StreamObject_Stream;
@@ -230,8 +234,8 @@ export type LocalStorageData = Partial<Record<LocalStorageValues, string | numbe
 export type NPOGoogleCastRemoteControlConfig = GoogleCastRemoteControlConfig;
 export interface PlayerTrackerParams {
     playerContext: PlayerContext;
-    duration: number | undefined;
-    source: string | undefined;
+    duration?: number;
+    source?: string;
 }
 export interface LogEventParams {
     playerContext: PlayerContext;

package/package.json

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