Блог

Я создал пользовательскую камеру, и с ее помощью я хочу записать видео и отправить его следующему VC.

Я попытался сделать это следующим образом, но таким образом видео сохраняется в галерее. Я пока не хочу, чтобы это произошло.

Итак, мой вопрос в том, как мне снимать видео только с помощью пользовательской камеры, не сохраняя его?

   func setupSession() -> Bool {

    captureSession.sessionPreset = AVCaptureSession.Preset.high

    // Setup Camera
    let camera = AVCaptureDevice.default(for: AVMediaType.video)!

    do {
    
        let input = try AVCaptureDeviceInput(device: camera)
    
        if captureSession.canAddInput(input) {
            captureSession.addInput(input)
            activeInput = input
        }
    } catch {
        print("Error setting device video input: (error)")
        return false
    }

    // Setup Microphone
    let microphone = AVCaptureDevice.default(for: AVMediaType.audio)!

    do {
        let micInput = try AVCaptureDeviceInput(device: microphone)
        if captureSession.canAddInput(micInput) {
            captureSession.addInput(micInput)
        }
    } catch {
        print("Error setting device audio input: (error)")
        return false
    }


    // Movie output
    if captureSession.canAddOutput(movieOutput) {
        captureSession.addOutput(movieOutput)
    }

    return true
}

func setupCaptureMode(_ mode: Int) {
    // Video Mode

}

//MARK:- Camera Session
func startSession() {

    if !captureSession.isRunning {
        videoQueue().async {
            self.captureSession.startRunning()
        }
    }
}

func stopSession() {
    if captureSession.isRunning {
        videoQueue().async {
            self.captureSession.stopRunning()
        }
    }
}

func videoQueue() -> DispatchQueue {
    return Dispatch.DispatchQueue.main
}

func currentVideoOrientation() -> AVCaptureVideoOrientation {
    var orientation: AVCaptureVideoOrientation

    switch UIDevice.current.orientation {
        case .portrait:
            orientation = AVCaptureVideoOrientation.portrait
        case .landscapeRight:
            orientation = AVCaptureVideoOrientation.landscapeLeft
        case .portraitUpsideDown:
            orientation = AVCaptureVideoOrientation.portraitUpsideDown
        default:
             orientation = AVCaptureVideoOrientation.landscapeRight
     }

     return orientation
 }


@IBAction func startCapture(_ sender: Any) {
    if cameraButton.titleLabel?.text == "record" {
        cameraButton.setTitle("Stop Recording", for: .normal)
        startRecording()
        runTimer()
        
    }
    else {
        
        stopRecording()
        timer.invalidate()
        cameraButton.setTitle("record", for: .normal)
    }
}

func tempURL() -> URL? {
    let directory = NSTemporaryDirectory() as NSString

    if directory != "" {
        let path = directory.appendingPathComponent(NSUUID().uuidString   ".mp4")
        return URL(fileURLWithPath: path)
    }

    return nil
}

func getPHAssetfromURL(url:URL,onCompleted:@escaping (_ phAsset:PHAsset)->Void){
    var phAsset:PHAsset?
    PHPhotoLibrary.shared().performChanges({
        PHAssetChangeRequest.creationRequestForAssetFromVideo(atFileURL: url)
    }) { saved, error in
        if saved {
            let fetchOptions = PHFetchOptions()
            fetchOptions.sortDescriptors = [NSSortDescriptor(key: "creationDate", ascending: true)]
            phAsset = PHAsset.fetchAssets(with: .video, options: fetchOptions).lastObject
            onCompleted(phAsset!)
            
        }
    }
}

func startRecording() {

    if movieOutput.isRecording == false {
    
        let connection = movieOutput.connection(with: AVMediaType.video)
    
        if (connection?.isVideoOrientationSupported)! {
            connection?.videoOrientation = currentVideoOrientation()
        }
    
        if (connection?.isVideoStabilizationSupported)! {
            connection?.preferredVideoStabilizationMode = AVCaptureVideoStabilizationMode.auto
        }
    
        let device = activeInput.device
    
        if (device.isSmoothAutoFocusSupported) {
        
            do {
                try device.lockForConfiguration()
                device.isSmoothAutoFocusEnabled = false
                device.unlockForConfiguration()
            } catch {
               print("Error setting configuration: (error)")
            }
        
        }
  
        outputURL = tempURL()
        movieOutput.startRecording(to: outputURL, recordingDelegate: self)
    
        }
        else {
            stopRecording()
        }
   }

 func stopRecording() {

   if movieOutput.isRecording == true {
       movieOutput.stopRecording()
    }
}

func capture(_ captureOutput: AVCaptureFileOutput!, didStartRecordingToOutputFileAt fileURL: URL!, fromConnections connections: [Any]!) {
    

}

func fileOutput(_ output: AVCaptureFileOutput, didFinishRecordingTo outputFileURL: URL, from connections: [AVCaptureConnection], error: Error?) {

    if (error != nil) {
    
        print("Error recording movie: (error!.localizedDescription)")
    
    } else {
    
        let videoRecorded = outputURL! as URL
        
        
        let url = videoRecorded

        getPHAssetfromURL(url: url) {(phAsset) in
            DispatchQueue.main.async {
                //let vc = segue.destination as! VideoPlaybackViewController
                
                let vc : VideoPlaybackViewController = UIStoryboard(name: "Main", bundle: nil).instantiateViewController(withIdentifier: "DisplayVC") as! VideoPlaybackViewController
                
                //let vc = VideoPlaybackViewController()
                        vc.videoTrimmerDelegate = self
                        vc.phAsset = phAsset
            vc.videoURL = url
                  vc.assetURL = url.path
                
                self.present(vc, animated: true, completion: nil)
                
            }
        }
    
    }

}