('window-tracking', (event) => {
+ const eventType = event.payload?.event_type;
+ if (eventType === 'TargetLost' || eventType === 'Timeout') {
+ hideSnapOverlay();
+ }
+ })
+ .then((removeListener) => {
+ unlistenTracking = removeListener;
+ })
+ .catch((error) => {
+ log.warn('Failed to subscribe to window-tracking event:', error);
+ });
+
+ return () => {
+ mounted = false;
+ if (snapTimerRef.current !== undefined) {
+ window.clearTimeout(snapTimerRef.current);
+ }
+ stopWindowTracking().catch(() => {});
+ hideSnapOverlay();
+ unlistenResize?.();
+ unlistenTracking?.();
+ };
+ }, [isWindowsDesktopTauri]);
+
+ if (!isWindowsDesktopTauri) return null;
+
+ const minimize = () => {
+ if (!isWindowsDesktopTauri) return;
+
+ stopWindowTracking().catch(() => {});
+ hideSnapOverlay();
+ appWindowRef.current?.minimize().catch((error) => {
+ log.warn('Failed to minimize window:', error);
+ });
+ };
+
+ const toggleMaximize = () => {
+ if (!isWindowsDesktopTauri) return;
+
+ if (snapTimerRef.current !== undefined) {
+ window.clearTimeout(snapTimerRef.current);
+ snapTimerRef.current = undefined;
+ }
+
+ stopWindowTracking().catch(() => {});
+ hideSnapOverlay();
+ appWindowRef.current?.toggleMaximize().catch((error) => {
+ log.warn('Failed to toggle maximize:', error);
+ });
+ };
+
+ const close = () => {
+ if (!isWindowsDesktopTauri) return;
+
+ stopWindowTracking().catch(() => {});
+ hideSnapOverlay();
+ appWindowRef.current?.close().catch((error) => {
+ log.warn('Failed to close window:', error);
+ });
+ };
+
+ const showSnapOverlay = () => {
+ if (!isWindowsDesktopTauri) return;
+
+ if (snapTimerRef.current !== undefined) {
+ window.clearTimeout(snapTimerRef.current);
+ }
+ stopWindowTracking().catch(() => {});
+
+ snapTimerRef.current = window.setTimeout(() => {
+ appWindowRef.current
+ ?.setFocus()
+ .then(() => showSnapOverlayCommand())
+ .catch((error) => {
+ log.warn('Failed to show snap overlay:', error);
+ });
+ }, SNAP_OVERLAY_DELAY_MS);
+ };
+
+ const cancelSnapOverlay = () => {
+ if (!isWindowsDesktopTauri) return;
+
+ if (snapTimerRef.current !== undefined) {
+ window.clearTimeout(snapTimerRef.current);
+ snapTimerRef.current = undefined;
+ }
+
+ stopWindowTracking()
+ .then(() =>
+ startWindowTrackingWithTarget({
+ target: {
+ window_class: SNAP_POPUP_WINDOW_CLASS,
+ exe_name: SNAP_POPUP_EXE,
+ },
+ })
+ )
+ .catch((error) => {
+ log.warn('Failed to start snap popup tracking:', error);
+ });
+ };
+
+ return (
+
+ );
+}
diff --git a/src/app/components/user-avatar/UserAvatar.tsx b/src/app/components/user-avatar/UserAvatar.tsx
index 3659cb305..629f4a654 100644
--- a/src/app/components/user-avatar/UserAvatar.tsx
+++ b/src/app/components/user-avatar/UserAvatar.tsx
@@ -2,6 +2,7 @@ import { AvatarFallback, AvatarImage, color } from 'folds';
import { ReactEventHandler, ReactNode, useState } from 'react';
import classNames from 'classnames';
import colorMXID from '$utils/colorMXID';
+import { useMediaSrc } from '$hooks/useMediaSrc';
import * as css from './UserAvatar.css';
type UserAvatarProps = {
@@ -13,6 +14,7 @@ type UserAvatarProps = {
};
export function UserAvatar({ className, userId, src, alt, renderFallback }: UserAvatarProps) {
const [error, setError] = useState(false);
+ const resolvedSrc = useMediaSrc(src);
const handleLoad: ReactEventHandler = (evt) => {
evt.currentTarget.setAttribute('data-image-loaded', 'true');
@@ -32,7 +34,7 @@ export function UserAvatar({ className, userId, src, alt, renderFallback }: User
return (
setError(true)}
onLoad={handleLoad}
diff --git a/src/app/components/user-profile/UserHero.tsx b/src/app/components/user-profile/UserHero.tsx
index 0acdc3618..903552ac3 100644
--- a/src/app/components/user-profile/UserHero.tsx
+++ b/src/app/components/user-profile/UserHero.tsx
@@ -24,6 +24,7 @@ import { useRoom } from '$hooks/useRoom';
import { useSableCosmetics } from '$hooks/useSableCosmetics';
import { useNickname } from '$hooks/useNickname';
import { useBlobCache } from '$hooks/useBlobCache';
+import { useMediaDownloadToken } from '$hooks/useMediaSrc';
import { ImageViewer } from '$components/image-viewer';
import { AvatarPresence, PresenceBadge } from '$components/presence';
import { UserAvatar } from '$components/user-avatar';
@@ -41,8 +42,9 @@ export function UserHero({ userId, avatarUrl, bannerUrl, presence, autoplayGifs
const [viewAvatar, setViewAvatar] = useState();
const [isFullStatus, setIsFullStatus] = useState(false);
- const cachedBannerUrl = useBlobCache(bannerUrl);
- const cachedAvatarUrl = useBlobCache(avatarUrl);
+ const mediaToken = useMediaDownloadToken();
+ const cachedBannerUrl = useBlobCache(bannerUrl, mediaToken);
+ const cachedAvatarUrl = useBlobCache(avatarUrl, mediaToken);
const coverUrl = cachedBannerUrl || cachedAvatarUrl;
const isFallbackCover = !cachedBannerUrl && !!cachedAvatarUrl;
diff --git a/src/app/features/common-settings/emojis-stickers/RoomPacks.tsx b/src/app/features/common-settings/emojis-stickers/RoomPacks.tsx
index 6162e4c0b..af14ff83b 100644
--- a/src/app/features/common-settings/emojis-stickers/RoomPacks.tsx
+++ b/src/app/features/common-settings/emojis-stickers/RoomPacks.tsx
@@ -32,6 +32,7 @@ import { SettingTile } from '$components/setting-tile';
import { useMatrixClient } from '$hooks/useMatrixClient';
import { mxcUrlToHttp } from '$utils/matrix';
import { useMediaAuthentication } from '$hooks/useMediaAuthentication';
+import { useMediaSrc } from '$hooks/useMediaSrc';
import { usePowerLevels } from '$hooks/usePowerLevels';
import { StateEvent } from '$types/matrix/room';
import { suffixRename } from '$utils/common';
@@ -41,6 +42,11 @@ import { useRoomCreators } from '$hooks/useRoomCreators';
import { useRoomPermissions } from '$hooks/useRoomPermissions';
import { SequenceCardStyle } from '$features/common-settings/styles.css';
+function PackAvatarImage({ url }: { url: string }) {
+ const resolved = useMediaSrc(url);
+ return ;
+}
+
type CreatePackTileProps = {
packs: ImagePack[];
roomId: string;
@@ -236,7 +242,7 @@ export function RoomPacks({ onViewPack }: Readonly) {
))}
{avatarUrl ? (
-
+
) : (
diff --git a/src/app/features/room/message/Message.tsx b/src/app/features/room/message/Message.tsx
index 4bfab3bbb..b84c2c23b 100644
--- a/src/app/features/room/message/Message.tsx
+++ b/src/app/features/room/message/Message.tsx
@@ -74,6 +74,7 @@ import { mobileOrTablet } from '$utils/user-agent';
import { useUserProfile } from '$hooks/useUserProfile';
import { useSetting } from '$state/hooks/settings';
import { useBlobCache } from '$hooks/useBlobCache';
+import { useMediaDownloadToken } from '$hooks/useMediaSrc';
import { MessageAllReactionItem } from '$components/message/modals/MessageReactions';
import { MessageReadReceiptItem } from '$components/message/modals/MessageReadRecipts';
import { MessageEditHistoryItem } from '$components/message/modals/MessageEditHistory';
@@ -381,6 +382,7 @@ function MessageInternal(
) {
const mx = useMatrixClient();
const useAuthentication = useMediaAuthentication();
+ const mediaToken = useMediaDownloadToken();
const [contentVersion, setContentVersion] = useState(0);
@@ -467,7 +469,7 @@ function MessageInternal(
return mxc ? mxcUrlToHttp(mx, mxc, useAuthentication, 48, 48, 'crop') : undefined;
}, [pmp, collapse, profile.avatarUrl, senderId, mx, room, useAuthentication]);
- const cachedAvatar = useBlobCache(avatarUrl ?? undefined);
+ const cachedAvatar = useBlobCache(avatarUrl ?? undefined, mediaToken);
// UI State
const [isDesktopHover, setIsDesktopHover] = useState(false);
diff --git a/src/app/features/settings/Settings.tsx b/src/app/features/settings/Settings.tsx
index 2dd1e4ae4..46cb3f4f4 100644
--- a/src/app/features/settings/Settings.tsx
+++ b/src/app/features/settings/Settings.tsx
@@ -14,6 +14,7 @@ import {
OverlayCenter,
Text,
} from 'folds';
+import { isTauri } from '@tauri-apps/api/core';
import FocusTrap from 'focus-trap-react';
import { PageNav, PageNavContent, PageNavHeader, PageRoot } from '$components/page';
import { ScreenSize, useScreenSizeContext } from '$hooks/useScreenSize';
@@ -38,6 +39,7 @@ import { General } from './general';
import { Cosmetics } from './cosmetics/Cosmetics';
import { Experimental } from './experimental/Experimental';
import { KeyboardShortcuts } from './keyboard-shortcuts';
+import { Desktop } from './desktop';
import { PerMessageProfilePage } from './Persona/ProfilesPage';
export enum SettingsPages {
@@ -46,6 +48,7 @@ export enum SettingsPages {
PerMessageProfilesPage,
NotificationPage,
DevicesPage,
+ DesktopPage,
EmojisStickersPage,
CosmeticsPage,
DeveloperToolsPage,
@@ -90,6 +93,15 @@ const useSettingsMenuItems = (showPersona: boolean): SettingsMenuItem[] =>
name: 'Devices',
icon: Icons.Monitor,
},
+ ...(isTauri()
+ ? [
+ {
+ page: SettingsPages.DesktopPage,
+ name: 'Desktop',
+ icon: Icons.Monitor,
+ },
+ ]
+ : []),
{
page: SettingsPages.EmojisStickersPage,
name: 'Emojis & Stickers',
@@ -278,6 +290,9 @@ export function Settings({ initialPage, requestClose }: SettingsProps) {
{activePage === SettingsPages.DevicesPage && (
)}
+ {activePage === SettingsPages.DesktopPage && (
+
+ )}
{activePage === SettingsPages.EmojisStickersPage && (
)}
diff --git a/src/app/features/settings/desktop/Desktop.tsx b/src/app/features/settings/desktop/Desktop.tsx
new file mode 100644
index 000000000..0efaf3cf4
--- /dev/null
+++ b/src/app/features/settings/desktop/Desktop.tsx
@@ -0,0 +1,61 @@
+import { isTauri } from '@tauri-apps/api/core';
+import { Box, Text, IconButton, Icon, Icons, Scroll, Switch } from 'folds';
+import { Page, PageContent, PageHeader } from '$components/page';
+import { SequenceCard } from '$components/sequence-card';
+import { SettingTile } from '$components/setting-tile';
+import { useSetting } from '$state/hooks/settings';
+import { settingsAtom } from '$state/settings';
+import { SequenceCardStyle } from '$features/settings/styles.css';
+
+type DesktopProps = {
+ requestClose: () => void;
+};
+
+export function Desktop({ requestClose }: DesktopProps) {
+ const [closeToTray, setCloseToTray] = useSetting(settingsAtom, 'closeToTray');
+
+ if (!isTauri()) return null;
+
+ return (
+
+
+
+
+
+ Desktop
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Window
+
+
+ }
+ />
+
+
+
+
+
+
+
+ );
+}
diff --git a/src/app/features/settings/desktop/index.ts b/src/app/features/settings/desktop/index.ts
new file mode 100644
index 000000000..71f2ecc9f
--- /dev/null
+++ b/src/app/features/settings/desktop/index.ts
@@ -0,0 +1 @@
+export * from './Desktop';
diff --git a/src/app/features/settings/emojis-stickers/GlobalPacks.tsx b/src/app/features/settings/emojis-stickers/GlobalPacks.tsx
index 1c66d4c6f..66df642eb 100644
--- a/src/app/features/settings/emojis-stickers/GlobalPacks.tsx
+++ b/src/app/features/settings/emojis-stickers/GlobalPacks.tsx
@@ -29,6 +29,7 @@ import { SequenceCard } from '$components/sequence-card';
import { SettingTile } from '$components/setting-tile';
import { mxcUrlToHttp } from '$utils/matrix';
import { useMediaAuthentication } from '$hooks/useMediaAuthentication';
+import { useMediaSrc } from '$hooks/useMediaSrc';
import { useMatrixClient } from '$hooks/useMatrixClient';
import {
EmoteRoomsContent,
@@ -44,6 +45,11 @@ import { AsyncStatus, useAsyncCallback } from '$hooks/useAsyncCallback';
import { stopPropagation } from '$utils/keyboard';
import { SequenceCardStyle } from '$features/settings/styles.css';
+function PackAvatarImage({ url }: { url: string }) {
+ const resolved = useMediaSrc(url);
+ return ;
+}
+
function GlobalPackSelector({
packs,
useAuthentication,
@@ -190,7 +196,7 @@ function GlobalPackSelector({
{avatarUrl ? (
-
+
) : (
@@ -389,7 +395,7 @@ export function GlobalPacks({ onViewPack }: GlobalPacksProps) {
)}
{avatarUrl ? (
-
+
) : (
diff --git a/src/app/features/settings/emojis-stickers/UserPack.tsx b/src/app/features/settings/emojis-stickers/UserPack.tsx
index 03c80da2f..36b71e29a 100644
--- a/src/app/features/settings/emojis-stickers/UserPack.tsx
+++ b/src/app/features/settings/emojis-stickers/UserPack.tsx
@@ -6,6 +6,7 @@ import { ImagePack, ImageUsage } from '$plugins/custom-emoji';
import { useMatrixClient } from '$hooks/useMatrixClient';
import { mxcUrlToHttp } from '$utils/matrix';
import { useMediaAuthentication } from '$hooks/useMediaAuthentication';
+import { useMediaSrc } from '$hooks/useMediaSrc';
import { SequenceCardStyle } from '$features/settings/styles.css';
type UserPackProps = {
@@ -18,6 +19,7 @@ export function UserPack({ onViewPack }: UserPackProps) {
const userPack = useUserImagePack();
const avatarMxc = userPack?.getAvatarUrl(ImageUsage.Emoticon);
const avatarUrl = avatarMxc ? mxcUrlToHttp(mx, avatarMxc, useAuthentication) : undefined;
+ const resolvedAvatarUrl = useMediaSrc(avatarUrl ?? undefined);
const handleView = () => {
if (userPack) {
@@ -43,7 +45,10 @@ export function UserPack({ onViewPack }: UserPackProps) {
before={
{avatarUrl ? (
-
+
) : (
diff --git a/src/app/features/settings/notifications/Notifications.tsx b/src/app/features/settings/notifications/Notifications.tsx
index f8935b782..e034f6743 100644
--- a/src/app/features/settings/notifications/Notifications.tsx
+++ b/src/app/features/settings/notifications/Notifications.tsx
@@ -1,9 +1,11 @@
import { Box, Text, IconButton, Icon, Icons, Scroll } from 'folds';
import { Page, PageContent, PageHeader } from '$components/page';
+import { isTauri } from '@tauri-apps/api/core';
import { SystemNotification } from './SystemNotification';
import { AllMessagesNotifications } from './AllMessages';
import { SpecialMessagesNotifications } from './SpecialMessages';
import { KeywordMessagesNotifications } from './KeywordMessages';
+import UnifiedPushNotificationSetting from './UnifiedPushNotificationSetting';
type NotificationsProps = {
requestClose: () => void;
@@ -30,6 +32,7 @@ export function Notifications({ requestClose }: NotificationsProps) {
+ {isTauri() && }
diff --git a/src/app/features/settings/notifications/PushNotifications.tsx b/src/app/features/settings/notifications/PushNotifications.tsx
index 46c0ebb0d..e35c9fbf0 100644
--- a/src/app/features/settings/notifications/PushNotifications.tsx
+++ b/src/app/features/settings/notifications/PushNotifications.tsx
@@ -1,5 +1,6 @@
import { MatrixClient } from '$types/matrix-sdk';
import { createDebugLogger } from '$utils/debugLogger';
+import { isTauri } from '@tauri-apps/api/core';
import { ClientConfig } from '../../../hooks/useClientConfig';
const debugLog = createDebugLogger('PushNotifications');
@@ -32,6 +33,9 @@ export async function enablePushNotifications(
clientConfig: ClientConfig,
pushSubscriptionAtom: PushSubscriptionState
): Promise {
+ if (isTauri()) {
+ throw new Error('Push notifications are disabled in Tauri runtime.');
+ }
if (!('serviceWorker' in navigator) || !('PushManager' in window)) {
debugLog.error(
'notification',
@@ -135,6 +139,8 @@ export async function disablePushNotifications(
clientConfig: ClientConfig,
pushSubscriptionAtom: PushSubscriptionState
): Promise {
+ if (isTauri()) return;
+
debugLog.info('notification', 'Disabling push notifications');
const [pushSubAtom] = pushSubscriptionAtom;
diff --git a/src/app/features/settings/notifications/SystemNotification.tsx b/src/app/features/settings/notifications/SystemNotification.tsx
index c9b59549a..6dd1ea1c3 100644
--- a/src/app/features/settings/notifications/SystemNotification.tsx
+++ b/src/app/features/settings/notifications/SystemNotification.tsx
@@ -229,18 +229,20 @@ export function SystemNotification() {
return (
System & Notifications
-
- }
- />
-
+ {mobileOrTablet() && (
+
+ }
+ />
+
+ )}
{mobileOrTablet() && (
(null);
+ const [distributors, setDistributors] = useState([]);
+ const [currentDistributor, setCurrentDistributor] = useState('');
+ const [menuCords, setMenuCords] = useState();
+
+ useEffect(() => {
+ Promise.all([
+ getUnifiedPushDistributors().catch(() => ({ distributors: [] as string[] })),
+ getUnifiedPushDistributor().catch(() => ({ distributor: '' })),
+ ]).then(async ([distResult, savedResult]) => {
+ setDistributors(distResult.distributors);
+ setCurrentDistributor(savedResult.distributor);
+
+ // Auto-save the only available distributor when none is saved yet.
+ // UP connector 3.x requires an explicit selection before register() works.
+ if (!savedResult.distributor && distResult.distributors.length === 1) {
+ await saveUnifiedPushDistributor(distResult.distributors[0]);
+ setCurrentDistributor(distResult.distributors[0]);
+ }
+ });
+ }, []);
+
+ const handleToggle = async (wantsUP: boolean) => {
+ setIsLoading(true);
+ setError(null);
+ try {
+ if (wantsUP) {
+ if (!currentDistributor && distributors.length > 0) {
+ await saveUnifiedPushDistributor(distributors[0]);
+ setCurrentDistributor(distributors[0]);
+ }
+
+ const result = await enableUnifiedPush(mx, clientConfig);
+ setUpEndpoint(result);
+ setUseUP(true);
+ } else {
+ await disableUnifiedPush(mx, clientConfig, upEndpoint?.endpoint);
+ setUpEndpoint(null);
+ setUseUP(false);
+ }
+ } catch (e) {
+ const msg = e instanceof Error ? e.message : String(e);
+ console.error('UnifiedPush toggle failed:', e);
+ setError(msg);
+ } finally {
+ setIsLoading(false);
+ }
+ };
+
+ const handleSelectDistributor = async (distributor: string) => {
+ setMenuCords(undefined);
+ if (distributor === currentDistributor) return;
+ setIsLoading(true);
+ try {
+ if (useUP) {
+ await disableUnifiedPush(mx, clientConfig, upEndpoint?.endpoint);
+ }
+ await saveUnifiedPushDistributor(distributor);
+ setCurrentDistributor(distributor);
+ if (useUP) {
+ const result = await enableUnifiedPush(mx, clientConfig);
+ setUpEndpoint(result);
+ }
+ } catch (e) {
+ console.error('Distributor switch failed:', e);
+ } finally {
+ setIsLoading(false);
+ }
+ };
+
+ const distributorLabel = (pkg: string) => {
+ const parts = pkg.split('.');
+ return parts[parts.length - 1] ?? pkg;
+ };
+
+ const handleDistributorMenu: MouseEventHandler = (evt) => {
+ setMenuCords(evt.currentTarget.getBoundingClientRect());
+ };
+
+ return (
+ <>
+
+ {error}
+
+ ) : distributors.length === 0 ? (
+
+ No UnifiedPush distributor installed. Install one (e.g. ntfy, NextPush) to use this
+ feature.
+
+ ) : (
+ 'Receive background notifications via UnifiedPush without Google Services.'
+ )
+ }
+ after={
+ isLoading ? (
+
+ ) : (
+
+ )
+ }
+ />
+ {distributors.length > 1 && (
+
+ setMenuCords(undefined),
+ clickOutsideDeactivates: true,
+ escapeDeactivates: stopPropagation,
+ }}
+ >
+
+
+ }
+ />
+
+
+ }
+ />
+ )}
+
+ );
+}
diff --git a/src/app/features/settings/notifications/UnifiedPushNotifications.ts b/src/app/features/settings/notifications/UnifiedPushNotifications.ts
new file mode 100644
index 000000000..a6ce21c35
--- /dev/null
+++ b/src/app/features/settings/notifications/UnifiedPushNotifications.ts
@@ -0,0 +1,529 @@
+import { MatrixClient } from '$types/matrix-sdk';
+import { ClientConfig } from '$hooks/useClientConfig';
+import {
+ registerForUnifiedPush,
+ unregisterFromUnifiedPush,
+ getUnifiedPushDistributors,
+ saveUnifiedPushDistributor,
+ getUnifiedPushDistributor,
+ onUnifiedPushMessage,
+ onUnifiedPushEndpoint,
+ sendNotification,
+ removeActive,
+ createChannel,
+ Importance,
+} from '@sableclient/tauri-plugin-notifications-api';
+import type {
+ MessagingStyleMessage,
+ MessagingStylePerson,
+} from '@sableclient/tauri-plugin-notifications-api';
+import { EventType } from 'matrix-js-sdk/lib/@types/event';
+import { resolveNotificationPreviewText } from '$utils/notificationStyle';
+import { getMxIdLocalPart } from '$utils/matrix';
+import { getStateEvent, getMemberAvatarMxc } from '$utils/room';
+import { StateEvent } from '$types/matrix/room';
+
+export { getUnifiedPushDistributors, getUnifiedPushDistributor, saveUnifiedPushDistributor };
+
+const UP_PUBLIC_GATEWAY = 'https://matrix.gateway.unifiedpush.org/_matrix/push/v1/notify';
+
+/**
+ * Probes the UP endpoint for a Matrix-compatible push gateway.
+ * Falls back to the configured or public UP gateway.
+ * Note: pushNotifyUrl (Sygnal) is NOT suitable — only a proper UP gateway works.
+ */
+async function discoverGateway(upEndpoint: string, unifiedPushGateway?: string): Promise {
+ try {
+ const probeUrl = new URL(upEndpoint);
+ probeUrl.pathname = '/_matrix/push/v1/notify';
+ probeUrl.search = '';
+ const res = await fetch(probeUrl.toString());
+ if (res.ok) {
+ const body = await res.json();
+ if (
+ body?.gateway === 'matrix' ||
+ (body?.unifiedpush && body.unifiedpush.gateway === 'matrix')
+ ) {
+ return probeUrl.toString();
+ }
+ }
+ } catch {
+ // probe failed
+ }
+ return unifiedPushGateway ?? UP_PUBLIC_GATEWAY;
+}
+
+const UP_REGISTER_TIMEOUT_MS = 30_000;
+
+export async function enableUnifiedPush(
+ mx: MatrixClient,
+ clientConfig: ClientConfig
+): Promise<{ endpoint: string; instance: string }> {
+ await createChannel({
+ id: 'messages',
+ name: 'Messages',
+ description: 'Matrix message and invite notifications',
+ importance: Importance.Default,
+ vibration: true,
+ });
+
+ const timeout = new Promise((_, reject) => {
+ const id = setTimeout(() => {
+ reject(new Error('UnifiedPush registration timed out'));
+ clearTimeout(id);
+ }, UP_REGISTER_TIMEOUT_MS);
+ });
+ const { endpoint, instance, pubKeySet } = await Promise.race([registerForUnifiedPush(), timeout]);
+
+ const appId = clientConfig.pushNotificationDetails?.unifiedPushAppID ?? 'moe.sable.up';
+
+ // Don't fall back to pushNotifyUrl (Sygnal) — it cannot forward to UP endpoints.
+ const unifiedPushGateway = clientConfig.pushNotificationDetails?.unifiedPushGatewayUrl;
+
+ const gatewayUrl = await discoverGateway(endpoint, unifiedPushGateway);
+
+ const pusherData: Record = {
+ url: gatewayUrl,
+ };
+
+ // VAPID-capable distributors (e.g. NextPush) provide keys for RFC 8291 encryption.
+ if (pubKeySet) {
+ pusherData.p256dh = pubKeySet.pubKey;
+ pusherData.auth = pubKeySet.auth;
+ }
+
+ await mx.setPusher({
+ kind: 'http',
+ app_id: appId,
+ pushkey: endpoint,
+ app_display_name: 'Sable (UnifiedPush)',
+ device_display_name:
+ (await mx.getDevice(mx.getDeviceId() ?? '')).display_name ?? 'Android Device',
+ lang: navigator.language || 'en',
+ data: pusherData,
+ append: false,
+ } as any);
+
+ return { endpoint, instance };
+}
+
+export async function disableUnifiedPush(
+ mx: MatrixClient,
+ clientConfig: ClientConfig,
+ pushkey?: string
+): Promise {
+ const appId = clientConfig.pushNotificationDetails?.unifiedPushAppID ?? 'moe.sable.up';
+
+ if (pushkey) {
+ await mx.setPusher({
+ kind: null,
+ app_id: appId,
+ pushkey,
+ } as any);
+ }
+
+ await unregisterFromUnifiedPush();
+}
+
+type NotificationSettings = {
+ mx: MatrixClient;
+ showMessageContent: boolean;
+ showEncryptedMessageContent: boolean;
+ notificationSoundEnabled: boolean;
+ useInAppNotifications: boolean;
+};
+
+// One MessagingStyle notification per room, accumulated into a single Android group.
+
+const NOTIF_GROUP_KEY = 'matrix_messages';
+const MAX_MESSAGES = 10;
+
+function hashCode(str: string): number {
+ let hash = 0;
+ for (let i = 0; i < str.length; i += 1) {
+ // eslint-disable-next-line no-bitwise
+ hash = (Math.imul(31, hash) + str.charCodeAt(i)) | 0;
+ }
+ return Math.abs(hash);
+}
+
+const roomNotifId = (roomId: string) => hashCode(roomId);
+const SUMMARY_NOTIF_ID = hashCode('sable-group-summary');
+
+/** Accumulated messages per room, cleared when unread drops to 0. */
+type RoomNotifCache = {
+ roomName: string;
+ messages: MessagingStyleMessage[];
+ seenEventIds: Set;
+ isGroupConversation: boolean;
+ latestEventId?: string;
+};
+
+const roomNotifCaches = new Map();
+
+/**
+ * Resolves a user avatar to an HTTP URL for notification display.
+ *
+ * Returns an authenticated media URL (/_matrix/client/v1/media/).
+ * The plugin's Kotlin layer downloads the image using the `authToken`
+ * supplied in `MessagingStyleConfig`, so authenticated endpoints work.
+ */
+function resolveAvatarUrl(mx: MatrixClient, roomId: string, userId: string): string | undefined {
+ const room = mx.getRoom(roomId);
+ if (!room) return undefined;
+ const mxcUrl = getMemberAvatarMxc(room, userId);
+ if (!mxcUrl) return undefined;
+ return mx.mxcUrlToHttp(mxcUrl, 96, 96, 'crop', false, true, true) ?? undefined;
+}
+
+function getOrCreateRoomCache(roomId: string, roomName: string): RoomNotifCache {
+ let cache = roomNotifCaches.get(roomId);
+ if (!cache) {
+ cache = { roomName, messages: [], seenEventIds: new Set(), isGroupConversation: false };
+ roomNotifCaches.set(roomId, cache);
+ }
+ cache.roomName = roomName;
+ return cache;
+}
+
+/** Clears accumulated messages for a room and dismisses its notification. */
+export async function clearRoomNotification(roomId: string) {
+ roomNotifCaches.delete(roomId);
+ try {
+ await removeActive([{ id: roomNotifId(roomId) }]);
+ } catch {
+ // already dismissed
+ }
+ if (roomNotifCaches.size <= 1) {
+ try {
+ await removeActive([{ id: SUMMARY_NOTIF_ID }]);
+ } catch {
+ // ignore
+ }
+ }
+}
+
+/** Posts (or updates) the per-room MessagingStyle notification and the group summary. */
+async function postRoomNotification(
+ roomId: string,
+ cache: RoomNotifCache,
+ selfUser: MessagingStylePerson,
+ isSilent: boolean,
+ extra: Record,
+ authToken?: string | null
+) {
+ const { messages, roomName, isGroupConversation } = cache;
+ const latestMsg = messages[messages.length - 1];
+ const latestBody = latestMsg ? `${latestMsg.sender?.name ?? 'You'}: ${latestMsg.text}` : '';
+
+ await sendNotification({
+ id: roomNotifId(roomId),
+ title: roomName,
+ body: latestBody,
+ channelId: 'messages',
+ group: NOTIF_GROUP_KEY,
+ icon: 'notification_icon',
+ silent: isSilent,
+ autoCancel: true,
+ extra,
+ messagingStyle: {
+ user: selfUser,
+ conversationTitle: isGroupConversation ? roomName : undefined,
+ isGroupConversation,
+ messages,
+ authToken: authToken ?? undefined,
+ },
+ });
+
+ // App-wide group summary — Android uses this when 4+ child notifications
+ // exist. With only one room there's nothing to summarise, and posting a
+ // summary can cause the OS to show the summary *instead of* the child
+ // MessagingStyle notification on some devices.
+ const roomCount = roomNotifCaches.size;
+ if (roomCount > 1) {
+ const totalMessages = Array.from(roomNotifCaches.values()).reduce(
+ (sum, c) => sum + c.messages.length,
+ 0
+ );
+ const summaryText = `${totalMessages} messages in ${roomCount} chats`;
+ const inboxLines: string[] = [];
+ Array.from(roomNotifCaches.values()).forEach((c) => {
+ const latest = c.messages[c.messages.length - 1];
+ if (latest) {
+ inboxLines.push(`${c.roomName}: ${latest.sender?.name ?? 'You'}: ${latest.text}`);
+ }
+ });
+ await sendNotification({
+ id: SUMMARY_NOTIF_ID,
+ title: summaryText,
+ body: '',
+ summary: summaryText,
+ inboxLines: inboxLines.slice(-5),
+ channelId: 'messages',
+ group: NOTIF_GROUP_KEY,
+ groupSummary: true,
+ icon: 'notification_icon',
+ silent: true,
+ autoCancel: true,
+ });
+ }
+}
+
+/** Handles a rich push payload containing full event details (type, room_name, content, etc.). */
+async function handleRichPushPayload(
+ pushData: Record,
+ settings: NotificationSettings
+) {
+ const eventType = pushData.type as EventType;
+
+ switch (eventType) {
+ case EventType.RoomMessage:
+ case EventType.Sticker:
+ case EventType.RoomMessageEncrypted: {
+ const isEncrypted = eventType === EventType.RoomMessageEncrypted;
+
+ const previewText = resolveNotificationPreviewText({
+ content: pushData?.content,
+ eventType: pushData?.type,
+ isEncryptedRoom: isEncrypted,
+ showMessageContent: settings.showMessageContent,
+ showEncryptedMessageContent: settings.showEncryptedMessageContent,
+ });
+
+ const roomId: string | undefined = pushData?.room_id;
+ const roomName: string = pushData?.room_name ?? 'Unknown Room';
+ const senderName: string | undefined = pushData?.sender_display_name;
+ const senderId: string | undefined = pushData?.sender;
+ const isSilent = !settings.notificationSoundEnabled;
+
+ const selfUserId = settings.mx.getUserId() ?? undefined;
+ const selfUser: MessagingStylePerson = {
+ name: 'You',
+ key: selfUserId,
+ iconUrl:
+ selfUserId && roomId ? resolveAvatarUrl(settings.mx, roomId, selfUserId) : undefined,
+ };
+
+ if (!roomId) {
+ await sendNotification({
+ title: roomName,
+ body: senderName ? `${senderName}: ${previewText}` : previewText,
+ channelId: 'messages',
+ icon: 'notification_icon',
+ silent: isSilent,
+ autoCancel: true,
+ });
+ break;
+ }
+
+ const sender: MessagingStylePerson | undefined = senderName
+ ? {
+ name: senderName,
+ key: senderId,
+ iconUrl: senderId ? resolveAvatarUrl(settings.mx, roomId, senderId) : undefined,
+ }
+ : undefined;
+
+ const message: MessagingStyleMessage = {
+ text: previewText,
+ timestamp: Date.now(),
+ sender,
+ };
+
+ const cache = getOrCreateRoomCache(roomId, roomName);
+
+ const eventId: string | undefined = pushData?.event_id;
+ if (eventId && cache.seenEventIds.has(eventId)) break;
+ if (eventId) cache.seenEventIds.add(eventId);
+
+ cache.messages.push(message);
+ if (cache.messages.length > MAX_MESSAGES) {
+ cache.messages = cache.messages.slice(-MAX_MESSAGES);
+ }
+ cache.latestEventId = eventId;
+
+ const room = settings.mx.getRoom(roomId);
+ if (room) {
+ cache.isGroupConversation = (room.getJoinedMemberCount() ?? 0) > 2;
+ }
+
+ await postRoomNotification(
+ roomId,
+ cache,
+ selfUser,
+ isSilent,
+ {
+ room_id: roomId,
+ event_id: pushData?.event_id,
+ user_id: pushData?.user_id,
+ },
+ settings.mx.getAccessToken()
+ );
+ break;
+ }
+ case EventType.RoomMember: {
+ if (pushData?.content?.membership !== 'invite') break;
+ const senderName: string | undefined = pushData?.sender_display_name;
+ const roomName: string | undefined = pushData?.room_name;
+ let body = '';
+ if (senderName && roomName) body = `${senderName} invites you to ${roomName}`;
+ else if (senderName) body = `from ${senderName}`;
+ else if (roomName) body = `to ${roomName}`;
+
+ await sendNotification({
+ title: 'New Invitation',
+ body,
+ channelId: 'messages',
+ group: NOTIF_GROUP_KEY,
+ icon: 'notification_icon',
+ autoCancel: true,
+ extra: {
+ room_id: pushData?.room_id,
+ event_id: pushData?.event_id,
+ user_id: pushData?.user_id,
+ },
+ });
+ break;
+ }
+ default:
+ break;
+ }
+}
+
+/**
+ * Handles a minimal push payload (event_id + room_id + counts) from
+ * the public UnifiedPush gateway, looking up context from local SDK state.
+ */
+async function handleMinimalPushPayload(
+ pushData: Record,
+ settings: NotificationSettings
+) {
+ const roomId: string | undefined = pushData?.room_id;
+ const eventId: string | undefined = pushData?.event_id;
+ const unread: number | undefined =
+ typeof pushData?.counts?.unread === 'number' ? pushData.counts.unread : undefined;
+
+ if (!roomId) return;
+
+ // Unread count of zero means the room was read — dismiss the notification.
+ if (unread === 0) {
+ await clearRoomNotification(roomId);
+ return;
+ }
+
+ const room = settings.mx.getRoom(roomId);
+ const roomName = room?.name ?? 'Unknown Room';
+ const isEncryptedRoom = room ? !!getStateEvent(room, StateEvent.RoomEncryption) : false;
+
+ let senderName: string | undefined;
+ let senderId: string | undefined;
+ let previewText: string | undefined;
+ if (room && eventId) {
+ const timeline = room.getLiveTimeline().getEvents();
+ const mEvent = timeline.find((e) => e.getId() === eventId);
+ if (mEvent) {
+ const sender = mEvent.getSender();
+ if (sender) {
+ const member = room.getMember(sender);
+ senderName = member?.name ?? getMxIdLocalPart(sender) ?? sender;
+ senderId = sender;
+ }
+
+ previewText = resolveNotificationPreviewText({
+ content: mEvent.getContent(),
+ eventType: mEvent.getType(),
+ isEncryptedRoom,
+ showMessageContent: settings.showMessageContent,
+ showEncryptedMessageContent: settings.showEncryptedMessageContent,
+ });
+ }
+ }
+
+ if (!previewText) {
+ previewText = isEncryptedRoom ? 'Encrypted message' : 'New message';
+ }
+
+ const selfUserId = settings.mx.getUserId() ?? undefined;
+ const selfUser: MessagingStylePerson = {
+ name: 'You',
+ key: selfUserId,
+ iconUrl: selfUserId && roomId ? resolveAvatarUrl(settings.mx, roomId, selfUserId) : undefined,
+ };
+
+ const sender: MessagingStylePerson | undefined = senderName
+ ? {
+ name: senderName,
+ key: senderId,
+ iconUrl: senderId && roomId ? resolveAvatarUrl(settings.mx, roomId, senderId) : undefined,
+ }
+ : undefined;
+
+ const message: MessagingStyleMessage = {
+ text: previewText,
+ timestamp: Date.now(),
+ sender,
+ };
+
+ const cache = getOrCreateRoomCache(roomId, roomName);
+
+ if (eventId && cache.seenEventIds.has(eventId)) return;
+ if (eventId) cache.seenEventIds.add(eventId);
+
+ cache.messages.push(message);
+ if (cache.messages.length > MAX_MESSAGES) {
+ cache.messages = cache.messages.slice(-MAX_MESSAGES);
+ }
+ cache.latestEventId = eventId;
+
+ if (room) {
+ cache.isGroupConversation = (room.getJoinedMemberCount() ?? 0) > 2;
+ }
+
+ await postRoomNotification(
+ roomId,
+ cache,
+ selfUser,
+ !settings.notificationSoundEnabled,
+ {
+ room_id: roomId,
+ event_id: eventId,
+ },
+ settings.mx.getAccessToken()
+ );
+}
+
+async function handleUnifiedPushPayload(
+ raw: Record,
+ getSettings: () => NotificationSettings
+) {
+ const settings = getSettings();
+
+ // Skip system notification when in-app banners are active and visible.
+ if (document.visibilityState === 'visible' && settings.useInAppNotifications) {
+ return;
+ }
+
+ // The UP gateway wraps the Matrix push in a `notification` field.
+ const pushData = (raw.notification ?? raw) as Record;
+ const eventType = pushData?.type as EventType | undefined;
+
+ if (eventType) {
+ await handleRichPushPayload(pushData, settings);
+ } else {
+ await handleMinimalPushPayload(pushData, settings);
+ }
+}
+
+export function listenForUnifiedPushMessages(getSettings: () => NotificationSettings) {
+ return onUnifiedPushMessage((data: Record) => {
+ handleUnifiedPushPayload(data, getSettings);
+ });
+}
+
+export function listenForUnifiedPushEndpointChanges(
+ onEndpointChanged: (endpoint: string, instance: string) => void
+) {
+ return onUnifiedPushEndpoint(({ endpoint, instance }) => {
+ onEndpointChanged(endpoint, instance);
+ });
+}
diff --git a/src/app/generated/tauri/.typecache b/src/app/generated/tauri/.typecache
new file mode 100644
index 000000000..185e7a279
--- /dev/null
+++ b/src/app/generated/tauri/.typecache
@@ -0,0 +1,7 @@
+{
+ "version": 1,
+ "commands_hash": "e6c1d6568b5f219",
+ "structs_hash": "985682e49243d7e7",
+ "config_hash": "c72a07caa5bc6ed4",
+ "combined_hash": "e55c2098e174d937"
+}
\ No newline at end of file
diff --git a/src/app/generated/tauri/commands.ts b/src/app/generated/tauri/commands.ts
new file mode 100644
index 000000000..ef5dd3156
--- /dev/null
+++ b/src/app/generated/tauri/commands.ts
@@ -0,0 +1,46 @@
+/**
+ * Auto-generated TypeScript bindings for Tauri commands
+ * Generated by tauri-typegen v0.5.0
+ * Generated at: 2026-03-25T18:25:12.201992200+00:00
+ * Generator: none
+ *
+ * Do not edit manually - regenerate using: cargo tauri-typegen generate
+ */
+
+import { invoke } from '@tauri-apps/api/core';
+import * as types from './types';
+
+export async function startWindowTrackingWithTarget(params: types.StartWindowTrackingWithTargetParams): Promise {
+ return invoke('start_window_tracking_with_target', params);
+}
+
+
+
+export async function stopWindowTracking(): Promise {
+ return invoke('stop_window_tracking');
+}
+
+
+
+export async function isWindowTrackingActive(): Promise {
+ return invoke('is_window_tracking_active');
+}
+
+
+
+export async function showSnapOverlay(): Promise {
+ return invoke('show_snap_overlay');
+}
+
+
+
+export async function hideSnapOverlay(): Promise {
+ return invoke('hide_snap_overlay');
+}
+
+
+export async function setCloseToTrayEnabled(params: types.SetCloseToTrayEnabledParams): Promise {
+ return invoke('set_close_to_tray_enabled', params);
+}
+
+
diff --git a/src/app/generated/tauri/index.ts b/src/app/generated/tauri/index.ts
new file mode 100644
index 000000000..f297bea3e
--- /dev/null
+++ b/src/app/generated/tauri/index.ts
@@ -0,0 +1,11 @@
+/**
+ * Auto-generated TypeScript bindings for Tauri commands
+ * Generated by tauri-typegen v0.5.0
+ * Generated at: 2026-03-25T18:25:12.202453300+00:00
+ * Generator: none
+ *
+ * Do not edit manually - regenerate using: cargo tauri-typegen generate
+ */
+
+export * from './types';
+export * from './commands';
diff --git a/src/app/generated/tauri/types.ts b/src/app/generated/tauri/types.ts
new file mode 100644
index 000000000..efbc83186
--- /dev/null
+++ b/src/app/generated/tauri/types.ts
@@ -0,0 +1,32 @@
+/**
+ * Auto-generated TypeScript bindings for Tauri commands
+ * Generated by tauri-typegen v0.5.0
+ * Generated at: 2026-03-25T18:25:12.199267900+00:00
+ * Generator: none
+ *
+ * Do not edit manually - regenerate using: cargo tauri-typegen generate
+ */
+
+
+
+export interface WindowTarget {
+ window_class?: string | null;
+ exe_name?: string | null;
+}
+
+export interface StartWindowTrackingWithTargetParams {
+ target: WindowTarget;
+ [key: string]: unknown;
+}
+
+
+
+
+
+
+export interface SetCloseToTrayEnabledParams {
+ enabled: boolean;
+ [key: string]: unknown;
+}
+
+
diff --git a/src/app/hooks/useAuthenticatedMediaUrl.ts b/src/app/hooks/useAuthenticatedMediaUrl.ts
new file mode 100644
index 000000000..6d378c6de
--- /dev/null
+++ b/src/app/hooks/useAuthenticatedMediaUrl.ts
@@ -0,0 +1,90 @@
+import { useState, useEffect } from 'react';
+import { hasServiceWorker } from '$utils/platform';
+import { authenticatedMediaFetch } from '$utils/matrix';
+import { getFromMediaCache, putInMediaCache } from '$utils/mediaCache';
+
+const blobCache = new Map();
+const inflightRequests = new Map>();
+
+/**
+ * On platforms without a service worker (e.g. Android WebViews), fetches
+ * media with the access token and returns a blob: URL.
+ * When a SW is available the original URL is returned unchanged.
+ */
+export function useAuthenticatedMediaUrl(
+ url: string | undefined,
+ accessToken: string | null | undefined
+): string | undefined {
+ const needsBlob = !hasServiceWorker();
+
+ const [blobUrl, setBlobUrl] = useState(() => {
+ if (!url) return undefined;
+ if (!needsBlob) return url;
+ return blobCache.get(url) ?? undefined;
+ });
+
+ const [sourceUrl, setSourceUrl] = useState(url);
+ if (url !== sourceUrl) {
+ setSourceUrl(url);
+ if (!url) {
+ setBlobUrl(undefined);
+ } else if (!needsBlob) {
+ setBlobUrl(url);
+ } else {
+ setBlobUrl(blobCache.get(url) ?? undefined);
+ }
+ }
+
+ useEffect(() => {
+ if (!url || !needsBlob || blobCache.has(url)) return undefined;
+
+ let cancelled = false;
+
+ const fetchBlob = async () => {
+ let promise = inflightRequests.get(url);
+ if (!promise) {
+ promise = (async () => {
+ const cachedBlob = await getFromMediaCache(url);
+ if (cachedBlob) {
+ const objectUrl = URL.createObjectURL(cachedBlob);
+ blobCache.set(url, objectUrl);
+ return objectUrl;
+ }
+
+ const res = await authenticatedMediaFetch(url, accessToken);
+ if (!res.ok) {
+ inflightRequests.delete(url);
+ return undefined;
+ }
+ const blob = await res.blob();
+ const objectUrl = URL.createObjectURL(blob);
+ blobCache.set(url, objectUrl);
+
+ putInMediaCache(url, blob);
+
+ return objectUrl;
+ })();
+ inflightRequests.set(url, promise);
+ }
+
+ try {
+ const result = await promise;
+ if (!cancelled && result) setBlobUrl(result);
+ } catch {
+ // Silently fail — the image will show as broken.
+ } finally {
+ inflightRequests.delete(url);
+ }
+ };
+
+ fetchBlob();
+
+ return () => {
+ cancelled = true;
+ };
+ }, [url, needsBlob, accessToken]);
+
+ if (!url) return undefined;
+ if (!needsBlob) return url;
+ return blobUrl;
+}
diff --git a/src/app/hooks/useBlobCache.ts b/src/app/hooks/useBlobCache.ts
index 96ac18f74..c6ace3730 100644
--- a/src/app/hooks/useBlobCache.ts
+++ b/src/app/hooks/useBlobCache.ts
@@ -1,4 +1,6 @@
import { useState, useEffect } from 'react';
+import { authenticatedMediaFetch } from '$utils/matrix';
+import { getFromMediaCache, putInMediaCache } from '$utils/mediaCache';
const imageBlobCache = new Map();
const inflightRequests = new Map>();
@@ -7,7 +9,7 @@ export function getBlobCacheStats(): { cacheSize: number; inflightCount: number
return { cacheSize: imageBlobCache.size, inflightCount: inflightRequests.size };
}
-export function useBlobCache(url?: string): string | undefined {
+export function useBlobCache(url?: string, accessToken?: string | null): string | undefined {
const [cacheState, setCacheState] = useState<{ sourceUrl?: string; blobUrl?: string }>({
sourceUrl: url,
blobUrl: url ? imageBlobCache.get(url) : undefined,
@@ -37,20 +39,24 @@ export function useBlobCache(url?: string): string | undefined {
}
const requestPromise = (async () => {
- try {
- const res = await fetch(url, { mode: 'cors' });
- if (!res.ok) {
- throw new Error(`Failed to fetch blob: ${res.status} ${res.statusText}`);
- }
- const blob = await res.blob();
- const objectUrl = URL.createObjectURL(blob);
-
+ const cachedBlob = await getFromMediaCache(url);
+ if (cachedBlob) {
+ const objectUrl = URL.createObjectURL(cachedBlob);
imageBlobCache.set(url, objectUrl);
return objectUrl;
- } catch (e) {
- inflightRequests.delete(url);
- throw e;
}
+
+ const res = await authenticatedMediaFetch(url, accessToken);
+ if (!res.ok) {
+ throw new Error(`Failed to fetch blob: ${res.status} ${res.statusText}`);
+ }
+ const blob = await res.blob();
+ const objectUrl = URL.createObjectURL(blob);
+
+ imageBlobCache.set(url, objectUrl);
+ putInMediaCache(url, blob);
+
+ return objectUrl;
})();
inflightRequests.set(url, requestPromise);
@@ -61,7 +67,7 @@ export function useBlobCache(url?: string): string | undefined {
setCacheState({ sourceUrl: url, blobUrl: finalBlobUrl });
}
} catch {
- // silency fail... mrow
+ // silently fail
} finally {
inflightRequests.delete(url);
}
@@ -72,7 +78,7 @@ export function useBlobCache(url?: string): string | undefined {
return () => {
isMounted = false;
};
- }, [url]);
+ }, [url, accessToken]);
return cacheState.blobUrl || url;
}
diff --git a/src/app/hooks/useClientConfig.ts b/src/app/hooks/useClientConfig.ts
index 87685337d..3563b1518 100644
--- a/src/app/hooks/useClientConfig.ts
+++ b/src/app/hooks/useClientConfig.ts
@@ -18,6 +18,8 @@ export type ClientConfig = {
pushNotifyUrl?: string;
vapidPublicKey?: string;
webPushAppID?: string;
+ unifiedPushAppID?: string;
+ unifiedPushGatewayUrl?: string;
};
slidingSync?: {
diff --git a/src/app/hooks/useMediaSrc.ts b/src/app/hooks/useMediaSrc.ts
new file mode 100644
index 000000000..ab1e71eff
--- /dev/null
+++ b/src/app/hooks/useMediaSrc.ts
@@ -0,0 +1,16 @@
+import { hasServiceWorker } from '$utils/platform';
+import { useMatrixClient } from './useMatrixClient';
+import { useAuthenticatedMediaUrl } from './useAuthenticatedMediaUrl';
+
+/** Wraps a media URL for `![]()
` / `