Support setting typing status

lib/model/binding.dart

@@ -113,6 +113,11 @@ abstract class ZulipBinding {
   /// This wraps [url_launcher.closeInAppWebView].
   Future<void> closeInAppWebView();
 
+  /// Provides access to a new stopwatch.
+  ///
+  /// Outside tests, this just calls the [Stopwatch] constructor.
+  Stopwatch stopwatch();
+
   /// Provides device and operating system information,
   /// via package:device_info_plus.
   ///
@@ -360,6 +365,9 @@ class LiveZulipBinding extends ZulipBinding {
     return url_launcher.closeInAppWebView();
   }
 
+  @override
+  Stopwatch stopwatch() => Stopwatch();
+
   @override
   Future<BaseDeviceInfo?> get deviceInfo => _deviceInfo;
   late Future<BaseDeviceInfo?> _deviceInfo;

lib/model/store.dart

@@ -277,6 +277,13 @@ class PerAccountStore extends ChangeNotifier with EmojiStore, ChannelStore, Mess
       accountId: accountId,
       selfUserId: account.userId,
       userSettings: initialSnapshot.userSettings,
+      typingNotifier: TypingNotifier(
+        connection: connection,
+        typingStoppedWaitPeriod: Duration(
+          milliseconds: initialSnapshot.serverTypingStoppedWaitPeriodMilliseconds),
+        typingStartedWaitPeriod: Duration(
+          milliseconds: initialSnapshot.serverTypingStartedWaitPeriodMilliseconds),
+      ),
       users: Map.fromEntries(
         initialSnapshot.realmUsers
         .followedBy(initialSnapshot.realmNonActiveUsers)
@@ -311,6 +318,7 @@ class PerAccountStore extends ChangeNotifier with EmojiStore, ChannelStore, Mess
     required this.accountId,
     required this.selfUserId,
     required this.userSettings,
+    required this.typingNotifier,
     required this.users,
     required this.typingStatus,
     required ChannelStoreImpl channels,
@@ -413,6 +421,8 @@ class PerAccountStore extends ChangeNotifier with EmojiStore, ChannelStore, Mess
 
   final UserSettings? userSettings; // TODO(server-5)
 
+  final TypingNotifier typingNotifier;
+
   ////////////////////////////////
   // Users and data about them.
 
@@ -493,6 +503,7 @@ class PerAccountStore extends ChangeNotifier with EmojiStore, ChannelStore, Mess
     unreads.dispose();
     _messages.dispose();
     typingStatus.dispose();
+    typingNotifier.dispose();
     updateMachine?.dispose();
     connection.close();
     _disposed = true;

lib/model/typing_status.dart

@@ -2,7 +2,10 @@ import 'dart:async';
 
 import 'package:flutter/foundation.dart';
 
+import '../api/core.dart';
 import '../api/model/events.dart';
+import '../api/route/typing.dart';
+import 'binding.dart';
 import 'narrow.dart';
 
 /// The model for tracking the typing status organized by narrows.
@@ -23,7 +26,7 @@ class TypingStatus extends ChangeNotifier {
     _timerMapsByNarrow[narrow]?.keys ?? [];
 
   // Using SendableNarrow as the key covers the narrows
-  // where typing notifications are supported (topics and DMs).
+  // where typing notices are supported (topics and DMs).
   final Map<SendableNarrow, Map<int, Timer>> _timerMapsByNarrow = {};
 
   @override
@@ -84,3 +87,148 @@ class TypingStatus extends ChangeNotifier {
     }
   }
 }
+
+/// Sends the self-user's typing-status updates.
+///
+/// See also:
+///  * https://github.com/zulip/zulip/blob/52a9846cdf4abfbe937a94559690d508e95f4065/web/shared/src/typing_status.ts
+///  * https://zulip.readthedocs.io/en/latest/subsystems/typing-indicators.html
+class TypingNotifier {
+  TypingNotifier({
+    required this.connection,
+    required this.typingStoppedWaitPeriod,
+    required this.typingStartedWaitPeriod,
+  });
+
+  final ApiConnection connection;
+  final Duration typingStoppedWaitPeriod;
+  final Duration typingStartedWaitPeriod;
+
+  SendableNarrow? _currentDestination;
+
+  /// Records time elapsed since the last time we notify the server;
+  /// this is `null` when the user is not actively typing.
+  Stopwatch? _sinceLastPing;
+
+  /// A timer that resets on every [keystroke].
+  ///
+  /// Upon its expiry, the user is considered idle and
+  /// a "typing stopped" notice will be sent.
+  Timer? _idleTimer;
+
+  void dispose() {
+    _idleTimer?.cancel();
+  }
+
+  /// Updates the server, if needed, that a keystroke was made when
+  /// composing a new message to [destination].
+  ///
+  /// To be called on all keystrokes in the composing session.
+  /// Sends "typing started" notices, throttled appropriately,
+  /// for repeated calls to the same [destination].
+  ///
+  /// If [destination] differs from the previous call, such as after a topic
+  /// input change, sends a "typing stopped" notice for the old destination.
+  ///
+  /// Keeps a timer to send a "typing stopped" notice when this and
+  /// [stoppedComposing] haven't been called in some time.
+  void keystroke(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.
+        if (_sinceLastPing!.elapsed > typingStartedWaitPeriod) {
+          _actuallyPingServer();
+        }
+        _startOrExtendIdleTimer();
+        return;
+      }
+
+      _stopLastNotification();
+    }
+
+    // We just started typing to this destination, so notify the server.
+    _currentDestination = destination;
+    _startOrExtendIdleTimer();
+    _actuallyPingServer();
+  }
+
+  /// Sends the server a "typing stopped" notice for the destination of
+  /// the current composing session, if there is one.
+  ///
+  /// To be called on cues that the user has exited a new-message composing session,
+  /// e.g., send button tapped, compose box unfocused, nav changed, app quit.
+  ///
+  /// If [keystroke] hasn't been called in some time, does nothing.
+  ///
+  /// Otherwise:
+  /// - Users will see our user's typing indicator disappear immediately
+  ///   instead of after [keystroke]'s timer.
+  /// - [keystroke]'s timer is canceled.
+  ///
+  /// (This has no "destination" param because the user can really only compose
+  /// to one destination at a time. This function acts on the current session
+  /// regardless of its destination.)
+  void stoppedComposing() {
+    if (!debugEnable) return;
+
+    if (_currentDestination != null) {
+      _stopLastNotification();
+    }
+  }
+
+  void _startOrExtendIdleTimer() {
+    _idleTimer?.cancel();
+    _idleTimer = Timer(typingStoppedWaitPeriod, _stopLastNotification);
+  }
+
+  void _actuallyPingServer() {
+    // This allows us to use [clock.stopwatch] only when testing.
+    _sinceLastPing = ZulipBinding.instance.stopwatch()..start();
+
+    unawaited(setTypingStatus(
+      connection,
+      op: TypingOp.start,
+      destination: _currentDestination!.destination));
+  }
+
+  void _stopLastNotification() {
+    assert(_currentDestination != null);
+    final destination = _currentDestination!;
+
+    _idleTimer!.cancel();
+    _currentDestination = null;
+    _sinceLastPing = null;
+
+    unawaited(setTypingStatus(
+      connection,
+      op: TypingOp.stop,
+      destination: destination.destination));
+  }
+
+  /// In debug mode, controls whether typing notices 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;
+  }
+}

lib/widgets/compose_box.dart

@@ -269,19 +269,100 @@ class ComposeContentController extends ComposeController<ContentValidationError>
   }
 }
 
-class _ContentInput extends StatelessWidget {
+class _ContentInput extends StatefulWidget {
   const _ContentInput({
     required this.narrow,
+    required this.destination,
     required this.controller,
     required this.focusNode,
     required this.hintText,
   });
 
   final Narrow narrow;
+  final SendableNarrow destination;
   final ComposeContentController controller;
   final FocusNode focusNode;
   final String hintText;
 
+  @override
+  State<_ContentInput> createState() => _ContentInputState();
+}
+
+class _ContentInputState extends State<_ContentInput> with WidgetsBindingObserver {
+  @override
+  void initState() {
+    super.initState();
+    widget.controller.addListener(_contentChanged);
+    widget.focusNode.addListener(_focusChanged);
+    WidgetsBinding.instance.addObserver(this);
+  }
+
+  @override
+  void didUpdateWidget(covariant _ContentInput oldWidget) {
+    super.didUpdateWidget(oldWidget);
+    if (widget.controller != oldWidget.controller) {
+      oldWidget.controller.removeListener(_contentChanged);
+      widget.controller.addListener(_contentChanged);
+    }
+    if (widget.focusNode != oldWidget.focusNode) {
+      oldWidget.focusNode.removeListener(_focusChanged);
+      widget.focusNode.addListener(_focusChanged);
+    }
+  }
+
+  @override
+  void dispose() {
+    widget.controller.removeListener(_contentChanged);
+    widget.focusNode.removeListener(_focusChanged);
+    WidgetsBinding.instance.removeObserver(this);
+    super.dispose();
+  }
+
+  void _contentChanged() {
+    final store = PerAccountStoreWidget.of(context);
+    (widget.controller.text.isEmpty)
+      ? store.typingNotifier.stoppedComposing()
+      : store.typingNotifier.keystroke(widget.destination);
+  }
+
+  void _focusChanged() {
+    if (widget.focusNode.hasFocus) {
+      // Content input getting focus doesn't necessarily mean that
+      // the user started typing, so do nothing.
+      return;
+    }
+    final store = PerAccountStoreWidget.of(context);
+    store.typingNotifier.stoppedComposing();
+  }
+
+  @override
+  void didChangeAppLifecycleState(AppLifecycleState state) {
+    switch (state) {
+      case AppLifecycleState.hidden:
+      case AppLifecycleState.paused:
+      case AppLifecycleState.detached:
+        // Transition to either [hidden] or [paused] signals that
+        // > [the] application is not currently visible to the user, and not
+        // > responding to user input.
+        //
+        // When transitioning to [detached], the compose box can't exist:
+        // > The application defaults to this state before it initializes, and
+        // > can be in this state (applicable on Android, iOS, and web) after
+        // > all views have been detached.
+        //
+        // For all these states, we can conclude that the user is not
+        // composing a message.
+        final store = PerAccountStoreWidget.of(context);
+        store.typingNotifier.stoppedComposing();
+      case AppLifecycleState.inactive:
+        // > At least one view of the application is visible, but none have
+        // > input focus. The application is otherwise running normally.
+        // For example, we expect this state when the user is selecting a file
+        // to upload.
+      case AppLifecycleState.resumed:
+    }
+  }
+
   @override
   Widget build(BuildContext context) {
     ColorScheme colorScheme = Theme.of(context).colorScheme;
@@ -296,15 +377,15 @@ class _ContentInput extends StatelessWidget {
           maxHeight: 200,
         ),
         child: ComposeAutocomplete(
-          narrow: narrow,
-          controller: controller,
-          focusNode: focusNode,
+          narrow: widget.narrow,
+          controller: widget.controller,
+          focusNode: widget.focusNode,
           fieldViewBuilder: (context) {
             return TextField(
-              controller: controller,
-              focusNode: focusNode,
+              controller: widget.controller,
+              focusNode: widget.focusNode,
               style: TextStyle(color: colorScheme.onSurface),
-              decoration: InputDecoration.collapsed(hintText: hintText),
+              decoration: InputDecoration.collapsed(hintText: widget.hintText),
               maxLines: null,
               textCapitalization: TextCapitalization.sentences,
             );
@@ -370,6 +451,7 @@ class _StreamContentInputState extends State<_StreamContentInput> {
       ?? zulipLocalizations.composeBoxUnknownChannelName;
     return _ContentInput(
       narrow: widget.narrow,
+      destination: TopicNarrow(widget.narrow.streamId, _topicTextNormalized),
       controller: widget.controller,
       focusNode: widget.focusNode,
       hintText: zulipLocalizations.composeBoxChannelContentHint(streamName, _topicTextNormalized));
@@ -446,6 +528,7 @@ class _FixedDestinationContentInput extends StatelessWidget {
   Widget build(BuildContext context) {
     return _ContentInput(
       narrow: narrow,
+      destination: narrow,
       controller: controller,
       focusNode: focusNode,
       hintText: _hintText(context));
@@ -818,6 +901,10 @@ class _SendButtonState extends State<_SendButton> {
     final content = widget.contentController.textNormalized;
 
     widget.contentController.clear();
+    // The following `stoppedComposing` call is currently redundant,
+    // because clearing input sends a "typing stopped" notice.
+    // It will be necessary once we resolve #720.
+    store.typingNotifier.stoppedComposing();
 
     try {
       // TODO(#720) clear content input only on success response;

test/model/binding.dart

@@ -1,5 +1,6 @@
 import 'dart:async';
 
+import 'package:clock/clock.dart';
 import 'package:firebase_core/firebase_core.dart';
 import 'package:firebase_messaging/firebase_messaging.dart';
 import 'package:flutter/foundation.dart';
@@ -209,6 +210,9 @@ class TestZulipBinding extends ZulipBinding {
     _closeInAppWebViewCallCount++;
   }
 
+  @override
+  Stopwatch stopwatch() => clock.stopwatch();
+
   /// The value that `ZulipBinding.instance.deviceInfo` should return.
   BaseDeviceInfo deviceInfoResult = _defaultDeviceInfoResult;
   static const _defaultDeviceInfoResult = AndroidDeviceInfo(sdkInt: 33, release: '13');