waitForNotificationAnswer

Signed-off-by: Timo K <toger5@hotmail.de>

Author: toger5

src/UrlParams.ts

@@ -216,6 +216,17 @@ export interface UrlConfiguration {
    * This is one part to make the call matrixRTC session behave like a telephone call.
    */
   autoLeaveWhenOthersLeft: boolean;
+
+  /**
+   * If the client should show behave like it is awaiting an answer if a notification was sent.
+   * This is a no-op if not combined with sendNotificationType.
+   *
+   * This entails:
+   *  - show ui that it is awaiting an answer
+   *  - play a sound that indicates that it is awaiting an answer
+   *  - auto-dismiss the call widget once the notification lifetime expires on the receivers side.
+   */
+  awaitingAnswer: boolean;
 }
 
 // If you need to add a new flag to this interface, prefer a name that describes
@@ -442,6 +453,7 @@ export const getUrlParams = (
       "ring",
       "notification",
     ]),
+    awaitingAnswer: parser.getFlag("showAwaitingAnswerFeedback"),
     autoLeaveWhenOthersLeft: parser.getFlag("autoLeave"),
   };
 

src/room/GroupCallView.tsx

@@ -453,7 +453,6 @@ export const GroupCallView: FC<Props> = ({
           matrixInfo={matrixInfo}
           rtcSession={rtcSession as MatrixRTCSession}
           matrixRoom={room}
-          participantCount={participantCount}
           onLeave={onLeave}
           header={header}
           muteStates={muteStates}

src/room/InCallView.tsx

@@ -216,7 +216,6 @@ export interface InCallViewProps {
   matrixRoom: MatrixRoom;
   livekitRoom: LivekitRoom;
   muteStates: MuteStates;
-  participantCount: number;
   /** Function to call when the user explicitly ends the call */
   onLeave: () => void;
   header: HeaderStyle;
@@ -233,7 +232,6 @@ export const InCallView: FC<InCallViewProps> = ({
   matrixRoom,
   livekitRoom,
   muteStates,
-  participantCount,
   onLeave,
   header: headerStyle,
   connState,
@@ -312,6 +310,7 @@ export const InCallView: FC<InCallViewProps> = ({
     () => void toggleRaisedHand(),
   );
 
+  const participantCount = useBehavior(vm.participantCount$);
   const reconnecting = useBehavior(vm.reconnecting$);
   const windowMode = useBehavior(vm.windowMode$);
   const layout = useBehavior(vm.layout$);

src/state/CallViewModel.test.ts

@@ -5,7 +5,7 @@ SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
 Please see LICENSE in the repository root for full details.
 */
 
-import { test, vi, onTestFinished, it } from "vitest";
+import { test, vi, onTestFinished, it, describe } from "vitest";
 import EventEmitter from "events";
 import {
   BehaviorSubject,
@@ -32,6 +32,9 @@ import {
   Status,
   type CallMembership,
   type MatrixRTCSession,
+  type IRTCNotificationContent,
+  type ICallNotifyContent,
+  MatrixRTCSessionEvent,
 } from "matrix-js-sdk/lib/matrixrtc";
 import { deepCompare } from "matrix-js-sdk/lib/utils";
 
@@ -1228,6 +1231,215 @@ test("autoLeaveWhenOthersLeft$ doesn't emits when autoLeaveWhenOthersLeft option
   });
 });
 
+describe("waitForNotificationAnswer$", () => {
+  test("unknown -> ringing -> timeout when notified and nobody joins", () => {
+    withTestScheduler(({ hot, schedule, expectObservable, scope }) => {
+      // No one ever joins (only local user)
+      withCallViewModel(
+        {
+          remoteParticipants$: scope.behavior(hot("a", { a: [] }), []),
+          rtcMembers$: scope.behavior(hot("a", { a: [localRtcMember] }), []),
+          connectionState$: of(ConnectionState.Connected),
+          speaking: new Map(),
+          mediaDevices: mockMediaDevices({}),
+        },
+        (vm, rtcSession) => {
+          // Fire a call notification at 10ms with lifetime 30ms
+          schedule("          10ms r", {
+            r: () => {
+              rtcSession.emit(
+                MatrixRTCSessionEvent.DidSendCallNotification,
+                { lifetime: 30 } as unknown as IRTCNotificationContent,
+                {} as unknown as ICallNotifyContent,
+              );
+            },
+          });
+
+          expectObservable(vm.waitForNotificationAnswer$).toBe(
+            "a 9ms b 29ms c",
+            { a: "unknown", b: "ringing", c: "timeout" },
+          );
+        },
+        {
+          waitForNotificationAnswer: true,
+          encryptionSystem: { kind: E2eeType.PER_PARTICIPANT },
+        },
+      );
+    });
+  });
+
+  test("ringing -> success if someone joins before timeout", () => {
+    withTestScheduler(({ hot, schedule, expectObservable, scope }) => {
+      // Someone joins at 20ms (both LiveKit participant and MatrixRTC member)
+      const remote$ = scope.behavior(
+        hot("a--b", { a: [], b: [aliceParticipant] }),
+        [],
+      );
+      const rtc$ = scope.behavior(
+        hot("a--b", {
+          a: [localRtcMember],
+          b: [localRtcMember, aliceRtcMember],
+        }),
+        [],
+      );
+
+      withCallViewModel(
+        {
+          remoteParticipants$: remote$,
+          rtcMembers$: rtc$,
+          connectionState$: of(ConnectionState.Connected),
+          speaking: new Map(),
+          mediaDevices: mockMediaDevices({}),
+        },
+        (vm, rtcSession) => {
+          // Notify at 5ms so we enter ringing, then success at 20ms
+          schedule("          5ms r", {
+            r: () => {
+              rtcSession.emit(
+                MatrixRTCSessionEvent.DidSendCallNotification,
+                { lifetime: 100 } as unknown as IRTCNotificationContent,
+                {} as unknown as ICallNotifyContent,
+              );
+            },
+          });
+
+          expectObservable(vm.waitForNotificationAnswer$).toBe("a 2ms c", {
+            a: "unknown",
+            c: "success",
+          });
+        },
+        {
+          waitForNotificationAnswer: true,
+          encryptionSystem: { kind: E2eeType.PER_PARTICIPANT },
+        },
+      );
+    });
+  });
+
+  test("success when someone joins before we notify", () => {
+    withTestScheduler(({ hot, schedule, expectObservable, scope }) => {
+      // Join at 10ms, notify later at 20ms (state should stay success)
+      const remote$ = scope.behavior(
+        hot("a-b", { a: [], b: [aliceParticipant] }),
+        [],
+      );
+      const rtc$ = scope.behavior(
+        hot("a-b", {
+          a: [localRtcMember],
+          b: [localRtcMember, aliceRtcMember],
+        }),
+        [],
+      );
+
+      withCallViewModel(
+        {
+          remoteParticipants$: remote$,
+          rtcMembers$: rtc$,
+          connectionState$: of(ConnectionState.Connected),
+          speaking: new Map(),
+          mediaDevices: mockMediaDevices({}),
+        },
+        (vm, rtcSession) => {
+          schedule("          20ms r", {
+            r: () => {
+              rtcSession.emit(
+                MatrixRTCSessionEvent.DidSendCallNotification,
+                { lifetime: 50 } as unknown as IRTCNotificationContent,
+                {} as unknown as ICallNotifyContent,
+              );
+            },
+          });
+          expectObservable(vm.waitForNotificationAnswer$).toBe("a 1ms b", {
+            a: "unknown",
+            b: "success",
+          });
+        },
+        {
+          waitForNotificationAnswer: true,
+          encryptionSystem: { kind: E2eeType.PER_PARTICIPANT },
+        },
+      );
+    });
+  });
+
+  test("notify without lifetime -> immediate timeout", () => {
+    withTestScheduler(({ hot, schedule, expectObservable, scope }) => {
+      withCallViewModel(
+        {
+          remoteParticipants$: scope.behavior(hot("a", { a: [] }), []),
+          rtcMembers$: scope.behavior(hot("a", { a: [localRtcMember] }), []),
+          connectionState$: of(ConnectionState.Connected),
+          speaking: new Map(),
+          mediaDevices: mockMediaDevices({}),
+        },
+        (vm, rtcSession) => {
+          schedule("          10ms r", {
+            r: () => {
+              rtcSession.emit(
+                MatrixRTCSessionEvent.DidSendCallNotification,
+                { lifetime: 0 } as unknown as IRTCNotificationContent, // no lifetime
+                {} as unknown as ICallNotifyContent,
+              );
+            },
+          });
+          expectObservable(vm.waitForNotificationAnswer$).toBe("a 9ms b", {
+            a: "unknown",
+            b: "timeout",
+          });
+        },
+        {
+          waitForNotificationAnswer: true,
+          encryptionSystem: { kind: E2eeType.PER_PARTICIPANT },
+        },
+      );
+    });
+  });
+
+  test("stays null when waitForNotificationAnswer=false", () => {
+    withTestScheduler(({ hot, schedule, expectObservable, scope }) => {
+      const remote$ = scope.behavior(
+        hot("a--b", { a: [], b: [aliceParticipant] }),
+        [],
+      );
+      const rtc$ = scope.behavior(
+        hot("a--b", {
+          a: [localRtcMember],
+          b: [localRtcMember, aliceRtcMember],
+        }),
+        [],
+      );
+
+      withCallViewModel(
+        {
+          remoteParticipants$: remote$,
+          rtcMembers$: rtc$,
+          connectionState$: of(ConnectionState.Connected),
+          speaking: new Map(),
+          mediaDevices: mockMediaDevices({}),
+        },
+        (vm, rtcSession) => {
+          schedule("          5ms r", {
+            r: () => {
+              rtcSession.emit(
+                MatrixRTCSessionEvent.DidSendCallNotification,
+                { lifetime: 30 } as unknown as IRTCNotificationContent,
+                {} as unknown as ICallNotifyContent,
+              );
+            },
+          });
+          expectObservable(vm.waitForNotificationAnswer$).toBe("(n)", {
+            n: null,
+          });
+        },
+        {
+          waitForNotificationAnswer: false,
+          encryptionSystem: { kind: E2eeType.PER_PARTICIPANT },
+        },
+      );
+    });
+  });
+});
+
 test("audio output changes when toggling earpiece mode", () => {
   withTestScheduler(({ schedule, expectObservable }) => {
     getUrlParams.mockReturnValue({ controlledAudioDevices: true });