@use-voltra/ios-client 1.4.0 → 2.0.0-rc.1

package/ios/app/VoltraLiveActivityService.swift

@@ -0,0 +1,306 @@
+//
+//  VoltraLiveActivityService.swift
+//  Voltra
+//
+//  Service for managing Voltra Live Activities
+//
+
+import ActivityKit
+import Foundation
+
+// MARK: - Request Types
+
+/// Parameters for creating a Live Activity
+public struct CreateActivityRequest {
+  /// Unique identifier for the activity (will be generated if nil)
+  public let activityId: String?
+
+  /// URL to open when the Live Activity is tapped
+  public let deepLinkUrl: String?
+
+  /// UI JSON data
+  public let jsonString: String
+
+  /// Optional date when content becomes stale
+  public let staleDate: Date?
+
+  /// Score between 0.0 and 1.0 for prioritization (defaults to 0.0)
+  public let relevanceScore: Double
+
+  /// Whether to request push token
+  public let pushType: PushType?
+
+  /// If true, ends any existing activities with the same name (defaults to true)
+  public let endExistingWithSameName: Bool
+
+  public init(
+    activityId: String? = nil,
+    deepLinkUrl: String? = nil,
+    jsonString: String,
+    staleDate: Date? = nil,
+    relevanceScore: Double = 0.0,
+    pushType: PushType? = nil,
+    endExistingWithSameName: Bool = true
+  ) {
+    self.activityId = activityId
+    self.deepLinkUrl = deepLinkUrl
+    self.jsonString = jsonString
+    self.staleDate = staleDate
+    self.relevanceScore = relevanceScore
+    self.pushType = pushType
+    self.endExistingWithSameName = endExistingWithSameName
+  }
+}
+
+/// Parameters for updating a Live Activity
+public struct UpdateActivityRequest {
+  /// New UI JSON data
+  public let jsonString: String
+
+  /// Optional date when content becomes stale
+  public let staleDate: Date?
+
+  /// Score between 0.0 and 1.0 for prioritization (defaults to 0.0)
+  public let relevanceScore: Double
+
+  public init(
+    jsonString: String,
+    staleDate: Date? = nil,
+    relevanceScore: Double = 0.0
+  ) {
+    self.jsonString = jsonString
+    self.staleDate = staleDate
+    self.relevanceScore = relevanceScore
+  }
+}
+
+// MARK: - Service
+
+/// Service for managing Voltra Live Activities
+public class VoltraLiveActivityService {
+  // MARK: - Availability Checks
+
+  /// Check if Live Activities are supported on this OS version
+  public static func isSupported() -> Bool {
+    guard #available(iOS 16.2, *) else { return false }
+    return true
+  }
+
+  /// Check if Live Activities are enabled for this app
+  public static func areActivitiesEnabled() -> Bool {
+    guard #available(iOS 16.2, *) else { return false }
+    return ActivityAuthorizationInfo().areActivitiesEnabled
+  }
+
+  // MARK: - Query Operations
+
+  /// Find an activity by its name (activityId)
+  public func findActivity(byName name: String) -> Activity<VoltraAttributes>? {
+    guard Self.isSupported() else { return nil }
+    let trimmedName = name.trimmingCharacters(in: .whitespacesAndNewlines)
+    return Activity<VoltraAttributes>.activities.first { $0.attributes.name == trimmedName }
+  }
+
+  /// Find all activities with the same name
+  public func findActivities(byName name: String) -> [Activity<VoltraAttributes>] {
+    guard Self.isSupported() else { return [] }
+    return Activity<VoltraAttributes>.activities.filter { $0.attributes.name == name }
+  }
+
+  /// Get all active Voltra activities
+  public func getAllActivities() -> [Activity<VoltraAttributes>] {
+    guard Self.isSupported() else { return [] }
+    return Array(Activity<VoltraAttributes>.activities)
+  }
+
+  /// Get the latest (most recently created) activity across both types
+  public func getLatestActivity() -> VoltraActivity? {
+    guard Self.isSupported() else { return nil }
+    let allActivities = getAllActivities()
+    return allActivities.last
+  }
+
+  /// Check if an activity with the given name exists across both types
+  public func isActivityActive(name: String) -> Bool {
+    findActivity(byName: name) != nil
+  }
+
+  // MARK: - Create Operations
+
+  /// Create a new Live Activity
+  /// - Parameter request: Parameters for creating the activity
+  /// - Returns: The created activity's name (activityId)
+  /// - Throws: Error if creation fails
+  public func createActivity(_ request: CreateActivityRequest) async throws -> String {
+    guard Self.isSupported() else {
+      throw VoltraLiveActivityError.unsupportedOS
+    }
+    guard Self.areActivitiesEnabled() else {
+      throw VoltraLiveActivityError.liveActivitiesNotEnabled
+    }
+
+    // Generate activityId if not provided
+    let finalActivityId = request.activityId?.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty == false
+      ? request.activityId!.trimmingCharacters(in: .whitespacesAndNewlines)
+      : UUID().uuidString
+
+    // End existing activities with the same name if requested
+    if request.endExistingWithSameName {
+      try await endActivities(byName: finalActivityId)
+    }
+
+    // Create attributes and initial state
+    let attributes = VoltraAttributes(name: finalActivityId, deepLinkUrl: request.deepLinkUrl)
+    let initialState = try VoltraAttributes.ContentState(uiJsonData: request.jsonString)
+
+    // Request the activity
+    _ = try Activity.request(
+      attributes: attributes,
+      content: .init(
+        state: initialState,
+        staleDate: request.staleDate,
+        relevanceScore: request.relevanceScore
+      ),
+      pushType: request.pushType
+    )
+
+    return finalActivityId
+  }
+
+  // MARK: - Update Operations
+
+  /// Update an existing Live Activity
+  /// - Parameters:
+  ///   - activity: The activity to update
+  ///   - request: Parameters for updating the activity
+  /// - Throws: Error if update fails
+  public func updateActivity(
+    _ activity: VoltraActivity,
+    request: UpdateActivityRequest
+  ) async throws {
+    guard Self.isSupported() else {
+      throw VoltraLiveActivityError.unsupportedOS
+    }
+
+    let newState = try VoltraAttributes.ContentState(uiJsonData: request.jsonString)
+    await activity.update(
+      ActivityContent(
+        state: newState,
+        staleDate: request.staleDate,
+        relevanceScore: request.relevanceScore
+      )
+    )
+  }
+
+  /// Update an activity by name
+  /// - Parameters:
+  ///   - name: The activity name (activityId)
+  ///   - request: Parameters for updating the activity
+  /// - Throws: Error if activity not found or update fails
+  public func updateActivity(
+    byName name: String,
+    request: UpdateActivityRequest
+  ) async throws {
+    guard let activity = findActivity(byName: name) else {
+      throw VoltraLiveActivityError.notFound
+    }
+    try await updateActivity(activity, request: request)
+  }
+
+  // MARK: - End Operations
+
+  /// End a specific activity
+  /// - Parameter activity: The activity to end
+  /// - Parameter dismissalPolicy: How the activity should be dismissed
+  public func endActivity(
+    _ activity: VoltraActivity,
+    dismissalPolicy: ActivityUIDismissalPolicy = .immediate
+  ) async {
+    guard Self.isSupported() else { return }
+    await activity.end(
+      ActivityContent(state: activity.content.state, staleDate: nil),
+      dismissalPolicy: dismissalPolicy
+    )
+  }
+
+  /// End an activity by name
+  /// - Parameter name: The activity name (activityId)
+  /// - Parameter dismissalPolicy: How the activity should be dismissed
+  /// - Throws: Error if activity not found
+  public func endActivity(
+    byName name: String,
+    dismissalPolicy: ActivityUIDismissalPolicy = .immediate
+  ) async throws {
+    guard let activity = findActivity(byName: name) else {
+      throw VoltraLiveActivityError.notFound
+    }
+    await endActivity(activity, dismissalPolicy: dismissalPolicy)
+  }
+
+  /// End all activities with the same name
+  /// - Parameter name: The activity name (activityId)
+  public func endActivities(byName name: String) async throws {
+    guard Self.isSupported() else { return }
+    let activities = findActivities(byName: name)
+    for activity in activities {
+      await endActivity(activity)
+    }
+  }
+
+  /// End all Voltra Live Activities
+  public func endAllActivities() async {
+    guard Self.isSupported() else { return }
+    let activities = getAllActivities()
+    for activity in activities {
+      await endActivity(activity)
+    }
+  }
+
+  // MARK: - Monitoring
+
+  private var activityManager: VoltraLiveActivityManager?
+
+  /// Start monitoring all Live Activities, push tokens, and lifecycle state changes.
+  public func startMonitoring(enablePush: Bool) {
+    let onTokenUpdated: (@Sendable (String, String) -> Void)?
+    let onPushToStartUpdated: (@Sendable (String) -> Void)?
+
+    if enablePush {
+      onTokenUpdated = { activityName, token in
+        VoltraEventBus.shared.send(.tokenReceived(activityName: activityName, pushToken: token))
+      }
+      onPushToStartUpdated = { token in
+        VoltraEventBus.shared.send(.pushToStartTokenReceived(token: token))
+      }
+    } else {
+      onTokenUpdated = nil
+      onPushToStartUpdated = nil
+    }
+
+    let manager = VoltraLiveActivityManager(
+      onTokenUpdated: onTokenUpdated,
+      onPushToStartUpdated: onPushToStartUpdated,
+      onStateChanged: { activityName, state in
+        VoltraEventBus.shared.send(.stateChange(activityName: activityName, state: state))
+      }
+    )
+
+    activityManager = manager
+    Task { await manager.startObserving() }
+  }
+
+  /// Stop all monitoring and cancel every outstanding observation task.
+  public func stopMonitoring() {
+    let manager = activityManager
+    activityManager = nil
+    Task { await manager?.stopObserving() }
+  }
+}
+
+// MARK: - Errors
+
+public enum VoltraLiveActivityError: Error {
+  case unsupportedOS
+  case notFound
+  case liveActivitiesNotEnabled
+}

package/ios/app/VoltraModule.swift

@@ -0,0 +1,215 @@
+import Foundation
+
+public enum VoltraErrors: Error {
+  case unsupportedOS
+  case notFound
+  case liveActivitiesNotEnabled
+  case unexpectedError(Error)
+}
+
+@objc public final class VoltraModule: NSObject {
+  private let impl: VoltraModuleImpl
+
+  @objc override public init() {
+    impl = VoltraModuleImpl()
+    super.init()
+  }
+
+  @objc public func startMonitoringWithEventHandler(
+    _ handler: @escaping (NSString, NSDictionary) -> Void
+  ) {
+    impl.startMonitoring { eventName, eventData in
+      handler(eventName as NSString, eventData as NSDictionary)
+    }
+  }
+
+  @objc public func stopMonitoring() {
+    impl.stopMonitoring()
+  }
+
+  // MARK: - Live Activity
+
+  @objc public func startLiveActivity(
+    _ jsonString: String,
+    options: StartVoltraOptions?,
+    completion: @escaping (String?, Error?) -> Void
+  ) {
+    Task {
+      do {
+        try completion(await impl.startLiveActivity(jsonString: jsonString, options: options), nil)
+      } catch {
+        completion(nil, error)
+      }
+    }
+  }
+
+  @objc public func updateLiveActivity(
+    _ activityId: String,
+    jsonString: String,
+    options: UpdateVoltraOptions?,
+    completion: @escaping (Error?) -> Void
+  ) {
+    Task {
+      do {
+        try await impl.updateLiveActivity(activityId: activityId, jsonString: jsonString, options: options)
+        completion(nil)
+      } catch {
+        completion(error)
+      }
+    }
+  }
+
+  @objc public func endLiveActivity(
+    _ activityId: String,
+    options: EndVoltraOptions?,
+    completion: @escaping (Error?) -> Void
+  ) {
+    Task {
+      do {
+        try await impl.endLiveActivity(activityId: activityId, options: options)
+        completion(nil)
+      } catch {
+        completion(error)
+      }
+    }
+  }
+
+  @objc public func endAllLiveActivities(_ completion: @escaping (Error?) -> Void) {
+    Task {
+      do {
+        try await impl.endAllLiveActivities()
+        completion(nil)
+      } catch {
+        completion(error)
+      }
+    }
+  }
+
+  @objc public func getLatestVoltraActivityId() -> String? {
+    impl.getLatestVoltraActivityId()
+  }
+
+  @objc public func listVoltraActivityIds() -> [String] {
+    impl.listVoltraActivityIds()
+  }
+
+  @objc public func isLiveActivityActive(_ activityName: String) -> Bool {
+    impl.isLiveActivityActive(name: activityName)
+  }
+
+  @objc public func isHeadless() -> Bool {
+    impl.isHeadless()
+  }
+
+  // MARK: - Images
+
+  @objc public func preloadImages(
+    _ images: NSArray,
+    completion: @escaping (NSDictionary?, Error?) -> Void
+  ) {
+    let opts = images.compactMap { $0 as? NSDictionary }.map(PreloadImageOptions.init)
+    Task {
+      do {
+        try completion(await impl.preloadImages(images: opts).toDictionary(), nil)
+      } catch {
+        completion(nil, error)
+      }
+    }
+  }
+
+  @objc public func reloadLiveActivities(
+    _ activityNames: NSArray?,
+    completion: @escaping (Error?) -> Void
+  ) {
+    let names = activityNames?.compactMap { $0 as? String }
+    Task {
+      do {
+        try await impl.reloadLiveActivities(activityNames: names)
+        completion(nil)
+      } catch {
+        completion(error)
+      }
+    }
+  }
+
+  @objc public func clearPreloadedImages(_ keys: NSArray?, completion: @escaping () -> Void) {
+    Task {
+      await impl.clearPreloadedImages(keys: keys?.compactMap { $0 as? String })
+      completion()
+    }
+  }
+
+  // MARK: - Home Screen Widgets
+
+  @objc public func updateWidget(
+    _ widgetId: String,
+    jsonString: String,
+    options: UpdateWidgetOptions?,
+    completion: @escaping (Error?) -> Void
+  ) {
+    Task {
+      do {
+        try await impl.updateWidget(widgetId: widgetId, jsonString: jsonString, options: options)
+        completion(nil)
+      } catch {
+        completion(error)
+      }
+    }
+  }
+
+  @objc public func scheduleWidget(
+    _ widgetId: String,
+    timelineJson: String,
+    completion: @escaping (Error?) -> Void
+  ) {
+    Task {
+      do {
+        try await impl.scheduleWidget(widgetId: widgetId, timelineJson: timelineJson)
+        completion(nil)
+      } catch {
+        completion(error)
+      }
+    }
+  }
+
+  @objc public func reloadWidgets(_ widgetIds: NSArray?, completion: @escaping () -> Void) {
+    Task {
+      await impl.reloadWidgets(widgetIds: widgetIds?.compactMap { $0 as? String })
+      completion()
+    }
+  }
+
+  @objc public func clearWidget(_ widgetId: String, completion: @escaping () -> Void) {
+    Task {
+      await impl.clearWidget(widgetId: widgetId)
+      completion()
+    }
+  }
+
+  @objc public func clearAllWidgets(_ completion: @escaping () -> Void) {
+    Task {
+      await impl.clearAllWidgets()
+      completion()
+    }
+  }
+
+  @objc public func getActiveWidgets(_ completion: @escaping (NSArray?, Error?) -> Void) {
+    Task {
+      do {
+        try completion(await impl.getActiveWidgets() as NSArray, nil)
+      } catch {
+        completion(nil, error)
+      }
+    }
+  }
+
+  // MARK: - Widget Server Credentials
+
+  @objc public func setWidgetServerCredentials(_ token: String, headers: NSDictionary?) {
+    impl.setWidgetServerCredentials(token: token, headers: headers as? [String: String])
+  }
+
+  @objc public func clearWidgetServerCredentials() {
+    impl.clearWidgetServerCredentials()
+  }
+}