End voice broadcast recording on any call (#9425)

test/stores/widgets/StopGapWidget-test.ts

@@ -15,12 +15,19 @@ limitations under the License.
 */
 
 import { mocked, MockedObject } from "jest-mock";
+import { MatrixEvent } from "matrix-js-sdk/src/matrix";
 import { MatrixClient, ClientEvent } from "matrix-js-sdk/src/client";
 import { ClientWidgetApi } from "matrix-widget-api";
 
 import { stubClient, mkRoom, mkEvent } from "../../test-utils";
 import { MatrixClientPeg } from "../../../src/MatrixClientPeg";
 import { StopGapWidget } from "../../../src/stores/widgets/StopGapWidget";
+import { ElementWidgetActions } from "../../../src/stores/widgets/ElementWidgetActions";
+import {
+    VoiceBroadcastInfoEventType,
+    VoiceBroadcastRecording,
+    VoiceBroadcastRecordingsStore,
+} from "../../../src/voice-broadcast";
 
 jest.mock("matrix-widget-api/lib/ClientWidgetApi");
 
@@ -68,4 +75,39 @@ describe("StopGapWidget", () => {
         await Promise.resolve(); // flush promises
         expect(messaging.feedToDevice).toHaveBeenCalledWith(event.getEffectiveEvent(), false);
     });
+
+    describe("when there is a voice broadcast recording", () => {
+        let voiceBroadcastInfoEvent: MatrixEvent;
+        let voiceBroadcastRecording: VoiceBroadcastRecording;
+
+        beforeEach(() => {
+            voiceBroadcastInfoEvent = mkEvent({
+                event: true,
+                room: client.getRoom("x").roomId,
+                user: client.getUserId(),
+                type: VoiceBroadcastInfoEventType,
+                content: {},
+            });
+            voiceBroadcastRecording = new VoiceBroadcastRecording(voiceBroadcastInfoEvent, client);
+            jest.spyOn(voiceBroadcastRecording, "stop");
+            jest.spyOn(VoiceBroadcastRecordingsStore.instance(), "getCurrent").mockReturnValue(voiceBroadcastRecording);
+        });
+
+        describe(`and receiving a action:${ElementWidgetActions.JoinCall} message`, () => {
+            beforeEach(async () => {
+                messaging.on.mock.calls.find(
+                    ([event, listener]) => {
+                        if (event === `action:${ElementWidgetActions.JoinCall}`) {
+                            listener();
+                            return true;
+                        }
+                    },
+                );
+            });
+
+            it("should stop the current voice broadcast recording", () => {
+                expect(voiceBroadcastRecording.stop).toHaveBeenCalled();
+            });
+        });
+    });
 });

test/voice-broadcast/models/VoiceBroadcastRecording-test.ts

@@ -41,6 +41,7 @@ import {
     VoiceBroadcastRecordingEvent,
 } from "../../../src/voice-broadcast";
 import { mkEvent, mkStubRoom, stubClient } from "../../test-utils";
+import dis from "../../../src/dispatcher/dispatcher";
 
 jest.mock("../../../src/voice-broadcast/audio/VoiceBroadcastRecorder", () => ({
     ...jest.requireActual("../../../src/voice-broadcast/audio/VoiceBroadcastRecorder") as object,
@@ -83,6 +84,12 @@ describe("VoiceBroadcastRecording", () => {
         jest.spyOn(voiceBroadcastRecording, "removeAllListeners");
     };
 
+    const itShouldBeInState = (state: VoiceBroadcastInfoState) => {
+        it(`should be in state stopped ${state}`, () => {
+            expect(voiceBroadcastRecording.getState()).toBe(state);
+        });
+    };
+
     beforeEach(() => {
         client = stubClient();
         room = mkStubRoom(roomId, "Test Room", client);
@@ -191,9 +198,7 @@ describe("VoiceBroadcastRecording", () => {
                 );
             });
 
-            it("should be in state stopped", () => {
-                expect(voiceBroadcastRecording.getState()).toBe(VoiceBroadcastInfoState.Stopped);
-            });
+            itShouldBeInState(VoiceBroadcastInfoState.Stopped);
 
             it("should emit a stopped state changed event", () => {
                 expect(onStateChanged).toHaveBeenCalledWith(VoiceBroadcastInfoState.Stopped);
@@ -209,6 +214,16 @@ describe("VoiceBroadcastRecording", () => {
                 expect(voiceBroadcastRecorder.start).toHaveBeenCalled();
             });
 
+            describe("and receiving a call action", () => {
+                beforeEach(() => {
+                    dis.dispatch({
+                        action: "call_state",
+                    }, true);
+                });
+
+                itShouldBeInState(VoiceBroadcastInfoState.Stopped);
+            });
+
             describe("and a chunk has been recorded", () => {
                 beforeEach(async () => {
                     await onChunkRecorded({