@npo/player 1.27.4 → 1.27.6

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

@@ -159,25 +159,25 @@ export default class NpoPlayer {
             }
             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);
-            this.hidePlayNextScreen();
             const streamDuration = _streamObject.metadata.duration;
             this.npoPlayerServices.startPlayerTracker({
                 playerContext: this.playerContext,
                 source: source,
                 duration: streamDuration ? Number(streamDuration) : undefined
             });
-            if (this.variant === NpoPlayerUIVariants.DEFAULT &&
-                this.streamObject.metadata.hasPreroll === 'true' &&
-                this.streamObject.assets.preroll) {
-                await this.npoPlayerServices.schedulePreRolls(this.playerContext);
-            }
         }
         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();
+        if (this.variant === NpoPlayerUIVariants.DEFAULT &&
+            this.streamObject.metadata.hasPreroll === 'true' &&
+            this.streamObject.assets.preroll) {
+            await this.npoPlayerServices.schedulePreRolls(this.playerContext);
+        }
         if (this.variant === NpoPlayerUIVariants.VERTICAL) {
             this.npoPlayerServices.handleVerticalVideoControls(this.playerContext);
             this.npoPlayerServices.handleVerticalVideoSettings(this.playerContext);
@@ -329,6 +329,7 @@ export default class NpoPlayer {
                 }
                 this.pause();
                 if (this.playerContext) {
+                    this.npoPlayerServices.removeEventListeners(this.playerContext);
                     this.npoPlayerServices.discardAdBreak(this.playerContext);
                 }
                 this.hidePlayNextScreen();

package/lib/package.json

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

package/lib/services/advertHandlers/handlePreRolls.js

@@ -124,7 +124,14 @@ export async function handlePreRolls(playerContext) {
             adUiSet = false;
             resolve();
         }
-        playerContext.player.on(NpoPlayerEvent.AdBreakFinished, handleAdBreakFinished);
-        playerContext.player.on(NpoPlayerEvent.AdError, handleAdBreakFinished);
+        const adBreakFinishedCallback = () => handleAdBreakFinished();
+        const adErrorCallback = () => handleAdBreakFinished();
+        playerContext.player.on(NpoPlayerEvent.AdBreakFinished, adBreakFinishedCallback);
+        playerContext.player.on(NpoPlayerEvent.AdError, adErrorCallback);
+        playerContext.npoPlayer.eventListeners = {
+            ...playerContext.npoPlayer.eventListeners,
+            adBreakFinishedCallback,
+            adErrorCallback
+        };
     });
 }

package/lib/services/eventListenerHandlers/removeEventListeners.js

@@ -2,11 +2,17 @@ import { NpoPlayerEvent } from '../../types/events';
 export const removeEventListeners = (playerContext) => {
     const { eventListeners } = playerContext.npoPlayer;
     if (eventListeners) {
-        const { segmentHandleTimeChangedCallback, segmentSeekFunctionCallback, liveStreamHandleTimeChangedCallback } = 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.Seek, callback: segmentSeekFunctionCallback },
+            { event: NpoPlayerEvent.AdBreakFinished, callback: adBreakFinishedCallback },
+            { 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/liveStreamHandlers/handleLiveStreamControls.js

@@ -4,6 +4,7 @@ export const handleLiveStreamControls = (playerContext) => {
     const { player, npoPlayer } = playerContext;
     player.on(NpoPlayerEvent.TimeChanged, liveStreamHandleTimeChangedCallback);
     npoPlayer.eventListeners = {
+        ...npoPlayer.eventListeners,
         liveStreamHandleTimeChangedCallback
     };
 };

package/lib/services/segmentHandlers/addSegmentEventListeners.js

@@ -8,6 +8,7 @@ export const addSegmentEventListeners = (playerContext, segment) => {
     player.on(NpoPlayerEvent.TimeChanged, segmentHandleTimeChangedCallback);
     player.on(NpoPlayerEvent.Seek, segmentSeekFunctionCallback);
     npoPlayer.eventListeners = {
+        ...npoPlayer.eventListeners,
         segmentHandleTimeChangedCallback,
         segmentSeekFunctionCallback
     };

package/lib/services/services.d.ts

@@ -26,4 +26,5 @@ export declare class NpoPlayerServices {
     startPlayerTracker({ playerContext, source, duration }: PlayerTrackerParams): void;
     initPlayerTracker(playerContext: PlayerContext): void;
     logEvent({ playerContext, event, data }: LogEventParams): void;
+    removeEventListeners(playerContext: PlayerContext): void;
 }

package/lib/services/services.js

@@ -16,6 +16,7 @@ import { handleStreamOptions } from './streamoptionsHandlers/streamOptionsHandle
 import { handlePlayerError } from './errors/errorHandler';
 import { fetchStream } from './streamFetchHandler/fetchStream';
 import { startPlayerTracker, initPlayerTracker, logEvent } from './trackingHandlers';
+import { removeEventListeners } from './eventListenerHandlers/removeEventListeners';
 export class NpoPlayerServices {
     getAVType(avType) {
         return getAVType(avType);
@@ -104,4 +105,7 @@ export class NpoPlayerServices {
     logEvent({ playerContext, event, data }) {
         logEvent({ playerContext, event, data });
     }
+    removeEventListeners(playerContext) {
+        removeEventListeners(playerContext);
+    }
 }

package/lib/services/streamoptionsHandlers/streamOptionsHandler.js

@@ -1,14 +1,12 @@
 import * as playerAction from '../../js/playeractions/playeractions';
 import { initSegment } from '../segmentHandlers/initSegment';
 import { handleLiveStreamControls } from '../liveStreamHandlers/handleLiveStreamControls';
-import { removeEventListeners } from '../eventListenerHandlers/removeEventListeners';
 import { NpoPlayerEvent } from '../../types/events';
 import { updateClassFromElementByQuery } from '../../js/utilities/utilities.element';
 export function handleStreamOptions(playerContext) {
     const { streamObject, uiManager } = playerContext.npoPlayer;
     if (!streamObject || !uiManager)
         return;
-    removeEventListeners(playerContext);
     initializeFragment(playerContext);
     handleStartOffset(playerContext);
     updateStreamClasses(playerContext);

package/lib/src/services/services.d.ts

@@ -26,4 +26,5 @@ export declare class NpoPlayerServices {
     startPlayerTracker({ playerContext, source, duration }: PlayerTrackerParams): void;
     initPlayerTracker(playerContext: PlayerContext): void;
     logEvent({ playerContext, event, data }: LogEventParams): void;
+    removeEventListeners(playerContext: PlayerContext): void;
 }

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

@@ -19,6 +19,12 @@ export interface EventListeners {
     liveStreamHandleTimeChangedCallback?: NpoPlayerEventCallback;
     segmentHandleTimeChangedCallback?: NpoPlayerEventCallback;
     segmentSeekFunctionCallback?: NpoPlayerEventCallback;
+    adBreakFinishedCallback?: NpoPlayerEventCallback;
+    adErrorCallback?: NpoPlayerEventCallback;
+    handleStartOffsetCallbackOnReady?: NpoPlayerEventCallback;
+    handleStartOffsetCallbackOnSourceLoaded?: NpoPlayerEventCallback;
+    handleStartOffsetCallbackOnAdBreakFinished?: NpoPlayerEventCallback;
+    handleStartOffsetCallbackOnAdError?: NpoPlayerEventCallback;
 }
 export interface StreamObject {
     stream: StreamObject_Stream;

package/lib/types/interfaces.d.ts

@@ -19,6 +19,12 @@ export interface EventListeners {
     liveStreamHandleTimeChangedCallback?: NpoPlayerEventCallback;
     segmentHandleTimeChangedCallback?: NpoPlayerEventCallback;
     segmentSeekFunctionCallback?: NpoPlayerEventCallback;
+    adBreakFinishedCallback?: NpoPlayerEventCallback;
+    adErrorCallback?: NpoPlayerEventCallback;
+    handleStartOffsetCallbackOnReady?: NpoPlayerEventCallback;
+    handleStartOffsetCallbackOnSourceLoaded?: NpoPlayerEventCallback;
+    handleStartOffsetCallbackOnAdBreakFinished?: NpoPlayerEventCallback;
+    handleStartOffsetCallbackOnAdError?: NpoPlayerEventCallback;
 }
 export interface StreamObject {
     stream: StreamObject_Stream;

package/package.json

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