Improvements to the NFC connection

Author: jdmoreira

Samples/OATHSample/OATHSample/ConnectionManager.swift

@@ -83,10 +83,12 @@ final class ConnectionManager: ObservableObject {
 extension SmartCardConnection {
     var connectionType: String {
         switch self {
+        #if os(iOS)
         case _ as NFCSmartCardConnection:
             return "NFC"
         case _ as LightningSmartCardConnection:
             return "Lightning"
+        #endif
         case _ as SmartCardConnection:
             return "USB"
         default:

YubiKit/YubiKit/Connection.swift

@@ -78,8 +78,8 @@ public enum ConnectionError: Error, Sendable {
     case missingResult
     /// Awaiting call to connect() was cancelled.
     case cancelled
-    /// SmartCardConnection was closed.
-    case closed
+    /// Awaiting call to connect() was dismissed by the user.
+    case cancelledByUser
 }
 
 /// A ResponseError containing the status code.

YubiKit/YubiKit/NFCSmartCardConnection.swift

@@ -267,13 +267,7 @@ private final actor NFCConnectionManager: NSObject {
             if let message = message {
                 currentState.session?.alertMessage = message
             }
-        }
-
-        switch result {
-        case .success:
-            await invalidate()
-        case let .failure(error):
-            await invalidate(error: error)
+            currentState.session?.invalidate()
         }
     }
 
@@ -282,7 +276,7 @@ private final actor NFCConnectionManager: NSObject {
         trace(message: "Manager.connected(session:tag:) - tag: \(String(describing: tag.identifier))")
 
         guard let promise = currentState.connectionPromise else {
-            await invalidate()
+            await cleanup(session: session)
             return
         }
 
@@ -299,15 +293,21 @@ private final actor NFCConnectionManager: NSObject {
         await promise.fulfill(connection)
     }
 
-    private func invalidate(error: Error? = nil) async {
-        currentState.session?.invalidate()
+    private func cleanup(session: NFCTagReaderSession, error: Error? = nil) async {
+        guard currentState.session === session else {
+            return
+        }
+
+        switch error {
+        case .none:
+            await currentState.didCloseConnection?.fulfill(nil)
+            await currentState.connectionPromise?.cancel(with: ConnectionError.cancelledByUser)
+        case let .some(error):
+            await currentState.didCloseConnection?.fulfill(nil)
+            await currentState.connectionPromise?.cancel(with: error)
+        }
 
-        // Workaround for the NFC session being active for an additional 4 seconds after
-        // invalidate() has been called on the session.
-        try? await Task.sleep(for: .seconds(5))
-        await currentState.didCloseConnection?.fulfill(error)
-        await currentState.connectionPromise?.cancel(with: error ?? ConnectionError.cancelled)
-        currentState = .inactive
+        self.currentState = .inactive
     }
 }
 
@@ -325,16 +325,16 @@ extension NFCConnectionManager: NFCTagReaderSessionDelegate {
         trace(message: "NFCTagReaderSessionDelegate: Session invalidated – \(error.localizedDescription)")
 
         let nfcError = error as? NFCReaderError
+
+        let mappedError: Error?
         switch nfcError?.code {
         case .some(.readerSessionInvalidationErrorUserCanceled):
-            return
+            mappedError = nil  // user cancelled, no error
         default:
-            Task {
-                if await currentState.session === session {
-                    await stop(with: .failure(error))
-                }
-            }
+            mappedError = error
         }
+
+        Task { await cleanup(session: session, error: mappedError) }
     }
 
     // @TraceScope
@@ -354,7 +354,7 @@ extension NFCConnectionManager: NFCTagReaderSessionDelegate {
             if await session === currentState.session {
                 await connected(session: session, tag: firstTag)
             } else {
-                await invalidate(error: ConnectionError.cancelled)
+                await cleanup(session: session, error: ConnectionError.cancelled)
             }
         }
     }

YubiKit/YubiKit/SharedConnection.swift

@@ -0,0 +1,21 @@
+// Copyright Yubico AB
+//
+// 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 Foundation
+
+protocol ShareableConnection: Sendable {
+    func hold(timeout: TimeInterval) async throws
+
+    func release()
+}

YubiKit/YubiKit/Utilities/Timeout.swift

@@ -0,0 +1,42 @@
+// Copyright Yubico AB
+//
+// 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 Foundation
+
+enum TimeoutError: Error {
+    case exceeded
+}
+
+func withTimeout<T>(
+    _ seconds: TimeInterval,
+    operation: @escaping @Sendable () async throws -> T
+) async throws -> T where T: Sendable {
+    try await withThrowingTaskGroup(of: T.self) { group in
+        // Main operation
+        group.addTask {
+            try await operation()
+        }
+
+        // Timeout enforcer
+        group.addTask {
+            try await Task.sleep(nanoseconds: UInt64(seconds * 1_000_000_000))
+            throw TimeoutError.exceeded
+        }
+
+        // Return the first finished task
+        let result = try await group.next()!
+        group.cancelAll()
+        return result
+    }
+}