Only distinguish between typing or not (incoming)

fixes #739

1 files changed, 58 insertions, 31 deletions

diff --git a/libdino/src/service/counterpart_interaction_manager.vala b/libdino/src/service/counterpart_interaction_manager.vala
index b994ca64..88818e95 100644
--- a/libdino/src/service/counterpart_interaction_manager.vala
+++ b/libdino/src/service/counterpart_interaction_manager.vala
@@ -8,13 +8,13 @@ public class CounterpartInteractionManager : StreamInteractionModule, Object {
     public static ModuleIdentity<CounterpartInteractionManager> IDENTITY = new ModuleIdentity<CounterpartInteractionManager>("counterpart_interaction_manager");
     public string id { get { return IDENTITY.id; } }
 
-    public signal void received_state(Account account, Jid jid, string state);
+    public signal void received_state(Conversation conversation, string state);
     public signal void received_marker(Account account, Jid jid, Entities.Message message, Entities.Message.Marked marker);
     public signal void received_message_received(Account account, Jid jid, Entities.Message message);
     public signal void received_message_displayed(Account account, Jid jid, Entities.Message message);
 
     private StreamInteractor stream_interactor;
-    private HashMap<Conversation, HashMap<Jid, string>> chat_states = new HashMap<Conversation, HashMap<Jid, string>>(Conversation.hash_func, Conversation.equals_func);
+    private HashMap<Conversation, HashMap<Jid, DateTime>> typing_since = new HashMap<Conversation, HashMap<Jid, DateTime>>(Conversation.hash_func, Conversation.equals_func);
     private HashMap<string, string> marker_wo_message = new HashMap<string, string>();
 
     public static void start(StreamInteractor stream_interactor) {
@@ -25,14 +25,42 @@ public class CounterpartInteractionManager : StreamInteractionModule, Object {
     private CounterpartInteractionManager(StreamInteractor stream_interactor) {
         this.stream_interactor = stream_interactor;
         stream_interactor.account_added.connect(on_account_added);
-        stream_interactor.get_module(MessageProcessor.IDENTITY).received_pipeline.connect(new ReceivedMessageListener(this));
-        stream_interactor.get_module(MessageProcessor.IDENTITY).message_sent.connect(check_if_got_marker);
-        stream_interactor.stream_negotiated.connect(() => chat_states.clear() );
+        stream_interactor.get_module(MessageProcessor.IDENTITY).message_received.connect((message, conversation) => clear_chat_state(conversation, message.from));
+        stream_interactor.get_module(MessageProcessor.IDENTITY).message_sent_or_received.connect(check_if_got_marker);
+        stream_interactor.get_module(PresenceManager.IDENTITY).received_offline_presence.connect((jid, account) => {
+            foreach (Conversation conversation in stream_interactor.get_module(ConversationManager.IDENTITY).get_conversations(jid, account)) {
+                clear_chat_state(conversation, jid);
+            }
+        });
+        stream_interactor.stream_negotiated.connect((account) => clear_all_chat_states(account) );
+
+        Timeout.add_seconds(60, () => {
+            var one_min_ago = new DateTime.now_utc().add_seconds(-1);
+
+            foreach (Conversation conversation in typing_since.keys) {
+                ArrayList<Jid> to_remove = new ArrayList<Jid>();
+                foreach (Jid jid in typing_since[conversation].keys) {
+                    if (typing_since[conversation][jid].compare(one_min_ago) < 0) {
+                        to_remove.add(jid);
+                    }
+                }
+                foreach (Jid jid in to_remove) {
+                    clear_chat_state(conversation, jid);
+                }
+            }
+            return true;
+        });
     }
 
-    public HashMap? get_chat_states(Conversation conversation) {
+    public Gee.List<Jid>? get_typing_jids(Conversation conversation) {
         if (stream_interactor.connection_manager.get_state(conversation.account) != ConnectionManager.ConnectionState.CONNECTED) return null;
-        return chat_states[conversation];
+        if (!typing_since.contains(conversation) || typing_since[conversation].size == 0) return null;
+
+        var jids = new ArrayList<Jid>();
+        foreach (Jid jid in typing_since[conversation].keys) {
+            jids.add(jid);
+        }
+        return jids;
     }
 
     private void on_account_added(Account account) {
@@ -47,6 +75,23 @@ public class CounterpartInteractionManager : StreamInteractionModule, Object {
         });
     }
 
+    private void clear_chat_state(Conversation conversation, Jid jid) {
+        if (!(typing_since.contains(conversation) && typing_since[conversation].contains(jid))) return;
+
+        typing_since[conversation].unset(jid);
+        received_state(conversation, Xmpp.Xep.ChatStateNotifications.STATE_ACTIVE);
+    }
+
+    private void clear_all_chat_states(Account account) {
+        foreach (Conversation conversation in typing_since.keys) {
+            if (conversation.account.equals(account)) {
+                foreach (Jid jid in typing_since[conversation].keys) {
+                    clear_chat_state(conversation, jid);
+                }
+            }
+        }
+    }
+
     private async void on_chat_state_received(Account account, Jid jid, string state, MessageStanza stanza) {
         // Don't show our own (other devices) typing notification
         if (jid.equals_bare(account.bare_jid)) return;
@@ -63,15 +108,15 @@ public class CounterpartInteractionManager : StreamInteractionModule, Object {
             }
         }
 
-        if (!chat_states.has_key(conversation)) {
-            chat_states[conversation] = new HashMap<Jid, string>(Jid.hash_func, Jid.equals_func);
+        if (!typing_since.has_key(conversation)) {
+            typing_since[conversation] = new HashMap<Jid, DateTime>(Jid.hash_func, Jid.equals_func);
         }
-        if (state == Xmpp.Xep.ChatStateNotifications.STATE_ACTIVE) {
-            chat_states[conversation].unset(jid);
+        if (state == Xmpp.Xep.ChatStateNotifications.STATE_COMPOSING) {
+            typing_since[conversation][jid] = new DateTime.now_utc();
+            received_state(conversation, state);
         } else {
-            chat_states[conversation][jid] = state;
+            clear_chat_state(conversation, jid);
         }
-        received_state(account, jid, state);
     }
 
     private void on_chat_marker_received(Account account, Jid jid, string marker, string stanza_id) {
@@ -140,24 +185,6 @@ public class CounterpartInteractionManager : StreamInteractionModule, Object {
         }
     }
 
-    private class ReceivedMessageListener : MessageListener {
-
-        public string[] after_actions_const = new string[]{ "DEDUPLICATE" };
-        public override string action_group { get { return "STORE"; } }
-        public override string[] after_actions { get { return after_actions_const; } }
-
-        private CounterpartInteractionManager outer;
-
-        public ReceivedMessageListener(CounterpartInteractionManager outer) {
-            this.outer = outer;
-        }
-
-        public override async bool run(Entities.Message message, Xmpp.MessageStanza stanza, Conversation conversation) {
-            outer.on_chat_state_received.begin(conversation.account, conversation.counterpart, Xep.ChatStateNotifications.STATE_ACTIVE, stanza);
-            return false;
-        }
-    }
-
     private void on_receipt_received(Account account, Jid jid, string id) {
         on_chat_marker_received(account, jid, Xep.ChatMarkers.MARKER_RECEIVED, id);
     }