Add URL parsing for record action

[rbdr/captura] / Captura / CapturaApp.swift

diff --git a/Captura/CapturaApp.swift b/Captura/CapturaApp.swift
index 4dc65a478d25a7c8bea47f22a12ed51dbe09fca2..eb6f02ecb264a24147165745a7944435a176ca9b 100644 (file)
--- a/Captura/CapturaApp.swift
+++ b/Captura/CapturaApp.swift
@@ -1,6 +1,8 @@
 import SwiftUI
 import SwiftData
 import Cocoa
 import SwiftUI
 import SwiftData
 import Cocoa

+import Combine
+import AVFoundation

 
 @main
 struct CapturaApp: App {
 
 @main
 struct CapturaApp: App {


@@ -9,107 +11,453 @@ struct CapturaApp: App {
 
     var body: some Scene {
         WindowGroup {
 
     var body: some Scene {
         WindowGroup {

-            PreferencesWindow()
-              .handlesExternalEvents(preferring: Set(arrayLiteral: "PreferencesWindow"), allowing: Set(arrayLiteral: "*"))
+          PreferencesScreen()
+              .handlesExternalEvents(preferring: Set(arrayLiteral: "PreferencesScreen"), allowing: Set(arrayLiteral: "*"))

               .frame(width: 650, height: 450)
         }
               .frame(width: 650, height: 450)
         }

-        .handlesExternalEvents(matching: Set(arrayLiteral: "PreferencesWindow"))
-        .modelContainer(for: Item.self)
+        .handlesExternalEvents(matching: Set(arrayLiteral: "PreferencesScreen"))
+        //.modelContainer(for: CapturaRemoteFile.self)

       }
 }
 
       }
 }
 

-class CapturaAppDelegate: NSObject, NSApplicationDelegate {
+class CapturaAppDelegate: NSObject, NSApplicationDelegate, NSMenuDelegate {

     
     

-    @Environment(\.openURL) var openURL
-    var statusItem: NSStatusItem!
-    var captureState: CaptureState = .idle
-    var recordingWindow: RecordingWindow? = nil
-
-    func applicationDidFinishLaunching(_ notification: Notification) {
-      setupMenu()
-      NotificationCenter.default.addObserver(
-        self,
-        selector: #selector(self.didReceiveNotification(_:)),
-        name: nil,
-        object: nil)
-      closeWindow()
+  @Environment(\.openURL) var openURL
+  var statusItem: NSStatusItem!
+  var captureState: CaptureState = .idle
+  var recordingWindow: RecordingWindow? = nil
+  var preferencesWindow: PreferencesWindow? = nil
+  var boxListener: AnyCancellable? = nil
+  var popover: NSPopover? = nil
+  var helpShown = false
+  var captureSession: CapturaCaptureSession? = nil
+  var images: [CGImage] = []
+  var outputFile: CapturaFile? = nil
+  var gifCallbackTimer = ContinuousClock.now
+  var pixelDensity: CGFloat = 1.0
+  var stopTimer: DispatchWorkItem?
+  var remoteFiles: [CapturaRemoteFile] = []
+  var captureSessionConfiguration: CaptureSessionConfiguration = CaptureSessionConfiguration()
+  
+  func applicationDidFinishLaunching(_ notification: Notification) {
+    setupStatusBar()
+    NotificationCenter.default.addObserver(
+      self,
+      selector: #selector(self.didReceiveNotification(_:)),
+      name: nil,
+      object: nil)
+    closeWindow()
+    fetchRemoteItems()
+  }
+  
+  // MARK: - Setup Functions
+  
+  
+  private func setupStatusBar() {
+    statusItem = NSStatusBar.system.statusItem(withLength: NSStatusItem.variableLength)
+    
+    if let button = statusItem.button {
+      button.image = NSImage(systemSymbolName: "rectangle.dashed.badge.record", accessibilityDescription: "Captura")

     }
     }

+    
+    statusItem.isVisible = true
+    statusItem.menu = NSMenu()
+    statusItem.menu?.delegate = self
+    
+    // Create the Popover
+    popover = NSPopover()
+    popover?.contentViewController = HelpPopoverViewController()
+    popover?.behavior = .transient
+    
+    setupMenu()
+  }

   
   

-    // MARK: - Setup Functions
+  private func setupMenu() {
+    
+    statusItem.menu?.removeAllItems()
+    
+    statusItem.menu?.addItem(NSMenuItem(title: "Record", action: #selector(CapturaAppDelegate.onClickStartRecording), keyEquivalent: ""))
+    if (remoteFiles.count > 0) {
+      statusItem.menu?.addItem(NSMenuItem.separator())
+      for remoteFile in remoteFiles {
+        let remoteFileItem = NSMenuItem(title: remoteFile.name, action: #selector(CapturaAppDelegate.onClickRemoteFile), keyEquivalent: "")
+        remoteFileItem.representedObject = remoteFile
+        statusItem.menu?.addItem(remoteFileItem)
+      }
+    }
+    statusItem.menu?.addItem(NSMenuItem.separator())
+    statusItem.menu?.addItem(NSMenuItem(title: "Open Local Folder", action: #selector(CapturaAppDelegate.onOpenFolder), keyEquivalent: ""))
+    statusItem.menu?.addItem(NSMenuItem.separator())
+    statusItem.menu?.addItem(NSMenuItem(title: "Preferences", action: #selector(CapturaAppDelegate.onOpenPreferences), keyEquivalent: ""))
+    statusItem.menu?.addItem(NSMenuItem(title: "Quit", action: #selector(CapturaAppDelegate.onQuit), keyEquivalent: ""))
+  }

   
   

+  private func closeWindow() {
+    if let window = NSApplication.shared.windows.first {
+      window.close()
+    }
+  }

   
   

-    private func setupMenu() {
-      statusItem = NSStatusBar.system.statusItem(withLength: NSStatusItem.variableLength)
-
-      statusItem.button!.image = NSImage(systemSymbolName: "rectangle.dashed.badge.record", accessibilityDescription: "Captura")
-      statusItem.isVisible = true
-      statusItem.menu = NSMenu()
-      
-      let recordItem = NSMenuItem(title: "record", action: #selector(CapturaAppDelegate.onClickStartRecording), keyEquivalent: "6")
-      recordItem.keyEquivalentModifierMask = [.command, .shift]
-      
-      statusItem.menu?.addItem(recordItem)
+  // MARK: - URL Event Handler
+  
+  func application(_ application: NSApplication, open urls: [URL]) {
+    if (CapturaSettings.shouldAllowURLAutomation) {
+      for url in urls {
+        if let action = CapturaURLDecoder.decodeParams(url: url) {
+          switch action {
+            case let .configure(config):
+              CapturaSettings.apply(config)
+            case let .record(config):
+              captureSessionConfiguration = CaptureSessionConfiguration(from: config)
+              NotificationCenter.default.post(name: .startAreaSelection, object: nil, userInfo: nil)
+          }
+        }
+      }
+    } else {
+      let alert = NSAlert()
+      alert.messageText = "URL Automation Prevented"
+              alert.informativeText = "A website or application attempted to record your screen using URL Automation. If you want to allow this, enable it in Preferences."
+              alert.alertStyle = .warning
+              alert.addButton(withTitle: "OK")
+              alert.runModal()

     }
     }

+  }
+  
+  // MARK: - UI Event Handlers

   
   

-    private func closeWindow() {
-      if let window = NSApplication.shared.windows.first {
-          window.close()
+  func menuWillOpen(_ menu: NSMenu) {
+    if captureState != .idle {
+      menu.cancelTracking()
+      if captureState == .recording {
+        NotificationCenter.default.post(name: .stopRecording, object: nil, userInfo: nil)

       }
     }
       }
     }

+  }

   
   

-    // MARK: - UI Event Handlers
-
-    @objc private func onClickStartRecording() {
-      NotificationCenter.default.post(name: .startAreaSelection, object: nil, userInfo: nil)
+  @objc private func onClickStartRecording() {
+    NotificationCenter.default.post(name: .startAreaSelection, object: nil, userInfo: nil)
+  }
+  
+  @objc private func onOpenPreferences() {
+    NSApp.activate(ignoringOtherApps: true)
+    if preferencesWindow == nil {
+      preferencesWindow =  PreferencesWindow()
+    } else {
+      preferencesWindow?.makeKeyAndOrderFront(nil)
+      preferencesWindow?.orderFrontRegardless()

     }
     }

+  }

   
   

+  @objc private func onOpenFolder() {
+    if let directory = FileManager.default.urls(for: .picturesDirectory, in: .userDomainMask).first?.appendingPathComponent("captura") {
+      NSWorkspace.shared.open(directory)
+    }
+  }

   
   

-    // MARK: - App State Event Listeners
+  @objc private func onClickRemoteFile(_ sender: NSMenuItem) {
+    if let remoteFile = sender.representedObject as? CapturaRemoteFile {
+      if let urlString = remoteFile.url {
+        if let url = URL(string: urlString) {
+          NSWorkspace.shared.open(url)
+        }
+      }
+    }
+  }
+  
+  @objc private func onQuit() {
+    NSApplication.shared.terminate(self)
+  }

   
   

-    @objc func didReceiveNotification(_ notification: Notification) {
-      switch(notification.name) {
-      case .startAreaSelection:
-        startAreaSelection()
-      case .startRecording:
-        startRecording()
-      case .stopRecording:
-        stopRecording()
-      case .finalizeRecording:
-        finalizeRecording()
-      case .reset:
-        reset()
-      default:
-        return
+  // MARK: - App State Event Listeners
+  
+  @objc func didReceiveNotification(_ notification: Notification) {
+    switch(notification.name) {
+    case .startAreaSelection:
+      startAreaSelection()
+    case .startRecording:
+      startRecording()
+    case .stopRecording:
+      stopRecording()
+    case .finalizeRecording:
+      DispatchQueue.main.async {
+        self.finalizeRecording()
+      }
+    case .reset:
+      reset()
+    case .failedToStart:
+      DispatchQueue.main.async {
+        self.failed(true)

       }
       }

-/*
-      if let data = notification.userInfo?["data"] as? String {
-          print("Data received: \(data)")
+    case .failedtoUpload:
+      DispatchQueue.main.async {
+        self.failed()

       }
       }

- */
+    case .receivedFrame:
+      if let frame = notification.userInfo?["frame"] {
+        receivedFrame(frame as! CVImageBuffer)
+      }
+    case .NSManagedObjectContextObjectsDidChange:
+      DispatchQueue.main.async {
+        self.fetchRemoteItems()
+        self.setupMenu()
+      }
+    default:
+      return

     }
     }

+  }
+  
+  
+  func startAreaSelection() {
+    helpShown = false
+    if captureState != .selectingArea {
+      captureState = .selectingArea
+      if let button = statusItem.button {
+        let rectInWindow = button.convert(button.bounds, to: nil)
+        let rectInScreen = button.window?.convertToScreen(rectInWindow)
+        NSApp.activate(ignoringOtherApps: true)
+        recordingWindow = RecordingWindow(captureSessionConfiguration, rectInScreen)
+        recordingWindow?.makeKeyAndOrderFront(nil)
+        recordingWindow?.orderFrontRegardless()
+        boxListener = recordingWindow?.recordingContentView.$box
+          .debounce(for: .seconds(0.3), scheduler: RunLoop.main)
+          .sink { newValue in
+            if newValue != nil {
+              self.updateImage()
+              if !self.helpShown {
+                self.helpShown = true
+                self.showPopoverWithMessage("Click here when you're ready to record.")
+              }
+            }
+          }
+      }
+    }
+  }
+  
+  func startRecording() {
+    captureState = .recording
+    updateImage()
+    outputFile = nil
+    images = [];
+    pixelDensity = recordingWindow?.pixelDensity ?? 1.0
+    recordingWindow?.recordingContentView.startRecording()
+    if let box = recordingWindow?.recordingContentView.box {
+      if let screen = recordingWindow?.screen {
+        captureSession = CapturaCaptureSession(screen, box: box)
+        
+        if let captureSession {

 
 

+          stopTimer = DispatchWorkItem {
+            self.stopRecording()
+          }
+          DispatchQueue.main.asyncAfter(deadline: .now() + Double(captureSessionConfiguration.maxLength), execute: stopTimer!)
+          
+          outputFile = CapturaFile()
+          if captureSessionConfiguration.shouldSaveMp4 {
+            captureSession.startRecording(to: outputFile!.mp4URL)
+          } else {
+            captureSession.startRunning()
+          }
+          return
+        }
+      }
+    }
+    NotificationCenter.default.post(name: .failedToStart, object: nil, userInfo: nil)
+  }

   
   

-    @objc func startAreaSelection() {
-      if captureState != .selectingArea {
-        captureState = .selectingArea
-        recordingWindow = RecordingWindow()
-        print("Recording")
+  func stopRecording() {
+    captureState = .uploading
+    updateImage()
+    stop()
+    
+    Task.detached {
+      if self.captureSessionConfiguration.shouldSaveGif {
+        if let outputFile = self.outputFile {
+          await GifRenderer.render(self.images, at: self.captureSessionConfiguration.frameRate, to: outputFile.gifURL)
+        }
+      }
+      let wasSuccessful = await self.uploadOrCopy()
+      if wasSuccessful {
+        NotificationCenter.default.post(name: .finalizeRecording, object: nil, userInfo: nil)
+      } else {
+        NotificationCenter.default.post(name: .failedtoUpload, object: nil, userInfo: nil)

       }
     }
       }
     }

+  }

   
   

-    func startRecording() {
-      captureState = .recording
+  func finalizeRecording() {
+    captureState = .uploaded
+    updateImage()
+    DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) {
+      NotificationCenter.default.post(name: .reset, object: nil, userInfo: nil)

     }
     }

+  }
+  
+  func reset() {
+    captureState = .idle
+    updateImage()
+    captureSessionConfiguration = CaptureSessionConfiguration()
+    stop()
+  }

   
   

-    func stopRecording() {
-      captureState = .uploading
+  func receivedFrame(_ frame: CVImageBuffer) {
+    let now = ContinuousClock.now
+    
+    if now - gifCallbackTimer > .nanoseconds(1_000_000_000 / UInt64(captureSessionConfiguration.frameRate)) {
+      gifCallbackTimer = now
+      DispatchQueue.main.async {
+        if let cgImage = frame.cgImage?.resize(by: self.pixelDensity) {
+          self.images.append(cgImage)
+        }
+      }

     }
     }

+  }

   
   

-    func finalizeRecording() {
-      captureState = .uploaded
+  func failed(_ requestPermission: Bool = false) {
+    captureState = .error
+    updateImage()
+    if requestPermission {
+      requestPermissionToRecord()
+    }
+    stop()
+    DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) {
+      NotificationCenter.default.post(name: .reset, object: nil, userInfo: nil)
+    }
+  }
+  
+  // MARK: - CoreData
+  
+  private func fetchRemoteItems() {
+    let viewContext = PersistenceController.shared.container.viewContext
+    let fetchRequest = NSFetchRequest<CapturaRemoteFile>(entityName: "CapturaRemoteFile")
+    fetchRequest.fetchLimit = 5
+    fetchRequest.sortDescriptors = [NSSortDescriptor(key: "timestamp", ascending: false)]
+    
+    let results = try? viewContext.fetch(fetchRequest)
+    remoteFiles = results ?? []
+  }
+  
+  // MARK: - Presentation Helpers
+  
+  
+  private func requestPermissionToRecord() {
+    showPopoverWithMessage("Please grant Captura permission to record")
+    if let url = URL(string: "x-apple.systempreferences:com.apple.preference.security?Privacy_ScreenRecording") {
+      NSWorkspace.shared.open(url)
+    }
+  }
+  
+  private func showPopoverWithMessage(_ message: String) {
+    if let button = statusItem.button {
+      (self.popover?.contentViewController as? HelpPopoverViewController)?.updateLabel(message)
+      self.popover?.show(relativeTo: button.bounds, of: button, preferredEdge: NSRectEdge.minY)
+      DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) {
+        self.popover?.performClose(nil)
+      }

     }
     }

+  }

   
   

-    func reset() {
-      captureState = .idle
+  private func updateImage() {
+    if let button = statusItem.button {
+      let image: String = switch captureState {
+      case .idle:
+        "rectangle.dashed.badge.record"
+      case .selectingArea:
+        "circle.rectangle.dashed"
+      case .recording:
+        "checkmark.rectangle"
+      case .uploading:
+        "dock.arrow.up.rectangle"
+      case .uploaded:
+        "checkmark.rectangle.fill"
+      case .error:
+        "xmark.rectangle.fill"
+      }
+      button.image = NSImage(systemSymbolName: image, accessibilityDescription: "Captura")
+    }
+  }
+  
+  private func stop() {
+    stopTimer?.cancel()
+    captureSession?.stopRunning()
+    captureSession = nil
+    boxListener?.cancel()
+    recordingWindow?.close()
+    recordingWindow = nil
+  }
+  
+  private func uploadOrCopy() async -> Bool {
+    if captureSessionConfiguration.shouldUseBackend {
+      let result = await uploadToBackend()
+      if result && !captureSessionConfiguration.shouldKeepLocalFiles {
+        deleteLocalFiles()
+      }
+      return result
+    } else {
+      copyLocalToClipboard()
+      return true
+    }
+  }
+  
+  private func copyLocalToClipboard() {
+    let fileType: NSPasteboard.PasteboardType = .init(rawValue: captureSessionConfiguration.shouldSaveGif ? "com.compuserve.gif" : "public.mpeg-4")
+    if let url = captureSessionConfiguration.shouldSaveGif ? outputFile?.gifURL : outputFile?.mp4URL {
+      if let data = try? Data(contentsOf: url) {
+        let pasteboard = NSPasteboard.general
+        pasteboard.declareTypes([fileType], owner: nil)
+        pasteboard.setData(data, forType: fileType)
+      }
+    }
+  }
+  
+  private func uploadToBackend() async -> Bool {
+    let contentType = captureSessionConfiguration.shouldUploadGif ? "image/gif" : "video/mp4"
+    if let url = captureSessionConfiguration.shouldUploadGif ? outputFile?.gifURL : outputFile?.mp4URL {
+      if let data = try? Data(contentsOf: url) {
+        if let remoteUrl = captureSessionConfiguration.backend {
+          var request = URLRequest(url: remoteUrl)
+          request.httpMethod = "POST"
+          request.httpBody = data
+          request.setValue(contentType, forHTTPHeaderField: "Content-Type")
+          request.setValue("Captura/1.0", forHTTPHeaderField: "User-Agent")
+          
+          do {
+            let (data, response) = try await URLSession.shared.data(for: request)
+            
+            if let httpResponse = response as? HTTPURLResponse {
+              if httpResponse.statusCode == 201 {
+                let answer = try JSONDecoder().decode(BackendResponse.self, from: data)
+                createRemoteFile(answer.url)
+                return true
+              }
+            }
+          } catch {}
+        }
+      }
+    }
+    return false
+  }
+  
+  private func createRemoteFile(_ url: URL) {
+    let viewContext = PersistenceController.shared.container.viewContext
+    let remoteFile = CapturaRemoteFile(context: viewContext)
+    remoteFile.url = url.absoluteString
+    remoteFile.timestamp = Date()
+    try? viewContext.save()
+    let pasteboard = NSPasteboard.general
+    pasteboard.declareTypes([.URL], owner: nil)
+    pasteboard.setString(url.absoluteString, forType: .string)
+  }
+  
+  private func deleteLocalFiles() {
+    if captureSessionConfiguration.shouldSaveGif {
+      if let url = outputFile?.gifURL {
+          try? FileManager.default.removeItem(at: url)
+      }
+    }
+    if captureSessionConfiguration.shouldSaveMp4 {
+      if let url = outputFile?.mp4URL {
+        try? FileManager.default.removeItem(at: url)
+      }

     }
     }

+  }

 }
 }