erpsuiteios/common/Camera/RACameraViewController.m

//
//  RACameraViewController.m
//  Apex And Drivers
//
//  Created by Jack on 2018/6/5.
//  Copyright © 2018年 USAI. All rights reserved.
//

#import "RACameraViewController.h"
#import <AVFoundation/AVFoundation.h>
#import "RATakePhotoPreviewController.h"
#import <CoreMotion/CoreMotion.h>


@interface RACameraViewController ()<AVCapturePhotoCaptureDelegate>

@property (nonatomic,strong) IBOutlet UIView *previewContainer;
@property (nonatomic,strong) IBOutlet UIView *controlContanier;
@property (strong, nonatomic) IBOutlet UIButton *takePhotoBtn;
@property (strong, nonatomic) IBOutlet UIButton *backBtn;

@property (nonatomic,assign) BOOL barHidden;

#pragma mark - Camera

@property (nonatomic,strong) AVCaptureDevice *captureDevice;
@property (nonatomic,strong) AVCaptureSession *captureSession;
@property (nonatomic,strong) AVCaptureDeviceInput *captureInput;
//@property (nonatomic,strong) AVCaptureStillImageOutput *captureOutput;


@property (nonatomic,strong) AVCapturePhotoSettings *photoSetting;
@property (nonatomic,strong) AVCapturePhotoOutput* photoOutput;
@property (nonatomic,strong) AVCaptureVideoPreviewLayer *previewLayer;

@property (nonatomic,assign) BOOL cameraInitial;
@property (nonatomic,assign) AVLayerVideoGravity gravity;

@property (strong, nonatomic) CMMotionManager *motionManager;
@property (assign, nonatomic) UIDeviceOrientation orientationLast;

@end

@implementation RACameraViewController
-(BOOL)shouldAutorotate {
    return NO;
}


- (void)initMotionManager
{
    if (_motionManager == nil) {
        _motionManager = [[CMMotionManager alloc] init];
    }
    
    // 提供设备运动数据到指定的时间间隔
    _motionManager.deviceMotionUpdateInterval = .3;
    
    if (_motionManager.deviceMotionAvailable) {  // 确定是否使用任何可用的态度参考帧来决定设备的运动是否可用
        [_motionManager startAccelerometerUpdatesToQueue:[NSOperationQueue currentQueue]
                   withHandler:^(CMAccelerometerData  *accelerometerData, NSError *error) {
                          if (!error) {
                                    [self outputAccelertionData:accelerometerData.acceleration];
                          }
                          else{
                                    NSLog(@"%@", error);
                          }
        }];
        
        

    }else
    {
        [self setMotionManager:nil];
    }
}


- (void)outputAccelertionData:(CMAcceleration)acceleration{
    UIDeviceOrientation orientationNew;

//    NSLog(@"x %f y %f z %f",acceleration.x,acceleration.y, acceleration.z);
    if (acceleration.x >= 0.75) {
        orientationNew = UIDeviceOrientationLandscapeRight;
        
        
    }
    else if (acceleration.x <= -0.75) {
        orientationNew = UIDeviceOrientationLandscapeLeft;
    }
    else if (acceleration.y <= -0.75) {
        orientationNew = UIDeviceOrientationPortrait;
    }
    else if (acceleration.y >= 0.75) {
        orientationNew = UIDeviceOrientationPortraitUpsideDown;
    }
    else {
        // Consider same as last time
        return;
    }

    if (orientationNew == self.orientationLast)
        return;

    self.orientationLast = orientationNew;
    
//    [[UIDevice currentDevice] setValue:[NSNumber numberWithInteger:orientationNew] forKey:@"orientation"];
    
    
//    CGRect frame = self.previewContainer.bounds;
    
//    [self resetPreview:frame];
}
+ (NSString *)storyboardID {
    return NSStringFromClass([self class]);
}

+ (instancetype)viewControllerFromStoryboard {
    RACameraViewController *cameraVC = [[UIStoryboard storyboardWithName:@"Camera" bundle:nil] instantiateViewControllerWithIdentifier:[self storyboardID]];
    cameraVC.takeMode = RACameraTakeModeTakeOnce;
    cameraVC.gravity = AVLayerVideoGravityResizeAspectFill;
    return cameraVC;
}

+ (instancetype)showCameraFromViewController:(UIViewController *)from withTakeMode:(RACameraTakeMode)mode videoGravity:(AVLayerVideoGravity)gravity completion:(void(^)(UIImage *image))completion {
    
    RACameraViewController *vc = [self viewControllerFromStoryboard];
    vc.takeMode = mode;
    if (!gravity) {
        gravity = AVLayerVideoGravityResizeAspectFill;
    }
    vc.gravity = gravity;
    vc.completion = completion;
    return vc;
}

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view.
    [self initMotionManager];
    UIImage *normal_img = [self.class imageWithColor:[UIColor redColor] Size:CGSizeMake(60, 60)];
    UIImage *highlight_img = [self.class imageWithColor:[UIColor whiteColor] Size:CGSizeMake(60, 60)];
    
    [self.takePhotoBtn setImage:normal_img forState:UIControlStateNormal];
    [self.takePhotoBtn setImage:highlight_img forState:UIControlStateHighlighted];
    
//    [self initCapture];
//    [self initTakePicture];
    
    if ([self camerAuthorization]) {
        
        [self initCapture];
        [self initTakePicture];
        
    } else {
        // fix:第一次打开相机的时候授权成功后，未初始化相机
        [AVCaptureDevice requestAccessForMediaType:AVMediaTypeVideo completionHandler:^(BOOL granted) {
            
            dispatch_async(dispatch_get_main_queue(), ^{
                if (granted) {
                    [self initCapture];
                    [self initTakePicture];
                    
                    CGRect frame = self.previewContainer.bounds;
                    [self resetPreview:CGRectOffset(frame, CGRectGetWidth(frame), 0)];
                    
                    [UIView animateWithDuration:0.3 animations:^{
                        self.previewLayer.frame = frame;
                    }];
                    
                    if (self.cameraInitial && !self.captureSession.isRunning) {
                        [self.captureSession startRunning];
                    }
                    
                } else {
                    
                    NSDictionary* infoDict =[[NSBundle mainBundle] infoDictionary];
                    NSString *appName = [infoDict objectForKey:@"CFBundleDisplayName"];
                    if (!appName) {
                        appName = [infoDict objectForKey:@"CFBundleName"];
                    }
                    __weak typeof(self) weakSelf = self;
                    UIAlertController *alert = [UIAlertController alertControllerWithTitle:@"Warning" message:[NSString stringWithFormat:@"Camera access denied, please change %@ setting, allow App use camera. (setting -> privacy -> camera enable %@)",[UIDevice currentDevice].model,appName] preferredStyle:UIAlertControllerStyleAlert];
                    UIAlertAction *action = [UIAlertAction actionWithTitle:@"Ok" style:UIAlertActionStyleDefault handler:^(UIAlertAction * _Nonnull action) {
                        [weakSelf dismissViewControllerAnimated:YES completion:nil];
                    }];
                    [alert addAction:action];
                    [self presentViewController:alert animated:YES completion:nil];
                    
                }
            });
            
        }];
    }
    /**
     * 管理导航条
     * 在viewDidload的时候隐藏导航条
     * 恢复导航条的显示/隐藏有两个地方：1.退出的时候；2.确认使用照片的时候
     */
    if (self.navigationController) {
        BOOL navBarHidden = self.navigationController.navigationBar.hidden;
        self.barHidden = navBarHidden;
        if (!navBarHidden) {
            [self.navigationController setNavigationBarHidden:YES animated:YES];
        }
    }
}

- (void)didReceiveMemoryWarning {
    [super didReceiveMemoryWarning];
    // Dispose of any resources that can be recreated.
}

- (void)viewWillAppear:(BOOL)animated {
    [super viewWillAppear:animated];
    
    if (self.cameraInitial && !self.captureSession.isRunning) {
        [self.captureSession startRunning];
    }
}

- (void)viewWillDisappear:(BOOL)animated {
    [super viewWillDisappear:animated];
    
    if ([self.captureSession isRunning]) {
        [self.captureSession stopRunning];
    }
}

- (BOOL)prefersStatusBarHidden {
    return YES;
}

- (void)viewDidLayoutSubviews {
    [super viewDidLayoutSubviews];
    
    // 强制布局一次，不然 takePhotoBtn frame还没发生改变
    [self.controlContanier layoutIfNeeded];
    
    if ([self camerAuthorization] && self.cameraInitial) {
        
        CGRect frame = self.previewContainer.bounds;
        
        BOOL isPortrait = self.interfaceOrientation == UIInterfaceOrientationPortrait || self.interfaceOrientation == UIInterfaceOrientationPortraitUpsideDown;
        // aspect ratio 3:4
        if (self.gravity == AVLayerVideoGravityResizeAspect) {
            
            CGRect backBtnFrame = [self.previewContainer convertRect:self.backBtn.frame fromView:self.controlContanier];
            CGRect captureBtnFrame = [self.previewContainer convertRect:self.takePhotoBtn.frame fromView:self.controlContanier];
            
            if (isPortrait) {
                CGFloat left = 0;
                CGFloat top = CGRectGetMaxY(backBtnFrame);
                CGFloat bottom = CGRectGetMinY(captureBtnFrame);
                CGFloat width = CGRectGetWidth(self.controlContanier.bounds);
                CGFloat height = bottom - top;
                
                frame = CGRectMake(left, top, width, height);
            } else {
                
                CGFloat left = CGRectGetMaxX(backBtnFrame);
                CGFloat right = CGRectGetMinX(captureBtnFrame);
                CGFloat top = 0;
                CGFloat width = right - left;
                CGFloat bottom = CGRectGetHeight(self.controlContanier.bounds);
                CGFloat height = bottom - top;
                
                frame = CGRectMake(left, top, width, height);
            }
        }
        
        [self resetPreview:frame];
    }
}

#pragma mark - Capture

- (void)resetPreview:(CGRect)frame {
    
    self.previewLayer.frame = frame;
    
//    if (self.previewLayer.connection.isVideoOrientationSupported) {
//        self.previewLayer.connection.videoOrientation = [self captureVideoOrientation];
//    }
//
//    if ([self.captureOutput connectionWithMediaType:AVMediaTypeVideo].isVideoOrientationSupported) {
//        [self.captureOutput connectionWithMediaType:AVMediaTypeVideo].videoOrientation = [self captureVideoOrientation];
//    }
//
}

- (BOOL)camerAuthorization {
    
    AVAuthorizationStatus status = [AVCaptureDevice authorizationStatusForMediaType:AVMediaTypeVideo];
    if (status == AVAuthorizationStatusRestricted || status == AVAuthorizationStatusDenied) {
        return NO;
    }
    return YES;
}


- (void)initCapture {
    
    
    self.photoSetting= [AVCapturePhotoSettings photoSettings];
    self.cameraInitial = NO;
    
    if (![self camerAuthorization]) {
        
        NSDictionary* infoDict =[[NSBundle mainBundle] infoDictionary];
        NSString *appName = [infoDict objectForKey:@"CFBundleDisplayName"];
        if (!appName) {
            appName = [infoDict objectForKey:@"CFBundleName"];
        }
        __weak typeof(self) weakSelf = self;
        UIAlertController *alert = [UIAlertController alertControllerWithTitle:@"Warning" message:[NSString stringWithFormat:@"Camera access denied, please change %@ setting, allow App use camera. (setting -> privacy -> camera enable %@)",[UIDevice currentDevice].model,appName] preferredStyle:UIAlertControllerStyleAlert];
        UIAlertAction *action = [UIAlertAction actionWithTitle:@"Ok" style:UIAlertActionStyleDefault handler:^(UIAlertAction * _Nonnull action) {
            [weakSelf dismissViewControllerAnimated:YES completion:nil];
        }];
        [alert addAction:action];
        [self presentViewController:alert animated:YES completion:nil];
        
        return;
    }
    
    self.captureSession = [[AVCaptureSession alloc] init];
    
    self.captureDevice = [self videoDevicePosition:AVCaptureDevicePositionBack];
    if (!self.captureDevice) {
        NSLog(@"there is no capture device while init camera");
        return;
    }
    
    NSError *error;
    self.captureInput = [[AVCaptureDeviceInput alloc] initWithDevice:self.captureDevice error:&error];
    
    if (error) {
        NSLog(@"init camera error: %@",error);
        return;
    }
    
    [self.captureSession beginConfiguration];
    
    if ([_captureSession canSetSessionPreset:AVCaptureSessionPresetPhoto]) {
        _captureSession.sessionPreset = AVCaptureSessionPresetPhoto;
    }
    
//    if ([self.captureDevice isFlashAvailable] && [_captureDevice isFlashModeSupported:AVCaptureFlashModeAuto]) {
    if ([self.captureDevice isFlashAvailable] && [self.photoOutput supportedFlashModes]) {
        NSError *configErr;
        [self.captureDevice lockForConfiguration:&configErr];
//        AVCapturePhotoSettings.flashMode
        self.photoSetting.flashMode =AVCaptureFlashModeAuto;
//        [self.captureDevice setFlashMode:AVCaptureFlashModeAuto];
        [self.captureDevice unlockForConfiguration];
    }
    
//    if ([self.captureDevice isAdjustingWhiteBalance] && [self.captureDevice isWhiteBalanceModeSupported:AVCaptureWhiteBalanceModeAutoWhiteBalance]) {
//        NSError *configErr;
//        [self.captureDevice lockForConfiguration:&configErr];
//        [self.captureDevice setWhiteBalanceMode:AVCaptureWhiteBalanceModeAutoWhiteBalance];
//        [self.captureDevice unlockForConfiguration];
//    }
    
    if ([self.captureSession canAddInput:self.captureInput]) {
        
        
        [self.captureSession addInput:self.captureInput];
        
//        if ([self.captureSession canSetSessionPreset:AVCaptureSessionPreset1920x1080]) {
//            self.captureSession.sessionPreset = AVCaptureSessionPreset1920x1080;
//        } else {
//            if ([self.captureSession canSetSessionPreset:AVCaptureSessionPresetHigh]) {
//                self.captureSession.sessionPreset = AVCaptureSessionPresetHigh;
//            }
//        }
        
    } else {
        NSLog(@"init camera can't add input");
        return;
    }
    
    [self.captureSession commitConfiguration];
    
    self.previewLayer = [[AVCaptureVideoPreviewLayer alloc] initWithSession:self.captureSession];
    self.previewLayer.videoGravity = self.gravity;
    [self.previewContainer.layer addSublayer:self.previewLayer];
    
    self.cameraInitial = YES;
}

- (void)initTakePicture {
    if (!self.cameraInitial) {
        return;
    }
//    self.captureOutput = [[AVCaptureStillImageOutput alloc] init];
    self.photoOutput = [AVCapturePhotoOutput new];
    
//    NSDictionary *setting = @{AVVideoCodecKey:AVVideoCodecJPEG};
//    AVVideoCodecTypeJPEG

//    self.photoSetting.cod
//    [self.captureOutput setOutputSettings:setting];
//
    if ([self.captureSession canAddOutput:self.photoOutput]) {
        [self.captureSession addOutput:self.photoOutput];
    }
    
//    AVCaptureConnection *connection = [self.captureOutput connectionWithMediaType:AVMediaTypeVideo];
//    if (connection.isVideoOrientationSupported) { // addOutput之后判断，否则一直都是false
//        connection.videoOrientation = [self captureVideoOrientation];
//    }
    
}

- (AVCaptureDevice *) videoDevicePosition:(AVCaptureDevicePosition)position {

//    NSArray *videoDevices = [AVCaptureDevice devicesWithMediaType:AVMediaTypeVideo];
    
    
    AVCaptureDeviceDiscoverySession * _Nonnull cameras = [AVCaptureDeviceDiscoverySession discoverySessionWithDeviceTypes:@[AVCaptureDeviceTypeBuiltInWideAngleCamera] mediaType:AVMediaTypeVideo position: AVCaptureDevicePositionUnspecified];//AVCaptureDevicePositionFront & AVCaptureDevicePositionBack
//       //获取当前摄像头方向
//       AVCaptureDevicePosition currentPosition = self.captureDeviceInput.device.position;
//       AVCaptureDevicePosition toPosition = AVCaptureDevicePositionUnspecified;
//       if (currentPosition == AVCaptureDevicePositionBack || currentPosition == AVCaptureDevicePositionUnspecified) {
//           toPosition = AVCaptureDevicePositionFront;
//       }else{
//           toPosition = AVCaptureDevicePositionBack;
//       }
    
    
//    NSArray* captureDeviceArray = [cameras.devices filteredArrayUsingPredicate:[NSPredicate predicateWithFormat:@"position == %d",toPosition]];
//    if (captureDeviceArray.count == 0) {
//        return [self throw_errorWithDomain:@"VideoCapture: reverseCamera failed! get new  camera failed!"];
//    }
    
    for (AVCaptureDevice *device in cameras.devices) {
        if ([device position] == position) {
            return device;
        }
    }
    
    return nil;
}

- (AVCaptureVideoOrientation)captureVideoOrientation {
    AVCaptureVideoOrientation result;
    
//    UIDeviceOrientation deviceOrientation = [UIDevice currentDevice].orientation;
    switch (self.orientationLast) {
        case UIDeviceOrientationPortrait:
        case UIDeviceOrientationFaceUp:
        case UIDeviceOrientationFaceDown:
            result = AVCaptureVideoOrientationPortrait;
            break;
        case UIDeviceOrientationPortraitUpsideDown:
            //如果这里设置成AVCaptureVideoOrientationPortraitUpsideDown，则视频方向和拍摄时的方向是相反的。
            result = AVCaptureVideoOrientationPortraitUpsideDown;
            break;
        case UIDeviceOrientationLandscapeLeft:
            result = AVCaptureVideoOrientationLandscapeRight;
            break;
        case UIDeviceOrientationLandscapeRight:
            result = AVCaptureVideoOrientationLandscapeLeft;
            break;
        default:
            result = AVCaptureVideoOrientationPortrait;
            break;
    }
    
    return result;
}

#pragma mark - Action

- (IBAction)takePictureBtnClick:(UIButton *)sender {
    
//    UIDeviceOrientation deviceOrientation = [UIDevice currentDevice].orientation;
//    NSLog(@"UIDeviceOrientation %ld",deviceOrientation);
//    [self.captureOutput connectionWithMediaType:AVMediaTypeVideo];
    if (!self.cameraInitial) {
        return;
    }
    sender.enabled = false;
//    AVCaptureConnection *connection = [self.captureOutput connectionWithMediaType:AVMediaTypeVideo];
//
//    if (connection.isVideoOrientationSupported) { // addOutput之后判断，否则一直都是false
//        connection.videoOrientation =  [self captureVideoOrientation];
//    }
//
//    NSLog(@"capture orientation %ld",connection.videoOrientation);
    ;
//    __weak typeof(self) weakSelf = self;
    
    [self.photoOutput capturePhotoWithSettings:self.photoSetting delegate:self];
//
//    [self.captureOutput captureStillImageAsynchronouslyFromConnection:connection completionHandler:^(CMSampleBufferRef  _Nullable imageDataSampleBuffer, NSError * _Nullable error) {
//
//        if (imageDataSampleBuffer) {
//            NSData *imageData=[AVCaptureStillImageOutput jpegStillImageNSDataRepresentation:imageDataSampleBuffer];
//            UIImage *image=[UIImage imageWithData:imageData];
//
//            RATakePhotoPreviewController *preVC = [RATakePhotoPreviewController viewControllerFromStoryboard];
//            preVC.photoHandler = ^(UIImage *img){
//                if (weakSelf) {
//                    __strong typeof(weakSelf) strongSelf = weakSelf;
//                    if (strongSelf.completion) {
//                        strongSelf.completion(img);
//                    }
//                }
//            };
//            preVC.preImage = image;
//            if (weakSelf.takeMode == RACameraTakeModeTakeOnce) {
//                preVC.popTo = weakSelf.fromVC;
//                preVC.barHidden = weakSelf.barHidden;
//            }
//            [weakSelf.navigationController pushViewController:preVC animated:YES];
//
//        } else {
//            NSLog(@"take picture failed: %@",error);
//        }
//        sender.enabled = true;
//    }];
}

- (IBAction)returnButtonClick:(UIButton *)sender {
    if (self.navigationController) {
        [self.navigationController popViewControllerAnimated:YES];
    } else {
        [self dismissViewControllerAnimated:YES completion:nil];
    }
    
    if (self.navigationController) {
        [self.navigationController setNavigationBarHidden:self.barHidden animated:YES];
    }
}

#pragma mark - Utils

+ (UIImage *)imageWithColor:(UIColor *)color Size:(CGSize)size {
    
    UIGraphicsBeginImageContextWithOptions(size, NO, [UIScreen mainScreen].scale);
    CGContextRef ctx = UIGraphicsGetCurrentContext();
    CGContextAddEllipseInRect(ctx, CGRectMake(5, 5, size.width - 10, size.height - 10));
    CGContextSetFillColorWithColor(ctx, color.CGColor);
    CGContextSetStrokeColorWithColor(ctx, [UIColor whiteColor].CGColor);
    CGContextSetLineWidth(ctx, 3.0f);
    CGContextDrawPath(ctx, kCGPathFillStroke);
    UIImage *img = UIGraphicsGetImageFromCurrentImageContext();
    UIGraphicsEndImageContext();
    
    return img;
}


#pragma mark - AVCapturePhotoCaptureDelegate
-(void)captureOutput:(AVCapturePhotoOutput *)output didFinishProcessingPhoto:(AVCapturePhoto *)photo error:(NSError *)error  API_AVAILABLE(ios(11.0)) {
    if (!error) {
        // 使用该方式获取图片，可能图片会存在旋转问题，在使用的时候调整图片即可
        NSData *imageData = [photo fileDataRepresentation];
        UIImage *image = [UIImage imageWithData:imageData];

        
//              NSData *imageData=[AVCaptureStillImageOutput jpegStillImageNSDataRepresentation:imageDataSampleBuffer];
//              UIImage *image=[UIImage imageWithData:imageData];
  
              RATakePhotoPreviewController *preVC = [RATakePhotoPreviewController viewControllerFromStoryboard];
              preVC.photoHandler = ^(UIImage *img){

                  if (self.completion) {
                      self.completion(img);
                  }
              };
              preVC.preImage = image;
              if (self.takeMode == RACameraTakeModeTakeOnce) {
                  preVC.popTo = self.fromVC;
                  preVC.barHidden = self.barHidden;
              }
              [self.navigationController pushViewController:preVC animated:YES];
  
          } else {
              NSLog(@"take picture failed: %@",error);
          }
//          sender.enabled = true;
    self.takePhotoBtn.enabled = true;
        
        
    
}


@end