feat(discord): broadcast typing indicator while composing a message

Author: chojs23

src/app/command_dispatch.rs

@@ -90,6 +90,7 @@ impl CommandDispatcher {
                 .await;
             }
             command @ (AppCommand::SendMessage { .. }
+            | AppCommand::TriggerTyping { .. }
             | AppCommand::CreateForumPost { .. }
             | AppCommand::SetThreadArchived { .. }
             | AppCommand::SetThreadLocked { .. }

src/app/message_commands.rs

@@ -24,6 +24,7 @@ pub(super) async fn handle(client: DiscordClient, command: AppCommand) {
             Ok(message) => client.publish_event(message_create_event(message)).await,
             Err(error) => publish_app_error(&client, "send message failed", &error).await,
         },
+        AppCommand::TriggerTyping { channel_id } => client.trigger_typing(channel_id),
         AppCommand::SendTtsMessage {
             channel_id,
             content,

src/discord/client/rest_actions.rs

@@ -31,6 +31,7 @@ impl DiscordClient {
         attachments: &[MessageAttachmentUpload],
     ) -> Result<MessageInfo> {
         self.ensure_can_send_message(channel_id, attachments)?;
+        self.rest.spawn_typing(channel_id);
         let upload_limit = self.attachment_size_limit(channel_id);
         self.rest
             .send_message(channel_id, content, reply_to, attachments, upload_limit)
@@ -43,9 +44,14 @@ impl DiscordClient {
         content: &str,
     ) -> Result<MessageInfo> {
         self.ensure_can_send_tts_message(channel_id)?;
+        self.rest.spawn_typing(channel_id);
         self.rest.send_tts_message(channel_id, content).await
     }
 
+    pub fn trigger_typing(&self, channel_id: Id<ChannelMarker>) {
+        self.rest.spawn_typing(channel_id);
+    }
+
     pub async fn create_forum_post(&self, post: &ForumPostCreate) -> Result<CreatedForumPost> {
         self.ensure_can_create_forum_post(post)?;
         let upload_limit = self.attachment_size_limit(post.channel_id);

src/discord/commands.rs

@@ -474,6 +474,9 @@ pub enum AppCommand {
     SetSelectedMessageChannel {
         channel_id: Option<Id<ChannelMarker>>,
     },
+    TriggerTyping {
+        channel_id: Id<ChannelMarker>,
+    },
     SubscribeDirectMessage {
         channel_id: Id<ChannelMarker>,
     },

src/discord/mod.rs

@@ -53,7 +53,6 @@ pub use channel::{
 };
 pub use client::DiscordClient;
 pub(crate) use client::validate_token_header;
-pub(crate) use fingerprint::refresh_client_build_number;
 pub use commands::{
     AppCommand, AttachmentDownloadId, DownloadAttachmentSource, ForumPostArchiveState,
     ForumPostCreate, GlobalUserProfileUpdate, GuildUserProfileUpdate, MediaPlaybackRequestId,
@@ -73,6 +72,7 @@ pub use events::{
     PresenceEventFields, SequencedAppEvent, ThreadListSyncInfo, ThreadMemberUpdateInfo,
     ThreadMembersUpdateInfo, UserGuildSettingsInfo,
 };
+pub(crate) use fingerprint::refresh_client_build_number;
 pub use guild::{CustomEmojiInfo, GuildFolder};
 pub use ids::{Id, marker};
 pub use member::{MemberInfo, RoleInfo};

src/discord/rest/messages.rs

@@ -36,6 +36,26 @@ impl DiscordRest {
             .await
     }
 
+    /// Fires a typing indicator without blocking the send it precedes. A
+    /// message that arrives with no prior typing looks automated.
+    pub fn spawn_typing(&self, channel_id: Id<ChannelMarker>) {
+        let rest = self.clone();
+        tokio::spawn(async move {
+            let _ = rest.trigger_typing(channel_id).await;
+        });
+    }
+
+    async fn trigger_typing(&self, channel_id: Id<ChannelMarker>) -> Result<()> {
+        self.send_unit(
+            self.raw_http.post(format!(
+                "https://discord.com/api/v9/channels/{}/typing",
+                channel_id.get()
+            )),
+            "trigger typing",
+        )
+        .await
+    }
+
     pub async fn send_tts_message(
         &self,
         channel_id: Id<ChannelMarker>,

src/tui/input/keyboard/composer.rs

@@ -22,7 +22,7 @@ pub(super) fn handle_composer_key(state: &mut DashboardState, key: KeyEvent) ->
         }
         ComposerAction::InsertNewline => {
             state.push_composer_char('\n');
-            None
+            state.note_composer_typing()
         }
         ComposerAction::Submit => state.submit_composer(),
         ComposerAction::Close => {
@@ -85,7 +85,7 @@ pub(super) fn handle_composer_key(state: &mut DashboardState, key: KeyEvent) ->
             if value != ':' || !state.open_composer_reaction_picker_from_plus_colon() {
                 state.push_composer_char(value);
             }
-            None
+            state.note_composer_typing()
         }
         ComposerAction::Ignore => None,
     }

src/tui/state/composer/state.rs

@@ -1,4 +1,5 @@
 use std::ops::Range;
+use std::time::{Duration, Instant};
 
 use crate::discord::ids::{
     Id,
@@ -46,6 +47,10 @@ pub enum DmComposerLock {
     NeverMessaged,
 }
 
+/// Discord keeps a typing indicator alive for about ten seconds, so resend a
+/// little sooner while the user keeps typing.
+const COMPOSER_TYPING_INTERVAL: Duration = Duration::from_secs(8);
+
 #[derive(Debug, Default)]
 pub(in crate::tui::state) struct ComposerUiState {
     pub(in crate::tui::state) composer_input: TextInputState,
@@ -71,6 +76,9 @@ pub(in crate::tui::state) struct ComposerUiState {
     /// Mutually exclusive with those pickers, enforced in
     /// `refresh_active_mention_query`.
     pub(in crate::tui::state) emoji_completion: EmojiCompletionState,
+    /// Channel and time of the last typing indicator sent while composing, used
+    /// to throttle resends.
+    pub(in crate::tui::state) last_typing_sent: Option<(Id<ChannelMarker>, Instant)>,
 }
 
 #[derive(Debug, Default)]
@@ -462,6 +470,32 @@ impl DashboardState {
         self.insert_composer_text_at_cursor(&text);
     }
 
+    pub fn note_composer_typing(&mut self) -> Option<AppCommand> {
+        self.note_composer_typing_at(Instant::now())
+    }
+
+    pub(in crate::tui::state) fn note_composer_typing_at(
+        &mut self,
+        now: Instant,
+    ) -> Option<AppCommand> {
+        // Discord does not broadcast typing while editing an existing message.
+        if self.composer.edit_target_message.is_some() {
+            return None;
+        }
+        let channel_id = self.selected_channel_id()?;
+        let due = match self.composer.last_typing_sent {
+            Some((last_channel, at)) if last_channel == channel_id => {
+                now.saturating_duration_since(at) >= COMPOSER_TYPING_INTERVAL
+            }
+            _ => true,
+        };
+        if !due {
+            return None;
+        }
+        self.composer.last_typing_sent = Some((channel_id, now));
+        Some(AppCommand::TriggerTyping { channel_id })
+    }
+
     pub fn insert_composer_text_at_cursor(&mut self, value: &str) {
         if value.is_empty() {
             return;

src/tui/state/tests/composer.rs

@@ -2206,3 +2206,25 @@ fn composer_sends_to_opened_thread_channel() {
         })
     );
 }
+
+#[test]
+fn composer_typing_indicator_throttles_and_resends() {
+    use std::time::{Duration, Instant};
+
+    let mut state = state_with_writable_channel();
+    state.start_composer();
+    let typing = Some(AppCommand::TriggerTyping {
+        channel_id: Id::new(2),
+    });
+
+    let start = Instant::now();
+    assert_eq!(state.note_composer_typing_at(start), typing);
+    assert_eq!(
+        state.note_composer_typing_at(start + Duration::from_secs(1)),
+        None
+    );
+    assert_eq!(
+        state.note_composer_typing_at(start + Duration::from_secs(8)),
+        typing
+    );
+}