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