@amazon-devices/kepler-player-server 2.2.3

package/dist/turbo-modules/PlayerServer.js

@@ -0,0 +1,642 @@
+/*
+ * Copyright 2025 Amazon.com, Inc. or its affiliates. All rights reserved.
+ *
+ * AMAZON PROPRIETARY/CONFIDENTIAL
+ *
+ * You may not use this file except in compliance with the terms and
+ * conditions set forth in the accompanying LICENSE.TXT file.
+ *
+ * THESE MATERIALS ARE PROVIDED ON AN "AS IS" BASIS. AMAZON SPECIFICALLY
+ * DISCLAIMS, WITH RESPECT TO THESE MATERIALS, ALL WARRANTIES, EXPRESS,
+ * IMPLIED, OR STATUTORY, INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+ */
+import { IUnloadSyncStatus } from './PlayerServerDataTypes/PlayerServerDataTypes';
+import KeplerPlayerServerTurboModule from './KeplerPlayerServerTurboModule';
+/**
+ * @ignore
+ * The implementation of IPlayerServer.
+ */
+export class PlayerServer {
+    mServerHandler = null;
+    mPositionListenerMap = new Map();
+    clearPositionListeners(sessionId, listenerId) {
+        let _sessionId = sessionId ? sessionId.id : -1;
+        const sessionListeners = this.mPositionListenerMap.get(_sessionId);
+        if (!sessionListeners) {
+            // no listener for session, nothing to do
+            return false;
+        }
+        if (!listenerId) {
+            // not deleting specific listener, clear all timers and delete map entry for session.
+            sessionListeners.forEach(value => {
+                clearInterval(value[1]);
+            });
+            this.mPositionListenerMap.delete(_sessionId);
+        }
+        else {
+            // clear specific timer and update listener map
+            const match = sessionListeners.find(value => value[0] == listenerId);
+            if (!match) {
+                // listenerId not found
+                return false;
+            }
+            clearInterval(match[1]);
+            const remainingListeners = sessionListeners?.filter(values => values[0] != listenerId);
+            if (remainingListeners) {
+                this.mPositionListenerMap.set(_sessionId, remainingListeners);
+            }
+            else {
+                this.mPositionListenerMap.delete(_sessionId);
+            }
+        }
+        return true;
+    }
+    handleEvent(result, transactionId) {
+        console.log('KeplerPlayerServer: handleEvent with callback event ', result.event);
+        if (this.mServerHandler === null) {
+            return;
+        }
+        let resultCallback = result.event;
+        if (resultCallback === "handleLoad") {
+            try {
+                this.mServerHandler.handleLoad(result.urlInfo, result.loadParams, result.sessionId);
+                console.log("handleLoad: Success.");
+                KeplerPlayerServerTurboModule.transactionSuccess(transactionId);
+            }
+            catch (error) {
+                let message = "Unknown";
+                if (error instanceof Error) {
+                    message = error.message;
+                }
+                console.log(`handleLoad: Error: ${message}`);
+                KeplerPlayerServerTurboModule.transactionError(transactionId, message);
+            }
+        }
+        else if (resultCallback === "handleUnload") {
+            try {
+                this.clearPositionListeners(result.sessionId);
+                this.mServerHandler.handleUnload(result.sessionId);
+                console.log("handleUnload: Success.");
+                KeplerPlayerServerTurboModule.transactionSuccess(transactionId);
+            }
+            catch (error) {
+                let message = "Unknown";
+                if (error instanceof Error) {
+                    message = error.message;
+                }
+                console.log(`handleUnload: Error: ${message}`);
+                KeplerPlayerServerTurboModule.transactionError(transactionId, message);
+            }
+        }
+        else if (resultCallback === "handleSetVideoView") {
+            try {
+                this.mServerHandler.handleSetVideoView(result.handle, result.sessionId);
+                console.log("handleSetVideoView: Success.");
+                KeplerPlayerServerTurboModule.transactionSuccess(transactionId);
+            }
+            catch (error) {
+                let message = "Unknown";
+                if (error instanceof Error) {
+                    message = error.message;
+                }
+                console.log(`handleSetVideoView: Error: ${message}`);
+                KeplerPlayerServerTurboModule.transactionError(transactionId, message);
+            }
+        }
+        else if (resultCallback === "handleClearVideoView") {
+            try {
+                this.mServerHandler.handleClearVideoView(result.sessionId);
+                console.log("handleClearVideoView: Success.");
+                KeplerPlayerServerTurboModule.transactionSuccess(transactionId);
+            }
+            catch (error) {
+                let message = "Unknown";
+                if (error instanceof Error) {
+                    message = error.message;
+                }
+                console.log(`handleClearVideoView: Error: ${message}`);
+                KeplerPlayerServerTurboModule.transactionError(transactionId, message);
+            }
+        }
+        else if (resultCallback === "handleSetTextView") {
+            try {
+                this.mServerHandler.handleSetTextView(result.handle, result.sessionId);
+                console.log("handleSetTextView: Success.");
+                KeplerPlayerServerTurboModule.transactionSuccess(transactionId);
+            }
+            catch (error) {
+                let message = "Unknown";
+                if (error instanceof Error) {
+                    message = error.message;
+                }
+                console.log(`handleSetTextView: Error: ${message}`);
+                KeplerPlayerServerTurboModule.transactionError(transactionId, message);
+            }
+        }
+        else if (resultCallback === "handleClearTextView") {
+            try {
+                this.mServerHandler.handleClearTextView(result.sessionId);
+                console.log("handleClearTextView: Success.");
+                KeplerPlayerServerTurboModule.transactionSuccess(transactionId);
+            }
+            catch (error) {
+                let message = "Unknown";
+                if (error instanceof Error) {
+                    message = error.message;
+                }
+                console.log(`handleClearTextView: Error: ${message}`);
+                KeplerPlayerServerTurboModule.transactionError(transactionId, message);
+            }
+        }
+        else if (resultCallback === "handlePlay") {
+            try {
+                this.mServerHandler.handlePlay(result.sessionId);
+                console.log("handlePlay: Success.");
+                KeplerPlayerServerTurboModule.transactionSuccess(transactionId);
+            }
+            catch (error) {
+                let message = "Unknown";
+                if (error instanceof Error) {
+                    message = error.message;
+                }
+                console.log(`handlePlay: Error: ${message}`);
+                KeplerPlayerServerTurboModule.transactionError(transactionId, message);
+            }
+        }
+        else if (resultCallback === "handlePause") {
+            try {
+                this.mServerHandler.handlePause(result.sessionId);
+                console.log("handlePause: Success.");
+                KeplerPlayerServerTurboModule.transactionSuccess(transactionId);
+            }
+            catch (error) {
+                let message = "Unknown";
+                if (error instanceof Error) {
+                    message = error.message;
+                }
+                console.log(`handlePause: Error: ${message}`);
+                KeplerPlayerServerTurboModule.transactionError(transactionId, message);
+            }
+        }
+        else if (resultCallback === "handleSeek") {
+            try {
+                this.mServerHandler.handleSeek(result.timevalue, result.boolValue, result.sessionId);
+                console.log("handleSeek: Success.");
+                KeplerPlayerServerTurboModule.transactionSuccess(transactionId);
+            }
+            catch (error) {
+                let message = "Unknown";
+                if (error instanceof Error) {
+                    message = error.message;
+                }
+                console.log(`handleSeek: Error: ${message}`);
+                KeplerPlayerServerTurboModule.transactionError(transactionId, message);
+            }
+        }
+        else if (resultCallback === "handleSetMute") {
+            try {
+                this.mServerHandler.handleSetMute(result.boolValue, result.sessionId);
+                console.log("handleSetMute: Success.");
+                KeplerPlayerServerTurboModule.transactionSuccess(transactionId);
+            }
+            catch (error) {
+                let message = "Unknown";
+                if (error instanceof Error) {
+                    message = error.message;
+                }
+                console.log(`handleSetMute: Error: ${message}`);
+                KeplerPlayerServerTurboModule.transactionError(transactionId, message);
+            }
+        }
+        else if (resultCallback === "handleSetPlaybackRate") {
+            try {
+                this.mServerHandler.handleSetPlaybackRate(result.numberValue, result.sessionId);
+                console.log("handleSetPlaybackRate: Success.");
+                KeplerPlayerServerTurboModule.transactionSuccess(transactionId);
+            }
+            catch (error) {
+                let message = "Unknown";
+                if (error instanceof Error) {
+                    message = error.message;
+                }
+                console.log(`handleSetPlaybackRate: Error: ${message}`);
+                KeplerPlayerServerTurboModule.transactionError(transactionId, message);
+            }
+        }
+        else if (resultCallback === "handleSetVolume") {
+            try {
+                this.mServerHandler.handleSetVolume(result.numberValue, result.sessionId);
+                console.log("handleSetVolume: Success.");
+                KeplerPlayerServerTurboModule.transactionSuccess(transactionId);
+            }
+            catch (error) {
+                let message = "Unknown";
+                if (error instanceof Error) {
+                    message = error.message;
+                }
+                console.log(`handleSetVolume: Error: ${message}`);
+                KeplerPlayerServerTurboModule.transactionError(transactionId, message);
+            }
+        }
+        else if (resultCallback === "handleSetActiveTrack") {
+            try {
+                this.mServerHandler.handleSetActiveTrack(result.trackType, result.stringValue, result.sessionId);
+                console.log("handleSetActiveTrack: Success.");
+                KeplerPlayerServerTurboModule.transactionSuccess(transactionId);
+            }
+            catch (error) {
+                let message = "Unknown";
+                if (error instanceof Error) {
+                    message = error.message;
+                }
+                console.log(`handleSetActiveTrack: Error: ${message}`);
+                KeplerPlayerServerTurboModule.transactionError(transactionId, message);
+            }
+        }
+        else if (resultCallback === "handleGetCurrentPosition") {
+            try {
+                let position = this.mServerHandler.handleGetCurrentPosition(result.sessionId);
+                console.log("handleGetCurrentPosition: Success.");
+                KeplerPlayerServerTurboModule.transactionSuccessWithValue(transactionId, { positionValue: position });
+            }
+            catch (error) {
+                let message = "Unknown";
+                if (error instanceof Error) {
+                    message = error.message;
+                }
+                console.log(`handleGetCurrentPosition: Error: ${message}`);
+                KeplerPlayerServerTurboModule.transactionError(transactionId, message);
+            }
+        }
+        else if (resultCallback === "handleMessage") {
+            try {
+                let messageObj = JSON.parse(result.stringValue);
+                this.mServerHandler.handleMessage(messageObj, result.sessionId);
+                console.log("handleMessage: Success.");
+                KeplerPlayerServerTurboModule.transactionSuccess(transactionId);
+            }
+            catch (error) {
+                let message = "Unknown";
+                if (error instanceof Error) {
+                    message = error.message;
+                }
+                console.log(`handleMessage: Error: ${message}`);
+                KeplerPlayerServerTurboModule.transactionError(transactionId, message);
+            }
+        }
+        else if (resultCallback === "handleStartBufferedRangesUpdates") {
+            try {
+                this.mServerHandler.handleStartBufferedRangesUpdates(result.sessionId);
+                console.log("handleStartBufferedRangesUpdates: Success.");
+                KeplerPlayerServerTurboModule.transactionSuccess(transactionId);
+            }
+            catch (error) {
+                let message = "Unknown";
+                if (error instanceof Error) {
+                    message = error.message;
+                }
+                console.log(`handleStartBufferedRangesUpdates: Error: ${message}`);
+                KeplerPlayerServerTurboModule.transactionError(transactionId, message);
+            }
+        }
+        else if (resultCallback === "handleStopBufferedRangesUpdates") {
+            try {
+                this.mServerHandler.handleStopBufferedRangesUpdates(result.sessionId);
+                console.log("handleStopBufferedRangesUpdates: Success.");
+                KeplerPlayerServerTurboModule.transactionSuccess(transactionId);
+            }
+            catch (error) {
+                let message = "Unknown";
+                if (error instanceof Error) {
+                    message = error.message;
+                }
+                console.log(`handleStopBufferedRangesUpdates: Error: ${message}`);
+                KeplerPlayerServerTurboModule.transactionError(transactionId, message);
+            }
+        }
+        else if (resultCallback === "handleStartStatusUpdates") {
+            try {
+                this.mServerHandler.handleStartStatusUpdates(result.sessionId);
+                console.log("handleStartStatusUpdates: Success.");
+                KeplerPlayerServerTurboModule.transactionSuccess(transactionId);
+            }
+            catch (error) {
+                let message = "Unknown";
+                if (error instanceof Error) {
+                    message = error.message;
+                }
+                console.log(`handleStartStatusUpdates: Error: ${message}`);
+                KeplerPlayerServerTurboModule.transactionError(transactionId, message);
+            }
+        }
+        else if (resultCallback === "handleStopStatusUpdates") {
+            try {
+                this.mServerHandler.handleStopStatusUpdates(result.sessionId);
+                console.log("handleStopStatusUpdates: Success.");
+                KeplerPlayerServerTurboModule.transactionSuccess(transactionId);
+            }
+            catch (error) {
+                let message = "Unknown";
+                if (error instanceof Error) {
+                    message = error.message;
+                }
+                console.log(`handleStopStatusUpdates: Error: ${message}`);
+                KeplerPlayerServerTurboModule.transactionError(transactionId, message);
+            }
+        }
+        else if (resultCallback === "handleStartTrackUpdates") {
+            try {
+                this.mServerHandler.handleStartTrackUpdates(result.sessionId);
+                console.log("handleStartTrackUpdates: Success.");
+                KeplerPlayerServerTurboModule.transactionSuccess(transactionId);
+            }
+            catch (error) {
+                let message = "Unknown";
+                if (error instanceof Error) {
+                    message = error.message;
+                }
+                console.log(`handleStartTrackUpdates: Error: ${message}`);
+                KeplerPlayerServerTurboModule.transactionError(transactionId, message);
+            }
+        }
+        else if (resultCallback === "handleStopTrackUpdates") {
+            try {
+                this.mServerHandler.handleStopTrackUpdates(result.sessionId);
+                console.log("handleStopTrackUpdates: Success.");
+                KeplerPlayerServerTurboModule.transactionSuccess(transactionId);
+            }
+            catch (error) {
+                let message = "Unknown";
+                if (error instanceof Error) {
+                    message = error.message;
+                }
+                console.log(`handleStopTrackUpdates: Error: ${message}`);
+                KeplerPlayerServerTurboModule.transactionError(transactionId, message);
+            }
+        }
+        else if (resultCallback === "handleStartMessageUpdates") {
+            try {
+                this.mServerHandler.handleStartMessageUpdates(result.sessionId);
+                console.log("handleStartMessageUpdates: Success.");
+                KeplerPlayerServerTurboModule.transactionSuccess(transactionId);
+            }
+            catch (error) {
+                let message = "Unknown";
+                if (error instanceof Error) {
+                    message = error.message;
+                }
+                console.log(`handleStartMessageUpdates: Error: ${message}`);
+                KeplerPlayerServerTurboModule.transactionError(transactionId, message);
+            }
+        }
+        else if (resultCallback === "handleStopMessageUpdates") {
+            try {
+                this.mServerHandler.handleStopMessageUpdates(result.sessionId);
+                console.log("handleStopMessageUpdates: Success.");
+                KeplerPlayerServerTurboModule.transactionSuccess(transactionId);
+            }
+            catch (error) {
+                let message = "Unknown";
+                if (error instanceof Error) {
+                    message = error.message;
+                }
+                console.log(`handleStopMessageUpdates: Error: ${message}`);
+                KeplerPlayerServerTurboModule.transactionError(transactionId, message);
+            }
+        }
+        else if (resultCallback === "handleStartErrorUpdates") {
+            try {
+                this.mServerHandler.handleStartErrorUpdates(result.sessionId);
+                console.log("handleStartErrorUpdates: Success.");
+                KeplerPlayerServerTurboModule.transactionSuccess(transactionId);
+            }
+            catch (error) {
+                let message = "Unknown";
+                if (error instanceof Error) {
+                    message = error.message;
+                }
+                console.log(`handleStartErrorUpdates: Error: ${message}`);
+                KeplerPlayerServerTurboModule.transactionError(transactionId, message);
+            }
+        }
+        else if (resultCallback === "handleStopErrorUpdates") {
+            try {
+                this.mServerHandler.handleStopErrorUpdates(result.sessionId);
+                console.log("handleStopErrorUpdates: Success.");
+                KeplerPlayerServerTurboModule.transactionSuccess(transactionId);
+            }
+            catch (error) {
+                let message = "Unknown";
+                if (error instanceof Error) {
+                    message = error.message;
+                }
+                console.log(`handleStopErrorUpdates: Error: ${message}`);
+                KeplerPlayerServerTurboModule.transactionError(transactionId, message);
+            }
+        }
+        else if (resultCallback === "handleUnloadSync") {
+            try {
+                let _unloadSyncStatus = IUnloadSyncStatus.INVALID;
+                this.clearPositionListeners(result.sessionId);
+                if (this.mServerHandler.handleUnloadSync) {
+                    _unloadSyncStatus = this.mServerHandler.handleUnloadSync(result.numberValue, result.sessionId);
+                    console.log("handleUnloadSync: Success.");
+                    KeplerPlayerServerTurboModule.transactionSuccessWithValue(transactionId, { unloadSyncStatus: _unloadSyncStatus });
+                }
+                else {
+                    console.log("handleUnloadSync: not implemented, returning invalid.");
+                    KeplerPlayerServerTurboModule.transactionError(transactionId, "handleUnloadSync not implemented.");
+                }
+            }
+            catch (error) {
+                let message = "Unknown";
+                if (error instanceof Error) {
+                    message = error.message;
+                }
+                console.log(`handleUnloadSync: Error: ${message}`);
+                KeplerPlayerServerTurboModule.transactionError(transactionId, message);
+            }
+        }
+        else if (resultCallback === "handleStartPlaybackPositionUpdates") {
+            try {
+                if (!result.timevalue || !result.numberValue) {
+                    throw new Error(`invalid interval: ${result.timevalue} or listenerId: ${result.numberValue}`);
+                }
+                let sessionId = result.sessionId ? result.sessionId.id : -1;
+                let interval = result.timevalue;
+                let listenerId = result.numberValue;
+                let timerId = setInterval(async () => {
+                    try {
+                        if (!this.mServerHandler) {
+                            throw new Error('invalid mServerHandler');
+                        }
+                        let position = this.mServerHandler.handleGetCurrentPosition(result.sessionId);
+                        let sessionPosition = { sessionId: result.sessionId, position: position };
+                        KeplerPlayerServerTurboModule.updatePlaybackPosition(listenerId, [sessionPosition]);
+                        console.log(`updatePlaybackPosition: ${position}, for listenerId ${listenerId}`);
+                    }
+                    catch (error) {
+                        console.error("updatePlaybackPosition error: ", error);
+                    }
+                }, Math.floor(interval * 1000));
+                let listners = [[listenerId, timerId]];
+                const existingListeners = this.mPositionListenerMap.get(sessionId);
+                if (existingListeners) {
+                    listners.concat(existingListeners);
+                }
+                this.mPositionListenerMap.set(sessionId, listners);
+                console.log("handleStartPlaybackPositionUpdates: Success.");
+                KeplerPlayerServerTurboModule.transactionSuccess(transactionId);
+            }
+            catch (error) {
+                let message = "Unknown";
+                if (error instanceof Error) {
+                    message = error.message;
+                }
+                console.log(`handleStartPlaybackPositionUpdates: Error: ${message}`);
+                KeplerPlayerServerTurboModule.transactionError(transactionId, message);
+            }
+        }
+        else if (resultCallback === "handleStopPlaybackPositionUpdates") {
+            try {
+                if (!result.numberValue) {
+                    throw new Error(`invalid listenerId: ${result.numberValue}`);
+                }
+                if (!this.clearPositionListeners(result.sessionId, result.numberValue)) {
+                    throw new Error(`ListenerId ${result.numberValue} not present for sessionId ${result.sessionId}`);
+                }
+                console.log("handleStopPlaybackPositionUpdates: Success.");
+                KeplerPlayerServerTurboModule.transactionSuccess(transactionId);
+            }
+            catch (error) {
+                let message = "Unknown";
+                if (error instanceof Error) {
+                    message = error.message;
+                }
+                console.log(`handleStopPlaybackPositionUpdates: Error: ${message}`);
+                KeplerPlayerServerTurboModule.transactionError(transactionId, message);
+            }
+        }
+        else {
+            console.log("Unknown handler event: ", resultCallback);
+        }
+    }
+    /**
+     * {@inheritDoc}
+     */
+    setHandler(_handler, _componentId) {
+        this.mServerHandler = _handler;
+        this.handleEvent = this.handleEvent.bind(this);
+        KeplerPlayerServerTurboModule.setHandler(this.handleEvent, _componentId);
+    }
+    /**
+     * {@inheritDoc}
+     */
+    updateBufferedRanges(_bufferedRanges, _sessionId) {
+        if (!_sessionId) {
+            _sessionId = { id: -1 };
+        }
+        const resultPromise = new Promise((resolve, reject) => {
+            try {
+                KeplerPlayerServerTurboModule.updateBufferedRanges(_bufferedRanges, _sessionId);
+                resolve();
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+        return resultPromise;
+    }
+    /**
+     * {@inheritDoc}
+     */
+    updateStatus(_states) {
+        const resultPromise = new Promise((resolve, reject) => {
+            try {
+                KeplerPlayerServerTurboModule.updateStatus(_states);
+                resolve();
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+        return resultPromise;
+    }
+    /**
+     * {@inheritDoc}
+     */
+    addTrack(_newTrack, _sessionId) {
+        if (!_sessionId) {
+            _sessionId = { id: -1 };
+        }
+        const resultPromise = new Promise((resolve, reject) => {
+            try {
+                KeplerPlayerServerTurboModule.addTrack(_newTrack, _sessionId);
+                resolve();
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+        return resultPromise;
+    }
+    /**
+     * {@inheritDoc}
+     */
+    removeTrack(_removedTrack, _sessionId) {
+        if (!_sessionId) {
+            _sessionId = { id: -1 };
+        }
+        const resultPromise = new Promise((resolve, reject) => {
+            try {
+                KeplerPlayerServerTurboModule.removeTrack(_removedTrack, _sessionId);
+                resolve();
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+        return resultPromise;
+    }
+    /**
+     * {@inheritDoc}
+     */
+    sendMessage(_message, _sessionId) {
+        if (!_sessionId) {
+            _sessionId = { id: -1 };
+        }
+        if (_message === undefined) { // _message = null is allowed.
+            return Promise.reject("undefined message passed.");
+        }
+        const resultPromise = new Promise((resolve, reject) => {
+            try {
+                let _messageString = JSON.stringify(_message);
+                KeplerPlayerServerTurboModule.sendMessage(_messageString, _sessionId);
+                resolve();
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+        return resultPromise;
+    }
+    /**
+     * {@inheritDoc}
+     */
+    sendError(_error, _sessionId) {
+        if (!_sessionId) {
+            _sessionId = { id: -1 };
+        }
+        const resultPromise = new Promise((resolve, reject) => {
+            try {
+                KeplerPlayerServerTurboModule.sendError(_error, _sessionId);
+                resolve();
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+        return resultPromise;
+    }
+}