@droppii-org/chat-mobile 0.2.6 → 0.2.8

package/src/config/attachment-priority.ts

@@ -0,0 +1,93 @@
+/**
+ * Configuration for attachment sending priority order
+ * AC2: Send mixed media with configurable priority
+ */
+
+export type AttachmentType = 'image' | 'video' | 'file' | 'text';
+
+export interface AttachmentPriorityConfig {
+  enabled: boolean;
+  order: AttachmentType[];
+  mergeStrategy: {
+    images: 'merge' | 'individual';
+    videos: 'merge' | 'individual';
+    files: 'merge' | 'individual';
+  };
+}
+
+// Default AC2 configuration
+export const DEFAULT_ATTACHMENT_PRIORITY: AttachmentPriorityConfig = {
+  enabled: true,
+  order: ['image', 'video', 'file', 'text'],
+  mergeStrategy: {
+    images: 'merge', // Multiple images merged into one message
+    videos: 'individual', // Videos always sent individually (never merged)
+    files: 'merge', // Multiple files merged into one message
+  },
+};
+
+// Alternative configurations
+export const ATTACHMENT_PRIORITY_PRESETS = {
+  // Send everything individually (no merging)
+  INDIVIDUAL: {
+    enabled: true,
+    order: ['image', 'video', 'file', 'text'],
+    mergeStrategy: {
+      images: 'individual',
+      videos: 'individual',
+      files: 'individual',
+    },
+  } as AttachmentPriorityConfig,
+
+  // Send videos first, then everything else
+  VIDEOS_FIRST: {
+    enabled: true,
+    order: ['video', 'image', 'file', 'text'],
+    mergeStrategy: {
+      images: 'merge',
+      videos: 'individual',
+      files: 'merge',
+    },
+  } as AttachmentPriorityConfig,
+
+  // Group by type - all media first, then text
+  MEDIA_FIRST: {
+    enabled: true,
+    order: ['image', 'video', 'file', 'text'],
+    mergeStrategy: {
+      images: 'merge',
+      videos: 'individual',
+      files: 'merge',
+    },
+  } as AttachmentPriorityConfig,
+
+  // Disabled - use original behavior
+  DISABLED: {
+    enabled: false,
+    order: [],
+    mergeStrategy: {
+      images: 'merge',
+      videos: 'individual',
+      files: 'merge',
+    },
+  } as AttachmentPriorityConfig,
+};
+
+/**
+ * Get attachment priority config
+ * Can be overridden via environment variable or per-user settings
+ */
+export function getAttachmentPriorityConfig(): AttachmentPriorityConfig {
+  // Can be extended to read from environment or user preferences
+  return DEFAULT_ATTACHMENT_PRIORITY;
+}
+
+/**
+ * Validate and normalize priority order
+ */
+export function validatePriorityOrder(
+  order: AttachmentType[]
+): AttachmentType[] {
+  const validTypes: AttachmentType[] = ['image', 'video', 'file', 'text'];
+  return order.filter((type) => validTypes.includes(type));
+}

package/src/config/configuration.ts

@@ -0,0 +1,50 @@
+/**
+ * Centralized Configuration
+ *
+ * Manages all API configuration in one place. Different services may use
+ * different protocols (axios, native HTTP), but they should all derive
+ * from the same base URL configuration.
+ */
+
+export interface AppConfig {
+  apiBaseUrl: string;
+}
+
+let config: AppConfig = {
+  apiBaseUrl: '',
+};
+
+/**
+ * Initialize the base URL configuration
+ * This should be called during app startup before any API calls
+ *
+ * @param apiBaseUrl - The base URL for all API services (e.g., 'https://api.example.com')
+ */
+export const initBaseUrl = (apiBaseUrl: string): void => {
+  if (!apiBaseUrl) {
+    if (__DEV__)
+      console.warn('[Configuration] Initializing with empty apiBaseUrl');
+  }
+  config.apiBaseUrl = apiBaseUrl;
+};
+
+/**
+ * Get the configured base URL
+ */
+export const getBaseUrl = (): string => {
+  return config.apiBaseUrl;
+};
+
+/**
+ * Reset configuration (useful for testing)
+ */
+export const resetBaseUrl = (): void => {
+  config = { apiBaseUrl: '' };
+};
+
+/**
+ * Check if base URL is configured
+ */
+export const isBaseUrlConfigured = (): boolean => {
+  return !!config.apiBaseUrl;
+};

package/src/config/index.ts

@@ -0,0 +1,19 @@
+/**
+ * Library Configuration
+ * Provides convenient access to library configuration values
+ */
+
+import { getBaseUrl } from './configuration';
+
+/**
+ * Library Config object for easy access to configuration values
+ */
+export const Config = {
+  /**
+   * Get the configured API base URL
+   * @returns The base URL (e.g., 'https://api.example.com')
+   */
+  get BASE_URL(): string {
+    return getBaseUrl();
+  },
+};

package/src/context/ChatContext.tsx

@@ -13,11 +13,19 @@ export const useChatContext = (): ChatContextType => {
   return context;
 };
 
-const ChatProviderInner = ({ logGA, children }: ChatProviderProps) => {
-  const value = useMemo(() => ({ logGA }), [logGA]);
+const ChatProviderInner = ({
+  logGA,
+  children,
+  applicationType,
+}: ChatProviderProps) => {
+  const value = useMemo(
+    () => ({ logGA, applicationType }),
+    [logGA, applicationType]
+  );
 
   return <ChatContext.Provider value={value}>{children}</ChatContext.Provider>;
 };
 
-export const ChatProvider = ({ enabled, ...props }: ChatProviderProps) =>
-  enabled ? <ChatProviderInner {...props} /> : props.children;
+export const ChatProvider = ({ ...props }: ChatProviderProps) => (
+  <ChatProviderInner {...props} />
+);

package/src/core/index.ts

@@ -1,8 +1,32 @@
 import OpenIMSDK from '@droppii/openim-rn-client-sdk';
+import type { InitOptions } from '@droppii/openim-rn-client-sdk';
+import { initBaseUrl } from '../config/configuration';
 import { useUserListener } from './useUserListener';
 import { useChatListener } from './useChatListener';
 
-export const initChatSdk = OpenIMSDK.initSDK.bind(OpenIMSDK);
+export interface InitChatSdkOptions extends InitOptions {
+  /**
+   * Base URL for API services (image uploads, etc.)
+   * Will be set as the centralized configuration
+   */
+  apiBaseUrl?: string;
+}
+
+/**
+ * Initialize the chat SDK with optional base URL
+ * @param options - SDK initialization options + apiBaseUrl for centralized config
+ */
+export const initChatSdk = (options: InitChatSdkOptions) => {
+  const { apiBaseUrl, ...sdkOptions } = options;
+
+  // Initialize OpenIM SDK
+  OpenIMSDK.initSDK(sdkOptions);
+
+  // Initialize centralized base URL config for all services
+  if (apiBaseUrl) {
+    initBaseUrl(apiBaseUrl);
+  }
+};
 
 export const useChatSdk = () => {
   useUserListener();

package/src/core/useChatListener.ts

@@ -2,21 +2,11 @@ import OpenIMSDK, {
   OpenIMEvent,
   type ConversationItem,
   type GroupMemberItem,
-  type MessageItem,
-  type RevokedInfo,
 } from '@droppii/openim-rn-client-sdk';
 import { useCallback, useEffect } from 'react';
 import { useConversationStore } from '../store/conversation';
 
 export const useChatListener = () => {
-  const onRecvNewMessages = useCallback((messages: MessageItem[]) => {
-    console.log('onRecvNewMessages', messages);
-  }, []);
-
-  const onNewRecvMessageRevoked = useCallback((revokedInfo: RevokedInfo) => {
-    console.log('onNewRecvMessageRevoked', revokedInfo);
-  }, []);
-
   const onConversationChanged = useCallback(
     (conversations: ConversationItem[]) => {
       console.log('onConversationChanged', conversations);
@@ -41,10 +31,6 @@ export const useChatListener = () => {
   }, []);
 
   useEffect(() => {
-    // Message
-    OpenIMSDK.on(OpenIMEvent.OnRecvNewMessages, onRecvNewMessages);
-    OpenIMSDK.on(OpenIMEvent.OnNewRecvMessageRevoked, onNewRecvMessageRevoked);
-
     // Conversation
     OpenIMSDK.on(OpenIMEvent.OnConversationChanged, onConversationChanged);
     OpenIMSDK.on(OpenIMEvent.OnNewConversation, onNewConversation);
@@ -54,13 +40,6 @@ export const useChatListener = () => {
     OpenIMSDK.on(OpenIMEvent.OnGroupMemberDeleted, onGroupMemberDeleted);
 
     return () => {
-      // Message
-      OpenIMSDK.off(OpenIMEvent.OnRecvNewMessages, onRecvNewMessages);
-      OpenIMSDK.off(
-        OpenIMEvent.OnNewRecvMessageRevoked,
-        onNewRecvMessageRevoked
-      );
-
       // Conversation
       OpenIMSDK.off(OpenIMEvent.OnConversationChanged, onConversationChanged);
       OpenIMSDK.off(OpenIMEvent.OnNewConversation, onNewConversation);

package/src/hooks/message/useSendMessage.ts

@@ -0,0 +1,143 @@
+import { useCallback } from 'react';
+import type { UploadFileItem } from 'react-native-fs';
+import { useConversationStore } from '../../store';
+import type {
+  MessageItem,
+  MessageType,
+  OfflinePush,
+} from '@droppii/openim-rn-client-sdk';
+import { extractUrls } from '../../utils/url';
+import OpenIMSDK from '@droppii/openim-rn-client-sdk';
+import type { IMessageItemEx } from '../../types/chat';
+import { useChatContext } from '../../context';
+import { generateContentBasedOnMessageType } from '../../utils/conversation';
+import { useMessageStore } from '../../store/message';
+import type { IUrlMetadata } from '../../types/common';
+
+export const useSendMessage = () => {
+  const applicationType = useChatContext().applicationType;
+  const pushNewMessage = useMessageStore((state) => state.pushNewMessage);
+
+  const sendMessage = useCallback(
+    async ({
+      plainText,
+      files,
+      urlMetadata,
+    }: {
+      plainText?: string;
+      files?: UploadFileItem[]; //TODO
+      urlMetadata?: IUrlMetadata;
+    }) => {
+      const { userID: recvID, groupID } =
+        useConversationStore.getState().getCurrentConversation() || {};
+      if (!recvID && !groupID) return;
+
+      const messageList: MessageItem[] = [];
+
+      for (const file of files || []) {
+        if (!file) continue;
+      }
+
+      // Allow empty text if urlMetadata (preview link) is present
+      const hasText = !!plainText && plainText.trim() !== '';
+      const hasPreview = !!urlMetadata?.url;
+
+      if (hasText || hasPreview) {
+        const urls = hasText ? extractUrls(plainText) : [];
+        const isUrlMessage = urls.length > 0 || hasPreview;
+        let message: MessageItem | null = null;
+
+        if (isUrlMessage) {
+          // Create URL message even with empty text if preview exists
+          message = await createUrlTextMessage(plainText || '', urls);
+        } else if (hasText) {
+          message = await createTextMessage(plainText);
+        }
+
+        if (!message) return;
+        messageList.push(message);
+      }
+
+      for (const message of messageList) {
+        const extendMessageInfo: IMessageItemEx = {
+          applicationType,
+          urlMetadata,
+        };
+
+        const successMessage = await OpenIMSDK.sendMessage({
+          groupID: groupID || '',
+          recvID: recvID || '',
+          message: {
+            ...message,
+            ex: JSON.stringify(extendMessageInfo) || '{}',
+          },
+          offlinePushInfo: generateOfflinePushInfo(
+            message.contentType,
+            plainText || ''
+          ),
+        });
+
+        pushNewMessage(successMessage);
+      }
+    },
+    [applicationType, pushNewMessage]
+  );
+
+  return {
+    sendMessage,
+  };
+};
+
+const generateOfflinePushInfo = (
+  contentType: MessageType,
+  plainText: string
+) => {
+  const conversationData = useConversationStore
+    ?.getState?.()
+    ?.getCurrentConversation();
+  const title = conversationData?.showName || 'Droppii';
+  const desc = generateContentBasedOnMessageType(contentType, plainText);
+  return {
+    title,
+    desc,
+    ex: JSON.stringify({
+      icon: conversationData?.faceURL || '',
+      conversationId: conversationData?.conversationId || '',
+      title,
+      desc,
+    }),
+    iOSPushSound: 'default',
+    iOSBadgeCount: true,
+  } as OfflinePush;
+};
+
+export const createTextMessage = async (text: string) => {
+  let textMessage = await OpenIMSDK.createTextMessage(
+    text,
+    new Date().getTime().toString()
+  )
+    .then((data) => {
+      return data;
+    })
+    .catch(({ errCode, errMsg }) => {
+      console.error('createTextMessage', errCode, errMsg);
+      return null;
+    });
+  return textMessage;
+};
+
+export const createUrlTextMessage = async (text: string, urls: string[]) => {
+  let urlTextMessage = await OpenIMSDK.createUrlTextMessage(
+    text,
+    urls,
+    new Date().getTime().toString()
+  )
+    .then((data) => {
+      return data;
+    })
+    .catch(({ errCode, errMsg }) => {
+      console.error('createUrlTextMessage', errCode, errMsg);
+      return null;
+    });
+  return urlTextMessage;
+};