RU-T46 PR#198 fixes

Author: ucswift

src/api/calls/calls.ts

@@ -1,3 +1,4 @@
+import { cacheManager } from '@/lib/cache/cache-manager';
 import { type ActiveCallsResult } from '@/models/v4/calls/activeCallsResult';
 import { type CallExtraDataResult } from '@/models/v4/calls/callExtraDataResult';
 import { type CallResult } from '@/models/v4/calls/callResult';
@@ -126,6 +127,15 @@ export const createCall = async (callData: CreateCallRequest) => {
   };
 
   const response = await createCallApi.post<SaveCallResult>(data);
+  
+  // Invalidate cache after successful mutation
+  try {
+    cacheManager.remove('/Calls/GetActiveCalls');
+  } catch (error) {
+    // Silently handle cache removal errors
+    console.warn('Failed to invalidate calls cache:', error);
+  }
+  
   return response.data;
 };
 
@@ -174,6 +184,15 @@ export const updateCall = async (callData: UpdateCallRequest) => {
   };
 
   const response = await updateCallApi.post<SaveCallResult>(data);
+  
+  // Invalidate cache after successful mutation
+  try {
+    cacheManager.remove('/Calls/GetActiveCalls');
+  } catch (error) {
+    // Silently handle cache removal errors
+    console.warn('Failed to invalidate calls cache:', error);
+  }
+  
   return response.data;
 };
 
@@ -185,5 +204,14 @@ export const closeCall = async (callData: CloseCallRequest) => {
   };
 
   const response = await closeCallApi.put<SaveCallResult>(data);
+  
+  // Invalidate cache after successful mutation
+  try {
+    cacheManager.remove('/Calls/GetActiveCalls');
+  } catch (error) {
+    // Silently handle cache removal errors
+    console.warn('Failed to invalidate calls cache:', error);
+  }
+  
   return response.data;
 };

src/components/maps/full-screen-location-picker.tsx

@@ -62,7 +62,7 @@ const FullScreenLocationPicker: React.FC<FullScreenLocationPickerProps> = ({ ini
 
       if (result && result.length > 0) {
         const { street, name, city, region, country, postalCode } = result[0];
-        let addressParts = [];
+        const addressParts: string[] = [];
 
         if (street) addressParts.push(street);
         if (name && name !== street) addressParts.push(name);
@@ -150,7 +150,7 @@ const FullScreenLocationPicker: React.FC<FullScreenLocationPickerProps> = ({ ini
     };
   }, [initialLocation, getUserLocation, reverseGeocode]);
 
-  const handleMapPress = (event: any) => {
+  const handleMapPress = (event: GeoJSON.Feature) => {
     const { coordinates } = event.geometry;
     const newLocation = {
       latitude: coordinates[1],
@@ -193,7 +193,7 @@ const FullScreenLocationPicker: React.FC<FullScreenLocationPickerProps> = ({ ini
 
       {/* Location info and confirm button */}
       <Box style={[styles.bottomPanel, { paddingBottom: insets.bottom + 16 }]} className="bg-white p-4 shadow-lg">
-        {!hasUserLocation && <Text className="mb-2 text-center text-amber-600">{t('common.tap_map_to_select')}</Text>}
+        {!hasUserLocation ? <Text className="mb-2 text-center text-amber-600">{t('common.tap_map_to_select')}</Text> : null}
         {isReverseGeocoding ? (
           <Text className="mb-2 text-gray-500">{t('common.loading_address')}</Text>
         ) : address ? (

src/components/maps/location-picker.tsx

@@ -55,9 +55,10 @@ const LocationPicker: React.FC<LocationPickerProps> = ({ initialLocation, onLoca
         return;
       }
 
-      // Create a timeout promise
+      // Create a timeout promise with cleanup
+      let timeoutId: NodeJS.Timeout;
       const timeoutPromise = new Promise<never>((_, reject) => {
-        setTimeout(() => reject(new Error('Location timeout')), LOCATION_TIMEOUT);
+        timeoutId = setTimeout(() => reject(new Error('Location timeout')), LOCATION_TIMEOUT);
       });
 
       // Race between getting location and timeout
@@ -68,6 +69,9 @@ const LocationPicker: React.FC<LocationPickerProps> = ({ initialLocation, onLoca
         timeoutPromise,
       ]);
 
+      // Clear timeout if location resolved first
+      clearTimeout(timeoutId);
+
       if (!isMountedRef.current) return;
 
       const newLocation = {

src/services/callkeep.service.android.ts

@@ -0,0 +1,77 @@
+import { logger } from '../lib/logging';
+
+export interface CallKeepConfig {
+  appName: string;
+  maximumCallGroups: number;
+  maximumCallsPerCallGroup: number;
+  includesCallsInRecents: boolean;
+  supportsVideo: boolean;
+  ringtoneSound?: string;
+}
+
+/**
+ * No-op implementation of CallKeepService for Android
+ * CallKeep functionality is only supported on iOS
+ */
+export class CallKeepService {
+  private static instance: CallKeepService | null = null;
+
+  private constructor() {}
+
+  static getInstance(): CallKeepService {
+    if (!CallKeepService.instance) {
+      CallKeepService.instance = new CallKeepService();
+    }
+    return CallKeepService.instance;
+  }
+
+  async setup(_config: CallKeepConfig): Promise<void> {
+    logger.debug({
+      message: 'CallKeep setup skipped - not supported on Android',
+    });
+  }
+
+  async startCall(_displayName: string): Promise<string> {
+    logger.debug({
+      message: 'CallKeep startCall skipped - not supported on Android',
+    });
+    return '';
+  }
+
+  async endCall(): Promise<void> {
+    logger.debug({
+      message: 'CallKeep endCall skipped - not supported on Android',
+    });
+  }
+
+  async setMuted(_muted: boolean): Promise<void> {
+    logger.debug({
+      message: 'CallKeep setMuted skipped - not supported on Android',
+    });
+  }
+
+  setMuteStateCallback(_callback: (muted: boolean) => void | null): void {
+    logger.debug({
+      message: 'CallKeep setMuteStateCallback skipped - not supported on Android',
+    });
+  }
+
+  async updateCallDisplay(_displayName: string): Promise<void> {
+    logger.debug({
+      message: 'CallKeep updateCallDisplay skipped - not supported on Android',
+    });
+  }
+
+  isCallActive(): boolean {
+    return false;
+  }
+
+  async cleanup(): Promise<void> {
+    logger.debug({
+      message: 'CallKeep cleanup skipped - not supported on Android',
+    });
+  }
+}
+
+// Export singleton instance
+export const callKeepService = CallKeepService.getInstance();

src/stores/app/livekit-store.ts

@@ -8,7 +8,7 @@ import { getCanConnectToVoiceSession, getDepartmentVoiceSettings } from '../../a
 import { logger } from '../../lib/logging';
 import { type DepartmentVoiceChannelResultData } from '../../models/v4/voice/departmentVoiceResultData';
 import { audioService } from '../../services/audio.service';
-import { callKeepService } from '../../services/callkeep.service.ios';
+import { callKeepService } from '../../services/callkeep.service';
 import { useBluetoothAudioStore } from './bluetooth-audio-store';
 
 // Helper function to setup audio routing based on selected devices

src/stores/calls/store.ts

@@ -13,6 +13,7 @@ interface CallsState {
   callTypes: CallTypeResultData[];
   isLoading: boolean;
   error: string | null;
+  lastFetchedAt: number;
   fetchCalls: () => Promise<void>;
   fetchCallPriorities: () => Promise<void>;
   fetchCallTypes: () => Promise<void>;
@@ -25,6 +26,7 @@ export const useCallsStore = create<CallsState>((set, get) => ({
   callTypes: [],
   isLoading: false,
   error: null,
+  lastFetchedAt: 0,
   init: async () => {
     set({ isLoading: true, error: null });
     const callsResponse = await getCalls();
@@ -35,13 +37,14 @@ export const useCallsStore = create<CallsState>((set, get) => ({
       callPriorities: callPrioritiesResponse.Data,
       callTypes: callTypesResponse.Data,
       isLoading: false,
+      lastFetchedAt: Date.now(),
     });
   },
   fetchCalls: async () => {
     set({ isLoading: true, error: null });
     try {
       const response = await getCalls();
-      set({ calls: response.Data, isLoading: false });
+      set({ calls: response.Data, isLoading: false, lastFetchedAt: Date.now() });
     } catch (error) {
       set({ error: 'Failed to fetch calls', isLoading: false });
     }

src/stores/status/store.ts

@@ -22,6 +22,9 @@ type DestinationType = 'none' | 'call' | 'station';
 // Status type that can accept both custom statuses and regular statuses
 type StatusType = CustomStatusResultData | StatusesResultData;
 
+// Store TTL: 5 minutes in milliseconds
+const STORE_TTL_MS = 5 * 60 * 1000;
+
 interface StatusBottomSheetStore {
   isOpen: boolean;
   currentStep: StatusStep;
@@ -77,21 +80,24 @@ export const useStatusBottomSheetStore = create<StatusBottomSheetStore>((set, ge
   fetchDestinationData: async (unitId: string) => {
     set({ isLoading: true, error: null });
     try {
-      // Check if we already have calls in the calls store to avoid redundant API calls
+      // Check if we already have calls in the calls store and if they're still fresh
       const callsStore = useCallsStore.getState();
       const existingCalls = callsStore.calls;
+      const lastFetchedAt = callsStore.lastFetchedAt || 0;
+      const isStale = !lastFetchedAt || Date.now() - lastFetchedAt > STORE_TTL_MS;
 
-      // Only fetch calls if we don't have any in the store
+      // Fetch calls if we don't have any or if they're stale
       // Groups are cached (2 day TTL) so getAllGroups is already fast
-      const needsCallsFetch = existingCalls.length === 0;
+      const needsCallsFetch = existingCalls.length === 0 || isStale;
 
       if (needsCallsFetch) {
         // Fetch calls and groups in parallel
         const [callsResponse, groupsResponse] = await Promise.all([getCalls(), getAllGroups()]);
 
-        // Also update the calls store so other parts of the app benefit
-        useCallsStore.setState({ calls: callsResponse.Data || [] });
+        // Update the calls store with fresh data and timestamp
+        useCallsStore.setState({ calls: callsResponse.Data || [], lastFetchedAt: Date.now() });
 
+        // Set availableCalls from the fresh response
         set({
           availableCalls: callsResponse.Data || [],
           availableStations: groupsResponse.Data || [],