wallet: split event streams into separate publishers to avoid waking sleeping tasks uncessarily

bin/darkwallet/src/app.rs

@@ -12,7 +12,7 @@ use crate::{
     error::{Error, Result},
     expr::{Op, SExprMachine, SExprVal},
     gfx::Rectangle,
-    gfx2::{self, DrawCall, DrawInstruction, DrawMesh, GraphicsEvent, RenderApiPtr, Vertex},
+    gfx2::{self, DrawCall, DrawInstruction, DrawMesh, GraphicsEventPublisherPtr, RenderApiPtr, Vertex},
     prop::{
         Property, PropertyBool, PropertyColor, PropertyFloat32, PropertyPtr, PropertyStr,
         PropertySubType, PropertyType, PropertyUint32,
@@ -103,7 +103,7 @@ pub struct App {
     sg: SceneGraphPtr2,
     ex: Arc<smol::Executor<'static>>,
     render_api: RenderApiPtr,
-    event_pub: PublisherPtr<GraphicsEvent>,
+    event_pub: GraphicsEventPublisherPtr,
 }
 
 impl App {
@@ -111,7 +111,7 @@ impl App {
         sg: SceneGraphPtr2,
         ex: Arc<smol::Executor<'static>>,
         render_api: RenderApiPtr,
-        event_pub: PublisherPtr<GraphicsEvent>,
+        event_pub: GraphicsEventPublisherPtr,
     ) -> Arc<Self> {
         Arc::new(Self { sg, ex, render_api, event_pub })
     }
@@ -467,7 +467,7 @@ impl Window {
         node_id: SceneNodeId,
         ex: Arc<smol::Executor<'static>>,
         render_api: RenderApiPtr,
-        event_pub: PublisherPtr<GraphicsEvent>,
+        event_pub: GraphicsEventPublisherPtr,
     ) -> Pimpl {
         debug!(target: "app", "Window::new()");
 
@@ -481,20 +481,16 @@ impl Window {
         let self_ = Arc::new_cyclic(|me: &Weak<Self>| {
             // Start a task monitoring for window resize events
             // which updates screen_size
-            let ev_sub = event_pub.subscribe();
+            let ev_sub = event_pub.subscribe_resize();
             let screen_size_prop2 = screen_size_prop.clone();
             let me2 = me.clone();
             let sg2 = sg.clone();
             let resize_task = ex.spawn(async move {
                 loop {
-                    let Ok(ev) = ev_sub.receive().await else {
+                    let Ok((w, h)) = ev_sub.receive().await else {
                         debug!(target: "app", "Event relayer closed");
                         break
                     };
-                    let (w, h) = match ev {
-                        GraphicsEvent::Resize((w, h)) => (w, h),
-                        _ => continue,
-                    };
 
                     debug!(target: "app", "Window resized ({w}, {h})");
                     // Now update the properties

bin/darkwallet/src/gfx2.rs

@@ -24,7 +24,7 @@ use crate::{
     gfx::Rectangle,
     keysym::{KeyCodeAsStr, MouseButtonAsU8},
     prop::{Property, PropertySubType, PropertyType},
-    pubsub::PublisherPtr,
+    pubsub::{Publisher, PublisherPtr, Subscription},
     res::{ResourceId, ResourceManager},
     scene::{
         MethodResponseFn, Pimpl, SceneGraph, SceneGraphPtr, SceneNode, SceneNodeId, SceneNodeInfo,
@@ -221,10 +221,34 @@ pub enum GraphicsMethod {
     ReplaceDrawCalls(Vec<(u64, DrawCall)>),
 }
 
-#[derive(Debug, Clone)]
-pub enum GraphicsEvent {
-    KeyDown((KeyCode, KeyMods, bool)),
-    Resize((f32, f32)),
+pub type GraphicsEventPublisherPtr = Arc<GraphicsEventPublisher>;
+
+pub struct GraphicsEventPublisher {
+    key_down: PublisherPtr<(KeyCode, KeyMods, bool)>,
+    resize: PublisherPtr<(f32, f32)>,
+}
+
+impl GraphicsEventPublisher {
+    pub fn new() -> Arc<Self> {
+        Arc::new(Self {
+            key_down: Publisher::new(),
+            resize: Publisher::new(),
+        })
+    }
+
+    fn notify_key_down(&self, key: KeyCode, mods: KeyMods, repeat: bool) {
+        self.key_down.notify((key, mods, repeat));
+    }
+    fn notify_resize(&self, w: f32, h: f32) {
+        self.resize.notify((w, h));
+    }
+
+    pub fn subscribe_key_down(&self) -> Subscription<(KeyCode, KeyMods, bool)> {
+        self.key_down.clone().subscribe()
+    }
+    pub fn subscribe_resize(&self) -> Subscription<(f32, f32)> {
+        self.resize.clone().subscribe()
+    }
 }
 
 struct Stage {
@@ -237,14 +261,14 @@ struct Stage {
     last_draw_time: Option<Instant>,
 
     method_rep: mpsc::Receiver<GraphicsMethod>,
-    event_pub: PublisherPtr<GraphicsEvent>,
+    event_pub: GraphicsEventPublisherPtr,
 }
 
 impl Stage {
     pub fn new(
         async_runtime: AsyncRuntime,
         method_rep: mpsc::Receiver<GraphicsMethod>,
-        event_pub: PublisherPtr<GraphicsEvent>,
+        event_pub: GraphicsEventPublisherPtr,
     ) -> Self {
         let mut ctx: Box<dyn RenderingBackend> = window::new_rendering_backend();
 
@@ -253,8 +277,7 @@ impl Stage {
         #[cfg(target_os = "android")]
         {
             let (screen_width, screen_height) = window::screen_size();
-            let event = GraphicsEvent::Resize((screen_width, screen_height));
-            event_pub.notify(event);
+            event_pub.notify_resize(screen_width, screen_height);
         }
 
         let white_texture = ctx.new_texture_from_rgba8(1, 1, &[255, 255, 255, 255]);
@@ -422,12 +445,10 @@ impl EventHandler for Stage {
     }
 
     fn key_down_event(&mut self, keycode: KeyCode, mods: KeyMods, repeat: bool) {
-        let event = GraphicsEvent::KeyDown((keycode, mods, repeat));
-        self.event_pub.notify(event);
+        self.event_pub.notify_key_down(keycode, mods, repeat);
     }
     fn resize_event(&mut self, width: f32, height: f32) {
-        let event = GraphicsEvent::Resize((width, height));
-        self.event_pub.notify(event);
+        self.event_pub.notify_resize(width, height);
     }
 
     fn quit_requested_event(&mut self) {
@@ -438,7 +459,7 @@ impl EventHandler for Stage {
 pub fn run_gui(
     async_runtime: AsyncRuntime,
     method_rep: mpsc::Receiver<GraphicsMethod>,
-    event_pub: PublisherPtr<GraphicsEvent>,
+    event_pub: GraphicsEventPublisherPtr,
 ) {
     let mut conf = miniquad::conf::Conf {
         high_dpi: true,

bin/darkwallet/src/main.rs

@@ -79,7 +79,7 @@ fn main() {
     // The UI actually needs to be running for this to reply back.
     // Otherwise calls will just hang.
     let render_api = gfx2::RenderApi::new(method_req);
-    let event_pub = pubsub::Publisher::new();
+    let event_pub = gfx2::GraphicsEventPublisher::new();
 
     let async_runtime = app::AsyncRuntime::new(ex.clone());
     async_runtime.start();
@@ -90,21 +90,20 @@ fn main() {
     //app.clone().start();
 
     // Nice to see which events exist
-    let ev_sub = event_pub.clone().subscribe();
+    let ev_sub = event_pub.subscribe_key_down();
     let ev_relay_task = ex.spawn(async move {
         debug!(target: "main", "event relayer started");
         loop {
-            let Ok(ev) = ev_sub.receive().await else {
+            let Ok((key, mods, repeat)) = ev_sub.receive().await else {
                 debug!(target: "main", "Event relayer closed");
                 break
             };
-            // Ignore keys which get stuck
-            match &ev {
-                gfx2::GraphicsEvent::KeyDown((miniquad::KeyCode::LeftShift, _, _)) |
-                gfx2::GraphicsEvent::KeyDown((miniquad::KeyCode::LeftSuper, _, _)) => continue,
+            // Ignore keys which get stuck repeating when switching windows
+            match key {
+                miniquad::KeyCode::LeftShift | miniquad::KeyCode::LeftSuper => continue,
                 _ => {}
             }
-            debug!(target: "main", "event: {:?}", ev);
+            debug!(target: "main", "key_down event: {:?} {:?} {}", key, mods, repeat);
         }
     });
     async_runtime.push_task(ev_relay_task);