fix(ui): prevent cooldown resume crash if channel state is null (#2343)

Author: xsahil03x

packages/stream_chat/CHANGELOG.md

@@ -1,3 +1,10 @@
+## Upcoming
+
+🐞 Fixed
+
+- Fixed `Channel` methods to throw proper `StateError` exceptions instead of relying on assertions
+  for state validation.
+
 ## 9.15.0
 
 ✅ Added

packages/stream_chat/lib/src/client/channel.dart

@@ -2049,15 +2049,18 @@ class Channel {
   void dispose() {
     client.state.removeChannel('$cid');
     state?.dispose();
+    state = null;
     _muteExpirationTimer?.cancel();
     _keyStrokeHandler.cancel();
   }
 
   void _checkInitialized() {
-    assert(
-      _initializedCompleter.isCompleted,
-      "Channel $cid hasn't been initialized yet. Make sure to call .watch()"
-      ' or to instantiate the client using [Channel.fromState]',
+    if (_initializedCompleter.isCompleted && state != null) return;
+
+    throw StateError(
+      "Channel $cid hasn't been initialized yet or has been disposed. "
+      'Make sure to call .watch() or instantiate the client using '
+      '[Channel.fromState]',
     );
   }
 }

packages/stream_chat/test/src/client/channel_test.dart

@@ -1,4 +1,4 @@
-// ignore_for_file: lines_longer_than_80_chars
+// ignore_for_file: lines_longer_than_80_chars, cascade_invocations
 
 import 'package:mocktail/mocktail.dart';
 import 'package:stream_chat/stream_chat.dart';
@@ -5095,4 +5095,166 @@ void main() {
       expect(channel.canUpdateChannel, false);
     });
   });
+
+  group('Channel State Validation and Cooldown', () {
+    late final client = MockStreamChatClient();
+    const channelId = 'test-channel-id';
+    const channelType = 'test-channel-type';
+
+    setUpAll(() {
+      // detached loggers
+      when(() => client.detachedLogger(any())).thenAnswer((invocation) {
+        final name = invocation.positionalArguments.first;
+        return _createLogger(name);
+      });
+
+      final retryPolicy = RetryPolicy(
+        shouldRetry: (_, __, ___) => false,
+        delayFactor: Duration.zero,
+      );
+      when(() => client.retryPolicy).thenReturn(retryPolicy);
+
+      // fake clientState
+      final clientState = FakeClientState();
+      when(() => client.state).thenReturn(clientState);
+
+      // client logger
+      when(() => client.logger).thenReturn(_createLogger('mock-client-logger'));
+    });
+
+    group('Non-initialized channel state validation', () {
+      test(
+        'should throw StateError when accessing cooldown on non-initialized channel',
+        () {
+          final channel = Channel(client, channelType, channelId);
+          expect(() => channel.cooldown, throwsA(isA<StateError>()));
+        },
+      );
+
+      test(
+        'should throw StateError when accessing getRemainingCooldown on non-initialized channel',
+        () {
+          final channel = Channel(client, channelType, channelId);
+          expect(channel.getRemainingCooldown, throwsA(isA<StateError>()));
+        },
+      );
+
+      test(
+        'should throw StateError when accessing cooldownStream on non-initialized channel',
+        () {
+          final channel = Channel(client, channelType, channelId);
+          expect(() => channel.cooldownStream, throwsA(isA<StateError>()));
+        },
+      );
+    });
+
+    group('Initialized channel cooldown functionality', () {
+      late Channel channel;
+
+      setUp(() {
+        final channelState = _generateChannelState(channelId, channelType);
+        channel = Channel.fromState(client, channelState);
+      });
+
+      tearDown(() => channel.dispose());
+
+      test(
+        'should return default cooldown value of 0 for initialized channel',
+        () => expect(channel.cooldown, equals(0)),
+      );
+
+      test('should return custom cooldown value when set in channel model', () {
+        final channelWithCooldown = ChannelModel(
+          id: channelId,
+          type: channelType,
+          cooldown: 30,
+        );
+
+        final stateWithCooldown = ChannelState(channel: channelWithCooldown);
+        final testChannel = Channel.fromState(client, stateWithCooldown);
+        addTearDown(testChannel.dispose);
+
+        expect(testChannel.cooldown, equals(30));
+      });
+
+      test('should return 0 remaining cooldown when no cooldown is set', () {
+        expect(channel.getRemainingCooldown(), equals(0));
+      });
+
+      test('should return cooldown stream with default value', () {
+        expectLater(channel.cooldownStream.take(1), emits(0));
+      });
+    });
+
+    group('Disposed channel state validation', () {
+      late Channel channel;
+
+      setUp(() {
+        final channelState = _generateChannelState(channelId, channelType);
+        channel = Channel.fromState(client, channelState);
+      });
+
+      test(
+        'should throw StateError when accessing cooldown after disposal',
+        () {
+          // First verify it works when initialized
+          expect(channel.cooldown, equals(0));
+
+          // Dispose the channel
+          channel.dispose();
+
+          // Now accessing cooldown should throw
+          expect(() => channel.cooldown, throwsA(isA<StateError>()));
+        },
+      );
+
+      test(
+        'should throw StateError when accessing getRemainingCooldown after disposal',
+        () {
+          // First verify it works when initialized
+          expect(channel.getRemainingCooldown(), equals(0));
+
+          // Dispose the channel
+          channel.dispose();
+
+          // Now accessing getRemainingCooldown should throw
+          expect(channel.getRemainingCooldown, throwsA(isA<StateError>()));
+        },
+      );
+
+      test(
+        'should throw StateError when accessing cooldownStream after disposal',
+        () {
+          // First verify it works when initialized
+          expectLater(channel.cooldownStream.take(1), emits(0));
+
+          // Dispose the channel
+          channel.dispose();
+
+          // Now accessing cooldownStream should throw
+          expect(() => channel.cooldownStream, throwsA(isA<StateError>()));
+        },
+      );
+
+      test(
+        'should handle race condition scenario - initialization then quick disposal',
+        () {
+          // This test simulates the race condition that was causing the production crash
+          final channelState = _generateChannelState(channelId, channelType);
+          final raceChannel = Channel.fromState(client, channelState);
+
+          // Verify it works initially
+          expect(raceChannel.cooldown, equals(0));
+
+          // Simulate quick disposal (like what happens with rapid navigation)
+          raceChannel.dispose();
+
+          // This should throw StateError instead of crashing with null check operator
+          expect(() => raceChannel.cooldown, throwsA(isA<StateError>()));
+
+          expect(raceChannel.getRemainingCooldown, throwsA(isA<StateError>()));
+        },
+      );
+    });
+  });
 }

packages/stream_chat_flutter/CHANGELOG.md

@@ -4,6 +4,8 @@
 
 - Fixed context menu being truncated and scrollable on web when there was enough space to display it
   fully. [[#2317]](https://github.com/GetStream/stream-chat-flutter/issues/2317)
+- Fixed `StreamMessageInput` cooldown resume error if channel state is not yet initialized.
+  [[#2338]](https://github.com/GetStream/stream-chat-flutter/issues/2338)
 
 ✅ Added
 

packages/stream_chat_flutter/lib/src/message_input/stream_message_input.dart

@@ -571,7 +571,7 @@ class StreamMessageInputState extends State<StreamMessageInput>
     final config = StreamChatConfiguration.of(context);
 
     // Resumes the cooldown if the channel has currently an active cooldown.
-    if (!_isEditing) {
+    if (!_isEditing && channel.state != null) {
       _effectiveController.startCooldown(channel.getRemainingCooldown());
     }