Add XPCCommunicationBridge

Author: intitni

Tool/Package.swift

@@ -80,7 +80,7 @@ let package = Package(
     targets: [
         // MARK: - Helpers
 
-        .target(name: "XPCShared", dependencies: ["SuggestionModel"]),
+        .target(name: "XPCShared", dependencies: ["SuggestionModel", "Logger"]),
 
         .target(name: "Configs"),
 

Tool/Sources/XPCShared/CommunicationBridgeXPCServiceProtocol.swift

@@ -0,0 +1,12 @@
+import Foundation
+
+@objc(CommunicationBridgeXPCServiceProtocol)
+public protocol CommunicationBridgeXPCServiceProtocol {
+    func launchExtensionServiceIfNeeded(withReply reply: @escaping (NSXPCListenerEndpoint?) -> Void)
+    func quit(withReply reply: @escaping () -> Void)
+    func updateServiceEndpoint(
+        endpoint: NSXPCListenerEndpoint,
+        withReply reply: @escaping () -> Void
+    )
+}
+

Tool/Sources/XPCShared/XPCCommunicationBridge.swift

@@ -0,0 +1,76 @@
+import Foundation
+import Logger
+
+public enum XPCCommunicationBridgeError: Swift.Error, LocalizedError {
+    case failedToCreateXPCConnection
+    case xpcServiceError(Error)
+
+    public var errorDescription: String? {
+        switch self {
+        case .failedToCreateXPCConnection:
+            return "Failed to create XPC connection"
+        case let .xpcServiceError(error):
+            return "XPC Service error: \(error.localizedDescription)"
+        }
+    }
+}
+
+@XPCServiceActor
+public class XPCCommunicationBridge {
+    let service: XPCService
+    let logger: Logger
+    var serviceEndpoint: NSXPCListenerEndpoint?
+
+    nonisolated
+    public init(logger: Logger) {
+        service = .init(
+            kind: .machService(
+                identifier: Bundle(for: XPCService.self)
+                    .object(forInfoDictionaryKey: "BUNDLE_IDENTIFIER_BASE") as! String +
+                    ".CommunicationBridge"
+            ),
+            interface: NSXPCInterface(with: CommunicationBridgeXPCServiceProtocol.self),
+            logger: logger
+        )
+        self.logger = logger
+    }
+
+    public func launchExtensionServiceIfNeeded() async throws -> NSXPCListenerEndpoint? {
+        try await withXPCServiceConnected { service, continuation in
+            service.launchExtensionServiceIfNeeded { endpoint in
+                continuation.resume(endpoint)
+            }
+        }
+    }
+
+    public func quit() async throws {
+        try await withXPCServiceConnected { service, continuation in
+            service.quit {
+                continuation.resume(())
+            }
+        }
+    }
+
+    public func updateServiceEndpoint(_ endpoint: NSXPCListenerEndpoint) async throws {
+        try await withXPCServiceConnected { service, continuation in
+            service.updateServiceEndpoint(endpoint: endpoint) {
+                continuation.resume(())
+            }
+        }
+    }
+}
+
+extension XPCCommunicationBridge {
+    func withXPCServiceConnected<T>(
+        _ fn: @escaping (CommunicationBridgeXPCServiceProtocol, AutoFinishContinuation<T>) -> Void
+    ) async throws -> T {
+        guard let connection = service.connection
+        else { throw XPCCommunicationBridgeError.failedToCreateXPCConnection }
+        do {
+            return try await XPCShared.withXPCServiceConnected(connection: connection, fn)
+        } catch {
+            throw XPCCommunicationBridgeError.xpcServiceError(error)
+        }
+    }
+}
+