@droppii-org/chat-mobile 0.2.23 → 0.2.25

package/src/hooks/useChatMessages.ts

@@ -11,6 +11,8 @@ import {
   mergeMessages,
 } from '../utils/message';
 import { useMessageStore } from '../store/message';
+import { useUserStore } from '../store/user';
+import { useChatContext } from '../context';
 
 type UseChatMessagesOptions = {
   conversationId: string;
@@ -30,7 +32,11 @@ export function useChatMessages({
   const pushNewMessage = useMessageStore((s) => s.pushNewMessage);
   const reset = useMessageStore((s) => s.reset);
 
-  const [currentUserId, setCurrentUserId] = useState<string>();
+  const { applicationType } = useChatContext();
+  const cachedUserId = useUserStore((s) => s.user?.userID);
+  const [currentUserId, setCurrentUserId] = useState<string | undefined>(
+    cachedUserId
+  );
   const [isLoading, setIsLoading] = useState(false);
   const [isLoadingEarlier, setIsLoadingEarlier] = useState(false);
   const [isLoadingNewer, setIsLoadingNewer] = useState(false);
@@ -46,27 +52,60 @@ export function useChatMessages({
     setError(null);
 
     try {
-      const [history, userId] = await Promise.all([
+      // Fetch userId and history independently so an offline SDK state
+      // doesn't block reading local SQLite history.
+      const [historyResult, userIdResult] = await Promise.allSettled([
         ChatMessageAPI.fetchHistoryMessages(conversationId, {
           count: pageSize,
+          applicationType,
         }),
         ChatMessageAPI.getCurrentUserId(),
       ]);
 
-      const initialMessages = history.messageList as DMessageItem[];
-
-      setCurrentUserId(userId);
-      setMessages(mergeMessages([], initialMessages), !history.isEnd);
+      if (userIdResult.status === 'fulfilled') {
+        setCurrentUserId(userIdResult.value);
+      }
 
-      ChatMessageAPI.markConversationAsRead(conversationId).catch(
-        () => undefined
-      );
+      if (historyResult.status === 'fulfilled') {
+        const initialMessages = historyResult.value
+          .messageList as DMessageItem[];
+        setMessages(
+          mergeMessages([], initialMessages),
+          !historyResult.value.isEnd
+        );
+        ChatMessageAPI.markConversationAsRead(conversationId).catch(
+          () => undefined
+        );
+      } else {
+        // Fallback: try searchLocalMessages to verify local SQLite is accessible offline
+        console.warn(
+          '[useChatMessages] getAdvancedHistoryMessageList failed, trying searchLocalMessages fallback:',
+          historyResult.reason
+        );
+        const localResult = await ChatMessageAPI.searchLocalMessages(
+          conversationId,
+          { count: pageSize }
+        );
+        const localMessages = (localResult?.searchResultItems ?? []).flatMap(
+          (item: any) => item.messageList ?? []
+        ) as DMessageItem[];
+        console.log(
+          '[useChatMessages] searchLocalMessages fallback result:',
+          localMessages.length,
+          'messages'
+        );
+        if (localMessages.length > 0) {
+          setMessages(mergeMessages([], localMessages), false);
+        } else {
+          throw historyResult.reason;
+        }
+      }
     } catch (err) {
       setError(err instanceof Error ? err : new Error(String(err)));
     } finally {
       setIsLoading(false);
     }
-  }, [conversationId, pageSize, setMessages]);
+  }, [applicationType, conversationId, pageSize, setMessages]);
 
   const onLoadEarlier = useCallback(async () => {
     if (isLoadingEarlier || !hasMoreEarlier || !messages.length) return;
@@ -148,6 +187,11 @@ export function useChatMessages({
 
   const appendIncomingMessages = useCallback(
     (incoming: MessageItem[]) => {
+      console.log('[Listener] OnRecvNewMessages', {
+        total: incoming.length,
+        conversationId: conversationIdRef.current,
+        clientMsgIDs: incoming.map((m) => m.clientMsgID),
+      });
       const relevant = incoming.filter((message) =>
         belongsToConversation(message, conversationIdRef.current)
       );

package/src/hooks/useFileAttachment.ts

@@ -1,7 +1,7 @@
 import { useCallback, useState } from 'react';
 import { ImageUploadAPI } from '../services/imageUpload';
 import DeviceUtils from '../utils/device';
-import UIUtils from '../utils/ui';
+import { UIUtils } from '../utils/UIUtils';
 import { trans } from '../translation';
 import { MAX_FILE_SIZE } from '../services/attachmentHandlers';
 

package/src/hooks/useFileDownload.ts

@@ -2,7 +2,7 @@ import { useCallback, useEffect, useRef, useState } from 'react';
 import { Platform, Share } from 'react-native';
 import RNFS from 'react-native-fs';
 import FileViewer from 'react-native-file-viewer';
-import UIUtils from '../utils/ui';
+import { UIUtils } from '../utils/UIUtils';
 import { trans } from '../translation';
 
 export type DownloadStatus = 'idle' | 'downloading' | 'done' | 'error';

package/src/hooks/useImageAttachment.ts

@@ -1,11 +1,16 @@
 import { useCallback, useState } from 'react';
-import type { Image as PickedImage } from 'react-native-image-crop-picker';
+import type {
+  ImageOrVideo as PickedImage,
+  Video as PickedVideo,
+} from 'react-native-image-crop-picker';
 import DeviceUtils from '../utils/device';
-import UIUtils from '../utils/ui';
+import { UIUtils } from '../utils/UIUtils';
 import { trans } from '../translation';
 import { getMimeType, isVideoFromPicker } from '../utils/imageUtils';
+import { UPLOAD_CONCURRENCY, UPLOAD_LIMITS } from '../config/uploadLimits';
 import { ImageUploadAPI } from '../services/imageUpload';
 import VideoThumbnailUtil from '../utils/videoThumbnail';
+import { pLimit } from '../utils/pLimit';
 
 export interface ImageWithUploadStatus {
   image: PickedImage;
@@ -20,7 +25,7 @@ export interface ImageWithUploadStatus {
 export interface UseImageAttachmentReturn {
   selectedImages: ImageWithUploadStatus[];
   isImagePreviewVisible: boolean;
-  handleImageAttach: () => Promise<void>;
+  handleImageAttach: (multipleMode?: boolean) => Promise<void>;
   handleImageRemove: (index: number) => void;
   clearAllImages: () => void;
 }
@@ -46,81 +51,49 @@ export const useImageAttachment = (): UseImageAttachmentReturn => {
 
   const uploadImage = useCallback(
     async (index: number, image: PickedImage) => {
-      console.log('Upload', 'Step 1: Starting upload for image', { index });
-
-      try {
-        console.log('Upload', 'Step 2: Updating status to uploading...');
-        updateImageStatus(index, {
-          isUploading: true,
-          error: null,
-          uploadProgress: 0,
-        });
-
-        // ✅ OPTIMIZED: Use original path directly, no copy
-        const filePath = image.path.startsWith('file://')
-          ? image.path.replace('file://', '')
-          : image.path;
+      updateImageStatus(index, {
+        isUploading: true,
+        error: null,
+        uploadProgress: 0,
+      });
 
-        const filename = image.filename || 'image.jpg';
+      const filePath = image.path.startsWith('file://')
+        ? image.path.replace('file://', '')
+        : image.path;
 
-        const setProgress = (progress: number) => {
-          try {
-            console.log('Upload', 'Progress', { percentage: progress });
-            updateImageStatus(index, { uploadProgress: progress });
-          } catch (err) {
-            console.error('Upload', 'Progress update error', err);
-          }
-        };
+      const filename = image.filename || 'image.jpg';
 
-        let uploadedImage;
-        try {
-          console.log('Upload', 'Uploading to server...', {
+      try {
+        const uploadedImage = await ImageUploadAPI.uploadImageFile(
+          {
+            path: filePath,
             filename,
-            size: image.size,
-            filePath,
-          });
-          uploadedImage = await ImageUploadAPI.uploadImageFile(
-            {
-              path: filePath,
-              filename,
-              size: image.size || 0,
-              width: image.width || 0,
-              height: image.height || 0,
-              mime: getMimeType(filename),
-            },
-            setProgress
-          );
-          console.log('Upload', 'Upload successful!', {
-            url: uploadedImage?.url,
-          });
-        } catch (uploadError: any) {
-          console.error('Upload', 'Server upload error', uploadError);
-          throw new Error(
-            `Upload failed: ${uploadError?.message || 'Unknown error'}`
-          );
-        }
+            size: image.size || 0,
+            width: image.width || 0,
+            height: image.height || 0,
+            mime: getMimeType(filename),
+          },
+          (progress) => updateImageStatus(index, { uploadProgress: progress })
+        );
 
-        if (!uploadedImage?.url) {
-          throw new Error('No URL returned from server');
-        }
+        if (!uploadedImage?.url) throw new Error('No URL returned from server');
 
-        console.log('Upload', 'Upload complete, updating status...');
         updateImageStatus(index, {
           isUploading: false,
           uploadProgress: 100,
           uploadedUrl: uploadedImage.url,
         });
-
-        console.log('Upload', 'COMPLETE ✓');
-      } catch (error: any) {
-        console.error('Upload', 'ERROR', error);
-        const errorMsg = error?.message || trans('chat:image_upload_failed');
-        updateImageStatus(index, {
-          isUploading: false,
-          error: errorMsg,
+      } catch (error: unknown) {
+        const msg =
+          error instanceof Error
+            ? error?.message
+            : trans('chat:image_upload_failed');
+        updateImageStatus(index, { isUploading: false, error: msg });
+        UIUtils.toast.open({
+          title: trans('chat:image_upload_failed'),
+          message: trans('chat:generic_error'),
+          theme: 'danger',
         });
-
-        console.error('uploadImage', 'Full error', error);
       }
     },
     [updateImageStatus]
@@ -128,55 +101,36 @@ export const useImageAttachment = (): UseImageAttachmentReturn => {
 
   const generateVideoThumbnail = useCallback(
     async (index: number, image: PickedImage) => {
-      if (!isVideoFromPicker(image)) return; // Only for videos
-      console.log('[ImageAttach] Generating thumbnail for video:', image);
+      if (!isVideoFromPicker(image)) return;
 
-      try {
-        let videoDuration = (image as any).duration || 0;
+      const video = image as PickedVideo;
+      let videoDuration =
+        typeof video.duration === 'number' ? video.duration : 0;
 
-        // ✅ FIX: Validate duration is reasonable
-        if (videoDuration <= 0 || videoDuration > 3600000) {
-          // Duration should be between 0 and 1 hour (3600000ms)
-          console.warn(
-            '[ImageAttach] Invalid duration, using default:',
-            videoDuration
-          );
-          videoDuration = 5000; // Default 5 seconds
-        }
-
-        // ✅ FIX: Choose frame at 35% for better representation
-        const timeMs = Math.min(
-          Math.max(1000, Math.floor(videoDuration * 0.35)),
-          videoDuration - 1000
-        );
-
-        // ✅ OPTIMIZED: Use original path directly, no copy
-        const videoPath = image.path.startsWith('file://')
-          ? image.path.replace('file://', '')
-          : image.path;
-
-        console.log('[ImageAttach] Generating thumbnail for video:', {
-          filename: image.filename,
-          videoPath,
-          videoDuration,
-          timeMs,
-        });
+      if (videoDuration <= 0 || videoDuration > 3600000) {
+        videoDuration = 5000;
+      }
 
-        // Generate thumbnail directly from original path
-        console.log('[ImageAttach] Generating thumbnail at timeMs:', timeMs);
-        const thumbnail = await VideoThumbnailUtil.generateThumbnail(
-          videoPath,
-          {
-            time: timeMs,
-            quality: 80,
-            cacheId: `thumb-${index}-${Date.now()}`,
-          }
-        );
+      // Clamp to avoid negative timeMs on short clips.
+      const timeMs = Math.min(
+        Math.max(1000, Math.floor(videoDuration * 0.35)),
+        Math.max(0, videoDuration - 1000)
+      );
+
+      // Pass image.path directly — VideoThumbnailUtil owns path normalization
+      // (Android requires file:// to be preserved; stripping it causes a crash).
+      const baseName =
+        image.filename?.replace(/\.[^.]+$/, '') || `video-${index}`;
+
+      const thumbnail = await VideoThumbnailUtil.generateThumbnail(image.path, {
+        time: timeMs,
+        quality: 80,
+        cacheId: `thumb-${baseName}-${Date.now()}`,
+      });
 
-        if (!thumbnail) throw new Error('Thumbnail generation failed');
+      if (!thumbnail) return;
 
-        // Upload thumbnail (force .jpg extension for image file)
-        const baseName = image.filename?.split('.')[0] || 'video';
+      try {
         const uploadedThumbnail = await ImageUploadAPI.uploadImageFile(
           {
             path: thumbnail.path,
@@ -186,34 +140,22 @@ export const useImageAttachment = (): UseImageAttachmentReturn => {
             height: thumbnail.height || 180,
             mime: 'image/jpeg',
           },
-          (progress) => {
-            console.log('[ImageAttach] Thumbnail upload progress:', {
-              index,
-              percentage: progress,
-            });
-          }
+          () => {}
         );
 
-        if (!uploadedThumbnail?.url) {
-          throw new Error('No thumbnail URL returned');
+        if (uploadedThumbnail?.url) {
+          updateImageStatus(index, {
+            thumbnailUrl: uploadedThumbnail.url,
+            thumbnailSize: uploadedThumbnail.size || 0,
+          });
         }
-
-        // Update state with thumbnail
-        updateImageStatus(index, {
-          thumbnailUrl: uploadedThumbnail.url,
-          thumbnailSize: uploadedThumbnail.size || 0,
-        });
-
-        console.log(
-          `✅ [ImageAttach] THUMBNAIL URL (picked): ${uploadedThumbnail.url}`
-        );
-      } catch (error) {
-        console.error('[ImageAttach] Video thumbnail generation error:', error);
-        UIUtils.toast.open({
-          title: 'Thumbnail Error',
-          message: `Failed to generate thumbnail for ${image.filename}`,
-          theme: 'danger',
-        });
+      } catch (error: unknown) {
+        // Thumbnail failure is non-fatal — video still sends without preview.
+        if (__DEV__) {
+          console.warn('[ImageAttach] Thumbnail upload failed:', error);
+        }
+      } finally {
+        VideoThumbnailUtil.cleanupThumbnail(thumbnail.path).catch(() => {});
       }
     },
     [updateImageStatus]
@@ -221,89 +163,68 @@ export const useImageAttachment = (): UseImageAttachmentReturn => {
 
   const handleImageAttach = useCallback(
     async (multipleMode: boolean = true) => {
-      console.log('ImageAttach', 'Step 1: User tapped attachment button', {
-        multipleMode,
-      });
       try {
-        console.log('ImageAttach', 'Step 2: Opening image picker...');
         const images = await DeviceUtils.openImagePicker(multipleMode);
+        if (!images || images.length === 0) return;
 
-        if (!images || images.length === 0) {
-          console.log('ImageAttach', 'Step 3: User cancelled picker');
-          return;
-        }
-
-        console.log('ImageAttach', 'Step 4: Images picked', {
-          count: images.length,
-        });
-
-        // The gallery picker can return both images and videos. Apply the
-        // correct size limit per type: 5MB for images, 200MB for videos.
-        const MAX_IMAGE_SIZE = 5 * 1024 * 1024;
-        const MAX_VIDEO_SIZE = 200 * 1024 * 1024;
         const isWithinLimit = (item: PickedImage) => {
           const maxSize = isVideoFromPicker(item)
-            ? MAX_VIDEO_SIZE
-            : MAX_IMAGE_SIZE;
+            ? UPLOAD_LIMITS.video
+            : UPLOAD_LIMITS.image;
           return (item.size || 0) <= maxSize;
         };
 
         const oversizedItems = images.filter((img) => !isWithinLimit(img));
-
         if (oversizedItems.length > 0) {
-          const hasOversizedVideo = oversizedItems.some(isVideoFromPicker);
-          console.warn('ImageAttach', 'Step 5: Some files too large', {
-            count: oversizedItems.length,
-          });
+          const isVideo = oversizedItems.some(isVideoFromPicker);
+          const maxSize = Math.floor(
+            (isVideo ? UPLOAD_LIMITS.video : UPLOAD_LIMITS.image) / 1024 / 1024
+          );
           UIUtils.toast.open({
             title: trans(
-              hasOversizedVideo
-                ? 'chat:video_too_large'
-                : 'chat:image_too_large'
+              isVideo ? 'chat:video_too_large' : 'chat:image_too_large',
+              { maxSize: String(maxSize) }
             ),
             theme: 'danger',
           });
-          const validImages = images.filter(isWithinLimit);
-          if (validImages.length === 0) return;
-          images.splice(0, images.length, ...validImages);
         }
 
-        console.log('ImageAttach', 'Step 6: Size validation passed');
-        const startIndex = selectedImages.length;
-
-        console.log('ImageAttach', 'Step 7: Adding to preview list', {
-          count: images.length,
-          startIndex,
+        const finalImages = images.filter(isWithinLimit);
+        if (finalImages.length === 0) return;
+
+        // Derive startIndex inside the updater so concurrent calls don't
+        // produce the same index when state hasn't committed yet.
+        let startIndex = 0;
+        setSelectedImages((prev) => {
+          startIndex = prev.length;
+          return [
+            ...prev,
+            ...finalImages.map((image) => ({
+              image,
+              uploadProgress: 0,
+              error: null,
+              isUploading: true,
+            })),
+          ];
         });
-
-        setSelectedImages((prev) => [
-          ...prev,
-          ...images.map((image) => ({
-            image,
-            uploadProgress: 0,
-            error: null,
-            isUploading: true,
-          })),
-        ]);
         setIsImagePreviewVisible(true);
 
-        // Generate thumbnails for videos (parallel)
-        console.log(
-          'ImageAttach',
-          'Step 7.5: Generating thumbnails for videos...'
-        );
-        await Promise.all(
-          images.map((image, offset) =>
-            generateVideoThumbnail(startIndex + offset, image)
-          )
-        );
-
-        console.log('ImageAttach', 'Step 8: Starting uploads...');
-        await Promise.all(
-          images.map((image, offset) => uploadImage(startIndex + offset, image))
-        );
-      } catch (error) {
-        console.error('ImageAttach', 'ERROR', error);
+        // Thumbnail generation and upload run concurrently per-item,
+        // both limited to UPLOAD_CONCURRENCY to avoid OOM on low-end devices.
+        await Promise.all([
+          pLimit(
+            finalImages,
+            (image, offset) =>
+              generateVideoThumbnail(startIndex + offset, image),
+            UPLOAD_CONCURRENCY
+          ),
+          pLimit(
+            finalImages,
+            (image, offset) => uploadImage(startIndex + offset, image),
+            UPLOAD_CONCURRENCY
+          ),
+        ]);
+      } catch (error: unknown) {
         UIUtils.toast.open({
           title: trans('chat:image_pick_failed'),
           message: error instanceof Error ? error.message : 'Unknown error',
@@ -311,7 +232,7 @@ export const useImageAttachment = (): UseImageAttachmentReturn => {
         });
       }
     },
-    [selectedImages.length, uploadImage, generateVideoThumbnail]
+    [uploadImage, generateVideoThumbnail]
   );
 
   const handleImageRemove = useCallback((index: number) => {

package/src/hooks/useSendAttachment.ts

@@ -56,8 +56,7 @@ export interface UseSendAttachmentReturn {
   error: string | null;
   send(
     items: AttachmentItem[],
-    options?: Partial<AttachmentSendOptions>,
-    onMessageSent?: (message: any) => void
+    options?: Partial<AttachmentSendOptions>
   ): Promise<boolean>;
   clearError(): void;
 }
@@ -75,8 +74,7 @@ export function useSendAttachment(): UseSendAttachmentReturn {
   const send = useCallback(
     async (
       items: AttachmentItem[],
-      options?: Partial<AttachmentSendOptions>,
-      onMessageSent?: (message: any) => void
+      options?: Partial<AttachmentSendOptions>
     ): Promise<boolean> => {
       console.log('[useSendAttachment] Start sending', {
         totalItems: items.length,
@@ -245,8 +243,7 @@ export function useSendAttachment(): UseSendAttachmentReturn {
             {
               strategy: 'individual',
               ...options,
-            },
-            onMessageSent
+            }
           );
 
         console.log('[useSendAttachment] Send result:', {

package/src/index.tsx

@@ -50,9 +50,7 @@ export type {
   ChatQuickActionsRenderParams,
   ChatAttachmentPanelProps,
 } from './screens/chat-detail';
-export type { DGiftedChatMessage } from './utils/giftedChatMessage';
-export {
-  mapOpenIMMessageToGiftedChat,
-  mapOpenIMMessagesToGiftedChat,
-} from './utils/giftedChatMessage';
+
 export type { PeerType } from '@droppii/openim-rn-client-sdk';
+
+export { registerUIUtils, UIUtils } from './utils/UIUtils';