diff --git a/src/@types/event.ts b/src/@types/event.ts
index 230cb05039d..e7399a85d3e 100644
--- a/src/@types/event.ts
+++ b/src/@types/event.ts
@@ -42,6 +42,7 @@ export enum EventType {
     RoomMessage = "m.room.message",
     RoomMessageEncrypted = "m.room.encrypted",
     Sticker = "m.sticker",
+
     CallInvite = "m.call.invite",
     CallCandidates = "m.call.candidates",
     CallAnswer = "m.call.answer",
@@ -54,6 +55,10 @@ export enum EventType {
     CallReplaces = "m.call.replaces",
     CallAssertedIdentity = "m.call.asserted_identity",
     CallAssertedIdentityPrefix = "org.matrix.call.asserted_identity",
+    CallTrackSubscription = "m.call.track_subscription",
+    CallPing = "m.call.ping",
+    CallPong = "m.call.pong",
+
     KeyVerificationRequest = "m.key.verification.request",
     KeyVerificationStart = "m.key.verification.start",
     KeyVerificationCancel = "m.key.verification.cancel",
diff --git a/src/client.ts b/src/client.ts
index b9de5b669ac..d3128483517 100644
--- a/src/client.ts
+++ b/src/client.ts
@@ -1774,10 +1774,12 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     public getFoci(): IFocusInfo[] {
         if (!this.localSfuUserId || !this.localSfuDeviceId) return [];
 
-        return [{
-            user_id: this.localSfuUserId,
-            device_id: this.localSfuDeviceId,
-        }];
+        return [
+            {
+                user_id: this.localSfuUserId,
+                device_id: this.localSfuDeviceId,
+            },
+        ];
     }
 
     /**
@@ -9332,13 +9334,13 @@ export function fixNotificationCountOnDecryption(cli: MatrixClient, event: Matri
             const thread = room.getThread(event.threadRootId);
             hasReadEvent = thread
                 ? thread.hasUserReadEvent(cli.getUserId()!, event.getId()!)
-                // If the thread object does not exist in the room yet, we don't
-                // want to calculate notification for this event yet. We have not
-                // restored the read receipts yet and can't accurately calculate
-                // highlight notifications at this stage.
-                //
-                // This issue can likely go away when MSC3874 is implemented
-                : true;
+                : // If the thread object does not exist in the room yet, we don't
+                  // want to calculate notification for this event yet. We have not
+                  // restored the read receipts yet and can't accurately calculate
+                  // highlight notifications at this stage.
+                  //
+                  // This issue can likely go away when MSC3874 is implemented
+                  true;
         } else {
             hasReadEvent = room.hasUserReadEvent(cli.getUserId()!, event.getId()!);
         }
diff --git a/src/webrtc/call.ts b/src/webrtc/call.ts
index d2be48a4169..bad04ef1cb8 100644
--- a/src/webrtc/call.ts
+++ b/src/webrtc/call.ts
@@ -44,21 +44,19 @@ import {
     MCallCandidates,
     MCallBase,
     MCallHangupReject,
-    ISfuTrackDesc,
-    ISfuBaseDataChannelMessage,
-    ISfuSelectDataChannelMessage,
-    ISfuAnswerDataChannelMessage,
-    ISfuPublishDataChannelMessage,
-    ISfuUnpublishDataChannelMessage,
-    ISfuOfferDataChannelMessage,
-    SFUDataChannelMessageOp,
-    ISfuMetadataDataChannelMessage,
+    FocusTrackDescription,
+    FocusTrackSubscriptionEvent,
+    FocusNegotiateEvent,
+    FocusSDPStreamMetadataChangedEvent,
     SDPStreamMetadataTracks,
-} from './callEventTypes';
-import { CallFeed } from './callFeed';
+    FocusEvent,
+    SDPStreamMetadataKeyStable,
+    FocusEventBaseContent,
+} from "./callEventTypes";
+import { CallFeed } from "./callFeed";
 import { MatrixClient } from "../client";
 import { EventEmitterEvents, TypedEventEmitter } from "../models/typed-event-emitter";
-import { DeviceInfo } from '../crypto/deviceinfo';
+import { DeviceInfo } from "../crypto/deviceinfo";
 import { IScreensharingOpts } from "./mediaHandler";
 import { GroupCallUnknownDeviceError } from "./groupCall";
 import { MatrixError } from "../http-api";
@@ -269,8 +267,6 @@ const CALL_TIMEOUT_MS = 60 * 1000; // ms
 const CALL_LENGTH_INTERVAL = 1000; // ms
 /** The time after which we end the call, if ICE got disconnected */
 const ICE_DISCONNECTED_TIMEOUT = 30 * 1000; // ms
-/** The time after which the SFU will consider the connection as stale */
-const SFU_KEEP_ALIVE_INTERVAL = 30 * 1000; // 30 seconds
 
 export class CallError extends Error {
     public readonly code: string;
@@ -356,7 +352,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
     // our transceivers for each purpose and type of media
     private transceivers = new Map<TransceiverKey, RTCRtpTransceiver>();
-    private subscribedTracks: ISfuTrackDesc[] = [];
+    private subscribedTracks: FocusTrackDescription[] = [];
 
     private inviteOrAnswerSent = false;
     private waitForLocalAVStream = false;
@@ -699,11 +695,11 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
         logger.info(
             `Call ${this.callId} Pushed remote stream (` +
-            `id="${stream.id}" ` +
-            `active="${stream.active}" ` +
-            `purpose=${purpose} ` +
-            `userId=${userId}` +
-            `)`,
+                `id="${stream.id}" ` +
+                `active="${stream.active}" ` +
+                `purpose=${purpose} ` +
+                `userId=${userId}` +
+                `)`,
         );
     }
 
@@ -722,7 +718,8 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
         // If we already have a stream, check this stream has the same id
         if (oldRemoteStream && stream.id !== oldRemoteStream.id) {
             logger.warn(
-                `Call ${this.callId} Ignoring new stream ID ${stream.id}: `+`we already have stream ID ${oldRemoteStream.id}`,
+                `Call ${this.callId} Ignoring new stream ID ${stream.id}: ` +
+                    `we already have stream ID ${oldRemoteStream.id}`,
             );
             return;
         }
@@ -849,20 +846,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
                 `purpose="${callFeed.purpose}")`,
         );
 
-        // If we're calling with an SFU and we aren't setting up the call, we
-        // send the offer manually
-        if (this.isFocus && this.state !== CallState.Fledgling && addToPeerConnection) {
-            this.peerConn!.createOffer().then(async (offer) => {
-                await this.peerConn!.setLocalDescription(offer);
-
-                this.sendSFUDataChannelMessage(SFUDataChannelMessageOp.Publish, {
-                    sdp: offer.sdp,
-                } as ISfuPublishDataChannelMessage);
-                this.emit(CallEvent.FeedsChanged, this.feeds);
-            });
-        } else {
-            this.emit(CallEvent.FeedsChanged, this.feeds);
-        }
+        this.emit(CallEvent.FeedsChanged, this.feeds);
     }
 
     /**
@@ -874,7 +858,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
         const audioTransceiverKey = getTransceiverKey(callFeed.purpose, "audio");
         const videoTransceiverKey = getTransceiverKey(callFeed.purpose, "video");
 
-        const tracksToUnpublish: ISfuTrackDesc[] = [];
+        const tracksToUnpublish: FocusTrackDescription[] = [];
         for (const transceiverKey of [audioTransceiverKey, videoTransceiverKey]) {
             // this is slightly mixing the track and transceiver API but is basically just shorthand.
             // There is no way to actually remove a transceiver, so this just sets it to inactive
@@ -898,17 +882,6 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
         }
 
         this.deleteFeed(callFeed);
-
-        if (this.isFocus) {
-            this.peerConn!.createOffer().then(async (offer) => {
-                await this.peerConn!.setLocalDescription(offer);
-
-                this.sendSFUDataChannelMessage(SFUDataChannelMessageOp.Unpublish, {
-                    sdp: offer.sdp,
-                    stop: tracksToUnpublish,
-                } as ISfuUnpublishDataChannelMessage);
-            });
-        }
     }
 
     private deleteAllFeeds(): void {
@@ -979,8 +952,9 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
         if (sdpStreamMetadata) {
             this.updateRemoteSDPStreamMetadata(sdpStreamMetadata);
         } else if (!this.isFocus) {
-            logger.debug(`Call ${
-                this.callId} did not get any SDPStreamMetadata! Can not send/receive multiple streams`);
+            logger.debug(
+                `Call ${this.callId} did not get any SDPStreamMetadata! Can not send/receive multiple streams`,
+            );
         }
 
         this.peerConn = this.createPeerConnection();
@@ -1554,7 +1528,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
     public async sendMetadataUpdate(): Promise<void> {
         if (this.isFocus) {
-            this.sendSFUDataChannelMessage(SFUDataChannelMessageOp.Metadata);
+            this.sendFocusEvent(EventType.CallSDPStreamMetadataChanged);
         } else {
             await this.sendVoipEvent(EventType.CallSDPStreamMetadataChangedPrefix, {
                 [SDPStreamMetadataKey]: this.getLocalSDPStreamMetadata(),
@@ -1975,7 +1949,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
     private onDataChannelMessage = async (event: MessageEvent): Promise<void> => {
         // TODO: play nice with application layer DC listeners
 
-        let json: ISfuBaseDataChannelMessage;
+        let json: FocusEvent;
         try {
             json = JSON.parse(event.data);
         } catch (e) {
@@ -1983,52 +1957,59 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
             return;
         }
 
-        if (!json.op) {
-            logger.warn("Ignoring unrecognized DC event:", json.op);
+        if (!json.type) {
+            logger.warn("Ignoring unrecognized DC event:", json);
             return;
         }
 
-        logger.warn(`Received DC ${json.op} event`, json);
+        logger.info(`Received DC ${json.type} event`, json);
 
-        switch (json.op) {
-            case SFUDataChannelMessageOp.Offer: {
-                try {
-                    const offer = json as ISfuOfferDataChannelMessage;
-                    this.updateRemoteSDPStreamMetadata(offer.metadata!);
-                    await this.peerConn!.setRemoteDescription({
-                        "type": "offer",
-                        "sdp": offer.sdp,
-                    });
+        switch (json.type) {
+            case EventType.CallNegotiate: {
+                // TODO: Use MatrixCall::onNegotiateReceived()
 
-                    const answer = await this.peerConn!.createAnswer();
-                    await this.peerConn!.setLocalDescription(answer);
+                const negotiate = json.content as FocusNegotiateEvent;
+                this.updateRemoteSDPStreamMetadata(negotiate[SDPStreamMetadataKeyStable]!);
+                
+                if (!["offer", "answer"].includes(negotiate.description.type)) {
+                    throw new Error("Unknown description type - ignoring");
+                }
 
-                    this.sendSFUDataChannelMessage(SFUDataChannelMessageOp.Answer, {
-                        sdp: answer.sdp,
-                    } as ISfuAnswerDataChannelMessage);
-                } catch (e) {
-                    logger.debug(`Call ${this.callId} Failed to set remote description`, e);
+                try {
+                    await this.peerConn!.setRemoteDescription(negotiate.description);
+                } catch (error) {
+                    logger.debug(`Call ${this.callId} Failed to set remote description`, error);
                     this.terminate(CallParty.Local, CallErrorCode.SetRemoteDescription, false);
                     return;
                 }
+
+                if (negotiate.description.type === "offer") {
+                    try {
+                        const answer = await this.peerConn!.createAnswer();
+                        await this.peerConn!.setLocalDescription(answer);
+
+                        this.sendFocusEvent(EventType.CallNegotiate, {
+                            description: answer,
+                        } as FocusNegotiateEvent);
+                    } catch (error) {
+                        logger.debug(`Call ${this.callId} Failed to set local description`, error);
+                        this.terminate(CallParty.Local, CallErrorCode.SetLocalDescription, false);
+                        return;
+                    }
+                }
             }
                 break;
-            case SFUDataChannelMessageOp.Answer: {
-                const answer = json as ISfuAnswerDataChannelMessage;
-                this.updateRemoteSDPStreamMetadata(answer.metadata!);
-                await this.peerConn!.setRemoteDescription({
-                    type: "answer",
-                    sdp: answer.sdp,
-                });
+            case EventType.CallSDPStreamMetadataChanged: {
+                const metadata = json.content as FocusSDPStreamMetadataChangedEvent;
+                this.updateRemoteSDPStreamMetadata(metadata[SDPStreamMetadataKeyStable]!);
             }
                 break;
-            case SFUDataChannelMessageOp.Metadata: {
-                const metadata = json as ISfuMetadataDataChannelMessage;
-                this.updateRemoteSDPStreamMetadata(metadata.metadata!);
+            case EventType.CallPing: {
+                this.sendFocusEvent(EventType.CallPong);
             }
                 break;
             default:
-                logger.warn("Ignoring unrecognized DC event op ", json.op);
+                logger.warn("Ignoring unrecognized DC event op ", json.type);
 
                 break;
         }
@@ -2036,7 +2017,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
     private async waitForDatachannelToBeOpen(): Promise<void> {
         if (this.dataChannel?.readyState === 'connecting') {
-            const p = new Promise<void>(resolve => {
+            const p = new Promise<void>((resolve) => {
                 this.dataChannel!.onopen = (): void => resolve();
                 this.dataChannel!.onclose = (): void => resolve();
             });
@@ -2050,24 +2031,24 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
         if (!this.remoteSDPStreamMetadata) return;
         if (this.dataChannel?.readyState !== "open") return;
 
-        const tracks: ISfuTrackDesc[] = Object.entries(this.remoteSDPStreamMetadata)
+        const tracks: FocusTrackDescription[] = Object.entries(this.remoteSDPStreamMetadata)
             .filter(([, info]) => Boolean(info.tracks)) // Skip trackless feeds
-            .reduce((a: ISfuTrackDesc[], [s, i]) => (
+            .reduce((a: FocusTrackDescription[], [s, i]) => (
                 [...a, ...Object.keys(i.tracks).map((t) => ({ stream_id: s, track_id: t }))]
             ), []) // Get array of tracks from feeds
             .filter((track) => !this.subscribedTracks.find((subscribed) => utils.deepCompare(track, subscribed))); // Filter out already subscribed tracks
 
         if (tracks.length === 0) {
-            logger.warn("Failed to find any new streams to subscribe to");
+            logger.info("Failed to find any new streams to subscribe to");
             return;
         } else {
             this.subscribedTracks.push(...tracks);
-            logger.warn("Subscribing to:", tracks);
         }
 
-        this.sendSFUDataChannelMessage(SFUDataChannelMessageOp.Select, {
-            start: tracks,
-        } as ISfuSelectDataChannelMessage);
+        this.sendFocusEvent(EventType.CallTrackSubscription, {
+            subscribe: tracks,
+            unsubscribe: [],
+        } as FocusTrackSubscriptionEvent);
     }
 
     public updateRemoteSDPStreamMetadata(metadata: SDPStreamMetadata): void {
@@ -2167,6 +2148,18 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
         if (this.callHasEnded()) return;
 
+        // TODO: Handle this better
+        // Other than the initial offer, we handle negotiation manually when calling with an SFU
+        if (this.isFocus && ![CallState.Fledgling, CallState.CreateOffer].includes(this.state)) {
+            this.sendFocusEvent(EventType.CallNegotiate, {
+                description: this.peerConn!.localDescription?.toJSON(),
+            } as FocusNegotiateEvent);
+
+            // TODO: Handle errors
+
+            return;
+        }
+
         const eventType = this.state === CallState.CreateOffer ? EventType.CallInvite : EventType.CallNegotiate;
 
         const content = {
@@ -2281,12 +2274,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
                     this.emit(CallEvent.LengthChanged, Math.round((Date.now() - this.callStartTime!) / 1000));
                 }, CALL_LENGTH_INTERVAL);
             }
-            if (!this.sfuKeepAliveInterval) {
-                this.sfuKeepAliveInterval = setInterval(() => {
-                    this.sendSFUDataChannelMessage(SFUDataChannelMessageOp.Alive);
-                }, SFU_KEEP_ALIVE_INTERVAL * 3 / 4);
-            }
-        } else if (this.peerConn?.iceConnectionState == 'failed') {
+        } else if (this.peerConn?.iceConnectionState == "failed") {
             // Firefox for Android does not yet have support for restartIce()
             // (the types say it's always defined though, so we have to cast
             // to prevent typescript from warning).
@@ -2332,6 +2320,15 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
         if (!this.removeTrackListeners.has(stream)) {
             const onRemoveTrack = (): void => {
                 if (stream.getTracks().length === 0) {
+                    // FIXME: We should really be doing this per-track. Šimon
+                    // leaves this for when we switch to mids for signalling
+                    const getIndex = (): number => this.subscribedTracks.findIndex((t) => t.stream_id === stream.id);
+                    let indexOfTrackToRemove = getIndex();
+                    while (indexOfTrackToRemove !== -1) {
+                        this.subscribedTracks.splice(indexOfTrackToRemove, 1);
+                        indexOfTrackToRemove = getIndex();
+                    }
+
                     logger.info(`Call ${this.callId} removing track streamId: ${stream.id}`);
                     this.deleteFeedByStream(stream);
                     stream.removeEventListener("removetrack", onRemoveTrack);
@@ -2388,9 +2385,6 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
     }
 
     private onNegotiationNeeded = async (): Promise<void> => {
-        // Other than the initial offer, we handle negotiation manually when calling with an SFU
-        if (this.isFocus && ![CallState.Fledgling, CallState.CreateOffer].includes(this.state)) return;
-
         logger.info(`Call ${this.callId} Negotiation is needed!`);
 
         if (this.state !== CallState.CreateOffer && this.opponentVersion === 0) {
@@ -2508,18 +2502,19 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
         }
     }
 
-    private sendSFUDataChannelMessage(op: SFUDataChannelMessageOp, content: object = {}): void {
-        const realContent: ISfuBaseDataChannelMessage = Object.assign(content, {
-            op: op,
-        });
+    private sendFocusEvent(type: EventType, content: FocusEventBaseContent = {}): void {
+        const event: FocusEvent = {
+            type: type,
+            content: content,
+        };
 
-        if (![SFUDataChannelMessageOp.Select, SFUDataChannelMessageOp.Alive].includes(op)) {
-            realContent.metadata = this.getLocalSDPStreamMetadata();
+        if ([EventType.CallNegotiate, EventType.CallSDPStreamMetadataChanged].includes(type)) {
+            event.content[SDPStreamMetadataKeyStable] = this.getLocalSDPStreamMetadata();
         }
 
         // FIXME: RPC reliability over DC
-        this.dataChannel!.send(JSON.stringify(realContent));
-        logger.warn(`Sent ${realContent.op} over DC:`, realContent);
+        this.dataChannel!.send(JSON.stringify(event));
+        logger.warn(`Sent ${event.type} over DC:`, event);
     }
 
     /**
diff --git a/src/webrtc/callEventTypes.ts b/src/webrtc/callEventTypes.ts
index 47121ede325..207b7c1a67f 100644
--- a/src/webrtc/callEventTypes.ts
+++ b/src/webrtc/callEventTypes.ts
@@ -1,10 +1,12 @@
 // allow non-camelcase as these are events type that go onto the wire
 /* eslint-disable camelcase */
 
+import { EventType } from "../matrix";
 import { CallErrorCode } from "./call";
 
 // TODO: Change to "sdp_stream_metadata" when MSC3077 is merged
 export const SDPStreamMetadataKey = "org.matrix.msc3077.sdp_stream_metadata";
+export const SDPStreamMetadataKeyStable = "m.sdp_stream_metadata";
 
 export enum SDPStreamMetadataPurpose {
     Usermedia = "m.usermedia",
@@ -98,58 +100,36 @@ export interface MCallHangupReject extends MCallBase {
     reason?: CallErrorCode;
 }
 
-export interface ISfuTrackDesc {
+export interface FocusTrackDescription {
     stream_id: string;
     track_id: string;
 }
 
-export enum SFUDataChannelMessageOp {
-    Select = "select",
-    Offer = "offer",
-    Answer = "answer",
-    Publish = "publish",
-    Unpublish = "unpublish",
-    Metadata = "metadata",
-    Alive = "alive",
+export interface FocusEvent {
+    type: EventType;
+    content: FocusEventBaseContent;
 }
 
-export interface ISfuBaseDataChannelMessage {
-    op: SFUDataChannelMessageOp;
-    metadata?: SDPStreamMetadata;
+export interface FocusEventBaseContent {
+    [SDPStreamMetadataKeyStable]?: SDPStreamMetadata;
 }
 
-export interface ISfuSelectDataChannelMessage extends ISfuBaseDataChannelMessage {
-    op: SFUDataChannelMessageOp.Select;
-    start: ISfuTrackDesc[];
+export interface FocusTrackSubscriptionEvent extends FocusEventBaseContent {
+    subscribe: FocusTrackDescription[];
+    unsubscribe: FocusTrackDescription[];
 }
 
-export interface ISfuOfferDataChannelMessage extends ISfuBaseDataChannelMessage {
-    op: SFUDataChannelMessageOp.Offer;
-    sdp: string;
-}
-
-export interface ISfuAnswerDataChannelMessage extends ISfuBaseDataChannelMessage {
-    op: SFUDataChannelMessageOp.Answer;
-    sdp: string;
-}
-
-export interface ISfuPublishDataChannelMessage extends ISfuBaseDataChannelMessage {
-    op: SFUDataChannelMessageOp.Publish;
-    sdp: string;
+export interface FocusNegotiateEvent extends FocusEventBaseContent {
+    description: RTCSessionDescription;
+    [SDPStreamMetadataKeyStable]: SDPStreamMetadata;
 }
 
-export interface ISfuUnpublishDataChannelMessage extends ISfuBaseDataChannelMessage {
-    op: SFUDataChannelMessageOp.Unpublish;
-    sdp: string;
-    stop: ISfuTrackDesc[];
+export interface FocusSDPStreamMetadataChangedEvent extends FocusEventBaseContent {
+    [SDPStreamMetadataKeyStable]: SDPStreamMetadata;
 }
 
-export interface ISfuMetadataDataChannelMessage extends ISfuBaseDataChannelMessage {
-    op: SFUDataChannelMessageOp.Metadata;
-}
+export interface FocusPingEvent extends FocusEventBaseContent {}
 
-export interface ISfuKeepAliveDataChannelMessage extends ISfuBaseDataChannelMessage {
-    op: SFUDataChannelMessageOp.Alive;
-}
+export interface FocusPongEvent extends FocusEventBaseContent {}
 
 /* eslint-enable camelcase */
diff --git a/src/webrtc/groupCall.ts b/src/webrtc/groupCall.ts
index b457d4a02c7..1c40cf0afa7 100644
--- a/src/webrtc/groupCall.ts
+++ b/src/webrtc/groupCall.ts
@@ -335,9 +335,11 @@ export class GroupCall extends TypedEventEmitter<
 
     private getPreferredFoci(): IFocusInfo[] {
         const preferredFoci = this.client.getFoci();
-        const isUsingPreferredFocus = Boolean(preferredFoci.find(pf => (
-            this.foci.find(f => pf.user_id === f.user_id && pf.device_id === pf.device_id)
-        )));
+        const isUsingPreferredFocus = Boolean(
+            preferredFoci.find((pf) =>
+                this.foci.find((f) => pf.user_id === f.user_id && pf.device_id === pf.device_id),
+            ),
+        );
 
         return isUsingPreferredFocus ? [] : preferredFoci;
     }
@@ -457,17 +459,14 @@ export class GroupCall extends TypedEventEmitter<
 
         this.activeSpeaker = undefined;
         this.onActiveSpeakerLoop();
-        this.activeSpeakerLoopInterval = setInterval(
-            this.onActiveSpeakerLoop,
-            this.activeSpeakerInterval,
-        );
+        this.activeSpeakerLoopInterval = setInterval(this.onActiveSpeakerLoop, this.activeSpeakerInterval);
 
         if (this.foci[0]) {
             const opponentDevice = {
-                "device_id": this.foci[0].device_id,
+                device_id: this.foci[0].device_id,
                 // XXX: What if an SFU gets restarted?
-                "session_id": "sfu",
-                "feeds": [],
+                session_id: "sfu",
+                feeds: [],
             };
 
             const onError = (e?: unknown): void => {
@@ -481,17 +480,13 @@ export class GroupCall extends TypedEventEmitter<
                 );
             };
 
-            const sfuCall = createNewMatrixCall(
-                this.client,
-                this.room.roomId,
-                {
-                    invitee: this.foci[0].user_id,
-                    opponentDeviceId: opponentDevice.device_id,
-                    opponentSessionId: opponentDevice.session_id,
-                    groupCallId: this.groupCallId,
-                    isFocus: true,
-                },
-            );
+            const sfuCall = createNewMatrixCall(this.client, this.room.roomId, {
+                invitee: this.foci[0].user_id,
+                opponentDeviceId: opponentDevice.device_id,
+                opponentSessionId: opponentDevice.session_id,
+                groupCallId: this.groupCallId,
+                isFocus: true,
+            });
             if (!sfuCall) {
                 onError();
                 return;
@@ -517,10 +512,10 @@ export class GroupCall extends TypedEventEmitter<
         // Try to find a focus of another user to use
         let focusOfAnotherMember: IFocusInfo | undefined;
         for (const event of this.getMemberStateEvents()) {
-            const focus = event.getContent<IGroupCallRoomMemberState>()
-                ?.["m.calls"] ?.[0]
-                ?.["m.devices"]?.[0]
-                ?.["m.foci.active"]?.[0];
+            const focus =
+                event.getContent<IGroupCallRoomMemberState>()?.["m.calls"]?.[0]?.["m.devices"]?.[0]?.[
+                    "m.foci.active"
+                ]?.[0];
             if (focus) {
                 focusOfAnotherMember = focus;
                 break;
@@ -759,10 +754,9 @@ export class GroupCall extends TypedEventEmitter<
                 );
 
                 // TODO: handle errors
-                this.forEachCall(call => call.pushLocalFeed(call.isFocus
-                    ? this.localScreenshareFeed!
-                    : this.localScreenshareFeed!.clone(),
-                ));
+                this.forEachCall((call) =>
+                    call.pushLocalFeed(call.isFocus ? this.localScreenshareFeed! : this.localScreenshareFeed!.clone()),
+                );
 
                 return true;
             } catch (error) {
@@ -1073,18 +1067,22 @@ export class GroupCall extends TypedEventEmitter<
 
     private onCallFeedsChanged = (call: MatrixCall): void => {
         // Find removed feeds
-        [...this.userMediaFeeds, ...this.screenshareFeeds].filter((gf) => gf.disposed).forEach((feed) => {
-            if (feed.purpose === SDPStreamMetadataPurpose.Usermedia) this.removeUserMediaFeed(feed);
-            else if (feed.purpose === SDPStreamMetadataPurpose.Screenshare) this.removeScreenshareFeed(feed);
-        });
+        [...this.userMediaFeeds, ...this.screenshareFeeds]
+            .filter((gf) => gf.disposed)
+            .forEach((feed) => {
+                if (feed.purpose === SDPStreamMetadataPurpose.Usermedia) this.removeUserMediaFeed(feed);
+                else if (feed.purpose === SDPStreamMetadataPurpose.Screenshare) this.removeScreenshareFeed(feed);
+            });
 
         // Find new feeds
-        call.getRemoteFeeds().filter((cf) => {
-            return !this.userMediaFeeds.find((gf) => gf.stream.id === cf.stream.id);
-        }).forEach((feed) => {
-            if (feed.purpose === SDPStreamMetadataPurpose.Usermedia) this.addUserMediaFeed(feed);
-            else if (feed.purpose === SDPStreamMetadataPurpose.Screenshare) this.addScreenshareFeed(feed);
-        });
+        call.getRemoteFeeds()
+            .filter((cf) => {
+                return !this.userMediaFeeds.find((gf) => gf.stream.id === cf.stream.id);
+            })
+            .forEach((feed) => {
+                if (feed.purpose === SDPStreamMetadataPurpose.Usermedia) this.addUserMediaFeed(feed);
+                else if (feed.purpose === SDPStreamMetadataPurpose.Screenshare) this.addScreenshareFeed(feed);
+            });
     };
 
     private onCallStateChanged = (call: MatrixCall, state: CallState, _oldState: CallState | undefined): void => {
@@ -1374,7 +1372,7 @@ export class GroupCall extends TypedEventEmitter<
                 "device_id": this.client.getDeviceId()!,
                 "session_id": this.client.getSessionId(),
                 "expires_ts": Date.now() + DEVICE_TIMEOUT,
-                "feeds": this.getLocalFeeds().map(feed => ({ purpose: feed.purpose })),
+                "feeds": this.getLocalFeeds().map((feed) => ({ purpose: feed.purpose })),
                 "m.foci.active": this.foci,
                 "m.foci.preferred": this.getPreferredFoci(),
                 // TODO: Add data channels