Develop

docs/audio-stream-refactoring.md

@@ -1,5 +1,19 @@
 # Audio Stream Store Refactoring
 
+## Expo SDK 56 migration requirement
+
+Before upgrading Dispatch to Expo SDK 56, upgrade `expo-audio` to the SDK 56-compatible version and replace all remaining `expo-av` audio usage with `expo-audio`. SDK 56 no longer provides the legacy Expo Modules Core header required by `expo-av` 16, so leaving `expo-av` installed can break the iOS archive build.
+
+Migration checklist:
+
+- Migrate `src/hooks/use-ptt.ts`, `src/components/calls/call-audio-modal.tsx`, `src/stores/app/audio-stream-store.ts`, and `src/services/audio.service.ts` to `createAudioPlayer`, `setAudioModeAsync`, `AudioPlayer`, and `playbackStatusUpdate`.
+- Remove `expo-av` from `package.json`, the lockfile, tests/mocks, and the Expo Doctor exclusion after no imports remain.
+- Keep this as an audio-only migration. Dispatch does not currently use the `expo-av` video component, so `expo-video` is not required for this change.
+- Re-test remote MP3 streams on physical iOS and Android devices. This store originally moved to `expo-av` because remote streams had problems with the earlier `expo-audio` implementation.
+- Also test PTT, call audio, background playback, interruptions, and Bluetooth/headset routing before release.
+
+Do not copy an SDK 56 implementation back into the current SDK 54 app unchanged. Dispatch's current `expo-audio` 1.1 API does not expose SDK 56 options such as `preferredForwardBufferDuration` or playback `status.error`.
+
 ## Overview
 
 The audio stream store has been refactored to use `expo-av` instead of `expo-audio` to resolve issues with playing remote MP3 streams over the internet in the new Expo architecture.

package.json

@@ -127,6 +127,7 @@
     "expo-auth-session": "~7.0.11",
     "expo-av": "~16.0.8",
     "expo-build-properties": "~1.0.10",
+    "expo-clipboard": "~8.0.8",
     "expo-constants": "~18.0.13",
     "expo-crypto": "~15.0.9",
     "expo-dev-client": "~6.0.21",

src/api/chat/chatbot.ts

@@ -7,7 +7,7 @@ const CHATBOT = '/Chatbot';
 /** Gets (creating if needed) the caller's chatbot conversation channel. */
 export const getChatbotChannel = async (signal?: AbortSignal) => {
   const response = await api.get<ChatbotChannelResponse>(`${CHATBOT}/GetChatChannel`, { signal });
-  return response.data;
+  return response.data?.Data ?? null;
 };
 
 /**
@@ -19,7 +19,7 @@ export const sendChatbotMessage = async (text: string, clientMessageId: string)
     Text: text,
     ClientMessageId: clientMessageId,
   });
-  return response.data;
+  return response.data?.Data ?? null;
 };
 
 /** Resets the chatbot conversational session (message history is retained). */

src/api/feature-flags/feature-flags.ts

@@ -0,0 +1,37 @@
+import { api } from '../common/client';
+
+const FEATURE_TOGGLES = '/FeatureToggles';
+
+// ---------------------------------------------------------------------------
+// Feature toggle evaluation (department-scoped, any authenticated user).
+// Backed by the v4 FeatureToggles API; keys live in Resgrid.Model.FeatureFlagKeys.
+// ---------------------------------------------------------------------------
+
+export interface FeatureToggleData {
+  Key: string;
+  Enabled: boolean;
+  Value?: string | null;
+  ValueType?: string | null;
+  Source?: string | null;
+}
+
+export interface FeatureTogglesResult {
+  Data?: FeatureToggleData[];
+  StateHash?: string;
+}
+
+export interface FeatureToggleResult {
+  Data?: FeatureToggleData;
+}
+
+/** Evaluates every active flag for the caller's department. */
+export const getAllFeatureFlags = async (signal?: AbortSignal) => {
+  const response = await api.get<FeatureTogglesResult>(`${FEATURE_TOGGLES}/GetAll`, { signal });
+  return response.data;
+};
+
+/** Lightweight enabled-only check for a single flag. */
+export const getFeatureFlagState = async (key: string, signal?: AbortSignal) => {
+  const response = await api.get<FeatureToggleResult>(`${FEATURE_TOGGLES}/GetState`, { params: { key }, signal });
+  return response.data;
+};

src/app/(app)/_layout.tsx

@@ -30,6 +30,7 @@ import { type GetConfigResultData } from '@/models/v4/configs/getConfigResultDat
 import { usePushNotifications } from '@/services/push-notification';
 import { useCoreStore } from '@/stores/app/core-store';
 import { useCallsStore } from '@/stores/calls/store';
+import { FeatureFlagKeys, featureFlagsStore } from '@/stores/feature-flags/store';
 import useLockscreenStore from '@/stores/lockscreen/store';
 import { useRolesStore } from '@/stores/roles/store';
 import { securityStore } from '@/stores/security/store';
@@ -150,7 +151,14 @@ export default function TabLayout() {
         await securityStore.getState().getRights();
 
         logger.info({
-          message: 'Security rights retrieved, connecting SignalR',
+          message: 'Security rights retrieved, fetching feature flags',
+          context: { platform: Platform.OS },
+        });
+
+        await featureFlagsStore.getState().fetchFlags();
+
+        logger.info({
+          message: 'Feature flags fetched, connecting SignalR',
           context: { platform: Platform.OS },
         });
 
@@ -169,18 +177,26 @@ export default function TabLayout() {
           // Don't fail initialization if SignalR connection fails
         }
 
-        // Connect the realtime chat hub (best-effort; chat may be disabled per department)
-        try {
-          await useSignalRStore.getState().connectChatHub();
+        // Connect the realtime chat hub only when the Chat.System feature flag is on for
+        // this department; when it is off every chat surface stays hidden.
+        if (featureFlagsStore.getState().isEnabled(FeatureFlagKeys.ChatSystem)) {
+          try {
+            await useSignalRStore.getState().connectChatHub();
+            logger.info({
+              message: 'SignalR chat hub connected successfully',
+              context: { platform: Platform.OS },
+            });
+          } catch (error) {
+            logger.error({
+              message: 'Failed to connect SignalR chat hub during initialization',
+              context: { error, platform: Platform.OS },
+            });
+          }
+        } else {
           logger.info({
-            message: 'SignalR chat hub connected successfully',
+            message: 'Chat disabled by feature flag; skipping chat hub connection',
             context: { platform: Platform.OS },
           });
-        } catch (error) {
-          logger.error({
-            message: 'Failed to connect SignalR chat hub during initialization',
-            context: { error, platform: Platform.OS },
-          });
         }
 
         // Initialize weather alerts

src/app/(app)/chat.tsx

@@ -1,4 +1,4 @@
-import { type Href, Stack, useFocusEffect, useRouter } from 'expo-router';
+import { type Href, Redirect, Stack, useFocusEffect, useRouter } from 'expo-router';
 import { Bot, MessageCircle, MessagesSquare, Network, Plus, Sparkles, Users } from 'lucide-react-native';
 import React, { useCallback, useState } from 'react';
 import { useTranslation } from 'react-i18next';
@@ -15,17 +15,19 @@
 import { FocusAwareStatusBar } from '@/components/ui/focus-aware-status-bar';
 import { HStack } from '@/components/ui/hstack';
 import { Pressable } from '@/components/ui/pressable';
+import { Spinner } from '@/components/ui/spinner';
 import { Text } from '@/components/ui/text';
 import { VStack } from '@/components/ui/vstack';
 import { type ChatChannelResultData, ChatChannelType } from '@/models/v4/chat';
 import { useChatStore } from '@/stores/chat/store';
+import { useChatSystemStatus } from '@/stores/feature-flags/store';
 
 function ChannelRow({ channel, onPress }: { channel: ChatChannelResultData; onPress: () => void }) {
   const { t } = useTranslation();
   const unread = channel.UnreadCount > 0;
   const isDm = channel.ChannelType === ChatChannelType.DirectMessage;
 
   const Leading = () => {
     if (isDm) {
       return (
         <Avatar size="md">
@@ -81,6 +83,8 @@
 export default function ChatScreen() {
   const { t } = useTranslation();
   const router = useRouter();
+  const chatStatus = useChatSystemStatus();
+  const isChatEnabled = chatStatus === 'enabled';
   const channels = useChatStore((s) => s.channels);
   const isLoading = useChatStore((s) => s.isLoadingChannels);
   const pendingAcks = useChatStore((s) => s.pendingAcks);
@@ -89,20 +93,44 @@
 
   useFocusEffect(
     useCallback(() => {
+      if (!isChatEnabled) return;
       useChatStore.getState().fetchChannels();
       useChatStore.getState().fetchPendingAcks();
-    }, [])
+    }, [isChatEnabled])
   );
 
   const grouped = groupChannels(channels);
 
   const openChannel = useCallback(
     (channelId: string) => {
+      // The assistant conversation always opens in its dedicated restricted screen
+      // (text only, no reactions/threads/deletes) instead of the generic conversation.
+      const channel = useChatStore.getState().channels.find((c) => c.ChatChannelId === channelId);
+      if (channel?.ChannelType === ChatChannelType.Chatbot) {
+        router.push('/chatbot' as Href);
+        return;
+      }
       router.push(`/chat/${channelId}` as Href);
     },
     [router]
   );
 
+  // Chat.System flag not yet resolved: wait instead of redirecting away from a valid route.
+  if (chatStatus === 'unknown') {
+    return (
+      <Box className="size-full flex-1 items-center justify-center bg-background-0">
+        <Stack.Screen options={{ headerShown: false }} />
+        <FocusAwareStatusBar />
+        <Spinner />
+      </Box>
+    );
+  }
+
+  // Chat.System feature flag off: no chat for this department.
+  if (chatStatus === 'disabled') {
+    return <Redirect href={'/home' as Href} />;
+  }
+
   return (
     <Box className="size-full flex-1 bg-background-0">
       <Stack.Screen options={{ headerShown: false }} />

src/app/(app)/chatbot.tsx

@@ -1,48 +1,65 @@
-import { Stack, useFocusEffect } from 'expo-router';
+import { type Href, Redirect, Stack, useFocusEffect } from 'expo-router';
 import { RefreshCw, Send, Sparkles } from 'lucide-react-native';
 import React, { useCallback, useMemo, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import { Platform } from 'react-native';
 
+import { copyToClipboard } from '@/components/chat/chat-utils';
+import { MessageActionsSheet } from '@/components/chat/message-actions-sheet';
 import { MessageBubble } from '@/components/chat/message-bubble';
 import { TypingDots } from '@/components/chat/typing-indicator';
+import { Actionsheet, ActionsheetBackdrop, ActionsheetContent, ActionsheetDragIndicator, ActionsheetDragIndicatorWrapper } from '@/components/ui/actionsheet';
 import { Box } from '@/components/ui/box';
+import { Button, ButtonText } from '@/components/ui/button';
 import { Center } from '@/components/ui/center';
 import { FlatList } from '@/components/ui/flat-list';
 import { FocusAwareStatusBar } from '@/components/ui/focus-aware-status-bar';
 import { HStack } from '@/components/ui/hstack';
 import { Input, InputField } from '@/components/ui/input';
 import { KeyboardAvoidingView } from '@/components/ui/keyboard-avoiding-view';
 import { Pressable } from '@/components/ui/pressable';
+import { Spinner } from '@/components/ui/spinner';
 import { Text } from '@/components/ui/text';
+import { Textarea, TextareaInput } from '@/components/ui/textarea';
 import { VStack } from '@/components/ui/vstack';
 import { type ChatMessageResultData } from '@/models/v4/chat';
 import useAuthStore from '@/stores/auth/store';
 import { useChatStore } from '@/stores/chat/store';
+import { useChatSystemStatus } from '@/stores/feature-flags/store';
+import { securityStore } from '@/stores/security/store';
+import { useToastStore } from '@/stores/toast/store';
 
 export default function ChatbotScreen() {
   const { t } = useTranslation();
+  const chatStatus = useChatSystemStatus();
+  const isChatEnabled = chatStatus === 'enabled';
   const currentUserId = useAuthStore((s) => s.userId);
   const chatbotChannelId = useChatStore((s) => s.chatbotChannelId);
   const chatbotTyping = useChatStore((s) => s.chatbotTyping);
   const messages = useChatStore((s) => (chatbotChannelId ? s.messagesByChannel[chatbotChannelId] : undefined));
+  const isModerator = !!securityStore((s) => s.rights)?.IsAdmin;
   const [text, setText] = useState('');
+  const [actionsMessage, setActionsMessage] = useState<ChatMessageResultData | null>(null);
+  const [editMessage, setEditMessage] = useState<ChatMessageResultData | null>(null);
+  const [editText, setEditText] = useState('');
 
   useFocusEffect(
     useCallback(() => {
+      if (!isChatEnabled) return;
       const store = useChatStore.getState();
       void store.initChatbot();
       return () => {
         useChatStore.getState().setActiveChannel(null);
       };
-    }, [])
+    }, [isChatEnabled])
   );
 
   // Keep the assistant channel active while viewing so incoming messages don't inflate unread.
   useFocusEffect(
     useCallback(() => {
+      if (!isChatEnabled) return;
       if (chatbotChannelId) useChatStore.getState().setActiveChannel(chatbotChannelId);
-    }, [chatbotChannelId])
+    }, [chatbotChannelId, isChatEnabled])
   );
 
   const inverted = useMemo(() => (messages ? messages.slice().reverse() : []), [messages]);
@@ -56,11 +73,27 @@
 
   const renderItem = useCallback(
     ({ item }: { item: ChatMessageResultData }) => (
-      <MessageBubble message={item} isOwn={!!item.SenderUserId && item.SenderUserId === currentUserId} showSender={false} currentUserId={currentUserId} onLongPress={() => undefined} onToggleReaction={() => undefined} />
+      <MessageBubble message={item} isOwn={!!item.SenderUserId && item.SenderUserId === currentUserId} showSender={false} currentUserId={currentUserId} onLongPress={setActionsMessage} onToggleReaction={() => undefined} />
     ),
     [currentUserId]
   );
 
+  // Chat.System flag not yet resolved: wait instead of redirecting away from a valid route.
+  if (chatStatus === 'unknown') {
+    return (
+      <Box className="size-full flex-1 items-center justify-center bg-background-0">
+        <Stack.Screen options={{ headerShown: false }} />
+        <FocusAwareStatusBar />
+        <Spinner />
+      </Box>
+    );
+  }
+
+  // Chat.System feature flag off: the assistant rides on the chat system, hide it too.
+  if (chatStatus === 'disabled') {
+    return <Redirect href={'/home' as Href} />;
+  }
+
   return (
     <Box className="size-full flex-1 bg-background-0">
       <Stack.Screen options={{ headerShown: false }} />
@@ -113,6 +146,57 @@
           </Pressable>
         </HStack>
       </KeyboardAvoidingView>
+
+      {/* Restricted actions for assistant messages: copy, edit own, pin (moderator), flag. */}
+      <MessageActionsSheet
+        message={actionsMessage}
+        isOpen={actionsMessage !== null}
+        onClose={() => setActionsMessage(null)}
+        isOwn={!!actionsMessage?.SenderUserId && actionsMessage.SenderUserId === currentUserId}
+        isModerator={isModerator}
+        assistant
+        onReact={() => undefined}
+        onReply={() => undefined}
+        onCopy={async (m) => {
+          const ok = await copyToClipboard(m.Body ?? '');
+          useToastStore.getState().showToast(ok ? 'success' : 'info', ok ? t('chat.copied') : t('chat.copy_unavailable'));
+        }}
+        onEdit={(m) => {
+          setEditMessage(m);
+          setEditText(m.Body ?? '');
+        }}
+        onDelete={() => undefined}
+        onFlag={(m, reason) => useChatStore.getState().flagMessage(m.ChatMessageId, reason)}
+        onTogglePin={(m, pinned) => chatbotChannelId && useChatStore.getState().togglePin(m.ChatMessageId, chatbotChannelId, pinned)}
+        onModeratorDelete={() => undefined}
+      />
+
+      {/* Edit own message */}
+      <Actionsheet isOpen={editMessage !== null} onClose={() => setEditMessage(null)}>
+        <ActionsheetBackdrop />
+        <ActionsheetContent>
+          <ActionsheetDragIndicatorWrapper>
+            <ActionsheetDragIndicator />
+          </ActionsheetDragIndicatorWrapper>
+          <VStack className="w-full p-2" space="md">
+            <Text className="text-base font-semibold text-typography-900">{t('chat.edit_message')}</Text>
+            <Textarea>
+              <TextareaInput value={editText} onChangeText={setEditText} multiline />
+            </Textarea>
+            <Button
+              className="bg-primary-600"
+              onPress={() => {
+                if (editMessage && chatbotChannelId && editText.trim()) {
+                  void useChatStore.getState().editMessage(editMessage.ChatMessageId, chatbotChannelId, editText.trim());
+                }
+                setEditMessage(null);
+              }}
+            >
+              <ButtonText>{t('chat.save')}</ButtonText>
+            </Button>
+          </VStack>
+        </ActionsheetContent>
+      </Actionsheet>
     </Box>
   );
 }