model: Add TypingNotifier.

The debugEnable setup is borrowed from
debugEnableRegisterNotificationToken. This acts as a hook to temporarily
disable typing notifications in later widget tests.

The documentation and implementation are based on the web app:

  https://github.com/zulip/zulip/blob/52a9846cdf4abfbe937a94559690d508e95f4065/web/shared/src/typing_status.ts

Signed-off-by: Zixuan James Li <[email protected]>

Author: PIG208

lib/model/store.dart

@@ -249,6 +249,10 @@ class PerAccountStore extends ChangeNotifier with ChannelStore, MessageStore {
         selfUserId: account.userId,
         typingStartedExpiryPeriod: Duration(milliseconds: initialSnapshot.serverTypingStartedExpiryPeriodMilliseconds),
       ),
+      typingNotifier: TypingNotifier(
+        typingStoppedWaitPeriod: Duration(milliseconds: initialSnapshot.serverTypingStoppedWaitPeriodMilliseconds),
+        typingStartedWaitPeriod: Duration(milliseconds: initialSnapshot.serverTypingStartedWaitPeriodMilliseconds),
+      ),
       channels: channels,
       messages: MessageStoreImpl(),
       unreads: Unreads(
@@ -276,6 +280,7 @@ class PerAccountStore extends ChangeNotifier with ChannelStore, MessageStore {
     required this.userSettings,
     required this.users,
     required this.typingStatus,
+    required this.typingNotifier,
     required ChannelStoreImpl channels,
     required MessageStoreImpl messages,
     required this.unreads,
@@ -342,6 +347,7 @@ class PerAccountStore extends ChangeNotifier with ChannelStore, MessageStore {
   final Map<int, User> users;
 
   final TypingStatus typingStatus;
+  final TypingNotifier typingNotifier;
 
   ////////////////////////////////
   // Streams, topics, and stuff about them.
@@ -409,6 +415,7 @@ class PerAccountStore extends ChangeNotifier with ChannelStore, MessageStore {
     recentDmConversationsView.dispose();
     unreads.dispose();
     _messages.dispose();
+    typingNotifier.dispose();
     typingStatus.dispose();
     super.dispose();
   }

lib/model/typing_status.dart

@@ -1,9 +1,13 @@
 import 'dart:async';
 
-import 'package:flutter/foundation.dart';
+import 'package:clock/clock.dart';
+import 'package:flutter/widgets.dart';
 
 import '../api/model/events.dart';
+import '../api/route/messages.dart';
+import '../api/route/typing.dart';
 import 'narrow.dart';
+import 'store.dart';
 
 /// The model for tracking the typing status organized by narrows.
 ///
@@ -84,3 +88,123 @@ class TypingStatus extends ChangeNotifier {
     }
   }
 }
+
+/// Manages updates to the user's typing status.
+///
+/// See the server implementation:
+///   https://github.com/zulip/zulip/blob/52a9846cdf4abfbe937a94559690d508e95f4065/web/shared/src/typing_status.ts
+class TypingNotifier {
+  TypingNotifier({
+    required this.typingStoppedWaitPeriod,
+    required this.typingStartedWaitPeriod,
+  });
+
+  final Duration typingStoppedWaitPeriod;
+  final Duration typingStartedWaitPeriod;
+
+  SendableNarrow? _currentDestination;
+  Stopwatch? _lastNotifyStart;
+  Timer? _idleTimer;
+
+  void dispose() {
+    _idleTimer?.cancel();
+  }
+
+  /// Update the store, and notify the server as needed, on the user's typing
+  /// status.
+  ///
+  /// This can and should be called frequently, on each keystroke.  The
+  /// implementation sends "still typing" notices at an appropriate throttled
+  /// rate, and keeps a timer to send a "stopped typing" notice when the user
+  /// hasn't typed for a few seconds.
+  ///
+  /// Call with `destination` as `null` when the user actively stops composing a
+  /// message.  If the user switches from one destination to another, there's no
+  /// need to call with `null` in between; the implementation tracks the change
+  /// and behaves appropriately.
+  ///
+  /// See docs/subsystems/typing-indicators.md for detailed background on the
+  /// typing indicators system.
+  void handleTypingStatusUpdate(PerAccountStore store, SendableNarrow? destination) {
+    if (!DebugTypingNotifier.debugEnable) return;
+
+    if (_currentDestination != null) {
+      if (destination == _currentDestination) {
+        _startOrExtendIdleTimer(store);
+        _maybePingServer(store);
+        return;
+      }
+
+      _stopLastNotification(store);
+    }
+
+    if (destination == null) return;
+
+    _currentDestination = destination;
+    _startOrExtendIdleTimer(store);
+    _actuallyPingServer(store);
+  }
+
+  void _startOrExtendIdleTimer(PerAccountStore store) {
+    _idleTimer?.cancel();
+    _idleTimer = Timer(typingStoppedWaitPeriod, () => _stopLastNotification(store));
+  }
+
+  Future<void> _maybePingServer(PerAccountStore store) async {
+    if (_lastNotifyStart == null || _lastNotifyStart!.elapsed > typingStartedWaitPeriod) {
+      await _actuallyPingServer(store);
+    }
+  }
+
+  Future<void> _actuallyPingServer(PerAccountStore store) {
+    _lastNotifyStart = clock.stopwatch()..start();
+
+    return setTypingStatus(store.connection,
+      op: TypingOp.start,
+      destination: MessageDestination.fromSendableNarrow(_currentDestination!),
+    );
+  }
+
+  Future<void> _stopLastNotification(PerAccountStore store) {
+    assert(_currentDestination != null);
+    final destination = _currentDestination!;
+
+    _idleTimer?.cancel();
+    _currentDestination = null;
+    _lastNotifyStart = null;
+
+    return setTypingStatus(store.connection,
+      op: TypingOp.stop,
+      destination: MessageDestination.fromSendableNarrow(destination),
+    );
+  }
+}
+
+/// A namespace for [TypingNotifier]'s debugging symbols.
+// This is for uncluttering [TypingNotifier] while still offering some testing
+// capabilities.
+abstract final class DebugTypingNotifier {
+  /// In debug mode, controls whether typing notifications should be sent.
+  ///
+  /// Outside of debug mode, this is always true and the setter has no effect.
+  static bool get debugEnable {
+    bool result = true;
+    assert(() {
+      result = _debugEnable;
+      return true;
+    }());
+    return result;
+  }
+  static bool _debugEnable = true;
+  static set debugEnable(bool value) {
+    assert(() {
+      _debugEnable = value;
+      return true;
+    }());
+  }
+
+  @visibleForTesting
+  static void debugReset() {
+    _debugEnable = true;
+  }
+}