scoplan.camera 1.2.5

package/src/ios/UIScoplanCamera.m

@@ -0,0 +1,1098 @@
+//
+//  UIScoplanCamera.m
+//  My happy client
+//
+//  Created by Adriela on 30/04/2018.
+//
+@import Photos;
+
+#import <Foundation/Foundation.h>
+#import "UIScoplanCamera.h"
+#import "ScoplanCamera.h"
+#import "AVCamPhotoCaptureDelegate.h"
+#import "AVCamPreviewView.h"
+#import <CoreMotion/CoreMotion.h>
+
+static void * SessionRunningContext = &SessionRunningContext;
+static AVCaptureVideoOrientation curOr;
+
+typedef NS_ENUM( NSInteger, AVCamSetupResult ) {
+    AVCamSetupResultSuccess,
+    AVCamSetupResultCameraNotAuthorized,
+    AVCamSetupResultSessionConfigurationFailed
+};
+
+typedef NS_ENUM( NSInteger, AVCamCaptureMode ) {
+    AVCamCaptureModePhoto = 0,
+    AVCamCaptureModeMovie = 1
+};
+
+typedef NS_ENUM( NSInteger, AVCamLivePhotoMode ) {
+    AVCamLivePhotoModeOn,
+    AVCamLivePhotoModeOff
+};
+
+typedef NS_ENUM( NSInteger, AVCamDepthDataDeliveryMode ) {
+    AVCamDepthDataDeliveryModeOn,
+    AVCamDepthDataDeliveryModeOff
+};
+
+@interface AVCaptureDeviceDiscoverySession (Utilities)
+
+- (NSInteger)uniqueDevicePositionsCount;
+
+@end
+
+@implementation AVCaptureDeviceDiscoverySession (Utilities)
+
+- (NSInteger)uniqueDevicePositionsCount
+{
+    NSMutableArray<NSNumber *> *uniqueDevicePositions = [NSMutableArray array];
+    
+    for ( AVCaptureDevice *device in self.devices ) {
+        if ( ! [uniqueDevicePositions containsObject:@(device.position)] ) {
+            [uniqueDevicePositions addObject:@(device.position)];
+        }
+    }
+    
+    return uniqueDevicePositions.count;
+}
+
+@end
+
+@interface UIScoplanCamera () <AVCaptureFileOutputRecordingDelegate>
+@property (strong, nonatomic) IBOutlet UIView *rootView;
+@property (strong, nonatomic) IBOutlet UIImageView *imageview;
+@property (strong, nonatomic) IBOutlet UIButton *okbutton;
+@property (strong, nonatomic) IBOutlet UIView *blackbottom;
+@property (strong, nonatomic) IBOutlet UIImageView *progress;
+
+// Session management.
+@property (nonatomic, weak) IBOutlet AVCamPreviewView *previewView;
+@property (nonatomic, weak) IBOutlet UISegmentedControl *captureModeControl;
+
+@property (nonatomic) AVCamSetupResult setupResult;
+@property (nonatomic) dispatch_queue_t sessionQueue;
+@property (nonatomic) AVCaptureSession *session;
+@property (nonatomic, getter=isSessionRunning) BOOL sessionRunning;
+@property (nonatomic) AVCaptureDeviceInput *videoDeviceInput;
+
+// Device configuration.
+@property (nonatomic, weak) IBOutlet UIButton *cameraButton;
+//@property (nonatomic, weak) IBOutlet UILabel *cameraUnavailableLabel;
+@property (nonatomic) AVCaptureDeviceDiscoverySession *videoDeviceDiscoverySession;
+
+// Capturing photos.
+@property (nonatomic, weak) IBOutlet UIButton *photoButton;
+//@property (nonatomic, weak) IBOutlet UIButton *livePhotoModeButton;
+@property (nonatomic) AVCamLivePhotoMode livePhotoMode;
+//@property (nonatomic, weak) IBOutlet UILabel *capturingLivePhotoLabel;
+//@property (nonatomic, weak) IBOutlet UIButton *depthDataDeliveryButton;
+@property (nonatomic) AVCamDepthDataDeliveryMode depthDataDeliveryMode;
+
+@property (nonatomic) AVCapturePhotoOutput *photoOutput;
+@property (nonatomic) NSMutableDictionary<NSNumber *, AVCamPhotoCaptureDelegate *> *inProgressPhotoCaptureDelegates;
+@property (nonatomic) NSInteger inProgressLivePhotoCapturesCount;
+
+// Recording movies.
+//@property (nonatomic, weak) IBOutlet UIButton *recordButton;
+//@property (nonatomic, weak) IBOutlet UIButton *resumeButton;
+
+@property (nonatomic, strong) AVCaptureMovieFileOutput *movieFileOutput;
+@property (nonatomic) UIBackgroundTaskIdentifier backgroundRecordingID;
+
+@end
+
+@implementation UIScoplanCamera
+
+#pragma mark View Controller Life Cycle
+
+- (void) setMCam:(ScoplanCamera *)mCam{
+    mCamera = mCam;
+}
+
+- (void)insertImgUrl:(NSString*)url{
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [_okbutton setTitle: @"OK" forState: UIControlStateNormal];
+        [_photoButton setHidden:FALSE];
+        [_progress stopAnimating];
+        [_progress setHidden:TRUE];
+    });
+    [mCamera insertPicture:url];
+}
+
+- (NSInteger)getOrientation{
+    return curOr;
+}
+
+- (void)viewDidLoad
+{
+    [super viewDidLoad];
+    
+    // Disable UI. The UI is enabled if and only if the session starts running.
+//    self.cameraButton.enabled = NO;
+//    self.recordButton.enabled = NO;
+    self.photoButton.enabled = NO;
+    NSMutableArray * framesLoader = [[NSMutableArray alloc] initWithCapacity:18];
+    for (int i = 1; i < 20; i++) {
+        NSString * imageName = [NSString stringWithFormat:@"image00000%d.png",i];
+        UIImage * img = [UIImage imageNamed:imageName];
+        [framesLoader addObject:img];
+    }
+    self.progress.animationImages = framesLoader;
+    self.progress.animationDuration = 1.0f;
+    self.progress.animationRepeatCount = 0;
+    //self.livePhotoModeButton.enabled = NO;
+    self.captureModeControl.enabled = YES;
+    //self.depthDataDeliveryButton.enabled = NO;
+    
+    // Create the AVCaptureSession.
+    self.session = [[AVCaptureSession alloc] init];
+    
+    // Create a device discovery session.
+    NSArray<AVCaptureDeviceType> *deviceTypes = @[AVCaptureDeviceTypeBuiltInWideAngleCamera, AVCaptureDeviceTypeBuiltInDualCamera];
+    self.videoDeviceDiscoverySession = [AVCaptureDeviceDiscoverySession discoverySessionWithDeviceTypes:deviceTypes mediaType:AVMediaTypeVideo position:AVCaptureDevicePositionUnspecified];
+    /*
+     Remove the AVCaptureMovieFileOutput from the session because movie recording is
+     not supported with AVCaptureSessionPresetPhoto. Additionally, Live Photo
+     capture is not supported when an AVCaptureMovieFileOutput is connected to the session.
+     */
+    
+    // Set up the preview view.
+    self.previewView.session = self.session;
+    
+    // Communicate with the session and other session objects on this queue.
+    self.sessionQueue = dispatch_queue_create( "session queue", DISPATCH_QUEUE_SERIAL );
+    
+    self.setupResult = AVCamSetupResultSuccess;
+    
+    [self.session beginConfiguration];
+    [self.session removeOutput:self.movieFileOutput];
+    if([self.session canSetSessionPreset:AVCaptureSessionPresetPhoto]){
+        self.session.sessionPreset = AVCaptureSessionPresetPhoto;
+    }
+    
+    self.movieFileOutput = nil;
+    
+    if ( self.photoOutput.livePhotoCaptureSupported ) {
+        self.photoOutput.livePhotoCaptureEnabled = YES;
+        
+        dispatch_async( dispatch_get_main_queue(), ^{
+            //self.livePhotoModeButton.enabled = YES;
+            //self.livePhotoModeButton.hidden = NO;
+        } );
+    }
+    
+    if ( self.photoOutput.depthDataDeliverySupported ) {
+        self.photoOutput.depthDataDeliveryEnabled = YES;
+        
+        dispatch_async( dispatch_get_main_queue(), ^{
+            //self.depthDataDeliveryButton.hidden = NO;
+            //self.depthDataDeliveryButton.enabled = YES;
+        } );
+    }
+    
+    //[testButn addTarget:self action:@selector(staypressed:) forControlEvents:UIControlEventTouchUpInside];
+    UIPinchGestureRecognizer* pinchGst = [[UIPinchGestureRecognizer alloc] initWithTarget:self action:@selector(pinchForZoom:)];
+    [self.previewView addGestureRecognizer:pinchGst];
+    [self.session commitConfiguration];
+    
+    /*
+     Setup the capture session.
+     In general it is not safe to mutate an AVCaptureSession or any of its
+     inputs, outputs, or connections from multiple threads at the same time.
+     
+     Why not do all of this on the main queue?
+     Because -[AVCaptureSession startRunning] is a blocking call which can
+     take a long time. We dispatch session setup to the sessionQueue so
+     that the main queue isn't blocked, which keeps the UI responsive.
+     */
+    dispatch_async( self.sessionQueue, ^{
+        [self configureSession];
+    } );
+    
+}
+
+- (void)pinchForZoom:(UIPinchGestureRecognizer *)pinchRecognizer{
+    static CGFloat zoomFactorBegin = .0;
+    if ( UIGestureRecognizerStateBegan == pinchRecognizer.state ) {
+        zoomFactorBegin = self.videoDeviceInput.device.videoZoomFactor;
+
+    } else if (UIGestureRecognizerStateChanged == pinchRecognizer.state) {
+        NSError *error = nil;
+        if ([self.videoDeviceInput.device lockForConfiguration:&error]) {
+
+            CGFloat desiredZoomFactor = zoomFactorBegin * pinchRecognizer.scale;
+            CGFloat zoomFactor = MAX(1.0, MIN(desiredZoomFactor, self.videoDeviceInput.device.activeFormat.videoMaxZoomFactor));
+            [self.videoDeviceInput.device rampToVideoZoomFactor:zoomFactor withRate:3.0];
+
+            [self.videoDeviceInput.device unlockForConfiguration];
+        } else {
+            NSLog(@"error: %@", error);
+        }
+    }
+}
+
+
+- (void)viewWillAppear:(BOOL)animated
+{
+    [super viewWillAppear:animated];
+    cm = [[CMMotionManager alloc] init];
+    cm.deviceMotionUpdateInterval=0.5f;
+    if([cm isDeviceMotionAvailable])
+    [cm startDeviceMotionUpdatesToQueue:[NSOperationQueue mainQueue]
+                            withHandler:^(CMDeviceMotion *data, NSError *error) {
+                                if(fabs(data.gravity.x)>fabs(data.gravity.y)){
+                                    //NSLog(@"LANSCAPE");
+                                    if(data.gravity.x>=0){
+                                        //NSLog(@"LEFT");
+                                        curOr = AVCaptureVideoOrientationLandscapeLeft;
+                                    }
+                                    else{
+                                        //NSLog(@"RIGHT");
+                                        curOr = AVCaptureVideoOrientationLandscapeRight;
+                                    }
+                                    
+                                }
+                                else{
+                                    //NSLog(@"PORTRAIT");
+                                    if(data.gravity.y>=0){
+                                        //NSLog(@"DOWN");
+                                        curOr = AVCaptureVideoOrientationPortraitUpsideDown;
+                                    }
+                                    else{
+                                        //NSLog(@"UP");
+                                        curOr = AVCaptureVideoOrientationPortrait;
+                                    }
+                                    
+                                }
+                                
+                            }];
+    AVCaptureVideoPreviewLayer *previewLayer = [AVCaptureVideoPreviewLayer layerWithSession:self.session];
+    previewLayer.frame = _rootView.bounds;
+    previewLayer.videoGravity = AVLayerVideoGravityResizeAspect;
+    [_rootView.layer addSublayer:previewLayer];
+    _blackbottom.layer.zPosition = 1;
+    _photoButton.imageView.layer.zPosition = 1;
+    _photoButton.layer.zPosition = 1;
+    _imageview.layer.zPosition = 1;
+    _okbutton.layer.zPosition = 1;
+    _progress.layer.zPosition = 1;
+    [_progress setHidden:TRUE];
+    dispatch_async( self.sessionQueue, ^{
+        switch ( self.setupResult )
+        {
+            case AVCamSetupResultSuccess:
+            {
+                // Only setup observers and start the session running if setup succeeded.
+                [self addObservers];
+                [self.session startRunning];
+                self.sessionRunning = self.session.isRunning;
+                break;
+            }
+            case AVCamSetupResultCameraNotAuthorized:
+            {
+                dispatch_async( dispatch_get_main_queue(), ^{
+                    NSString *message = NSLocalizedString( @"AVCam doesn't have permission to use the camera, please change privacy settings", @"Alert message when the user has denied access to the camera" );
+                    UIAlertController *alertController = [UIAlertController alertControllerWithTitle:@"AVCam" message:message preferredStyle:UIAlertControllerStyleAlert];
+                    UIAlertAction *cancelAction = [UIAlertAction actionWithTitle:NSLocalizedString( @"OK", @"Alert OK button" ) style:UIAlertActionStyleCancel handler:nil];
+                    [alertController addAction:cancelAction];
+                    // Provide quick access to Settings.
+                    UIAlertAction *settingsAction = [UIAlertAction actionWithTitle:NSLocalizedString( @"Settings", @"Alert button to open Settings" ) style:UIAlertActionStyleDefault handler:^( UIAlertAction *action ) {
+                        [[UIApplication sharedApplication] openURL:[NSURL URLWithString:UIApplicationOpenSettingsURLString] options:@{} completionHandler:nil];
+                    }];
+                    [alertController addAction:settingsAction];
+                    [self presentViewController:alertController animated:YES completion:nil];
+                } );
+                break;
+            }
+            case AVCamSetupResultSessionConfigurationFailed:
+            {
+                dispatch_async( dispatch_get_main_queue(), ^{
+                    NSString *message = NSLocalizedString( @"Unable to capture media", @"Alert message when something goes wrong during capture session configuration" );
+                    UIAlertController *alertController = [UIAlertController alertControllerWithTitle:@"AVCam" message:message preferredStyle:UIAlertControllerStyleAlert];
+                    UIAlertAction *cancelAction = [UIAlertAction actionWithTitle:NSLocalizedString( @"OK", @"Alert OK button" ) style:UIAlertActionStyleCancel handler:nil];
+                    [alertController addAction:cancelAction];
+                    [self presentViewController:alertController animated:YES completion:nil];
+                } );
+                break;
+            }
+        }
+    } );
+}
+
+- (void) setPhotodata:(AVCamPhotoCaptureDelegate*)photoCaptureDelegate{
+    UIImage *imgdata = [[UIImage alloc]initWithData:[photoCaptureDelegate getPhotodata]];
+}
+
+- (void)viewDidDisappear:(BOOL)animated
+{
+    dispatch_async( self.sessionQueue, ^{
+        if ( self.setupResult == AVCamSetupResultSuccess ) {
+            [self.session stopRunning];
+            [self removeObservers];
+        }
+    } );
+    
+    [super viewDidDisappear:animated];
+}
+
+- (BOOL)shouldAutorotate
+{
+    // Disable autorotation of the interface when recording is in progress.
+    return ! self.movieFileOutput.isRecording;
+}
+
+- (UIInterfaceOrientationMask)supportedInterfaceOrientations
+{
+    return UIInterfaceOrientationMaskPortrait;
+}
+
+- (void)viewWillTransitionToSize:(CGSize)size withTransitionCoordinator:(id<UIViewControllerTransitionCoordinator>)coordinator
+{
+    [super viewWillTransitionToSize:size withTransitionCoordinator:coordinator];
+    
+    UIDeviceOrientation deviceOrientation = [UIDevice currentDevice].orientation;
+    
+    if ( UIDeviceOrientationIsPortrait( deviceOrientation ) || UIDeviceOrientationIsLandscape( deviceOrientation ) ) {
+        self.previewView.videoPreviewLayer.connection.videoOrientation = (AVCaptureVideoOrientation)deviceOrientation;
+    }
+}
+
+#pragma mark Session Management
+
+// Call this on the session queue.
+- (void)configureSession
+{
+    if ( self.setupResult != AVCamSetupResultSuccess ) {
+        return;
+    }
+    
+    NSError *error = nil;
+    
+    [self.session beginConfiguration];
+    
+    /*
+     We do not create an AVCaptureMovieFileOutput when setting up the session because the
+     AVCaptureMovieFileOutput does not support movie recording with AVCaptureSessionPresetPhoto.
+     */
+    self.session.sessionPreset = AVCaptureSessionPresetPhoto;
+    
+    // Add video input.
+    
+    // Choose the back dual camera if available, otherwise default to a wide angle camera.
+    AVCaptureDevice *videoDevice = [AVCaptureDevice defaultDeviceWithDeviceType:AVCaptureDeviceTypeBuiltInDualCamera mediaType:AVMediaTypeVideo position:AVCaptureDevicePositionBack];
+    if ( ! videoDevice ) {
+        // If the back dual camera is not available, default to the back wide angle camera.
+        videoDevice = [AVCaptureDevice defaultDeviceWithDeviceType:AVCaptureDeviceTypeBuiltInWideAngleCamera mediaType:AVMediaTypeVideo position:AVCaptureDevicePositionBack];
+        
+        // In some cases where users break their phones, the back wide angle camera is not available. In this case, we should default to the front wide angle camera.
+        if ( ! videoDevice ) {
+            videoDevice = [AVCaptureDevice defaultDeviceWithDeviceType:AVCaptureDeviceTypeBuiltInWideAngleCamera mediaType:AVMediaTypeVideo position:AVCaptureDevicePositionFront];
+        }
+    }
+    AVCaptureDeviceInput *videoDeviceInput = [AVCaptureDeviceInput deviceInputWithDevice:videoDevice error:&error];
+    if ( ! videoDeviceInput ) {
+        NSLog( @"Could not create video device input: %@", error );
+        self.setupResult = AVCamSetupResultSessionConfigurationFailed;
+        [self.session commitConfiguration];
+        return;
+    }
+    if ( [self.session canAddInput:videoDeviceInput] ) {
+        [self.session addInput:videoDeviceInput];
+        self.videoDeviceInput = videoDeviceInput;
+        
+        dispatch_async( dispatch_get_main_queue(), ^{
+            /*
+             Why are we dispatching this to the main queue?
+             Because AVCaptureVideoPreviewLayer is the backing layer for AVCamPreviewView and UIView
+             can only be manipulated on the main thread.
+             Note: As an exception to the above rule, it is not necessary to serialize video orientation changes
+             on the AVCaptureVideoPreviewLayer’s connection with other session manipulation.
+             
+             Use the status bar orientation as the initial video orientation. Subsequent orientation changes are
+             handled by -[AVCamCameraViewController viewWillTransitionToSize:withTransitionCoordinator:].
+             */
+            UIInterfaceOrientation statusBarOrientation = [UIApplication sharedApplication].statusBarOrientation;
+            AVCaptureVideoOrientation initialVideoOrientation = AVCaptureVideoOrientationPortrait;
+            if ( statusBarOrientation != UIInterfaceOrientationUnknown ) {
+                initialVideoOrientation = (AVCaptureVideoOrientation)statusBarOrientation;
+            }
+            
+            self.previewView.videoPreviewLayer.connection.videoOrientation = initialVideoOrientation;
+        } );
+    }
+    else {
+        NSLog( @"Could not add video device input to the session" );
+        self.setupResult = AVCamSetupResultSessionConfigurationFailed;
+        [self.session commitConfiguration];
+        return;
+    }
+    
+    // Add photo output.
+    AVCapturePhotoOutput *photoOutput = [[AVCapturePhotoOutput alloc] init];
+    if ( [self.session canAddOutput:photoOutput] ) {
+        [self.session addOutput:photoOutput];
+        self.photoOutput = photoOutput;
+        
+        self.photoOutput.highResolutionCaptureEnabled = YES;
+        self.photoOutput.livePhotoCaptureEnabled = self.photoOutput.livePhotoCaptureSupported;
+        self.photoOutput.depthDataDeliveryEnabled = self.photoOutput.depthDataDeliverySupported;
+        
+        self.livePhotoMode = self.photoOutput.livePhotoCaptureSupported ? AVCamLivePhotoModeOn : AVCamLivePhotoModeOff;
+        self.depthDataDeliveryMode = self.photoOutput.depthDataDeliverySupported ? AVCamDepthDataDeliveryModeOn : AVCamDepthDataDeliveryModeOff;
+        
+        
+        self.inProgressPhotoCaptureDelegates = [NSMutableDictionary dictionary];
+        self.inProgressLivePhotoCapturesCount = 0;
+    }
+    else {
+        NSLog( @"Could not add photo output to the session" );
+        self.setupResult = AVCamSetupResultSessionConfigurationFailed;
+        [self.session commitConfiguration];
+        return;
+    }
+    
+    self.backgroundRecordingID = UIBackgroundTaskInvalid;
+    
+    [self.session commitConfiguration];
+}
+
+- (IBAction)resumeInterruptedSession:(id)sender
+{
+    dispatch_async( self.sessionQueue, ^{
+        /*
+         The session might fail to start running, e.g., if a phone or FaceTime call is still
+         using audio or video. A failure to start the session running will be communicated via
+         a session runtime error notification. To avoid repeatedly failing to start the session
+         running, we only try to restart the session running in the session runtime error handler
+         if we aren't trying to resume the session running.
+         */
+        [self.session startRunning];
+        self.sessionRunning = self.session.isRunning;
+        if ( ! self.session.isRunning ) {
+            dispatch_async( dispatch_get_main_queue(), ^{
+                NSString *message = NSLocalizedString( @"Unable to resume", @"Alert message when unable to resume the session running" );
+                UIAlertController *alertController = [UIAlertController alertControllerWithTitle:@"AVCam" message:message preferredStyle:UIAlertControllerStyleAlert];
+                UIAlertAction *cancelAction = [UIAlertAction actionWithTitle:NSLocalizedString( @"OK", @"Alert OK button" ) style:UIAlertActionStyleCancel handler:nil];
+                [alertController addAction:cancelAction];
+                [self presentViewController:alertController animated:YES completion:nil];
+            } );
+        }
+        else {
+            dispatch_async( dispatch_get_main_queue(), ^{
+                //self.resumeButton.hidden = YES;
+            } );
+        }
+    } );
+}
+
+- (IBAction)toggleCaptureMode:(UISegmentedControl *)captureModeControl
+{
+    if ( captureModeControl.selectedSegmentIndex == AVCamCaptureModePhoto ) {
+        //self.recordButton.enabled = NO;
+        
+        dispatch_async( self.sessionQueue, ^{
+            /*
+             Remove the AVCaptureMovieFileOutput from the session because movie recording is
+             not supported with AVCaptureSessionPresetPhoto. Additionally, Live Photo
+             capture is not supported when an AVCaptureMovieFileOutput is connected to the session.
+             */
+            [self.session beginConfiguration];
+            [self.session removeOutput:self.movieFileOutput];
+            self.session.sessionPreset = AVCaptureSessionPresetPhoto;
+            
+            self.movieFileOutput = nil;
+            
+            if ( self.photoOutput.livePhotoCaptureSupported ) {
+                self.photoOutput.livePhotoCaptureEnabled = YES;
+                
+                dispatch_async( dispatch_get_main_queue(), ^{
+                    //self.livePhotoModeButton.enabled = YES;
+                    //self.livePhotoModeButton.hidden = NO;
+                } );
+            }
+            
+            if ( self.photoOutput.depthDataDeliverySupported ) {
+                self.photoOutput.depthDataDeliveryEnabled = YES;
+                
+                dispatch_async( dispatch_get_main_queue(), ^{
+                    //self.depthDataDeliveryButton.hidden = NO;
+                    //self.depthDataDeliveryButton.enabled = YES;
+                } );
+            }
+            
+            [self.session commitConfiguration];
+        } );
+    }
+    else if ( captureModeControl.selectedSegmentIndex == AVCamCaptureModeMovie ) {
+        //self.livePhotoModeButton.hidden = YES;
+        //self.depthDataDeliveryButton.hidden = YES;
+        
+        dispatch_async( self.sessionQueue, ^{
+            AVCaptureMovieFileOutput *movieFileOutput = [[AVCaptureMovieFileOutput alloc] init];
+            
+            if ( [self.session canAddOutput:movieFileOutput] )
+            {
+                [self.session beginConfiguration];
+                [self.session addOutput:movieFileOutput];
+                self.session.sessionPreset = AVCaptureSessionPresetHigh;
+                AVCaptureConnection *connection = [movieFileOutput connectionWithMediaType:AVMediaTypeVideo];
+                if ( connection.isVideoStabilizationSupported ) {
+                    connection.preferredVideoStabilizationMode = AVCaptureVideoStabilizationModeAuto;
+                }
+                [self.session commitConfiguration];
+                
+                self.movieFileOutput = movieFileOutput;
+                
+                dispatch_async( dispatch_get_main_queue(), ^{
+                    //self.recordButton.enabled = YES;
+                } );
+            }
+        } );
+    }
+}
+
+#pragma mark Device Configuration
+
+- (IBAction)changeCamera:(id)sender
+{
+    self.cameraButton.enabled = NO;
+    //self.recordButton.enabled = NO;
+    self.photoButton.enabled = NO;
+    //self.livePhotoModeButton.enabled = NO;
+    self.captureModeControl.enabled = NO;
+    
+    dispatch_async( self.sessionQueue, ^{
+        AVCaptureDevice *currentVideoDevice = self.videoDeviceInput.device;
+        AVCaptureDevicePosition currentPosition = currentVideoDevice.position;
+        
+        AVCaptureDevicePosition preferredPosition;
+        AVCaptureDeviceType preferredDeviceType;
+        
+        switch ( currentPosition )
+        {
+            case AVCaptureDevicePositionUnspecified:
+            case AVCaptureDevicePositionFront:
+                preferredPosition = AVCaptureDevicePositionBack;
+                preferredDeviceType = AVCaptureDeviceTypeBuiltInDualCamera;
+                break;
+            case AVCaptureDevicePositionBack:
+                preferredPosition = AVCaptureDevicePositionFront;
+                preferredDeviceType = AVCaptureDeviceTypeBuiltInWideAngleCamera;
+                break;
+        }
+        
+        NSArray<AVCaptureDevice *> *devices = self.videoDeviceDiscoverySession.devices;
+        AVCaptureDevice *newVideoDevice = nil;
+        
+        // First, look for a device with both the preferred position and device type.
+        for ( AVCaptureDevice *device in devices ) {
+            if ( device.position == preferredPosition && [device.deviceType isEqualToString:preferredDeviceType] ) {
+                newVideoDevice = device;
+                break;
+            }
+        }
+        
+        // Otherwise, look for a device with only the preferred position.
+        if ( ! newVideoDevice ) {
+            for ( AVCaptureDevice *device in devices ) {
+                if ( device.position == preferredPosition ) {
+                    newVideoDevice = device;
+                    break;
+                }
+            }
+        }
+        
+        if ( newVideoDevice ) {
+            AVCaptureDeviceInput *videoDeviceInput = [AVCaptureDeviceInput deviceInputWithDevice:newVideoDevice error:NULL];
+            
+            [self.session beginConfiguration];
+            
+            // Remove the existing device input first, since using the front and back camera simultaneously is not supported.
+            [self.session removeInput:self.videoDeviceInput];
+            
+            if ( [self.session canAddInput:videoDeviceInput] ) {
+                [[NSNotificationCenter defaultCenter] removeObserver:self name:AVCaptureDeviceSubjectAreaDidChangeNotification object:currentVideoDevice];
+                
+                [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(subjectAreaDidChange:) name:AVCaptureDeviceSubjectAreaDidChangeNotification object:newVideoDevice];
+                
+                [self.session addInput:videoDeviceInput];
+                self.videoDeviceInput = videoDeviceInput;
+            }
+            else {
+                [self.session addInput:self.videoDeviceInput];
+            }
+            
+            AVCaptureConnection *movieFileOutputConnection = [self.movieFileOutput connectionWithMediaType:AVMediaTypeVideo];
+            if ( movieFileOutputConnection.isVideoStabilizationSupported ) {
+                movieFileOutputConnection.preferredVideoStabilizationMode = AVCaptureVideoStabilizationModeAuto;
+            }
+            
+            /*
+             Set Live Photo capture and depth data delivery if it is supported. When changing cameras, the
+             `livePhotoCaptureEnabled` and `depthDataDeliveryEnabled` properties of the AVCapturePhotoOutput gets set to NO when
+             a video device is disconnected from the session. After the new video device is
+             added to the session, re-enable Live Photo capture and depth data delivery if they are supported.
+             */
+            self.photoOutput.livePhotoCaptureEnabled = self.photoOutput.livePhotoCaptureSupported;
+            self.photoOutput.depthDataDeliveryEnabled = self.photoOutput.depthDataDeliverySupported;
+            
+            [self.session commitConfiguration];
+        }
+        
+        dispatch_async( dispatch_get_main_queue(), ^{
+            self.cameraButton.enabled = YES;
+            //self.recordButton.enabled = self.captureModeControl.selectedSegmentIndex == AVCamCaptureModeMovie;
+            self.photoButton.enabled = YES;
+//            self.livePhotoModeButton.enabled = YES;
+//            self.captureModeControl.enabled = YES;
+//            self.depthDataDeliveryButton.enabled = self.photoOutput.isDepthDataDeliveryEnabled;
+//            self.depthDataDeliveryButton.hidden = !self.photoOutput.depthDataDeliverySupported;
+        } );
+    } );
+}
+
+- (IBAction)focusAndExposeTap:(UIGestureRecognizer *)gestureRecognizer
+{
+    CGPoint devicePoint = [self.previewView.videoPreviewLayer captureDevicePointOfInterestForPoint:[gestureRecognizer locationInView:gestureRecognizer.view]];
+    [self focusWithMode:AVCaptureFocusModeAutoFocus exposeWithMode:AVCaptureExposureModeAutoExpose atDevicePoint:devicePoint monitorSubjectAreaChange:YES];
+}
+
+- (void)focusWithMode:(AVCaptureFocusMode)focusMode exposeWithMode:(AVCaptureExposureMode)exposureMode atDevicePoint:(CGPoint)point monitorSubjectAreaChange:(BOOL)monitorSubjectAreaChange
+{
+    dispatch_async( self.sessionQueue, ^{
+        AVCaptureDevice *device = self.videoDeviceInput.device;
+        NSError *error = nil;
+        if ( [device lockForConfiguration:&error] ) {
+            /*
+             Setting (focus/exposure)PointOfInterest alone does not initiate a (focus/exposure) operation.
+             Call set(Focus/Exposure)Mode() to apply the new point of interest.
+             */
+            if ( device.isFocusPointOfInterestSupported && [device isFocusModeSupported:focusMode] ) {
+                device.focusPointOfInterest = point;
+                device.focusMode = focusMode;
+            }
+            
+            if ( device.isExposurePointOfInterestSupported && [device isExposureModeSupported:exposureMode] ) {
+                device.exposurePointOfInterest = point;
+                device.exposureMode = exposureMode;
+            }
+            
+            device.subjectAreaChangeMonitoringEnabled = monitorSubjectAreaChange;
+            [device unlockForConfiguration];
+        }
+        else {
+            NSLog( @"Could not lock device for configuration: %@", error );
+        }
+    } );
+}
+
+#pragma mark Capturing Photos
+
+- (IBAction)backtowebview:(id)sender {
+    [mCamera dismissCam];
+}
+- (IBAction)capturePhoto:(id)sender
+{
+    /*
+     Retrieve the video preview layer's video orientation on the main queue before
+     entering the session queue. We do this to ensure UI elements are accessed on
+     the main thread and session configuration is done on the session queue.
+     */
+    [_photoButton setHidden:TRUE];
+    [_progress setHidden:FALSE];
+    [_progress startAnimating];
+    dispatch_async( self.sessionQueue, ^{
+        // Update the photo output's connection to match the video orientation of the video preview layer.
+        AVCaptureConnection *photoOutputConnection = [self.photoOutput connectionWithMediaType:AVMediaTypeVideo];
+        photoOutputConnection.videoOrientation = curOr;
+        
+        AVCapturePhotoSettings *photoSettings;
+        // Capture HEIF photo when supported, with flash set to auto and high resolution photo enabled.
+        if ( [self.photoOutput.availablePhotoCodecTypes containsObject:AVVideoCodecTypeHEVC] ) {
+            photoSettings = [AVCapturePhotoSettings photoSettingsWithFormat:@{ AVVideoCodecKey : AVVideoCodecTypeHEVC }];
+        }
+        else {
+            photoSettings = [AVCapturePhotoSettings photoSettings];
+        }
+        
+        if ( self.videoDeviceInput.device.isFlashAvailable ) {
+            photoSettings.flashMode = AVCaptureFlashModeAuto;
+        }
+        photoSettings.highResolutionPhotoEnabled = YES;
+        if ( photoSettings.availablePreviewPhotoPixelFormatTypes.count > 0 ) {
+            photoSettings.previewPhotoFormat = @{ (NSString *)kCVPixelBufferPixelFormatTypeKey : photoSettings.availablePreviewPhotoPixelFormatTypes.firstObject };
+        }
+        if ( self.livePhotoMode == AVCamLivePhotoModeOn && self.photoOutput.livePhotoCaptureSupported ) { // Live Photo capture is not supported in movie mode.
+            NSString *livePhotoMovieFileName = [NSUUID UUID].UUIDString;
+            NSString *livePhotoMovieFilePath = [NSTemporaryDirectory() stringByAppendingPathComponent:[livePhotoMovieFileName stringByAppendingPathExtension:@"mov"]];
+            photoSettings.livePhotoMovieFileURL = [NSURL fileURLWithPath:livePhotoMovieFilePath];
+        }
+        
+        if ( self.depthDataDeliveryMode == AVCamDepthDataDeliveryModeOn && self.photoOutput.isDepthDataDeliverySupported ) {
+            photoSettings.depthDataDeliveryEnabled = YES;
+        } else {
+            photoSettings.depthDataDeliveryEnabled = NO;
+        }
+        
+        // Use a separate object for the photo capture delegate to isolate each capture life cycle.
+        AVCamPhotoCaptureDelegate *photoCaptureDelegate = [[AVCamPhotoCaptureDelegate alloc] initWithRequestedPhotoSettings:photoSettings willCapturePhotoAnimation:^{
+            dispatch_async( dispatch_get_main_queue(), ^{
+                self.previewView.videoPreviewLayer.opacity = 0.0;
+                [UIView animateWithDuration:0.25 animations:^{
+                    self.previewView.videoPreviewLayer.opacity = 1.0;
+                }];
+            } );
+        } livePhotoCaptureHandler:^( BOOL capturing ) {
+            /*
+             Because Live Photo captures can overlap, we need to keep track of the
+             number of in progress Live Photo captures to ensure that the
+             Live Photo label stays visible during these captures.
+             */
+            dispatch_async( self.sessionQueue, ^{
+                if ( capturing ) {
+                    self.inProgressLivePhotoCapturesCount++;
+                }
+                else {
+                    self.inProgressLivePhotoCapturesCount--;
+                }
+                
+                NSInteger inProgressLivePhotoCapturesCount = self.inProgressLivePhotoCapturesCount;
+                dispatch_async( dispatch_get_main_queue(), ^{
+                    if ( inProgressLivePhotoCapturesCount > 0 ) {
+                        //self.capturingLivePhotoLabel.hidden = NO;
+                    }
+                    else if ( inProgressLivePhotoCapturesCount == 0 ) {
+                        //self.capturingLivePhotoLabel.hidden = YES;
+                    }
+                    else {
+                        NSLog( @"Error: In progress live photo capture count is less than 0" );
+                    }
+                } );
+            } );
+        } completionHandler:^( AVCamPhotoCaptureDelegate *photoCaptureDelegate ) {
+            // When the capture is complete, remove a reference to the photo capture delegate so it can be deallocated.
+            dispatch_async( self.sessionQueue, ^{
+                self.inProgressPhotoCaptureDelegates[@(photoCaptureDelegate.requestedPhotoSettings.uniqueID)] = nil;
+            } );
+        }];
+        
+        /*
+         The Photo Output keeps a weak reference to the photo capture delegate so
+         we store it in an array to maintain a strong reference to this object
+         until the capture is completed.
+         */
+        self.inProgressPhotoCaptureDelegates[@(photoCaptureDelegate.requestedPhotoSettings.uniqueID)] = photoCaptureDelegate;
+        [photoCaptureDelegate setUICam:self];
+        [self.photoOutput capturePhotoWithSettings:photoSettings delegate:photoCaptureDelegate];
+    } );
+}
+
+- (IBAction)toggleLivePhotoMode:(UIButton *)livePhotoModeButton
+{
+    dispatch_async( self.sessionQueue, ^{
+        self.livePhotoMode = ( self.livePhotoMode == AVCamLivePhotoModeOn ) ? AVCamLivePhotoModeOff : AVCamLivePhotoModeOn;
+        AVCamLivePhotoMode livePhotoMode = self.livePhotoMode;
+        
+        dispatch_async( dispatch_get_main_queue(), ^{
+            if ( livePhotoMode == AVCamLivePhotoModeOn ) {
+                //[self.livePhotoModeButton setTitle:NSLocalizedString( @"Live Photo Mode: On", @"Live photo mode button on title" ) forState:UIControlStateNormal];
+            }
+            else {
+                //[self.livePhotoModeButton setTitle:NSLocalizedString( @"Live Photo Mode: Off", @"Live photo mode button off title" ) forState:UIControlStateNormal];
+            }
+        } );
+    } );
+}
+
+- (IBAction)toggleDepthDataDeliveryMode:(UIButton *)depthDataDeliveryButton
+{
+    dispatch_async( self.sessionQueue, ^{
+        self.depthDataDeliveryMode = ( self.depthDataDeliveryMode == AVCamDepthDataDeliveryModeOn ) ? AVCamDepthDataDeliveryModeOff : AVCamDepthDataDeliveryModeOn;
+        AVCamDepthDataDeliveryMode depthDataDeliveryMode = self.depthDataDeliveryMode;
+        
+        dispatch_async( dispatch_get_main_queue(), ^{
+            if ( depthDataDeliveryMode == AVCamDepthDataDeliveryModeOn ) {
+                //[self.depthDataDeliveryButton setTitle:NSLocalizedString( @"Depth Data Delivery: On", @"Depth Data mode button on title" ) forState:UIControlStateNormal];
+            }
+            else {
+                //[self.depthDataDeliveryButton setTitle:NSLocalizedString( @"Depth Data Delivery: Off", @"Depth Data mode button off title" ) forState:UIControlStateNormal];
+            }
+        } );
+    } );
+}
+
+#pragma mark Recording Movies
+
+- (IBAction)toggleMovieRecording:(id)sender
+{
+    /*
+     Disable the Camera button until recording finishes, and disable
+     the Record button until recording starts or finishes.
+     
+     See the AVCaptureFileOutputRecordingDelegate methods.
+     */
+    self.cameraButton.enabled = NO;
+    //self.recordButton.enabled = NO;
+    self.captureModeControl.enabled = NO;
+    
+    /*
+     Retrieve the video preview layer's video orientation on the main queue
+     before entering the session queue. We do this to ensure UI elements are
+     accessed on the main thread and session configuration is done on the session queue.
+     */
+    AVCaptureVideoOrientation videoPreviewLayerVideoOrientation = self.previewView.videoPreviewLayer.connection.videoOrientation;
+    
+    dispatch_async( self.sessionQueue, ^{
+        if ( ! self.movieFileOutput.isRecording ) {
+            if ( [UIDevice currentDevice].isMultitaskingSupported ) {
+                /*
+                 Setup background task.
+                 This is needed because the -[captureOutput:didFinishRecordingToOutputFileAtURL:fromConnections:error:]
+                 callback is not received until AVCam returns to the foreground unless you request background execution time.
+                 This also ensures that there will be time to write the file to the photo library when AVCam is backgrounded.
+                 To conclude this background execution, -[endBackgroundTask:] is called in
+                 -[captureOutput:didFinishRecordingToOutputFileAtURL:fromConnections:error:] after the recorded file has been saved.
+                 */
+                self.backgroundRecordingID = [[UIApplication sharedApplication] beginBackgroundTaskWithExpirationHandler:nil];
+            }
+            
+            // Update the orientation on the movie file output video connection before starting recording.
+            AVCaptureConnection *movieFileOutputConnection = [self.movieFileOutput connectionWithMediaType:AVMediaTypeVideo];
+            movieFileOutputConnection.videoOrientation = videoPreviewLayerVideoOrientation;
+            
+            // Use HEVC codec if supported
+            if ( [self.movieFileOutput.availableVideoCodecTypes containsObject:AVVideoCodecTypeHEVC] ) {
+                [self.movieFileOutput setOutputSettings:@{ AVVideoCodecKey : AVVideoCodecTypeHEVC } forConnection:movieFileOutputConnection];
+            }
+            
+            // Start recording to a temporary file.
+            NSString *outputFileName = [NSUUID UUID].UUIDString;
+            NSString *outputFilePath = [NSTemporaryDirectory() stringByAppendingPathComponent:[outputFileName stringByAppendingPathExtension:@"mov"]];
+            [self.movieFileOutput startRecordingToOutputFileURL:[NSURL fileURLWithPath:outputFilePath] recordingDelegate:self];
+        }
+        else {
+            [self.movieFileOutput stopRecording];
+        }
+    } );
+}
+
+- (void)captureOutput:(AVCaptureFileOutput *)captureOutput didStartRecordingToOutputFileAtURL:(NSURL *)fileURL fromConnections:(NSArray *)connections
+{
+    // Enable the Record button to let the user stop the recording.
+    dispatch_async( dispatch_get_main_queue(), ^{
+        //self.recordButton.enabled = YES;
+        //[self.recordButton setTitle:NSLocalizedString( @"Stop", @"Recording button stop title" ) forState:UIControlStateNormal];
+    });
+}
+
+- (void)captureOutput:(AVCaptureFileOutput *)captureOutput didFinishRecordingToOutputFileAtURL:(NSURL *)outputFileURL fromConnections:(NSArray *)connections error:(NSError *)error
+{
+    /*
+     Note that currentBackgroundRecordingID is used to end the background task
+     associated with this recording. This allows a new recording to be started,
+     associated with a new UIBackgroundTaskIdentifier, once the movie file output's
+     `recording` property is back to NO — which happens sometime after this method
+     returns.
+     
+     Note: Since we use a unique file path for each recording, a new recording will
+     not overwrite a recording currently being saved.
+     */
+    UIBackgroundTaskIdentifier currentBackgroundRecordingID = self.backgroundRecordingID;
+    self.backgroundRecordingID = UIBackgroundTaskInvalid;
+    
+    dispatch_block_t cleanUp = ^{
+        if ( [[NSFileManager defaultManager] fileExistsAtPath:outputFileURL.path] ) {
+            [[NSFileManager defaultManager] removeItemAtPath:outputFileURL.path error:NULL];
+        }
+        
+        if ( currentBackgroundRecordingID != UIBackgroundTaskInvalid ) {
+            [[UIApplication sharedApplication] endBackgroundTask:currentBackgroundRecordingID];
+        }
+    };
+    
+    BOOL success = YES;
+    
+    if ( error ) {
+        NSLog( @"Movie file finishing error: %@", error );
+        success = [error.userInfo[AVErrorRecordingSuccessfullyFinishedKey] boolValue];
+    }
+    if ( success ) {
+        // Check authorization status.
+        [PHPhotoLibrary requestAuthorization:^( PHAuthorizationStatus status ) {
+            if ( status == PHAuthorizationStatusAuthorized ) {
+                // Save the movie file to the photo library and cleanup.
+                [[PHPhotoLibrary sharedPhotoLibrary] performChanges:^{
+                    PHAssetResourceCreationOptions *options = [[PHAssetResourceCreationOptions alloc] init];
+                    options.shouldMoveFile = YES;
+                    PHAssetCreationRequest *creationRequest = [PHAssetCreationRequest creationRequestForAsset];
+                    [creationRequest addResourceWithType:PHAssetResourceTypeVideo fileURL:outputFileURL options:options];
+                } completionHandler:^( BOOL success, NSError *error ) {
+                    if ( ! success ) {
+                        NSLog( @"Could not save movie to photo library: %@", error );
+                    }
+                    cleanUp();
+                }];
+            }
+            else {
+                cleanUp();
+            }
+        }];
+    }
+    else {
+        cleanUp();
+    }
+    
+    // Enable the Camera and Record buttons to let the user switch camera and start another recording.
+    dispatch_async( dispatch_get_main_queue(), ^{
+        // Only enable the ability to change camera if the device has more than one camera.
+        self.cameraButton.enabled = ( self.videoDeviceDiscoverySession.uniqueDevicePositionsCount > 1 );
+        //self.recordButton.enabled = YES;
+        self.captureModeControl.enabled = YES;
+        //[self.recordButton setTitle:NSLocalizedString( @"Record", @"Recording button record title" ) forState:UIControlStateNormal];
+    });
+}
+
+#pragma mark KVO and Notifications
+
+- (void)addObservers
+{
+    [self.session addObserver:self forKeyPath:@"running" options:NSKeyValueObservingOptionNew context:SessionRunningContext];
+    
+    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(subjectAreaDidChange:) name:AVCaptureDeviceSubjectAreaDidChangeNotification object:self.videoDeviceInput.device];
+    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(sessionRuntimeError:) name:AVCaptureSessionRuntimeErrorNotification object:self.session];
+    
+    /*
+     A session can only run when the app is full screen. It will be interrupted
+     in a multi-app layout, introduced in iOS 9, see also the documentation of
+     AVCaptureSessionInterruptionReason. Add observers to handle these session
+     interruptions and show a preview is paused message. See the documentation
+     of AVCaptureSessionWasInterruptedNotification for other interruption reasons.
+     */
+    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(sessionWasInterrupted:) name:AVCaptureSessionWasInterruptedNotification object:self.session];
+    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(sessionInterruptionEnded:) name:AVCaptureSessionInterruptionEndedNotification object:self.session];
+}
+
+- (void)removeObservers
+{
+    [[NSNotificationCenter defaultCenter] removeObserver:self];
+    
+    [self.session removeObserver:self forKeyPath:@"running" context:SessionRunningContext];
+}
+
+- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context
+{
+    if ( context == SessionRunningContext ) {
+        BOOL isSessionRunning = [change[NSKeyValueChangeNewKey] boolValue];
+        
+        dispatch_async( dispatch_get_main_queue(), ^{
+            // Only enable the ability to change camera if the device has more than one camera.
+            self.cameraButton.enabled = isSessionRunning && ( self.videoDeviceDiscoverySession.uniqueDevicePositionsCount > 1 );
+            //self.recordButton.enabled = isSessionRunning && ( self.captureModeControl.selectedSegmentIndex == AVCamCaptureModeMovie );
+            self.photoButton.enabled = isSessionRunning;
+            self.captureModeControl.enabled = isSessionRunning;
+            //self.livePhotoModeButton.enabled = isSessionRunning && livePhotoCaptureEnabled;
+            //self.livePhotoModeButton.hidden = ! ( isSessionRunning && livePhotoCaptureSupported );
+            //self.depthDataDeliveryButton.enabled = isSessionRunning && depthDataDeliveryEnabled ;
+            //self.depthDataDeliveryButton.hidden = ! ( isSessionRunning && depthDataDeliverySupported );
+        } );
+    }
+    else {
+        [super observeValueForKeyPath:keyPath ofObject:object change:change context:context];
+    }
+}
+
+- (void)subjectAreaDidChange:(NSNotification *)notification
+{
+    CGPoint devicePoint = CGPointMake( 0.5, 0.5 );
+    [self focusWithMode:AVCaptureFocusModeContinuousAutoFocus exposeWithMode:AVCaptureExposureModeContinuousAutoExposure atDevicePoint:devicePoint monitorSubjectAreaChange:NO];
+}
+
+- (void)sessionRuntimeError:(NSNotification *)notification
+{
+    NSError *error = notification.userInfo[AVCaptureSessionErrorKey];
+    NSLog( @"Capture session runtime error: %@", error );
+    
+    /*
+     Automatically try to restart the session running if media services were
+     reset and the last start running succeeded. Otherwise, enable the user
+     to try to resume the session running.
+     */
+    if ( error.code == AVErrorMediaServicesWereReset ) {
+        dispatch_async( self.sessionQueue, ^{
+            if ( self.isSessionRunning ) {
+                [self.session startRunning];
+                self.sessionRunning = self.session.isRunning;
+            }
+            else {
+                dispatch_async( dispatch_get_main_queue(), ^{
+                    //self.resumeButton.hidden = NO;
+                } );
+            }
+        } );
+    }
+    else {
+        //self.resumeButton.hidden = NO;
+    }
+}
+
+- (void)sessionWasInterrupted:(NSNotification *)notification
+{
+    /*
+     In some scenarios we want to enable the user to resume the session running.
+     For example, if music playback is initiated via control center while
+     using AVCam, then the user can let AVCam resume
+     the session running, which will stop music playback. Note that stopping
+     music playback in control center will not automatically resume the session
+     running. Also note that it is not always possible to resume, see -[resumeInterruptedSession:].
+     */
+    BOOL showResumeButton = NO;
+    
+    AVCaptureSessionInterruptionReason reason = [notification.userInfo[AVCaptureSessionInterruptionReasonKey] integerValue];
+    NSLog( @"Capture session was interrupted with reason %ld", (long)reason );
+    
+    if ( reason == AVCaptureSessionInterruptionReasonAudioDeviceInUseByAnotherClient ||
+        reason == AVCaptureSessionInterruptionReasonVideoDeviceInUseByAnotherClient ) {
+        showResumeButton = YES;
+    }
+    else if ( reason == AVCaptureSessionInterruptionReasonVideoDeviceNotAvailableWithMultipleForegroundApps ) {
+        // Simply fade-in a label to inform the user that the camera is unavailable.
+        //self.cameraUnavailableLabel.alpha = 0.0;
+        //self.cameraUnavailableLabel.hidden = NO;
+        [UIView animateWithDuration:0.25 animations:^{
+            //self.cameraUnavailableLabel.alpha = 1.0;
+        }];
+    }
+    
+    if ( showResumeButton ) {
+        // Simply fade-in a button to enable the user to try to resume the session running.
+        //self.resumeButton.alpha = 0.0;
+        //self.resumeButton.hidden = NO;
+        [UIView animateWithDuration:0.25 animations:^{
+            //self.resumeButton.alpha = 1.0;
+        }];
+    }
+}
+
+- (void)sessionInterruptionEnded:(NSNotification *)notification
+{
+    NSLog( @"Capture session interruption ended" );
+    
+//    if ( ! self.resumeButton.hidden ) {
+//        [UIView animateWithDuration:0.25 animations:^{
+//            self.resumeButton.alpha = 0.0;
+//        } completion:^( BOOL finished ) {
+//            self.resumeButton.hidden = YES;
+//        }];
+//    }
+//    if ( ! self.cameraUnavailableLabel.hidden ) {
+//        [UIView animateWithDuration:0.25 animations:^{
+//            self.cameraUnavailableLabel.alpha = 0.0;
+//        } completion:^( BOOL finished ) {
+//            self.cameraUnavailableLabel.hidden = YES;
+//        }];
+//    }
+}
+
+@end