expo-invoke 2.6.15 → 2.7.0

package/ios/Widgets/Widget/Utils.swift

@@ -0,0 +1,116 @@
+import SwiftUI
+import WidgetKit
+import Foundation
+
+func parseTimeline(identifier: String, name: String, family: WidgetFamily) -> [WidgetsTimelineEntry] {
+  guard let timeline = WidgetsStorage.getArray(forKey: "__expo_widgets_\(name)_timeline") else {
+    return [WidgetsTimelineEntry(date: Date(), name: name, props: nil, entryIndex: nil)]
+  }
+
+  let entries: [WidgetsTimelineEntry?] = timeline.enumerated().map { index, entry in
+    if let entry = entry as? [String: Any], let timestamp = entry["timestamp"] as? Int, let props = entry["props"] as? [String: Any] {
+      return WidgetsTimelineEntry(
+        date: Date(timeIntervalSince1970: Double(timestamp) / 1000),
+        name: name,
+        props: props,
+        entryIndex: index
+      )
+    }
+    return nil
+  }
+
+  return entries.compactMap(\.self)
+}
+
+public func createRedBox(message: String, stack: String? = nil) -> [String: Any] {
+  var props: [String: Any] = ["message": message]
+  if let stack {
+    props["stack"] = stack
+  }
+  return ["type": "RedBoxView", "props": props]
+}
+
+public func evaluateLayout(
+  layout: String,
+  props: [String: Any]?,
+  environment: [String: Any]
+) -> [String: Any] {
+  switch evaluateWidgetLayout(layout: layout, props: props, environment: environment) {
+  case .success(let result):
+    return result
+  case .failure(let error):
+    print("[ExpoWidgets] Layout evaluation failed: \(error.message)")
+    return createRedBox(message: error.message)
+  }
+}
+
+func getLiveActivityNodes(forName name: String, props: String? = nil, environment: [String: Any]) -> [String: Any] {
+  let layout = WidgetsStorage.getString(forKey: "__expo_widgets_live_activity_\(name)_layout") ?? ""
+  let propsDict = props.flatMap { props in
+    props.data(using: .utf8).flatMap {
+      try? JSONSerialization.jsonObject(with: $0, options: []) as? [String: Any]
+    }
+  }
+
+  switch evaluateWidgetLayout(layout: layout, props: propsDict, environment: environment) {
+  case .success(let result):
+    return result
+  case .failure(let error):
+    print("[ExpoWidgets] Layout evaluation failed: \(error.message)")
+    return ["banner": createRedBox(message: error.message)]
+  }
+}
+
+func getLiveActivityUrl(forName name: String) -> URL? {
+  guard let urlString = WidgetsStorage.getString(forKey: "__expo_widgets_live_activity_\(name)_url") else {
+    return nil
+  }
+  return URL(string: urlString)
+}
+
+public func getWidgetEnvironment(environment: EnvironmentValues) -> [String: Any] {
+  var env: [String: Any] = [
+    "showsContainerBackground": environment.showsWidgetContainerBackground,
+    "widgetFamily": environment.widgetFamily.description,
+    "colorScheme": "\(environment.colorScheme)"
+  ]
+
+  if #available(iOS 16.0, *) {
+    env["isLuminanceReduced"] = environment.isLuminanceReduced
+    env["widgetRenderingMode"] = environment.widgetRenderingMode.description
+    env["showsWidgetLabel"] = environment.showsWidgetLabel
+  }
+  if #available(iOS 17.0, *) {
+    env["widgetContentMargins"] = [
+      "top": environment.widgetContentMargins.top,
+      "bottom": environment.widgetContentMargins.bottom,
+      "leading": environment.widgetContentMargins.leading,
+      "trailing": environment.widgetContentMargins.trailing,
+    ]
+  }
+  if #available(iOS 26.0, *) {
+    env["levelOfDetail"] = environment.levelOfDetail == .simplified ? "simplified" : environment.levelOfDetail == .default ? "default" : nil
+  }
+  return env
+}
+
+func getLiveActivityEnvironment(environment: EnvironmentValues) -> [String: Any] {
+  var env: [String: Any] = [
+    "colorScheme": "\(environment.colorScheme)"
+  ]
+
+  if #available(iOS 16.0, *) {
+    env["isLuminanceReduced"] = environment.isLuminanceReduced
+  }
+  if #available(iOS 16.1, *) {
+    env["isActivityFullscreen"] = environment.isActivityFullscreen
+  }
+  if #available(iOS 18.0, *) {
+    env["isActivityUpdateReduced"] = environment.isActivityUpdateReduced
+    env["activityFamily"] = "\(environment.activityFamily)"
+  }
+  if #available(iOS 26.0, *) {
+    env["levelOfDetail"] = environment.levelOfDetail == .simplified ? "simplified" : environment.levelOfDetail == .default ? "default" : nil
+  }
+  return env
+}

package/ios/Widgets/Widget/WidgetLiveActivity.swift

@@ -0,0 +1,104 @@
+import SwiftUI
+import WidgetKit
+import ExpoModulesCore
+import ActivityKit
+
+struct LiveActivityAttributes: ActivityAttributes {
+  public struct ContentState: Codable, Hashable {
+    var name: String
+    var props: String?
+  }
+}
+
+@available(iOS 16.1, *)
+public struct WidgetLiveActivity: Widget {
+  @Environment(\.self) var env
+  
+  let widgetContext: AppContext = AppContext()
+  
+  var environment: [String: Any] {
+    return getLiveActivityEnvironment(environment: env)
+  }
+
+  public init() {}
+
+  public var body: some WidgetConfiguration {
+    ActivityConfiguration(for: LiveActivityAttributes.self) { context in
+      let nodes = getLiveActivityNodes(
+        forName: context.state.name,
+        props: context.state.props,
+        environment: environment
+      )
+      LiveActivityBannerView(context: context, nodes: nodes)
+    } dynamicIsland: { context in
+      let nodes = getLiveActivityNodes(
+        forName: context.state.name,
+        props: context.state.props,
+        environment: environment
+      )
+      return DynamicIsland {
+        DynamicIslandExpandedRegion(.center) {
+          LiveActivitySectionView(context: context, nodes: nodes, sectionName: "expandedCenter")
+        }
+        DynamicIslandExpandedRegion(.leading) {
+          LiveActivitySectionView(context: context, nodes: nodes, sectionName: "expandedLeading")
+        }
+        DynamicIslandExpandedRegion(.trailing) {
+          LiveActivitySectionView(context: context, nodes: nodes, sectionName: "expandedTrailing")
+        }
+        DynamicIslandExpandedRegion(.bottom) {
+          LiveActivitySectionView(context: context, nodes: nodes, sectionName: "expandedBottom")
+        }
+      } compactLeading: {
+        LiveActivitySectionView(context: context, nodes: nodes, sectionName: "compactLeading")
+      } compactTrailing: {
+        LiveActivitySectionView(context: context, nodes: nodes, sectionName: "compactTrailing")
+      } minimal: {
+        LiveActivitySectionView(context: context, nodes: nodes, sectionName: "minimal")
+      }
+      .widgetURL(getLiveActivityUrl(forName: context.state.name))
+    }
+    .supplementalActivityFamiliesIfAvailable()
+  }
+}
+
+@available(iOS 16.1, *)
+private struct LiveActivitySectionView: View {
+  let context: ActivityViewContext<LiveActivityAttributes>
+  let nodes: [String: Any]
+  let sectionName: String
+
+  var body: some View {
+    if let node = nodes[sectionName] as? [String: Any] {
+      WidgetsDynamicView(name: context.activityID, kind: .liveActivity, node: node)
+    } else {
+      EmptyView()
+    }
+  }
+}
+
+@available(iOS 16.1, *)
+private struct LiveActivityBannerView: View {
+  var context: ActivityViewContext<LiveActivityAttributes>
+  let nodes: [String: Any]
+
+  var body: some View {
+    if #available(iOS 18.0, *) {
+      LiveActivityBanner(context: context, nodes: nodes)
+    } else if let node = nodes["banner"] as? [String: Any] {
+      WidgetsDynamicView(name: context.activityID, kind: .liveActivity, node: node)
+    } else {
+      EmptyView()
+    }
+  }
+}
+
+extension WidgetConfiguration {
+  func supplementalActivityFamiliesIfAvailable() -> some WidgetConfiguration {
+    if #available(iOS 18.0, iOSApplicationExtension 18.0, *) {
+      return self.supplementalActivityFamilies([.small, .medium])
+    } else {
+      return self
+    }
+  }
+}

package/ios/Widgets/Widget/WidgetsJSRuntime.swift

@@ -0,0 +1,148 @@
+import Foundation
+import JavaScriptCore
+
+struct WidgetJavaScriptError: Error {
+  let message: String
+}
+
+typealias WidgetJavaScriptResult<Value> = Result<Value, WidgetJavaScriptError>
+
+private final class WidgetsJSRuntime {
+  static let shared = WidgetsJSRuntime()
+
+  private let lock = NSRecursiveLock()
+  private var context: JSContext?
+  private var bundleScript: String?
+  private var layoutCache: [String: JSValue] = [:]
+
+  private init() {}
+
+  func render(layout: String, props: [String: Any]?, environment: [String: Any]) -> WidgetJavaScriptResult<[String: Any]> {
+    call(layout: layout, functionName: "__expoWidgetRender") { context in
+      [props.map { $0 } ?? JSValue(undefinedIn: context) as Any, environment]
+    }.flatMap { result in
+      guard let renderedNode = result?.toObject() as? [String: Any] else {
+        return .failure(WidgetJavaScriptError(message: "Expo widget render did not produce any results."))
+      }
+      return .success(renderedNode)
+    }
+  }
+
+  func handlePress(layout: String, props: [String: Any], environment: [String: Any]) -> WidgetJavaScriptResult<[String: Any]?> {
+    call(layout: layout, functionName: "__expoWidgetHandlePress") { _ in [props, environment] }
+      .map { $0?.toObject() as? [String: Any] }
+  }
+
+  private func call(
+    layout: String,
+    functionName: String,
+    arguments: (JSContext) -> [Any]
+  ) -> WidgetJavaScriptResult<JSValue?> {
+    lock.lock()
+    defer { lock.unlock() }
+
+    guard let context = getContext() else {
+      return .failure(WidgetJavaScriptError(message: "Could not create context for layout evaluation."))
+    }
+    guard let layoutValue = getLayoutValue(layout, in: context) else {
+      return .failure(WidgetJavaScriptError(message: contextExceptionMessage(context) ?? "Could not evaluate layout."))
+    }
+
+    context.exception = nil
+    context.setObject(layoutValue, forKeyedSubscript: "__expoWidgetLayout" as NSString)
+
+    let function = context.objectForKeyedSubscript(functionName)
+    guard let function, function.isObject else {
+      return .failure(WidgetJavaScriptError(message: "Expo widget runtime function \(functionName) is unavailable."))
+    }
+
+    let result = function.call(withArguments: arguments(context))
+    if let exceptionMessage = contextExceptionMessage(context) {
+      return .failure(WidgetJavaScriptError(message: exceptionMessage))
+    }
+    return .success(result)
+  }
+
+  private func getContext() -> JSContext? {
+    if let context {
+      return context
+    }
+
+    guard let context = JSContext() else {
+      return nil
+    }
+
+    guard let script = getBundleScript() else {
+      print("[ExpoWidgets] Missing ExpoWidgets.bundle")
+      return nil
+    }
+
+    context.evaluateScript(script)
+    if let exceptionMessage = contextExceptionMessage(context) {
+      print("[ExpoWidgets] Bundle evaluation failed: \(exceptionMessage)")
+      return nil
+    }
+
+    self.context = context
+    return context
+  }
+
+  private func getBundleScript() -> String? {
+    if let bundleScript {
+      return bundleScript
+    }
+
+    guard let bundleURL = Bundle.main.url(forResource: "ExpoWidgets", withExtension: "bundle"),
+          let bundle = Bundle(url: bundleURL),
+          let url = bundle.url(forResource: "ExpoWidgets", withExtension: "bundle"),
+          let script = try? String(contentsOf: url, encoding: .utf8) else {
+      return nil
+    }
+
+    bundleScript = script
+    return script
+  }
+
+  private func getLayoutValue(_ layout: String, in context: JSContext) -> JSValue? {
+    if let layoutValue = layoutCache[layout] {
+      return layoutValue
+    }
+
+    context.exception = nil
+    guard let layoutValue = context.evaluateScript("(\(layout))"),
+          !layoutValue.isUndefined else {
+      return nil
+    }
+    guard context.exception == nil else {
+      return nil
+    }
+
+    layoutCache[layout] = layoutValue
+    return layoutValue
+  }
+
+  private func contextExceptionMessage(_ context: JSContext) -> String? {
+    guard let exception = context.exception else {
+      return nil
+    }
+
+    context.exception = nil
+    return exception.toString() ?? "Unknown JavaScript exception."
+  }
+}
+
+func evaluateWidgetLayout(
+  layout: String,
+  props: [String: Any]?,
+  environment: [String: Any]
+) -> WidgetJavaScriptResult<[String: Any]> {
+  WidgetsJSRuntime.shared.render(layout: layout, props: props, environment: environment)
+}
+
+func evaluateWidgetButtonPress(
+  layout: String,
+  props: [String: Any],
+  environment: [String: Any]
+) -> WidgetJavaScriptResult<[String: Any]?> {
+  WidgetsJSRuntime.shared.handlePress(layout: layout, props: props, environment: environment)
+}

package/ios/Widgets/WidgetObject.swift

@@ -0,0 +1,31 @@
+import ExpoModulesCore
+import WidgetKit
+
+final class WidgetObject: SharedObject {
+  let name: String
+  init(name: String, layout: String) {
+    self.name = name
+    WidgetsStorage.set(layout, forKey: "__expo_widgets_\(name)_layout")
+  }
+
+  func reload() {
+    WidgetCenter.shared.reloadTimelines(ofKind: name)
+  }
+
+  func updateTimeline(entries: [WidgetsJSTimelineEntry]) throws {
+    if WidgetsStorage.getString(forKey: "__expo_widgets_\(name)_layout") == nil {
+      throw UpdatedTimelineWithoutLayout(name)
+    }
+    WidgetsStorage.set(entries.map { $0.toDictionary() }, forKey: "__expo_widgets_\(name)_timeline")
+
+    self.reload()
+  }
+
+  func getTimeline() throws -> [WidgetsJSTimelineEntry] {
+    guard let entries = WidgetsStorage.getArray(forKey: "__expo_widgets_\(name)_timeline") as? [[String: Any]],
+          let appContext else {
+      return []
+    }
+    return try entries.map { try WidgetsJSTimelineEntry(from: $0, appContext: appContext) }
+  }
+}

package/ios/Widgets/WidgetsContext.swift

@@ -0,0 +1,7 @@
+import ExpoModulesCore
+
+// Shared AppContext for widgets
+struct WidgetsContext {
+  static let shared = WidgetsContext()
+  let context: AppContext = AppContext()
+}

package/ios/Widgets/WidgetsEvents.swift

@@ -0,0 +1,16 @@
+public enum WidgetsEventType: String {
+  case userEvent = "ExpoWidgetsUserInteraction"
+}
+
+public class WidgetsEvents {
+  public static let shared = WidgetsEvents()
+
+  private init() {}
+
+  public func sendNotification(type: WidgetsEventType, data: [String: Any]) {
+    var eventData = data
+    eventData["type"] = type.rawValue
+    let userInfo = ["eventData": eventData] as [String: Any]
+    NotificationCenter.default.post(name: onUserInteractionNotification, object: nil, userInfo: userInfo)
+  }
+}

package/ios/Widgets/WidgetsExceptions.swift

@@ -0,0 +1,25 @@
+import ExpoModulesCore
+
+internal final class LiveActivitiesNotSupportedException: Exception, @unchecked Sendable {
+  override var reason: String {
+    "Live Activities are not supported on this device"
+  }
+}
+
+internal final class StartLiveActivityException: GenericException<String>, @unchecked Sendable {
+  override var reason: String {
+    "Failed to start live activity: \(param)"
+  }
+}
+
+internal final class LiveActivityNotFoundException: GenericException<String>, @unchecked Sendable {
+  override var reason: String {
+    "Can't find live activity with id: \(param)"
+  }
+}
+
+internal final class UpdatedTimelineWithoutLayout: GenericException<String>, @unchecked Sendable {
+  override var reason: String {
+    "Cannot update widget timeline without a layout, first register a layout for: \(param)"
+  }
+}

package/ios/Widgets/WidgetsModule.swift

@@ -0,0 +1,149 @@
+import ExpoModulesCore
+import ActivityKit
+import WidgetKit
+
+let pushNotificationsEnabledKey: String = "ExpoWidgets_EnablePushNotifications"
+
+let onUserInteraction = "onExpoWidgetsUserInteraction"
+let onPushToStartTokenReceived = "onExpoWidgetsPushToStartTokenReceived"
+let onTokenReceived = "onExpoWidgetsTokenReceived"
+let onUserInteractionNotification = Notification.Name(onUserInteraction)
+
+public final class WidgetsModule: Module {
+  var pushToStartTokenObserverTask: Task<Void, Never>?
+
+  public func definition() -> ModuleDefinition {
+    Name("ExpoWidgets")
+
+    Events(onPushToStartTokenReceived, onTokenReceived, onUserInteraction)
+
+    OnStartObserving(onUserInteraction) {
+      NotificationCenter.default.addObserver(
+        self,
+        selector: #selector(handleUserInteractionNotification),
+        name: onUserInteractionNotification,
+        object: nil
+      )
+    }
+
+    OnStopObserving(onUserInteraction) {
+      NotificationCenter.default.removeObserver(
+        self,
+        name: onUserInteractionNotification,
+        object: nil
+      )
+    }
+
+    OnStartObserving(onPushToStartTokenReceived) {
+      if pushNotificationsEnabled {
+        observePushToStartToken()
+      }
+    }
+
+    OnStopObserving(onPushToStartTokenReceived) {
+      pushToStartTokenObserverTask?.cancel()
+      pushToStartTokenObserverTask = nil
+    }
+
+    Constant("widgetsDirectory") { () -> String? in
+      guard let appGroupIdentifier = WidgetsStorage.appGroupIdentifier,
+            let containerUrl = FileManager.default.containerURL(forSecurityApplicationGroupIdentifier: appGroupIdentifier) else {
+        return nil
+      }
+      let directoryUrl = containerUrl.appendingPathComponent("ExpoWidgets", isDirectory: true)
+      do {
+        try FileManager.default.createDirectory(at: directoryUrl, withIntermediateDirectories: true)
+        return directoryUrl.absoluteString
+      } catch {
+        return nil
+      }
+    }
+
+    Function("reloadAllWidgets") {
+      WidgetCenter.shared.reloadAllTimelines()
+    }
+
+    Class("Widget", WidgetObject.self) {
+      Constructor { (name: String, layout: String) in
+        WidgetObject(name: name, layout: layout)
+      }
+
+      Function("reload") { (widget: WidgetObject) in
+        widget.reload()
+      }
+
+      Function("updateTimeline") { (widget: WidgetObject, entries: [WidgetsJSTimelineEntry]) in
+        try widget.updateTimeline(entries: entries)
+      }
+
+      Function("getTimeline") { (widget: WidgetObject) in
+        try widget.getTimeline()
+      }
+    }
+
+    Class("LiveActivityFactory", LiveActivityFactory.self) {
+      Constructor { (name: String, layout: String) in
+        LiveActivityFactory(name: name, layout: layout)
+      }
+
+      Function("start") { (liveActivity: LiveActivityFactory, props: String?, url: URL?) in
+        try liveActivity.start(props: props, url: url)
+      }
+
+      Function("getInstances") { (liveActivity: LiveActivityFactory) in
+        try liveActivity.getInstances()
+      }
+    }
+
+    Class("LiveActivity", LiveActivity.self) {
+      AsyncFunction("update") { (instance: LiveActivity, props: String?) in
+        try await instance.update(props: props)
+      }
+
+      AsyncFunction("end") { (instance: LiveActivity, dismissalPolicy: LiveActivityDismissalPolicy?, afterDate: Date?, props: String?, contentDate: Date?) in
+        try await instance.end(dismissalPolicy: dismissalPolicy, afterDate: afterDate, props: props, contentDate: contentDate)
+      }
+
+      AsyncFunction("getPushToken") { (instance: LiveActivity) in
+        try instance.getPushToken()
+      }
+    }
+  }
+
+  @objc func handleUserInteractionNotification(_ notification: Notification) {
+    guard let userInfo = notification.userInfo as? [String: Any],
+          let eventData = userInfo["eventData"] as? [String: Any]
+    else { return }
+    self.sendEvent(onUserInteraction, eventData)
+  }
+
+  private func sendPushToStartToken(activityPushToStartToken: String) {
+    sendEvent(
+      onPushToStartTokenReceived,
+      [
+        "activityPushToStartToken": activityPushToStartToken
+      ]
+    )
+  }
+
+  private func observePushToStartToken() {
+    guard #available(iOS 17.2, *), ActivityAuthorizationInfo().areActivitiesEnabled else { return }
+    pushToStartTokenObserverTask = Task {
+      let initialToken = (Activity<LiveActivityAttributes>.pushToStartToken?.reduce("") { $0 + String(format: "%02x", $1) })
+      if let initialToken {
+        sendPushToStartToken(activityPushToStartToken: initialToken)
+      }
+
+      for await data in Activity<LiveActivityAttributes>.pushToStartTokenUpdates {
+        let token = data.reduce("") { $0 + String(format: "%02x", $1) }
+        if token != initialToken {
+          sendPushToStartToken(activityPushToStartToken: token)
+        }
+      }
+    }
+  }
+
+  private var pushNotificationsEnabled: Bool {
+    Bundle.main.object(forInfoDictionaryKey: pushNotificationsEnabledKey) as? Bool ?? false
+  }
+}

package/ios/Widgets/WidgetsRecords.swift

@@ -0,0 +1,22 @@
+import ExpoModulesCore
+import ActivityKit
+
+struct WidgetsJSTimelineEntry: Record {
+  @Field var timestamp: Int
+  @Field var props: [String: Any] = [:]
+}
+
+internal enum LiveActivityDismissalPolicy: String, Enumerable {
+  case `default`
+  case immediate
+  case after
+
+  @available(iOS 16.1, *)
+  internal func toDismissalPolicy(date: Date?) -> ActivityUIDismissalPolicy {
+    return switch self {
+    case .default: .default
+    case .immediate: .immediate
+    case .after: .after(date ?? Date.now)
+    }
+  }
+}

package/ios/Widgets/WidgetsStorage.swift

@@ -0,0 +1,58 @@
+public enum WidgetsStorage {
+  public static var appGroupIdentifier: String? = Bundle.main.object(forInfoDictionaryKey: "ExpoWidgetsAppGroupIdentifier") as? String
+  static let defaults = UserDefaults(suiteName: appGroupIdentifier)
+
+  static func set(_ value: [String: Any], forKey key: String) {
+    guard let defaults else { return }
+
+    defaults.set(value, forKey: key)
+  }
+
+  static func set(_ value: [[String: Any]], forKey key: String) {
+    guard let defaults else { return }
+
+    defaults.set(value, forKey: key)
+  }
+
+  static func set(_ value: String, forKey key: String) {
+    guard let defaults else { return }
+
+    defaults.set(value, forKey: key)
+  }
+
+  static func set(_ value: Data, forKey key: String) {
+    guard let defaults else { return }
+
+    defaults.set(value, forKey: key)
+  }
+
+  public static func getDictionary(forKey key: String) -> [String: Any]? {
+    guard let defaults else { return nil }
+
+    return defaults.dictionary(forKey: key)
+  }
+
+  public static func getArray(forKey key: String) -> [Any]? {
+    guard let defaults else { return nil }
+
+    return defaults.array(forKey: key)
+  }
+
+  public static func getData(forKey key: String) -> Data? {
+    guard let defaults else { return nil }
+
+    return defaults.data(forKey: key)
+  }
+
+  public static func getString(forKey key: String) -> String? {
+    guard let defaults else { return nil }
+
+    return defaults.string(forKey: key)
+  }
+
+  static func removeObject(forKey key: String) {
+    guard let defaults else { return }
+
+    defaults.removeObject(forKey: key)
+  }
+}