expo-invoke 2.6.15 → 2.8.0

package/ios/Widgets/LiveActivityFactory.swift

@@ -0,0 +1,49 @@
+import ExpoModulesCore
+import ActivityKit
+
+final class LiveActivityFactory: SharedObject {
+  let name: String
+
+  static var pushNotificationsEnabled: Bool {
+    Bundle.main.object(forInfoDictionaryKey: pushNotificationsEnabledKey) as? Bool ?? false
+  }
+
+  init(name: String, layout: String) {
+    self.name = name
+    WidgetsStorage.set(layout, forKey: "__expo_widgets_live_activity_\(name)_layout")
+  }
+
+  func start(props: String?, url: URL?) throws -> LiveActivity {
+    guard #available(iOS 16.2, *) else { throw LiveActivitiesNotSupportedException() }
+    guard ActivityAuthorizationInfo().areActivitiesEnabled else {
+      throw LiveActivitiesNotSupportedException()
+    }
+
+    if let url {
+      WidgetsStorage.set(url.absoluteString, forKey: "__expo_widgets_live_activity_\(name)_url")
+    }
+
+    do {
+      let initialState = LiveActivityAttributes.ContentState(name: name, props: props)
+      let activity = try Activity.request(
+        attributes: LiveActivityAttributes(),
+        content: .init(state: initialState, staleDate: nil),
+        pushType: LiveActivityFactory.pushNotificationsEnabled ? .token : nil
+      )
+
+      let instance = LiveActivity(id: activity.id, name: name)
+      instance.observePushTokenUpdates(for: activity, pushNotificationsEnabled: LiveActivityFactory.pushNotificationsEnabled)
+      return instance
+    } catch {
+      throw StartLiveActivityException(error.localizedDescription)
+    }
+  }
+
+  func getInstances() throws -> [LiveActivity] {
+    guard #available(iOS 16.1, *) else { throw LiveActivitiesNotSupportedException() }
+
+    return Activity<LiveActivityAttributes>.activities.map { activity in
+      LiveActivity(id: activity.id, name: name)
+    }
+  }
+}

package/ios/Widgets/Widget/AppIntent.swift

@@ -0,0 +1,130 @@
+import AppIntents
+import WidgetKit
+
+struct WidgetReload: AppIntent {
+  // title is not used for non-discoverable intents, but it is required
+  static var title: LocalizedStringResource = "Reload widget"
+  static var isDiscoverable: Bool = false
+  @Parameter(title: "source")
+  var source: String?
+
+  init() {}
+  init(source: String?) {
+    self.source = source
+  }
+
+  func perform() async throws -> some IntentResult {
+    guard let source else {
+      return .result()
+    }
+
+    WidgetCenter.shared.reloadTimelines(ofKind: source)
+    return .result()
+  }
+}
+
+@available(iOS 16.0, *)
+struct WidgetUserInteraction: AppIntent {
+  // title is not used for non-discoverable intents, but it is required
+  static var title: LocalizedStringResource = "User Interaction"
+  static var isDiscoverable: Bool = false
+  @Parameter(title: "source")
+  var source: String?
+
+  @Parameter(title: "target")
+  var target: String?
+
+  @Parameter(title: "entryIndex")
+  var entryIndex: Int?
+
+  @Parameter(title: "environmentString")
+  var environmentString: String?
+
+  init() {}
+  init(source: String?, target: String?, entryIndex: Int?, environmentString: String?) {
+    self.source = source
+    self.target = target
+    self.entryIndex = entryIndex
+    self.environmentString = environmentString
+  }
+
+  func perform() async throws -> some IntentResult {
+    guard let source else {
+      return .result()
+    }
+
+    let layout = WidgetsStorage.getString(forKey: "__expo_widgets_\(source)_layout") ?? ""
+    let timeline = WidgetsStorage.getArray(forKey: "__expo_widgets_\(source)_timeline")
+
+    guard let timeline,
+          let entryIndex,
+          timeline.indices.contains(entryIndex),
+          let entry = timeline[entryIndex] as? [String: Any],
+          let props = entry["props"] as? [String: Any],
+          let environmentData = environmentString?.data(using: .utf8),
+          var environment = try? JSONSerialization.jsonObject(with: environmentData) as? [String: Any] else {
+      return .result()
+    }
+    environment["target"] = target
+
+    let newProps: [String: Any]?
+    switch evaluateWidgetButtonPress(layout: layout, props: props, environment: environment) {
+    case .success(let result):
+      newProps = result
+    case .failure(let error):
+      print("[ExpoWidgets] Button press evaluation failed: \(error.message)")
+      newProps = nil
+    }
+
+    if let newProps {
+      var newEntry = entry
+      if let originalProps = entry["props"] as? [String: Any] {
+        newEntry["props"] = originalProps.merging(newProps) { _, new in new }
+      }
+      guard var newTimeline = timeline as? [[String: Any]] else {
+        return .result()
+      }
+      newTimeline[entryIndex] = newEntry
+      WidgetsStorage.set(newTimeline, forKey: "__expo_widgets_\(source)_timeline")
+    }
+
+    WidgetsEvents.shared.sendNotification(type: .userEvent, data: [
+      "source": source as Any,
+      "target": target as Any,
+      "timestamp": Int(Date().timeIntervalSince1970 * 1000)
+    ])
+
+    WidgetCenter.shared.reloadTimelines(ofKind: source)
+
+    return .result()
+  }
+}
+
+@available(iOS 16.0, *)
+struct LiveActivityUserInteraction: LiveActivityIntent {
+  // title is not used for non-discoverable intents, but it is required
+  static var title: LocalizedStringResource = "User Interaction"
+  static var isDiscoverable: Bool = false
+
+  @Parameter(title: "source")
+  var source: String?
+
+  @Parameter(title: "target")
+  var target: String?
+
+  init() {}
+  init(source: String?, target: String?) {
+    self.source = source
+    self.target = target
+  }
+
+  func perform() async throws -> some IntentResult {
+    WidgetsEvents.shared.sendNotification(type: .userEvent, data: [
+      "source": source as Any,
+      "target": target as Any,
+      "timestamp": Int(Date().timeIntervalSince1970 * 1000)
+    ])
+
+    return .result()
+  }
+}

package/ios/Widgets/Widget/Buttons.swift

@@ -0,0 +1,62 @@
+import SwiftUI
+import ExpoModulesCore
+import ExpoUI
+
+final class ButtonProps: ExpoUI.ButtonProps {
+  @Field var source: String?
+  @Field var target: String?
+  @Field var entryIndex: Int?
+  @Field var environmentString: String?
+}
+
+@available(iOS 17.0, *)
+struct WidgetButtonView: ExpoSwiftUI.View {
+  @ObservedObject var props: ButtonProps
+
+  var body: some View {
+    SwiftUI.Button(
+      role: props.role?.toNativeRole(),
+      intent: WidgetUserInteraction(
+        source: props.source,
+        target: props.target,
+        entryIndex: props.entryIndex,
+        environmentString: props.environmentString
+      )
+    ) {
+      if let label = props.label {
+        if let systemImage = props.systemImage {
+          Label(title: { Text(label) }, icon: { Image(systemName: systemImage) })
+        } else {
+          Text(label)
+        }
+      } else {
+        Children()
+      }
+    }
+  }
+}
+
+@available(iOS 17.0, *)
+struct LiveActivityButtonView: ExpoSwiftUI.View {
+  @ObservedObject var props: ButtonProps
+
+  var body: some View {
+    SwiftUI.Button(
+      role: props.role?.toNativeRole(),
+      intent: LiveActivityUserInteraction(
+        source: props.source,
+        target: props.target
+      )
+    ) {
+      if let label = props.label {
+        if let systemImage = props.systemImage {
+          Label(title: { Text(label) }, icon: { Image(systemName: systemImage) })
+        } else {
+          Text(label)
+        }
+      } else {
+        Children()
+      }
+    }
+  }
+}

package/ios/Widgets/Widget/DynamicView.swift

@@ -0,0 +1,161 @@
+import SwiftUI
+import ExpoModulesCore
+import ExpoUI
+
+// TODO(@jakex7): Hack to satisfy ExpoSwiftUI.AnyChild with random UUID value
+class NodeIdentityWrapper {
+  let id: UUID
+  init(id: UUID) {
+    self.id = id
+  }
+}
+extension ObjectIdentifier: @retroactive Encodable {
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.singleValueContainer()
+    try container.encode(String(describing: self))
+  }
+}
+
+public struct WidgetsDynamicView: View, ExpoSwiftUI.AnyChild {
+  let node: [String: Any]
+  let name: String
+  let kind: WidgetsKind
+  let entryIndex: Int?
+  let environmentString: String?
+
+  let uuid = NodeIdentityWrapper(id: UUID())
+  public var id: ObjectIdentifier {
+    ObjectIdentifier(uuid)
+  }
+
+  public init(name: String, kind: WidgetsKind, node: [String: Any]) {
+    self.name = name
+    self.kind = kind
+    self.node = node
+    self.entryIndex = nil
+    self.environmentString = nil
+  }
+
+  public init(name: String, kind: WidgetsKind, node: [String: Any], entryIndex: Int?, environmentString: String?) {
+    self.name = name
+    self.kind = kind
+    self.node = node
+    self.entryIndex = entryIndex
+    self.environmentString = environmentString
+  }
+
+  @ViewBuilder
+  public var body: some View {
+    switch node["type"] as? String {
+    case "TextView":
+      render(TextView.self, TextViewProps.self, updateProps: updateChildren)
+    case "HStackView":
+      render(HStackView.self, HStackViewProps.self, updateProps: updateChildren)
+    case "VStackView":
+      render(VStackView.self, VStackViewProps.self, updateProps: updateChildren)
+    case "ZStackView":
+      render(ZStackView.self, ZStackViewProps.self, updateProps: updateChildren)
+    case "RectangleView":
+      render(RectangleView.self, RectangleViewProps.self)
+    case "RoundedRectangleView":
+      render(RoundedRectangleView.self, RoundedRectangleViewProps.self)
+    case "CapsuleView":
+      render(CapsuleView.self, CapsuleViewProps.self)
+    case "CircleView":
+      render(CircleView.self, CircleViewProps.self)
+    case "ImageView":
+      render(ImageView.self, ImageViewProps.self)
+    case "AccessoryWidgetBackgroundView":
+      render(AccessoryWidgetBackgroundView.self, AccessoryWidgetBackgroundProps.self)
+    case "DividerView":
+      render(DividerView.self, DividerProps.self)
+    case "EllipseView":
+      render(EllipseView.self, EllipseViewProps.self)
+    case "LabelView":
+      render(LabelView.self, LabelViewProps.self)
+    case "ProgressView":
+      render(ProgressView.self, ProgressViewProps.self)
+    case "SpacerView":
+      render(SpacerView.self, SpacerViewProps.self)
+    case "UnevenRoundedRectangleView":
+      render(UnevenRoundedRectangleView.self, UnevenRoundedRectangleViewProps.self)
+    case "GaugeView":
+      render(GaugeView.self, GaugeProps.self)
+    case "ChartView":
+      render(ChartView.self, ChartProps.self)
+    case "Button":
+      if #available(iOS 17.0, *) {
+        switch kind {
+        case .widget:
+          render(WidgetButtonView.self, ButtonProps.self) { buttonProps in
+            try updateChildren(buttonProps)
+            buttonProps.source = name
+            buttonProps.entryIndex = entryIndex
+            buttonProps.environmentString = environmentString
+          }
+        case .liveActivity:
+          render(LiveActivityButtonView.self, ButtonProps.self) { buttonProps in
+            try updateChildren(buttonProps)
+            buttonProps.source = name
+          }
+        }
+      } else {
+        render(ExpoUI.Button.self, ExpoUI.ButtonProps.self, updateProps: updateChildren)
+      }
+    case "react.fragment":
+      render(FragmentView.self, FragmentProps.self, updateProps: updateChildren)
+    case "LinkView":
+      render(LinkView.self, LinkViewProps.self, updateProps: updateChildren)
+#if DEBUG
+    case "RedBoxView":
+      render(RedBoxView.self, RedBoxViewProps.self) { redBoxProps in
+        redBoxProps.source = name
+        redBoxProps.kind = kind
+      }
+    default:
+      ZStack {
+        Color.red.opacity(0.5)
+        Text("Unable to get the view for: \(node["type"] as? String ?? "undefined")")
+      }
+#else
+    default:
+      EmptyView()
+#endif
+    }
+  }
+
+  // MARK: - Render Method
+
+  @ViewBuilder
+  private func render<P, V>(_ viewType: V.Type, _ propsType: P.Type, updateProps: ((_ initialProps: P) throws -> Void)? = nil) -> some View
+  where P: UIBaseViewProps, V: ExpoSwiftUI.View, V.Props == P {
+    // immediately invoked closure {}() here because we can't use 'do-catch' inside @ViewBuilder
+    {
+      do {
+        if let rawProps = node["props"] as? [String: Any] {
+          let props = try propsType.init(rawProps: rawProps, context: WidgetsContext.shared.context)
+          try updateProps?(props)
+          // TODO(@jakex7): Prevent unwanted transition when view is updated with new props - we want to have the same view instance recreated with new props instead of creating a new view instance and transitioning to it
+          return AnyView(UIBaseView<P, V>(props: props).transition(.identity))
+        }
+        return AnyView(EmptyView())
+      } catch {
+        return AnyView(EmptyView())
+      }
+    }()
+  }
+
+  // MARK: - Function that sets children as DynamicView
+
+  private func updateChildren<P>(_ initialProps: P) throws
+  where P: UIBaseViewProps {
+    if let props = node["props"] as? [String: Any] {
+      if let children = props["children"] as? [Any] {
+        let validChildren = children.compactMap { $0 as? [String: Any] }
+        initialProps.children = validChildren.map { WidgetsDynamicView(name: name, kind: kind, node: $0, entryIndex: entryIndex, environmentString: environmentString) }
+      } else if let child = props["children"] as? [String: Any] {
+        initialProps.children = [WidgetsDynamicView(name: name, kind: kind, node: child, entryIndex: entryIndex, environmentString: environmentString)]
+      }
+    }
+  }
+}

package/ios/Widgets/Widget/EntryView.swift

@@ -0,0 +1,36 @@
+import SwiftUI
+import ExpoModulesCore
+import WidgetKit
+
+public struct WidgetsEntryView: View {
+  @Environment(\.self) var environment
+  var entry: WidgetsTimelineProvider.Entry
+
+  public init(entry: WidgetsTimelineProvider.Entry) {
+    self.entry = entry
+  }
+
+  private var widgetEnvironment: [String: Any] {
+    var env: [String: Any] = getWidgetEnvironment(environment: environment)
+    env["timestamp"] = Int(entry.date.timeIntervalSince1970 * 1000)
+    return env
+  }
+
+  private var widgetEnvironmentString: String? {
+    guard let data = try? JSONSerialization.data(withJSONObject: widgetEnvironment),
+          let jsonString = String(data: data, encoding: .utf8) else {
+        return nil
+    }
+    return jsonString
+  }
+
+  public var body: some View {
+    if let layout = WidgetsStorage.getString(forKey: "__expo_widgets_\(entry.name)_layout"),
+       !layout.isEmpty {
+      let node = evaluateLayout(layout: layout, props: entry.props, environment: widgetEnvironment)
+      WidgetsDynamicView(name: entry.name, kind: .widget, node: node, entryIndex: entry.entryIndex, environmentString: widgetEnvironmentString)
+    } else {
+      WidgetsDynamicView(name: entry.name, kind: .widget, node: createRedBox(message: "No layout found for \(WidgetsStorage.appGroupIdentifier ?? "")::\(entry.name)"), entryIndex: entry.entryIndex, environmentString: widgetEnvironmentString)
+    }
+  }
+}

package/ios/Widgets/Widget/Fragment.swift

@@ -0,0 +1,13 @@
+import SwiftUI
+import ExpoModulesCore
+import ExpoUI
+
+final class FragmentProps: ExpoUI.ButtonProps {}
+
+struct FragmentView: ExpoSwiftUI.View {
+  @ObservedObject var props: FragmentProps
+
+  var body: some View {
+    Children()
+  }
+}

package/ios/Widgets/Widget/LiveActivityBanner.swift

@@ -0,0 +1,19 @@
+import SwiftUI
+import WidgetKit
+
+@available(iOS 18.0, *)
+struct LiveActivityBanner: View {
+  @Environment(\.activityFamily) var activityFamily
+  var context: ActivityViewContext<LiveActivityAttributes>
+  var nodes: [String: Any]?
+
+  var body: some View {
+    if activityFamily == .small, let node = nodes?["bannerSmall"] as? [String: Any] {
+      WidgetsDynamicView(name: context.activityID, kind: .liveActivity, node: node)
+    } else if let node = nodes?["banner"] as? [String: Any] {
+      WidgetsDynamicView(name: context.activityID, kind: .liveActivity, node: node)
+    } else {
+      EmptyView()
+    }
+  }
+}

package/ios/Widgets/Widget/RedBoxView.swift

@@ -0,0 +1,83 @@
+import ExpoModulesCore
+import SwiftUI
+import ExpoUI
+
+public final class RedBoxViewProps: UIBaseViewProps {
+  @Field var message: String
+  @Field var source: String?
+  @Field var stack: String?
+  var kind: WidgetsKind = .widget
+}
+
+public struct RedBoxView: ExpoSwiftUI.View {
+  @ObservedObject public var props: RedBoxViewProps
+
+  public init(props: RedBoxViewProps) {
+    self.props = props
+  }
+
+  public var body: some View {
+    FullSizeZStack(kind: props.kind) {
+      Color.red
+      VStack(alignment: .leading, spacing: 2) {
+        HStack(spacing: 6) {
+          Image(systemName: "exclamationmark.triangle.fill")
+          Text("Error").font(.headline)
+          Spacer()
+          if #available(iOS 17.0, *) {
+            Button(intent: WidgetReload(source: props.source)) {
+              Image(systemName: "arrow.clockwise")
+            }
+              .buttonStyle(.plain)
+              .padding(4)
+          }
+        }
+        .foregroundStyle(.white)
+
+        Text(props.message)
+          .font(.system(size: 14).bold().monospaced())
+          .foregroundStyle(.white.opacity(0.9))
+          .modifier(RedBoxBody())
+
+        if let stack = props.stack, !stack.isEmpty {
+          Text(stack)
+            .font(.system(size: 11).monospaced())
+            .foregroundStyle(.white.opacity(0.75))
+            .modifier(RedBoxBody())
+        }
+      }
+      .padding(12)
+      .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .topLeading)
+    }
+  }
+}
+
+private struct RedBoxBody: ViewModifier {
+  @ViewBuilder
+  func body(content: Content) -> some View {
+    let base = content.lineLimit(nil).fixedSize(horizontal: false, vertical: true)
+    if #available(iOS 26.0, *) {
+      base.lineHeight(.tight)
+    } else {
+      base
+    }
+  }
+}
+
+public struct FullSizeZStack<Content: View>: View {
+  let kind: WidgetsKind
+  let content: Content
+
+  init(kind: WidgetsKind = .widget, @ViewBuilder _ content: () -> Content) {
+    self.kind = kind
+    self.content = content()
+  }
+
+  public var body: some View {
+    if #available(iOS 17.0, *), kind == .widget {
+      ZStack { content }.containerRelativeFrame([.horizontal, .vertical])
+    } else {
+      ZStack { content }.frame(maxWidth: .infinity)
+    }
+  }
+}

package/ios/Widgets/Widget/TimelineEntry.swift

@@ -0,0 +1,8 @@
+import WidgetKit
+
+public struct WidgetsTimelineEntry: WidgetKit.TimelineEntry {
+  public let date: Date
+  public let name: String
+  public let props: [String: Any]?
+  public let entryIndex: Int?
+}

package/ios/Widgets/Widget/TimelineProvider.swift

@@ -0,0 +1,45 @@
+import WidgetKit
+
+public struct WidgetsTimelineProvider: TimelineProvider {
+  public func placeholder(in context: Context) -> WidgetsTimelineEntry {
+    WidgetsTimelineEntry(date: Date(), name: name, props: nil, entryIndex: nil)
+  }
+
+  public func getSnapshot(
+    in context: Context, completion: @escaping @Sendable (WidgetsTimelineEntry) -> Void
+  ) {
+    let groupIdentifier =
+      Bundle.main.object(forInfoDictionaryKey: "ExpoWidgetsAppGroupIdentifier") as? String
+    guard let groupIdentifier else {
+      completion(WidgetsTimelineEntry(date: Date(), name: name, props: nil, entryIndex: nil))
+      return
+    }
+
+    let entries = parseTimeline(identifier: groupIdentifier, name: name, family: context.family)
+    completion(entries.first ?? WidgetsTimelineEntry(date: Date(), name: name, props: nil, entryIndex: nil))
+  }
+
+  public func getTimeline(
+    in context: Context,
+    completion: @escaping @Sendable (Timeline<WidgetsTimelineEntry>) -> Void
+  ) {
+    let groupIdentifier =
+      Bundle.main.object(forInfoDictionaryKey: "ExpoWidgetsAppGroupIdentifier") as? String
+    guard let groupIdentifier else {
+      fatalError("Could not get the app group identifier from Info.plist")
+    }
+
+    let entries = parseTimeline(identifier: groupIdentifier, name: name, family: context.family)
+
+    let timeline = Timeline<WidgetsTimelineEntry>(entries: entries, policy: .atEnd)
+    completion(timeline)
+  }
+
+  public typealias Entry = WidgetsTimelineEntry
+
+  let name: String
+
+  public init(name: String) {
+    self.name = name
+  }
+}

package/ios/Widgets/Widget/Type.swift

@@ -0,0 +1,6 @@
+import WidgetKit
+
+public enum WidgetsKind {
+  case widget
+  case liveActivity
+}