sitepong 0.2.3 → 0.2.5

package/ios/LiveActivity/widget/SitePongLiveActivityWidget.swift

@@ -0,0 +1,393 @@
+import ActivityKit
+import SwiftUI
+import WidgetKit
+
+// MARK: - Widget bundle entry point
+
+@available(iOS 17.0, *)
+@main
+struct SitePongLiveActivityBundle: WidgetBundle {
+    var body: some Widget {
+        SitePongLiveActivityWidget()
+        SitePongHomeWidget()
+    }
+}
+
+// MARK: - Widget definition
+
+@available(iOS 16.2, *)
+struct SitePongLiveActivityWidget: Widget {
+    var body: some WidgetConfiguration {
+        ActivityConfiguration(for: SitePongActivityAttributes.self) { context in
+            // Lock screen / banner presentation
+            LockScreenView(state: context.state, attributes: context.attributes)
+                .activityBackgroundTint(
+                    context.state.backgroundColor.flatMap(Color.init(hex:))
+                )
+                .activitySystemActionForegroundColor(.primary)
+        } dynamicIsland: { context in
+            DynamicIsland {
+                DynamicIslandExpandedRegion(.leading) {
+                    if let icon = context.state.leadingIcon {
+                        IconView(spec: icon, defaultSize: 22)
+                    }
+                }
+                DynamicIslandExpandedRegion(.trailing) {
+                    if let icon = context.state.trailingIcon {
+                        IconView(spec: icon, defaultSize: 22)
+                    }
+                }
+                DynamicIslandExpandedRegion(.center) {
+                    VStack(alignment: .leading, spacing: 2) {
+                        if let title = context.state.title {
+                            StyledText(text: title, style: context.state.titleStyle, defaultSize: 15, defaultWeight: .semibold)
+                        }
+                        if let subtitle = context.state.subtitle {
+                            StyledText(text: subtitle, style: context.state.subtitleStyle, defaultSize: 13, defaultWeight: .regular, defaultColor: .secondary)
+                        }
+                    }
+                }
+                DynamicIslandExpandedRegion(.bottom) {
+                    if let progress = context.state.progress {
+                        ProgressSection(spec: progress)
+                    }
+                }
+            } compactLeading: {
+                CompactSlot(slot: context.state.dynamicIsland?.compactLeading, fallbackIcon: context.state.leadingIcon)
+            } compactTrailing: {
+                CompactSlot(slot: context.state.dynamicIsland?.compactTrailing, fallbackIcon: context.state.trailingIcon)
+            } minimal: {
+                if let icon = context.state.dynamicIsland?.minimal ?? context.state.leadingIcon {
+                    IconView(spec: icon, defaultSize: 16)
+                }
+            }
+        }
+    }
+}
+
+// MARK: - Lock screen layout
+
+@available(iOS 16.2, *)
+struct LockScreenView: View {
+    let state: SitePongActivityAttributes.ContentState
+    let attributes: SitePongActivityAttributes
+
+    var body: some View {
+        if let dslLayout = state.dslLayout {
+            // DSL-driven layout
+            DSLView(node: dslLayout, data: [:])
+                .padding(16)
+        } else {
+            // Fixed slot-based layout (backward compatible)
+            fixedLayout
+        }
+    }
+
+    @ViewBuilder
+    private var fixedLayout: some View {
+        VStack(alignment: .leading, spacing: 12) {
+            HStack(alignment: .center, spacing: 12) {
+                if let icon = state.leadingIcon {
+                    IconView(spec: icon, defaultSize: 28)
+                }
+
+                VStack(alignment: .leading, spacing: 2) {
+                    if let title = state.title {
+                        StyledText(
+                            text: title,
+                            style: state.titleStyle,
+                            defaultSize: 16,
+                            defaultWeight: .semibold
+                        )
+                    }
+                    if let subtitle = state.subtitle {
+                        StyledText(
+                            text: subtitle,
+                            style: state.subtitleStyle,
+                            defaultSize: 14,
+                            defaultWeight: .regular,
+                            defaultColor: .secondary
+                        )
+                    }
+                }
+
+                Spacer(minLength: 0)
+
+                if let icon = state.trailingIcon {
+                    IconView(spec: icon, defaultSize: 28)
+                }
+            }
+
+            if let progress = state.progress {
+                ProgressSection(spec: progress)
+            }
+        }
+        .padding(16)
+    }
+}
+
+// MARK: - Compact Dynamic Island slots
+
+@available(iOS 16.2, *)
+struct CompactSlot: View {
+    let slot: DynamicIslandSlot?
+    let fallbackIcon: IconSpec?
+
+    var body: some View {
+        if let slot = slot {
+            if let icon = slot.icon {
+                IconView(spec: icon, defaultSize: 16)
+            } else if let text = slot.text {
+                StyledText(text: text, style: slot.style, defaultSize: 13, defaultWeight: .medium)
+            } else {
+                EmptyView()
+            }
+        } else if let icon = fallbackIcon {
+            IconView(spec: icon, defaultSize: 16)
+        } else {
+            EmptyView()
+        }
+    }
+}
+
+// MARK: - Progress section
+
+@available(iOS 16.2, *)
+struct ProgressSection: View {
+    let spec: ProgressSpec
+
+    var body: some View {
+        switch spec.style {
+        case "bar":
+            FlatBar(spec: spec)
+        case "bar-with-icon":
+            BarWithIcon(spec: spec)
+        case "circular":
+            CircularRing(spec: spec)
+        case "timer":
+            TimerSection(spec: spec)
+        default:
+            FlatBar(spec: spec)
+        }
+    }
+}
+
+@available(iOS 16.2, *)
+struct FlatBar: View {
+    let spec: ProgressSpec
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 4) {
+            if let label = spec.label {
+                StyledText(
+                    text: label,
+                    style: spec.labelStyle,
+                    defaultSize: 12,
+                    defaultWeight: .regular,
+                    defaultColor: .secondary
+                )
+            }
+
+            GeometryReader { geo in
+                ZStack(alignment: .leading) {
+                    Capsule()
+                        .fill(Color(hex: spec.trackColor) ?? Color.secondary.opacity(0.2))
+                    Capsule()
+                        .fill(Color(hex: spec.fillColor) ?? Color.accentColor)
+                        .frame(width: geo.size.width * clampedValue)
+                }
+            }
+            .frame(height: 6)
+        }
+    }
+
+    private var clampedValue: Double {
+        max(0, min(1, spec.value ?? 0))
+    }
+}
+
+@available(iOS 16.2, *)
+struct BarWithIcon: View {
+    let spec: ProgressSpec
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 6) {
+            if let label = spec.label {
+                StyledText(
+                    text: label,
+                    style: spec.labelStyle,
+                    defaultSize: 12,
+                    defaultWeight: .regular,
+                    defaultColor: .secondary
+                )
+            }
+
+            GeometryReader { geo in
+                let trackHeight: CGFloat = 6
+                let iconSize: CGFloat = 22
+                let usable = max(0, geo.size.width - iconSize)
+                let xOffset = usable * clampedValue
+
+                ZStack(alignment: .leading) {
+                    Capsule()
+                        .fill(Color(hex: spec.trackColor) ?? Color.secondary.opacity(0.2))
+                        .frame(height: trackHeight)
+                        .padding(.horizontal, iconSize / 2)
+
+                    Capsule()
+                        .fill(Color(hex: spec.fillColor) ?? Color.accentColor)
+                        .frame(width: max(trackHeight, xOffset + trackHeight), height: trackHeight)
+                        .padding(.leading, iconSize / 2)
+
+                    if let symbol = spec.icon {
+                        Image(systemName: symbol)
+                            .font(.system(size: iconSize - 4, weight: symbolWeight(spec.iconWeight)))
+                            .foregroundStyle(Color(hex: spec.iconColor) ?? Color.accentColor)
+                            .frame(width: iconSize, height: iconSize)
+                            .offset(x: xOffset)
+                    }
+                }
+                .frame(height: max(iconSize, trackHeight))
+            }
+            .frame(height: 24)
+        }
+    }
+
+    private var clampedValue: Double {
+        max(0, min(1, spec.value ?? 0))
+    }
+}
+
+@available(iOS 16.2, *)
+struct CircularRing: View {
+    let spec: ProgressSpec
+
+    var body: some View {
+        ZStack {
+            Circle()
+                .stroke(
+                    Color(hex: spec.trackColor) ?? Color.secondary.opacity(0.2),
+                    lineWidth: 5
+                )
+            Circle()
+                .trim(from: 0, to: clampedValue)
+                .stroke(
+                    Color(hex: spec.fillColor) ?? Color.accentColor,
+                    style: StrokeStyle(lineWidth: 5, lineCap: .round)
+                )
+                .rotationEffect(.degrees(-90))
+
+            if let symbol = spec.icon {
+                Image(systemName: symbol)
+                    .font(.system(size: 14, weight: .semibold))
+                    .foregroundStyle(Color(hex: spec.iconColor) ?? Color.accentColor)
+            }
+        }
+        .frame(width: 38, height: 38)
+    }
+
+    private var clampedValue: Double {
+        max(0, min(1, spec.value ?? 0))
+    }
+}
+
+@available(iOS 16.2, *)
+struct TimerSection: View {
+    let spec: ProgressSpec
+
+    var body: some View {
+        if let endDateMs = spec.endDate {
+            let end = Date(timeIntervalSince1970: endDateMs / 1000)
+            ProgressView(
+                timerInterval: Date()...end,
+                countsDown: true
+            ) {
+                EmptyView()
+            }
+            .progressViewStyle(.linear)
+            .tint(Color(hex: spec.fillColor) ?? Color.accentColor)
+        } else if let startDateMs = spec.startDate {
+            let start = Date(timeIntervalSince1970: startDateMs / 1000)
+            // Open-ended elapsed timer; use one hour as a default ceiling.
+            let endCap = start.addingTimeInterval(60 * 60)
+            ProgressView(
+                timerInterval: start...endCap,
+                countsDown: false
+            ) {
+                EmptyView()
+            }
+            .progressViewStyle(.linear)
+            .tint(Color(hex: spec.fillColor) ?? Color.accentColor)
+        } else {
+            EmptyView()
+        }
+    }
+}
+
+// MARK: - Reusable styled views
+
+@available(iOS 16.2, *)
+struct StyledText: View {
+    let text: String
+    let style: TextStyleSpec?
+    let defaultSize: Double
+    let defaultWeight: Font.Weight
+    var defaultColor: Color = .primary
+
+    var body: some View {
+        let size = style?.size ?? defaultSize
+        let weight = textWeight(style?.weight) ?? defaultWeight
+        let color = style?.color.flatMap(Color.init(hex:)) ?? defaultColor
+        let italic = style?.italic ?? false
+        let monoDigit = style?.monospacedDigit ?? false
+
+        var font = Font.system(size: size, weight: weight)
+        if monoDigit {
+            font = font.monospacedDigit()
+        }
+
+        return Text(text)
+            .font(font)
+            .italic(italic)
+            .foregroundStyle(color)
+            .lineLimit(1)
+    }
+}
+
+@available(iOS 16.2, *)
+struct IconView: View {
+    let spec: IconSpec
+    let defaultSize: Double
+
+    var body: some View {
+        let size = spec.size ?? defaultSize
+        let weight = symbolWeight(spec.weight)
+        let color = spec.color.flatMap(Color.init(hex:)) ?? .primary
+
+        Image(systemName: spec.symbol)
+            .font(.system(size: size, weight: weight))
+            .foregroundStyle(color)
+    }
+}
+
+// MARK: - Style helpers
+
+func symbolWeight(_ name: String?) -> Font.Weight {
+    switch name {
+    case "ultraLight": return .ultraLight
+    case "thin": return .thin
+    case "light": return .light
+    case "regular": return .regular
+    case "medium": return .medium
+    case "semibold": return .semibold
+    case "bold": return .bold
+    case "heavy": return .heavy
+    case "black": return .black
+    default: return .regular
+    }
+}
+
+func textWeight(_ name: String?) -> Font.Weight? {
+    guard let name = name else { return nil }
+    return symbolWeight(name)
+}

package/ios/LiveActivity/widget/SitePongWidgetBundle.swift

@@ -0,0 +1,84 @@
+import SwiftUI
+import WidgetKit
+
+// MARK: - Timeline Entry
+
+@available(iOS 16.2, *)
+struct SitePongWidgetEntry: TimelineEntry {
+    let date: Date
+    let rootNode: DSLNode?
+    let data: [String: AnyCodable]
+}
+
+// MARK: - Timeline Provider
+
+@available(iOS 16.2, *)
+struct SitePongTimelineProvider: TimelineProvider {
+    func placeholder(in context: Context) -> SitePongWidgetEntry {
+        SitePongWidgetEntry(date: Date(), rootNode: nil, data: [:])
+    }
+
+    func getSnapshot(in context: Context, completion: @escaping (SitePongWidgetEntry) -> Void) {
+        let configs = WidgetConfigStore.loadConfigs()
+        let data = WidgetConfigStore.loadData()
+        let entry = SitePongWidgetEntry(
+            date: Date(),
+            rootNode: configs?.first,
+            data: data
+        )
+        completion(entry)
+    }
+
+    func getTimeline(in context: Context, completion: @escaping (Timeline<SitePongWidgetEntry>) -> Void) {
+        let configs = WidgetConfigStore.loadConfigs()
+        let data = WidgetConfigStore.loadData()
+        let entry = SitePongWidgetEntry(
+            date: Date(),
+            rootNode: configs?.first,
+            data: data
+        )
+        // Refresh every 30 minutes; the app can also trigger reloads via WidgetCenter
+        let nextUpdate = Calendar.current.date(byAdding: .minute, value: 30, to: Date()) ?? Date()
+        let timeline = Timeline(entries: [entry], policy: .after(nextUpdate))
+        completion(timeline)
+    }
+}
+
+// MARK: - Widget View
+
+@available(iOS 16.2, *)
+struct SitePongHomeWidgetView: View {
+    let entry: SitePongWidgetEntry
+
+    var body: some View {
+        if let rootNode = entry.rootNode {
+            DSLView(node: rootNode, data: entry.data)
+        } else {
+            VStack(spacing: 4) {
+                Image(systemName: "square.grid.2x2")
+                    .font(.system(size: 24, weight: .light))
+                    .foregroundStyle(.secondary)
+                Text("Configure in app")
+                    .font(.system(size: 12))
+                    .foregroundStyle(.secondary)
+            }
+        }
+    }
+}
+
+// MARK: - Widget Definition
+
+@available(iOS 17.0, *)
+struct SitePongHomeWidget: Widget {
+    let kind: String = "SitePongHomeWidget"
+
+    var body: some WidgetConfiguration {
+        StaticConfiguration(kind: kind, provider: SitePongTimelineProvider()) { entry in
+            SitePongHomeWidgetView(entry: entry)
+                .containerBackground(.fill.tertiary, for: .widget)
+        }
+        .configurationDisplayName("SitePong")
+        .description("Display custom widgets powered by SitePong.")
+        .supportedFamilies([.systemSmall, .systemMedium, .systemLarge])
+    }
+}

package/ios/ScreenRecorder/ChunkUploader.swift

@@ -0,0 +1,52 @@
+import Foundation
+
+class ChunkUploader {
+  private let endpoint: String
+  private let apiKey: String
+  private let sessionId: String
+  private var chunkSequence: Int = 0
+
+  init(endpoint: String, apiKey: String, sessionId: String) {
+    self.endpoint = endpoint
+    self.apiKey = apiKey
+    self.sessionId = sessionId
+  }
+
+  /// Upload the given H.264 data to the ingest server.
+  /// Called with data drained from the encoder's rolling buffer on flush.
+  func uploadData(_ data: Data) async throws {
+    guard !data.isEmpty else { return }
+
+    let seq = chunkSequence
+    chunkSequence += 1
+
+    let url = URL(string: "\(endpoint)/api/replays/video")!
+    var request = URLRequest(url: url)
+    request.httpMethod = "POST"
+    request.setValue("application/octet-stream", forHTTPHeaderField: "Content-Type")
+    request.setValue(apiKey, forHTTPHeaderField: "X-API-Key")
+    request.setValue(sessionId, forHTTPHeaderField: "X-Session-ID")
+    request.setValue(String(seq), forHTTPHeaderField: "X-Chunk-Sequence")
+    request.setValue("error", forHTTPHeaderField: "X-Trigger")
+    request.httpBody = data
+    request.timeoutInterval = 10
+
+    do {
+      let (_, response) = try await URLSession.shared.data(for: request)
+      if let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode >= 400 {
+        print("[SitePong ScreenRecorder] Upload failed with status \(httpResponse.statusCode)")
+      }
+    } catch {
+      // Retry once
+      do {
+        let (_, response) = try await URLSession.shared.data(for: request)
+        if let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode >= 400 {
+          print("[SitePong ScreenRecorder] Upload retry failed with status \(httpResponse.statusCode)")
+        }
+      } catch {
+        print("[SitePong ScreenRecorder] Upload retry failed: \(error.localizedDescription)")
+        // Drop the chunk — don't block recording
+      }
+    }
+  }
+}