fix(notifications): quiet hours start and end while the app stays open (#325)

useNotificationsQuiet evaluated the quiet-hours window (and the
"Pause notifications" expiry) only at render time, and the long-lived
message/invite notifiers rarely re-render, so someone leaving Lotus open
overnight with quiet hours 22:00–07:00 got every sound all night (and a
30-minute pause could outlast itself). The hook now re-evaluates every
30 s.

Verified headless (notifications granted, window unfocused): quiet
hours set to start ~75 s after the app opened; a DM before the window
notified; one inside the window, with the app left alone: before it
still notified, now it's silent.

Fixes #325

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017PCb59uY3UKqDqt7B6hzd5

src/app/components/CallEmbedProvider.tsx

@@ -20,7 +20,6 @@ import {
 import {
   EventTimelineSetHandlerMap,
   EventType,
-  JoinRule,
   RelationType,
   Room,
   RoomEvent,
@@ -72,7 +71,8 @@ import { useReducedMotion } from '../hooks/useReducedMotion';
 import { useSetting } from '../state/hooks/settings';
 import { useCallPreferences } from '../state/hooks/callPreferences';
 import { settingsAtom } from '../state/settings';
-import { getStateEvent, getStateEvents, getMemberName } from '../utils/room';
+import { getStateEvent, getMemberName } from '../utils/room';
+import { isRingableRoom } from '../utils/callRing';
 import { StateEvent } from '../../types/matrix/room';
 import { getPowersLevelFromMatrixEvent } from '../hooks/usePowerLevels';
 import { getRoomCreatorsForRoomId } from '../hooks/useRoomCreators';
@@ -581,12 +581,7 @@ function IncomingCallListener({ callEmbed, joined }: IncomingCallListenerProps)
       // Only ring in rooms where the call button is visible: DMs or invite-only rooms
       // with no space parent. Persistent voice rooms (call rooms), space channels,
       // restricted rooms, and public rooms must never trigger ringing.
-      if (room.isCallRoom()) return;
-      const isDirect = directs.has(room.roomId);
-      const isSpaceChild = getStateEvents(room, StateEvent.SpaceParent).length > 0;
-      const joinRule = room.getJoinRule();
-      const isPrivateInviteGroup = !isSpaceChild && joinRule === JoinRule.Invite;
-      if (!isDirect && !isPrivateInviteGroup) return;
+      if (!isRingableRoom(room, directs.has(room.roomId))) return;
 
       const info: IncomingCallInfo = {
         room,

src/app/features/lotus/backgrounds/animAurora.ts

@@ -51,7 +51,7 @@ const dark: CSSProperties = {
   backgroundSize: '260% 240%, 300% 260%, 240% 280%, 220% 200%, 100% 100%, 100% 100%',
   backgroundPosition: '0% 30%, 100% 70%, 50% 0%, 20% 80%, 50% 50%, 50% 50%',
   backgroundRepeat: 'no-repeat',
-  animation: `${auroraFlow} 60s ease-in-out infinite`,
+  animation: `${auroraFlow} 60s steps(180) infinite`,
 };
 
 const light: CSSProperties = {
@@ -75,7 +75,7 @@ const light: CSSProperties = {
   backgroundSize: '260% 240%, 300% 260%, 240% 280%, 220% 200%, 100% 100%, 100% 100%',
   backgroundPosition: '0% 30%, 100% 70%, 50% 0%, 20% 80%, 50% 50%, 50% 50%',
   backgroundRepeat: 'no-repeat',
-  animation: `${auroraFlow} 60s ease-in-out infinite`,
+  animation: `${auroraFlow} 60s steps(180) infinite`,
 };
 
 export const animAurora: ChatBgVariants = { dark, light };

src/app/features/lotus/backgrounds/animFireflies.ts

@@ -55,7 +55,7 @@ export const animFireflies: ChatBgVariants = {
       '0 0', // wash A   (static)
       '0 0', // wash B   (static)
     ].join(','),
-    animation: `${firefliesDrift} 44s linear infinite`,
+    animation: `${firefliesDrift} 44s steps(528) infinite`,
   },
 
   // Light: a cozy warm dim-dusk. No harsh dots on white — soft amber motes with
@@ -93,6 +93,6 @@ export const animFireflies: ChatBgVariants = {
       '0 0', // wash A   (static)
       '0 0', // wash B   (static)
     ].join(','),
-    animation: `${firefliesDrift} 44s linear infinite`,
+    animation: `${firefliesDrift} 44s steps(528) infinite`,
   },
 };

src/app/features/lotus/backgrounds/animPulse.ts

@@ -76,7 +76,7 @@ export const animPulse: ChatBgVariants = {
       '0 0', // base wash
       '0 0', // vignette
     ].join(','),
-    animation: `${gridPulse} 22s ease-in-out infinite`,
+    animation: `${gridPulse} 22s steps(528) infinite`,
   },
 
   // Light: soft slate-blue grid on pale cool-white, a gentle luminance breathe.
@@ -116,6 +116,6 @@ export const animPulse: ChatBgVariants = {
       '0 0', // base wash
       '0 0', // vignette
     ].join(','),
-    animation: `${gridPulse} 22s ease-in-out infinite`,
+    animation: `${gridPulse} 22s steps(528) infinite`,
   },
 };

src/app/features/lotus/backgrounds/animRain.ts

@@ -97,7 +97,7 @@ export const animRain: ChatBgVariants = {
     ].join(','),
     backgroundSize: ['260px 200px', '100% 100%', '100% 100%', '100% 100%'].join(','),
     backgroundPosition: ['0 0', '0 0', '0 0', '0 0'].join(','),
-    animation: `${rainFall} 12s linear infinite`,
+    animation: `${rainFall} 12s steps(288) infinite`,
   },
 
   // Light: soft teal-grey streaks on a pale cool base — elegant, never neon.
@@ -118,6 +118,6 @@ export const animRain: ChatBgVariants = {
     ].join(','),
     backgroundSize: ['260px 200px', '100% 100%', '100% 100%', '100% 100%'].join(','),
     backgroundPosition: ['0 0', '0 0', '0 0', '0 0'].join(','),
-    animation: `${rainFall} 12s linear infinite`,
+    animation: `${rainFall} 12s steps(288) infinite`,
   },
 };

src/app/features/lotus/backgrounds/animStars.ts

@@ -68,7 +68,7 @@ export const animStars: ChatBgVariants = {
       '0 0', // nebula A
       '0 0', // nebula B
     ].join(','),
-    animation: `${starDrift} 90s linear infinite`,
+    animation: `${starDrift} 90s steps(1080) infinite`,
   },
 
   // Light: an airy pre-dawn sky. No literal white-on-white stars — instead very
@@ -112,6 +112,6 @@ export const animStars: ChatBgVariants = {
       '0 0', // wash A
       '0 0', // wash B
     ].join(','),
-    animation: `${starDrift} 100s linear infinite`,
+    animation: `${starDrift} 100s steps(1200) infinite`,
   },
 };

src/app/features/lotus/chatBackground.ts

@@ -149,6 +149,11 @@ export const getChatBg = (
   }
   // For animated backgrounds, promote the element to its own compositor layer so
   // background-position keyframes don't trigger repaints on descendant elements.
+  // [Gitea #337] background-position can't run on the compositor, so every
+  // animation frame repaints the whole chat area (45 to 70% main-thread busy
+  // at 60 fps). The drifts are slow (3–22 px/s), so each animation uses steps():
+  // ~12 updates/s for the slow ones, ~24/s for rain and pulse: visually the
+  // same, a fraction of the repaints.
   if (style.animation) {
     return { ...style, willChange: 'background-position', contain: 'paint' };
   }

src/app/features/room/RoomTimeline.tsx

@@ -138,6 +138,7 @@ import { useMediaAuthentication } from '../../hooks/useMediaAuthentication';
 import { useIgnoredUsers } from '../../hooks/useIgnoredUsers';
 import { useImagePackRooms } from '../../hooks/useImagePackRooms';
 import { useIsDirectRoom } from '../../hooks/useRoom';
+import { isRingableRoom } from '../../utils/callRing';
 import { useOpenUserRoomProfile } from '../../state/hooks/userRoomProfile';
 import { useSpaceOptionally } from '../../hooks/useSpace';
 import { useRoomCreators } from '../../hooks/useRoomCreators';
@@ -2030,6 +2031,9 @@ export function RoomTimeline({ room, eventId, roomInputRef, editor }: RoomTimeli
       [EventType.RTCNotification]: (mEventId, mEvent, item) => {
         const senderId = mEvent.getSender() ?? '';
         if (!senderId || senderId === mx.getUserId()) return null;
+        // Same rule as ringing: no "Missed call" in voice rooms or space
+        // channels, where starting a call is just joining the channel.
+        if (!isRingableRoom(room, direct)) return null;
         const content = mEvent.getContent();
         const mention =
           content['m.mentions']?.room ||

src/app/hooks/useNotificationsQuiet.ts

@@ -1,3 +1,4 @@
+import { useEffect, useState } from 'react';
 import { useAtomValue } from 'jotai';
 import { focusAssistActiveAtom } from '../state/focusAssist';
 import { manualDndAtom } from '../state/manualDnd';
@@ -6,6 +7,8 @@ import { isWithinTimeWindow } from '../utils/timeWindow';
 import { useSetting } from '../state/hooks/settings';
 import { settingsAtom } from '../state/settings';
 
+const QUIET_TICK_MS = 30_000;
+
 export type NotificationsQuietInputs = {
   focusAssistActive: boolean;
   manualDnd: boolean;
@@ -40,6 +43,15 @@ export function isNotificationsQuiet({
 // Live-atoms/settings-backed version of `isNotificationsQuiet` for use in
 // components.
 export function useNotificationsQuiet(): boolean {
+  // [Gitea #325] The quiet-hours window and the snooze expiry depend on the
+  // clock, but the long-lived notifiers using this hook rarely re-render, so a
+  // window starting (or a 30-minute pause ending) while the app stayed open was
+  // never noticed. Re-evaluate on a tick, like the night-light overlay.
+  const [, setTick] = useState(0);
+  useEffect(() => {
+    const id = setInterval(() => setTick((t) => t + 1), QUIET_TICK_MS);
+    return () => clearInterval(id);
+  }, []);
   const focusAssistActive = useAtomValue(focusAssistActiveAtom);
   const manualDnd = useAtomValue(manualDndAtom);
   const snoozeUntil = useAtomValue(notificationSnoozeUntilAtom);

src/app/utils/callRing.test.ts

@@ -0,0 +1,29 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import type { Room } from 'matrix-js-sdk';
+import { isRingableRoom } from './callRing';
+
+const fakeRoom = (opts: { callRoom?: boolean; joinRule?: string; spaceParent?: boolean }): Room =>
+  ({
+    isCallRoom: () => !!opts.callRoom,
+    getJoinRule: () => opts.joinRule ?? 'invite',
+    getLiveTimeline: () => ({
+      getState: () => ({ getStateEvents: () => (opts.spaceParent ? [{}] : []) }),
+    }),
+  }) as unknown as Room;
+
+test('voice rooms never ring or show "missed call", even as DMs', () => {
+  assert.equal(isRingableRoom(fakeRoom({ callRoom: true }), false), false);
+  assert.equal(isRingableRoom(fakeRoom({ callRoom: true }), true), false);
+});
+
+test('DMs and invite-only groups outside a space ring', () => {
+  assert.equal(isRingableRoom(fakeRoom({ joinRule: 'public' }), true), true);
+  assert.equal(isRingableRoom(fakeRoom({ joinRule: 'invite' }), false), true);
+});
+
+test('space channels, public and restricted rooms do not ring', () => {
+  assert.equal(isRingableRoom(fakeRoom({ joinRule: 'invite', spaceParent: true }), false), false);
+  assert.equal(isRingableRoom(fakeRoom({ joinRule: 'public' }), false), false);
+  assert.equal(isRingableRoom(fakeRoom({ joinRule: 'restricted' }), false), false);
+});

src/app/utils/callRing.ts

@@ -0,0 +1,18 @@
+import { JoinRule, Room } from 'matrix-js-sdk';
+import { StateEvent } from '../../types/matrix/room';
+import { getStateEvents } from './room';
+
+/**
+ * Whether a call notification in this room may ring — and, by the same rule,
+ * whether an unanswered one may show as "Missed call" (Gitea #162 follow-up).
+ * Only DMs and invite-only groups outside any space ring, i.e. rooms where the
+ * call button is shown. Persistent voice rooms, space channels, restricted and
+ * public rooms never do: joining a voice channel alone is normal and isn't a
+ * "call" anyone missed.
+ */
+export const isRingableRoom = (room: Room, isDirect: boolean): boolean => {
+  if (room.isCallRoom()) return false;
+  if (isDirect) return true;
+  const isSpaceChild = getStateEvents(room, StateEvent.SpaceParent).length > 0;
+  return !isSpaceChild && room.getJoinRule() === JoinRule.Invite;
+};