additional events

3 files changed, 48 insertions, 15 deletions

diff --git a/mumd/src/network/tcp.rs b/mumd/src/network/tcp.rs
index 5cc2bf7..4140f2a 100644
--- a/mumd/src/network/tcp.rs
+++ b/mumd/src/network/tcp.rs
@@ -13,6 +13,7 @@ use mumble_protocol::control::{msgs, ClientControlCodec, ControlCodec, ControlPa
 use mumble_protocol::crypt::ClientCryptState;
 use mumble_protocol::voice::VoicePacket;
 use mumble_protocol::{Clientbound, Serverbound};
+use mumlib::command::MumbleEventKind;
 use std::collections::HashMap;
 use std::convert::{Into, TryInto};
 use std::net::SocketAddr;
@@ -337,6 +338,8 @@ async fn listen(
                 if let Some(user) = user {
                     notifications::send(format!("{}: {}", user, msg.get_message()));
                     //TODO: probably want a config flag for this
+                    let user = user.to_string();
+                    state.push_event(MumbleEventKind::TextMessageReceived(user)) //TODO also include message target
                 }
                 state.register_message((msg.get_message().to_owned(), msg.get_actor()));
                 drop(state);
diff --git a/mumd/src/state.rs b/mumd/src/state.rs
index ec25204..3aa330f 100644
--- a/mumd/src/state.rs
+++ b/mumd/src/state.rs
@@ -170,6 +170,7 @@ impl State {
             .users_mut()
             .get_mut(&session)
             .unwrap();
+        let username = user.name().to_string();
 
         let mute = if msg.has_self_mute() && user.self_mute() != msg.get_self_mute() {
             Some(msg.get_self_mute())
@@ -185,35 +186,43 @@ impl State {
         let diff = UserDiff::from(msg);
         user.apply_user_diff(&diff);
 
-        let user = self.server().unwrap().users().get(&session).unwrap();
 
         if Some(session) != self.server().unwrap().session_id() {
-            //send notification if the user moved to or from any channel
+            // Send notification if the user moved either to or from our channel
             if let Some(to_channel) = diff.channel_id {
                 let this_channel =
                     self.get_users_channel(self.server().unwrap().session_id().unwrap());
-                if from_channel == this_channel || to_channel == this_channel {
+
+                if from_channel == this_channel {
+                    // User moved from our channel to somewhere else
                     if let Some(channel) = self.server().unwrap().channels().get(&to_channel) {
+                        let channel = channel.name().to_string();
                         notifications::send(format!(
                             "{} moved to channel {}",
-                            user.name(),
-                            channel.name()
+                            &username,
+                            &channel,
                         ));
-                    } else {
-                        warn!("{} moved to invalid channel {}", user.name(), to_channel);
+                        self.push_event(MumbleEventKind::UserLeftChannel(username.clone(), channel));
                     }
-                    self.audio_output
-                        .play_effect(if from_channel == this_channel {
-                            NotificationEvents::UserJoinedChannel
-                        } else {
-                            NotificationEvents::UserLeftChannel
-                        });
+                    self.audio_output.play_effect(NotificationEvents::UserLeftChannel);
+                } else if to_channel == this_channel {
+                    // User moved from somewhere else to our channel
+                    if let Some(channel) = self.server().unwrap().channels().get(&from_channel) {
+                        let channel = channel.name().to_string();
+                        notifications::send(format!(
+                            "{} moved to your channel from {}",
+                            &username,
+                            &channel,
+                        ));
+                        self.push_event(MumbleEventKind::UserJoinedChannel(username.clone(), channel));
+                    }
+                    self.audio_output.play_effect(NotificationEvents::UserJoinedChannel);
                 }
             }
 
             //send notification if a user muted/unmuted
             if mute != None || deaf != None {
-                let mut s = user.name().to_string();
+                let mut s = username;
                 if let Some(mute) = mute {
                     s += if mute { " muted" } else { " unmuted" };
                 }
@@ -224,7 +233,8 @@ impl State {
                     s += if deaf { " deafened" } else { " undeafened" };
                 }
                 s += " themselves";
-                notifications::send(s);
+                notifications::send(s.clone());
+                self.push_event(MumbleEventKind::UserMuteStateChanged(s));
             }
         }
     }
diff --git a/mumlib/src/command.rs b/mumlib/src/command.rs
index 402d6b0..818fd70 100644
--- a/mumlib/src/command.rs
+++ b/mumlib/src/command.rs
@@ -20,8 +20,15 @@ impl fmt::Display for MumbleEvent {
 pub enum MumbleEventKind {
     UserConnected(String, Option<String>),
     UserDisconnected(String, Option<String>),
+    /// This logic is kinda weird so we only store the rendered message.
+    UserMuteStateChanged(String),
+    TextMessageReceived(String),
+    UserJoinedChannel(String, String),
+    UserLeftChannel(String, String),
 }
 
+//TODO These strings are (mostly) duplicated with their respective notifications.
+//     The only difference is that the text message event doesn't contain the text message.
 impl fmt::Display for MumbleEventKind {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
@@ -31,6 +38,19 @@ impl fmt::Display for MumbleEventKind {
             MumbleEventKind::UserDisconnected(user, channel) => {
                 write!(f, "{} disconnected from {}", user, channel.as_deref().unwrap_or("unknown channel"))
             }
+            MumbleEventKind::UserMuteStateChanged(message) => {
+                write!(f, "{}", message)
+            }
+            MumbleEventKind::TextMessageReceived(user) => {
+                write!(f, "{} sent a text message", user)
+            }
+            MumbleEventKind::UserJoinedChannel(name, from) => {
+                write!(f, "{} moved to your channel from {}", name, from)
+            }
+            MumbleEventKind::UserLeftChannel(name, to) => {
+                write!(f, "{} moved to {}", name, to)
+            }
+
         }
     }
 }