@capgo/capacitor-watch 8.0.2 → 8.0.4

package/android/src/main/java/app/capgo/capacitor/watch/CapgoWatchPlugin.java

@@ -14,7 +14,7 @@ import com.getcapacitor.annotation.CapacitorPlugin;
 @CapacitorPlugin(name = "CapgoWatch")
 public class CapgoWatchPlugin extends Plugin {
 
-    private final String pluginVersion = "8.0.2";
+    private final String pluginVersion = "8.0.4";
     private static final String NOT_SUPPORTED_MSG = "Apple Watch is only supported on iOS";
 
     @PluginMethod

package/ios/Sources/CapgoWatchPlugin/CapgoWatchPlugin.swift

@@ -6,7 +6,7 @@ import WatchConnectivity
 /// here: https://capacitorjs.com/docs/plugins/ios
 @objc(CapgoWatchPlugin)
 public class CapgoWatchPlugin: CAPPlugin, CAPBridgedPlugin {
-    private let pluginVersion: String = "8.0.2"
+    private let pluginVersion: String = "8.0.4"
     public let identifier = "CapgoWatchPlugin"
     public let jsName = "CapgoWatch"
     public let pluginMethods: [CAPPluginMethod] = [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capgo/capacitor-watch",
-  "version": "8.0.2",
+  "version": "8.0.4",
   "description": "Capacitor plugin for Apple Watch communication with bidirectional messaging support",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",
@@ -13,7 +13,8 @@
     "ios/Sources",
     "ios/Tests",
     "Package.swift",
-    "CapgoCapacitorWatch.podspec"
+    "CapgoCapacitorWatch.podspec",
+    "watch-sdk"
   ],
   "author": "Martin Donadieu <martin@capgo.app>",
   "license": "MPL-2.0",

package/watch-sdk/Package.swift

@@ -0,0 +1,19 @@
+// swift-tools-version: 5.9
+import PackageDescription
+
+let package = Package(
+    name: "CapgoWatchSDK",
+    platforms: [.iOS(.v15), .watchOS(.v9)],
+    products: [
+        .library(
+            name: "CapgoWatchSDK",
+            targets: ["CapgoWatchSDK"])
+    ],
+    dependencies: [],
+    targets: [
+        .target(
+            name: "CapgoWatchSDK",
+            dependencies: [],
+            path: "Sources/CapgoWatchSDK")
+    ]
+)

package/watch-sdk/README.md

@@ -0,0 +1,96 @@
+# CapgoWatchSDK
+
+Swift Package for watchOS apps to communicate with the `@capgo/capacitor-watch` plugin.
+
+## Installation
+
+Add this package to your watchOS app target in Xcode:
+
+1. File > Add Package Dependencies
+2. Enter: `https://github.com/Cap-go/capacitor-watch.git`
+3. Select the `watch-sdk` directory
+4. Add `CapgoWatchSDK` to your watchOS target
+
+Or add to your `Package.swift`:
+
+```swift
+dependencies: [
+    .package(url: "https://github.com/Cap-go/capacitor-watch.git", from: "8.0.0")
+]
+```
+
+## Usage
+
+### SwiftUI Example
+
+```swift
+import SwiftUI
+import CapgoWatchSDK
+
+@main
+struct MyWatchApp: App {
+    init() {
+        WatchConnector.shared.activate()
+    }
+
+    var body: some Scene {
+        WindowGroup {
+            ContentView()
+        }
+    }
+}
+
+struct ContentView: View {
+    @ObservedObject var connector = WatchConnector.shared
+
+    var body: some View {
+        VStack {
+            Text(connector.isReachable ? "Phone Connected" : "Phone Disconnected")
+
+            Button("Send Message") {
+                connector.sendMessage(["action": "hello"]) { reply in
+                    print("Reply: \(reply)")
+                }
+            }
+            .disabled(!connector.isReachable)
+        }
+    }
+}
+```
+
+### Using Delegate
+
+```swift
+class WatchManager: WatchConnectorDelegate {
+    init() {
+        WatchConnector.shared.delegate = self
+        WatchConnector.shared.activate()
+    }
+
+    func didReceiveMessage(_ message: [String: Any]) {
+        print("Received: \(message)")
+    }
+
+    func didReceiveMessage(_ message: [String: Any], replyHandler: @escaping ([String: Any]) -> Void) {
+        // Process and reply
+        replyHandler(["status": "ok"])
+    }
+}
+```
+
+### Async/Await
+
+```swift
+Task {
+    do {
+        let reply = try await WatchConnector.shared.sendMessage(["action": "getData"])
+        print("Reply: \(reply)")
+    } catch {
+        print("Error: \(error)")
+    }
+}
+```
+
+## License
+
+MPL-2.0

package/watch-sdk/Sources/CapgoWatchSDK/WatchConnector.swift

@@ -0,0 +1,269 @@
+import Foundation
+import WatchConnectivity
+import Combine
+
+/// Protocol for handling messages from the phone
+public protocol WatchConnectorDelegate: AnyObject {
+    /// Called when a message is received from the phone
+    func didReceiveMessage(_ message: [String: Any])
+
+    /// Called when a message requiring a reply is received from the phone
+    func didReceiveMessage(_ message: [String: Any], replyHandler: @escaping ([String: Any]) -> Void)
+
+    /// Called when the application context is updated from the phone
+    func didReceiveApplicationContext(_ context: [String: Any])
+
+    /// Called when user info is received from the phone
+    func didReceiveUserInfo(_ userInfo: [String: Any])
+
+    /// Called when reachability changes
+    func reachabilityDidChange(_ isReachable: Bool)
+
+    /// Called when activation completes
+    func activationDidComplete(with state: WCSessionActivationState, error: Error?)
+}
+
+/// Default implementations for optional delegate methods
+public extension WatchConnectorDelegate {
+    func didReceiveMessage(_ message: [String: Any]) {}
+    func didReceiveMessage(_ message: [String: Any], replyHandler: @escaping ([String: Any]) -> Void) {
+        replyHandler([:])
+    }
+    func didReceiveApplicationContext(_ context: [String: Any]) {}
+    func didReceiveUserInfo(_ userInfo: [String: Any]) {}
+    func reachabilityDidChange(_ isReachable: Bool) {}
+    func activationDidComplete(with state: WCSessionActivationState, error: Error?) {}
+}
+
+/// Main class for watch-side communication with the iPhone app.
+/// Use this in your watchOS app to communicate with the Capacitor plugin on the phone.
+@available(watchOS 9.0, iOS 15.0, *)
+public final class WatchConnector: NSObject, ObservableObject {
+
+    /// Shared singleton instance
+    public static let shared = WatchConnector()
+
+    /// Delegate for receiving messages and events
+    public weak var delegate: WatchConnectorDelegate?
+
+    /// Published property for SwiftUI - whether the phone is reachable
+    @Published public private(set) var isReachable: Bool = false
+
+    /// Published property for SwiftUI - whether the session is activated
+    @Published public private(set) var isActivated: Bool = false
+
+    /// Published property for SwiftUI - the latest received message
+    @Published public private(set) var lastMessage: [String: Any] = [:]
+
+    /// Published property for SwiftUI - the current application context
+    @Published public private(set) var applicationContext: [String: Any] = [:]
+
+    /// The underlying WCSession
+    private var session: WCSession?
+
+    private override init() {
+        super.init()
+    }
+
+    // MARK: - Public Methods
+
+    /// Activate the watch connectivity session.
+    /// Call this when your watch app starts, typically in your App's init or onAppear.
+    public func activate() {
+        guard WCSession.isSupported() else {
+            print("[CapgoWatchSDK] WCSession is not supported on this device")
+            return
+        }
+
+        session = WCSession.default
+        session?.delegate = self
+        session?.activate()
+        print("[CapgoWatchSDK] WCSession activation requested")
+    }
+
+    /// Send a message to the phone.
+    /// The phone must be reachable for this to succeed.
+    /// - Parameter message: The data to send
+    /// - Parameter replyHandler: Optional handler for the phone's reply
+    /// - Parameter errorHandler: Optional handler for errors
+    public func sendMessage(
+        _ message: [String: Any],
+        replyHandler: (([String: Any]) -> Void)? = nil,
+        errorHandler: ((Error) -> Void)? = nil
+    ) {
+        guard let session = session, session.isReachable else {
+            errorHandler?(WatchConnectorError.phoneNotReachable)
+            return
+        }
+
+        session.sendMessage(message, replyHandler: replyHandler) { error in
+            print("[CapgoWatchSDK] Error sending message: \(error.localizedDescription)")
+            errorHandler?(error)
+        }
+    }
+
+    /// Send a message to the phone and wait for a reply.
+    /// - Parameter message: The data to send
+    /// - Returns: The reply from the phone
+    /// - Throws: WatchConnectorError if the phone is not reachable or the send fails
+    @available(watchOS 9.0, iOS 15.0, *)
+    public func sendMessage(_ message: [String: Any]) async throws -> [String: Any] {
+        guard let session = session, session.isReachable else {
+            throw WatchConnectorError.phoneNotReachable
+        }
+
+        return try await withCheckedThrowingContinuation { continuation in
+            session.sendMessage(message, replyHandler: { reply in
+                continuation.resume(returning: reply)
+            }, errorHandler: { error in
+                continuation.resume(throwing: error)
+            })
+        }
+    }
+
+    /// Update the application context to share with the phone.
+    /// Only the latest context is kept.
+    /// - Parameter context: The context data to sync
+    public func updateApplicationContext(_ context: [String: Any]) throws {
+        guard let session = session else {
+            throw WatchConnectorError.sessionNotActivated
+        }
+
+        try session.updateApplicationContext(context)
+    }
+
+    /// Transfer user info to the phone.
+    /// Transfers are queued and delivered in order.
+    /// - Parameter userInfo: The user info to transfer
+    /// - Returns: The transfer object for tracking
+    @discardableResult
+    public func transferUserInfo(_ userInfo: [String: Any]) -> WCSessionUserInfoTransfer? {
+        return session?.transferUserInfo(userInfo)
+    }
+
+    /// Get the current session state
+    public var activationState: WCSessionActivationState {
+        return session?.activationState ?? .notActivated
+    }
+
+    /// Check if the phone is currently reachable
+    public var phoneIsReachable: Bool {
+        return session?.isReachable ?? false
+    }
+
+    /// Get the received application context from the phone
+    public var receivedApplicationContext: [String: Any] {
+        return session?.receivedApplicationContext ?? [:]
+    }
+}
+
+// MARK: - WCSessionDelegate
+
+@available(watchOS 9.0, iOS 15.0, *)
+extension WatchConnector: WCSessionDelegate {
+
+    public func session(
+        _ session: WCSession,
+        activationDidCompleteWith activationState: WCSessionActivationState,
+        error: Error?
+    ) {
+        DispatchQueue.main.async {
+            self.isActivated = activationState == .activated
+            self.isReachable = session.isReachable
+            self.applicationContext = session.receivedApplicationContext
+        }
+
+        if let error = error {
+            print("[CapgoWatchSDK] Activation failed: \(error.localizedDescription)")
+        } else {
+            print("[CapgoWatchSDK] Activation completed with state: \(activationState.rawValue)")
+        }
+
+        delegate?.activationDidComplete(with: activationState, error: error)
+    }
+
+    public func sessionReachabilityDidChange(_ session: WCSession) {
+        DispatchQueue.main.async {
+            self.isReachable = session.isReachable
+        }
+
+        print("[CapgoWatchSDK] Reachability changed: \(session.isReachable)")
+        delegate?.reachabilityDidChange(session.isReachable)
+    }
+
+    // MARK: - Receiving Messages
+
+    public func session(_ session: WCSession, didReceiveMessage message: [String: Any]) {
+        DispatchQueue.main.async {
+            self.lastMessage = message
+        }
+
+        print("[CapgoWatchSDK] Received message: \(message)")
+        delegate?.didReceiveMessage(message)
+    }
+
+    public func session(
+        _ session: WCSession,
+        didReceiveMessage message: [String: Any],
+        replyHandler: @escaping ([String: Any]) -> Void
+    ) {
+        DispatchQueue.main.async {
+            self.lastMessage = message
+        }
+
+        print("[CapgoWatchSDK] Received message with reply: \(message)")
+        delegate?.didReceiveMessage(message, replyHandler: replyHandler)
+    }
+
+    // MARK: - Application Context
+
+    public func session(_ session: WCSession, didReceiveApplicationContext applicationContext: [String: Any]) {
+        DispatchQueue.main.async {
+            self.applicationContext = applicationContext
+        }
+
+        print("[CapgoWatchSDK] Received application context: \(applicationContext)")
+        delegate?.didReceiveApplicationContext(applicationContext)
+    }
+
+    // MARK: - User Info
+
+    public func session(_ session: WCSession, didReceiveUserInfo userInfo: [String: Any] = [:]) {
+        print("[CapgoWatchSDK] Received user info: \(userInfo)")
+        delegate?.didReceiveUserInfo(userInfo)
+    }
+
+    // MARK: - iOS only delegate methods (required for protocol conformance)
+
+    #if os(iOS)
+    public func sessionDidBecomeInactive(_ session: WCSession) {
+        print("[CapgoWatchSDK] Session became inactive")
+    }
+
+    public func sessionDidDeactivate(_ session: WCSession) {
+        print("[CapgoWatchSDK] Session deactivated")
+        // Reactivate for multi-watch support
+        session.activate()
+    }
+    #endif
+}
+
+// MARK: - Errors
+
+/// Errors that can occur during watch communication
+public enum WatchConnectorError: LocalizedError {
+    case phoneNotReachable
+    case sessionNotActivated
+    case sendFailed(Error)
+
+    public var errorDescription: String? {
+        switch self {
+        case .phoneNotReachable:
+            return "iPhone is not reachable"
+        case .sessionNotActivated:
+            return "WCSession is not activated"
+        case .sendFailed(let error):
+            return "Failed to send message: \(error.localizedDescription)"
+        }
+    }
+}