+ }
+
+ @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)
+ }
+ }
+
+ @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)
+ }
+
+ // 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)
+ }
+ case .failedtoUpload:
+ DispatchQueue.main.async {
+ self.failed()
+ }
+ case .receivedFrame:
+ if let frame = notification.userInfo?["frame"] {
+ receivedFrame(frame as! CVImageBuffer)
+ }
+ case .setConfiguration:
+ DispatchQueue.main.async {
+ if let userInfo = notification.userInfo {
+ if let config = userInfo["config"] as? ConfigureAction {
+ self.setConfiguration(config)
+ }
+ }
+ }
+ case .reloadConfiguration:
+ reloadConfiguration()
+ case .setCaptureSessionConfiguration:
+ if let userInfo = notification.userInfo {
+ if let config = userInfo["config"] as? RecordAction {
+ setCaptureSessionConfiguration(config)
+ }
+ }
+ case .NSManagedObjectContextObjectsDidChange:
+ DispatchQueue.main.async {
+ self.fetchRemoteItems()
+ self.setupMenu()
+ }
+ default:
+ return
+ }
+ }
+
+ func startAreaSelection() {
+ helpShown = false
+ if captureState != .selectingArea {
+ captureState = .selectingArea
+ updateImage()
+ 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)
+ }
+
+ 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 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 receivedFrame(_ frame: CVImageBuffer) {
+ let now = ContinuousClock.now
+
+ if now - gifCallbackTimer
+ > .nanoseconds(1_000_000_000 / UInt64(captureSessionConfiguration.frameRate))
+ {
+ gifCallbackTimer = now
+ DispatchQueue.main.async {
+ if var cgImage = frame.cgImage {
+ if self.pixelDensity > 1 {
+ cgImage = cgImage.resize(by: self.pixelDensity) ?? cgImage
+ }
+ self.images.append(cgImage)
+ }
+ }
+ }
+ }
+
+ 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)
+ }
+ }
+
+ func setConfiguration(_ config: ConfigureAction) {
+ CapturaSettings.apply(config)
+ }
+
+ func reloadConfiguration() {
+ self.captureSessionConfiguration = CaptureSessionConfiguration()
+ }
+
+ func setCaptureSessionConfiguration(_ config: RecordAction) {
+ self.captureSessionConfiguration = CaptureSessionConfiguration(from: config)
+ }
+
+ // 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 ?? []
+ }
git.r.bdr.sh / rbdr / captura / blobdiff