voltra 1.4.1 → 2.0.0-rc.4

package/ios/app/VoltraLiveActivityManager.swift

@@ -1,228 +0,0 @@
-import ActivityKit
-import Foundation
-
-//  The underlying ActivityKit APIs deliver updates via async for-await loops that
-//  run on arbitrary tasks. Without synchronization, dictionaries and sets mutated
-//  from those tasks are data races. Making this type an `actor` ensures every read
-//  and write to its stored properties is serialized automatically by the Swift
-//  concurrency runtime -- no locks required.
-
-public actor VoltraLiveActivityManager {
-  // MARK: - Callbacks
-
-  // Callbacks are `let` + `@Sendable` so they are immutable after init and safe
-  // to call from any concurrency context without capturing `self`.
-
-  /// Called when a push token is received or rotated for a specific activity.
-  /// Parameters: (activityName, hexToken)
-  private let onTokenUpdated: (@Sendable (String, String) -> Void)?
-
-  /// Called when the push-to-start token is received or rotated (iOS 17.2+).
-  /// Parameter: hexToken
-  private let onPushToStartUpdated: (@Sendable (String) -> Void)?
-
-  /// Called when an activity transitions to a new lifecycle state.
-  /// Parameters: (activityName, stateDescription)
-  private let onStateChanged: (@Sendable (String, String) -> Void)?
-
-  // MARK: - Internal Task State
-
-  /// Drives the main `Activity.activityUpdates` loop. When this task is cancelled,
-  /// the loop exits and no new per-activity observers are created.
-  private var activityUpdatesTask: Task<Void, Never>?
-
-  /// Drives the `Activity.pushToStartTokenUpdates` loop (iOS 17.2+ only).
-  private var pushToStartTask: Task<Void, Never>?
-
-  /// One push-token observer task per live activity, keyed by `activity.id`.
-  /// Using a dictionary (rather than a flat array) lets us deduplicate and cancel
-  /// individual tasks when an activity ends.
-  private var tokenTasks: [String: Task<Void, Never>] = [:]
-
-  /// One lifecycle-state observer task per live activity, keyed by `activity.id`.
-  private var stateTasks: [String: Task<Void, Never>] = [:]
-
-  /// The last push-to-start token we forwarded to the callback.
-  /// ActivityKit re-delivers the current token whenever a live activity starts or
-  /// ends (the push-to-start eligibility state has changed), even if the token
-  /// itself hasn't rotated. We track the last value so we only forward genuine
-  /// token changes and suppress duplicate deliveries.
-  private var lastPushToStartToken: String?
-
-  // MARK: - Init
-
-  public init(
-    onTokenUpdated: (@Sendable (String, String) -> Void)? = nil,
-    onPushToStartUpdated: (@Sendable (String) -> Void)? = nil,
-    onStateChanged: (@Sendable (String, String) -> Void)? = nil
-  ) {
-    self.onTokenUpdated = onTokenUpdated
-    self.onPushToStartUpdated = onPushToStartUpdated
-    self.onStateChanged = onStateChanged
-  }
-
-  // MARK: - Public API
-
-  /// Begin observing all live activities and tokens.
-  ///
-  /// This method is idempotent: calling it while already observing is a no-op.
-  /// To restart observation, call `stopObserving()` first.
-  public func startObserving() {
-    guard activityUpdatesTask == nil else { return }
-
-    startActivityUpdatesObservation()
-    startPushToStartObservation()
-  }
-
-  /// Stop all observation and cancel every outstanding task.
-  ///
-  /// Safe to call from any context. After this returns the actor holds no running
-  /// tasks; calling `startObserving()` again creates a fresh set.
-  public func stopObserving() {
-    activityUpdatesTask?.cancel()
-    activityUpdatesTask = nil
-
-    pushToStartTask?.cancel()
-    pushToStartTask = nil
-
-    lastPushToStartToken = nil
-
-    cancelAllPerActivityTasks()
-  }
-
-  // MARK: - deinit
-
-  /// Safety net: if the manager is deallocated without stopObserving() being called
-  /// (e.g. during app shutdown), cancel every task so no coroutine keeps running as
-  /// an orphan. SE-0371 (Swift 5.9) allows actors to access their stored properties
-  /// in deinit because no other reference can exist at that point.
-  deinit {
-    activityUpdatesTask?.cancel()
-    pushToStartTask?.cancel()
-    for task in tokenTasks.values {
-      task.cancel()
-    }
-    for task in stateTasks.values {
-      task.cancel()
-    }
-  }
-
-  // MARK: - Activity Updates Loop
-
-  private func startActivityUpdatesObservation() {
-    activityUpdatesTask = Task { [weak self] in
-      // Observe activities that were already running when we started --
-      // `Activity.activityUpdates` only yields *newly created* activities,
-      // so we must handle pre-existing ones explicitly.
-      for activity in Activity<VoltraAttributes>.activities {
-        await self?.observe(activity)
-      }
-
-      // Then listen for any activities created from this point onward.
-      for await activity in Activity<VoltraAttributes>.activityUpdates {
-        await self?.observe(activity)
-      }
-    }
-  }
-
-  // MARK: - Push-to-Start Token Loop (iOS 17.2+)
-
-  private func startPushToStartObservation() {
-    guard #available(iOS 17.2, *), let onPushToStartUpdated else { return }
-
-    // Read the token that may already be available before the async stream fires.
-    if let existingTokenData = Activity<VoltraAttributes>.pushToStartToken {
-      deliverPushToStartToken(existingTokenData.hexString, via: onPushToStartUpdated)
-    }
-
-    // Capture the callback locally so the task does not need to hop back to the
-    // actor on every token delivery -- callbacks are @Sendable and safe to call
-    // from any context.
-    let callback = onPushToStartUpdated
-
-    pushToStartTask = Task { [weak self] in
-      for await tokenData in Activity<VoltraAttributes>.pushToStartTokenUpdates {
-        await self?.deliverPushToStartToken(tokenData.hexString, via: callback)
-      }
-    }
-  }
-
-  /// Forward `token` to `callback` only if it differs from the last token we sent.
-  /// ActivityKit re-delivers the same token when a live activity starts or ends,
-  /// so this guard prevents spurious duplicate events on the JS side.
-  private func deliverPushToStartToken(
-    _ token: String,
-    via callback: @Sendable (String) -> Void
-  ) {
-    guard token != lastPushToStartToken else { return }
-    lastPushToStartToken = token
-    callback(token)
-  }
-
-  // MARK: - Per-Activity Observation
-
-  /// Start observing a single activity's push token and state changes.
-  ///
-  /// Deduplication: if we are already watching this activity (same `id`), this
-  /// is a no-op. `activityUpdates` can re-yield the same activity after updates,
-  /// so deduplication here prevents duplicate concurrent observers.
-  private func observe(_ activity: Activity<VoltraAttributes>) {
-    let activityId = activity.id
-    let activityName = activity.attributes.name
-
-    // Token observation
-    if let onTokenUpdated, tokenTasks[activityId] == nil {
-      // Capture the callback locally to avoid an actor hop on every token delivery.
-      let callback = onTokenUpdated
-
-      let tokenTask = Task { [weak self] in
-        for await tokenData in activity.pushTokenUpdates {
-          callback(activityName, tokenData.hexString)
-        }
-        // The async sequence ends when the activity is dismissed or ended.
-        // Clean up our entry so we don't hold a reference to the finished task.
-        await self?.removeTokenTask(for: activityId)
-      }
-
-      tokenTasks[activityId] = tokenTask
-    }
-
-    // State observation
-    if let onStateChanged, stateTasks[activityId] == nil {
-      let callback = onStateChanged
-
-      let stateTask = Task { [weak self] in
-        for await state in activity.activityStateUpdates {
-          callback(activityName, String(describing: state))
-        }
-        await self?.removeStateTask(for: activityId)
-      }
-
-      stateTasks[activityId] = stateTask
-    }
-  }
-
-  // MARK: - Task Cleanup Helpers
-
-  private func removeTokenTask(for activityId: String) {
-    tokenTasks[activityId]?.cancel()
-    tokenTasks.removeValue(forKey: activityId)
-  }
-
-  private func removeStateTask(for activityId: String) {
-    stateTasks[activityId]?.cancel()
-    stateTasks.removeValue(forKey: activityId)
-  }
-
-  private func cancelAllPerActivityTasks() {
-    for task in tokenTasks.values {
-      task.cancel()
-    }
-    tokenTasks.removeAll()
-
-    for task in stateTasks.values {
-      task.cancel()
-    }
-    stateTasks.removeAll()
-  }
-}

package/ios/app/VoltraLiveActivityService.swift

@@ -1,306 +0,0 @@
-//
-//  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

@@ -1,149 +0,0 @@
-import ActivityKit
-import Compression
-import ExpoModulesCore
-import Foundation
-import WidgetKit
-
-public class VoltraModule: Module {
-  public enum VoltraErrors: Error {
-    case unsupportedOS
-    case notFound
-    case liveActivitiesNotEnabled
-    case unexpectedError(Error)
-  }
-
-  private var impl: VoltraModuleImpl!
-
-  public func definition() -> ModuleDefinition {
-    Name("VoltraModule")
-
-    // UI component events forwarded from the extension + push/state events
-    Events("interaction", "activityTokenReceived", "activityPushToStartTokenReceived", "stateChange")
-
-    OnCreate {
-      self.impl = VoltraModuleImpl()
-    }
-
-    OnStartObserving {
-      // Subscribe to event bus and forward events to React Native
-      VoltraEventBus.shared.subscribe { [weak self] eventType, eventData in
-        self?.sendEvent(eventType, eventData)
-      }
-
-      // Start monitoring live activities and push tokens
-      self.impl.startMonitoring()
-    }
-
-    OnStopObserving {
-      self.impl.stopMonitoring()
-    }
-
-    AsyncFunction("startLiveActivity") { (jsonString: String, options: StartVoltraOptions?) async throws -> String in
-      return try await self.impl.startLiveActivity(jsonString: jsonString, options: options)
-    }
-
-    AsyncFunction("updateLiveActivity") { (activityId: String, jsonString: String, options: UpdateVoltraOptions?) async throws in
-      try await self.impl.updateLiveActivity(activityId: activityId, jsonString: jsonString, options: options)
-    }
-
-    AsyncFunction("endLiveActivity") { (activityId: String, options: EndVoltraOptions?) async throws in
-      try await self.impl.endLiveActivity(activityId: activityId, options: options)
-    }
-
-    // Preferred name mirroring iOS terminology
-    AsyncFunction("endAllLiveActivities") { () async throws in
-      try await self.impl.endAllLiveActivities()
-    }
-
-    // Return the latest (most recently created) Voltra Live Activity ID, if any.
-    // Useful to rebind after Fast Refresh in development.
-    AsyncFunction("getLatestVoltraActivityId") { () -> String? in
-      return self.impl.getLatestVoltraActivityId()
-    }
-
-    // Debug helper: list all running Voltra Live Activity IDs
-    AsyncFunction("listVoltraActivityIds") { () -> [String] in
-      return self.impl.listVoltraActivityIds()
-    }
-
-    Function("isLiveActivityActive") { (activityName: String) -> Bool in
-      return self.impl.isLiveActivityActive(name: activityName)
-    }
-
-    Function("isHeadless") { () -> Bool in
-      return self.impl.isHeadless()
-    }
-
-    // Preload images to App Group storage for use in Live Activities
-    AsyncFunction("preloadImages") { (images: [PreloadImageOptions]) async throws -> PreloadImagesResult in
-      return try await self.impl.preloadImages(images: images)
-    }
-
-    // Reload Live Activities to pick up preloaded images
-    // This triggers an update with the same content state, forcing SwiftUI to re-render
-    AsyncFunction("reloadLiveActivities") { (activityNames: [String]?) async throws in
-      try await self.impl.reloadLiveActivities(activityNames: activityNames)
-    }
-
-    // Clear preloaded images from App Group storage
-    AsyncFunction("clearPreloadedImages") { (keys: [String]?) async in
-      await self.impl.clearPreloadedImages(keys: keys)
-    }
-
-    // MARK: - Home Screen Widget Functions
-
-    // Update a home screen widget with new content
-    AsyncFunction("updateWidget") { (widgetId: String, jsonString: String, options: UpdateWidgetOptions?) async throws in
-      try await self.impl.updateWidget(widgetId: widgetId, jsonString: jsonString, options: options)
-    }
-
-    // Schedule a widget timeline with multiple entries
-    AsyncFunction("scheduleWidget") { (widgetId: String, timelineJson: String) async throws in
-      try await self.impl.scheduleWidget(widgetId: widgetId, timelineJson: timelineJson)
-    }
-
-    // Reload widget timelines to refresh their content
-    AsyncFunction("reloadWidgets") { (widgetIds: [String]?) async in
-      await self.impl.reloadWidgets(widgetIds: widgetIds)
-    }
-
-    // Clear a widget's stored data
-    AsyncFunction("clearWidget") { (widgetId: String) async in
-      await self.impl.clearWidget(widgetId: widgetId)
-    }
-
-    // Clear all widgets' stored data
-    AsyncFunction("clearAllWidgets") { () async in
-      await self.impl.clearAllWidgets()
-    }
-
-    AsyncFunction("getActiveWidgets") { () async throws -> [[String: String]] in
-      return try await self.impl.getActiveWidgets()
-    }
-
-    // Widget Server Credentials
-    AsyncFunction("setWidgetServerCredentials") { (credentials: [String: Any]) in
-      guard let token = credentials["token"] as? String else {
-        throw VoltraErrors.unexpectedError(
-          NSError(domain: "VoltraModule", code: -20, userInfo: [NSLocalizedDescriptionKey: "token is required in credentials"])
-        )
-      }
-      let headers = credentials["headers"] as? [String: String]
-      self.impl.setWidgetServerCredentials(token: token, headers: headers)
-    }
-
-    AsyncFunction("clearWidgetServerCredentials") { () in
-      self.impl.clearWidgetServerCredentials()
-    }
-
-    View(VoltraRN.self) {
-      Prop("payload") { (view, payload: String) in
-        view.setPayload(payload)
-      }
-
-      Prop("viewId") { (view, viewId: String) in
-        view.setViewId(viewId)
-      }
-    }
-  }
-}