git.r.bdr.sh - rbdr/captura/blob - 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 }