sitepong 0.2.3 → 0.2.4

package/ios/LiveActivity/SitePongLiveActivityModule.swift

@@ -0,0 +1,250 @@
+import ActivityKit
+import ExpoModulesCore
+import Foundation
+import WidgetKit
+
+public class SitePongLiveActivityModule: Module {
+    /// Tasks listening for push-token rotations on each running activity.
+    private var tokenObservers: [String: Task<Void, Never>] = [:]
+    /// activityId → activityType so endActivity / token rotations can resolve type.
+    private var activityTypes: [String: String] = [:]
+
+    public func definition() -> ModuleDefinition {
+        Name("SitePongLiveActivity")
+
+        Events("liveActivityPushTokenUpdate")
+
+        AsyncFunction("areActivitiesEnabled") { () -> Bool in
+            if #available(iOS 16.2, *) {
+                return ActivityAuthorizationInfo().areActivitiesEnabled
+            }
+            return false
+        }
+
+        AsyncFunction("startActivity") { (options: [String: Any], promise: Promise) in
+            guard #available(iOS 16.2, *) else {
+                promise.reject("UNSUPPORTED", "Live Activities require iOS 16.2 or later")
+                return
+            }
+
+            guard ActivityAuthorizationInfo().areActivitiesEnabled else {
+                promise.reject("DISABLED", "Live Activities are disabled by the user")
+                return
+            }
+
+            let activityType = options["activityType"] as? String ?? "default"
+            let attributesDict = options["attributes"] as? [String: Any] ?? [:]
+            let contentStateDict = options["contentState"] as? [String: Any] ?? [:]
+            let alertDict = options["alert"] as? [String: Any]
+
+            do {
+                let attributes = try Self.decode(SitePongActivityAttributes.self, from: attributesDict)
+                let state = try Self.decode(SitePongActivityAttributes.ContentState.self, from: contentStateDict)
+
+                let content = ActivityContent(state: state, staleDate: nil)
+
+                var alertConfig: AlertConfiguration? = nil
+                if let alertDict = alertDict {
+                    let title = alertDict["title"] as? String ?? ""
+                    let body = alertDict["body"] as? String ?? ""
+                    alertConfig = AlertConfiguration(
+                        title: LocalizedStringResource(stringLiteral: title),
+                        body: LocalizedStringResource(stringLiteral: body),
+                        sound: .default
+                    )
+                }
+
+                let activity: Activity<SitePongActivityAttributes>
+                if #available(iOS 16.2, *) {
+                    activity = try Activity.request(
+                        attributes: attributes,
+                        content: content,
+                        pushType: .token
+                    )
+                } else {
+                    promise.reject("UNSUPPORTED", "iOS 16.2 required")
+                    return
+                }
+                _ = alertConfig // alertConfig only applies to update calls in iOS 16.2+
+
+                self.activityTypes[activity.id] = activityType
+                self.observePushToken(for: activity, activityType: activityType)
+
+                // Wait up to 2 seconds for the first push token before resolving.
+                // ActivityKit on the simulator never emits a token, so without this
+                // race the promise would hang the JS caller forever.
+                Task {
+                    let token = await Self.firstPushToken(for: activity, timeoutSeconds: 2)
+                    promise.resolve([
+                        "activityId": activity.id,
+                        "pushToken": token ?? "",
+                    ])
+                }
+            } catch {
+                promise.reject("DECODE_FAILED", "Failed to start activity: \(error.localizedDescription)")
+            }
+        }
+
+        AsyncFunction("updateActivity") { (options: [String: Any], promise: Promise) in
+            guard #available(iOS 16.2, *) else {
+                promise.reject("UNSUPPORTED", "Live Activities require iOS 16.2 or later")
+                return
+            }
+
+            let activityId = options["activityId"] as? String ?? ""
+            let contentStateDict = options["contentState"] as? [String: Any] ?? [:]
+            let alertDict = options["alert"] as? [String: Any]
+
+            guard let activity = Activity<SitePongActivityAttributes>.activities.first(where: { $0.id == activityId }) else {
+                promise.reject("NOT_FOUND", "No running activity with id \(activityId)")
+                return
+            }
+
+            do {
+                let state = try Self.decode(SitePongActivityAttributes.ContentState.self, from: contentStateDict)
+                let content = ActivityContent(state: state, staleDate: nil)
+
+                Task {
+                    if let alertDict = alertDict {
+                        let title = alertDict["title"] as? String ?? ""
+                        let body = alertDict["body"] as? String ?? ""
+                        let alert = AlertConfiguration(
+                            title: LocalizedStringResource(stringLiteral: title),
+                            body: LocalizedStringResource(stringLiteral: body),
+                            sound: .default
+                        )
+                        await activity.update(content, alertConfiguration: alert)
+                    } else {
+                        await activity.update(content)
+                    }
+                    promise.resolve(nil)
+                }
+            } catch {
+                promise.reject("DECODE_FAILED", "Failed to update activity: \(error.localizedDescription)")
+            }
+        }
+
+        // MARK: - Widget DSL functions
+
+        AsyncFunction("syncWidgetConfigs") { (configsJson: String, promise: Promise) in
+            guard let data = configsJson.data(using: .utf8) else {
+                promise.reject("INVALID", "Invalid JSON string")
+                return
+            }
+            WidgetConfigStore.saveConfigs(data)
+            if #available(iOS 14.0, *) {
+                WidgetCenter.shared.reloadAllTimelines()
+            }
+            promise.resolve(nil)
+        }
+
+        AsyncFunction("updateWidgetData") { (dataJson: String, promise: Promise) in
+            guard let data = dataJson.data(using: .utf8) else {
+                promise.reject("INVALID", "Invalid JSON string")
+                return
+            }
+            WidgetConfigStore.saveData(data)
+            if #available(iOS 14.0, *) {
+                WidgetCenter.shared.reloadAllTimelines()
+            }
+            promise.resolve(nil)
+        }
+
+        AsyncFunction("endActivity") { (options: [String: Any], promise: Promise) in
+            guard #available(iOS 16.2, *) else {
+                promise.reject("UNSUPPORTED", "Live Activities require iOS 16.2 or later")
+                return
+            }
+
+            let activityId = options["activityId"] as? String ?? ""
+            let contentStateDict = options["contentState"] as? [String: Any]
+            let dismissalDateMs = options["dismissalDate"] as? Double
+
+            guard let activity = Activity<SitePongActivityAttributes>.activities.first(where: { $0.id == activityId }) else {
+                promise.resolve(nil)
+                return
+            }
+
+            Task {
+                var finalContent: ActivityContent<SitePongActivityAttributes.ContentState>? = nil
+                if let contentStateDict = contentStateDict {
+                    if let state = try? Self.decode(SitePongActivityAttributes.ContentState.self, from: contentStateDict) {
+                        finalContent = ActivityContent(state: state, staleDate: nil)
+                    }
+                }
+
+                let dismissalPolicy: ActivityUIDismissalPolicy
+                if let dismissalDateMs = dismissalDateMs {
+                    let date = Date(timeIntervalSince1970: dismissalDateMs / 1000)
+                    dismissalPolicy = .after(date)
+                } else {
+                    dismissalPolicy = .immediate
+                }
+
+                await activity.end(finalContent, dismissalPolicy: dismissalPolicy)
+
+                self.tokenObservers[activityId]?.cancel()
+                self.tokenObservers.removeValue(forKey: activityId)
+                self.activityTypes.removeValue(forKey: activityId)
+
+                promise.resolve(nil)
+            }
+        }
+    }
+
+    // MARK: - Push token observation
+
+    @available(iOS 16.2, *)
+    private func observePushToken(for activity: Activity<SitePongActivityAttributes>, activityType: String) {
+        // Cancel any prior observer for this id (idempotent)
+        tokenObservers[activity.id]?.cancel()
+
+        let task = Task { [weak self] in
+            for await tokenData in activity.pushTokenUpdates {
+                let hex = tokenData.map { String(format: "%02x", $0) }.joined()
+                self?.sendEvent(
+                    "liveActivityPushTokenUpdate",
+                    [
+                        "activityId": activity.id,
+                        "activityType": activityType,
+                        "pushToken": hex,
+                    ]
+                )
+            }
+        }
+        tokenObservers[activity.id] = task
+    }
+
+    // MARK: - JSON helpers
+
+    private static func decode<T: Decodable>(_ type: T.Type, from dict: [String: Any]) throws -> T {
+        let data = try JSONSerialization.data(withJSONObject: dict, options: [])
+        let decoder = JSONDecoder()
+        return try decoder.decode(type, from: data)
+    }
+
+    /// Race the first emission of `activity.pushTokenUpdates` against a sleep.
+    /// Returns the hex-encoded token, or nil if the timeout fires first
+    /// (the common case on iOS Simulator).
+    @available(iOS 16.2, *)
+    private static func firstPushToken(
+        for activity: Activity<SitePongActivityAttributes>,
+        timeoutSeconds: Double
+    ) async -> String? {
+        await withTaskGroup(of: String?.self) { group in
+            group.addTask {
+                for await tokenData in activity.pushTokenUpdates {
+                    return tokenData.map { String(format: "%02x", $0) }.joined()
+                }
+                return nil
+            }
+            group.addTask {
+                try? await Task.sleep(nanoseconds: UInt64(timeoutSeconds * 1_000_000_000))
+                return nil
+            }
+            let result = await group.next() ?? nil
+            group.cancelAll()
+            return result
+        }
+    }
+}

package/ios/LiveActivity/widget/ColorHex.swift

@@ -0,0 +1,30 @@
+import SwiftUI
+
+extension Color {
+    /// Parse a hex color string like "#3b82f6" or "#3b82f6cc" (RRGGBB or RRGGBBAA).
+    /// Returns nil for malformed input so the widget can fall back to defaults.
+    init?(hex: String?) {
+        guard let raw = hex else { return nil }
+        var s = raw.trimmingCharacters(in: .whitespacesAndNewlines)
+        if s.hasPrefix("#") { s.removeFirst() }
+        guard s.count == 6 || s.count == 8 else { return nil }
+
+        var rgba: UInt64 = 0
+        guard Scanner(string: s).scanHexInt64(&rgba) else { return nil }
+
+        let r, g, b, a: Double
+        if s.count == 8 {
+            r = Double((rgba >> 24) & 0xff) / 255
+            g = Double((rgba >> 16) & 0xff) / 255
+            b = Double((rgba >> 8) & 0xff) / 255
+            a = Double(rgba & 0xff) / 255
+        } else {
+            r = Double((rgba >> 16) & 0xff) / 255
+            g = Double((rgba >> 8) & 0xff) / 255
+            b = Double(rgba & 0xff) / 255
+            a = 1
+        }
+
+        self.init(.sRGB, red: r, green: g, blue: b, opacity: a)
+    }
+}

package/ios/LiveActivity/widget/DSLAnimations.swift

@@ -0,0 +1,128 @@
+import SwiftUI
+import WidgetKit
+
+// MARK: - Animation view modifier
+
+@available(iOS 16.2, *)
+struct DSLAnimationModifier: ViewModifier {
+    let animation: DSLAnimation?
+
+    func body(content: Content) -> some View {
+        var view = AnyView(content)
+
+        // Entrance transitions — in WidgetKit these only apply as content
+        // transitions between timeline entries. Full animations work in
+        // Live Activities.
+        if let entrance = animation?.entrance {
+            let transition = entranceTransition(entrance)
+            view = AnyView(view.transition(transition))
+        }
+
+        // Value transition — animate numeric content changes
+        if let valueTransition = animation?.valueTransition {
+            let anim = valueAnimation(valueTransition)
+            view = AnyView(view.animation(anim, value: 0))
+        }
+
+        return view
+    }
+
+    private func entranceTransition(_ type: String) -> AnyTransition {
+        switch type {
+        case "fadeIn":
+            return .opacity
+        case "slideUp":
+            return .move(edge: .bottom).combined(with: .opacity)
+        case "slideLeft":
+            return .move(edge: .trailing).combined(with: .opacity)
+        case "scaleIn":
+            return .scale.combined(with: .opacity)
+        default:
+            return .opacity
+        }
+    }
+
+    private func valueAnimation(_ type: String) -> Animation {
+        let duration = animation?.entranceDuration ?? 0.3
+        switch type {
+        case "spring":
+            return .spring(response: 0.5, dampingFraction: 0.7)
+        case "easeIn":
+            return .easeIn(duration: duration)
+        case "easeOut":
+            return .easeOut(duration: duration)
+        case "linear":
+            return .linear(duration: duration)
+        default:
+            return .easeInOut(duration: duration)
+        }
+    }
+}
+
+// MARK: - Ambient animation modifier
+// Note: Ambient animations (pulse, shimmer, glow) only work in Live Activities,
+// not in static Home Screen widgets where WidgetKit controls the timeline.
+
+@available(iOS 16.2, *)
+struct DSLAmbientModifier: ViewModifier {
+    let ambient: String?
+    let ambientDuration: Double?
+    @State private var isAnimating = false
+
+    func body(content: Content) -> some View {
+        guard let ambient = ambient else {
+            return AnyView(content)
+        }
+
+        let duration = ambientDuration ?? 2.0
+
+        switch ambient {
+        case "pulse":
+            return AnyView(
+                content
+                    .opacity(isAnimating ? 0.6 : 1.0)
+                    .onAppear {
+                        withAnimation(.easeInOut(duration: duration).repeatForever(autoreverses: true)) {
+                            isAnimating = true
+                        }
+                    }
+            )
+        case "shimmer":
+            return AnyView(
+                content
+                    .opacity(isAnimating ? 0.8 : 1.0)
+                    .onAppear {
+                        withAnimation(.easeInOut(duration: duration).repeatForever(autoreverses: true)) {
+                            isAnimating = true
+                        }
+                    }
+            )
+        case "glow":
+            return AnyView(
+                content
+                    .shadow(
+                        color: .white.opacity(isAnimating ? 0.4 : 0.0),
+                        radius: isAnimating ? 8 : 2
+                    )
+                    .onAppear {
+                        withAnimation(.easeInOut(duration: duration).repeatForever(autoreverses: true)) {
+                            isAnimating = true
+                        }
+                    }
+            )
+        default:
+            return AnyView(content)
+        }
+    }
+}
+
+// MARK: - View extension
+
+@available(iOS 16.2, *)
+extension View {
+    func applyAnimation(_ animation: DSLAnimation?) -> some View {
+        self
+            .modifier(DSLAnimationModifier(animation: animation))
+            .modifier(DSLAmbientModifier(ambient: animation?.ambient, ambientDuration: animation?.ambientDuration))
+    }
+}