adds .local/share/millennium and easyeffects

2026-08-06 18:19:44 +02:00
parent d4541842a4
commit 2b51bfa8c5
2581 changed files with 339035 additions and 0 deletions
@@ -0,0 +1,150 @@
+"""
+Message handler for WebSocket communication.
+Processes different types of messages and routes them appropriately.
+"""
+
+import json
+from typing import Any, Dict, Optional
+
+from logger.logger import logger  # pylint: disable=import-error
+
+from .client_manager import ClientManager
+from .message_types import ClientType, MessageType
+from .request_handler import RequestHandler
+
+
+class MessageAdapter:
+    def send_message(self, client: Dict[str, Any], message: str):
+        pass
+
+class MessageHandler:
+    """
+    Handles processing and routing of WebSocket messages.
+    """
+
+    def __init__(self, server: MessageAdapter, client_manager: ClientManager, request_handler: RequestHandler):
+        """
+        Initialize the message handler.
+
+        Args:
+            server: The WebSocket server instance
+            client_manager: The client manager instance
+            request_handler: The request handler instance
+        """
+        self._server = server
+        self._client_manager = client_manager
+        self._request_handler = request_handler
+        self._message_handlers = {
+            MessageType.IDENTIFY.value: self._handle_identify,
+            MessageType.WEBKIT_MESSAGE.value: self._handle_webkit_message,
+            MessageType.FRONTEND_RESPONSE.value: self._handle_frontend_response,
+            MessageType.ERROR.value: self._handle_error,
+        }
+
+    def process_message(self, client: Dict[str, Any], message: str) -> None:
+        """
+        Process an incoming WebSocket message.
+
+        Args:
+            client: The client that sent the message
+            message: The message string
+        """
+        try:
+            data = json.loads(message)
+            message_type = data.get('type')
+
+            if message_type in self._message_handlers:
+                self._message_handlers[message_type](client, data)
+            else:
+                logger.error(f"Unknown message type: {message_type}")
+                self._send_error(client, data.get('requestId'), "Unknown message type")
+        except json.JSONDecodeError:
+            logger.error(f"Invalid JSON message: {message}")
+            self._send_error(client, None, "Invalid JSON message")
+        except Exception as e:
+            logger.error(f"Error processing message: {str(e)}")
+            self._send_error(client, data.get('requestId') if 'data' in locals() else None, f"Error: {str(e)}")
+
+    def _handle_identify(self, client: Dict[str, Any], data: Dict[str, Any]) -> None:
+        client_type = data.get('clientType')
+
+        if client_type == ClientType.FRONTEND.value:
+            self._client_manager.frontend_client = client
+        elif client_type == ClientType.WEBKIT.value:
+            self._client_manager.add_webkit_client(client)
+        else:
+            logger.error(f"Unknown client type: {client_type}")
+            self._send_error(client, None, f"Unknown client type: {client_type}")
+
+    def _handle_webkit_message(self, client: Dict[str, Any], data: Dict[str, Any]) -> None:
+        """
+        Handle a message from a webkit client to the frontend.
+
+        Args:
+            client: The client that sent the message
+            data: The message data
+        """
+        if not self._client_manager.has_frontend_client():
+            logger.error("No frontend client connected to receive message")
+            self._send_error(client, data.get('requestId'), "No frontend client connected")
+            return
+
+        request_id = data.get('requestId')
+
+        if request_id:
+            # Store the request for later response matching
+            self._request_handler.add_request(request_id, client)
+
+            # Forward message to frontend
+            self._server.send_message(self._client_manager.frontend_client, json.dumps(data))
+        else:
+            logger.error("Missing requestId in webkit message")
+            self._send_error(client, request_id, "Missing requestId")
+
+    def _handle_frontend_response(self, client: Dict[str, Any], data: Dict[str, Any]) -> None:
+        """
+        Handle a response from the frontend to a webkit client.
+
+        Args:
+            client: The client that sent the message
+            data: The message data
+        """
+        request_id = data.get('requestId')
+
+        if not request_id:
+            logger.error("Missing requestId in frontend response")
+            self._send_error(client, None, "Missing requestId in response")
+            return
+
+        request = self._request_handler.get_request(request_id)
+        if request:
+            webkit_client = request['client']
+            # Send response back to the webkit client
+            self._server.send_message(webkit_client, json.dumps(data))
+            # Clean up the pending request
+            self._request_handler.remove_request(request_id)
+        else:
+            # logger.error(f"Received response for unknown request: {request_id}")
+            self._send_error(client, request_id, f"Unknown request: {request_id}")
+
+    def _handle_error(self, client: Dict[str, Any], data: Dict[str, Any]) -> None:
+        logger.error(f"Received error: {data['error']} requestId: {data['requestId']} extensionName: {data['extensionName']}")
+
+    def _send_error(self, client: Dict[str, Any], request_id: Optional[str], error_message: str) -> None:
+        """
+        Send an error message to a client.
+
+        Args:
+            client: The client to send the error to
+            request_id: The ID of the request that caused the error
+            error_message: The error message
+        """
+        error_data = {
+            'type': MessageType.ERROR.value,
+            'error': error_message
+        }
+
+        if request_id:
+            error_data['requestId'] = request_id
+
+        self._server.send_message(client, json.dumps(error_data))