@therealtinhtute/baroiplayer 1.0.0 → 1.0.1

package/dist/src/features/media-session/media-session-manager.js

@@ -0,0 +1,331 @@
+export class MediaSessionManager {
+    callbacks = {};
+    config;
+    positionUpdateInterval = null;
+    isInitialized = false;
+    constructor(config = {}) {
+        this.config = {
+            enableActions: ['play', 'pause', 'seekbackward', 'seekforward', 'seekto'],
+            skipBackwardTime: 10,
+            skipForwardTime: 10,
+            enablePositionTracking: true,
+            ...config
+        };
+        this.initialize();
+    }
+    /**
+     * Initialize Media Session API
+     */
+    initialize() {
+        if (!this.isSupported()) {
+            console.warn('Media Session API is not supported');
+            return;
+        }
+        this.setupActionHandlers();
+        this.isInitialized = true;
+    }
+    /**
+     * Check if Media Session API is supported
+     */
+    isSupported() {
+        return 'mediaSession' in navigator;
+    }
+    /**
+     * Set media metadata
+     */
+    setMetadata(metadata) {
+        if (!this.isInitialized)
+            return;
+        try {
+            const processedArtwork = metadata.artwork?.map(img => ({
+                src: img.src,
+                sizes: img.sizes || '512x512',
+                type: img.type || 'image/png'
+            }));
+            navigator.mediaSession.metadata = new MediaMetadata({
+                title: metadata.title || 'Unknown Title',
+                artist: metadata.artist || 'Unknown Artist',
+                album: metadata.album || 'Unknown Album',
+                artwork: processedArtwork || []
+            });
+        }
+        catch (error) {
+            console.error('Failed to set media metadata:', error);
+        }
+    }
+    /**
+     * Set playback state
+     */
+    setPlaybackState(state) {
+        if (!this.isInitialized)
+            return;
+        try {
+            navigator.mediaSession.playbackState = state;
+        }
+        catch (error) {
+            console.error('Failed to set playback state:', error);
+        }
+    }
+    /**
+     * Set position state
+     */
+    setPositionState(state) {
+        if (!this.isInitialized || !this.config.enablePositionTracking)
+            return;
+        try {
+            navigator.mediaSession.setPositionState(state);
+        }
+        catch (error) {
+            console.error('Failed to set position state:', error);
+        }
+    }
+    /**
+     * Register callbacks for media actions
+     */
+    setCallbacks(callbacks) {
+        this.callbacks = { ...this.callbacks, ...callbacks };
+        if (this.isInitialized) {
+            this.updateActionHandlers();
+        }
+    }
+    /**
+     * Setup action handlers
+     */
+    setupActionHandlers() {
+        const actions = this.config.enableActions || [];
+        actions.forEach(action => {
+            this.setActionHandler(action);
+        });
+    }
+    /**
+     * Update action handlers with current callbacks
+     */
+    updateActionHandlers() {
+        this.setupActionHandlers();
+    }
+    /**
+     * Set individual action handler
+     */
+    setActionHandler(action) {
+        try {
+            navigator.mediaSession.setActionHandler(action, (details) => {
+                this.handleAction(action, details);
+            });
+        }
+        catch (error) {
+            console.warn(`Failed to set handler for action: ${action}`, error);
+        }
+    }
+    /**
+     * Handle media session actions
+     */
+    handleAction(action, details) {
+        switch (action) {
+            case 'play':
+                this.callbacks.onPlay?.();
+                break;
+            case 'pause':
+                this.callbacks.onPause?.();
+                break;
+            case 'seekbackward':
+                const backwardTime = details?.seekOffset || this.config.skipBackwardTime || 10;
+                this.callbacks.onSeekBackward?.(backwardTime);
+                break;
+            case 'seekforward':
+                const forwardTime = details?.seekOffset || this.config.skipForwardTime || 10;
+                this.callbacks.onSeekForward?.(forwardTime);
+                break;
+            case 'seekto':
+                if (details?.seekTime !== undefined) {
+                    this.callbacks.onSeekTo?.(details.seekTime);
+                }
+                break;
+            case 'previoustrack':
+                this.callbacks.onPreviousTrack?.();
+                break;
+            case 'nexttrack':
+                this.callbacks.onNextTrack?.();
+                break;
+            case 'stop':
+                this.callbacks.onStop?.();
+                break;
+            case 'togglemicrophone':
+                this.callbacks.onToggleMicrophone?.();
+                break;
+            case 'togglecamera':
+                this.callbacks.onToggleCamera?.();
+                break;
+            case 'hangup':
+                this.callbacks.onHangup?.();
+                break;
+            default:
+                console.warn(`Unhandled media session action: ${action}`);
+        }
+    }
+    /**
+     * Start automatic position tracking
+     */
+    startPositionTracking(getCurrentTime, getDuration) {
+        if (!this.config.enablePositionTracking || this.positionUpdateInterval) {
+            return;
+        }
+        this.positionUpdateInterval = window.setInterval(() => {
+            try {
+                const currentTime = getCurrentTime();
+                const duration = getDuration();
+                if (!isNaN(currentTime) && !isNaN(duration) && duration > 0) {
+                    this.setPositionState({
+                        duration,
+                        position: currentTime,
+                        playbackRate: 1.0
+                    });
+                }
+            }
+            catch (error) {
+                console.error('Failed to update position state:', error);
+            }
+        }, 1000); // Update every second
+    }
+    /**
+     * Stop automatic position tracking
+     */
+    stopPositionTracking() {
+        if (this.positionUpdateInterval) {
+            clearInterval(this.positionUpdateInterval);
+            this.positionUpdateInterval = null;
+        }
+    }
+    /**
+     * Enable specific actions
+     */
+    enableActions(actions) {
+        this.config.enableActions = [...(this.config.enableActions || []), ...actions];
+        if (this.isInitialized) {
+            actions.forEach(action => {
+                this.setActionHandler(action);
+            });
+        }
+    }
+    /**
+     * Disable specific actions
+     */
+    disableActions(actions) {
+        if (!this.isInitialized)
+            return;
+        actions.forEach(action => {
+            try {
+                navigator.mediaSession.setActionHandler(action, null);
+            }
+            catch (error) {
+                console.warn(`Failed to disable action: ${action}`, error);
+            }
+        });
+        this.config.enableActions = this.config.enableActions?.filter(action => !actions.includes(action));
+    }
+    /**
+     * Create artwork from video thumbnail
+     */
+    createArtworkFromVideo(videoElement) {
+        return new Promise((resolve) => {
+            try {
+                const canvas = document.createElement('canvas');
+                const ctx = canvas.getContext('2d');
+                if (!ctx || videoElement.videoWidth === 0 || videoElement.videoHeight === 0) {
+                    resolve([]);
+                    return;
+                }
+                canvas.width = Math.min(videoElement.videoWidth, 512);
+                canvas.height = Math.min(videoElement.videoHeight, 512);
+                ctx.drawImage(videoElement, 0, 0, canvas.width, canvas.height);
+                canvas.toBlob((blob) => {
+                    if (blob) {
+                        const url = URL.createObjectURL(blob);
+                        resolve([{
+                                src: url,
+                                sizes: `${canvas.width}x${canvas.height}`,
+                                type: blob.type
+                            }]);
+                    }
+                    else {
+                        resolve([]);
+                    }
+                }, 'image/png');
+            }
+            catch (error) {
+                console.error('Failed to create artwork from video:', error);
+                resolve([]);
+            }
+        });
+    }
+    /**
+     * Update metadata from media element
+     */
+    async updateFromMediaElement(mediaElement, additionalInfo) {
+        const metadata = {
+            title: additionalInfo?.title || document.title || 'Media Player',
+            artist: additionalInfo?.artist || 'Unknown Artist',
+            album: additionalInfo?.album || 'Unknown Album',
+            artwork: additionalInfo?.artwork || []
+        };
+        // Try to extract artwork from video element
+        if (mediaElement instanceof HTMLVideoElement && metadata.artwork?.length === 0) {
+            try {
+                const videoArtwork = await this.createArtworkFromVideo(mediaElement);
+                metadata.artwork = videoArtwork;
+            }
+            catch (error) {
+                console.error('Failed to extract video artwork:', error);
+            }
+        }
+        this.setMetadata(metadata);
+    }
+    /**
+     * Get current session info
+     */
+    getSessionInfo() {
+        return {
+            supported: this.isSupported(),
+            initialized: this.isInitialized,
+            metadata: this.isInitialized ? navigator.mediaSession.metadata : null,
+            playbackState: this.isInitialized ? navigator.mediaSession.playbackState : null,
+            enabledActions: this.config.enableActions || []
+        };
+    }
+    /**
+     * Reset session
+     */
+    reset() {
+        if (!this.isInitialized)
+            return;
+        try {
+            navigator.mediaSession.metadata = null;
+            navigator.mediaSession.playbackState = 'none';
+            this.stopPositionTracking();
+            const actions = this.config.enableActions || [];
+            actions.forEach(action => {
+                try {
+                    navigator.mediaSession.setActionHandler(action, null);
+                }
+                catch (error) {
+                    console.warn(`Failed to reset handler for action: ${action}`, error);
+                }
+            });
+            this.callbacks = {};
+        }
+        catch (error) {
+            console.error('Failed to reset media session:', error);
+        }
+    }
+    /**
+     * Cleanup resources
+     */
+    destroy() {
+        this.stopPositionTracking();
+        this.reset();
+        this.isInitialized = false;
+    }
+}
+// Utility function to create a configured media session manager
+export function createMediaSessionManager(config) {
+    return new MediaSessionManager(config);
+}