switch DiscordClient to interior mutability model

Author: Sanae6

src/discord/src/channel/mod.rs

@@ -8,16 +8,20 @@ use crate::{client::DiscordClient, message::{author::{DiscordMessageAuthor, Disp
 pub struct DiscordChannel {
   channel_id: Snowflake,
   receiver: broadcast::Receiver<DiscordMessage>,
-  client: Arc<RwLock<DiscordClient>>
+  client: Arc<DiscordClient>,
 }
 
 impl DiscordChannel {
-  pub async fn new(client: Arc<RwLock<DiscordClient>>, channel_id: Snowflake) -> Self {
+  pub async fn new(client: Arc<DiscordClient>, channel_id: Snowflake) -> Self {
     let (sender, receiver) = broadcast::channel(10);
 
-    client.write().await.add_channel_message_sender(channel_id, sender).await;
+    client.add_channel_message_sender(channel_id, sender).await;
 
-    DiscordChannel { channel_id, receiver, client }
+    DiscordChannel {
+      channel_id,
+      receiver,
+      client,
+    }
   }
 }
 
@@ -35,7 +39,7 @@ impl Channel for DiscordChannel {
     let sent_nonce = nonce.clone();
 
     tokio::spawn(async move {
-      client.write().await.send_message(channel_id, sent_content, sent_nonce).await;
+      client.send_message(channel_id, sent_content, sent_nonce).await;
     });
 
     DiscordMessage {
@@ -52,7 +56,7 @@ impl Clone for DiscordChannel {
     Self {
       channel_id: self.channel_id.clone(),
       receiver: self.receiver.resubscribe(),
-      client: self.client.clone()
+      client: self.client.clone(),
     }
   }
 }

src/discord/src/client.rs

@@ -1,4 +1,6 @@
-use std::{collections::HashMap, rc::Rc, sync::Arc};
+use std::{
+  collections::HashMap, rc::Rc, sync::{Arc, OnceLock}
+};
 
 use serenity::{
   all::{Context, EventHandler, GatewayIntents, Message},
@@ -18,47 +20,48 @@ use crate::{
 
 #[derive(Default)]
 pub struct DiscordClient {
-  channel_message_event_handlers: HashMap<Snowflake, Vec<broadcast::Sender<DiscordMessage>>>,
-  client: Option<serenity::Client>
+  channel_message_event_handlers: RwLock<HashMap<Snowflake, Vec<broadcast::Sender<DiscordMessage>>>>,
+  client: OnceLock<serenity::Client>,
 }
 
 impl DiscordClient {
-  pub fn new(token: String) -> Arc<RwLock<DiscordClient>> {
-    let client = Arc::new(RwLock::new(DiscordClient::default()));
-    let remote = RemoteDiscordClient(client.clone());
-    let async_client = client.clone();
-
-    tokio::spawn(async move {
-      let mut client = serenity::Client::builder(token, GatewayIntents::all())
-        .event_handler(remote)
-        .await
-        .expect("Error creating client");
-
-      if let Err(why) = client.start().await {
-        panic!("Client error: {why:?}");
-      }
+  pub async fn new(token: String) -> Arc<DiscordClient> {
+    let client = Arc::new(DiscordClient::default());
+
+    let mut discord = serenity::Client::builder(token, GatewayIntents::all()).event_handler_arc(client.clone()).await.expect("Error creating client");
+
+    if let Err(why) = discord.start().await {
+      panic!("Client error: {why:?}");
+    }
 
-      async_client.write().await.client = Some(client);
-    });
+    let _ = client.client.set(discord);
 
     client
   }
 
-  pub async fn add_channel_message_sender(&mut self, channel: Snowflake, sender: broadcast::Sender<DiscordMessage>) {
-    self.channel_message_event_handlers.entry(channel).or_default().push(sender);
+  fn discord(&self) -> &serenity::Client {
+    self.client.get().unwrap()
+  }
+
+  pub async fn add_channel_message_sender(&self, channel: Snowflake, sender: broadcast::Sender<DiscordMessage>) {
+    self.channel_message_event_handlers.write().await.entry(channel).or_default().push(sender);
   }
 
-  pub async fn send_message(&mut self, channel_id: Snowflake, content: String, nonce: String) {
+  pub async fn send_message(&self, channel_id: Snowflake, content: String, nonce: String) {
     println!("All the way to discord~! {:?} {:?}", channel_id, content);
-    ChannelId::new(channel_id.content).send_message(self.client.as_ref().unwrap().http.clone(), CreateMessage::new().content(content).enforce_nonce(true).nonce(serenity::all::Nonce::String(nonce))).await.unwrap();
+    ChannelId::new(channel_id.content)
+      .send_message(
+        self.discord().http.clone(),
+        CreateMessage::new().content(content).enforce_nonce(true).nonce(serenity::all::Nonce::String(nonce)),
+      )
+      .await
+      .unwrap();
   }
 }
 
-struct RemoteDiscordClient(Arc<RwLock<DiscordClient>>);
-
 #[async_trait]
-impl EventHandler for RemoteDiscordClient {
-  async fn ready(&self, ctx: Context, data_about_bot: serenity::model::prelude::Ready) {
+impl EventHandler for DiscordClient {
+  async fn ready(&self, _: Context, data_about_bot: serenity::model::prelude::Ready) {
     println!("Ready! {:?}", data_about_bot);
   }
 
@@ -69,7 +72,7 @@ impl EventHandler for RemoteDiscordClient {
       content: msg.channel_id.get(),
     };
 
-    if let Some(vec) = self.0.read().await.channel_message_event_handlers.get(&snowflake) {
+    if let Some(vec) = self.channel_message_event_handlers.read().await.get(&snowflake) {
       for sender in vec {
         println!("Sending to sender!");
 
@@ -86,7 +89,7 @@ impl EventHandler for RemoteDiscordClient {
           nonce: msg.nonce.clone().map(|n| match n {
             Nonce::Number(n) => n.to_string(),
             Nonce::String(s) => s,
-          })
+          }),
         });
       }
     }

src/ui/src/main.rs

@@ -1,5 +1,5 @@
-pub mod channel;
 pub mod app_state;
+pub mod channel;
 
 use std::{fs, path::PathBuf, sync::Arc};
 
@@ -30,44 +30,44 @@ impl AssetSource for Assets {
 actions!(main_menu, [Quit]);
 
 fn init(app_state: Arc<AppState>, cx: &mut AppContext) -> Result<()> {
-    components::init(cx);
+  components::init(cx);
 
-    cx.bind_keys([KeyBinding::new("cmd-q", Quit, None)]);
+  cx.bind_keys([KeyBinding::new("cmd-q", Quit, None)]);
 
-    Ok(())
+  Ok(())
 }
 
 #[tokio::main]
 async fn main() {
   env_logger::init();
 
-    let app_state = Arc::new(AppState {});
+  let app_state = Arc::new(AppState {});
 
     let token = dotenv::var("DISCORD_TOKEN").expect("Must provide DISCORD_TOKEN in .env");
     let demo_channel_id = dotenv::var("DEMO_CHANNEL_ID").expect("Must provide DEMO_CHANNEL_ID in .env");
 
   let mut client = DiscordClient::new(token);
 
-    let mut channel = DiscordChannel::new(client.clone(), Snowflake { content: demo_channel_id.parse().unwrap() }).await;
+  let channel = DiscordChannel::new(
+    client.clone(),
+    Snowflake {
+      content: demo_channel_id.parse().unwrap(),
+    },
+  )
+  .await;
 
-    App::new()
-        .with_assets(Assets {
-            base: PathBuf::from("img"),
-        })
-        .with_http_client(Arc::new(reqwest_client::ReqwestClient::new()))
-        .run(move |cx: &mut AppContext| {
-            AppState::set_global(Arc::downgrade(&app_state), cx);
+  App::new().with_assets(Assets { base: PathBuf::from("img") }).with_http_client(Arc::new(reqwest_client::ReqwestClient::new())).run(
+    move |cx: &mut AppContext| {
+      AppState::set_global(Arc::downgrade(&app_state), cx);
 
-            if let Err(e) = init(app_state.clone(), cx) {
-                log::error!("{}", e);
-                return;
-            }
+      if let Err(e) = init(app_state.clone(), cx) {
+        log::error!("{}", e);
+        return;
+      }
 
-            Theme::sync_system_appearance(cx);
+      Theme::sync_system_appearance(cx);
 
-            let window = cx.open_window(WindowOptions::default(), |cx| {
-                ChannelView::<DiscordMessage>::create(cx, channel)
-            })
-            .unwrap();
-        });
+      let window = cx.open_window(WindowOptions::default(), |cx| ChannelView::<DiscordMessage>::create(cx, channel)).unwrap();
+    },
+  );
 }