SPB Git

Repository Public

ProjectSession.swift 24.7 KB 559 lines swift

1// SP Lecture Studio2// File: Apps/LectureStudio/Shared/Workspace/ProjectSession.swift3// Description: Live state of one open lecture: pages, vector ink with undo/redo, tools, viewport, recording engine, camera, banners, checkpoints.4//5// Author: Simon-Pierre Boucher6// Contact: contact@spboucher.ai7import Foundation8import Observation9import SwiftUI10import AVFoundation11import LectureCore12import LectureStorage13import LecturePDF14import LectureCapture15import LectureTranscription16#if os(iOS)17import UIKit18#endif1920enum ToolKind: String, CaseIterable, Identifiable {21    case pen, marker, pencil, eraser, line, arrow, rectangle, ellipse, laser, pan22    var id: String { rawValue }23    var symbol: String {24        switch self {25        case .pen: "pencil.tip"; case .marker: "highlighter"; case .pencil: "pencil"; case .eraser: "eraser"26        case .line: "line.diagonal"; case .arrow: "arrow.up.right"; case .rectangle: "rectangle"; case .ellipse: "circle"27        case .laser: "dot.radiowaves.left.and.right"; case .pan: "hand.draw"28        }29    }30    var title: LocalizedStringKey {31        switch self {32        case .pen: "Stylo"; case .marker: "Surligneur"; case .pencil: "Crayon"; case .eraser: "Gomme"33        case .line: "Ligne"; case .arrow: "Flèche"; case .rectangle: "Rectangle"; case .ellipse: "Ellipse"34        case .laser: "Pointeur laser"; case .pan: "Déplacer"35        }36    }37    var inkTool: InkTool? {38        switch self {39        case .pen: .pen; case .marker: .marker; case .pencil: .pencil; case .line: .line; case .arrow: .arrow40        case .rectangle: .rectangle; case .ellipse: .ellipse; default: nil41        }42    }43}4445struct ToolState: Equatable {46    var kind: ToolKind = .pen47    var color: RGBAColor = .red48    /// Thickness step 0…4.49    var thickness = 150    static let steps: [Double] = [0.0018, 0.0032, 0.0052, 0.008, 0.012]5152    /// Nominal stroke width normalized to the page width.53    var width: Double { Self.steps[min(4, max(0, thickness))] * (kind == .marker ? 5 : kind == .pencil ? 0.8 : 1) }54    var strokeColor: RGBAColor {55        var c = color56        if kind == .marker { c.a = 0.38 } else if kind == .pencil { c.a = 0.85 }57        return c58    }59}6061enum SessionBanner: Equatable, Identifiable {62    case suggestPause63    case countdown(AutoPolicyKind)64    case warning(String)65    case interrupted66    case info(String)67    var id: String {68        switch self {69        case .suggestPause: "suggest"; case .countdown(let k): "countdown-\(k.rawValue)"; case .warning(let w): "warn-\(w)"70        case .interrupted: "interrupted"; case .info(let i): "info-\(i)"71        }72    }73}7475enum StartOutcome { case started, needsMicrophoneDecision, failed(String) }7677private enum InkOp { case added([Stroke]); case removed([Stroke]) }7879@MainActor @Observable80final class ProjectSession: Identifiable {81    nonisolated let id: UUID82    let settings: AppSettings83    private(set) var package: ProjectPackage84    private(set) var manifest: ProjectManifest85    let document: SlideDocument86    @ObservationIgnored private let log: EventLogWriter87    @ObservationIgnored private var engine: RecordingEngine88    @ObservationIgnored var onManifestChanged: () -> Void = {}8990    // Presentation91    private(set) var page: Int92    /// Visible strokes per page, in drawing order (the final state of the event stream, kept live).93    private(set) var strokes: [Int: [Stroke]] = [:]94    /// Incremented whenever ink changes from outside a canvas (undo, clear, page change) so canvases redraw / reload.95    private(set) var inkRevision = 096    var tool = ToolState()97    private(set) var viewport = Viewport.fit98    private(set) var pointer: CGPoint?99    private(set) var canUndo = false100    private(set) var canRedo = false101    @ObservationIgnored private var undoStack: [InkOp] = []102    @ObservationIgnored private var redoStack: [InkOp] = []103    @ObservationIgnored private var lastPointerSent = Date.distantPast104    @ObservationIgnored private var lastViewportSent = Date.distantPast105    @ObservationIgnored private var thumbnailCache: [Int: CGImage] = [:]106    private(set) var thumbnailRevision = 0107108    // Recording109    private(set) var recState: RecordingState = .idle110    private(set) var elapsed: MediaTime = .zero111    private(set) var position: MediaTime112    var levelDB: Double = -120113    var peak: Float = 0114    private(set) var hasAudio = true115    var banner: SessionBanner?116    private(set) var countdownRemaining: Int = 0117    private(set) var freeBytes: Int64 = 0118    private(set) var markerCount = 0119    var cameraOn = false120    private(set) var cameraAvailable = false121    @ObservationIgnored let camera = CameraRecorder()122    @ObservationIgnored private var spotter: LivePhraseSpotter?123    @ObservationIgnored private var timer: Timer?124    @ObservationIgnored private var activity: NSObjectProtocol?125    /// Set when the project was repaired after an interrupted recording; shown once to the user.126    /// True while a sheet, alert or dialog is shown: the system ink palette is hidden so that it never floats over it.127    var workspaceOverlayActive = false128    var chromeOverlayActive = false129    var paletteSuppressed: Bool { workspaceOverlayActive || chromeOverlayActive }130    var recoveryReport: RecoveryReport?131    var skippedEventLines = 0132133    init(package: ProjectPackage, settings: AppSettings) throws {134        self.settings = settings135        var pkg = package136        var m = try pkg.loadManifest()137        if ProjectRecovery.needsRecovery(pkg, manifest: m) {138            let result = try ProjectRecovery.recover(pkg)139            m = result.manifest140            if result.report.didChange || !result.report.unreadableFiles.isEmpty { recoveryReport = result.report }141        }142        guard m.pdf != nil, FileManager.default.fileExists(atPath: pkg.pdfURL.path) else { throw StorageError.pdfMissing }143        document = try SlideDocument(url: pkg.pdfURL)144        pkg = ProjectPackage(url: pkg.url)145        self.package = pkg; manifest = m; id = m.id146        page = min(max(0, m.lastPage), document.pageCount - 1)147        position = m.duration148        log = try EventLogWriter(url: pkg.eventsURL)149        engine = RecordingEngine(package: pkg, manifest: m, log: log, audio: nil)150        let parsed = pkg.loadEvents()151        skippedEventLines = parsed.skippedLines152        let index = TimelineIndex(events: parsed.events)153        for p in index.annotatedPages { strokes[p] = index.finalStrokes(page: p) }154        markerCount = index.markers.count155        freeBytes = ProjectPackage.freeDiskSpace(at: pkg.url)156        cameraAvailable = !CameraRecorder.devices().isEmpty157    }158159    func close() { timer?.invalidate(); timer = nil; camera.stopPreview(); log.flush() }160161    var title: String { manifest.title }162    var duration: MediaTime { manifest.duration }163    var pageCount: Int { document.pageCount }164    var isRecordingOrPaused: Bool { recState != .idle }165166    func updateManifest(_ change: (inout ProjectManifest) -> Void) {167        guard recState == .idle else { return }168        change(&manifest)169        try? package.saveManifest(manifest)170        engine = RecordingEngine(package: package, manifest: manifest, log: log, audio: nil)171        onManifestChanged()172    }173174    /// Reloads the manifest after another component (export, editor) changed it on disk.175    func reloadManifest() {176        guard recState == .idle, let m = try? package.loadManifest() else { return }177        manifest = m; position = m.duration178        engine = RecordingEngine(package: package, manifest: m, log: log, audio: nil)179    }180181    // MARK: Pages182183    func go(to newPage: Int) {184        let p = min(max(0, newPage), pageCount - 1)185        guard p != page else { return }186        page = p; pointer = nil187        if recState != .idle { engine.record(.page(index: p)) } else { manifest.lastPage = p; saveSoon() }188        if !viewport.isFit { applyViewport(.fit, force: true) }189        inkRevision += 1190    }191    func nextPage() { go(to: page + 1) }192    func previousPage() { go(to: page - 1) }193194    @ObservationIgnored private var savePending = false195    private func saveSoon() {196        guard !savePending else { return }197        savePending = true198        DispatchQueue.main.asyncAfter(deadline: .now() + 1) { [weak self] in199            guard let self else { return }200            self.savePending = false201            if self.recState == .idle { try? self.package.saveManifest(self.manifest) }202        }203    }204205    var note: String {206        get { manifest.notes[page] ?? "" }207        set {208            if newValue.isEmpty { manifest.notes.removeValue(forKey: page) } else { manifest.notes[page] = newValue }209            saveSoon()210        }211    }212213    func thumbnail(_ index: Int) -> CGImage? {214        if let img = thumbnailCache[index] { return img }215        let doc = document216        Task.detached(priority: .utility) { [weak self] in217            let img = doc.thumbnail(page: index, maxDimension: 320)218            await MainActor.run { [weak self] in219                guard let self, let img else { return }220                self.thumbnailCache[index] = img; self.thumbnailRevision += 1221            }222        }223        return nil224    }225226    // MARK: Ink227228    func strokes(on p: Int) -> [Stroke] { strokes[p] ?? [] }229    var currentStrokes: [Stroke] { strokes[page] ?? [] }230231    /// Timeline time to stamp a stroke that begins now.232    func strokeBeginTime() -> MediaTime { engine.position }233    var isTimelineRunning: Bool { recState == .recording }234235    /// A canvas finished a stroke.236    func add(_ stroke: Stroke) {237        strokes[stroke.page, default: []].append(stroke)238        engine.record(.strokeAdded(stroke))239        push(.added([stroke]))240    }241242    /// Stroke eraser / lasso delete: the strokes disappear from now on (they stay in the event log).243    func remove(ids: [UUID], on p: Int? = nil) {244        let target = p ?? page245        let removed = (strokes[target] ?? []).filter { ids.contains($0.id) }246        guard !removed.isEmpty else { return }247        strokes[target]?.removeAll { ids.contains($0.id) }248        engine.record(.strokesRemoved(ids: removed.map(\.id)))249        push(.removed(removed))250    }251252    /// PencilKit reported a change: `added` are new strokes, `removed` disappeared, `restored` came back (undo of an erase).253    func applyCanvasDiff(added: [Stroke], removed: [UUID], restored: [Stroke]) {254        for s in added { strokes[s.page, default: []].append(s); engine.record(.strokeAdded(s)) }255        if !removed.isEmpty {256            for p in strokes.keys { strokes[p]?.removeAll { removed.contains($0.id) } }257            engine.record(.strokesRemoved(ids: removed))258        }259        if !restored.isEmpty {260            for s in restored { strokes[s.page, default: []].append(s) }261            engine.record(.strokesRestored(ids: restored.map(\.id)))262        }263    }264265    func clearPage() {266        let all = currentStrokes267        guard !all.isEmpty else { return }268        strokes[page] = []269        engine.record(.strokesRemoved(ids: all.map(\.id)))270        push(.removed(all)); inkRevision += 1271    }272273    private func push(_ op: InkOp) {274        undoStack.append(op); if undoStack.count > 500 { undoStack.removeFirst() }275        redoStack.removeAll(); canUndo = true; canRedo = false276    }277278    /// On iPadOS / iOS the PencilKit canvas owns undo (it also covers lasso moves); it installs these hooks.279    @ObservationIgnored var canvasUndo: (() -> Void)?280    @ObservationIgnored var canvasRedo: (() -> Void)?281    func setCanvasUndoState(canUndo u: Bool, canRedo r: Bool) { if canvasUndo != nil { canUndo = u; canRedo = r } }282    func performUndo() { if let canvasUndo { canvasUndo() } else { undo() } }283    func performRedo() { if let canvasRedo { canvasRedo() } else { redo() } }284285    func undo() {286        guard let op = undoStack.popLast() else { return }287        apply(inverse: op); redoStack.append(op)288        canUndo = !undoStack.isEmpty; canRedo = true; inkRevision += 1289    }290    func redo() {291        guard let op = redoStack.popLast() else { return }292        apply(forward: op); undoStack.append(op)293        canUndo = true; canRedo = !redoStack.isEmpty; inkRevision += 1294    }295    private func apply(inverse op: InkOp) {296        switch op {297        case .added(let list): hide(list)298        case .removed(let list): show(list)299        }300    }301    private func apply(forward op: InkOp) {302        switch op {303        case .added(let list): show(list)304        case .removed(let list): hide(list)305        }306    }307    private func hide(_ list: [Stroke]) {308        let ids = Set(list.map(\.id))309        for p in Set(list.map(\.page)) { strokes[p]?.removeAll { ids.contains($0.id) } }310        engine.record(.strokesRemoved(ids: list.map(\.id)))311    }312    private func show(_ list: [Stroke]) {313        for s in list { strokes[s.page, default: []].append(s) }314        engine.record(.strokesRestored(ids: list.map(\.id)))315    }316317    // MARK: Pointer and viewport318319    func movePointer(x: Double, y: Double) {320        pointer = CGPoint(x: x, y: y)321        guard recState == .recording, Date().timeIntervalSince(lastPointerSent) >= 1.0 / 30 else { return }322        lastPointerSent = Date()323        engine.record(.pointer(x: (x * 10_000).rounded() / 10_000, y: (y * 10_000).rounded() / 10_000))324    }325    func hidePointer() {326        guard pointer != nil else { return }327        pointer = nil328        if recState == .recording { engine.record(.pointerHidden) }329    }330331    func applyViewport(_ v: Viewport, force: Bool = false) {332        var nv = v; nv.zoom = min(8, max(1, v.zoom)); nv.cx = min(1, max(0, v.cx)); nv.cy = min(1, max(0, v.cy))333        if nv.isFit { nv = .fit }334        guard nv != viewport else { return }335        viewport = nv336        guard recState == .recording, force || Date().timeIntervalSince(lastViewportSent) >= 0.1 else { return }337        lastViewportSent = Date()338        engine.record(.viewport(Viewport(zoom: (nv.zoom * 1000).rounded() / 1000, cx: (nv.cx * 10_000).rounded() / 10_000, cy: (nv.cy * 10_000).rounded() / 10_000)))339    }340    /// Called when a zoom / pan gesture ends so that the final position is always recorded.341    func commitViewport() {342        guard recState == .recording else { return }343        lastViewportSent = Date()344        engine.record(.viewport(viewport))345    }346347    // MARK: Recording348349    func addMarker(_ kind: MarkerKind, label: String = "") {350        engine.record(.marker(Marker(kind: kind, label: label)))351        markerCount += 1352        #if os(iOS)353        UIImpactFeedbackGenerator(style: .light).impactOccurred()354        #endif355    }356357    /// Starts a recording. The microphone permission is requested here, just in time.358    /// When it is denied the caller asks the user whether to continue without sound (`withoutAudio: true`).359    func startRecording(withoutAudio: Bool = false) async -> StartOutcome {360        guard recState == .idle else { return .started }361        var source: MicrophoneSource?362        if !withoutAudio {363            let permission = await CapturePermissions.request(.audio)364            guard permission == .granted else { return .needsMicrophoneDecision }365            let mic = MicrophoneSource()366            mic.preferredDeviceID = settings.stored.microphoneID367            mic.voiceProcessing = settings.stored.voiceProcessing368            source = mic369        }370        var cfg = RecordingConfiguration()371        cfg.segmentSeconds = settings.stored.segmentSeconds; cfg.policy = settings.stored.policy372        let fresh = RecordingEngine(package: package, manifest: manifest, log: log, audio: source, configuration: cfg)373        wire(fresh)374        do { try fresh.start(currentPage: page) } catch {375            return .failed((error as? AudioSourceError)?.description ?? error.localizedDescription)376        }377        engine = fresh378        recState = fresh.state379        hasAudio = source != nil380        if !viewport.isFit { engine.record(.viewport(viewport), interaction: false) }381        startCameraIfNeeded()382        startSpotterIfNeeded(fresh)383        keepAwake(true)384        startTimer()385        banner = nil386        return .started387    }388389    private func wire(_ e: RecordingEngine) {390        e.callbacks.stateChanged = { [weak self] s in self?.stateChanged(s) }391        e.callbacks.level = { [weak self] db, pk in self?.levelDB = db; self?.peak = pk }392        e.callbacks.auto = { [weak self] out in self?.handle(auto: out) }393        e.callbacks.warning = { [weak self] w in self?.handle(warning: w) }394        e.callbacks.sourceEvent = { [weak self] ev in395            guard let self else { return }396            switch ev {397            case .interruptionBegan, .failed: self.banner = .interrupted398            case .routeChanged(let d): self.banner = .info(String(localized: "Entrée audio modifiée : \(d)"))399            case .interruptionEnded: break400            }401        }402        e.callbacks.manifestSaved = { [weak self] m in self?.manifest = m; self?.onManifestChanged() }403    }404405    private func stateChanged(_ s: RecordingState) {406        recState = s407        position = engine.position408        if s == .idle {409            timer?.invalidate(); timer = nil410            keepAwake(false); spotter?.stop(); spotter = nil411            levelDB = -120; peak = 0; elapsed = .zero412            manifest = engine.currentManifest413            banner = nil414            onManifestChanged()415        }416    }417418    func pause() {419        guard recState == .recording else { return }420        camera.stopSegment()421        engine.pause(reason: .manual)422        recState = engine.state                 // reflect the new state immediately (the engine callback arrives asynchronously)423        if banner == .suggestPause { banner = nil }424    }425    func resume() {426        guard recState == .paused else { return }427        engine.resume()428        recState = engine.state429        startCameraIfNeeded()430        if banner == .interrupted || banner == .suggestPause { banner = nil }431        if case .countdown = banner { banner = nil }432    }433    func stopRecording() {434        guard recState != .idle else { return }435        camera.stopSegment()436        // Give the camera a moment to close its file so that the segment joins the session before it ends.437        let e = engine438        DispatchQueue.main.asyncAfter(deadline: .now() + (cameraOn ? 0.6 : 0)) { e.stop() }439    }440    /// "Continue recording" on a suggestion or a countdown.441    func dismissAutomatic() { engine.userContinued(); banner = nil }442443    private func startTimer() {444        timer?.invalidate()445        timer = Timer.scheduledTimer(withTimeInterval: 0.25, repeats: true) { [weak self] _ in446            Task { @MainActor [weak self] in self?.tick() }447        }448    }449450    private func tick() {451        guard recState != .idle else { return }452        engine.tick()453        elapsed = engine.sessionElapsed454        position = engine.position455        if case .countdown = banner { countdownRemaining = Int((engine.countdownRemaining() ?? 0).rounded(.up)) }456        if Int(elapsed.seconds * 4) % 20 == 0 { freeBytes = ProjectPackage.freeDiskSpace(at: package.url) }457    }458459    private func handle(auto out: AutoPauseEngine.Output) {460        switch out {461        case .suggestPause: banner = .suggestPause462        case .withdrawSuggestion: if banner == .suggestPause { banner = nil }463        case .countdownStarted(let kind, let seconds): countdownRemaining = Int(seconds); banner = .countdown(kind)464        case .countdownCancelled: if case .countdown = banner { banner = nil }465        case .countdownFinished(let kind, let stop):466            camera.stopSegment()467            banner = .info(stop ? String(localized: "Enregistrement arrêté automatiquement et sauvegardé.")468                                : Self.pauseExplanation(kind))469        }470    }471472    static func pauseExplanation(_ kind: AutoPolicyKind) -> String {473        switch kind {474        case .inactivity: String(localized: "Mise en pause automatique : aucune activité. Rien n'est perdu.")475        case .maxDuration: String(localized: "Mise en pause automatique : durée maximale atteinte. Rien n'est perdu.")476        case .endTime: String(localized: "Mise en pause automatique : heure de fin atteinte. Rien n'est perdu.")477        case .endPhrase: String(localized: "Mise en pause automatique : phrase de fin reconnue. Rien n'est perdu.")478        default: String(localized: "Mise en pause automatique. Rien n'est perdu.")479        }480    }481482    private func handle(warning w: SystemWarning) {483        switch w {484        case .lowDisk(let b): banner = .warning(String(localized: "Espace disque faible : \(DS.bytes(b)) libres."))485        case .criticalDisk(let b): banner = .warning(String(localized: "Espace disque critique (\(DS.bytes(b))). Enregistrement mis en pause et sauvegardé."))486        case .thermal(let serious): banner = .warning(serious ? String(localized: "L'appareil est très chaud. Fermez d'autres apps ou éloignez-le d'une source de chaleur.")487                                                             : String(localized: "L'appareil chauffe. L'enregistrement continue."))488        case .lowBattery(let p): banner = .warning(String(localized: "Batterie faible (\(p) %). Branchez l'appareil."))489        case .audioWriteFailed(let m): banner = .warning(String(localized: "Écriture audio impossible : \(m)"))490        }491    }492493    private func keepAwake(_ on: Bool) {494        #if os(iOS)495        UIApplication.shared.isIdleTimerDisabled = on496        #else497        if on, activity == nil {498            activity = ProcessInfo.processInfo.beginActivity(options: [.idleDisplaySleepDisabled, .idleSystemSleepDisabled, .userInitiated], reason: "Recording a lecture")499        } else if !on, let a = activity { ProcessInfo.processInfo.endActivity(a); activity = nil }500        #endif501    }502503    /// iOS scene moved to the background. With audio, recording continues (audio background mode). Without audio the504    /// app will be suspended, so the session is paused cleanly instead of silently losing time.505    func appDidEnterBackground() {506        log.flush()507        if recState == .recording, !hasAudio { camera.stopSegment(); engine.pause(reason: .appBackground); banner = .info(String(localized: "Mis en pause : l'app est passée à l'arrière-plan.")) }508        else if recState == .recording, cameraOn { camera.stopSegment() }      // the camera cannot run in the background509    }510    func appDidBecomeActive() { if recState == .recording, cameraOn { startCameraIfNeeded() } }511512    // MARK: Camera513514    /// Turns the face camera on or off. The permission is requested the first time it is turned on.515    func setCamera(_ on: Bool) async {516        if on {517            guard await CapturePermissions.request(.video) == .granted else {518                banner = .warning(String(localized: "Accès à la caméra refusé. Autorisez-le dans les réglages du système pour l'utiliser."))519                cameraOn = false; return520            }521            do {522                try camera.configure(deviceID: settings.stored.cameraID)523                camera.onSegment = { [weak self] seg in self?.engine.attach(cameraSegment: seg) }524                camera.onError = { [weak self] m in self?.banner = .warning(String(localized: "Caméra : \(m)")) }525                camera.startPreview(); cameraOn = true526                if recState != .idle { engine.record(.camera(enabled: true, placement: settings.stored.cameraPlacement), interaction: false) }527                if recState == .recording { startCameraIfNeeded() }528            } catch { banner = .warning(String(localized: "Caméra indisponible.")); cameraOn = false }529        } else {530            camera.stopSegment(); camera.stopPreview(); cameraOn = false531            if recState != .idle { engine.record(.camera(enabled: false, placement: settings.stored.cameraPlacement), interaction: false) }532        }533    }534535    private func startCameraIfNeeded() {536        guard cameraOn, camera.isConfigured, let s = engine.activeSession else { return }537        let existing = (try? FileManager.default.contentsOfDirectory(atPath: package.mediaURL.path))?.filter { $0.hasPrefix("camera-\(s.shortID)") }.count ?? 0538        camera.setNextIndex(existing + 1)539        engine.record(.camera(enabled: true, placement: settings.stored.cameraPlacement), interaction: false)540        camera.startSegment(package: package, recordingSession: s, clock: engine.clock)541    }542543    // MARK: Optional local voice commands544545    private func startSpotterIfNeeded(_ e: RecordingEngine) {546        let policy = settings.stored.policy547        guard hasAudio, policy.retakePhraseEnabled || policy.endPhraseEnabled, let s = LivePhraseSpotter(locale: settings.locale) else { return }548        if policy.retakePhraseEnabled { s.watch(phrase: policy.retakePhrase) { [weak self] in self?.addMarker(.retake, label: "voice") } }549        if policy.endPhraseEnabled { s.watch(phrase: policy.endPhrase) { [weak e] in e?.endPhraseHeard() } }550        e.bufferTap = { [weak s] buffer in s?.append(buffer) }551        s.start(); spotter = s552    }553554    // MARK: Estimates555556    /// Minutes of recording that fit in the free space (audio, plus camera when on).557    var minutesRemaining: Int { Int(Double(freeBytes) / Double(Preflight.bytesPerMinute(camera: cameraOn))) }558}559
Files main
Menu

Theme