@droppii-org/chat-mobile 0.2.6 → 0.2.8

package/src/screens/chat-detail/legend/messageTypes.tsx

@@ -0,0 +1,13 @@
+/**
+ * Message type components - re-exports from components/messages
+ * Stateless message components live in components/messages
+ */
+
+export type { BaseLegendMessageProps } from '../../../components/messages/types';
+export { formatMessageTime } from '../../../components/messages/types';
+export { TextMessage } from '../../../components/messages/textMessage';
+export { ImageMessage } from '../../../components/messages/imageMessage';
+export { VideoMessage } from '../../../components/messages/videoMessage';
+export { FileMessage } from '../../../components/messages/fileMessage';
+export { MergedMessage } from '../../../components/messages/mergedMessage';
+export { messageStyles } from '../../../components/messages/styles';

package/src/screens/chat-detail/types.ts

@@ -1,6 +1,9 @@
 import type { ReactNode } from 'react';
-import type { DChatType, DChatCategory } from '../../types/chat';
+
+import type { MediaItem } from '../../hooks/useMediaViewer';
 import type { DConversationItem, DMessageItem } from '../../types/chat';
+import type { IUrlMetadata } from '../../types/common';
+import type { PeerType } from '@droppii/openim-rn-client-sdk';
 
 export type DChatActionIconProvider = 'MaterialCommunityIcons' | 'DroppiiNew';
 
@@ -22,8 +25,7 @@ export interface ChatDetailHeaderProps {
   subtitle?: string;
   avatarUri?: string | null;
   avatarFullName?: string;
-  chatType?: DChatType;
-  chatCategory?: DChatCategory;
+  peerType?: PeerType;
   applicationType?: DConversationItem['applicationType'];
   showAddMember?: boolean;
   onBack?: () => void;
@@ -59,10 +61,11 @@ export interface ChatAttachmentPanelProps {
 export interface ChatComposerProps {
   value?: string;
   placeholder?: string;
-  onChangeText?: (text: string) => void;
-  onSend?: () => void;
+  onChangeText?: (text?: string) => void;
+  onSend?: (urlMetadata?: IUrlMetadata) => void;
   onPressAttach?: () => void;
   onPressEmoji?: () => void;
+  onMessageSent?: (message: DMessageItem) => void;
   showQuickActions?: boolean;
   quickActions?: DChatQuickAction[];
   attachmentActions?: DChatAttachmentAction[];
@@ -85,6 +88,7 @@ export interface ChatListProps {
   onLoadNewer?: () => void;
   isLoadingNewer?: boolean;
   hasMoreNewer?: boolean;
+  onMediaPress?: (items: MediaItem[], index?: number) => void;
 }
 
 export interface ChatDetailProps extends Omit<
@@ -93,8 +97,7 @@ export interface ChatDetailProps extends Omit<
   | 'subtitle'
   | 'avatarUri'
   | 'avatarFullName'
-  | 'chatType'
-  | 'chatCategory'
+  | 'peerType'
   | 'applicationType'
   | 'showAddMember'
 > {
@@ -104,8 +107,7 @@ export interface ChatDetailProps extends Omit<
   subtitle?: string;
   avatarUri?: string | null;
   avatarFullName?: string;
-  chatType?: DChatType;
-  chatCategory?: DChatCategory;
+  peerType?: PeerType;
   applicationType?: DConversationItem['applicationType'];
   showAddMember?: boolean;
   getSubtitle?: (conversation: DConversationItem) => string | undefined;

package/src/screens/inbox/MessagesTab.tsx

@@ -1,5 +1,5 @@
 import { memo, useCallback } from 'react';
-import { GestureResponderEvent, ActivityIndicator } from 'react-native';
+import { type GestureResponderEvent, ActivityIndicator } from 'react-native';
 import { KContainer, KDivider, KLabel, KColors } from '@droppii/libs';
 import { useConversationList } from '../../hooks/useConversationList';
 import { ThreadCard } from '../../components/ThreadCard';

package/src/services/attachmentHandlers/fileAttachmentHandler.ts

@@ -0,0 +1,78 @@
+import type { Attachment, FileAttachment } from '../../types/attachment';
+import type { IAttachmentHandler } from '../../types/attachmentHandler';
+
+interface FileElem {
+  uuid: string;
+  fileName: string;
+  fileSize: number;
+  fileType: string;
+  url: string;
+}
+
+export class FileAttachmentHandler implements IAttachmentHandler {
+  private static readonly MAX_FILE_SIZE = 200 * 1024 * 1024; // 200MB
+
+  validate(
+    attachment: Attachment
+  ): { valid: true } | { valid: false; reason: string } {
+    if (attachment.type !== 'file') {
+      return {
+        valid: false,
+        reason: 'Invalid attachment type for file handler',
+      };
+    }
+
+    const { sourceFile } = attachment;
+
+    if (!sourceFile.filename) {
+      return {
+        valid: false,
+        reason: 'File name is required',
+      };
+    }
+
+    if (!sourceFile.size) {
+      return {
+        valid: false,
+        reason: 'File size is required',
+      };
+    }
+
+    if (sourceFile.size > FileAttachmentHandler.MAX_FILE_SIZE) {
+      return {
+        valid: false,
+        reason: `File size exceeds maximum (${FileAttachmentHandler.MAX_FILE_SIZE / 1024 / 1024}MB)`,
+      };
+    }
+
+    return { valid: true };
+  }
+
+  async buildPayload(
+    attachment: Attachment,
+    uploadedUrl: string
+  ): Promise<FileElem> {
+    const file = attachment as FileAttachment;
+    const { sourceFile } = file;
+
+    const fileElem: FileElem = {
+      uuid: attachment.id,
+      fileName: sourceFile.filename,
+      fileSize: sourceFile.size,
+      fileType: sourceFile.mimeType,
+      url: uploadedUrl,
+    };
+
+    console.warn('[FileAttachmentHandler] Built payload', {
+      uuid: fileElem.uuid,
+      fileName: fileElem.fileName,
+      fileSize: fileElem.fileSize,
+      fileType: fileElem.fileType,
+      url: uploadedUrl.substring(0, 50) + '...',
+    });
+
+    return fileElem;
+  }
+}
+
+export default new FileAttachmentHandler();

package/src/services/attachmentHandlers/imageAttachmentHandler.ts

@@ -0,0 +1,54 @@
+import type { ImageAttachment } from '../../types/attachment';
+import type { IAttachmentHandler } from '../../types/attachmentHandler';
+import { generateUUID } from '../../utils/imageUtils';
+
+export const ImageAttachmentHandler: IAttachmentHandler = {
+  validate(attachment: ImageAttachment) {
+    const MAX_SIZE = 5 * 1024 * 1024;
+    if (attachment.sourceFile.size > MAX_SIZE) {
+      return { valid: false, reason: 'Image exceeds 5MB limit' };
+    }
+
+    const validMimes = ['image/jpeg', 'image/png', 'image/webp', 'image/jpg'];
+    if (!validMimes.includes(attachment.sourceFile.mimeType)) {
+      return {
+        valid: false,
+        reason: `Unsupported format: ${attachment.sourceFile.mimeType}`,
+      };
+    }
+
+    if (attachment.metadata.width <= 0 || attachment.metadata.height <= 0) {
+      return { valid: false, reason: 'Invalid image dimensions' };
+    }
+
+    return { valid: true };
+  },
+
+  async buildPayload(attachment: ImageAttachment, uploadedUrl: string) {
+    console.log('[ImageAttachmentHandler] Building payload for', {
+      filename: attachment.sourceFile.filename,
+      url: uploadedUrl,
+    });
+
+    const picInfo = {
+      uuid: generateUUID(),
+      type: attachment.sourceFile.mimeType,
+      size: attachment.sourceFile.size,
+      width: attachment.metadata.width,
+      height: attachment.metadata.height,
+      url: uploadedUrl,
+    };
+
+    const payload = {
+      sourcePicture: picInfo,
+      bigPicture: picInfo,
+      snapshotPicture: picInfo,
+    };
+
+    console.log('[ImageAttachmentHandler] Payload created for', {
+      fileName: attachment.sourceFile.filename,
+    });
+
+    return payload;
+  },
+};

package/src/services/attachmentHandlers/index.ts

@@ -0,0 +1,10 @@
+// Handlers are now dispatched directly in getAttachmentHandler without registry
+
+// Legacy export for backward compatibility
+export function initializeAttachmentHandlers(): void {
+  // No longer needed - handlers are dispatched directly
+}
+
+export { ImageAttachmentHandler } from './imageAttachmentHandler';
+export { default as VideoAttachmentHandler } from './videoAttachmentHandler';
+export { default as FileAttachmentHandler } from './fileAttachmentHandler';

package/src/services/attachmentHandlers/videoAttachmentHandler.ts

@@ -0,0 +1,114 @@
+import type { Attachment, VideoAttachment } from '../../types/attachment';
+import type { IAttachmentHandler } from '../../types/attachmentHandler';
+
+interface VideoPicInfo {
+  videoUUID: string;
+  videoType: string;
+  videoSize: number;
+  duration: number;
+  snapshotWidth: number;
+  snapshotHeight: number;
+  videoUrl: string;
+  videoPath: string;
+  snapshotPath: string;
+  snapshotUUID: string;
+  snapshotSize: number;
+  snapshotUrl: string;
+  snapShotType: string;
+}
+
+export class VideoAttachmentHandler implements IAttachmentHandler {
+  private static readonly MAX_VIDEO_SIZE = 100 * 1024 * 1024; // 100MB
+  private static readonly SUPPORTED_TYPES = ['video/mp4', 'video/quicktime'];
+
+  validate(
+    attachment: Attachment
+  ): { valid: true } | { valid: false; reason: string } {
+    if (attachment.type !== 'video') {
+      return {
+        valid: false,
+        reason: 'Invalid attachment type for video handler',
+      };
+    }
+
+    const { sourceFile } = attachment;
+
+    if (!sourceFile?.size) {
+      return {
+        valid: false,
+        reason: 'Video file size is required',
+      };
+    }
+
+    if (sourceFile.size > VideoAttachmentHandler.MAX_VIDEO_SIZE) {
+      return {
+        valid: false,
+        reason: `Video size exceeds maximum (${VideoAttachmentHandler.MAX_VIDEO_SIZE / 1024 / 1024}MB)`,
+      };
+    }
+
+    if (
+      sourceFile.mimeType &&
+      !VideoAttachmentHandler.SUPPORTED_TYPES.includes(sourceFile.mimeType)
+    ) {
+      return {
+        valid: false,
+        reason: 'Unsupported video format',
+      };
+    }
+
+    return { valid: true };
+  }
+
+  async buildPayload(
+    attachment: Attachment,
+    uploadedUrl: string
+  ): Promise<VideoPicInfo> {
+    const video = attachment as VideoAttachment;
+    const { sourceFile, metadata } = video;
+
+    // Use thumbnail URL if available, otherwise fall back to video URL
+    const snapshotUrl = metadata.thumbnail?.url || uploadedUrl;
+    const snapshotWidth = metadata.thumbnail?.width || metadata.width || 320;
+    const snapshotHeight = metadata.thumbnail?.height || metadata.height || 180;
+    const snapshotSize = metadata.thumbnail?.size || 0;
+
+    if (metadata.thumbnail?.url) {
+      console.log('✅ [VideoAttachmentHandler] Using thumbnail:', {
+        snapshotUrl: metadata.thumbnail.url,
+        snapshotWidth,
+        snapshotHeight,
+        snapshotSize,
+      });
+    }
+
+    const picInfo: VideoPicInfo = {
+      videoUUID: attachment.id,
+      videoType: sourceFile.mimeType || 'video/mp4',
+      videoSize: sourceFile.size,
+      duration: metadata.duration,
+      snapshotWidth: snapshotWidth,
+      snapshotHeight: snapshotHeight,
+      videoUrl: uploadedUrl,
+      videoPath: sourceFile.path,
+      snapshotPath: snapshotUrl,
+      snapshotUUID: `${attachment.id}-snapshot`,
+      snapshotSize: snapshotSize,
+      snapshotUrl: snapshotUrl,
+      snapShotType: 'image/jpeg',
+    };
+
+    console.warn('[VideoAttachmentHandler] Built payload', {
+      videoUUID: picInfo.videoUUID,
+      videoSize: picInfo.videoSize,
+      duration: picInfo.duration,
+      snapshotWidth: picInfo.snapshotWidth,
+      snapshotHeight: picInfo.snapshotHeight,
+      videoUrl: uploadedUrl.substring(0, 50) + '...',
+    });
+
+    return picInfo;
+  }
+}
+
+export default new VideoAttachmentHandler();

package/src/services/attachmentOrchestrator.ts

@@ -0,0 +1,300 @@
+import OpenIMSDK, { type MessageItem } from '@droppii/openim-rn-client-sdk';
+import type {
+  Attachment,
+  AttachmentSendOptions,
+  AttachmentSendResult,
+} from '../types/attachment';
+import { getAttachmentHandler } from '../types/attachmentHandler';
+import { useConversationStore } from '../store';
+import {
+  getAttachmentPriorityConfig,
+  type AttachmentType,
+} from '../config/attachment-priority';
+
+export namespace AttachmentOrchestratorService {
+  export async function sendPreparedAttachments(
+    attachments: Attachment[],
+    uploadedUrls: Record<string, string>,
+    options: AttachmentSendOptions = { strategy: 'individual' },
+    onMessageSent?: (message: any) => void
+  ): Promise<AttachmentSendResult> {
+    const result: AttachmentSendResult = {
+      success: false,
+      sentAttachmentIds: [],
+      failedAttachmentIds: [],
+      errors: {},
+    };
+
+    if (!attachments || attachments.length === 0) {
+      return result;
+    }
+
+    // 1. Validate all attachments
+    console.log('[AttachmentOrchestrator] Validating prepared attachments...');
+    for (const att of attachments) {
+      try {
+        const handler = getAttachmentHandler(att.type);
+        const validation = handler.validate(att);
+        if (!validation.valid) {
+          result.failedAttachmentIds.push(att.id);
+          result.errors[att.id] = (
+            validation as { valid: false; reason: string }
+          ).reason;
+        }
+      } catch (error) {
+        const msg =
+          error instanceof Error ? error.message : 'Validation failed';
+        result.failedAttachmentIds.push(att.id);
+        result.errors[att.id] = msg;
+      }
+    }
+
+    if (result.failedAttachmentIds.length === attachments.length) {
+      return result;
+    }
+
+    const validAttachments = attachments.filter(
+      (a) => !result.failedAttachmentIds.includes(a.id)
+    );
+
+    // 2. Build message payloads directly (no upload)
+    console.log(
+      '[AttachmentOrchestrator] Building message payloads for prepared attachments...'
+    );
+    const payloads: Array<{ attachmentId: string; payload: unknown }> = [];
+    for (const att of validAttachments) {
+      try {
+        const uploadedUrl = uploadedUrls[att.id];
+        if (!uploadedUrl) {
+          result.failedAttachmentIds.push(att.id);
+          result.errors[att.id] = 'No uploaded URL provided';
+          continue;
+        }
+
+        const handler = getAttachmentHandler(att.type);
+        const payload = await handler.buildPayload(att, uploadedUrl);
+        payloads.push({ attachmentId: att.id, payload });
+      } catch (error) {
+        const msg =
+          error instanceof Error ? error.message : 'Payload build failed';
+        result.failedAttachmentIds.push(att.id);
+        result.errors[att.id] = msg;
+      }
+    }
+
+    // 3. Send via OpenIM - always use createMergerMessage
+    console.log('[AttachmentOrchestrator] Sending via createMergerMessage', {
+      payloadCount: payloads.length,
+      attachmentIds: payloads.map((p) => p.attachmentId),
+    });
+    try {
+      const mergedMsgId = await sendMergedMessage(
+        payloads.map((p) => p.payload),
+        options.includeCaption,
+        onMessageSent
+      );
+      console.log('[AttachmentOrchestrator] Messages sent via merger:', {
+        messageId: mergedMsgId,
+        count: payloads.length,
+      });
+      result.sentAttachmentIds = payloads.map((p) => p.attachmentId);
+      result.mergedMessageId = mergedMsgId;
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : 'Send failed';
+      console.error('[AttachmentOrchestrator] OpenIM send error:', {
+        error: msg,
+        stack: error instanceof Error ? error.stack : undefined,
+      });
+      if (result.sentAttachmentIds.length === 0) {
+        result.errors._send = msg;
+      }
+    }
+
+    result.success = result.sentAttachmentIds.length > 0;
+    return result;
+  }
+
+  async function sendMergedMessage(
+    payloads: unknown[],
+    _caption?: string,
+    onMessageSent?: (message: any) => void
+  ): Promise<string> {
+    const currentConversation = useConversationStore
+      .getState()
+      .getCurrentConversation();
+
+    if (!currentConversation) {
+      throw new Error('No conversation selected');
+    }
+
+    // Get priority configuration
+    const priorityConfig = getAttachmentPriorityConfig();
+    console.log('[AttachmentOrchestrator] Using priority config:', {
+      enabled: priorityConfig.enabled,
+      order: priorityConfig.order,
+    });
+
+    // Categorize payloads by type
+    const categorizedPayloads: Record<AttachmentType, unknown[]> = {
+      image: [],
+      video: [],
+      file: [],
+      text: [],
+    };
+
+    for (const p of payloads) {
+      const payload = p as any;
+      // Detect type from payload properties
+      if (payload.duration !== undefined || payload.videoPath !== undefined) {
+        categorizedPayloads.video.push(p);
+      } else if (
+        payload.fileExtension !== undefined ||
+        (payload.fileName && payload.fileName.includes('.'))
+      ) {
+        categorizedPayloads.file.push(p);
+      } else if (payload.content && typeof payload.content === 'string') {
+        categorizedPayloads.text.push(p);
+      } else {
+        categorizedPayloads.image.push(p);
+      }
+    }
+
+    console.log('[AttachmentOrchestrator] Categorized payloads:', {
+      count: payloads.length,
+      images: categorizedPayloads.image.length,
+      videos: categorizedPayloads.video.length,
+      files: categorizedPayloads.file.length,
+      texts: categorizedPayloads.text.length,
+    });
+
+    // AC2: Create message from payload based on type
+    const createMessageFromPayload = async (p: any) => {
+      if (p.duration !== undefined || p.videoPath !== undefined) {
+        console.log('[AttachmentOrchestrator] Creating video message');
+        return OpenIMSDK.createVideoMessageByURL(p);
+      }
+      if (
+        p.fileExtension !== undefined ||
+        (p.fileName && p.fileName.includes('.'))
+      ) {
+        console.log('[AttachmentOrchestrator] Creating file message');
+        return OpenIMSDK.createFileMessageByURL(p);
+      }
+      if (p.content && typeof p.content === 'string') {
+        console.log('[AttachmentOrchestrator] Creating text message');
+        return OpenIMSDK.createTextMessage(p.content);
+      }
+      // Default to image
+      console.log('[AttachmentOrchestrator] Creating image message');
+      return OpenIMSDK.createImageMessageByURL(p);
+    };
+
+    // Process attachments in priority order from config
+    let lastMsgId = '';
+    const allMessages = [];
+
+    if (priorityConfig.enabled) {
+      // Use configured priority order
+      console.log(
+        '[AttachmentOrchestrator] Processing in priority order:',
+        priorityConfig.order
+      );
+
+      for (const attachmentType of priorityConfig.order) {
+        const payloadsForType = categorizedPayloads[attachmentType];
+        if (payloadsForType.length === 0) continue;
+
+        console.log(`[AttachmentOrchestrator] Processing ${attachmentType}:`, {
+          count: payloadsForType.length,
+        });
+
+        const mergeStrategy =
+          attachmentType === 'image'
+            ? priorityConfig.mergeStrategy.images
+            : attachmentType === 'video'
+              ? priorityConfig.mergeStrategy.videos
+              : attachmentType === 'file'
+                ? priorityConfig.mergeStrategy.files
+                : 'individual';
+
+        if (mergeStrategy === 'individual' || payloadsForType.length === 1) {
+          // Send individually
+          for (const p of payloadsForType) {
+            const message = await createMessageFromPayload(p as any);
+            allMessages.push(message);
+          }
+        } else {
+          // Merge multiple items
+          const messages = [];
+          for (const p of payloadsForType) {
+            const message = await createMessageFromPayload(p as any);
+            messages.push(message);
+          }
+
+          const typeLabel =
+            attachmentType.charAt(0).toUpperCase() + attachmentType.slice(1);
+          const merged = await OpenIMSDK.createMergerMessage({
+            messageList: messages,
+            title: typeLabel + 's',
+            summaryList: messages.map((_, i) => `[${typeLabel} ${i + 1}]`),
+          });
+
+          if (merged) {
+            allMessages.push(merged);
+          }
+        }
+      }
+    } else {
+      // Original behavior (config disabled)
+      console.log('[AttachmentOrchestrator] Priority config disabled');
+
+      const allPayloads = [
+        ...categorizedPayloads.image,
+        ...categorizedPayloads.video,
+        ...categorizedPayloads.file,
+        ...categorizedPayloads.text,
+      ];
+
+      for (const p of allPayloads) {
+        const message = await createMessageFromPayload(p as any);
+        allMessages.push(message);
+      }
+    }
+
+    // Send all messages in priority order
+    console.log(
+      '[AttachmentOrchestrator] Sending all messages in priority order',
+      {
+        totalMessages: allMessages.length,
+      }
+    );
+
+    for (let i = 0; i < allMessages.length; i++) {
+      const message = allMessages[i] as MessageItem;
+      console.log(
+        '[AttachmentOrchestrator] Sending message',
+        i + 1,
+        'of',
+        allMessages.length
+      );
+
+      const result = await OpenIMSDK.sendMessageNotOss({
+        recvID: currentConversation.userID || '',
+        groupID: currentConversation.groupID || '',
+        message,
+      });
+
+      lastMsgId = result?.clientMsgID || result?.serverMsgID || '';
+      console.log('[AttachmentOrchestrator] Message sent:', {
+        messageId: lastMsgId,
+        index: i + 1,
+      });
+
+      if (onMessageSent && result) {
+        onMessageSent(result);
+      }
+    }
+
+    return lastMsgId;
+  }
+}

package/src/services/auth.ts

@@ -0,0 +1,34 @@
+/**
+ * Auth token management
+ * Consumer app calls setAuthToken() once at startup
+ * Library services call getAuthToken() internally
+ */
+
+let authToken: string | null = null;
+
+/**
+ * Set auth token (call once at app startup)
+ */
+export const setAuthToken = (token: string) => {
+  authToken = token;
+};
+
+/**
+ * Get auth token (called internally by library services)
+ * @throws Error if token not set
+ */
+export const getAuthToken = (): string => {
+  if (!authToken) {
+    throw new Error(
+      'Auth token not initialized. Call setAuthToken(token) at app startup.'
+    );
+  }
+  return authToken;
+};
+
+/**
+ * Clear token (logout)
+ */
+export const clearAuthToken = () => {
+  authToken = null;
+};