Group calling SFU URL should be configurable

config/default.json

@@ -11,6 +11,7 @@
   "contentProxyUrl": "http://contentproxy.signal.org:443",
   "updatesUrl": "https://updates2.signal.org/desktop",
   "updatesPublicKey": "fd7dd3de7149dc0a127909fee7de0f7620ddd0de061b37a2c303e37de802a401",
+  "sfuUrl": "https://sfu.voip.signal.org/",
   "updatesEnabled": false,
   "openDevTools": false,
   "buildExpiration": 0,

main.js

@@ -204,6 +204,7 @@ function prepareURL(pathSegments, moreKeys) {
       appInstance: process.env.NODE_APP_INSTANCE,
       proxyUrl: process.env.HTTPS_PROXY || process.env.https_proxy,
       contentProxyUrl: config.contentProxyUrl,
+      sfuUrl: config.get('sfuUrl'),
       importMode: importMode ? true : undefined, // for stringify()
       serverPublicParams: config.get('serverPublicParams'),
       serverTrustRoot: config.get('serverTrustRoot'),

preload.js

@@ -45,6 +45,7 @@ try {
   window.getHostName = () => config.hostname;
   window.getServerTrustRoot = () => config.serverTrustRoot;
   window.getServerPublicParams = () => config.serverPublicParams;
+  window.getSfuUrl = () => config.sfuUrl;
   window.isBehindProxy = () => Boolean(config.proxyUrl);
 
   function setSystemTheme() {

ts/background.ts

@@ -646,7 +646,10 @@ type WhatIsThis = import('./window.d').WhatIsThis;
         window.reduxActions.updates,
         window.Whisper.events
       );
-      window.Signal.Services.calling.initialize(window.reduxActions.calling);
+      window.Signal.Services.calling.initialize(
+        window.reduxActions.calling,
+        window.getSfuUrl()
+      );
       window.reduxActions.expiration.hydrateExpirationStatus(
         window.Signal.Util.hasExpired()
       );

ts/services/calling.ts

@@ -55,8 +55,6 @@ import { fetchMembershipProof, getMembershipList } from '../groups';
 import { missingCaseError } from '../util/missingCaseError';
 import { normalizeGroupCallTimestamp } from '../util/ringrtc/normalizeGroupCallTimestamp';
 
-const RINGRTC_SFU_URL = 'https://sfu.voip.signal.org/';
-
 const RINGRTC_HTTP_METHOD_TO_OUR_HTTP_METHOD: Map<
   HttpMethod,
   'GET' | 'PUT' | 'POST' | 'DELETE'
@@ -92,6 +90,8 @@ export class CallingClass {
 
   private uxActions?: UxActionsType;
 
+  private sfuUrl?: string;
+
   private lastMediaDeviceSettings?: MediaDeviceSettings;
 
   private deviceReselectionTimer?: NodeJS.Timeout;
@@ -105,11 +105,14 @@ export class CallingClass {
     this.callsByConversation = {};
   }
 
-  initialize(uxActions: UxActionsType): void {
+  initialize(uxActions: UxActionsType, sfuUrl: string): void {
     this.uxActions = uxActions;
     if (!uxActions) {
       throw new Error('CallingClass.initialize: Invalid uxActions.');
     }
+
+    this.sfuUrl = sfuUrl;
+
     RingRTC.handleOutgoingSignaling = this.handleOutgoingSignaling.bind(this);
     RingRTC.handleIncomingCall = this.handleIncomingCall.bind(this);
     RingRTC.handleAutoEndedIncomingCallRequest = this.handleAutoEndedIncomingCallRequest.bind(
@@ -333,6 +336,10 @@ export class CallingClass {
       return statefulPeekInfo;
     }
 
+    if (!this.sfuUrl) {
+      throw new Error('Missing SFU URL; not peeking group call');
+    }
+
     const conversation = window.ConversationController.get(conversationId);
     if (!conversation) {
       throw new Error('Missing conversation; not peeking group call');
@@ -352,7 +359,7 @@ export class CallingClass {
     const membershipProof = new TextEncoder().encode(proof).buffer;
 
     return RingRTC.peekGroupCall(
-      RINGRTC_SFU_URL,
+      this.sfuUrl,
       membershipProof,
       this.getGroupCallMembers(conversationId)
     );
@@ -388,22 +395,21 @@ export class CallingClass {
       return existing;
     }
 
+    if (!this.sfuUrl) {
+      throw new Error('Missing SFU URL; not connecting group call');
+    }
+
     const groupIdBuffer = base64ToArrayBuffer(groupId);
 
     let updateMessageState = GroupCallUpdateMessageState.SentNothing;
     let isRequestingMembershipProof = false;
 
-    const outerGroupCall = RingRTC.getGroupCall(
-      groupIdBuffer,
-      RINGRTC_SFU_URL,
-      {
+    const outerGroupCall = RingRTC.getGroupCall(groupIdBuffer, this.sfuUrl, {
       onLocalDeviceStateChanged: groupCall => {
         const localDeviceState = groupCall.getLocalDeviceState();
         const { eraId } = groupCall.getPeekInfo() || {};
 
-          if (
-            localDeviceState.connectionState === ConnectionState.NotConnected
-          ) {
+        if (localDeviceState.connectionState === ConnectionState.NotConnected) {
           // NOTE: This assumes that only one call is active at a time. For example, if
           //   there are two calls using the camera, this will disable both of them.
           //   That's fine for now, but this will break if that assumption changes.
@@ -470,8 +476,7 @@ export class CallingClass {
         groupCall.setGroupMembers(this.getGroupCallMembers(conversationId));
       },
       onEnded: noop,
-      }
-    );
+    });
 
     if (!outerGroupCall) {
       // This should be very rare, likely due to RingRTC not being able to get a lock

ts/window.d.ts

@@ -114,6 +114,7 @@ declare global {
     getMediaCameraPermissions: () => Promise<boolean>;
     getMediaPermissions: () => Promise<boolean>;
     getServerPublicParams: () => string;
+    getSfuUrl: () => string;
     getSocketStatus: () => number;
     getSyncRequest: () => WhatIsThis;
     getTitle: () => string;