composition.swift

extension ViewController {

    func creatingAnAssetObject(asset: AVAsset) {
        let anAsset = asset

        // anAsset.cancelLoading()
        let keys = ["duration"]
        anAsset.loadValuesAsynchronously(forKeys: keys) {

            let durationSeconds = anAsset.duration.seconds

            var error: NSError?
            let status = anAsset.statusOfValue(forKey: "duration", error: &error)
            switch status {
            case .loading:
                print("loading")
            case .loaded:
                // self.updateuserInterfaceForDuation()
                print("loaded")
            case .failed:
                print(error?.localizedDescription ?? "-")
                // self.reportError(error: error, forAsset: asset)
                print("failed")
            case .cancelled:
                print("cancelled")
            case .unknown:
                print("unknown")
            @unknown default:
                print("@unknown default")
            }

            let imageGenerator = AVAssetImageGenerator(asset: anAsset)

            if anAsset.tracks(withMediaType: .video).count > 0 {
                let midPoint = CMTime(seconds: durationSeconds / 2.0, preferredTimescale: 699)

                var actualTime: CMTime = .zero
                do {
                    let halfWayImage = try imageGenerator.copyCGImage(at: midPoint, actualTime: &actualTime)
                    let actualTimeString = CMTimeCopyDescription(allocator: nil, time: actualTime)
                    let requestedTimeString = CMTimeCopyDescription(allocator: nil, time: midPoint)
                    print("Got halfWayImage: Asked for \(requestedTimeString!), got \(actualTimeString)")

                    //
                    DispatchQueue.main.async {
                        self.imageView.image = UIImage(cgImage: halfWayImage, scale: 1.0, orientation: UIImage.Orientation.right)
                    }
                } catch {
                    print(error.localizedDescription)
                }
            }

            let durationSecondss = CMTimeGetSeconds(anAsset.duration)
            let firstThird = CMTimeMakeWithSeconds(durationSecondss / 3.0, preferredTimescale: 600)
            let secondsThird = CMTimeMakeWithSeconds(durationSecondss * 2.0 / 3.0, preferredTimescale: 600)
            let end = CMTimeMakeWithSeconds(durationSecondss, preferredTimescale: 600)

            let times: [NSValue] = [CMTime.zero, firstThird, secondsThird, end].map { NSValue(time: $0) }

            imageGenerator.generateCGImagesAsynchronously(forTimes: times, completionHandler: { (requestedTime, image, actualTime, result, error) in
                if let requested = CMTimeCopyDescription(allocator: nil, time: requestedTime) {
                    print("requested: ", requested)
                }

                if let actual = CMTimeCopyDescription(allocator: nil, time: actualTime) {
                    print("actual", actual)
                }

                switch result {
                case .succeeded:
                    DispatchQueue.main.async {
                        if let image = image {
                            self.images.append(UIImage(cgImage: image, scale: 1.0, orientation: UIImage.Orientation.right))
                        }

                        self.imageView.animationImages = self.images
                        self.imageView.startAnimating()
                    }

                    print("Succeeded")
                case .cancelled:
                    print("Cancelled")
                case .failed:
                    print("Failed with error: \(error?.localizedDescription ?? "")")
                @unknown default:
                    fatalError()
                }
            })
        }
    }

    func trimVideo() {
        let compatiblePresets = AVAssetExportSession.exportPresets(compatibleWith: asset)
        print(#function)

        if compatiblePresets.contains(AVAssetExportPresetHighestQuality) {

            let exportSession = AVAssetExportSession(asset: asset, presetName: AVAssetExportPresetHighestQuality)
            let path = NSTemporaryDirectory() + "/" + UUID().uuidString + ".mov"
            exportSession?.outputURL = URL(fileURLWithPath: path)
            exportSession?.outputFileType = AVFileType.mp4

            let start = CMTimeMakeWithSeconds(1.0, preferredTimescale: 600)
            let duration = CMTimeMakeWithSeconds(3.0, preferredTimescale: 600)
            let range = CMTimeRangeMake(start: start, duration: duration)
            exportSession?.timeRange = range

            guard let outputURL = exportSession?.outputURL else {
                fatalError()
            }
            exportSession?.exportAsynchronously {
                print("Export Completed...")
                guard let status = exportSession?.status else { return }
                switch status {
                case .completed:
                    print("completed")
                case .exporting:
                    print("exporting")
                case .failed:
                    print("failed: \(exportSession?.error?.localizedDescription ?? ".")")
                case .cancelled:
                    print("cancelled")
                case .waiting:
                    print("waiting: \(exportSession?.progress ?? 0)")
                case .unknown:
                    print("unknown")
                @unknown default:
                    fatalError("unknown default")
                }

                DispatchQueue.main.async {
                    if exportSession?.status == .completed {
                        PHPhotoLibrary.shared().performChanges({
                            PHAssetChangeRequest.creationRequestForAssetFromVideo(atFileURL: outputURL)
                        }) { saved, error in
                            if saved {
                                let alertController = UIAlertController(title: "Your video was successfully saved", message: nil, preferredStyle: .alert)
                                let defaultAction = UIAlertAction(title: "OK", style: .default, handler: nil)
                                alertController.addAction(defaultAction)
                                self.present(alertController, animated: true, completion: nil)
                            }
                        }
                    }
                }
            }
        }
    }
}