]> git.r.bdr.sh - rbdr/captura/blob - Captura/CapturaApp.swift
Adds configure support for URLs
[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 NotificationCenter.default.post(name: .setConfiguration, object: nil, userInfo: [
112 "config": config
113 ])
114 case let .record(config):
115 NotificationCenter.default.post(name: .setCaptureSessionConfiguration, object: nil, userInfo: [
116 "config": config
117 ])
118 NotificationCenter.default.post(name: .startAreaSelection, object: nil, userInfo: nil)
119 }
120 }
121 }
122 } else {
123 let alert = NSAlert()
124 alert.messageText = "URL Automation Prevented"
125 alert.informativeText = "A website or application attempted to record your screen using URL Automation. If you want to allow this, enable it in Preferences."
126 alert.alertStyle = .warning
127 alert.addButton(withTitle: "OK")
128 alert.runModal()
129 }
130 }
131
132 // MARK: - UI Event Handlers
133
134 func menuWillOpen(_ menu: NSMenu) {
135 if captureState != .idle {
136 menu.cancelTracking()
137 if captureState == .recording {
138 NotificationCenter.default.post(name: .stopRecording, object: nil, userInfo: nil)
139 }
140 }
141 }
142
143 @objc private func onClickStartRecording() {
144 NotificationCenter.default.post(name: .startAreaSelection, object: nil, userInfo: nil)
145 }
146
147 @objc private func onOpenPreferences() {
148 NSApp.activate(ignoringOtherApps: true)
149 if preferencesWindow == nil {
150 preferencesWindow = PreferencesWindow()
151 } else {
152 preferencesWindow?.makeKeyAndOrderFront(nil)
153 preferencesWindow?.orderFrontRegardless()
154 }
155 }
156
157 @objc private func onOpenFolder() {
158 if let directory = FileManager.default.urls(for: .picturesDirectory, in: .userDomainMask).first?.appendingPathComponent("captura") {
159 NSWorkspace.shared.open(directory)
160 }
161 }
162
163 @objc private func onClickRemoteFile(_ sender: NSMenuItem) {
164 if let remoteFile = sender.representedObject as? CapturaRemoteFile {
165 if let urlString = remoteFile.url {
166 if let url = URL(string: urlString) {
167 NSWorkspace.shared.open(url)
168 }
169 }
170 }
171 }
172
173 @objc private func onQuit() {
174 NSApplication.shared.terminate(self)
175 }
176
177 // MARK: - App State Event Listeners
178
179 @objc func didReceiveNotification(_ notification: Notification) {
180 switch(notification.name) {
181 case .startAreaSelection:
182 startAreaSelection()
183 case .startRecording:
184 startRecording()
185 case .stopRecording:
186 stopRecording()
187 case .finalizeRecording:
188 DispatchQueue.main.async {
189 self.finalizeRecording()
190 }
191 case .reset:
192 reset()
193 case .failedToStart:
194 DispatchQueue.main.async {
195 self.failed(true)
196 }
197 case .failedtoUpload:
198 DispatchQueue.main.async {
199 self.failed()
200 }
201 case .receivedFrame:
202 if let frame = notification.userInfo?["frame"] {
203 receivedFrame(frame as! CVImageBuffer)
204 }
205 case .setConfiguration:
206 DispatchQueue.main.async {
207 if let userInfo = notification.userInfo {
208 if let config = userInfo["config"] as? ConfigureAction {
209 self.setConfiguration(config)
210 }
211 }
212 }
213 case .reloadConfiguration:
214 reloadConfiguration()
215 case .setCaptureSessionConfiguration:
216 if let userInfo = notification.userInfo {
217 if let config = userInfo["config"] as? RecordAction {
218 setCaptureSessionConfiguration(config)
219 }
220 }
221 case .NSManagedObjectContextObjectsDidChange:
222 DispatchQueue.main.async {
223 self.fetchRemoteItems()
224 self.setupMenu()
225 }
226 default:
227 return
228 }
229 }
230
231
232 func startAreaSelection() {
233 helpShown = false
234 if captureState != .selectingArea {
235 captureState = .selectingArea
236 if let button = statusItem.button {
237 let rectInWindow = button.convert(button.bounds, to: nil)
238 let rectInScreen = button.window?.convertToScreen(rectInWindow)
239 NSApp.activate(ignoringOtherApps: true)
240 recordingWindow = RecordingWindow(captureSessionConfiguration, rectInScreen)
241 recordingWindow?.makeKeyAndOrderFront(nil)
242 recordingWindow?.orderFrontRegardless()
243 boxListener = recordingWindow?.recordingContentView.$box
244 .debounce(for: .seconds(0.3), scheduler: RunLoop.main)
245 .sink { newValue in
246 if newValue != nil {
247 self.updateImage()
248 if !self.helpShown {
249 self.helpShown = true
250 self.showPopoverWithMessage("Click here when you're ready to record.")
251 }
252 }
253 }
254 }
255 }
256 }
257
258 func startRecording() {
259 captureState = .recording
260 updateImage()
261 outputFile = nil
262 images = [];
263 pixelDensity = recordingWindow?.pixelDensity ?? 1.0
264 recordingWindow?.recordingContentView.startRecording()
265 if let box = recordingWindow?.recordingContentView.box {
266 if let screen = recordingWindow?.screen {
267 captureSession = CapturaCaptureSession(screen, box: box)
268
269 if let captureSession {
270
271 stopTimer = DispatchWorkItem {
272 self.stopRecording()
273 }
274 DispatchQueue.main.asyncAfter(deadline: .now() + Double(captureSessionConfiguration.maxLength), execute: stopTimer!)
275
276 outputFile = CapturaFile()
277 if captureSessionConfiguration.shouldSaveMp4 {
278 captureSession.startRecording(to: outputFile!.mp4URL)
279 } else {
280 captureSession.startRunning()
281 }
282 return
283 }
284 }
285 }
286 NotificationCenter.default.post(name: .failedToStart, object: nil, userInfo: nil)
287 }
288
289 func stopRecording() {
290 captureState = .uploading
291 updateImage()
292 stop()
293
294 Task.detached {
295 if self.captureSessionConfiguration.shouldSaveGif {
296 if let outputFile = self.outputFile {
297 await GifRenderer.render(self.images, at: self.captureSessionConfiguration.frameRate, to: outputFile.gifURL)
298 }
299 }
300 let wasSuccessful = await self.uploadOrCopy()
301 if wasSuccessful {
302 NotificationCenter.default.post(name: .finalizeRecording, object: nil, userInfo: nil)
303 } else {
304 NotificationCenter.default.post(name: .failedtoUpload, object: nil, userInfo: nil)
305 }
306 }
307 }
308
309 func finalizeRecording() {
310 captureState = .uploaded
311 updateImage()
312 DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) {
313 NotificationCenter.default.post(name: .reset, object: nil, userInfo: nil)
314 }
315 }
316
317 func reset() {
318 captureState = .idle
319 updateImage()
320 captureSessionConfiguration = CaptureSessionConfiguration()
321 stop()
322 }
323
324 func receivedFrame(_ frame: CVImageBuffer) {
325 let now = ContinuousClock.now
326
327 if now - gifCallbackTimer > .nanoseconds(1_000_000_000 / UInt64(captureSessionConfiguration.frameRate)) {
328 gifCallbackTimer = now
329 DispatchQueue.main.async {
330 if let cgImage = frame.cgImage?.resize(by: self.pixelDensity) {
331 self.images.append(cgImage)
332 }
333 }
334 }
335 }
336
337 func failed(_ requestPermission: Bool = false) {
338 captureState = .error
339 updateImage()
340 if requestPermission {
341 requestPermissionToRecord()
342 }
343 stop()
344 DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) {
345 NotificationCenter.default.post(name: .reset, object: nil, userInfo: nil)
346 }
347 }
348
349 func setConfiguration(_ config: ConfigureAction) {
350 CapturaSettings.apply(config)
351 }
352
353 func reloadConfiguration() {
354 self.captureSessionConfiguration = CaptureSessionConfiguration()
355 }
356
357 func setCaptureSessionConfiguration(_ config: RecordAction) {
358 self.captureSessionConfiguration = CaptureSessionConfiguration(from: config)
359 }
360
361 // MARK: - CoreData
362
363 private func fetchRemoteItems() {
364 let viewContext = PersistenceController.shared.container.viewContext
365 let fetchRequest = NSFetchRequest<CapturaRemoteFile>(entityName: "CapturaRemoteFile")
366 fetchRequest.fetchLimit = 5
367 fetchRequest.sortDescriptors = [NSSortDescriptor(key: "timestamp", ascending: false)]
368
369 let results = try? viewContext.fetch(fetchRequest)
370 remoteFiles = results ?? []
371 }
372
373 // MARK: - Presentation Helpers
374
375
376 private func requestPermissionToRecord() {
377 showPopoverWithMessage("Please grant Captura permission to record")
378 if let url = URL(string: "x-apple.systempreferences:com.apple.preference.security?Privacy_ScreenRecording") {
379 NSWorkspace.shared.open(url)
380 }
381 }
382
383 private func showPopoverWithMessage(_ message: String) {
384 if let button = statusItem.button {
385 (self.popover?.contentViewController as? HelpPopoverViewController)?.updateLabel(message)
386 self.popover?.show(relativeTo: button.bounds, of: button, preferredEdge: NSRectEdge.minY)
387 DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) {
388 self.popover?.performClose(nil)
389 }
390 }
391 }
392
393 private func updateImage() {
394 if let button = statusItem.button {
395 let image: String = switch captureState {
396 case .idle:
397 "rectangle.dashed.badge.record"
398 case .selectingArea:
399 "circle.rectangle.dashed"
400 case .recording:
401 "checkmark.rectangle"
402 case .uploading:
403 "dock.arrow.up.rectangle"
404 case .uploaded:
405 "checkmark.rectangle.fill"
406 case .error:
407 "xmark.rectangle.fill"
408 }
409 button.image = NSImage(systemSymbolName: image, accessibilityDescription: "Captura")
410 }
411 }
412
413 private func stop() {
414 stopTimer?.cancel()
415 captureSession?.stopRunning()
416 captureSession = nil
417 boxListener?.cancel()
418 recordingWindow?.close()
419 recordingWindow = nil
420 }
421
422 private func uploadOrCopy() async -> Bool {
423 if captureSessionConfiguration.shouldUseBackend {
424 let result = await uploadToBackend()
425 if result && !captureSessionConfiguration.shouldKeepLocalFiles {
426 deleteLocalFiles()
427 }
428 return result
429 } else {
430 copyLocalToClipboard()
431 return true
432 }
433 }
434
435 private func copyLocalToClipboard() {
436 let fileType: NSPasteboard.PasteboardType = .init(rawValue: captureSessionConfiguration.shouldSaveGif ? "com.compuserve.gif" : "public.mpeg-4")
437 if let url = captureSessionConfiguration.shouldSaveGif ? outputFile?.gifURL : outputFile?.mp4URL {
438 if let data = try? Data(contentsOf: url) {
439 let pasteboard = NSPasteboard.general
440 pasteboard.declareTypes([fileType], owner: nil)
441 pasteboard.setData(data, forType: fileType)
442 }
443 }
444 }
445
446 private func uploadToBackend() async -> Bool {
447 let contentType = captureSessionConfiguration.shouldUploadGif ? "image/gif" : "video/mp4"
448 if let url = captureSessionConfiguration.shouldUploadGif ? outputFile?.gifURL : outputFile?.mp4URL {
449 if let data = try? Data(contentsOf: url) {
450 if let remoteUrl = captureSessionConfiguration.backend {
451 var request = URLRequest(url: remoteUrl)
452 request.httpMethod = "POST"
453 request.httpBody = data
454 request.setValue(contentType, forHTTPHeaderField: "Content-Type")
455 request.setValue("Captura/1.0", forHTTPHeaderField: "User-Agent")
456
457 do {
458 let (data, response) = try await URLSession.shared.data(for: request)
459
460 if let httpResponse = response as? HTTPURLResponse {
461 if httpResponse.statusCode == 201 {
462 let answer = try JSONDecoder().decode(BackendResponse.self, from: data)
463 createRemoteFile(answer.url)
464 return true
465 }
466 }
467 } catch {}
468 }
469 }
470 }
471 return false
472 }
473
474 private func createRemoteFile(_ url: URL) {
475 let viewContext = PersistenceController.shared.container.viewContext
476 let remoteFile = CapturaRemoteFile(context: viewContext)
477 remoteFile.url = url.absoluteString
478 remoteFile.timestamp = Date()
479 try? viewContext.save()
480 let pasteboard = NSPasteboard.general
481 pasteboard.declareTypes([.URL], owner: nil)
482 pasteboard.setString(url.absoluteString, forType: .string)
483 }
484
485 private func deleteLocalFiles() {
486 if captureSessionConfiguration.shouldSaveGif {
487 if let url = outputFile?.gifURL {
488 try? FileManager.default.removeItem(at: url)
489 }
490 }
491 if captureSessionConfiguration.shouldSaveMp4 {
492 if let url = outputFile?.mp4URL {
493 try? FileManager.default.removeItem(at: url)
494 }
495 }
496 }
497 }