Skip to content

Open source CapCut alternative.

TypeScript

fix(app): let quit through a stalled recording [rebuild]

David Le5b94b9ba266b
diff --git a/apps/Donkey/Sources/Donkey/ScreenRecordingController.swift b/apps/Donkey/Sources/Donkey/ScreenRecordingController.swift
index 65be9dae..2ffdc0ac 100644
--- a/apps/Donkey/Sources/Donkey/ScreenRecordingController.swift
+++ b/apps/Donkey/Sources/Donkey/ScreenRecordingController.swift
@@ -5,6 +5,9 @@ import DonkeyRuntime
import DonkeyUI
import ScreenCaptureKit
+/// How long a quit waits on a movie still finalizing before it goes through anyway.
+private let quitDeadline: Duration = .seconds(15)
+
/// Coordinates the whole screen-recording flow: the menu bar toggle, the center-bottom control bar,
/// the region/window pickers, and the recorder. It is the single source of truth — the menu bar glyph
/// and the control bar both render from this controller's state, so a click on either surface routes
@@ -39,8 +42,9 @@ final class ScreenRecordingController {
private var windowSizeTask: Task<Void, Never>?
private var recordingStart: Date?
private var timer: Timer?
- /// Quits waiting on the movie in flight, answered once it is written or abandoned.
- private var quitWaiters: [@MainActor () -> Void] = []
+ /// Quits waiting on the movie in flight, answered once it is written or abandoned, or after
+ /// `quitDeadline` when finalizing stalls.
+ private let quitWaiters = QuitWaiters(deadline: quitDeadline)
init() {
model.onSelectMode = { [weak self] mode in self?.selectMode(mode) }
@@ -106,14 +110,12 @@ final class ScreenRecordingController {
return
}
- quitWaiters.append(done)
+ quitWaiters.add(done)
stopRecording()
}
private func releaseQuit() {
- let waiters = quitWaiters
- quitWaiters = []
- waiters.forEach { $0() }
+ quitWaiters.release()
}
// MARK: - Arm / cancel
diff --git a/apps/Donkey/Sources/DonkeyRuntime/QuitWaiters.swift b/apps/Donkey/Sources/DonkeyRuntime/QuitWaiters.swift
new file mode 100644
index 00000000..38580269
--- /dev/null
+++ b/apps/Donkey/Sources/DonkeyRuntime/QuitWaiters.swift
@@ -0,0 +1,39 @@
+import Foundation
+
+/// Quits waiting on the movie in flight. Each waiter is answered once: when the movie is written or
+/// abandoned, or when the deadline passes, so a stop that never returns cannot hold a quit, an update
+/// install or a logout forever.
+@MainActor
+public final class QuitWaiters {
+ private let deadline: Duration
+ private var waiters: [@MainActor () -> Void] = []
+ private var timeout: Task<Void, Never>?
+
+ public init(deadline: Duration) {
+ self.deadline = deadline
+ }
+
+ public var isEmpty: Bool { waiters.isEmpty }
+
+ /// Queue `done`; the first waiter starts the deadline.
+ public func add(_ done: @escaping @MainActor () -> Void) {
+ waiters.append(done)
+ guard timeout == nil else { return }
+
+ let deadline = self.deadline
+ timeout = Task { [weak self] in
+ try? await Task.sleep(for: deadline)
+ guard !Task.isCancelled else { return }
+ self?.release()
+ }
+ }
+
+ /// Answer every waiter and clear the deadline.
+ public func release() {
+ timeout?.cancel()
+ timeout = nil
+ let pending = waiters
+ waiters = []
+ pending.forEach { $0() }
+ }
+}
diff --git a/apps/Donkey/Tests/DonkeyRuntimeTests/QuitWaitersTests.swift b/apps/Donkey/Tests/DonkeyRuntimeTests/QuitWaitersTests.swift
new file mode 100644
index 00000000..797c4ef6
--- /dev/null
+++ b/apps/Donkey/Tests/DonkeyRuntimeTests/QuitWaitersTests.swift
@@ -0,0 +1,33 @@
+import DonkeyRuntime
+import Testing
+
+/// Quitting waits on the movie in flight, but never forever: a recorder whose stop never returns
+/// still lets the quit, update or logout through once the deadline passes.
+@MainActor
+struct QuitWaitersTests {
+ @Test func releaseAnswersEveryWaiterOnce() {
+ let waiters = QuitWaiters(deadline: .seconds(60))
+ var answered = 0
+ waiters.add { answered += 1 }
+ waiters.add { answered += 1 }
+
+ waiters.release()
+ waiters.release()
+
+ #expect(answered == 2)
+ #expect(waiters.isEmpty)
+ }
+
+ @Test func deadlineReleasesAStalledStop() async throws {
+ let waiters = QuitWaiters(deadline: .milliseconds(20))
+ var answered = 0
+ waiters.add { answered += 1 }
+
+ try await Task.sleep(for: .milliseconds(200))
+ #expect(answered == 1)
+
+ // The stop finishing late answers nobody twice.
+ waiters.release()
+ #expect(answered == 1)
+ }
+}