feat: add explicit rich presence clearing; can be completely hidden w…

…ith `force = true`

lua/cord/activity/manager.lua

@@ -224,6 +224,8 @@ function ActivityManager:resume()
   end
 end
 
+function ActivityManager:clear_activity(force) self.tx:clear_activity(force) end
+
 function ActivityManager:should_update_time()
   return self.config.display.show_time
     and (

lua/cord/event/sender.lua

@@ -25,7 +25,7 @@ function Producer:update_activity(activity)
   self:send_event('update_activity', activity)
 end
 
-function Producer:clear_activity() self:send_event 'clear_activity' end
+function Producer:clear_activity(force) self:send_event('clear_activity', force) end
 
 function Producer:disconnect() self:send_event 'disconnect' end
 

src/messages/events/client/clear_activity.rs

@@ -1,31 +1,48 @@
 use crate::messages::events::event::{EventContext, OnEvent};
 use crate::presence::packet::Packet;
+use crate::protocol::msgpack::Deserialize;
 
 #[derive(Debug, Default)]
-pub struct ClearActivityEvent;
+pub struct ClearActivityEvent {
+    force: bool,
+}
 
 impl OnEvent for ClearActivityEvent {
     fn on_event(self, ctx: &mut EventContext) -> crate::Result<()> {
-        let sessions = ctx.cord.session_manager.sessions.read().unwrap();
-        let latest = sessions
-            .iter()
-            .filter(|s| s.1.last_activity.is_some())
-            .max_by_key(|s| {
-                (
-                    s.1.last_activity.as_ref().is_some_and(|a| !a.is_idle),
-                    s.1.last_updated,
-                )
-            });
-
-        if let Some((_, session)) = latest {
-            ctx.cord.rich_client.update(&Packet::new(
-                ctx.cord.rich_client.pid,
-                session.last_activity.as_ref(),
-            ))?;
-        } else {
+        if self.force {
             ctx.cord.rich_client.clear()?;
+        } else {
+            let sessions = ctx.cord.session_manager.sessions.read().unwrap();
+            let latest = sessions
+                .iter()
+                .filter(|s| s.1.last_activity.is_some())
+                .max_by_key(|s| {
+                    (
+                        s.1.last_activity.as_ref().is_some_and(|a| !a.is_idle),
+                        s.1.last_updated,
+                    )
+                });
+
+            if let Some((_, session)) = latest {
+                ctx.cord.rich_client.update(&Packet::new(
+                    ctx.cord.rich_client.pid,
+                    session.last_activity.as_ref(),
+                ))?;
+            } else {
+                ctx.cord.rich_client.clear()?;
+            }
         }
 
         Ok(())
     }
 }
+
+impl Deserialize for ClearActivityEvent {
+    fn deserialize(
+        input: crate::protocol::msgpack::Value,
+    ) -> crate::Result<Self> {
+        let force = input.as_bool().unwrap_or_default();
+
+        Ok(ClearActivityEvent { force })
+    }
+}

src/messages/events/client/mod.rs

@@ -61,7 +61,9 @@ impl ClientEvent {
             "update_activity" => Self::UpdateActivity(
                 UpdateActivityEvent::new(Activity::deserialize(data!(map))?),
             ),
-            "clear_activity" => Self::ClearActivity(ClearActivityEvent),
+            "clear_activity" => Self::ClearActivity(
+                ClearActivityEvent::deserialize(data!(map))?,
+            ),
             "disconnect" => Self::Disconnect(DisconnectEvent),
             _ => return Err(format!("Unknown message type: {}", ty).into()),
         })