@ethora/chat-component-rn 26.4.1

package/src/roomStore/roomsSlice.ts

@@ -0,0 +1,353 @@
+import { createSlice, PayloadAction } from '@reduxjs/toolkit';
+import { EditAction, HistoryPreloadState, IMessage, IRoom } from '../types/types';
+import { insertMessageWithDelimiter } from '../helpers/insertMessageWithDelimiter';
+
+export interface RoomPreloadPatch {
+  jid: string;
+  messages?: IMessage[];
+  historyPreloadState?: HistoryPreloadState;
+  unreadCapped?: boolean;
+  historyComplete?: boolean;
+}
+
+interface RoomMessagesState {
+  rooms: { [jid: string]: IRoom };
+  activeRoomJID: string | null;
+  editAction?: EditAction;
+  isLoading: boolean;
+  pendingNotificationJid?: string | null;
+}
+
+const initialState: RoomMessagesState = {
+  rooms: {},
+  activeRoomJID: null,
+  isLoading: false,
+  editAction: {
+    isEdit: false,
+    roomJid: '',
+    messageId: '',
+    text: '',
+  },
+  pendingNotificationJid: null,
+};
+
+export const roomsStore = createSlice({
+  name: 'roomMessages',
+  initialState,
+  reducers: {
+    addRoom(state, action: PayloadAction<{ roomData: IRoom }>) {
+      const { roomData } = action.payload;
+      state.rooms[roomData.jid] = roomData;
+    },
+    deleteRoom(state, action: PayloadAction<{ jid: string }>) {
+      const { jid } = action.payload;
+      if (state.rooms[jid]) {
+        delete state.rooms[jid];
+      }
+    },
+    updateRoom(
+      state,
+      action: PayloadAction<{ jid: string; updates: Partial<IRoom> }>
+    ) {
+      const { jid, updates } = action.payload;
+      const existingRoom = state.rooms[jid];
+
+      if (existingRoom) {
+        state.rooms[jid] = {
+          ...existingRoom,
+          ...updates,
+        };
+      }
+    },
+    setRoomMessages(
+      state,
+      action: PayloadAction<{ roomJID: string; messages: IMessage[] }>
+    ) {
+      const { roomJID, messages } = action.payload;
+      if (state.rooms[roomJID]) {
+        state.rooms[roomJID].messages = messages;
+      }
+    },
+    deleteRoomMessage(
+      state,
+      action: PayloadAction<{ roomJID: string; messageId: string }>
+    ) {
+      const { roomJID, messageId } = action.payload;
+      if (state.rooms[roomJID]) {
+        state.rooms[roomJID].messages.map((message) => {
+          if (message.id === messageId) {
+            message.isDeleted = true;
+          }
+        });
+      }
+    },
+    setEditAction: (state, action: PayloadAction<EditAction | undefined>) => {
+      if (action.payload?.isEdit) {
+        state.editAction = action.payload;
+      } else {
+        state.editAction = {
+          isEdit: false,
+          roomJid: '',
+          messageId: '',
+          text: '',
+        };
+      }
+    },
+    editRoomMessage(
+      state,
+      action: PayloadAction<{
+        roomJID: string;
+        messageId: string;
+        text: string;
+      }>
+    ) {
+      const { roomJID, messageId, text } = action.payload;
+      if (state.rooms[roomJID]) {
+        state.rooms[roomJID].messages.map((message) => {
+          if (message.id === messageId) {
+            message.body = text;
+          }
+        });
+      }
+    },
+    addRoomMessage(
+      state,
+      action: PayloadAction<{
+        roomJID: string;
+        message: IMessage;
+        start?: boolean;
+      }>
+    ) {
+      const { roomJID, message, start } = action.payload;
+
+      if (!state.rooms[roomJID]?.messages) {
+        state.rooms[roomJID].messages = [];
+      }
+
+      const roomMessages = state.rooms[roomJID].messages;
+
+      if (roomMessages.length === 0 || start) {
+        roomMessages.unshift(message);
+      } else {
+        const lastViewedTimestamp = state.rooms[roomJID].lastViewedTimestamp
+          ? new Date(state.rooms[roomJID].lastViewedTimestamp)
+          : null;
+
+        insertMessageWithDelimiter(roomMessages, message, lastViewedTimestamp);
+      }
+    },
+    deleteAllRooms(state) {
+      state.rooms = {};
+    },
+    setComposing(
+      state,
+      action: PayloadAction<{
+        chatJID: string;
+        composing: boolean;
+        composingList?: string[];
+      }>
+    ) {
+      const { chatJID, composing, composingList } = action.payload;
+      state.rooms[chatJID].composing = composing;
+      state.rooms[chatJID].composingList = composingList;
+    },
+    setIsLoading: (
+      state,
+      action: PayloadAction<{ chatJID?: string; loading: boolean }>
+    ) => {
+      const { chatJID, loading } = action.payload;
+      if (chatJID && state.rooms?.[chatJID]) {
+        state.rooms[chatJID].isLoading = loading;
+      }
+      state.isLoading = loading;
+    },
+    setLastViewedTimestamp: (
+      state,
+      action: PayloadAction<{ chatJID: string; timestamp: number }>
+    ) => {
+      const { chatJID, timestamp } = action.payload;
+      if (state.rooms[chatJID]) {
+        state.rooms[chatJID].lastViewedTimestamp = timestamp;
+        // timestamp === 0 means "user is currently viewing this room" —
+        // unread is cleared. Otherwise count messages received strictly
+        // after the last-viewed instant.
+        if (!timestamp) {
+          state.rooms[chatJID].unreadMessages = 0;
+        } else {
+          state.rooms[chatJID].unreadMessages = countNewerMessages(
+            state.rooms[chatJID].messages,
+            timestamp
+          );
+        }
+      }
+    },
+    setRoomRole: (
+      state,
+      action: PayloadAction<{ chatJID: string; role: string }>
+    ) => {
+      const { chatJID, role } = action.payload;
+      if (state.rooms[chatJID]) {
+        state.rooms[chatJID].role = role;
+      }
+    },
+    setRoomNoMessages: (
+      state,
+      action: PayloadAction<{ value: boolean; chatJID?: string }>
+    ) => {
+      const { value, chatJID } = action.payload;
+      if (chatJID) {
+        state.rooms[chatJID].noMessages = value;
+      }
+    },
+    setCurrentRoom: (
+      state,
+      action: PayloadAction<{ roomJID: string | null }>
+    ) => {
+      // Accept null/empty so callers can clear the active room (e.g.
+      // back button from chat → return to RoomList). Mirrors web.
+      state.activeRoomJID = action.payload.roomJID || '';
+    },
+    /**
+     * Stash a JID that a push notification asked us to open before
+     * the rooms list has loaded. The Chat component clears this once
+     * the room exists locally and dispatches `setCurrentRoom`.
+     */
+    setPendingNotificationJid: (
+      state,
+      action: PayloadAction<string | null>
+    ) => {
+      state.pendingNotificationJid = action.payload;
+    },
+    clearPendingNotificationJid: (state) => {
+      state.pendingNotificationJid = null;
+    },
+    /**
+     * Stamp a message in `state.rooms[roomJID].messages` with an updated
+     * reactions list. The reactionsMiddleware listens for this action to
+     * keep `IRoom.lastMessage` / `lastMessageTimestamp` in sync.
+     */
+    setReactions: (
+      state,
+      action: PayloadAction<{
+        roomJID: string;
+        messageId: string;
+        from?: string;
+        reactions: string[];
+        latestReactionTimestamp?: string;
+        data?: Record<string, string>;
+      }>
+    ) => {
+      const { roomJID, messageId, reactions } = action.payload;
+      const room = state.rooms[roomJID];
+      if (!room?.messages) {return;}
+      for (const msg of room.messages) {
+        if (msg?.id === messageId) {
+          (msg as any).reactions = reactions;
+          break;
+        }
+      }
+    },
+    setLogoutState: (state) => {
+      state.rooms = {};
+      state.activeRoomJID = null;
+      state.isLoading = false;
+    },
+    setActiveMessage: (
+      state,
+      action: PayloadAction<{ id: string; chatJID: string }>
+    ) => {
+      const { id, chatJID } = action.payload;
+
+      state.rooms[chatJID].messages.map((message) => {
+        if (message.id === id) {
+          message.activeMessage = true;
+        } else {
+          message.activeMessage = false;
+        }
+      });
+    },
+    setCloseActiveMessage: (
+      state,
+      action: PayloadAction<{ chatJID: string }>
+    ) => {
+      const { chatJID } = action.payload;
+
+      state.rooms[chatJID].messages.map((message) => {
+        message.activeMessage = false;
+      });
+    },
+    /**
+     * Batched update used by the history preload scheduler. Each patch is
+     * applied to its room: messages REPLACE (when provided), state fields
+     * MERGE. Rooms that don't exist yet are ignored.
+     */
+    applyRoomsPreloadBatch: (
+      state,
+      action: PayloadAction<{ rooms: RoomPreloadPatch[] }>
+    ) => {
+      const { rooms } = action.payload;
+      for (const patch of rooms) {
+        const room = state.rooms[patch.jid];
+        if (!room) {continue;}
+        if (typeof patch.historyPreloadState !== 'undefined') {
+          room.historyPreloadState = patch.historyPreloadState;
+        }
+        if (typeof patch.unreadCapped !== 'undefined') {
+          room.unreadCapped = patch.unreadCapped;
+        }
+        if (typeof patch.historyComplete !== 'undefined') {
+          room.historyComplete = patch.historyComplete;
+        }
+        if (Array.isArray(patch.messages)) {
+          // Merge: keep any locally-pending messages, replace the rest.
+          const pending = room.messages?.filter((m) => m?.pending) || [];
+          room.messages = [...patch.messages, ...pending];
+        }
+      }
+    },
+  },
+});
+
+// Count messages strictly newer than the given millisecond timestamp.
+// Uses `msg.date` (canonical ISO/Date) so it matches the unread
+// middleware. Excludes the "delimiter-new" sentinel and pending sends.
+const countNewerMessages = (
+  messages: IMessage[],
+  timestamp: number
+): number => {
+  if (!messages?.length || !timestamp) {return 0;}
+  let count = 0;
+  for (const message of messages) {
+    if (!message || message.id === 'delimiter-new' || message.pending) {continue;}
+    const ms = new Date(message.date as any).getTime();
+    if (Number.isFinite(ms) && ms > timestamp) {count += 1;}
+  }
+  return count;
+};
+
+export const {
+  addRoom,
+  deleteAllRooms,
+  setRoomMessages,
+  addRoomMessage,
+  deleteRoomMessage,
+  setEditAction,
+  editRoomMessage,
+  setComposing,
+  setIsLoading,
+  setLastViewedTimestamp,
+  setRoomNoMessages,
+  setCurrentRoom,
+  setRoomRole,
+  setLogoutState,
+  setActiveMessage,
+  setCloseActiveMessage,
+  deleteRoom,
+  updateRoom,
+  applyRoomsPreloadBatch,
+  setPendingNotificationJid,
+  clearPendingNotificationJid,
+  setReactions,
+} = roomsStore.actions;
+
+export default roomsStore.reducer;

package/src/services/pushNotifications.ts

@@ -0,0 +1,170 @@
+import messaging, { FirebaseMessagingTypes } from '@react-native-firebase/messaging';
+import { getApp } from '@react-native-firebase/app';
+import { Platform, PermissionsAndroid } from 'react-native';
+
+let appInstance: any;
+try {
+  appInstance = getApp();
+} catch (error) {
+}
+
+const AuthorizationStatus = (messaging as any).AuthorizationStatus;
+
+let cachedMessagingInstance: any = null;
+
+const getMessagingInstance = () => {
+  if (cachedMessagingInstance) {
+    return cachedMessagingInstance;
+  }
+
+  if (!appInstance) {
+    try {
+      appInstance = getApp();
+    } catch (e) {
+    }
+  }
+
+  cachedMessagingInstance = messaging();
+  return cachedMessagingInstance;
+};
+
+export async function requestNotificationPermission(): Promise<boolean> {
+  const messagingInstance = getMessagingInstance();
+  if (Platform.OS === 'ios') {
+    const authStatus = await messagingInstance.requestPermission();
+    return (
+      authStatus === AuthorizationStatus.AUTHORIZED ||
+      authStatus === AuthorizationStatus.PROVISIONAL
+    );
+  }
+
+  if (Platform.OS === 'android' && Platform.Version >= 33) {
+    const granted = await PermissionsAndroid.request(
+      PermissionsAndroid.PERMISSIONS.POST_NOTIFICATIONS
+    );
+    return granted === PermissionsAndroid.RESULTS.GRANTED;
+  }
+
+  return true;
+}
+
+export async function getFCMToken(): Promise<string | null> {
+  try {
+    const messagingInstance = getMessagingInstance();
+    if (!messagingInstance.isDeviceRegisteredForRemoteMessages) {
+      await messagingInstance.registerDeviceForRemoteMessages();
+    }
+
+    if (Platform.OS === 'ios') {
+      await new Promise(resolve => setTimeout(resolve, 2000));
+
+      let apnsToken = await messagingInstance.getAPNSToken();
+
+      if (!apnsToken) {
+        await new Promise(resolve => setTimeout(resolve, 3000));
+        apnsToken = await messagingInstance.getAPNSToken();
+      }
+
+      // No APNS token means push not configured - this is OK for development
+      if (!apnsToken) {
+        console.log('Push notifications not configured (missing APNs). App will work without push.');
+        return null;
+      }
+    }
+
+    const token = await messagingInstance.getToken();
+
+    return token;
+  } catch (error: any) {
+    // Silently handle missing aps-environment (push not configured in Xcode)
+    const errorMsg = error?.message || String(error);
+    if (errorMsg.includes('aps-environment') || errorMsg.includes('messaging/unknown')) {
+      console.log('Push notifications not configured in Xcode. App will work without push.');
+      return null;
+    }
+    console.warn('Error getting FCM token:', error);
+    return null;
+  }
+}
+
+export function onForegroundMessage(
+  callback: (message: FirebaseMessagingTypes.RemoteMessage) => void
+): () => void {
+  const messagingInstance = getMessagingInstance();
+  return messagingInstance.onMessage(callback);
+}
+
+export function setBackgroundMessageHandler(
+  handler: (message: any) => Promise<void>
+): void {
+  const messagingInstance = getMessagingInstance();
+  messagingInstance.setBackgroundMessageHandler(handler);
+}
+
+export function onNotificationOpenedApp(
+  callback: (message: any) => void
+): () => void {
+  const messagingInstance = getMessagingInstance();
+  return messagingInstance.onNotificationOpenedApp(callback);
+}
+
+export async function getInitialNotification(): Promise<any | null> {
+  try {
+    const messagingInstance = getMessagingInstance();
+    const message = await messagingInstance.getInitialNotification();
+    return message;
+  } catch (error) {
+    console.error('Error getting initial notification:', error);
+    return null;
+  }
+}
+
+export async function initPushNotifications(): Promise<string | null> {
+
+  const hasPermission = await requestNotificationPermission();
+
+  if (!hasPermission) {
+    console.error('Push notification permission denied');
+    return null;
+  }
+
+  const token = await getFCMToken();
+
+  return token;
+}
+
+export async function checkNotificationPermission(): Promise<boolean> {
+  try {
+    const messagingInstance = getMessagingInstance();
+    if (Platform.OS === 'ios') {
+      try {
+        const apnsToken = await messagingInstance.getAPNSToken();
+        return apnsToken !== null;
+      } catch (error) {
+        return false;
+      }
+    }
+
+    if (Platform.OS === 'android' && Platform.Version >= 33) {
+      const granted = await PermissionsAndroid.check(
+        PermissionsAndroid.PERMISSIONS.POST_NOTIFICATIONS
+      );
+      return granted;
+    }
+
+    return true;
+  } catch (error) {
+    console.warn('Error checking notification permission:', error);
+    return false;
+  }
+}
+
+export async function disablePushNotifications(): Promise<void> {
+  try {
+    const messagingInstance = getMessagingInstance();
+    await messagingInstance.deleteToken();
+    console.log('FCM token deleted successfully');
+  } catch (error) {
+    console.warn('Error deleting FCM token:', error);
+  }
+}

package/src/services/pushSubscriptionService.ts

@@ -0,0 +1,145 @@
+import { Client } from '@xmpp/client';
+import { User } from '../types/types';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { subscribeToPushNotifications } from '../networking/api-requests/push.api';
+import { subscribeToRoomMessages } from '../networking/xmpp/subscribeToRoomMessages.xmpp';
+
+const SUBSCRIBED_ROOMS_KEY = 'preshent_subscribed_rooms';
+
+export class PushSubscriptionService {
+  private subscribedRooms: Set<string> = new Set();
+  private isPushSubscribed: boolean = false;
+  private lastSubscriptionKey: string | null = null;
+  private isInitialized: boolean = false;
+
+  private async loadSubscribedRoomsFromStorage(): Promise<void> {
+    if (this.isInitialized) {return;}
+
+    try {
+      const storedRooms = await AsyncStorage.getItem(SUBSCRIBED_ROOMS_KEY);
+      if (storedRooms) {
+        const roomsArray = JSON.parse(storedRooms) as string[];
+        this.subscribedRooms = new Set(roomsArray);
+      }
+      this.isInitialized = true;
+    } catch (error) {
+      console.error('[PushService] Failed to load subscribed rooms from storage:', error);
+    }
+  }
+
+  private async saveSubscribedRoomsToStorage(): Promise<void> {
+    try {
+      const roomsArray = Array.from(this.subscribedRooms);
+      await AsyncStorage.setItem(SUBSCRIBED_ROOMS_KEY, JSON.stringify(roomsArray));
+    } catch (error) {
+      console.error('[PushService] Failed to save subscribed rooms to storage:', error);
+    }
+  }
+
+  async subscribeToPush(
+    fcmToken: string,
+    user: User,
+    projectName: string,
+  ): Promise<void> {
+    const walletAddress = user.defaultWallet?.walletAddress || user.walletAddress;
+    const subscriptionKey = `${fcmToken}_${walletAddress}`;
+
+    if (this.isPushSubscribed && this.lastSubscriptionKey === subscriptionKey) {
+      console.log('⚠️ Push already subscribed with this token, skipping...');
+      return;
+    }
+
+    try {
+      const userJid: string = user.xmppUsername || '';
+
+      if (!userJid) {
+        throw new Error('User JID is required for push subscription');
+      }
+
+      await subscribeToPushNotifications(fcmToken, userJid, projectName);
+      this.isPushSubscribed = true;
+      this.lastSubscriptionKey = subscriptionKey;
+    } catch (error: any) {
+      console.error('Failed to subscribe to push after all retries:', error);
+    }
+  }
+
+  async subscribeToRoom(
+    client: Client,
+    roomJID: string,
+    userNick?: string
+  ): Promise<boolean> {
+    await this.loadSubscribedRoomsFromStorage();
+
+    if (this.subscribedRooms.has(roomJID)) {
+      return true;
+    }
+
+    try {
+      const result = await subscribeToRoomMessages(client, roomJID, userNick);
+      if (result) {
+        this.subscribedRooms.add(roomJID);
+        await this.saveSubscribedRoomsToStorage();
+      }
+      console.log('Successfully Subscribed to room', roomJID);
+      return result;
+    } catch (error) {
+      console.error(`[PushService] Failed to subscribe to room ${roomJID}:`, error);
+      return false;
+    }
+  }
+
+  async subscribeToRooms(
+    client: Client,
+    roomJIDs: string[],
+    userNick?: string
+  ): Promise<void> {
+    let successful = 0;
+    let failed = 0;
+
+    console.log('test roomJIDs', roomJIDs);
+
+    for (const roomJID of roomJIDs) {
+      try {
+        const result = await this.subscribeToRoom(client, roomJID, userNick);
+        console.log('test roomJID-1', result);
+        if (result) {
+          successful++;
+        } else {
+          failed++;
+        }
+        await new Promise(resolve => setTimeout(resolve, 100));
+      } catch (error) {
+        failed++;
+        console.error(`Failed to subscribe to room ${roomJID}:`, error);
+      }
+    }
+
+    console.log(`Subscribed to ${successful} rooms, ${failed} failed`);
+  }
+
+  async reset(): Promise<void> {
+    this.subscribedRooms.clear();
+    this.isPushSubscribed = false;
+    this.lastSubscriptionKey = null;
+    this.isInitialized = false;
+
+    try {
+      await AsyncStorage.removeItem(SUBSCRIBED_ROOMS_KEY);
+      console.log('[PushService] Subscribed rooms cleared from storage');
+    } catch (error) {
+      console.error('[PushService] Failed to clear subscribed rooms from storage:', error);
+    }
+  }
+
+  isRoomSubscribed(roomJID: string): boolean {
+    return this.subscribedRooms.has(roomJID);
+  }
+
+  getSubscribedRooms(): string[] {
+    return Array.from(this.subscribedRooms);
+  }
+}
+
+export const pushSubscriptionService = new PushSubscriptionService();
+