.

crates/chat/src/lib.rs

@@ -10,11 +10,11 @@ use common::EventUtils;
 use fuzzy_matcher::skim::SkimMatcherV2;
 use fuzzy_matcher::FuzzyMatcher;
 use gpui::{
-    App, AppContext, Context, Entity, EventEmitter, Global, Subscription, Task, WeakEntity,
+    App, AppContext, Context, Entity, EventEmitter, Global, Subscription, Task, WeakEntity, Window,
 };
 use nostr_sdk::prelude::*;
 use smallvec::{smallvec, SmallVec};
-use state::{NostrRegistry, RelayState, DEVICE_GIFTWRAP, USER_GIFTWRAP};
+use state::{NostrRegistry, DEVICE_GIFTWRAP, USER_GIFTWRAP};
 
 mod message;
 mod room;
@@ -22,8 +22,8 @@ mod room;
 pub use message::*;
 pub use room::*;
 
-pub fn init(cx: &mut App) {
-    ChatRegistry::set_global(cx.new(ChatRegistry::new), cx);
+pub fn init(window: &mut Window, cx: &mut App) {
+    ChatRegistry::set_global(cx.new(|cx| ChatRegistry::new(window, cx)), cx);
 }
 
 struct GlobalChatRegistry(Entity<ChatRegistry>);
@@ -59,11 +59,8 @@ pub struct ChatRegistry {
     /// Tracking the status of unwrapping gift wrap events.
     tracking_flag: Arc<AtomicBool>,
 
-    /// Handle tracking asynchronous task
-    tracking_task: Option<Task<Result<(), Error>>>,
-
-    /// Handle notification asynchronous task
-    notification_task: Option<Task<()>>,
+    /// Async tasks
+    tasks: SmallVec<[Task<Result<(), Error>>; 2]>,
 
     /// Subscriptions
     _subscriptions: SmallVec<[Subscription; 1]>,
@@ -83,31 +80,28 @@ impl ChatRegistry {
     }
 
     /// Create a new chat registry instance
-    fn new(cx: &mut Context<Self>) -> Self {
+    fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
         let nostr = NostrRegistry::global(cx);
         let nip17 = nostr.read(cx).nip17_state();
 
         let mut subscriptions = smallvec![];
 
         subscriptions.push(
-            // Observe the identity
-            cx.observe(&nip17, |this, state, cx| {
-                if state.read(cx) == &RelayState::Configured {
-                    // Handle nostr notifications
-                    this.handle_notifications(cx);
-                    // Track unwrapping progress
-                    this.tracking(cx);
-                }
-                // Get chat rooms from the database on every state changes
+            // Observe the nip17 state and load chat rooms on every state change
+            cx.observe(&nip17, |this, _state, cx| {
                 this.get_rooms(cx);
             }),
         );
 
+        cx.defer_in(window, |this, _window, cx| {
+            this.handle_notifications(cx);
+            this.tracking(cx);
+        });
+
         Self {
             rooms: vec![],
             tracking_flag: Arc::new(AtomicBool::new(false)),
-            tracking_task: None,
-            notification_task: None,
+            tasks: smallvec![],
             _subscriptions: subscriptions,
         }
     }
@@ -126,7 +120,7 @@ impl ChatRegistry {
         // Channel for communication between nostr and gpui
         let (tx, rx) = flume::bounded::<Signal>(1024);
 
-        cx.background_spawn(async move {
+        self.tasks.push(cx.background_spawn(async move {
             let device_signer = signer.get_encryption_signer().await;
             let mut notifications = client.notifications();
             let mut processed_events = HashSet::new();
@@ -149,7 +143,7 @@ impl ChatRegistry {
                             continue;
                         }
 
-                        log::info!("Received gift-wrap event: {event:?}");
+                        log::info!("Received gift wrap event: {:?}", event);
 
                         // Extract the rumor from the gift wrap event
                         match Self::extract_rumor(&client, &device_signer, event.as_ref()).await {
@@ -158,7 +152,7 @@ impl ChatRegistry {
                                     let new_message = NewMessage::new(event.id, rumor);
                                     let signal = Signal::Message(new_message);
 
-                                    tx.send_async(signal).await.ok();
+                                    tx.send_async(signal).await?;
                                 }
                                 false => {
                                     status.store(true, Ordering::Release);
@@ -171,32 +165,33 @@ impl ChatRegistry {
                     }
                     RelayMessage::EndOfStoredEvents(id) => {
                         if id.as_ref() == &sub_id1 || id.as_ref() == &sub_id2 {
-                            tx.send_async(Signal::Eose).await.ok();
+                            tx.send_async(Signal::Eose).await?;
                         }
                     }
                     _ => {}
                 }
             }
-        })
-        .detach();
 
-        self.notification_task = Some(cx.spawn(async move |this, cx| {
+            Ok(())
+        }));
+
+        self.tasks.push(cx.spawn(async move |this, cx| {
             while let Ok(message) = rx.recv_async().await {
                 match message {
                     Signal::Message(message) => {
                         this.update(cx, |this, cx| {
                             this.new_message(message, cx);
-                        })
-                        .ok();
+                        })?;
                     }
                     Signal::Eose => {
                         this.update(cx, |this, cx| {
                             this.get_rooms(cx);
-                        })
-                        .ok();
+                        })?;
                     }
                 };
             }
+
+            Ok(())
         }));
     }
 
@@ -204,7 +199,7 @@ impl ChatRegistry {
     fn tracking(&mut self, cx: &mut Context<Self>) {
         let status = self.tracking_flag.clone();
 
-        self.tracking_task = Some(cx.background_spawn(async move {
+        self.tasks.push(cx.background_spawn(async move {
             let loop_duration = Duration::from_secs(10);
 
             loop {