fix: presence not updating after app resumes from background

app/containers/Status/index.tsx

@@ -21,10 +21,11 @@ const StatusContainer = ({ id, style, status, size = 32, ...props }: IStatus): R
 	});
 
 	useEffect(() => {
-		if (connected && statusState === 'loading' && !status) {
+		if (connected && !status) {
+			// Always fetch fresh presence when connected (especially after reconnection)
 			getUserPresence(id);
 		}
-	}, [connected, statusState]);
+	}, [connected, id, status]);
 
 	return <Status size={size} style={style} status={status ?? statusState} {...props} />;
 };

app/lib/methods/getUsersPresence.ts

@@ -1,5 +1,6 @@
 import { InteractionManager } from 'react-native';
 import { sanitizedRaw } from '@nozbe/watermelondb/RawRecord';
+import { Q } from '@nozbe/watermelondb';
 
 import { type IActiveUsers } from '../../reducers/activeUsers';
 import { store as reduxStore } from '../store/auxStore';
@@ -55,8 +56,8 @@ export async function getUsersPresence(usersParams: string[]) {
 			if (!usersParams.length) {
 				return;
 			}
-			// Request userPresence on demand
-			params = { ids: usersParams.join(',') };
+			// Request userPresence on demand with cache-busting timestamp
+			params = { ids: usersParams.join(','), _t: Date.now() };
 		}
 
 		try {
@@ -140,3 +141,28 @@ export const setPresenceCap = async (enabled: boolean) => {
 		reduxStore.dispatch(setNotificationPresenceCap(false));
 	}
 };
+
+export const getDirectMessageUserIds = async (): Promise<string[]> => {
+	try {
+		const db = database.active;
+		const subscriptionsCollection = db.get('subscriptions');
+		const subscriptions = await subscriptionsCollection
+			.query(Q.where('t', 'd'), Q.where('open', true), Q.where('archived', false))
+			.fetch();
+		const userIds = subscriptions.map((sub: any) => sub.uids?.[0]).filter(Boolean);
+		return [...new Set(userIds)];
+	} catch (e) {
+		return [];
+	}
+};
+
+export const refreshDmUsersPresence = async (): Promise<void> => {
+	try {
+		const dmUserIds = await getDirectMessageUserIds();
+		if (dmUserIds.length > 0) {
+			await getUsersPresence(dmUserIds);
+		}
+	} catch (e) {
+		// Silently fail
+	}
+};

app/sagas/login.js

@@ -28,7 +28,7 @@ import { getEnterpriseModules, isOmnichannelModuleAvailable } from '../lib/metho
 import { getPermissions } from '../lib/methods/getPermissions';
 import { getRoles } from '../lib/methods/getRoles';
 import { getSlashCommands } from '../lib/methods/getSlashCommands';
-import { getUserPresence, subscribeUsersPresence } from '../lib/methods/getUsersPresence';
+import { getUserPresence, subscribeUsersPresence, refreshDmUsersPresence } from '../lib/methods/getUsersPresence';
 import { logout, removeServerData, removeServerDatabase } from '../lib/methods/logout';
 import { subscribeSettings } from '../lib/methods/getSettings';
 import { connect, loginWithPassword, login } from '../lib/services/connect';
@@ -200,6 +200,14 @@ const fetchUsersPresenceFork = function* fetchUsersPresenceFork() {
 	}
 };
 
+const fetchDmUsersPresenceFork = function* fetchDmUsersPresenceFork() {
+	try {
+		yield call(refreshDmUsersPresence);
+	} catch (e) {
+		log('[login.js] Error fetching DM users presence:', e);
+	}
+};
+
 const fetchEnterpriseModulesFork = function* fetchEnterpriseModulesFork({ user }) {
 	try {
 		yield getEnterpriseModules();
@@ -253,6 +261,7 @@ const handleLoginSuccess = function* handleLoginSuccess({ user }) {
 		yield fork(fetchSlashCommandsFork);
 		yield fork(registerPushTokenFork);
 		yield fork(fetchUsersPresenceFork);
+		yield fork(fetchDmUsersPresenceFork);
 		yield fork(fetchEnterpriseModulesFork, { user });
 		yield fork(subscribeSettingsFork);
 		yield fork(fetchUsersRoles);

app/sagas/state.js

@@ -1,37 +1,54 @@
-import { select, takeLatest } from 'redux-saga/effects';
+import { call, delay, select, takeLatest } from 'redux-saga/effects';
 
 import log from '../lib/methods/helpers/log';
 import { localAuthenticate, saveLastLocalAuthenticationSession } from '../lib/methods/helpers/localAuthentication';
-import { APP_STATE } from '../actions/actionsTypes';
+import { APP_STATE, METEOR } from '../actions/actionsTypes';
 import { RootEnum } from '../definitions';
 import { checkAndReopen } from '../lib/services/connect';
 import { setUserPresenceOnline, setUserPresenceAway } from '../lib/services/restApi';
 import { checkPendingNotification } from '../lib/notifications';
+import { refreshDmUsersPresence, subscribeUsersPresence } from '../lib/methods/getUsersPresence';
+
+const CONNECTION_RETRY_LIMIT = 10;
+const CONNECTION_RETRY_DELAY_MS = 1000;
 
 const isAuthAndConnected = function* isAuthAndConnected() {
 	const login = yield select(state => state.login);
 	const meteor = yield select(state => state.meteor);
 	return login.isAuthenticated && meteor.connected;
 };
 
-const appHasComeBackToForeground = function* appHasComeBackToForeground() {
-	const appRoot = yield select(state => state.app.root);
-	if (appRoot !== RootEnum.ROOT_INSIDE) {
-		return;
-	}
-	const isReady = yield isAuthAndConnected();
-	if (!isReady) {
-		return;
+const waitForConnection = function* waitForConnection() {
+	let retries = 0;
+	let isReady = yield isAuthAndConnected();
+	while (!isReady && retries < CONNECTION_RETRY_LIMIT) {
+		yield delay(CONNECTION_RETRY_DELAY_MS);
+		isReady = yield isAuthAndConnected();
+		retries++;
 	}
+	return isReady;
+};
+
+const appHasComeBackToForeground = function* appHasComeBackToForeground() {
 	try {
 		const server = yield select(state => state.server.server);
 		yield localAuthenticate(server);
 		checkAndReopen();
+
+		const isReady = yield waitForConnection();
+		if (!isReady) {
+			log('[state.js] Connection not ready after retries, aborting foreground tasks');
+			return;
+		}
+
+		// Refresh presence for DM users to ensure status is up-to-date after background
+		yield setUserPresenceOnline();
+		yield call(refreshDmUsersPresence);
+
 		// Check for pending notification when app comes to foreground (Android - notification tap while in background)
 		checkPendingNotification().catch(e => {
 			log('[state.js] Error checking pending notification:', e);
 		});
-		return yield setUserPresenceOnline();
 	} catch (e) {
 		log(e);
 	}
@@ -55,9 +72,24 @@ const appHasComeBackToBackground = function* appHasComeBackToBackground() {
 	}
 };
 
+const handleMeteorConnect = function* handleMeteorConnect() {
+	const appRoot = yield select(state => state.app.root);
+	if (appRoot !== RootEnum.ROOT_INSIDE) {
+		return;
+	}
+	try {
+		// Re-subscribe to presence stream and fetch current presence
+		subscribeUsersPresence();
+		yield call(refreshDmUsersPresence);
+	} catch (e) {
+		log('[state.js] Error refreshing DM users presence on connect:', e);
+	}
+};
+
 const root = function* root() {
 	yield takeLatest(APP_STATE.FOREGROUND, appHasComeBackToForeground);
 	yield takeLatest(APP_STATE.BACKGROUND, appHasComeBackToBackground);
+	yield takeLatest(METEOR.SUCCESS, handleMeteorConnect);
 };
 
 export default root;