Extract notification receiving into an observer

kifu/gtk/src/lib.rs

@@ -3,9 +3,10 @@ pub mod ui;
 mod view_models;
 mod views;
 
-use kifu_core::{Core, CoreRequest, CoreResponse};
+use async_std::task::yield_now;
-use std::sync::Arc;
+use kifu_core::{Core, CoreRequest, CoreResponse, Observable};
-use tokio::{runtime::Runtime, spawn};
+use std::{rc::Rc, sync::Arc};
+use tokio::runtime::Runtime;
 
 #[derive(Clone)]
 pub struct CoreApi {
@@ -37,3 +38,39 @@ where
     println!("[Trace: {}] {:?}", trace_name, end - start);
     result
 }
+
+struct LocalObserver<T> {
+    join_handle: glib::JoinHandle<()>,
+    handler: Rc<dyn Fn(T)>,
+}
+
+impl<T: 'static> LocalObserver<T> {
+    fn new(observable: &dyn Observable<T>, handler: impl Fn(T) + 'static) -> Self {
+        let listener = observable.subscribe();
+        let handler = Rc::new(handler);
+        let join_handle = glib::spawn_future_local({
+            let handler = handler.clone();
+            async move {
+                loop {
+                    match listener.recv().await {
+                        Ok(msg) => handler(msg),
+                        Err(err) => {
+                            unimplemented!("Should display an error message in the UI: {}", err)
+                        }
+                    }
+                    yield_now().await;
+                }
+            }
+        });
+        Self {
+            join_handle,
+            handler,
+        }
+    }
+}
+
+impl<T> Drop for LocalObserver<T> {
+    fn drop(&mut self) {
+        self.join_handle.abort();
+    }
+}

kifu/gtk/src/view_models/database_view_model.rs

@@ -14,30 +14,25 @@ General Public License for more details.
 You should have received a copy of the GNU General Public License along with Kifu. If not, see <https://www.gnu.org/licenses/>.
 */
 
-use async_channel::Receiver;
+use crate::LocalObserver;
-use async_std::task::{spawn, spawn_blocking, yield_now, JoinHandle};
 use kifu_core::{Core, CoreNotification};
 
 /// DatabaseViewModel controls the view that the user sees when starting the application if the application has been configured and if there are no games in progress. It provides a window into the database, showing a list of recently recorded games (whether from this app or from a main database). It also provides the UI for starting a new game. This will render an empty database view if the user hasn't configured a database yet.
 pub struct DatabaseViewModel {
     core: Core,
-    notification_handler: JoinHandle<()>,
+    notification_observer: LocalObserver<CoreNotification>,
     widget: gtk::Box,
 }
 
 impl DatabaseViewModel {
-    fn new(core: Core, notifications: Receiver<CoreNotification>) -> Self {
+    fn new(core: Core) -> Self {
-        let handler = spawn(async move {
+        let notification_observer = LocalObserver::new(&core, |msg| {
-            loop {
+            println!("DatabaseViewModelHandler called with message: {:?}", msg)
-                let message = notifications.recv().await;
-                println!("Message received in DatabaseViewModel: {:?}", message);
-                yield_now().await;
-            }
         });
 
         Self {
             core,
-            notification_handler: handler,
+            notification_observer,
             widget: gtk::Box::new(gtk::Orientation::Horizontal, 0),
         }
     }

kifu/gtk/src/view_models/game_view_model.rs

@@ -18,6 +18,8 @@ use async_std::{channel::Receiver, task::yield_now};
 use kifu_core::{Color, Core, CoreNotification, Goban, Observable, Player};
 use std::{cell::RefCell, rc::Rc, time::Duration};
 
+use crate::LocalObserver;
+
 pub struct GameState {
     goban: Goban,
     white_clock: Duration,
@@ -37,13 +39,13 @@ struct GameViewModelPrivate {
 /// The Game View Model manages the current state of the game. It shows the two player cards, the board, the current capture count, the current player, and it maintains the UI for the clock (bearing in mind that the real clock is managed in the core). This view model should only be created once the details of the game, whether a game in progress or a new game (this view model won't know the difference) is known.
 pub struct GameViewModel {
     core: Core,
-    notification_handler: glib::JoinHandle<()>,
+    notification_observer: LocalObserver<CoreNotification>,
     widget: gtk::Box,
     data: Rc<RefCell<GameViewModelPrivate>>,
 }
 
 impl GameViewModelPrivate {
-    fn handle(&mut self, message: CoreNotification) {}
+    fn handle(&mut self, _message: CoreNotification) {}
 }
 
 impl GameViewModel {
@@ -54,38 +56,15 @@ impl GameViewModel {
             state: game,
         }));
 
-        let notification_handler = {
+        let notification_observer = LocalObserver::new(&core, |msg| {
-            let notifications = core.subscribe();
+            println!("GameViewModelHandler called with message: {:?}", msg)
-            let data: Rc<RefCell<GameViewModelPrivate>> = data.clone();
+        });
-            glib::spawn_future_local(Self::listen(notifications, data))
-        };
 
         Self {
             core,
-            notification_handler,
+            notification_observer,
             widget: gtk::Box::new(gtk::Orientation::Horizontal, 0),
             data,
         }
     }
-
-    async fn listen(
-        notifications: Receiver<CoreNotification>,
-        data: Rc<RefCell<GameViewModelPrivate>>,
-    ) {
-        loop {
-            match notifications.recv().await {
-                Ok(msg) => data.borrow_mut().handle(msg),
-                Err(err) => {
-                    unimplemented!("Should display an error message in the UI: {}", err)
-                }
-            }
-            yield_now().await;
-        }
-    }
-}
-
-impl Drop for GameViewModel {
-    fn drop(&mut self) {
-        self.notification_handler.abort();
-    }
 }