chore: Apply changes from version 4.20.11+1

Support patch off 4.20.11 (customers pinned to that line). New-direct-chat
first-message + 1:1 header fixes:
- guard member firstWhere + attach message/loading listeners before lookup
- resolve 1:1 header from cache with retry on collection emits (no extra network)
- no reset() on create/open/jump init paths (keep live-collection reactor alive)
- dismiss chat loading toast via close()/BlocListener
- example android toolchain bump (Kotlin 2.1.20 / AGP 8.9.1 / Gradle 8.11.1)

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: kornsitti

example/android/gradle/wrapper/gradle-wrapper.properties

@@ -2,4 +2,4 @@ distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.9-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.11.1-all.zip

example/android/settings.gradle

@@ -18,8 +18,8 @@ pluginManagement {
 
 plugins {
     id "dev.flutter.flutter-plugin-loader" version "1.0.0"
-    id "com.android.application" version "8.7.3" apply false
-    id "org.jetbrains.kotlin.android" version "1.9.0" apply false
+    id "com.android.application" version "8.9.1" apply false
+    id "org.jetbrains.kotlin.android" version "2.1.20" apply false
 }
 
 include ":app"

lib/v4/chat/message/bloc/chat_page_bloc.dart

@@ -347,9 +347,18 @@ class ChatPageBloc extends Bloc<ChatPageEvent, ChatPageState> {
 
       final channelId = channel.channelId;
       if (channelId != null) {
-        initLiveCollection(channelId);
+        // Await init so the message-stream + loading-state listeners and the
+        // live collection's reactor are fully wired before the first page is
+        // loaded. Then load the first page directly WITHOUT reset(): reset()
+        // stops the reactor and forces an empty first-page query whose
+        // deletePagingIdByHash wipes paging-ids, which races the user's first
+        // optimistic send (the create flow drops them straight into a ready
+        // chat) and makes that message invisible until re-entry (PDT new-chat
+        // message-not-shown). Keeping the reactor alive lets the optimistic
+        // message keep its paging-id.
+        await initLiveCollection(channelId);
         addEvent(ChatPageEventChannelIdChanged(channelId));
-        addEvent(ChatPageEventRefresh());
+        liveCollection?.loadNext();
         addEvent(const ChatPageEventFetchMuteState());
       }
     });
@@ -508,12 +517,16 @@ class ChatPageBloc extends Bloc<ChatPageEvent, ChatPageState> {
       addEvent(ChatPageSetAroundMessage(
           aroundMessageId: event.aroundMessageId));
 
-      // Reinitialize the live collection with the aroundMessageId
-      initLiveCollection(state.channelId,
+      // Reinitialize the live collection with the aroundMessageId. Await so the
+      // rebuilt collection + listeners are wired, then load the first page
+      // WITHOUT reset(): reset() stops the reactor and forces an empty-first-page
+      // paging-id wipe that can hide an in-flight optimistic send. Keeping the
+      // reactor alive avoids that race.
+      await initLiveCollection(state.channelId,
           aroundMessageId: event.aroundMessageId);
 
-      // Refresh to load messages around the target message
-      addEvent(ChatPageEventRefresh());
+      // Load messages around the target message.
+      liveCollection?.loadNext();
     });
 
     on<ChatPageSetAroundMessage>((event, emit) async {
@@ -555,9 +568,14 @@ class ChatPageBloc extends Bloc<ChatPageEvent, ChatPageState> {
     if (channelId != null && channelId.isNotEmpty) {
       addEvent(ChatPageSetAroundMessage(aroundMessageId: jumpToMessageId));
 
+      // initLiveCollection assigns liveCollection and attaches its listeners
+      // synchronously (before its first await) on a fresh open, so loadNext()
+      // below runs against the live collection. Load directly WITHOUT reset()
+      // so the reactor is never stopped (avoids the empty-first-page paging-id
+      // wipe racing an optimistic send).
       initLiveCollection(channelId, aroundMessageId: jumpToMessageId);
       addEvent(ChatPageEventChannelIdChanged(channelId));
-      addEvent(ChatPageEventRefresh());
+      liveCollection?.loadNext();
       addEvent(const ChatPageEventFetchMuteState());
     } else if (userId != null && userId.isNotEmpty) {
       addEvent(ChatPageEventCreateNewChannel(userId: userId));
@@ -622,6 +640,9 @@ class ChatPageBloc extends Bloc<ChatPageEvent, ChatPageState> {
 
   @override
   Future<void> close() {
+    // PDT-3317: guarantee the global loading toast is dismissed when leaving
+    // the page so a stuck "loading" toast can never leak across the app.
+    toastBloc.add(AmityToastDismissIfLoading());
     _scrollController.dispose();
     subscription.cancel();
     _jumpToMessageTimeoutTimer?.cancel();
@@ -630,7 +651,34 @@ class ChatPageBloc extends Bloc<ChatPageEvent, ChatPageState> {
     return super.close();
   }
 
-  void initLiveCollection(String channelId, {String? aroundMessageId}) async {
+  /// Resolve the 1:1 header's other participant from the LOCAL cache only (no
+  /// network `getMembers()`). No-op once `state.channelMember` is set, so the
+  /// message-listener retry stops as soon as the header fills.
+  Future<void> _resolveHeaderFromCache(String channelId) async {
+    if (state.channelMember != null) return;
+    try {
+      final list = await AmityChatClient.newChannelRepository()
+          .membership(channelId)
+          .getMembersFromCache();
+      AmityChannelMember? otherMember;
+      for (final member in list) {
+        if (member.userId != AmityCoreClient.getUserId()) {
+          otherMember = member;
+          break;
+        }
+      }
+
+      if (otherMember?.user != null) {
+        addEvent(ChatPageHeaderEventChanged(channelMember: otherMember!));
+        // User will be updated in the HeaderEventChanged handler
+      }
+    } catch (_) {
+      // Cache not ready yet; a later collection emit retries.
+    }
+  }
+
+  Future<void> initLiveCollection(String channelId,
+      {String? aroundMessageId}) async {
     if (liveCollection != null) {
       liveCollection?.getStreamController().close();
       await liveCollection?.dispose();
@@ -651,26 +699,30 @@ class ChatPageBloc extends Bloc<ChatPageEvent, ChatPageState> {
 
     liveCollection = query.getLiveCollection();
 
-    final list = await AmityChatClient.newChannelRepository()
-        .membership(channelId)
-        .getMembersFromCache();
-    final otherMember = list
-        .firstWhere((element) => element.userId != AmityCoreClient.getUserId());
-
-    if (otherMember.user != null) {
-      addEvent(ChatPageHeaderEventChanged(channelMember: otherMember));
-      // User will be updated in the HeaderEventChanged handler
-    }
-
+    // Attach the message + loading-state listeners FIRST so the page can
+    // render and the loading state can reach `false` regardless of the
+    // member-cache lookup below. The lookup used an unguarded `firstWhere`
+    // that throws "Bad state: No element" when the member cache is empty or
+    // holds only the current user (a never-messaged contact whose channel
+    // exists with no messages). Because the throw happened before these
+    // listeners attached, the chat hung on loading.
     liveCollection?.getStreamController().stream.listen((event) {
       addEvent(
           ChatPageEventChanged(messages: event, isFetching: state.isFetching));
+      // Brand-new chat: member cache is empty at init, so the header starts
+      // blank. Retry the cache read on each emit until it resolves — no network
+      // getMembers(); no-op once state.channelMember is set.
+      if (state.channelMember == null) _resolveHeaderFromCache(channelId);
     });
 
     liveCollection?.observeLoadingState().listen((event) {
       addEvent(ChatPageEventLoadingStateUpdated(isFetching: event));
     });
 
+    // First attempt at init; may be empty for a just-created channel, in which
+    // case the message-listener retry above resolves it once the cache fills.
+    await _resolveHeaderFromCache(channelId);
+
     // Observe Network Connectivity status here
     subscription =
         Connectivity().onConnectivityChanged.listen((connectivityEvent) {

lib/v4/chat/message/chat_loading_toast.dart

@@ -0,0 +1,18 @@
+import 'package:amity_uikit_beta_service/v4/chat/message/bloc/chat_page_bloc.dart';
+
+/// Pure decision helpers for the one-to-one chat loading toast lifecycle.
+///
+/// Extracted from `chat_page.dart` so the show/dismiss conditions are
+/// unit-testable without the Amity SDK, and so the dismiss can be driven
+/// from a `BlocListener` (every state) instead of `BlocBuilder.builder`
+/// (coalesced per frame).
+
+/// The loading toast should be shown only while the page is still in its
+/// initial state and the chat was not opened as a just-created conversation.
+bool shouldShowChatLoadingToast(ChatPageState state, bool isJustCreated) =>
+    state is ChatPageStateInitial && !isJustCreated;
+
+/// The loading toast should be dismissed as soon as the page has left the
+/// initial state and is no longer fetching.
+bool shouldDismissChatLoadingToast(ChatPageState state) =>
+    !state.isFetching && state is! ChatPageStateInitial;

lib/v4/chat/message/chat_page.dart

@@ -4,6 +4,7 @@ import 'package:amity_uikit_beta_service/l10n/localization_helper.dart';
 import 'package:amity_uikit_beta_service/v4/chat/full_text_message.dart';
 import 'package:amity_uikit_beta_service/v4/chat/message/amity_message_bubble.dart';
 import 'package:amity_uikit_beta_service/v4/chat/message/bloc/chat_page_bloc.dart';
+import 'package:amity_uikit_beta_service/v4/chat/message/chat_loading_toast.dart';
 import 'package:amity_uikit_beta_service/v4/chat/message/components/amity_conversation_chat_user_action_component.dart';
 import 'package:amity_uikit_beta_service/v4/chat/message_composer/message_composer.dart';
 import 'package:amity_uikit_beta_service/v4/chat/message_composer/message_composer_action.dart';
@@ -85,24 +86,27 @@ class AmityChatPage extends NewBasePage {
                 if (state.bounceTargetIndex != null && bounceAnimator != null) {
                   bounceAnimator!.animateItem(state.bounceTargetIndex!);
                 }
+                // Dismiss the loading toast here (not in builder): the
+                // listener runs for every state, so the transient
+                // {not-Initial, isFetching:false} state is never coalesced
+                // away the way it is in BlocBuilder.builder.
+                if (shouldDismissChatLoadingToast(state)) {
+                  context
+                      .read<AmityToastBloc>()
+                      .add(AmityToastDismissIfLoading());
+                  _handleToastDismissal(context, state);
+                }
               },
               child: BlocBuilder<ChatPageBloc, ChatPageState>(
                 key: Key("${channelId ?? ""}_${userId ?? ""}"),
                 builder: (context, state) {
-                if (state is ChatPageStateInitial && !isJustCreated) {
+                if (shouldShowChatLoadingToast(state, isJustCreated)) {
                   context.read<AmityToastBloc>().add(AmityToastLoading(
                       message: context.l10n.chat_loading,
                       icon: AmityToastIcon.loading,
                       bottomPadding: toastBottomPadding));
                 }
 
-                if (!state.isFetching && state is! ChatPageStateInitial) {
-                  context
-                      .read<AmityToastBloc>()
-                      .add(AmityToastDismissIfLoading());
-                  _handleToastDismissal(context, state);
-                }
-
                 final isLoadingUserAvatar =
                     state.avatarUrl == null && state.userDisplayName == null;
 

pubspec.yaml

@@ -1,6 +1,6 @@
 name: amity_uikit_beta_service
 description: Amity UIkit opensource developed by SLE team to enable social feature in Flutter.
-version: 4.20.11
+version: 4.20.11+1
 homepage: https://github.com/ThanakornThanom/ThanakornThanom--flutter_amity_uikit_beta_service
 
 environment:

test/v4/chat/message/chat_loading_toast_test.dart

@@ -0,0 +1,50 @@
+import 'package:flutter/widgets.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:amity_uikit_beta_service/v4/chat/message/bloc/chat_page_bloc.dart';
+import 'package:amity_uikit_beta_service/v4/chat/message/chat_loading_toast.dart';
+
+void main() {
+  TestWidgetsFlutterBinding.ensureInitialized();
+
+  ChatPageStateInitial initialState() => ChatPageStateInitial(
+        channelId: 'c1',
+        userDisplayName: null,
+        avatarUrl: null,
+        scrollController: ScrollController(),
+      );
+
+  ChatPageState changedState({required bool isFetching}) => ChatPageState(
+        channelId: 'c1',
+        messages: const [],
+        scrollController: ScrollController(),
+        isFetching: isFetching,
+      );
+
+  group('shouldShowChatLoadingToast', () {
+    test('shows on Initial when not just-created', () {
+      expect(shouldShowChatLoadingToast(initialState(), false), isTrue);
+    });
+    test('suppressed when just-created', () {
+      expect(shouldShowChatLoadingToast(initialState(), true), isFalse);
+    });
+    test('not shown once out of Initial', () {
+      expect(
+          shouldShowChatLoadingToast(changedState(isFetching: true), false),
+          isFalse);
+    });
+  });
+
+  group('shouldDismissChatLoadingToast', () {
+    test('dismisses on first non-Initial state with isFetching=false', () {
+      expect(shouldDismissChatLoadingToast(changedState(isFetching: false)),
+          isTrue);
+    });
+    test('does not dismiss while still Initial', () {
+      expect(shouldDismissChatLoadingToast(initialState()), isFalse);
+    });
+    test('does not dismiss while fetching', () {
+      expect(shouldDismissChatLoadingToast(changedState(isFetching: true)),
+          isFalse);
+    });
+  });
+}