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