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