Files
cinny/src/app/pages/client/ClientRoot.tsx
T
litruv 95d1cb9630
Trigger cinny-mobile / dispatch (push) Successful in 1s
Show cached spaces on the loading splash until the chats are ready
The splash hid as soon as sync reported Prepared, so the first paint after it
disappeared showed the empty state. Hide only once the room-list atoms actually
contain chats, and bind those atoms while the splash is still up so the first
paint is already populated.

Also fixes the ClientEvent.Sync handler signature: data is the third argument,
so reading it as the second made fromCache always undefined.
2026-10-06 11:11:27 +11:00

469 lines
16 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import { Box, Button, config, Dialog, IconButton, Menu, MenuItem, PopOut, RectCords, Text } from 'folds';
import { Icon, Icons } from '../../components/icons';
import {
ClientEvent,
HttpApiEvent,
HttpApiEventHandlerMap,
MatrixClient,
SyncState,
} from 'matrix-js-sdk';
import FocusTrap from 'focus-trap-react';
import React, { MouseEventHandler, ReactNode, useCallback, useEffect, useRef, useState } from 'react';
import {
clearCacheAndReload,
clearLoginData,
initClient,
logoutClient,
startClient,
} from '../../../client/initMatrix';
import { SplashScreen } from '../../components/splash-screen';
import { ClientLoading } from './ClientLoading';
import { ServerConfigsLoader } from '../../components/ServerConfigsLoader';
import { CapabilitiesProvider } from '../../hooks/useCapabilities';
import { MediaConfigProvider } from '../../hooks/useMediaConfig';
import { MatrixClientProvider } from '../../hooks/useMatrixClient';
import { PluginLoader } from '../../features/settings/plugins';
import { SpecVersions } from './SpecVersions';
import { AsyncStatus, useAsyncCallback } from '../../hooks/useAsyncCallback';
import { useSyncState } from '../../hooks/useSyncState';
import { stopPropagation } from '../../utils/keyboard';
import { useAtomValue } from 'jotai';
import { allRoomsAtom, useBindAllRoomsAtom } from '../../state/room-list/roomList';
import { mDirectAtom, useBindMDirectAtom } from '../../state/mDirectList';
import { roomToParentsAtom, useBindRoomToParentsAtom } from '../../state/room/roomToParents';
import { AuthMetadataProvider } from '../../hooks/useAuthMetadata';
import { getCurrentSession } from '../../state/sessions';
import { CallProviderWrapper } from '../../features/call/CallProviderWrapper';
import { isTauriMobile, startBackgroundSync, stopBackgroundSync } from '../../utils/tauri';
import { TitleBar } from '../../components/title-bar';
import { AccountSwitcher } from '../../components/account-switcher';
import { getLoginPath, withSearchParam } from '../pathUtils';
import { useViewTransitions } from '../../hooks/useViewTransitions';
const useLogoutListener = (mx?: MatrixClient) => {
useEffect(() => {
const handleLogout: HttpApiEventHandlerMap[HttpApiEvent.SessionLoggedOut] = async () => {
mx?.stopClient();
await mx?.clearStores();
window.localStorage.clear();
window.location.reload();
};
mx?.on(HttpApiEvent.SessionLoggedOut, handleLogout);
return () => {
mx?.removeListener(HttpApiEvent.SessionLoggedOut, handleLogout);
};
}, [mx]);
};
/**
* Hook to handle visibility changes and restart sync on mobile
* When the app goes to background and comes back, sync may be stale/stopped
*/
const useVisibilitySync = (mx?: MatrixClient) => {
useEffect(() => {
if (!mx || !isTauriMobile()) return;
const handleVisibilityChange = () => {
if (document.visibilityState === 'visible') {
console.log('[useVisibilitySync] App became visible, checking sync state');
const syncState = mx.getSyncState();
console.log('[useVisibilitySync] Current sync state:', syncState);
// If sync is not running or errored, restart it
if (!mx.clientRunning || syncState === SyncState.Error || syncState === SyncState.Stopped || syncState === null) {
console.log('[useVisibilitySync] Restarting sync...');
startClient(mx).catch((err) => {
console.error('[useVisibilitySync] Failed to restart sync:', err);
});
} else {
// Force a sync even if client is running (to catch up quickly)
console.log('[useVisibilitySync] Triggering immediate sync');
mx.retryImmediately();
}
}
};
document.addEventListener('visibilitychange', handleVisibilityChange);
// Also handle resume event for mobile (if available)
window.addEventListener('resume', handleVisibilityChange);
return () => {
document.removeEventListener('visibilitychange', handleVisibilityChange);
window.removeEventListener('resume', handleVisibilityChange);
};
}, [mx]);
};
/**
* Hook to start/stop native Rust background sync on mobile
* This allows notifications to work even when the app is backgrounded
*/
const useBackgroundSync = (mx?: MatrixClient) => {
useEffect(() => {
if (!mx || !isTauriMobile()) return;
// Start background sync with credentials from the Matrix client
const startSync = async () => {
try {
const homeserverUrl = mx.getHomeserverUrl();
const userId = mx.getUserId();
const accessToken = mx.getAccessToken();
const deviceId = mx.getDeviceId();
if (!homeserverUrl || !userId || !accessToken || !deviceId) {
console.warn('[useBackgroundSync] Missing credentials, cannot start background sync');
return;
}
await startBackgroundSync({
homeserverUrl,
userId,
accessToken,
deviceId,
});
console.log('[useBackgroundSync] Background sync started');
} catch (err) {
console.error('[useBackgroundSync] Failed to start background sync:', err);
}
};
startSync();
// Stop background sync on cleanup
return () => {
stopBackgroundSync().catch((err) => {
console.error('[useBackgroundSync] Failed to stop background sync:', err);
});
};
}, [mx]);
};
/**
* Binds the atoms the chat UI reads while the splash is still up. Without this,
* they are only bound after the splash hides, so the first paint shows the empty
* state ("No Direct Messages") for a moment.
*
* Only the context-free bindings go here: the rest (unread, typing, auto-join)
* needs the RoomsNotificationPreferences provider, which lives inside children.
*/
function ClientAtomBinder({ mx }: { mx: MatrixClient }) {
useBindMDirectAtom(mx, mDirectAtom);
useBindAllRoomsAtom(mx, allRoomsAtom);
useBindRoomToParentsAtom(mx, roomToParentsAtom);
return null;
}
type ClientRootProps = {
children: ReactNode;
};
export function ClientRoot({ children }: ClientRootProps) {
const [loading, setLoading] = useState(true);
const mxRef = useRef<MatrixClient | undefined>(undefined);
const recoverInFlight = useRef(false);
// Hold the splash briefly after chats are loaded so the space particles
// finish animating before the UI swaps in.
const splashHoldTimer = useRef<number | undefined>(undefined);
// Grace window for the first network sync to land after the cache is ready;
// hide anyway if we are offline so the UI is never blocked.
const firstNetworkSyncGrace = useRef<number | undefined>(undefined);
// Hard deadline so a sync that never lands (offline, empty store, errored
// first sync) can not leave the splash up forever.
const splashDeadline = useRef<number | undefined>(undefined);
const scheduleHide = useCallback((reason?: string) => {
if (splashHoldTimer.current !== undefined) return;
if (reason) console.log(`[ClientRoot] Hiding splash: ${reason}`);
splashHoldTimer.current = window.setTimeout(() => {
splashHoldTimer.current = undefined;
setLoading(false);
}, 1500);
}, []);
// The UI renders chats from the room-list atoms, which are filled by
// ClientAtomBinder while the splash is still up. Gate the hide on those atoms
// so the first paint after the splash already contains the chats.
const roomsAtom = useAtomValue(allRoomsAtom);
const directsAtom = useAtomValue(mDirectAtom);
const chatsReady =
roomsAtom.length > 0 && directsAtom.size > 0 && roomsAtom.some((roomId) => directsAtom.has(roomId));
const tryHide = useCallback(
(reason: string): boolean => {
if (chatsReady) {
scheduleHide(reason);
return true;
}
return false;
},
[chatsReady, scheduleHide]
);
// The atoms fill in as the store restores the cache; hide as soon as they do.
useEffect(() => {
if (loading && chatsReady) scheduleHide('chats populated');
}, [loading, chatsReady, scheduleHide]);
const { baseUrl } = getCurrentSession() ?? {};
// Enable view transitions for smooth navigation
useViewTransitions();
const [loadState, loadMatrix] = useAsyncCallback<MatrixClient, Error, []>(
useCallback(() => {
const session = getCurrentSession();
if (!session) {
throw new Error('No session Found!');
}
return initClient(session);
}, [])
);
const mx = loadState.status === AsyncStatus.Success ? loadState.data : undefined;
useEffect(() => {
mxRef.current = mx;
}, [mx]);
useEffect(() => {
return () => {
if (splashHoldTimer.current !== undefined) {
window.clearTimeout(splashHoldTimer.current);
}
if (firstNetworkSyncGrace.current !== undefined) {
window.clearTimeout(firstNetworkSyncGrace.current);
}
if (splashDeadline.current !== undefined) {
window.clearTimeout(splashDeadline.current);
}
};
}, []);
const [startState, startMatrix] = useAsyncCallback<void, Error, [MatrixClient]>(
useCallback((m) => startClient(m), [])
);
useLogoutListener(mx);
useVisibilitySync(mx);
useBackgroundSync(mx);
useEffect(() => {
if (loadState.status === AsyncStatus.Idle) {
loadMatrix();
}
}, [loadState, loadMatrix]);
useEffect(() => {
if (mx && !mx.clientRunning) {
startMatrix(mx);
}
}, [mx, startMatrix]);
// Cached rooms and m.direct land asynchronously from the IndexedDB store, so
// watch for them while loading and hide as soon as the chats are populated.
useEffect(() => {
if (!mx || !loading) return undefined;
const check = () => tryHide('chats populated');
check();
console.log(
'[ClientRoot] Splash gate:',
mx.getSyncState(),
`${roomsAtom.length} rooms in atom`,
`${directsAtom.size} m.direct`
);
// Prepared can fire before this listener attaches, so look at the current
// state too, and never let the splash outlive the deadline.
const syncState = mx.getSyncState();
if (syncState === SyncState.Prepared || syncState === SyncState.Syncing) check();
if (splashDeadline.current === undefined) {
splashDeadline.current = window.setTimeout(() => {
splashDeadline.current = undefined;
scheduleHide('deadline reached, showing whatever the cache has');
}, 10000);
}
const poll = window.setInterval(check, 400);
mx.on(ClientEvent.Room, check);
mx.on(ClientEvent.AccountData, check);
return () => {
window.clearInterval(poll);
mx.removeListener(ClientEvent.Room, check);
mx.removeListener(ClientEvent.AccountData, check);
};
}, [mx, loading, chatsReady, tryHide, scheduleHide, roomsAtom, directsAtom]);
// Timeout if sync takes too long - nudge the client rather than immediately erroring
useEffect(() => {
if (!mx || !loading) return;
const timeout = setTimeout(() => {
console.warn('[ClientRoot] Sync taking too long, nudging client...');
mx.retryImmediately();
}, 30000);
return () => clearTimeout(timeout);
}, [mx, loading]);
// Hold the splash until the chats are actually populated, then keep it a
// moment longer so the space particles finish animating.
// Soft-recover from sync ERROR (e.g. sleep/wake with no network); the grace
// window ensures we never block the UI when offline.
useSyncState(
mx,
useCallback((state, prevState, data) => {
const client = mxRef.current;
if (state === SyncState.Prepared || state === SyncState.Syncing) {
if (state === SyncState.Prepared) {
console.log(
'[ClientRoot] Prepared from',
prevState ?? 'nothing',
data?.fromCache ? '(cache)' : '(network)'
);
}
if (tryHide(data?.fromCache ? 'cache populated' : 'first network sync')) {
return;
}
if (data?.fromCache) {
// Cache-only prepared: the room list is still being restored, so wait
// for it, but hide anyway once the grace expires so we never block the
// UI when offline.
if (firstNetworkSyncGrace.current === undefined) {
firstNetworkSyncGrace.current = window.setTimeout(() => {
firstNetworkSyncGrace.current = undefined;
scheduleHide('cache grace expired');
}, 5000);
}
} else {
// First network sync completed: whatever we have is what the UI shows.
scheduleHide('first network sync completed');
}
recoverInFlight.current = false;
return;
}
if (state !== SyncState.Error || !client) {
return;
}
// Sync failed (no network, first sync never landed). Show whatever the
// cache restored instead of leaving the splash up.
if (client.getRooms().length > 0) scheduleHide('sync error with cached chats');
if (recoverInFlight.current) {
return;
}
recoverInFlight.current = true;
console.warn('[ClientRoot] Sync error after sleep/network blip, soft-recovering...');
const recover = () => {
if (!mxRef.current) {
recoverInFlight.current = false;
return;
}
const c = mxRef.current;
if (!c.clientRunning) {
startClient(c)
.catch((err) => console.warn('[ClientRoot] Soft recover startClient failed:', err))
.finally(() => {
recoverInFlight.current = false;
});
return;
}
try {
c.retryImmediately();
} catch (err) {
console.warn('[ClientRoot] Soft recover retryImmediately failed:', err);
}
recoverInFlight.current = false;
};
// Give Wi‑Fi a moment to come back after lid open / resume
window.setTimeout(recover, 1500);
}, [tryHide, scheduleHide])
);
// Also nudge sync when the laptop wakes / network returns
useEffect(() => {
if (!mx) return;
const nudge = () => {
if (document.visibilityState !== 'visible') return;
const syncState = mx.getSyncState();
if (syncState === SyncState.Error || syncState === SyncState.Reconnecting || !mx.clientRunning) {
console.log('[ClientRoot] Online/visible again, nudging sync', syncState);
if (!mx.clientRunning) {
startClient(mx).catch(() => {});
} else {
mx.retryImmediately();
}
}
};
window.addEventListener('online', nudge);
document.addEventListener('visibilitychange', nudge);
return () => {
window.removeEventListener('online', nudge);
document.removeEventListener('visibilitychange', nudge);
};
}, [mx]);
return (
<SpecVersions baseUrl={baseUrl!}>
<TitleBar mx={mx} />
{mx && <ClientAtomBinder mx={mx} />}
{(loadState.status === AsyncStatus.Error || startState.status === AsyncStatus.Error) && (
<SplashScreen>
<Box direction="Column" grow="Yes" alignItems="Center" justifyContent="Center" gap="400">
<Dialog>
<Box direction="Column" gap="400" style={{ padding: config.space.S400 }}>
{loadState.status === AsyncStatus.Error && (
<Text>{`Failed to load. ${loadState.error.message}`}</Text>
)}
{startState.status === AsyncStatus.Error && (
<Text>{`Failed to start. ${startState.error.message}`}</Text>
)}
<Button variant="Critical" onClick={mx ? () => startMatrix(mx) : loadMatrix}>
<Text as="span" size="B400">
Retry
</Text>
</Button>
</Box>
</Dialog>
</Box>
</SplashScreen>
)}
{loading || !mx ? (
<ClientLoading mx={mx} />
) : (
<MatrixClientProvider value={mx}>
<PluginLoader matrixClient={mx}>
<CallProviderWrapper>
<ServerConfigsLoader>
{(serverConfigs) => (
<CapabilitiesProvider value={serverConfigs.capabilities ?? {}}>
<MediaConfigProvider value={serverConfigs.mediaConfig ?? {}}>
<AuthMetadataProvider value={serverConfigs.authMetadata}>
{children}
</AuthMetadataProvider>
</MediaConfigProvider>
</CapabilitiesProvider>
)}
</ServerConfigsLoader>
</CallProviderWrapper>
</PluginLoader>
</MatrixClientProvider>
)}
</SpecVersions>
);
}