diff --git a/synapse/handlers/typing.py b/synapse/handlers/typing.py
index d88a53242c..989f73947f 100644
--- a/synapse/handlers/typing.py
+++ b/synapse/handlers/typing.py
@@ -43,7 +43,14 @@ class TypingNotificationHandler(BaseHandler):
self.federation.register_edu_handler("m.typing", self._recv_edu)
- self._member_typing_until = {}
+ self._member_typing_until = {} # clock time we expect to stop
+ self._member_typing_timer = {} # deferreds to manage theabove
+
+ # map room IDs to serial numbers
+ self._room_serials = {}
+ self._latest_room_serial = 0
+ # map room IDs to sets of users currently typing
+ self._room_typing = {}
@defer.inlineCallbacks
def started_typing(self, target_user, auth_user, room_id, timeout):
@@ -58,7 +65,13 @@ class TypingNotificationHandler(BaseHandler):
was_present = member in self._member_typing_until
+ if member in self._member_typing_timer:
+ self.clock.cancel_call_later(self._member_typing_timer[member])
+
self._member_typing_until[member] = until
+ self._member_typing_timer[member] = self.clock.call_later(
+ timeout / 1000, lambda: self._stopped_typing(member)
+ )
if was_present:
# No point sending another notification
@@ -80,16 +93,25 @@ class TypingNotificationHandler(BaseHandler):
member = RoomMember(room_id=room_id, user=target_user)
+ yield self._stopped_typing(member)
+
+ @defer.inlineCallbacks
+ def _stopped_typing(self, member):
if member not in self._member_typing_until:
# No point
defer.returnValue(None)
yield self._push_update(
- room_id=room_id,
- user=target_user,
+ room_id=member.room_id,
+ user=member.user,
typing=False,
)
+ del self._member_typing_until[member]
+
+ self.clock.cancel_call_later(self._member_typing_timer[member])
+ del self._member_typing_timer[member]
+
@defer.inlineCallbacks
def _push_update(self, room_id, user, typing):
localusers = set()
@@ -101,12 +123,11 @@ class TypingNotificationHandler(BaseHandler):
ignore_user=user
)
- for u in localusers:
- self.push_update_to_clients(
+ if localusers:
+ self._push_update_local(
room_id=room_id,
- observer_user=u,
- observed_user=user,
- typing=typing,
+ user=user,
+ typing=typing
)
deferreds = []
@@ -135,29 +156,65 @@ class TypingNotificationHandler(BaseHandler):
room_id, localusers=localusers
)
- for u in localusers:
- self.push_update_to_clients(
+ if localusers:
+ self._push_update_local(
room_id=room_id,
- observer_user=u,
- observed_user=user,
+ user=user,
typing=content["typing"]
)
- def push_update_to_clients(self, room_id, observer_user, observed_user,
- typing):
- # TODO(paul) steal this from presence.py
- pass
+ def _push_update_local(self, room_id, user, typing):
+ if room_id not in self._room_serials:
+ self._room_serials[room_id] = 0
+ self._room_typing[room_id] = set()
+
+ room_set = self._room_typing[room_id]
+ if typing:
+ room_set.add(user)
+ elif user in room_set:
+ room_set.remove(user)
+
+ self._latest_room_serial += 1
+ self._room_serials[room_id] = self._latest_room_serial
+
+ self.notifier.on_new_user_event(rooms=[room_id])
class TypingNotificationEventSource(object):
def __init__(self, hs):
self.hs = hs
+ self._handler = None
+
+ def handler(self):
+ # Avoid cyclic dependency in handler setup
+ if not self._handler:
+ self._handler = self.hs.get_handlers().typing_notification_handler
+ return self._handler
+
+ def _make_event_for(self, room_id):
+ typing = self.handler()._room_typing[room_id]
+ return {
+ "type": "m.typing",
+ "room_id": room_id,
+ "typing": [u.to_string() for u in typing],
+ }
def get_new_events_for_user(self, user, from_key, limit):
- return ([], from_key)
+ from_key = int(from_key)
+ handler = self.handler()
+
+ events = []
+ for room_id in handler._room_serials:
+ if handler._room_serials[room_id] <= from_key:
+ continue
+
+ # TODO: check if user is in room
+ events.append(self._make_event_for(room_id))
+
+ return (events, handler._latest_room_serial)
def get_current_key(self):
- return 0
+ return self.handler()._latest_room_serial
def get_pagination_rows(self, user, pagination_config, key):
return ([], pagination_config.from_key)
diff --git a/tests/handlers/test_typing.py b/tests/handlers/test_typing.py
index 7e6ed9a42f..b858f96323 100644
--- a/tests/handlers/test_typing.py
+++ b/tests/handlers/test_typing.py
@@ -65,6 +65,9 @@ class TypingNotificationsTestCase(unittest.TestCase):
self.mock_config = Mock()
self.mock_config.signing_key = [MockKey()]
+ mock_notifier = Mock(spec=["on_new_user_event"])
+ self.on_new_user_event = mock_notifier.on_new_user_event
+
hs = HomeServer("test",
clock=self.clock,
db_pool=None,
@@ -77,6 +80,7 @@ class TypingNotificationsTestCase(unittest.TestCase):
"get_destination_retry_timings",
]),
handlers=None,
+ notifier=mock_notifier,
resource_for_client=Mock(),
resource_for_federation=self.mock_federation_resource,
http_client=self.mock_http_client,
@@ -85,11 +89,9 @@ class TypingNotificationsTestCase(unittest.TestCase):
)
hs.handlers = JustTypingNotificationHandlers(hs)
- self.mock_update_client = Mock()
- self.mock_update_client.return_value = defer.succeed(None)
-
self.handler = hs.get_handlers().typing_notification_handler
- self.handler.push_update_to_clients = self.mock_update_client
+
+ self.event_source = hs.get_event_sources().sources["typing"]
self.datastore = hs.get_datastore()
self.datastore.get_destination_retry_timings.return_value = (
@@ -151,6 +153,8 @@ class TypingNotificationsTestCase(unittest.TestCase):
def test_started_typing_local(self):
self.room_members = [self.u_apple, self.u_banana]
+ self.assertEquals(self.event_source.get_current_key(), 0)
+
yield self.handler.started_typing(
target_user=self.u_apple,
auth_user=self.u_apple,
@@ -158,13 +162,20 @@ class TypingNotificationsTestCase(unittest.TestCase):
timeout=20000,
)
- self.mock_update_client.assert_has_calls([
- call(observer_user=self.u_banana,
- observed_user=self.u_apple,
- room_id=self.room_id,
- typing=True),
+ self.on_new_user_event.assert_has_calls([
+ call(rooms=[self.room_id]),
])
+ self.assertEquals(self.event_source.get_current_key(), 1)
+ self.assertEquals(
+ self.event_source.get_new_events_for_user(self.u_apple, 0, None)[0],
+ [
+ {"type": "m.typing",
+ "room_id": self.room_id,
+ "typing": [self.u_apple.to_string()]},
+ ]
+ )
+
@defer.inlineCallbacks
def test_started_typing_remote_send(self):
self.room_members = [self.u_apple, self.u_onion]
@@ -198,6 +209,8 @@ class TypingNotificationsTestCase(unittest.TestCase):
def test_started_typing_remote_recv(self):
self.room_members = [self.u_apple, self.u_onion]
+ self.assertEquals(self.event_source.get_current_key(), 0)
+
yield self.mock_federation_resource.trigger("PUT",
"/_matrix/federation/v1/send/1000000/",
_make_edu_json("farm", "m.typing",
@@ -209,13 +222,20 @@ class TypingNotificationsTestCase(unittest.TestCase):
)
)
- self.mock_update_client.assert_has_calls([
- call(observer_user=self.u_apple,
- observed_user=self.u_onion,
- room_id=self.room_id,
- typing=True),
+ self.on_new_user_event.assert_has_calls([
+ call(rooms=[self.room_id]),
])
+ self.assertEquals(self.event_source.get_current_key(), 1)
+ self.assertEquals(
+ self.event_source.get_new_events_for_user(self.u_apple, 0, None)[0],
+ [
+ {"type": "m.typing",
+ "room_id": self.room_id,
+ "typing": [self.u_onion.to_string()]},
+ ]
+ )
+
@defer.inlineCallbacks
def test_stopped_typing(self):
self.room_members = [self.u_apple, self.u_banana, self.u_onion]
@@ -238,9 +258,14 @@ class TypingNotificationsTestCase(unittest.TestCase):
# Gut-wrenching
from synapse.handlers.typing import RoomMember
- self.handler._member_typing_until[
- RoomMember(self.room_id, self.u_apple)
- ] = 1002000
+ member = RoomMember(self.room_id, self.u_apple)
+ self.handler._member_typing_until[member] = 1002000
+ self.handler._member_typing_timer[member] = (
+ self.clock.call_later(1002, lambda: 0)
+ )
+ self.handler._room_typing[self.room_id] = set((self.u_apple,))
+
+ self.assertEquals(self.event_source.get_current_key(), 0)
yield self.handler.stopped_typing(
target_user=self.u_apple,
@@ -248,11 +273,62 @@ class TypingNotificationsTestCase(unittest.TestCase):
room_id=self.room_id,
)
- self.mock_update_client.assert_has_calls([
- call(observer_user=self.u_banana,
- observed_user=self.u_apple,
- room_id=self.room_id,
- typing=False),
+ self.on_new_user_event.assert_has_calls([
+ call(rooms=[self.room_id]),
])
yield put_json.await_calls()
+
+ self.assertEquals(self.event_source.get_current_key(), 1)
+ self.assertEquals(
+ self.event_source.get_new_events_for_user(self.u_apple, 0, None)[0],
+ [
+ {"type": "m.typing",
+ "room_id": self.room_id,
+ "typing": []},
+ ]
+ )
+
+ @defer.inlineCallbacks
+ def test_typing_timeout(self):
+ self.room_members = [self.u_apple, self.u_banana]
+
+ self.assertEquals(self.event_source.get_current_key(), 0)
+
+ yield self.handler.started_typing(
+ target_user=self.u_apple,
+ auth_user=self.u_apple,
+ room_id=self.room_id,
+ timeout=10000,
+ )
+
+ self.on_new_user_event.assert_has_calls([
+ call(rooms=[self.room_id]),
+ ])
+ self.on_new_user_event.reset_mock()
+
+ self.assertEquals(self.event_source.get_current_key(), 1)
+ self.assertEquals(
+ self.event_source.get_new_events_for_user(self.u_apple, 0, None)[0],
+ [
+ {"type": "m.typing",
+ "room_id": self.room_id,
+ "typing": [self.u_apple.to_string()]},
+ ]
+ )
+
+ self.clock.advance_time(11)
+
+ self.on_new_user_event.assert_has_calls([
+ call(rooms=[self.room_id]),
+ ])
+
+ self.assertEquals(self.event_source.get_current_key(), 2)
+ self.assertEquals(
+ self.event_source.get_new_events_for_user(self.u_apple, 1, None)[0],
+ [
+ {"type": "m.typing",
+ "room_id": self.room_id,
+ "typing": []},
+ ]
+ )
|
