Improve live voice broadcast detection by testing if the started event has been redacted (#9780)

Author: weeman1337

src/utils/arrays.ts

@@ -313,3 +313,13 @@ export const concat = (...arrays: Uint8Array[]): Uint8Array => {
         return concatenated;
     }, new Uint8Array(0));
 };
+
+/**
+ * Async version of Array.every.
+ */
+export async function asyncEvery<T>(values: T[], predicate: (value: T) => Promise<boolean>): Promise<boolean> {
+    for (const value of values) {
+        if (!(await predicate(value))) return false;
+    }
+    return true;
+}

src/voice-broadcast/hooks/useHasRoomLiveVoiceBroadcast.ts

@@ -14,18 +14,34 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { useState } from "react";
+import { useContext, useEffect, useMemo, useState } from "react";
 import { Room, RoomStateEvent } from "matrix-js-sdk/src/matrix";
 
 import { hasRoomLiveVoiceBroadcast } from "../utils/hasRoomLiveVoiceBroadcast";
 import { useTypedEventEmitter } from "../../hooks/useEventEmitter";
+import { SDKContext } from "../../contexts/SDKContext";
 
 export const useHasRoomLiveVoiceBroadcast = (room: Room) => {
-    const [hasLiveVoiceBroadcast, setHasLiveVoiceBroadcast] = useState(hasRoomLiveVoiceBroadcast(room).hasBroadcast);
-
-    useTypedEventEmitter(room.currentState, RoomStateEvent.Update, () => {
-        setHasLiveVoiceBroadcast(hasRoomLiveVoiceBroadcast(room).hasBroadcast);
-    });
-
+    const sdkContext = useContext(SDKContext);
+    const [hasLiveVoiceBroadcast, setHasLiveVoiceBroadcast] = useState(false);
+
+    const update = useMemo(() => {
+        return sdkContext.client
+            ? () => {
+                  hasRoomLiveVoiceBroadcast(sdkContext.client!, room).then(
+                      ({ hasBroadcast }) => {
+                          setHasLiveVoiceBroadcast(hasBroadcast);
+                      },
+                      () => {}, // no update on error
+                  );
+              }
+            : () => {}; // noop without client
+    }, [room, sdkContext, setHasLiveVoiceBroadcast]);
+
+    useEffect(() => {
+        update();
+    }, [update]);
+
+    useTypedEventEmitter(room.currentState, RoomStateEvent.Update, () => update());
     return hasLiveVoiceBroadcast;
 };

src/voice-broadcast/index.ts

@@ -49,6 +49,7 @@ export * from "./utils/getChunkLength";
 export * from "./utils/getMaxBroadcastLength";
 export * from "./utils/hasRoomLiveVoiceBroadcast";
 export * from "./utils/findRoomLiveVoiceBroadcastFromUserAndDevice";
+export * from "./utils/retrieveStartedInfoEvent";
 export * from "./utils/shouldDisplayAsVoiceBroadcastRecordingTile";
 export * from "./utils/shouldDisplayAsVoiceBroadcastTile";
 export * from "./utils/shouldDisplayAsVoiceBroadcastStoppedText";

src/voice-broadcast/utils/checkVoiceBroadcastPreConditions.tsx

@@ -67,11 +67,11 @@ const showOthersAlreadyRecordingDialog = () => {
     });
 };
 
-export const checkVoiceBroadcastPreConditions = (
+export const checkVoiceBroadcastPreConditions = async (
     room: Room,
     client: MatrixClient,
     recordingsStore: VoiceBroadcastRecordingsStore,
-): boolean => {
+): Promise<boolean> => {
     if (recordingsStore.getCurrent()) {
         showAlreadyRecordingDialog();
         return false;
@@ -86,7 +86,7 @@ export const checkVoiceBroadcastPreConditions = (
         return false;
     }
 
-    const { hasBroadcast, startedByUser } = hasRoomLiveVoiceBroadcast(room, currentUserId);
+    const { hasBroadcast, startedByUser } = await hasRoomLiveVoiceBroadcast(client, room, currentUserId);
 
     if (hasBroadcast && startedByUser) {
         showAlreadyRecordingDialog();

src/voice-broadcast/utils/doMaybeSetCurrentVoiceBroadcastPlayback.ts

@@ -34,12 +34,12 @@ import {
  * @param {VoiceBroadcastPlaybacksStore} voiceBroadcastPlaybacksStore
  * @param {VoiceBroadcastRecordingsStore} voiceBroadcastRecordingsStore
  */
-export const doMaybeSetCurrentVoiceBroadcastPlayback = (
+export const doMaybeSetCurrentVoiceBroadcastPlayback = async (
     room: Room,
     client: MatrixClient,
     voiceBroadcastPlaybacksStore: VoiceBroadcastPlaybacksStore,
     voiceBroadcastRecordingsStore: VoiceBroadcastRecordingsStore,
-): void => {
+): Promise<void> => {
     // do not disturb the current recording
     if (voiceBroadcastRecordingsStore.hasCurrent()) return;
 
@@ -50,7 +50,7 @@ export const doMaybeSetCurrentVoiceBroadcastPlayback = (
         return;
     }
 
-    const { infoEvent } = hasRoomLiveVoiceBroadcast(room);
+    const { infoEvent } = await hasRoomLiveVoiceBroadcast(client, room);
 
     if (infoEvent) {
         // live broadcast in the room + no recording + not listening yet: set the current broadcast

src/voice-broadcast/utils/hasRoomLiveVoiceBroadcast.ts

@@ -14,9 +14,10 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { MatrixEvent, Room } from "matrix-js-sdk/src/matrix";
+import { MatrixClient, MatrixEvent, Room } from "matrix-js-sdk/src/matrix";
 
-import { VoiceBroadcastInfoEventType, VoiceBroadcastInfoState } from "..";
+import { retrieveStartedInfoEvent, VoiceBroadcastInfoEventType, VoiceBroadcastInfoState } from "..";
+import { asyncEvery } from "../../utils/arrays";
 
 interface Result {
     // whether there is a live broadcast in the room
@@ -27,22 +28,26 @@ interface Result {
     startedByUser: boolean;
 }
 
-export const hasRoomLiveVoiceBroadcast = (room: Room, userId?: string): Result => {
+export const hasRoomLiveVoiceBroadcast = async (client: MatrixClient, room: Room, userId?: string): Promise<Result> => {
     let hasBroadcast = false;
     let startedByUser = false;
     let infoEvent: MatrixEvent | null = null;
 
     const stateEvents = room.currentState.getStateEvents(VoiceBroadcastInfoEventType);
-    stateEvents.every((event: MatrixEvent) => {
+    await asyncEvery(stateEvents, async (event: MatrixEvent) => {
         const state = event.getContent()?.state;
 
         if (state && state !== VoiceBroadcastInfoState.Stopped) {
+            const startEvent = await retrieveStartedInfoEvent(event, client);
+
+            // skip if started voice broadcast event is redacted
+            if (startEvent?.isRedacted()) return true;
+
             hasBroadcast = true;
-            infoEvent = event;
+            infoEvent = startEvent;
 
             // state key = sender's MXID
             if (event.getStateKey() === userId) {
-                infoEvent = event;
                 startedByUser = true;
                 // break here, because more than true / true is not possible
                 return false;

src/voice-broadcast/utils/retrieveStartedInfoEvent.ts

@@ -0,0 +1,45 @@
+/*
+Copyright 2022 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { MatrixClient, MatrixEvent } from "matrix-js-sdk/src/matrix";
+
+import { VoiceBroadcastInfoState } from "..";
+
+export const retrieveStartedInfoEvent = async (
+    event: MatrixEvent,
+    client: MatrixClient,
+): Promise<MatrixEvent | null> => {
+    // started event passed as argument
+    if (event.getContent()?.state === VoiceBroadcastInfoState.Started) return event;
+
+    const relatedEventId = event.getRelation()?.event_id;
+
+    // no related event
+    if (!relatedEventId) return null;
+
+    const roomId = event.getRoomId() || "";
+    const relatedEventFromRoom = client.getRoom(roomId)?.findEventById(relatedEventId);
+
+    // event found
+    if (relatedEventFromRoom) return relatedEventFromRoom;
+
+    try {
+        const relatedEventData = await client.fetchRoomEvent(roomId, relatedEventId);
+        return new MatrixEvent(relatedEventData);
+    } catch (e) {}
+
+    return null;
+};

src/voice-broadcast/utils/startNewVoiceBroadcastRecording.ts

@@ -38,7 +38,7 @@ const startBroadcast = async (
     const userId = client.getUserId();
 
     if (!userId) {
-        reject("unable to start voice broadcast if current user is unkonwn");
+        reject("unable to start voice broadcast if current user is unknown");
         return promise;
     }
 
@@ -88,7 +88,7 @@ export const startNewVoiceBroadcastRecording = async (
     playbacksStore: VoiceBroadcastPlaybacksStore,
     recordingsStore: VoiceBroadcastRecordingsStore,
 ): Promise<VoiceBroadcastRecording | null> => {
-    if (!checkVoiceBroadcastPreConditions(room, client, recordingsStore)) {
+    if (!(await checkVoiceBroadcastPreConditions(room, client, recordingsStore))) {
         return null;
     }
 

test/components/views/rooms/RoomTile-test.tsx

@@ -32,40 +32,45 @@ import {
     useMockedCalls,
     setupAsyncStoreWithClient,
     filterConsole,
+    flushPromises,
 } from "../../../test-utils";
 import { CallStore } from "../../../../src/stores/CallStore";
 import RoomTile from "../../../../src/components/views/rooms/RoomTile";
 import { DefaultTagID } from "../../../../src/stores/room-list/models";
 import DMRoomMap from "../../../../src/utils/DMRoomMap";
-import { MatrixClientPeg } from "../../../../src/MatrixClientPeg";
 import PlatformPeg from "../../../../src/PlatformPeg";
 import BasePlatform from "../../../../src/BasePlatform";
 import { WidgetMessagingStore } from "../../../../src/stores/widgets/WidgetMessagingStore";
 import { VoiceBroadcastInfoState } from "../../../../src/voice-broadcast";
 import { mkVoiceBroadcastInfoStateEvent } from "../../../voice-broadcast/utils/test-utils";
+import { TestSdkContext } from "../../../TestSdkContext";
+import { SDKContext } from "../../../../src/contexts/SDKContext";
 
 describe("RoomTile", () => {
     jest.spyOn(PlatformPeg, "get").mockReturnValue({
         overrideBrowserShortcuts: () => false,
     } as unknown as BasePlatform);
     useMockedCalls();
 
-    const setUpVoiceBroadcast = (state: VoiceBroadcastInfoState): void => {
+    const setUpVoiceBroadcast = async (state: VoiceBroadcastInfoState): Promise<void> => {
         voiceBroadcastInfoEvent = mkVoiceBroadcastInfoStateEvent(
             room.roomId,
             state,
-            client.getUserId(),
-            client.getDeviceId(),
+            client.getSafeUserId(),
+            client.getDeviceId()!,
         );
 
-        act(() => {
+        await act(async () => {
             room.currentState.setStateEvents([voiceBroadcastInfoEvent]);
+            await flushPromises();
         });
     };
 
     const renderRoomTile = (): void => {
         renderResult = render(
-            <RoomTile room={room} showMessagePreview={false} isMinimized={false} tag={DefaultTagID.Untagged} />,
+            <SDKContext.Provider value={sdkContext}>
+                <RoomTile room={room} showMessagePreview={false} isMinimized={false} tag={DefaultTagID.Untagged} />
+            </SDKContext.Provider>,
         );
     };
 
@@ -74,15 +79,18 @@ describe("RoomTile", () => {
     let voiceBroadcastInfoEvent: MatrixEvent;
     let room: Room;
     let renderResult: RenderResult;
+    let sdkContext: TestSdkContext;
 
     beforeEach(() => {
+        sdkContext = new TestSdkContext();
+
         restoreConsole = filterConsole(
             // irrelevant for this test
             "Room !1:example.org does not have an m.room.create event",
         );
 
-        stubClient();
-        client = mocked(MatrixClientPeg.get());
+        client = mocked(stubClient());
+        sdkContext.client = client;
         DMRoomMap.makeShared();
 
         room = new Room("!1:example.org", client, "@alice:example.org", {
@@ -136,7 +144,7 @@ describe("RoomTile", () => {
 
             // Insert an await point in the connection method so we can inspect
             // the intermediate connecting state
-            let completeConnection: () => void;
+            let completeConnection: () => void = () => {};
             const connectionCompleted = new Promise<void>((resolve) => (completeConnection = resolve));
             jest.spyOn(call, "performConnection").mockReturnValue(connectionCompleted);
 
@@ -180,8 +188,8 @@ describe("RoomTile", () => {
         });
 
         describe("and a live broadcast starts", () => {
-            beforeEach(() => {
-                setUpVoiceBroadcast(VoiceBroadcastInfoState.Started);
+            beforeEach(async () => {
+                await setUpVoiceBroadcast(VoiceBroadcastInfoState.Started);
             });
 
             it("should still render the call subtitle", () => {
@@ -192,25 +200,26 @@ describe("RoomTile", () => {
     });
 
     describe("when a live voice broadcast starts", () => {
-        beforeEach(() => {
-            setUpVoiceBroadcast(VoiceBroadcastInfoState.Started);
+        beforeEach(async () => {
+            await setUpVoiceBroadcast(VoiceBroadcastInfoState.Started);
         });
 
         it("should render the »Live« subtitle", () => {
             expect(screen.queryByText("Live")).toBeInTheDocument();
         });
 
         describe("and the broadcast stops", () => {
-            beforeEach(() => {
+            beforeEach(async () => {
                 const stopEvent = mkVoiceBroadcastInfoStateEvent(
                     room.roomId,
                     VoiceBroadcastInfoState.Stopped,
-                    client.getUserId(),
-                    client.getDeviceId(),
+                    client.getSafeUserId(),
+                    client.getDeviceId()!,
                     voiceBroadcastInfoEvent,
                 );
-                act(() => {
+                await act(async () => {
                     room.currentState.setStateEvents([stopEvent]);
+                    await flushPromises();
                 });
             });