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

@@ -252,6 +252,10 @@ class PerAccountStore extends ChangeNotifier with EmojiStore, ChannelStore, Mess
         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(
@@ -279,6 +283,7 @@ class PerAccountStore extends ChangeNotifier with EmojiStore, ChannelStore, Mess
     required this.userSettings,
     required this.users,
     required this.typingStatus,
+    required this.typingNotifier,
     required ChannelStoreImpl channels,
     required MessageStoreImpl messages,
     required this.unreads,
@@ -364,6 +369,7 @@ class PerAccountStore extends ChangeNotifier with EmojiStore, ChannelStore, Mess
   final Map<int, User> users;
 
   final TypingStatus typingStatus;
+  final TypingNotifier typingNotifier;
 
   ////////////////////////////////
   // Streams, topics, and stuff about them.
@@ -434,6 +440,7 @@ class PerAccountStore extends ChangeNotifier with EmojiStore, ChannelStore, Mess
     recentDmConversationsView.dispose();
     unreads.dispose();
     _messages.dispose();
+    typingNotifier.dispose();
     typingStatus.dispose();
     super.dispose();
   }

lib/model/typing_status.dart

@@ -1,9 +1,12 @@
 import 'dart:async';
 
-import 'package:flutter/foundation.dart';
+import 'package:flutter/widgets.dart';
 
 import '../api/model/events.dart';
+import '../api/route/typing.dart';
+import 'binding.dart';
 import 'narrow.dart';
+import 'store.dart';
 
 /// The model for tracking the typing status organized by narrows.
 ///
@@ -84,3 +87,141 @@ class TypingStatus extends ChangeNotifier {
     }
   }
 }
+
+/// Manages updates to the user's typing status.
+///
+/// See the web 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;
+
+  /// 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;
+  }
+
+  /// The narrow where the user is currently typing in.
+  SendableNarrow? _currentDestination;
+
+  /// The time elapsed since the last typing started request was sent.
+  Stopwatch? _lastNotifyStart;
+
+  /// A timer that resets whenever the user starts typing.
+  ///
+  /// Upon its expiry, the user is considered idle and a typing stopped request
+  /// will be sent.
+  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 (!debugEnable) return;
+
+    if (_currentDestination != null) {
+      if (destination == _currentDestination) {
+        // Nothing has really changed, except we may need
+        // to send a ping to the server and extend out our idle time
+        _maybePingServer(store);
+        _startOrExtendIdleTimer(store);
+        return;
+      }
+
+      // We stopped typing to our old destination,
+      // so we must stop the old typing status.
+      // Don't return yet, because we may have a new destination.
+      _stopLastNotification(store);
+    }
+
+    if (destination == null) {
+      // If we are not talking to somebody we care about,
+      // then there is no more action to take.
+      return;
+    }
+
+    // We just started typing to the destination, so notify the server.
+    _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) {
+    // This allows us to use [clock.stopwatch] only when testing.
+    _lastNotifyStart = ZulipBinding.instance.stopwatch()..start();
+
+    return setTypingStatus(
+      store.connection,
+      op: TypingOp.start,
+      destination: _currentDestination!.destination);
+  }
+
+  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: destination.destination);
+  }
+}