EC update and improvements

Velin92 · Velin92 · commit 98a95342d046 · 2025-03-26T13:13:28.000+01:00
Use .startCall intent, and always pass rageshakeURL to the widget

Updated EC to 0.9.0-rc.4

rageshakeURL is now a parameter
diff --git a/ElementX.xcodeproj/project.pbxproj b/ElementX.xcodeproj/project.pbxproj
@@ -8585,7 +8585,7 @@
 			repositoryURL = "https://github.com/element-hq/element-call-swift";
 			requirement = {
 				kind = exactVersion;
-				version = "0.9.0-rc.3";
+				version = "0.9.0-rc.4";
 			};
 		};
 		821C67C9A7F8CC3FD41B28B4 /* XCRemoteSwiftPackageReference "emojibase-bindings" */ = {
diff --git a/ElementX.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved b/ElementX.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved
diff --git a/ElementX/Sources/Mocks/Generated/GeneratedMocks.swift b/ElementX/Sources/Mocks/Generated/GeneratedMocks.swift
@@ -5989,72 +5989,72 @@ class ElementCallWidgetDriverMock: ElementCallWidgetDriverProtocol, @unchecked S
 
     //MARK: - start
 
-    var startBaseURLClientIDColorSchemeAnalyticsConfigurationUnderlyingCallsCount = 0
-    var startBaseURLClientIDColorSchemeAnalyticsConfigurationCallsCount: Int {
+    var startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationUnderlyingCallsCount = 0
+    var startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationCallsCount: Int {
         get {
             if Thread.isMainThread {
-                return startBaseURLClientIDColorSchemeAnalyticsConfigurationUnderlyingCallsCount
+                return startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationUnderlyingCallsCount
             } else {
                 var returnValue: Int? = nil
                 DispatchQueue.main.sync {
-                    returnValue = startBaseURLClientIDColorSchemeAnalyticsConfigurationUnderlyingCallsCount
+                    returnValue = startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationUnderlyingCallsCount
                 }
 
                 return returnValue!
             }
         }
         set {
             if Thread.isMainThread {
-                startBaseURLClientIDColorSchemeAnalyticsConfigurationUnderlyingCallsCount = newValue
+                startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationUnderlyingCallsCount = newValue
             } else {
                 DispatchQueue.main.sync {
-                    startBaseURLClientIDColorSchemeAnalyticsConfigurationUnderlyingCallsCount = newValue
+                    startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationUnderlyingCallsCount = newValue
                 }
             }
         }
     }
-    var startBaseURLClientIDColorSchemeAnalyticsConfigurationCalled: Bool {
-        return startBaseURLClientIDColorSchemeAnalyticsConfigurationCallsCount > 0
+    var startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationCalled: Bool {
+        return startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationCallsCount > 0
     }
-    var startBaseURLClientIDColorSchemeAnalyticsConfigurationReceivedArguments: (baseURL: URL, clientID: String, colorScheme: ColorScheme, analyticsConfiguration: ElementCallAnalyticsConfiguration?)?
-    var startBaseURLClientIDColorSchemeAnalyticsConfigurationReceivedInvocations: [(baseURL: URL, clientID: String, colorScheme: ColorScheme, analyticsConfiguration: ElementCallAnalyticsConfiguration?)] = []
+    var startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationReceivedArguments: (baseURL: URL, clientID: String, colorScheme: ColorScheme, rageshakeURL: String?, analyticsConfiguration: ElementCallAnalyticsConfiguration?)?
+    var startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationReceivedInvocations: [(baseURL: URL, clientID: String, colorScheme: ColorScheme, rageshakeURL: String?, analyticsConfiguration: ElementCallAnalyticsConfiguration?)] = []
 
-    var startBaseURLClientIDColorSchemeAnalyticsConfigurationUnderlyingReturnValue: Result<URL, ElementCallWidgetDriverError>!
-    var startBaseURLClientIDColorSchemeAnalyticsConfigurationReturnValue: Result<URL, ElementCallWidgetDriverError>! {
+    var startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationUnderlyingReturnValue: Result<URL, ElementCallWidgetDriverError>!
+    var startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationReturnValue: Result<URL, ElementCallWidgetDriverError>! {
         get {
             if Thread.isMainThread {
-                return startBaseURLClientIDColorSchemeAnalyticsConfigurationUnderlyingReturnValue
+                return startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationUnderlyingReturnValue
             } else {
                 var returnValue: Result<URL, ElementCallWidgetDriverError>? = nil
                 DispatchQueue.main.sync {
-                    returnValue = startBaseURLClientIDColorSchemeAnalyticsConfigurationUnderlyingReturnValue
+                    returnValue = startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationUnderlyingReturnValue
                 }
 
                 return returnValue!
             }
         }
         set {
             if Thread.isMainThread {
-                startBaseURLClientIDColorSchemeAnalyticsConfigurationUnderlyingReturnValue = newValue
+                startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationUnderlyingReturnValue = newValue
             } else {
                 DispatchQueue.main.sync {
-                    startBaseURLClientIDColorSchemeAnalyticsConfigurationUnderlyingReturnValue = newValue
+                    startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationUnderlyingReturnValue = newValue
                 }
             }
         }
     }
-    var startBaseURLClientIDColorSchemeAnalyticsConfigurationClosure: ((URL, String, ColorScheme, ElementCallAnalyticsConfiguration?) async -> Result<URL, ElementCallWidgetDriverError>)?
+    var startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationClosure: ((URL, String, ColorScheme, String?, ElementCallAnalyticsConfiguration?) async -> Result<URL, ElementCallWidgetDriverError>)?
 
-    func start(baseURL: URL, clientID: String, colorScheme: ColorScheme, analyticsConfiguration: ElementCallAnalyticsConfiguration?) async -> Result<URL, ElementCallWidgetDriverError> {
-        startBaseURLClientIDColorSchemeAnalyticsConfigurationCallsCount += 1
-        startBaseURLClientIDColorSchemeAnalyticsConfigurationReceivedArguments = (baseURL: baseURL, clientID: clientID, colorScheme: colorScheme, analyticsConfiguration: analyticsConfiguration)
+    func start(baseURL: URL, clientID: String, colorScheme: ColorScheme, rageshakeURL: String?, analyticsConfiguration: ElementCallAnalyticsConfiguration?) async -> Result<URL, ElementCallWidgetDriverError> {
+        startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationCallsCount += 1
+        startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationReceivedArguments = (baseURL: baseURL, clientID: clientID, colorScheme: colorScheme, rageshakeURL: rageshakeURL, analyticsConfiguration: analyticsConfiguration)
         DispatchQueue.main.async {
-            self.startBaseURLClientIDColorSchemeAnalyticsConfigurationReceivedInvocations.append((baseURL: baseURL, clientID: clientID, colorScheme: colorScheme, analyticsConfiguration: analyticsConfiguration))
+            self.startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationReceivedInvocations.append((baseURL: baseURL, clientID: clientID, colorScheme: colorScheme, rageshakeURL: rageshakeURL, analyticsConfiguration: analyticsConfiguration))
         }
-        if let startBaseURLClientIDColorSchemeAnalyticsConfigurationClosure = startBaseURLClientIDColorSchemeAnalyticsConfigurationClosure {
-            return await startBaseURLClientIDColorSchemeAnalyticsConfigurationClosure(baseURL, clientID, colorScheme, analyticsConfiguration)
+        if let startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationClosure = startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationClosure {
+            return await startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationClosure(baseURL, clientID, colorScheme, rageshakeURL, analyticsConfiguration)
         } else {
-            return startBaseURLClientIDColorSchemeAnalyticsConfigurationReturnValue
+            return startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationReturnValue
         }
     }
     //MARK: - handleMessage
diff --git a/ElementX/Sources/Mocks/JoinedRoomProxyMock.swift b/ElementX/Sources/Mocks/JoinedRoomProxyMock.swift
@@ -119,7 +119,7 @@ extension JoinedRoomProxyMock {
             fatalError()
         }
         
-        widgetDriver.startBaseURLClientIDColorSchemeAnalyticsConfigurationReturnValue = .success(url)
+        widgetDriver.startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationReturnValue = .success(url)
         
         elementCallWidgetDriverDeviceIDReturnValue = widgetDriver
         sendCallNotificationIfNeededReturnValue = .success(())
diff --git a/ElementX/Sources/Screens/CallScreen/CallScreenViewModel.swift b/ElementX/Sources/Screens/CallScreen/CallScreenViewModel.swift
@@ -142,7 +142,7 @@ class CallScreenViewModel: CallScreenViewModelType, CallScreenViewModelProtocol
             state.url = url
             // We need widget messaging to work before enabling CallKit, otherwise mute, hangup etc do nothing.
             
-        case .roomCall(let roomProxy, let clientProxy, let clientID, let elementCallBaseURL, let elementCallBaseURLOverride, let colorScheme, let notifyOtherParticipants):
+        case .roomCall(let roomProxy, _, let clientID, let elementCallBaseURL, let elementCallBaseURLOverride, let colorScheme, let notifyOtherParticipants):
             Task { [weak self] in
                 guard let self else { return }
                 
@@ -155,11 +155,11 @@ class CallScreenViewModel: CallScreenViewModelType, CallScreenViewModelProtocol
                 // We only set the analytics configuration if analytics are enabled
                 let analyticsConfiguration = analyticsService.isEnabled ? ElementCallAnalyticsConfiguration(posthogAPIHost: appSettings.elementCallPosthogAPIHost,
                                                                                                             posthogAPIKey: appSettings.elementCallPosthogAPIKey,
-                                                                                                            rageshakeSubmitURL: Secrets.rageshakeServerURL,
                                                                                                             sentryDSN: appSettings.elementCallPosthogSentryDSN) : nil
                 switch await widgetDriver.start(baseURL: baseURL,
                                                 clientID: clientID,
                                                 colorScheme: colorScheme,
+                                                rageshakeURL: Secrets.rageshakeServerURL,
                                                 analyticsConfiguration: analyticsConfiguration) {
                 case .success(let url):
                     state.url = url
diff --git a/ElementX/Sources/Screens/CallScreen/View/CallScreen.swift b/ElementX/Sources/Screens/CallScreen/View/CallScreen.swift
@@ -301,7 +301,7 @@ struct CallScreen_Previews: PreviewProvider {
         let widgetDriver = ElementCallWidgetDriverMock()
         widgetDriver.underlyingMessagePublisher = .init()
         widgetDriver.underlyingActions = PassthroughSubject<ElementCallWidgetDriverAction, Never>().eraseToAnyPublisher()
-        widgetDriver.startBaseURLClientIDColorSchemeAnalyticsConfigurationReturnValue = .success(URL.userDirectory)
+        widgetDriver.startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationReturnValue = .success(URL.userDirectory)
         
         roomProxy.elementCallWidgetDriverDeviceIDReturnValue = widgetDriver
         
diff --git a/ElementX/Sources/Services/ElementCall/ElementCallWidgetDriver.swift b/ElementX/Sources/Services/ElementCall/ElementCallWidgetDriver.swift
@@ -66,7 +66,11 @@ class ElementCallWidgetDriver: WidgetCapabilitiesProvider, ElementCallWidgetDriv
         self.deviceID = deviceID
     }
     
-    func start(baseURL: URL, clientID: String, colorScheme: ColorScheme, analyticsConfiguration: ElementCallAnalyticsConfiguration?) async -> Result<URL, ElementCallWidgetDriverError> {
+    func start(baseURL: URL,
+               clientID: String,
+               colorScheme: ColorScheme,
+               rageshakeURL: String?,
+               analyticsConfiguration: ElementCallAnalyticsConfiguration?) async -> Result<URL, ElementCallWidgetDriverError> {
         guard let room = room as? Room else {
             return .failure(.roomInvalid)
         }
@@ -85,12 +89,12 @@ class ElementCallWidgetDriver: WidgetCapabilitiesProvider, ElementCallWidgetDriv
                                                                           confineToRoom: true,
                                                                           font: nil,
                                                                           encryption: useEncryption ? .perParticipantKeys : .unencrypted,
-                                                                          intent: nil,
+                                                                          intent: .startCall,
                                                                           hideScreensharing: false,
                                                                           posthogUserId: nil,
                                                                           posthogApiHost: analyticsConfiguration?.posthogAPIHost,
                                                                           posthogApiKey: analyticsConfiguration?.posthogAPIKey,
-                                                                          rageshakeSubmitUrl: analyticsConfiguration?.rageshakeSubmitURL,
+                                                                          rageshakeSubmitUrl: rageshakeURL,
                                                                           sentryDsn: analyticsConfiguration?.sentryDSN,
                                                                           sentryEnvironment: nil))
         } catch {
diff --git a/ElementX/Sources/Services/ElementCall/ElementCallWidgetDriverProtocol.swift b/ElementX/Sources/Services/ElementCall/ElementCallWidgetDriverProtocol.swift
@@ -29,7 +29,11 @@ protocol ElementCallWidgetDriverProtocol {
     var messagePublisher: PassthroughSubject<String, Never> { get }
     var actions: AnyPublisher<ElementCallWidgetDriverAction, Never> { get }
     
-    func start(baseURL: URL, clientID: String, colorScheme: ColorScheme, analyticsConfiguration: ElementCallAnalyticsConfiguration?) async -> Result<URL, ElementCallWidgetDriverError>
+    func start(baseURL: URL,
+               clientID: String,
+               colorScheme: ColorScheme,
+               rageshakeURL: String?,
+               analyticsConfiguration: ElementCallAnalyticsConfiguration?) async -> Result<URL, ElementCallWidgetDriverError>
     
     /// Passes a message from the Widget to the SDK to handle, returning a Bool that represents whether or not the widget driver is still running.
     func handleMessage(_ message: String) async -> Result<Bool, ElementCallWidgetDriverError>
@@ -38,6 +42,5 @@ protocol ElementCallWidgetDriverProtocol {
 struct ElementCallAnalyticsConfiguration {
     let posthogAPIHost: String
     let posthogAPIKey: String
-    let rageshakeSubmitURL: String
     let sentryDSN: String
 }
diff --git a/ElementX/Sources/Services/ElementCall/GenericCallLinkWidgetDriver.swift b/ElementX/Sources/Services/ElementCall/GenericCallLinkWidgetDriver.swift
@@ -23,7 +23,11 @@ class GenericCallLinkWidgetDriver: ElementCallWidgetDriverProtocol {
         self.url = url
     }
     
-    func start(baseURL: URL, clientID: String, colorScheme: ColorScheme, analyticsConfiguration: ElementCallAnalyticsConfiguration?) async -> Result<URL, ElementCallWidgetDriverError> {
+    func start(baseURL: URL,
+               clientID: String,
+               colorScheme: ColorScheme,
+               rageshakeURL: String?,
+               analyticsConfiguration: ElementCallAnalyticsConfiguration?) async -> Result<URL, ElementCallWidgetDriverError> {
         MXLog.error("Nothing to start, use the configuration's URL directly instead.")
         return .success(url)
     }
diff --git a/project.yml b/project.yml
@@ -83,7 +83,7 @@ packages:
     # path: ../matrix-rich-text-editor/platforms/ios/lib/WysiwygComposer
   EmbeddedElementCall:
     url: https://github.com/element-hq/element-call-swift
-    exactVersion: 0.9.0-rc.3
+    exactVersion: 0.9.0-rc.4
   
   # External dependencies
   Algorithms:

Original file line number	Diff line number	Diff line change
`@@ -5989,72 +5989,72 @@ class ElementCallWidgetDriverMock: ElementCallWidgetDriverProtocol, @unchecked S`
`5989`	`5989`
`5990`	`5990`	`//MARK: - start`
`5991`	`5991`
`5992`		`- var startBaseURLClientIDColorSchemeAnalyticsConfigurationUnderlyingCallsCount = 0`
`5993`		`- var startBaseURLClientIDColorSchemeAnalyticsConfigurationCallsCount: Int {`
	`5992`	`+ var startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationUnderlyingCallsCount = 0`
	`5993`	`+ var startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationCallsCount: Int {`
`5994`	`5994`	`get {`
`5995`	`5995`	`if Thread.isMainThread {`
`5996`		`- return startBaseURLClientIDColorSchemeAnalyticsConfigurationUnderlyingCallsCount`
	`5996`	`+ return startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationUnderlyingCallsCount`
`5997`	`5997`	`} else {`
`5998`	`5998`	`var returnValue: Int? = nil`
`5999`	`5999`	`DispatchQueue.main.sync {`
`6000`		`- returnValue = startBaseURLClientIDColorSchemeAnalyticsConfigurationUnderlyingCallsCount`
	`6000`	`+ returnValue = startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationUnderlyingCallsCount`
`6001`	`6001`	`}`
`6002`	`6002`
`6003`	`6003`	`return returnValue!`
`6004`	`6004`	`}`
`6005`	`6005`	`}`
`6006`	`6006`	`set {`
`6007`	`6007`	`if Thread.isMainThread {`
`6008`		`- startBaseURLClientIDColorSchemeAnalyticsConfigurationUnderlyingCallsCount = newValue`
	`6008`	`+ startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationUnderlyingCallsCount = newValue`
`6009`	`6009`	`} else {`
`6010`	`6010`	`DispatchQueue.main.sync {`
`6011`		`- startBaseURLClientIDColorSchemeAnalyticsConfigurationUnderlyingCallsCount = newValue`
	`6011`	`+ startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationUnderlyingCallsCount = newValue`
`6012`	`6012`	`}`
`6013`	`6013`	`}`
`6014`	`6014`	`}`
`6015`	`6015`	`}`
`6016`		`- var startBaseURLClientIDColorSchemeAnalyticsConfigurationCalled: Bool {`
`6017`		`- return startBaseURLClientIDColorSchemeAnalyticsConfigurationCallsCount > 0`
	`6016`	`+ var startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationCalled: Bool {`
	`6017`	`+ return startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationCallsCount > 0`
`6018`	`6018`	`}`
`6019`		`- var startBaseURLClientIDColorSchemeAnalyticsConfigurationReceivedArguments: (baseURL: URL, clientID: String, colorScheme: ColorScheme, analyticsConfiguration: ElementCallAnalyticsConfiguration?)?`
`6020`		`- var startBaseURLClientIDColorSchemeAnalyticsConfigurationReceivedInvocations: [(baseURL: URL, clientID: String, colorScheme: ColorScheme, analyticsConfiguration: ElementCallAnalyticsConfiguration?)] = []`
	`6019`	`+ var startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationReceivedArguments: (baseURL: URL, clientID: String, colorScheme: ColorScheme, rageshakeURL: String?, analyticsConfiguration: ElementCallAnalyticsConfiguration?)?`
	`6020`	`+ var startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationReceivedInvocations: [(baseURL: URL, clientID: String, colorScheme: ColorScheme, rageshakeURL: String?, analyticsConfiguration: ElementCallAnalyticsConfiguration?)] = []`
`6021`	`6021`
`6022`		`- var startBaseURLClientIDColorSchemeAnalyticsConfigurationUnderlyingReturnValue: Result<URL, ElementCallWidgetDriverError>!`
`6023`		`- var startBaseURLClientIDColorSchemeAnalyticsConfigurationReturnValue: Result<URL, ElementCallWidgetDriverError>! {`
	`6022`	`+ var startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationUnderlyingReturnValue: Result<URL, ElementCallWidgetDriverError>!`
	`6023`	`+ var startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationReturnValue: Result<URL, ElementCallWidgetDriverError>! {`
`6024`	`6024`	`get {`
`6025`	`6025`	`if Thread.isMainThread {`
`6026`		`- return startBaseURLClientIDColorSchemeAnalyticsConfigurationUnderlyingReturnValue`
	`6026`	`+ return startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationUnderlyingReturnValue`
`6027`	`6027`	`} else {`
`6028`	`6028`	`var returnValue: Result<URL, ElementCallWidgetDriverError>? = nil`
`6029`	`6029`	`DispatchQueue.main.sync {`
`6030`		`- returnValue = startBaseURLClientIDColorSchemeAnalyticsConfigurationUnderlyingReturnValue`
	`6030`	`+ returnValue = startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationUnderlyingReturnValue`
`6031`	`6031`	`}`
`6032`	`6032`
`6033`	`6033`	`return returnValue!`
`6034`	`6034`	`}`
`6035`	`6035`	`}`
`6036`	`6036`	`set {`
`6037`	`6037`	`if Thread.isMainThread {`
`6038`		`- startBaseURLClientIDColorSchemeAnalyticsConfigurationUnderlyingReturnValue = newValue`
	`6038`	`+ startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationUnderlyingReturnValue = newValue`
`6039`	`6039`	`} else {`
`6040`	`6040`	`DispatchQueue.main.sync {`
`6041`		`- startBaseURLClientIDColorSchemeAnalyticsConfigurationUnderlyingReturnValue = newValue`
	`6041`	`+ startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationUnderlyingReturnValue = newValue`
`6042`	`6042`	`}`
`6043`	`6043`	`}`
`6044`	`6044`	`}`
`6045`	`6045`	`}`
`6046`		`- var startBaseURLClientIDColorSchemeAnalyticsConfigurationClosure: ((URL, String, ColorScheme, ElementCallAnalyticsConfiguration?) async -> Result<URL, ElementCallWidgetDriverError>)?`
	`6046`	`+ var startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationClosure: ((URL, String, ColorScheme, String?, ElementCallAnalyticsConfiguration?) async -> Result<URL, ElementCallWidgetDriverError>)?`
`6047`	`6047`
`6048`		`- func start(baseURL: URL, clientID: String, colorScheme: ColorScheme, analyticsConfiguration: ElementCallAnalyticsConfiguration?) async -> Result<URL, ElementCallWidgetDriverError> {`
`6049`		`- startBaseURLClientIDColorSchemeAnalyticsConfigurationCallsCount += 1`
`6050`		`- startBaseURLClientIDColorSchemeAnalyticsConfigurationReceivedArguments = (baseURL: baseURL, clientID: clientID, colorScheme: colorScheme, analyticsConfiguration: analyticsConfiguration)`
	`6048`	`+ func start(baseURL: URL, clientID: String, colorScheme: ColorScheme, rageshakeURL: String?, analyticsConfiguration: ElementCallAnalyticsConfiguration?) async -> Result<URL, ElementCallWidgetDriverError> {`
	`6049`	`+ startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationCallsCount += 1`
	`6050`	`+ startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationReceivedArguments = (baseURL: baseURL, clientID: clientID, colorScheme: colorScheme, rageshakeURL: rageshakeURL, analyticsConfiguration: analyticsConfiguration)`
`6051`	`6051`	`DispatchQueue.main.async {`
`6052`		`- self.startBaseURLClientIDColorSchemeAnalyticsConfigurationReceivedInvocations.append((baseURL: baseURL, clientID: clientID, colorScheme: colorScheme, analyticsConfiguration: analyticsConfiguration))`
	`6052`	`+ self.startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationReceivedInvocations.append((baseURL: baseURL, clientID: clientID, colorScheme: colorScheme, rageshakeURL: rageshakeURL, analyticsConfiguration: analyticsConfiguration))`
`6053`	`6053`	`}`
`6054`		`- if let startBaseURLClientIDColorSchemeAnalyticsConfigurationClosure = startBaseURLClientIDColorSchemeAnalyticsConfigurationClosure {`
`6055`		`- return await startBaseURLClientIDColorSchemeAnalyticsConfigurationClosure(baseURL, clientID, colorScheme, analyticsConfiguration)`
	`6054`	`+ if let startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationClosure = startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationClosure {`
	`6055`	`+ return await startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationClosure(baseURL, clientID, colorScheme, rageshakeURL, analyticsConfiguration)`
`6056`	`6056`	`} else {`
`6057`		`- return startBaseURLClientIDColorSchemeAnalyticsConfigurationReturnValue`
	`6057`	`+ return startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationReturnValue`
`6058`	`6058`	`}`
`6059`	`6059`	`}`
`6060`	`6060`	`//MARK: - handleMessage`
Original file line number	Diff line number	Diff line change
`@@ -119,7 +119,7 @@ extension JoinedRoomProxyMock {`
`119`	`119`	`fatalError()`
`120`	`120`	`}`
`121`	`121`
`122`		`- widgetDriver.startBaseURLClientIDColorSchemeAnalyticsConfigurationReturnValue = .success(url)`
	`122`	`+ widgetDriver.startBaseURLClientIDColorSchemeRageshakeURLAnalyticsConfigurationReturnValue = .success(url)`
`123`	`123`
`124`	`124`	`elementCallWidgetDriverDeviceIDReturnValue = widgetDriver`
`125`	`125`	`sendCallNotificationIfNeededReturnValue = .success(())`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,11 @@ class GenericCallLinkWidgetDriver: ElementCallWidgetDriverProtocol {`
`23`	`23`	`self.url = url`
`24`	`24`	`}`
`25`	`25`
`26`		`- func start(baseURL: URL, clientID: String, colorScheme: ColorScheme, analyticsConfiguration: ElementCallAnalyticsConfiguration?) async -> Result<URL, ElementCallWidgetDriverError> {`
	`26`	`+ func start(baseURL: URL,`
	`27`	`+ clientID: String,`
	`28`	`+ colorScheme: ColorScheme,`
	`29`	`+ rageshakeURL: String?,`
	`30`	`+ analyticsConfiguration: ElementCallAnalyticsConfiguration?) async -> Result<URL, ElementCallWidgetDriverError> {`
`27`	`31`	`MXLog.error("Nothing to start, use the configuration's URL directly instead.")`
`28`	`32`	`return .success(url)`
`29`	`33`	`}`