GUI File Server and Alternate GUI Framework Support

ovos_gui/bus.py

@@ -25,17 +25,18 @@
 """
 import asyncio
 import json
+import os.path
 from threading import Lock
 
 from ovos_bus_client import Message, GUIMessage
 from ovos_config.config import Configuration
-# from ovos_gui.namespace import NamespaceManager
 from ovos_utils import create_daemon
 from ovos_utils.log import LOG
 from tornado import ioloop
 from tornado.options import parse_command_line
 from tornado.web import Application
 from tornado.websocket import WebSocketHandler
+# from ovos_gui.namespace import NamespaceManager
 
 _write_lock = Lock()
 
@@ -50,10 +51,10 @@ def get_gui_websocket_config() -> dict:
     return websocket_config
 
 
-def create_gui_service(enclosure) -> Application:
+def create_gui_service(nsmanager) -> Application:
     """
     Initiate a websocket for communicating with the GUI service.
-    @param enclosure: NamespaceManager instance
+    @param nsmanager: NamespaceManager instance
     """
     LOG.info('Starting message bus for GUI...')
     websocket_config = get_gui_websocket_config()
@@ -62,9 +63,7 @@ def create_gui_service(enclosure) -> Application:
 
     routes = [(websocket_config['route'], GUIWebsocketHandler)]
     application = Application(routes)
-    # TODO: Is the NamespaceManager used by `application`, or can it be a
-    #   GUIWebsocketHandler class variable
-    application.enclosure = enclosure
+    application.nsmanager = nsmanager
     application.listen(
         websocket_config['base_port'], websocket_config['host']
     )
@@ -96,6 +95,7 @@ def determine_if_gui_connected() -> bool:
 class GUIWebsocketHandler(WebSocketHandler):
     """Defines the websocket pipeline between the GUI and Mycroft."""
     clients = []
+    _framework = "qt5"
 
     def open(self):
         """
@@ -112,42 +112,71 @@ def on_close(self):
         LOG.info('Closing {}'.format(id(self)))
         GUIWebsocketHandler.clients.remove(self)
 
+    def get_client_pages(self, namespace):
+        nsmanager = self.application.nsmanager
+        skill_id = namespace.skill_id
+
+        client_pages = []
+
+        for page in namespace.pages:
+
+            if not page.url.startswith('http') and nsmanager.qml_server:
+                p = os.path.join(nsmanager.gui_file_path, skill_id, self.framework, page)
+                if os.path.isfile(p):
+                    LOG.info(f"serving qml file {page.url} via {p}")
+                    client_pages.append(p)
+                    continue
+                p = os.path.join(nsmanager.gui_file_path, skill_id, self.framework, page)
+                if os.path.isfile(p):
+                    LOG.info(f"serving qml file {page.url} via {p}")
+                    client_pages.append(p)
+                    continue
+
+            client_pages.append(page.url)
+
+        return client_pages
+
     def synchronize(self):
         """
         Upload namespaces, pages and data to the last connected client.
         """
         namespace_pos = 0
-        enclosure = self.application.enclosure
+        nsmanager = self.application.nsmanager
 
-        for namespace in enclosure.active_namespaces:
-            LOG.info(f'Sync {namespace.name}')
+        for namespace in nsmanager.active_namespaces:
+            LOG.info(f'Sync {namespace.skill_id}')
             # Insert namespace
             self.send({"type": "mycroft.session.list.insert",
                        "namespace": "mycroft.system.active_skills",
                        "position": namespace_pos,
-                       "data": [{"skill_id": namespace.name}]
+                       "data": [{"skill_id": namespace.skill_id}]
                        })
             # Insert pages
             self.send({"type": "mycroft.gui.list.insert",
-                       "namespace": namespace.name,
+                       "namespace": namespace.skill_id,
                        "position": 0,
-                       "data": [{"url": p.url} for p in namespace.pages]
+                       "data": [{"url": url} for url in self.get_client_pages(namespace)]
                        })
             # Insert data
             for key, value in namespace.data.items():
                 self.send({"type": "mycroft.session.set",
-                           "namespace": namespace.name,
+                           "namespace": namespace.skill_id,
                            "data": {key: value}
                            })
             namespace_pos += 1
 
+    @property
+    def framework(self):
+        return self._framework or "qt5"
+
     def on_message(self, message: str):
         """
         Handle a message on the GUI websocket. Deserialize the message, map
         message types to valid equivalents for the core messagebus and emit
         on the core messagebus.
         @param message: Serialized Message
         """
+        LOG.info(f"Received: {message}")
         parsed_message = GUIMessage.deserialize(message)
         LOG.debug(f"Received: {parsed_message.msg_type}|{parsed_message.data}")
 
@@ -179,18 +208,36 @@ def on_message(self, message: str):
             msg_data = parsed_message.data['data']
         elif parsed_message.msg_type == 'mycroft.gui.connected':
             # new client connected to GUI
+
+            # NOTE: mycroft-gui clients do this directly in core bus, dont send it to gui bus
+            # in those cases framework is always QT5 (backwards compat)
+            # new GUIs MUST send this message via gui websocket
+            # this means QT6 version of mycroft-gui WILL NOT WORK for now
+            # TODO: Move default framework to configuration
             msg_type = parsed_message.msg_type
             msg_data = parsed_message.data
+
+            framework = msg_data.get("framework")  # new api
+            if framework is None:
+                qt = msg_data.get("qt_version", 5)  # mycroft-gui api
+                if int(qt) == 6:
+                    framework = "qt6"
+                else:
+                    framework = "qt5"
+
+            self._framework = framework
         else:
             # message not in spec
             # https://github.com/MycroftAI/mycroft-gui/blob/master/transportProtocol.md
             LOG.error(f"unknown GUI protocol message type, ignoring: "
-                      f"{parsed_message}")
+                      f"{parsed_message.msg_type}")
             return
 
+        parsed_message.context["gui_framework"] = self.framework
         message = Message(msg_type, msg_data, parsed_message.context)
-        self.application.enclosure.core_bus.emit(message)
-        LOG.debug('Forwarded to core bus')
+        LOG.info('Forwarding to core bus...')
+        self.application.nsmanager.core_bus.emit(message)
+        LOG.info('Done!')
 
     def write_message(self, *arg, **kwarg):
         """
@@ -214,8 +261,5 @@ def send(self, data: dict):
         self.write_message(s)
 
     def check_origin(self, origin):
-        """
-        Disable origin check to make js connections work.
-        """
-        # TODO: Should this be implemented or deprecated
+        """Disable origin check to make js connections work."""
         return True

ovos_gui/gui_file_server.py

@@ -0,0 +1,51 @@
+import http.server
+import os
+import shutil
+import socketserver
+from threading import Thread, Event
+
+from ovos_config import Configuration
+from ovos_utils.file_utils import get_temp_path
+from ovos_utils.log import LOG
+
+_HTTP_SERVER = None
+
+
+class GuiFileHandler(http.server.SimpleHTTPRequestHandler):
+    def end_headers(self) -> None:
+        mimetype = self.guess_type(self.path)
+        is_file = not self.path.endswith('/')
+        if is_file and any([mimetype.startswith(prefix) for
+                            prefix in ("text/", "application/octet-stream")]):
+            self.send_header('Content-Type', "text/plain")
+            self.send_header('Content-Disposition', 'inline')
+        super().end_headers()
+
+
+def start_gui_http_server(qml_path: str, port: int = None):
+    port = port or Configuration().get("gui", {}).get("qml_server_port", 8089)
+
+    if os.path.exists(qml_path):
+        shutil.rmtree(qml_path, ignore_errors=True)
+    os.makedirs(qml_path, exist_ok=True)
+
+    started_event = Event()
+    http_daemon = Thread(target=_initialize_http_server,
+                         args=(started_event, qml_path, port),
+                         daemon=True)
+    http_daemon.start()
+    started_event.wait(30)
+    return _HTTP_SERVER
+
+
+def _initialize_http_server(started: Event, directory: str, port: int):
+    global _HTTP_SERVER
+    os.chdir(directory)
+    handler = GuiFileHandler
+    http_server = socketserver.TCPServer(("", port), handler)
+    _HTTP_SERVER = http_server
+    _HTTP_SERVER.qml_path = directory
+    _HTTP_SERVER.url = f"{_HTTP_SERVER.server_address[0]}:{_HTTP_SERVER.server_address[1]}"
+    LOG.info(f"QML file server started: {_HTTP_SERVER.url}")
+    started.set()
+    http_server.serve_forever()

ovos_gui/homescreen.py

@@ -101,8 +101,8 @@ def get_active_homescreen(self) -> Optional[dict]:
         Get the active homescreen according to configuration if it is loaded
         @return: Loaded homescreen with an ID matching configuration
         """
-        enclosure_config = Configuration().get("gui") or {}
-        active_homescreen = enclosure_config.get("idle_display_skill")
+        gui_config = Configuration().get("gui") or {}
+        active_homescreen = gui_config.get("idle_display_skill")
         LOG.debug(f"Homescreen Manager: Active Homescreen {active_homescreen}")
         for h in self.homescreens:
             if h["id"] == active_homescreen: