Repository Public
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