ehealthsolutions/element-x-ios
3
0
Fork 0
mirror of https://github.com/Novaloop-AG/element-x-ios.git synced 2026-11-02 21:33:26 +00:00
Code Issues Packages Projects Releases Wiki Activity

Swift 6 Migration (#5733)

Browse Source 
* Enable Swift 6.2 with default main actor isolation for the app target

Turn on SWIFT_VERSION 6.2, SWIFT_APPROACHABLE_CONCURRENCY and SWIFT_DEFAULT_ACTOR_ISOLATION = MainActor for the ElementX target, matching the NSE and Share Extension (which already use 6.2 without the main actor default).

# Conflicts:
#	ElementX.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved

* Update the code generation templates for Swift 6

Emit nonisolated/@unchecked Sendable mocks and nonisolated string enums, and mark async mock methods @concurrent so they keep suspending like the real implementations (otherwise intermediate states are unobservable in tests). Includes the regenerated mocks and strings.

# Conflicts:
#	ElementX/Sources/Mocks/Generated/GeneratedMocks.swift

* Make the data layer and services nonisolated and Sendable

Annotate the value-type models, Rust SDK proxy wrappers, timeline item graph, settings, logging and NSE-shared types as nonisolated, and conform the service protocols to Sendable so their existentials can cross isolation boundaries. These types run off the main actor and no longer inherit the target's default main actor isolation.

* Adopt the new isolation across call sites, mocks and signatures

Update call sites, closure signatures and mock configuration helpers to match the nonisolated/Sendable data layer, including the main actor isolated mock inits and the @Sendable filter on recentlyVisitedRooms.

^ Conflicts:
^	ElementX/Sources/Services/SecureBackup/SecureBackupController.swift

* Remove redundant @MainActor annotations

With the app target defaulting to main actor isolation, the explicit @MainActor on view models, coordinators, views and their protocols is no longer required.

* Fix concurrency hotspots surfaced by the migration

Resolve the room summary main-thread deadlock by moving diff processing onto AsyncStreams, add the SDKListener.onMainActor FIFO bridge for SDK callbacks, hop KVO/timer/UIKit callbacks to the main actor via assumeIsolated, add isolated deinits, and apply the few justified nonisolated(unsafe) escapes for queue-confined Apple APIs.

* Fix the unit tests for Swift 6 concurrency

Hop the waitForConfirmation body onto the caller's actor (Swift Testing runs confirmation closures off-actor), and adjust the affected suites and async signatures.

* offload diffs on concurrent threads instead of main actor

* make room info protocols sendable

* use a task group for fetching data so that everything runs concurrently in the TextRoomTimelineView when getting the preview.

* use the generic onMainActor implementation, which already makes a stream and send the continuation on the main actor.

* small pr comments issues being addressed

* update enterprise

* Update StaticCode to 1.1.0 and specify the required Swift isolation.

* fix ElementCallServiceTests

* update enterprise

* re-generate mocks

* update enterprise

* enterprise new code conformed to swift 6

---------

Co-authored-by: Doug <douglase@element.io>
This commit is contained in:
Mauro
2026-06-18 17:55:31 +02:00
committed by GitHub
parent 7edca8b5a1
commit a520d94760
444 changed files with 3677 additions and 3361 deletions
Download Patch File Download Diff File Expand all files Collapse all files
ElementX/Sources/Services/ElementCall/ElementCallService.swift
+17 -10
View File
@@ -220,14 +220,19 @@ class ElementCallService: NSObject, ElementCallServiceProtocol, PKPushRegistryDe
// https://stackoverflow.com/a/41230020/730924
update.remoteHandle = .init(type: .generic, value: roomID)
// The push registry uses the main queue so the completion is main actor bound,
// whereas CallKit invokes its completion on a background queue.
let mainActorCompletion = { @MainActor @Sendable in completion() }
callProvider.reportNewIncomingCall(with: callID.callKitID, update: update) { [weak self] error in
if let error {
MXLog.error("Failed reporting new incoming call with error: \(error)")
}
self?.actionsSubject.send(.receivedIncomingCallRequest)
completion()
Task { @MainActor in
self?.actionsSubject.send(.receivedIncomingCallRequest)
mainActorCompletion()
}
}
endUnansweredCallTask = Task { [weak self] in
@@ -351,8 +356,6 @@ class ElementCallService: NSObject, ElementCallServiceProtocol, PKPushRegistryDe
private func reportImmediatelyEndedCall(reason: CXCallEndedReason,
callerInfo: (roomID: String, roomDisplayName: String?)? = nil,
completion: @escaping () -> Void) {
let provider = callProvider
let callID = UUID()
let update = CXCallUpdate()
// Never answered through CallKit, so the hasVideo workaround for #5335 isn't needed.
@@ -363,14 +366,18 @@ class ElementCallService: NSObject, ElementCallServiceProtocol, PKPushRegistryDe
update.remoteHandle = .init(type: .generic, value: callerInfo.roomID)
}
provider.reportNewIncomingCall(with: callID, update: update) { error in
// CallKit invokes the completion on a background queue, so hop back to the main actor
// to report the ended call and to run the (main actor bound) completion.
let mainActorCompletion = { @MainActor @Sendable in completion() }
callProvider.reportNewIncomingCall(with: callID, update: update) { [weak self] error in
if let error {
MXLog.error("Failed reporting immediately ended call with error: \(error)")
}
provider.reportCall(with: callID, endedAt: nil, reason: reason)
completion()
Task { @MainActor in
self?.callProvider.reportCall(with: callID, endedAt: nil, reason: reason)
mainActorCompletion()
}
}
}
@@ -443,7 +450,7 @@ class ElementCallService: NSObject, ElementCallServiceProtocol, PKPushRegistryDe
MXLog.info("Observe decline events for notification \(rtcNotificationID)")
let listener: CallDeclineListener = SDKListener { [weak self] senderID in
let listener: CallDeclineListener = SDKListener.onMainActor { [weak self] senderID in
guard let self else { return }
MXLog.debug("Call declined event received from \(senderID)")
ElementX/Sources/Services/ElementCall/ElementCallServiceConstants.swift
+2 -2
View File
@@ -8,7 +8,7 @@
import Foundation
enum ElementCallServiceNotificationKey: String {
nonisolated enum ElementCallServiceNotificationKey: String {
case roomID
case roomDisplayName
/// When an incoming call is set to ring, there will be a `m.rtc.notification`event (MSC4075).
@@ -19,4 +19,4 @@ enum ElementCallServiceNotificationKey: String {
case isVoiceCall
}
let ElementCallServiceNotificationDiscardDelta = 15.0
nonisolated let ElementCallServiceNotificationDiscardDelta = 15.0
ElementX/Sources/Services/ElementCall/ElementCallWidgetDriver.swift
+9 -4
View File
@@ -129,7 +129,7 @@ final class ElementCallWidgetDriver: WidgetCapabilitiesProvider, ElementCallWidg
self.widgetDriver = widgetDriver
Task.detached { [weak self, widgetDriver, messagePublisher] in
Task.detached { [weak self, widgetDriver] in
MXLog.debug("Started message receiving loop")
defer {
@@ -141,10 +141,9 @@ final class ElementCallWidgetDriver: WidgetCapabilitiesProvider, ElementCallWidg
return
}
messagePublisher.send(receivedMessage)
MXLog.debug("Received message: \(receivedMessage)")
self?.handleMessageIfNeeded(receivedMessage)
await self?.receiveMessage(receivedMessage)
}
}
@@ -177,12 +176,18 @@ final class ElementCallWidgetDriver: WidgetCapabilitiesProvider, ElementCallWidg
// MARK: - WidgetCapabilitiesProvider
func acquireCapabilities(capabilities: WidgetCapabilities) -> WidgetCapabilities {
/// Called by the SDK from arbitrary threads, only touches Sendable state.
nonisolated func acquireCapabilities(capabilities: WidgetCapabilities) -> WidgetCapabilities {
getElementCallRequiredPermissions(ownUserId: room.ownUserId(), ownDeviceId: deviceID)
}
// MARK: - Private
private func receiveMessage(_ message: String) {
messagePublisher.send(message)
handleMessageIfNeeded(message)
}
func handleMessageIfNeeded(_ message: String) {
guard let data = message.data(using: .utf8) else {
return