Meta quest callbacks, vibration and publish async

simpub/core/net_manager.py

@@ -70,14 +70,17 @@ def __init__(self, topic: str):
 
     def publish(self, data: Dict):
         msg = f"{self.topic}:{dumps(data)}"
-        self.socket.send_string(msg)
+        self.manager.submit_task(self.send_msg_async, msg)
 
     def publish_string(self, string: str):
-        self.socket.send_string(f"{self.topic}:{string}")
+        self.manager.submit_task(self.send_msg_async, f"{self.topic}:{string}")
 
     def on_shutdown(self):
         super().on_shutdown()
 
+    async def send_msg_async(self, msg: str):
+        await self.socket.send_string(msg)
+
 
 class Streamer(Publisher):
     def __init__(
@@ -104,7 +107,7 @@ async def update_loop(self):
                 "updateData": self.update_func(),
                 "time": last,
             }
-            self.socket.send_string(f"{self.topic}:{dumps(msg)}")
+            await self.socket.send_string(f"{self.topic}:{dumps(msg)}")
 
 
 ResponseType = Union[str, bytes, Dict]
@@ -235,9 +238,9 @@ async def service_loop(self):
         while self.running:
             message = await self.service_socket.recv_string()
             if ":" not in message:
-                logger.error(f"Invalid message with no spliter \":\"")
+                logger.error("Invalid message with no spliter \":\"")
                 await self.service_socket.send_string("Invalid message")
-                continue        
+                continue
             service, request = message.split(":", 1)
             # the zmq service socket is blocked and only run one at a time
             if service in self.service_list.keys():

simpub/xr_device/meta_quest3.py

@@ -1,5 +1,6 @@
-from typing import TypedDict, Callable, Dict
+from typing import TypedDict, Callable, Dict, List
 import json
+from asyncio import sleep as async_sleep
 
 from simpub.core.net_manager import Publisher
 from .xr_device import XRDevice
@@ -38,25 +39,46 @@ def __init__(
         self.input_subscriber = self.register_topic_callback(
             f"{device_name}/InputData", self.update
         )
-        self.viborate_publisher = Publisher(f"{device_name}/Vibration")
-        self.button_trigger_event: Dict[str, Callable] = {}
+        self.start_vib_pub = Publisher(f"{device_name}/StartVibration")
+        self.stop_vib_pub = Publisher(f"{device_name}/StopVibration")
+        self.button_trigger_event: Dict[str, List[Callable]] = {
+            "A": [],
+            "B": [],
+            "X": [],
+            "Y": [],
+        }
+        self.on_vibration = {"left": False, "right": False,}
 
     def update(self, data: str):
         self.last_input_data = self.input_data
         self.input_data = json.loads(data)
         if self.last_input_data is None:
             return
-        for button, callback in self.button_trigger_event.items():
+        for button, callbacks in self.button_trigger_event.items():
             if self.input_data[button] and not self.last_input_data[button]:
-                callback()
+                [callback() for callback in callbacks]
 
     def register_button_trigger_event(self, button: str, callback: Callable):
         # button should be one of A, B, X, Y
-        self.button_trigger_event[button] = callback
+        self.button_trigger_event[button].append(callback)
 
     def get_input_data(self) -> MetaQuest3InputData:
         return self.input_data
 
     # TODO: Vibration Data Structure
-    def publish_vibrate(self, hand: str = "right"):
-        self.viborate_publisher.publish_string(hand)
+    def start_vibration(self, hand: str = "right", duration=0.5):
+        if not self.on_vibration[hand]:
+            self.on_vibration[hand] = True
+            self.manager.submit_task(
+                self.start_vibration_async, hand, duration,
+            )
+
+    async def start_vibration_async(self, hand: str = "right", duration=0.5):
+        self.start_vib_pub.publish_string(hand)
+        await async_sleep(duration)
+        self.stop_vib_pub.publish_string(hand)
+
+    def stop_vibration(self, hand: str = "right"):
+        if self.on_vibration[hand]:
+            self.on_vibration[hand] = False
+        self.stop_vib_pub.publish_string(hand)