]> git.r.bdr.sh - rbdr/captura/blob - Captura/CapturaApp.swift
d954b9f800e969554ae4bcc478e270f11759c4fb
[rbdr/captura] / Captura / CapturaApp.swift
1 import SwiftUI
2 import SwiftData
3 import Cocoa
4 import Combine
5 import AVFoundation
6
7 @main
8 struct CapturaApp: App {
9
10 @NSApplicationDelegateAdaptor(CapturaAppDelegate.self) var appDelegate
11
12 var body: some Scene {
13 WindowGroup {
14 PreferencesScreen()
15 .handlesExternalEvents(preferring: Set(arrayLiteral: "PreferencesScreen"), allowing: Set(arrayLiteral: "*"))
16 .frame(width: 650, height: 450)
17 }
18 .handlesExternalEvents(matching: Set(arrayLiteral: "PreferencesScreen"))
19 //.modelContainer(for: CapturaRemoteFile.self)
20 }
21 }
22
23 @objc(CapturaAppDelegate) class CapturaAppDelegate: NSObject, NSApplicationDelegate, NSMenuDelegate {
24
25 @Environment(\.openURL) var openURL
26 var statusItem: NSStatusItem!
27 var captureState: CaptureState = .idle
28 var recordingWindow: RecordingWindow? = nil
29 var preferencesWindow: PreferencesWindow? = nil
30 var boxListener: AnyCancellable? = nil
31 var popover: NSPopover? = nil
32 var helpShown = false
33 var captureSession: CapturaCaptureSession? = nil
34 var images: [CGImage] = []
35 var outputFile: CapturaFile? = nil
36 var gifCallbackTimer = ContinuousClock.now
37 var pixelDensity: CGFloat = 1.0
38 var stopTimer: DispatchWorkItem?
39 var remoteFiles: [CapturaRemoteFile] = []
40 var captureSessionConfiguration: CaptureSessionConfiguration = CaptureSessionConfiguration()
41
42 @objc dynamic var scriptedPreferences: ScriptedPreferences = ScriptedPreferences()
43
44 func applicationDidFinishLaunching(_ notification: Notification) {
45 setupStatusBar()
46 NotificationCenter.default.addObserver(
47 self,
48 selector: #selector(self.didReceiveNotification(_:)),
49 name: nil,
50 object: nil)
51 closeWindow()
52 fetchRemoteItems()
53 }
54
55 // MARK: - Setup Functions
56
57
58 private func setupStatusBar() {
59 statusItem = NSStatusBar.system.statusItem(withLength: NSStatusItem.variableLength)
60
61 if let button = statusItem.button {
62 button.image = NSImage(systemSymbolName: "rectangle.dashed.badge.record", accessibilityDescription: "Captura")
63 }
64
65 statusItem.isVisible = true
66 statusItem.menu = NSMenu()
67 statusItem.menu?.delegate = self
68
69 // Create the Popover
70 popover = NSPopover()
71 popover?.contentViewController = HelpPopoverViewController()
72 popover?.behavior = .transient
73
74 setupMenu()
75 }
76
77 private func setupMenu() {
78
79 statusItem.menu?.removeAllItems()
80
81 statusItem.menu?.addItem(NSMenuItem(title: "Record", action: #selector(CapturaAppDelegate.onClickStartRecording), keyEquivalent: ""))
82 if (remoteFiles.count > 0) {
83 statusItem.menu?.addItem(NSMenuItem.separator())
84 for remoteFile in remoteFiles {
85 let remoteFileItem = NSMenuItem(title: remoteFile.name, action: #selector(CapturaAppDelegate.onClickRemoteFile), keyEquivalent: "")
86 remoteFileItem.representedObject = remoteFile
87 statusItem.menu?.addItem(remoteFileItem)
88 }
89 }
90 statusItem.menu?.addItem(NSMenuItem.separator())
91 statusItem.menu?.addItem(NSMenuItem(title: "Open Local Folder", action: #selector(CapturaAppDelegate.onOpenFolder), keyEquivalent: ""))
92 statusItem.menu?.addItem(NSMenuItem.separator())
93 statusItem.menu?.addItem(NSMenuItem(title: "Preferences", action: #selector(CapturaAppDelegate.onOpenPreferences), keyEquivalent: ""))
94 statusItem.menu?.addItem(NSMenuItem(title: "Quit", action: #selector(CapturaAppDelegate.onQuit), keyEquivalent: ""))
95 }
96
97 private func closeWindow() {
98 if let window = NSApplication.shared.windows.first {
99 window.close()
100 }
101 }
102
103 // MARK: - URL Event Handler
104
105 func application(_ application: NSApplication, open urls: [URL]) {
106 if (CapturaSettings.shouldAllowURLAutomation) {
107 for url in urls {
108 if let action = CapturaURLDecoder.decodeParams(url: url) {
109 switch action {
110 case let .configure(config):
111 CapturaSettings.apply(config)
112 case let .record(config):
113 NotificationCenter.default.post(name: .setCaptureSessionConfiguration, object: nil, userInfo: [
114 "config": config
115 ])
116 NotificationCenter.default.post(name: .startAreaSelection, object: nil, userInfo: nil)
117 }
118 }
119 }
120 } else {
121 let alert = NSAlert()
122 alert.messageText = "URL Automation Prevented"
123 alert.informativeText = "A website or application attempted to record your screen using URL Automation. If you want to allow this, enable it in Preferences."
124 alert.alertStyle = .warning
125 alert.addButton(withTitle: "OK")
126 alert.runModal()
127 }
128 }
129
130 // MARK: - UI Event Handlers
131
132 func menuWillOpen(_ menu: NSMenu) {
133 if captureState != .idle {
134 menu.cancelTracking()
135 if captureState == .recording {
136 NotificationCenter.default.post(name: .stopRecording, object: nil, userInfo: nil)
137 }
138 }
139 }
140
141 @objc private func onClickStartRecording() {
142 NotificationCenter.default.post(name: .startAreaSelection, object: nil, userInfo: nil)
143 }
144
145 @objc private func onOpenPreferences() {
146 NSApp.activate(ignoringOtherApps: true)
147 if preferencesWindow == nil {
148 preferencesWindow = PreferencesWindow()
149 } else {
150 preferencesWindow?.makeKeyAndOrderFront(nil)
151 preferencesWindow?.orderFrontRegardless()
152 }
153 }
154
155 @objc private func onOpenFolder() {
156 if let directory = FileManager.default.urls(for: .picturesDirectory, in: .userDomainMask).first?.appendingPathComponent("captura") {
157 NSWorkspace.shared.open(directory)
158 }
159 }
160
161 @objc private func onClickRemoteFile(_ sender: NSMenuItem) {
162 if let remoteFile = sender.representedObject as? CapturaRemoteFile {
163 if let urlString = remoteFile.url {
164 if let url = URL(string: urlString) {
165 NSWorkspace.shared.open(url)
166 }
167 }
168 }
169 }
170
171 @objc private func onQuit() {
172 NSApplication.shared.terminate(self)
173 }
174
175 // MARK: - App State Event Listeners
176
177 @objc func didReceiveNotification(_ notification: Notification) {
178 switch(notification.name) {
179 case .startAreaSelection:
180 startAreaSelection()
181 case .startRecording:
182 startRecording()
183 case .stopRecording:
184 stopRecording()
185 case .finalizeRecording:
186 DispatchQueue.main.async {
187 self.finalizeRecording()
188 }
189 case .reset:
190 reset()
191 case .failedToStart:
192 DispatchQueue.main.async {
193 self.failed(true)
194 }
195 case .failedtoUpload:
196 DispatchQueue.main.async {
197 self.failed()
198 }
199 case .receivedFrame:
200 if let frame = notification.userInfo?["frame"] {
201 receivedFrame(frame as! CVImageBuffer)
202 }
203 case .reloadConfiguration:
204 reloadConfiguration()
205 case .setCaptureSessionConfiguration:
206 if let userInfo = notification.userInfo {
207 if let config = userInfo["config"] as? RecordAction {
208 setCaptureSessionConfiguration(config)
209 }
210 }
211 case .NSManagedObjectContextObjectsDidChange:
212 DispatchQueue.main.async {
213 self.fetchRemoteItems()
214 self.setupMenu()
215 }
216 default:
217 return
218 }
219 }
220
221
222 func startAreaSelection() {
223 helpShown = false
224 if captureState != .selectingArea {
225 captureState = .selectingArea
226 if let button = statusItem.button {
227 let rectInWindow = button.convert(button.bounds, to: nil)
228 let rectInScreen = button.window?.convertToScreen(rectInWindow)
229 NSApp.activate(ignoringOtherApps: true)
230 recordingWindow = RecordingWindow(captureSessionConfiguration, rectInScreen)
231 recordingWindow?.makeKeyAndOrderFront(nil)
232 recordingWindow?.orderFrontRegardless()
233 boxListener = recordingWindow?.recordingContentView.$box
234 .debounce(for: .seconds(0.3), scheduler: RunLoop.main)
235 .sink { newValue in
236 if newValue != nil {
237 self.updateImage()
238 if !self.helpShown {
239 self.helpShown = true
240 self.showPopoverWithMessage("Click here when you're ready to record.")
241 }
242 }
243 }
244 }
245 }
246 }
247
248 func startRecording() {
249 captureState = .recording
250 updateImage()
251 outputFile = nil
252 images = [];
253 pixelDensity = recordingWindow?.pixelDensity ?? 1.0
254 recordingWindow?.recordingContentView.startRecording()
255 if let box = recordingWindow?.recordingContentView.box {
256 if let screen = recordingWindow?.screen {
257 captureSession = CapturaCaptureSession(screen, box: box)
258
259 if let captureSession {
260
261 stopTimer = DispatchWorkItem {
262 self.stopRecording()
263 }
264 DispatchQueue.main.asyncAfter(deadline: .now() + Double(captureSessionConfiguration.maxLength), execute: stopTimer!)
265
266 outputFile = CapturaFile()
267 if captureSessionConfiguration.shouldSaveMp4 {
268 captureSession.startRecording(to: outputFile!.mp4URL)
269 } else {
270 captureSession.startRunning()
271 }
272 return
273 }
274 }
275 }
276 NotificationCenter.default.post(name: .failedToStart, object: nil, userInfo: nil)
277 }
278
279 func stopRecording() {
280 captureState = .uploading
281 updateImage()
282 stop()
283
284 Task.detached {
285 if self.captureSessionConfiguration.shouldSaveGif {
286 if let outputFile = self.outputFile {
287 await GifRenderer.render(self.images, at: self.captureSessionConfiguration.frameRate, to: outputFile.gifURL)
288 }
289 }
290 let wasSuccessful = await self.uploadOrCopy()
291 if wasSuccessful {
292 NotificationCenter.default.post(name: .finalizeRecording, object: nil, userInfo: nil)
293 } else {
294 NotificationCenter.default.post(name: .failedtoUpload, object: nil, userInfo: nil)
295 }
296 }
297 }
298
299 func finalizeRecording() {
300 captureState = .uploaded
301 updateImage()
302 DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) {
303 NotificationCenter.default.post(name: .reset, object: nil, userInfo: nil)
304 }
305 }
306
307 func reset() {
308 captureState = .idle
309 updateImage()
310 captureSessionConfiguration = CaptureSessionConfiguration()
311 stop()
312 }
313
314 func receivedFrame(_ frame: CVImageBuffer) {
315 let now = ContinuousClock.now
316
317 if now - gifCallbackTimer > .nanoseconds(1_000_000_000 / UInt64(captureSessionConfiguration.frameRate)) {
318 gifCallbackTimer = now
319 DispatchQueue.main.async {
320 if let cgImage = frame.cgImage?.resize(by: self.pixelDensity) {
321 self.images.append(cgImage)
322 }
323 }
324 }
325 }
326
327 func failed(_ requestPermission: Bool = false) {
328 captureState = .error
329 updateImage()
330 if requestPermission {
331 requestPermissionToRecord()
332 }
333 stop()
334 DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) {
335 NotificationCenter.default.post(name: .reset, object: nil, userInfo: nil)
336 }
337 }
338
339 func reloadConfiguration() {
340 self.captureSessionConfiguration = CaptureSessionConfiguration()
341 }
342
343 func setCaptureSessionConfiguration(_ config: RecordAction) {
344 self.captureSessionConfiguration = CaptureSessionConfiguration(from: config)
345 }
346
347 // MARK: - CoreData
348
349 private func fetchRemoteItems() {
350 let viewContext = PersistenceController.shared.container.viewContext
351 let fetchRequest = NSFetchRequest<CapturaRemoteFile>(entityName: "CapturaRemoteFile")
352 fetchRequest.fetchLimit = 5
353 fetchRequest.sortDescriptors = [NSSortDescriptor(key: "timestamp", ascending: false)]
354
355 let results = try? viewContext.fetch(fetchRequest)
356 remoteFiles = results ?? []
357 }
358
359 // MARK: - Presentation Helpers
360
361
362 private func requestPermissionToRecord() {
363 showPopoverWithMessage("Please grant Captura permission to record")
364 if let url = URL(string: "x-apple.systempreferences:com.apple.preference.security?Privacy_ScreenRecording") {
365 NSWorkspace.shared.open(url)
366 }
367 }
368
369 private func showPopoverWithMessage(_ message: String) {
370 if let button = statusItem.button {
371 (self.popover?.contentViewController as? HelpPopoverViewController)?.updateLabel(message)
372 self.popover?.show(relativeTo: button.bounds, of: button, preferredEdge: NSRectEdge.minY)
373 DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) {
374 self.popover?.performClose(nil)
375 }
376 }
377 }
378
379 private func updateImage() {
380 if let button = statusItem.button {
381 let image: String = switch captureState {
382 case .idle:
383 "rectangle.dashed.badge.record"
384 case .selectingArea:
385 "circle.rectangle.dashed"
386 case .recording:
387 "checkmark.rectangle"
388 case .uploading:
389 "dock.arrow.up.rectangle"
390 case .uploaded:
391 "checkmark.rectangle.fill"
392 case .error:
393 "xmark.rectangle.fill"
394 }
395 button.image = NSImage(systemSymbolName: image, accessibilityDescription: "Captura")
396 }
397 }
398
399 private func stop() {
400 stopTimer?.cancel()
401 captureSession?.stopRunning()
402 captureSession = nil
403 boxListener?.cancel()
404 recordingWindow?.close()
405 recordingWindow = nil
406 }
407
408 private func uploadOrCopy() async -> Bool {
409 if captureSessionConfiguration.shouldUseBackend {
410 let result = await uploadToBackend()
411 if result && !captureSessionConfiguration.shouldKeepLocalFiles {
412 deleteLocalFiles()
413 }
414 return result
415 } else {
416 copyLocalToClipboard()
417 return true
418 }
419 }
420
421 private func copyLocalToClipboard() {
422 let fileType: NSPasteboard.PasteboardType = .init(rawValue: captureSessionConfiguration.shouldSaveGif ? "com.compuserve.gif" : "public.mpeg-4")
423 if let url = captureSessionConfiguration.shouldSaveGif ? outputFile?.gifURL : outputFile?.mp4URL {
424 if let data = try? Data(contentsOf: url) {
425 let pasteboard = NSPasteboard.general
426 pasteboard.declareTypes([fileType], owner: nil)
427 pasteboard.setData(data, forType: fileType)
428 }
429 }
430 }
431
432 private func uploadToBackend() async -> Bool {
433 let contentType = captureSessionConfiguration.shouldUploadGif ? "image/gif" : "video/mp4"
434 if let url = captureSessionConfiguration.shouldUploadGif ? outputFile?.gifURL : outputFile?.mp4URL {
435 if let data = try? Data(contentsOf: url) {
436 if let remoteUrl = captureSessionConfiguration.backend {
437 var request = URLRequest(url: remoteUrl)
438 request.httpMethod = "POST"
439 request.httpBody = data
440 request.setValue(contentType, forHTTPHeaderField: "Content-Type")
441 request.setValue("Captura/1.0", forHTTPHeaderField: "User-Agent")
442
443 do {
444 let (data, response) = try await URLSession.shared.data(for: request)
445
446 if let httpResponse = response as? HTTPURLResponse {
447 if httpResponse.statusCode == 201 {
448 let answer = try JSONDecoder().decode(BackendResponse.self, from: data)
449 createRemoteFile(answer.url)
450 return true
451 }
452 }
453 } catch {}
454 }
455 }
456 }
457 return false
458 }
459
460 private func createRemoteFile(_ url: URL) {
461 let viewContext = PersistenceController.shared.container.viewContext
462 let remoteFile = CapturaRemoteFile(context: viewContext)
463 remoteFile.url = url.absoluteString
464 remoteFile.timestamp = Date()
465 try? viewContext.save()
466 let pasteboard = NSPasteboard.general
467 pasteboard.declareTypes([.URL], owner: nil)
468 pasteboard.setString(url.absoluteString, forType: .string)
469 }
470
471 private func deleteLocalFiles() {
472 if captureSessionConfiguration.shouldSaveGif {
473 if let url = outputFile?.gifURL {
474 try? FileManager.default.removeItem(at: url)
475 }
476 }
477 if captureSessionConfiguration.shouldSaveMp4 {
478 if let url = outputFile?.mp4URL {
479 try? FileManager.default.removeItem(at: url)
480 }
481 }
482 }
483 }