@blueid/access-capacitor 0.78.0 → 0.80.0

package/ios/CBlueIDAccess.xcframework/Info.plist

@@ -10,7 +10,7 @@
 			<key>HeadersPath</key>
 			<string>Headers</string>
 			<key>LibraryIdentifier</key>
-			<string>macos-arm64_x86_64</string>
+			<string>ios-arm64_x86_64-simulator</string>
 			<key>LibraryPath</key>
 			<string>libCBlueIDAccess.a</string>
 			<key>SupportedArchitectures</key>
@@ -19,7 +19,9 @@
 				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
-			<string>macos</string>
+			<string>ios</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
 		</dict>
 		<dict>
 			<key>BinaryPath</key>
@@ -27,18 +29,15 @@
 			<key>HeadersPath</key>
 			<string>Headers</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64_x86_64-simulator</string>
+			<string>ios-arm64</string>
 			<key>LibraryPath</key>
 			<string>libCBlueIDAccess.a</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
-				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
-			<key>SupportedPlatformVariant</key>
-			<string>simulator</string>
 		</dict>
 		<dict>
 			<key>BinaryPath</key>
@@ -46,15 +45,16 @@
 			<key>HeadersPath</key>
 			<string>Headers</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64</string>
+			<string>macos-arm64_x86_64</string>
 			<key>LibraryPath</key>
 			<string>libCBlueIDAccess.a</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
+				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
-			<string>ios</string>
+			<string>macos</string>
 		</dict>
 	</array>
 	<key>CFBundlePackageType</key>

package/ios/Plugin/BlueIDAccessSDK/BlueAccessSync.swift

@@ -56,9 +56,7 @@ internal class BlueAbstractSynchronizeAccessCommand<T>: BlueAPIAsyncCommand wher
             return
         }
         
-        guard let synchronizationResult = response.data else {
-            return
-        }
+        let synchronizationResult = try response.getData()
         
         if synchronizationResult.noRefresh == true {
             return
@@ -188,3 +186,68 @@ internal class BlueSynchronizeMobileAccessCommand: BlueAbstractSynchronizeAccess
         blueAccessDevicesStorage.deleteEntry(id: credential.credentialID.id)
     }
 }
+
+/**
+ * @class BlueSynchronizeAccessCredentialsCommand
+ * A command to synchronize all stored credentials.
+ */
+public class BlueSynchronizeAccessCredentialsCommand: BlueAPIAsyncCommand {
+    internal override func runAsync(arg0: Any?, arg1: Any?, arg2: Any?) async throws -> Any? {
+        return try await runAsync()
+    }
+    
+    /// Synchronizes all stored credentials.
+    /// Note: Master credentials are not synced in case of any, as they can only be synced once during the claiming process.
+    ///
+    /// - throws: Throws an error of type `BlueError(.sdkUnsupportedPlatform)` If the macOS version is earlier than 10.15.
+    /// - returns: The exit status (BlueReturnCode) of each credential, and its error description, if any.
+    public func runAsync() async throws -> BlueSynchronizeAccessCredentials {
+        guard #available(macOS 10.15, *) else {
+            throw BlueError(.sdkUnsupportedPlatform)
+        }
+        
+        let credentials = try await BlueGetAccessCredentialsCommand().runAsync().credentials
+            .filter { $0.credentialType != .master }
+        
+        if (credentials.isEmpty) {
+            return BlueSynchronizeAccessCredentials()
+        }
+        
+        return await withTaskGroup(of: BlueSynchronizeAccessCredential.self, returning: BlueSynchronizeAccessCredentials.self) { group in
+            
+            for credential in credentials {
+                group.addTask { await self.handleCredential(credential) }
+            }
+            
+            var credentials: [BlueSynchronizeAccessCredential] = []
+            
+            for await resultItem in group {
+                credentials.append(resultItem)
+            }
+            
+            return BlueSynchronizeAccessCredentials(credentials: credentials)
+        }
+    }
+    
+    private func handleCredential(_ credential: BlueAccessCredential) async -> BlueSynchronizeAccessCredential {
+        var resultItem = BlueSynchronizeAccessCredential()
+        resultItem.credentialID.id = credential.credentialID.id
+        
+        do {
+            try await BlueSynchronizeAccessCredentialCommand(self.blueAPI)
+                .runAsync(credentialID: credential.credentialID.id, forceRefresh: true)
+            
+            resultItem.returnCode = .ok
+        }
+        catch let error as BlueError {
+            resultItem.returnCode = error.returnCode
+            resultItem.errorDescription = error.localizedDescription
+        }
+        catch {
+            resultItem.returnCode = .error
+            resultItem.errorDescription = error.localizedDescription
+        }
+        
+        return resultItem
+    }
+}

package/ios/Plugin/BlueIDAccessSDK/BlueAccessSyncScheduler.swift

@@ -0,0 +1,145 @@
+import Foundation
+
+private class ForegroundScheduler {
+    private var timer: Timer?
+    private var scheduler: BlueAccessSyncScheduler?
+    
+    func setup(_ scheduler: BlueAccessSyncScheduler) {
+        self.scheduler = scheduler
+    }
+    
+    func suspend() {
+        timer?.invalidate()
+        timer = nil
+    }
+    
+    func schedule(_ now: Bool? = false) {
+        guard #available(macOS 10.15, *) else {
+            blueLogWarn("Unsupported platform")
+            return
+        }
+        
+        suspend()
+        
+        if now == true {
+            self.handleTask()
+        } else {
+            blueRunInMainThread {
+                self.timer = Timer.scheduledTimer(
+                    timeInterval: self.scheduler!.timeInterval,
+                    target: self,
+                    selector: #selector(self.handleTask),
+                    userInfo: nil,
+                    repeats: false
+                )
+            }
+        }
+    }
+    
+    @available(macOS 10.15, *)
+    @objc private func handleTask() {
+        DispatchQueue.global(qos: .background).async {
+            Task {
+                do {
+                    try await self.scheduler!.synchronizeAccessCredentials()
+                } catch {
+                    blueLogError(error.localizedDescription)
+                }
+                
+                if (self.scheduler!.autoSchedule) {
+                    self.schedule()
+                }
+            }
+        }
+    }
+}
+
+internal class BlueAccessSyncScheduler: BlueEventListener {
+    public static let shared = BlueAccessSyncScheduler()
+    
+    let timeInterval: TimeInterval
+    let autoSchedule: Bool
+    
+    private let foregroundScheduler = ForegroundScheduler()
+    
+    private let command: BlueSynchronizeAccessCredentialsCommand
+    
+    private var syncing = false
+    
+    init(
+        timeInterval: TimeInterval? = 60 * 60 * 6, // every 6h by default
+        autoSchedule: Bool? = true,
+        command: BlueSynchronizeAccessCredentialsCommand? = nil
+    ) {
+        self.command = command ?? blueCommands.synchronizeAccessCredentials
+        self.timeInterval = timeInterval ?? 60
+        self.autoSchedule = autoSchedule ?? true
+        
+        foregroundScheduler.setup(self)
+        
+        blueAddEventListener(listener: self)
+    }
+    
+    deinit {
+        blueRemoveEventListener(listener: self)
+    }
+    
+    func willResignActive() {
+        suspend()
+    }
+    
+    func willTerminate() {
+        suspend()
+    }
+    
+    func didBecomeActive() {
+        schedule(true)
+    }
+    
+    func didFinishLaunching() {
+        schedule(true)
+    }
+    
+    func blueEvent(event: BlueEventType, data: Any?) {
+        if (event == .accessCredentialAdded) {
+            schedule()
+        }
+    }
+    
+    func schedule(_ now: Bool? = false) {
+        do {
+            guard try blueAccessCredentialsKeyChain.getNumberOfEntries() > 0 else {
+                return
+            }
+        } catch {
+            blueLogError(error.localizedDescription)
+        }
+        
+        blueRemoveEventListener(listener: self)
+        
+        foregroundScheduler.schedule(now)
+    }
+    
+    func suspend() {
+        foregroundScheduler.suspend()
+    }
+    
+    func synchronizeAccessCredentials() async throws -> Void {
+        if (syncing) {
+            blueLogInfo("There is already a synchronization in progress")
+            return
+        }
+        
+        syncing = true
+        
+        blueFireListeners(fireEvent: BlueEventType.tokenSyncStarted, data: nil)
+        
+        defer {
+            syncing = false
+            
+            blueFireListeners(fireEvent: BlueEventType.tokenSyncFinished, data: nil)
+        }
+        
+        _ = try await command.runAsync()
+    }
+}

package/ios/Plugin/BlueIDAccessSDK/BlueApp.swift

@@ -40,18 +40,3 @@ public struct BlueOpenAppSettingsCommand: BlueAsyncCommand {
         completionHandler(false)
     }
 }
-
-internal func blueAppHasLaunchedBefore() -> Bool {
-    if let hasLaunchedBefore = hasLaunchedBefore {
-        return hasLaunchedBefore
-    }
-    
-    let result = blueAppStorage.getBool(id: "hasLaunchedBefore")
-    if (!result) {
-        blueAppStorage.storeBool(id: "hasLaunchedBefore", bool: true)
-    }
-    
-    hasLaunchedBefore = true
-    
-    return result
-}

package/ios/Plugin/BlueIDAccessSDK/BlueAppDelegate.swift

@@ -18,7 +18,7 @@ public final class BlueAppDelegate: NSObject {
         }
 #endif
         
-        BlueTokenSyncScheduler.shared.didFinishLaunching()
+        BlueAccessSyncScheduler.shared.didFinishLaunching()
     }
     
 #if os(iOS) || os(watchOS)
@@ -38,7 +38,7 @@ public final class BlueAppDelegate: NSObject {
 #endif
 
     @objc public static func willResignActive() {
-        BlueTokenSyncScheduler.shared.willResignActive()
+        BlueAccessSyncScheduler.shared.willResignActive()
     }
 
     @objc public static func didBecomeActive() {
@@ -46,7 +46,7 @@ public final class BlueAppDelegate: NSObject {
         blueNearbyAppBecameActive()
 #endif
         
-        BlueTokenSyncScheduler.shared.didBecomeActive()
+        BlueAccessSyncScheduler.shared.didBecomeActive()
     }
     
     @objc public static func didEnterBackground() {
@@ -62,6 +62,6 @@ public final class BlueAppDelegate: NSObject {
             fatalError(error.localizedDescription)
         }
         
-        BlueTokenSyncScheduler.shared.willTerminate()
+        BlueAccessSyncScheduler.shared.willTerminate()
     }
 }

package/ios/Plugin/BlueIDAccessSDK/BlueCommands.swift

@@ -74,6 +74,7 @@ public struct BlueCommands {
     public let claimAccessCredential = BlueClaimAccessCredentialCommand()
     public let getAccessCredentials = BlueGetAccessCredentialsCommand()
     public let synchronizeAccessCredential = BlueSynchronizeAccessCredentialCommand()
+    public let synchronizeAccessCredentials = BlueSynchronizeAccessCredentialsCommand()
     public let getAccessDevices = BlueGetAccessDevicesCommand()
     public let listAccessDevices = BlueListAccessDevicesCommand()
     public let updateDeviceConfiguration = BlueUpdateDeviceConfigurationCommand()

package/ios/Plugin/BlueIDAccessSDK/BlueSDK.pb.swift

@@ -751,6 +751,59 @@ public struct BlueRefreshOssSoCredentials {
   public init() {}
 }
 
+public struct BlueSynchronizeAccessCredential {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  public var credentialID: BlueCredentialId {
+    get {return _credentialID ?? BlueCredentialId()}
+    set {_credentialID = newValue}
+  }
+  /// Returns true if `credentialID` has been explicitly set.
+  public var hasCredentialID: Bool {return self._credentialID != nil}
+  /// Clears the value of `credentialID`. Subsequent reads from it will return its default value.
+  public mutating func clearCredentialID() {self._credentialID = nil}
+
+  public var returnCode: BlueReturnCode {
+    get {return _returnCode ?? .ok}
+    set {_returnCode = newValue}
+  }
+  /// Returns true if `returnCode` has been explicitly set.
+  public var hasReturnCode: Bool {return self._returnCode != nil}
+  /// Clears the value of `returnCode`. Subsequent reads from it will return its default value.
+  public mutating func clearReturnCode() {self._returnCode = nil}
+
+  public var errorDescription: String {
+    get {return _errorDescription ?? String()}
+    set {_errorDescription = newValue}
+  }
+  /// Returns true if `errorDescription` has been explicitly set.
+  public var hasErrorDescription: Bool {return self._errorDescription != nil}
+  /// Clears the value of `errorDescription`. Subsequent reads from it will return its default value.
+  public mutating func clearErrorDescription() {self._errorDescription = nil}
+
+  public var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  public init() {}
+
+  fileprivate var _credentialID: BlueCredentialId? = nil
+  fileprivate var _returnCode: BlueReturnCode? = nil
+  fileprivate var _errorDescription: String? = nil
+}
+
+public struct BlueSynchronizeAccessCredentials {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  public var credentials: [BlueSynchronizeAccessCredential] = []
+
+  public var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  public init() {}
+}
+
 #if swift(>=5.5) && canImport(_Concurrency)
 extension BlueDeviceType: @unchecked Sendable {}
 extension BlueRefreshOssSoCredentialStatus: @unchecked Sendable {}
@@ -767,6 +820,8 @@ extension BlueAccessObject: @unchecked Sendable {}
 extension BlueAccessObjectList: @unchecked Sendable {}
 extension BlueRefreshOssSoCredential: @unchecked Sendable {}
 extension BlueRefreshOssSoCredentials: @unchecked Sendable {}
+extension BlueSynchronizeAccessCredential: @unchecked Sendable {}
+extension BlueSynchronizeAccessCredentials: @unchecked Sendable {}
 #endif  // swift(>=5.5) && canImport(_Concurrency)
 
 // MARK: - Code below here is support for the SwiftProtobuf runtime.
@@ -1715,3 +1770,95 @@ extension BlueRefreshOssSoCredentials: SwiftProtobuf.Message, SwiftProtobuf._Mes
     return true
   }
 }
+
+extension BlueSynchronizeAccessCredential: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  public static let protoMessageName: String = "BlueSynchronizeAccessCredential"
+  public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "credentialId"),
+    2: .same(proto: "returnCode"),
+    3: .same(proto: "errorDescription"),
+  ]
+
+  public var isInitialized: Bool {
+    if self._credentialID == nil {return false}
+    if self._returnCode == nil {return false}
+    if let v = self._credentialID, !v.isInitialized {return false}
+    return true
+  }
+
+  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularMessageField(value: &self._credentialID) }()
+      case 2: try { try decoder.decodeSingularEnumField(value: &self._returnCode) }()
+      case 3: try { try decoder.decodeSingularStringField(value: &self._errorDescription) }()
+      default: break
+      }
+    }
+  }
+
+  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    // The use of inline closures is to circumvent an issue where the compiler
+    // allocates stack space for every if/case branch local when no optimizations
+    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
+    // https://github.com/apple/swift-protobuf/issues/1182
+    try { if let v = self._credentialID {
+      try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
+    } }()
+    try { if let v = self._returnCode {
+      try visitor.visitSingularEnumField(value: v, fieldNumber: 2)
+    } }()
+    try { if let v = self._errorDescription {
+      try visitor.visitSingularStringField(value: v, fieldNumber: 3)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  public static func ==(lhs: BlueSynchronizeAccessCredential, rhs: BlueSynchronizeAccessCredential) -> Bool {
+    if lhs._credentialID != rhs._credentialID {return false}
+    if lhs._returnCode != rhs._returnCode {return false}
+    if lhs._errorDescription != rhs._errorDescription {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension BlueSynchronizeAccessCredentials: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  public static let protoMessageName: String = "BlueSynchronizeAccessCredentials"
+  public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "credentials"),
+  ]
+
+  public var isInitialized: Bool {
+    if !SwiftProtobuf.Internal.areAllInitialized(self.credentials) {return false}
+    return true
+  }
+
+  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeRepeatedMessageField(value: &self.credentials) }()
+      default: break
+      }
+    }
+  }
+
+  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if !self.credentials.isEmpty {
+      try visitor.visitRepeatedMessageField(value: self.credentials, fieldNumber: 1)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  public static func ==(lhs: BlueSynchronizeAccessCredentials, rhs: BlueSynchronizeAccessCredentials) -> Bool {
+    if lhs.credentials != rhs.credentials {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}

package/ios/Plugin/BlueIDAccessSDK/Extensions.swift

@@ -198,6 +198,12 @@ extension BlueRefreshOssSoCredentials {
     }
 }
 
+extension BlueSynchronizeAccessCredentials {
+    public init(credentials: [BlueSynchronizeAccessCredential]) {
+        self.credentials = credentials
+    }
+}
+
 extension Array {
     
     /// Extension function for Arrays, allowing the splitting of the collection into subarrays of a specified size.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blueid/access-capacitor",
-  "version": "0.78.0",
+  "version": "0.80.0",
   "description": "Capacitor JS plugin for the BlueID Access SDK",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",