Kulexiu/KulexiuForStudent/KulexiuForStudent/Common/Base/KSVideoRecordManager.m

//
//  KSVideoRecordManager.m
//  TeacherDaya
//
//  Created by Kyle on 2021/8/16.
//  Copyright © 2021 DayaMusic. All rights reserved.
//

#import "KSVideoRecordManager.h"
#import <AVFoundation/AVFoundation.h>
#import <AssetsLibrary/AssetsLibrary.h>
#import "TZImageManager.h"
#import "KSVideoEditor.h"
#import "KSUploadManager.h"

@interface KSVideoRecordManager ()<AVCaptureFileOutputRecordingDelegate>

//会话 负责输入和输出设备之间的数据传递
@property (nonatomic, strong) AVCaptureSession *captureSession;

@property (nonatomic, strong) AVCaptureDeviceInput *videoCaptureDeviceInput;

@property (nonatomic, strong) AVCaptureDeviceInput *audioCaptureDeviceInput;

// 视频流输出
@property (nonatomic, strong) AVCaptureMovieFileOutput *captureMovieFileOutput;

// 相机拍摄预览图层
@property (nonatomic, strong) AVCaptureVideoPreviewLayer *captureVideoPreviewLayer;

@property (nonatomic, strong) NSURL *videoFileURL;

@property (nonatomic, assign) BOOL recordEnable;

// 是否正在录制
@property (nonatomic, assign) BOOL isRecording;

@property (nonatomic, copy) KSVideoRecordCallback callback;

@property (nonatomic, strong) PHAsset *videoAsset;

@property (nonatomic, strong) NSString *presentName;

@property (strong, nonatomic) MBProgressHUD *HUD;

@property (nonatomic, strong) dispatch_queue_t videoRecordQueue;

@property (nonatomic, assign) BOOL isChangeSession;

@end

@implementation KSVideoRecordManager

- (instancetype)initSessionRecordCallback:(KSVideoRecordCallback)callback {
    self = [super init];
    if (self) {
        if (callback) {
            self.callback = callback;
        }
    }
    return self;
}

- (void)setIgnoreAudio:(BOOL)ignoreAudio {
    _ignoreAudio = ignoreAudio;
    [self resetSession];
}

- (BOOL)getSessionStatusisActive {
    if (self.captureSession && self.captureSession.isRunning) {
        return YES;
    }
    else  {
        return NO;
    }
}

- (void)configSessiondisplayInView:(UIView *)containerView {
    
    _captureSession = [[AVCaptureSession alloc] init];

    // 设置YES 播放web伴奏会导致打断
    _captureSession.automaticallyConfiguresApplicationAudioSession = NO;
    // 初始化会话对象
    if ([_captureSession canSetSessionPreset:AVCaptureSessionPresetInputPriority]) {
        _captureSession.sessionPreset = AVCaptureSessionPresetInputPriority;
    }
    NSError *error = nil;
    
    // 获取视频输出对象
    AVCaptureDevice *videoCaptureDevice = [self cameraDeviceWithPosition:(AVCaptureDevicePositionFront)];
    if (!videoCaptureDevice) {
        if (self.callback) {
            self.callback(NO, @"获取摄像头失败!");
        }
    }
    _videoCaptureDeviceInput = [[AVCaptureDeviceInput alloc] initWithDevice:videoCaptureDevice error:&error];
    if (error) {
        if (self.callback) {
            self.callback(NO, @"获取视频设备输入出错！");
        }
        return;
    }
    if ([_captureSession canAddInput:_videoCaptureDeviceInput]) {
        [_captureSession addInput:_videoCaptureDeviceInput];
        // 设置帧率
        [self setMaxFrameRate:10 forDevice:_videoCaptureDeviceInput.device];
    }
    else {
        if (self.callback) {
            self.callback(NO, @"摄像头被占用！");
        }
    }
    if (_ignoreAudio == NO) {
        // 获取音频输入对象
        AVCaptureDevice *audioCaptureDevice = [AVCaptureDevice defaultDeviceWithMediaType:AVMediaTypeAudio];
        _audioCaptureDeviceInput = [[AVCaptureDeviceInput alloc] initWithDevice:audioCaptureDevice error:&error];
        if (error) {
            if (self.callback) {
                self.callback(NO, @"获取音频设备输入出错！");
            }
            return;
        }
        //将设备输入添加到会话中
        if ([_captureSession canAddInput:_audioCaptureDeviceInput]) {
            [_captureSession addInput:_audioCaptureDeviceInput];
        }
        else {
            if (self.callback) {
                self.callback(NO, @"麦克风被占用！");
            }
        }
    }
    
    // 初始化设备输出对象
    _captureMovieFileOutput = [[AVCaptureMovieFileOutput alloc] init];
    _captureMovieFileOutput.movieFragmentInterval = kCMTimeInvalid;
    
    //将设备输出添加到会话中
    if ([_captureSession canAddOutput:_captureMovieFileOutput]) {
        AVCaptureConnection *captureConnection = [_captureMovieFileOutput connectionWithMediaType:AVMediaTypeVideo];
        //防抖功能
        if ([captureConnection isVideoStabilizationSupported]) {
            captureConnection.preferredVideoStabilizationMode = AVCaptureVideoStabilizationModeAuto;
        }
        [_captureSession addOutput:_captureMovieFileOutput];
    }
    
    //创建视频预览图层
    _captureVideoPreviewLayer = [[AVCaptureVideoPreviewLayer alloc] initWithSession:_captureSession];
    containerView.layer.masksToBounds = YES;
    _captureVideoPreviewLayer.frame = containerView.bounds;
    _captureVideoPreviewLayer.videoGravity = AVLayerVideoGravityResizeAspectFill;
    _captureVideoPreviewLayer.connection.videoOrientation = AVCaptureVideoOrientationLandscapeRight;
    [containerView.layer addSublayer:_captureVideoPreviewLayer];
    
    // 一定要在添加了 input 和 output之后～
    AVCaptureConnection *captureConnection = [_captureMovieFileOutput connectionWithMediaType:AVMediaTypeVideo];
    captureConnection.videoOrientation = AVCaptureVideoOrientationLandscapeRight;
    [self startSession];
}

- (void)removeDisplay {
    [self stopSession];
    if (_captureVideoPreviewLayer) {
        [_captureVideoPreviewLayer removeFromSuperlayer];
    }
}

- (void)resetSession {
    if ([_captureSession isRunning]) {
        if (_ignoreAudio == NO) {
            [_captureSession beginConfiguration];
            self.isChangeSession = YES;
            if (_audioCaptureDeviceInput) {
                [_captureSession removeInput:_audioCaptureDeviceInput];
            }
            
            NSError *error = nil;
            // 获取音频输入对象
            AVCaptureDevice *audioCaptureDevice = [AVCaptureDevice defaultDeviceWithMediaType:AVMediaTypeAudio];
            _audioCaptureDeviceInput = [[AVCaptureDeviceInput alloc] initWithDevice:audioCaptureDevice error:&error];
            if (error) {
                if (self.callback) {
                    self.callback(NO, @"获取音频设备输入出错！");
                }
                return;
            }
            if ([_captureSession canAddInput:_audioCaptureDeviceInput]) {
                [_captureSession addInput:_audioCaptureDeviceInput];
            }
            else {
                if (self.callback) {
                    self.callback(NO, @"麦克风被占用！");
                }
            }
            
            [_captureSession commitConfiguration];
            self.isChangeSession = NO;
        }
    }
    else {
        [self startSession];
    }
}


- (void)startSession {
    @weakObj(self);
    dispatch_async(self.videoRecordQueue, ^{
        @strongObj(self);
        if (!self.captureSession.running) {
            [self.captureSession startRunning];
        }
    });
}

- (void)stopSession {
    if (_captureSession && _isChangeSession == NO) {
        @weakObj(self);
        dispatch_async(self.videoRecordQueue, ^{
            @strongObj(self);
            if (self.captureSession.running) {
                [self.captureSession stopRunning];
            }
        });
        self.captureSession = nil;
    }
}

- (void)startRecord {
    if (_captureMovieFileOutput) {
        [self clearVideoFile];

        // 开始录制
        [self.captureMovieFileOutput startRecordingToOutputFileURL:[NSURL fileURLWithPath:[self getRecordFilePath]] recordingDelegate:self];
    }
    
}

- (void)stopRecord {
    if (_captureMovieFileOutput) {
        [self.captureMovieFileOutput stopRecording];
    }
    [self resetSession];
}


- (void)removeVideoWithPath:(NSString *)videoUrl {
    NSFileManager *fileMamager = [NSFileManager defaultManager];
    if ([fileMamager fileExistsAtPath:videoUrl]) {
        [fileMamager removeItemAtPath:videoUrl error:nil];
    }
}

/**取得指定位置的摄像头*/
- (AVCaptureDevice *)cameraDeviceWithPosition:(AVCaptureDevicePosition)position {
    NSArray *cameras = [AVCaptureDevice devicesWithMediaType:AVMediaTypeVideo];
    for (AVCaptureDevice *camera in cameras) {
        if ([camera position] == position) {
            return camera;
        }
    }
    return nil;
}
// 切换摄像头
- (void)swapCameras {
    // Assume the session is already running
    NSArray *inputs =self.captureSession.inputs;
    for (AVCaptureDeviceInput *input in inputs ) {
        AVCaptureDevice *device = input.device;
        if ( [device hasMediaType:AVMediaTypeVideo] ) {
            AVCaptureDevicePosition position = device.position;
            AVCaptureDevice *newCamera =nil;
            AVCaptureDeviceInput *newInput =nil;
            
            if (position ==AVCaptureDevicePositionFront)
                newCamera = [self cameraDeviceWithPosition:AVCaptureDevicePositionBack];
            else
                newCamera = [self cameraDeviceWithPosition:AVCaptureDevicePositionFront];
            newInput = [AVCaptureDeviceInput deviceInputWithDevice:newCamera error:nil];
            
            // beginConfiguration ensures that pending changes are not applied immediately
            [self.captureSession beginConfiguration];
            
            [self.captureSession removeInput:input];
            [self.captureSession addInput:newInput];
            
            // Changes take effect once the outermost commitConfiguration is invoked.
            [self.captureSession commitConfiguration];
            break;
        }
    }
}

#pragma mark --------  AVCaptureFileOutputRecordingDelegate  ----------
- (void)captureOutput:(AVCaptureFileOutput *)captureOutput didStartRecordingToOutputFileAtURL:(NSURL *)fileURL fromConnections:(NSArray *)connections {
    NSLog(@"开始录制");
    _isRecording = YES;
}

- (void)captureOutput:(AVCaptureFileOutput *)captureOutput didFinishRecordingToOutputFileAtURL:(NSURL *)outputFileURL fromConnections:(NSArray *)connections error:(NSError *)error {
    if (error) {
        NSLog(@"error desc :%@", error.description);
    }
    NSLog(@"录制结束");
    _isRecording = NO;
    @weakObj(self);
    dispatch_async(self.videoRecordQueue, ^{
        @strongObj(self);
        if (self.captureSession.running) {
            [self.captureSession stopRunning];
        }
    });

    // 暂时存储文件地址
    self.videoFileURL = outputFileURL;
    [self resetSession];
    self.skipSaveRecord = NO;
    if (self.callback) {
        self.callback(YES, @"");
    }
}

- (void)saveVideoCallback:(KSVideoRecordCallback)callback {
    // 保存文件
    if (self.skipSaveRecord == NO) {
        if (_ignoreAudio == NO) {
            [self saveVideoToAsset:self.videoFileURL callback:^(BOOL isSuccess, NSString * _Nullable message) {
                callback(isSuccess, message);
            }];
        }
        else {
            [self addBackgroundMuisc:self.audioUrl callback:^(BOOL isSuccess, NSString * _Nullable message) {
                callback(isSuccess, message);
            }];
        }
    }
}

// 生成文件 合并音轨
- (void)addBackgroundMuisc:(NSURL *)audioUrl callback:(KSVideoRecordCallback)callback {
    AVURLAsset* audioAsset =[AVURLAsset URLAssetWithURL:audioUrl options:nil];
    
    CMTime audioDuration = audioAsset.duration;
    
    float audioDurationSeconds = CMTimeGetSeconds(audioDuration);
    
    NSLog(@"%f",audioDurationSeconds);
    [KSVideoEditor addBackgroundMiusicWithVideoUrlStr:self.videoFileURL audioUrl:audioUrl bgAudioUrl:self.bgAudioUrl start:0 end:audioDurationSeconds isOriginalSound:NO oriVolume:0 newVolume:100 completion:^(NSString * _Nonnull outPath, BOOL isSuccess) {
        if (isSuccess) {
            [self saveVideoToAsset:[NSURL fileURLWithPath:outPath] callback:^(BOOL isSuccess, NSString * _Nullable message) {
                if (callback) {
                    callback(isSuccess, message);
                }
            }];
        }
        else {
            
        }
    }];
}



// 保存到相册
- (void)saveVideoToAsset:(NSURL *)videoUrl callback:(KSVideoRecordCallback)callback {
    [LOADING_MANAGER MBShowInWindow:@"视频处理中..."];
    [[TZImageManager manager] saveVideoWithUrl:videoUrl completion:^(PHAsset *asset, NSError *error) {
        if (!error) {
            self.videoAsset = asset;
            dispatch_main_async_safe(^{
                [LOADING_MANAGER removeHUD];
                if (callback) {
                    callback(YES, @"已保存到相册");
                }
                else if (self.callback) {
                    self.callback(YES, @"已保存到相册");
                }
                // 重置
                [self resetSession];
                
            });
        }
        else {
            dispatch_main_async_safe(^{
                [LOADING_MANAGER removeHUD];
                if (callback) {
                    callback(NO, @"保存视频错误");
                }
                else if (self.callback) {
                    self.callback(NO, @"保存视频错误");
                }
                // 重置
                [self resetSession];
                
            });
        }
    }];
}

- (void)clearVideoFile {
    if (_isRecording) {
        return;
    }
    NSURL *fileUrl = [NSURL fileURLWithPath:[self getRecordFilePath]];
    if (fileUrl) {
        [self removeVideoWithPath:fileUrl.path];
    }
    self.videoFileURL = nil;
}

// 上传视频
- (void)uploadRecordVideoSuccess:(void (^)(NSString * _Nonnull))success failure:(void (^)(NSString * _Nonnull))faliure {
    if (self.videoAsset) {
        
        [[TZImageManager manager] getVideoOutputPathWithAsset:self.videoAsset presetName:self.presentName success:^(NSString *outputPath) {
            
            NSLog(@"视频导出到本地完成,沙盒路径为:%@",outputPath);
            NSData *outputData = [NSData dataWithContentsOfURL:[NSURL fileURLWithPath:outputPath]]; //压缩后的视频
            NSLog(@"导出后的视频：%@",[NSString stringWithFormat:@"%.2fM",(CGFloat)outputData.length/(1024*1024)]);
            // 上传
            dispatch_main_async_safe(^{
                [self sendVideoActionWith:outputPath success:success failure:faliure];
            });
            
        } failure:^(NSString *errorMessage, NSError *error) {
            dispatch_main_async_safe(^{
                faliure(@"视频导出失败");
            });
            NSLog(@"视频导出失败:%@,error:%@",errorMessage, error);
        }];
    }
    else {
        faliure(@"未找到视频资源");
    }
}


- (void)sendVideoActionWith:(NSString *)fileUrl success:(void (^)(NSString * _Nonnull))success failure:(void (^)(NSString * _Nonnull))faliure {
    [self hudTipWillShow:YES];
    NSData *fileData = [NSData dataWithContentsOfURL:[NSURL fileURLWithPath:fileUrl]];
    NSString *suffix = [NSString stringWithFormat:@".%@",[fileUrl pathExtension]];
    [[KSUploadManager shareInstance] configBucketName:@"daya"];
    [[KSUploadManager shareInstance] videoUpload:fileData fileName:@"video" fileSuffix:suffix progress:^(int64_t bytesWritten, int64_t totalBytes) {
        // 显示进度
        if (self.HUD) {
            self.HUD.progress = bytesWritten / totalBytes;// progress是回调进度
        }
    } successCallback:^(NSMutableArray * _Nonnull fileUrlArray) {
        [self hudTipWillShow:NO];
        NSString *fileUrl = [fileUrlArray lastObject];
        success(fileUrl);
        
    } faliure:^(NSError * _Nullable error, NSString * _Nullable descMessaeg) {
        [self hudTipWillShow:NO];
        faliure(descMessaeg);
    }];
}

- (void)hudTipWillShow:(BOOL)willShow{
    if (willShow) {
        
        UIWindow *keyWindow = [NSObject getKeyWindow];
        if (!_HUD) {
            _HUD = [MBProgressHUD showHUDAddedTo:keyWindow animated:YES];
            _HUD.label.textColor = [UIColor whiteColor];
            _HUD.mode = MBProgressHUDModeDeterminateHorizontalBar;
            _HUD.label.text = @"正在上传视频...";
            _HUD.contentColor = [UIColor whiteColor];
            _HUD.removeFromSuperViewOnHide = YES;
            _HUD.bezelView.style = MBProgressHUDBackgroundStyleSolidColor;
            _HUD.bezelView.backgroundColor = [UIColor colorWithHexString:@"#000000" alpha:0.8];
        }else{
            _HUD.progress = 0;
            [keyWindow addSubview:_HUD];
            [_HUD showAnimated:YES];
        }
    }else{
        [_HUD hideAnimated:YES];
    }
}


#pragma mark ------ 设置录制地址
- (NSString *)getRecordFilePath {
    NSString *path = [[NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES)lastObject] stringByAppendingPathComponent:@"AccompanyVideoData"];
    NSFileManager *fileManager = [NSFileManager defaultManager];
    BOOL isDir = FALSE;
    BOOL isDirExist = [fileManager fileExistsAtPath:path isDirectory:&isDir];
    if(!(isDirExist && isDir)) {
        BOOL bCreateDir = [fileManager createDirectoryAtPath:path withIntermediateDirectories:YES attributes:nil error:nil];
        if(!bCreateDir){
            NSLog(@"创建文件夹失败！");
        }
        NSLog(@"创建文件夹成功，文件路径%@",path);
    }
    NSString *songName = @"recordSong";
    NSString *fileName = [NSString stringWithFormat:@"%@.mp4",songName];
    NSString *filePath = [path stringByAppendingPathComponent:fileName];
    return filePath;
}

- (dispatch_queue_t)videoRecordQueue {
    if (!_videoRecordQueue) {
        _videoRecordQueue = dispatch_queue_create("com.Colexiu.videoRecord", DISPATCH_QUEUE_SERIAL);
    }
    return _videoRecordQueue;
}

- (void)setMaxFrameRate:(Float64)maxFrameRate forDevice:(AVCaptureDevice *)device {
    @try
    {
        NSError *lockError = nil;
        if ([device lockForConfiguration:&lockError])
        {
            NSArray *videoSupportedFrameRateRanges = device.activeFormat.videoSupportedFrameRateRanges;
            AVFrameRateRange *minFrameRateRange = videoSupportedFrameRateRanges.firstObject;
            for (AVFrameRateRange *range in device.activeFormat.videoSupportedFrameRateRanges)
            {
                if (range.minFrameRate < minFrameRateRange.minFrameRate)
                {
                    minFrameRateRange = range;
                }
            }
            CMTime minFrameDuration = CMTimeMake(1, maxFrameRate);
            //超出范围就取默认值
            if (maxFrameRate < minFrameRateRange.minFrameRate || maxFrameRate > minFrameRateRange.maxFrameRate)
            {
                minFrameDuration = kCMTimeInvalid;
            }
            device.activeVideoMinFrameDuration = minFrameDuration;
            [device unlockForConfiguration];
            NSLog(@"OnboardingScan--打印帧数最小: %@， 最大：%@", @((int32_t)device.activeVideoMinFrameDuration.timescale).stringValue, @((int32_t)device.activeVideoMaxFrameDuration.timescale).stringValue);
        }
    } @catch (NSException *exception) {

     } @finally {

    }
}
@end