Add and update helpers: Data, WebSocket, Api and User

helpers/websocketHelper.js

@@ -0,0 +1,128 @@
+(function() {
+    'use strict';
+    
+    const LOG = (...args) => console.log('[KefinTweaks WebSocketHelper]', ...args);
+    const WARN = (...args) => console.warn('[KefinTweaks WebSocketHelper]', ...args);
+    const ERR = (...args) => console.error('[KefinTweaks WebSocketHelper]', ...args);
+    
+    // Registry of event listeners: MessageType -> array of callbacks
+    const listeners = {};
+    
+    // Track initialization state
+    let isInitialized = false;
+    let retries = 0;
+    const maxRetries = 10;
+    
+    /**
+     * Initialize WebSocket monitoring by hooking into ApiClient's WebSocket
+     */
+    function initialize() {
+        try {
+            // Grab the actual socket
+            const socket = (window.ApiClient && (window.ApiClient.webSocket || window.ApiClient._webSocket)) || null;
+            
+            if (!socket) {
+                if (retries >= maxRetries) {
+                    ERR('Max retries reached, giving up on WebSocket initialization');
+                    return false;
+                }
+                retries++;
+                setTimeout(() => {
+                    if (!isInitialized) {
+                        initialize();
+                    }
+                }, 1000);
+                return;
+            }
+            
+            // Store original handler if it exists
+            const originalHandler = socket.onmessage;
+            
+            // Hook into onmessage
+            socket.onmessage = function(event) {
+                try {
+                    // Pass it through so Jellyfin still works normally
+                    if (originalHandler) {
+                        originalHandler.call(this, event);
+                    }
+                    
+                    // Parse the message data
+                    const messageData = event.Data || event.data;
+                    const data = typeof messageData === 'string' ? JSON.parse(messageData) : messageData;
+                    
+                    // Get the MessageType
+                    const messageType = data.MessageType;
+                    
+                    if (messageType && listeners[messageType]) {
+                        // Fire all callbacks for this message type
+                        listeners[messageType].forEach(callback => {
+                            try {
+                                callback(data);
+                            } catch (err) {
+                                ERR(`Error in WebSocket listener for ${messageType}:`, err);
+                            }
+                        });
+                    }
+                } catch (err) {
+                    // Log parse errors but don't break the original handler
+                    WARN('WebSocket message parse error:', err);
+                }
+            };
+            
+            isInitialized = true;
+            LOG('WebSocket monitoring initialized');
+            return true;
+        } catch (err) {
+            ERR('Error initializing WebSocket monitoring:', err);
+            return false;
+        }
+    }
+    
+    /**
+     * Register a callback to listen for a specific WebSocket message type
+     * @param {string} messageType - The MessageType to listen for (e.g., 'UserDataChanged', 'PlaybackStopped')
+     * @param {Function} callback - Function to call when the message type is received. Receives the parsed message data.
+     */
+    function listen(messageType, callback) {
+        if (typeof messageType !== 'string' || !messageType) {
+            ERR('listen() requires a non-empty string messageType');
+            return;
+        }
+        
+        if (typeof callback !== 'function') {
+            ERR('listen() requires a callback function');
+            return;
+        }
+        
+        // Initialize listeners array for this message type if it doesn't exist
+        if (!listeners[messageType]) {
+            listeners[messageType] = [];
+        }
+        
+        // Add the callback
+        listeners[messageType].push(callback);
+        LOG(`Registered listener for message type: ${messageType} (${listeners[messageType].length} total listeners)`);
+        
+        // Ensure WebSocket is initialized
+        if (!isInitialized) {
+            initialize();
+        }
+    }
+    
+    // Expose the API globally
+    window.websocketHelper = {
+        listen: listen
+    };
+    
+    // Try to initialize immediately
+    if (!initialize()) {
+        // If WebSocket isn't available yet, retry after a short delay
+        // This can happen if the page loads before the WebSocket connection is established
+        setTimeout(() => {
+            if (!isInitialized) {
+                initialize();
+            }
+        }, 1000);
+    }
+})();
+