A great number of mobile applications can interact with your device’s camera, including apps that take pictures, record videos, and provide overlays (for example, augmented-reality applications such as a constellation app). iOS developers have a great deal of control in how they can interact with any given device’s hardware. With iOS 7, a number of features have been added to improve capture quality and give developers more to work with, such as increased frame rate and smoother auto focus. One exciting new feature is the ability to use real-time discovery of machine-readable metadata (barcodes). In this chapter, you will learn multiple ways to access and use these functionalities, from simple, predefined interfaces to incredibly flexible, custom implementations, as well as capturing machine-readable metadata.

Recipe 9-1: Taking Pictures

iOS has an incredibly handy and simple interface to your device’s camera. With this interface you can allow users to take pictures and record video from inside an app. Here, you learn the basics of starting the camera interface to capture a still image.

To begin, you will create a simple project that allows you to pull up your camera, take a picture, and then display the most recently taken image on your screen. First, create a new single view application project. For this recipe, you don’t need to import any extra frameworks into your project.

//
//  ViewController.h
//  Recipe 9-1 Taking Pictures
//

#import <UIKit/UIKit.h>

@interface ViewController : UIViewController

@property (weak, nonatomic) IBOutlet UIImageView *imageView;
@property (weak, nonatomic) IBOutlet UIButton *cameraButton;

- (IBAction)takePicture:(id)sender;

@end

- (IBAction)takePicture:(id)sender
{
        // Make sure camera is available
    if ([UIImagePickerController
         isSourceTypeAvailable:UIImagePickerControllerSourceTypeCamera] == NO)
    {
        UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"Error"
                                                        message:@"Camera Unavailable"
                                                       delegate:self
                                              cancelButtonTitle:@"Cancel"
                                              otherButtonTitles:nil, nil];
        [alert show];
        return;
    }
}

//
//  ViewController.h
//  Recipe 9-1 Taking Pictures
//

#import <UIKit/UIKit.h>

@interface ViewController : UIViewController <UIImagePickerControllerDelegate,
                                             UINavigationControllerDelegate>

@property (weak, nonatomic) IBOutlet UIImageView *imageView;
@property (weak, nonatomic) IBOutlet UIButton *cameraButton;
@property (strong, nonatomic) UIImagePickerController *imagePicker;

- (IBAction)takePicture:(id)sender;

@end

- (IBAction)takePicture:(id)sender
{
        // Make sure camera is available
    if ([UIImagePickerController
         isSourceTypeAvailable:UIImagePickerControllerSourceTypeCamera] == NO)
    {
        UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"Error"
                                                        message:@"Camera Unavailable"
                                                       delegate:self
                                              cancelButtonTitle:@"Cancel"
                                              otherButtonTitles:nil, nil];
        [alert show];
        return;
    }
    if (self.imagePicker == nil)
    {
        self.imagePicker = [[UIImagePickerController alloc] init];
        self.imagePicker.delegate = self;
        self.imagePicker.sourceType = UIImagePickerControllerSourceTypeCamera;

    }
    [self presentViewController:self.imagePicker animated:YES completion:NULL];
}

-(void)imagePickerController:(UIImagePickerController *)picker didFinishPickingMediaWithInfo:(NSDictionary *)info
{
    UIImage *image = [info objectForKey:UIImagePickerControllerOriginalImage];
    self.imageView.image = image;
    self.imageView.contentMode = UIViewContentModeScaleAspectFill;
    [self dismissViewControllerAnimated:YES completion:NULL];
}

- (void) imagePickerControllerDidCancel: (UIImagePickerController *) picker
{
    [self dismissViewControllerAnimated:YES completion:NULL];
}

- (IBAction)takePicture:(id)sender
{
    // ...

    if (self.imagePicker == nil)
    {
        self.imagePicker = [[UIImagePickerController alloc] init];
        self.imagePicker.delegate = self;
        self.imagePicker.sourceType = UIImagePickerControllerSourceTypeCamera;
        self.imagePicker.allowsEditing = YES;

    }
    [self presentViewController:self.imagePicker animated:YES completion:NULL];
}

-(void)imagePickerController:(UIImagePickerController *)picker didFinishPickingMediaWithInfo:(NSDictionary *)info
{
    UIImage *image = [info objectForKey:UIImagePickerControllerEditedImage];
    self.imageView.image = image;
    self.imageView.contentMode = UIViewContentModeScaleAspectFill;
    [self dismissViewControllerAnimated:YES completion:NULL];
}

-(void)imagePickerController:(UIImagePickerController *)picker didFinishPickingMediaWithInfo:(NSDictionary *)info
{
    UIImage *image = (UIImage *)[info objectForKey:UIImagePickerControllerEditedImage];
    UIImageWriteToSavedPhotosAlbum (image, nil, nil , nil);
    self.imageView.image = image;
    self.imageView.contentMode = UIViewContentModeScaleAspectFill;
    [self dismissViewControllerAnimated:YES completion:NULL];
}

Recipe 9-2: Recording Video

Your UIImagePickerController is actually a lot more flexible than you’ve seen so far, especially because you’ve been using it exclusively for still images. Here, you’ll learn how to set up your UIImagePickerController to handle both still images and video.

For this recipe, you build off the code from Recipe 9-1 because it already includes the setup you need. You add to its functionality by implementing the option to record and save videos.

Start by setting the image picker’s allowed media types to all available types for the camera. This can be done using the availableMediaTypesForSourceType: class method of the UIImagePickerController, as shown in Listing 9-10.

Listing 9-10.  Updating the takePicture: method to allow video recording

- (IBAction)takePicture:(id)sender
{
        // Make sure camera is available
    if ([UIImagePickerController
         isSourceTypeAvailable:UIImagePickerControllerSourceTypeCamera] == NO)
    {
        UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"Error"
                                                        message:@"Camera Unavailable"
                                                       delegate:self
                                              cancelButtonTitle:@"Cancel"
                                              otherButtonTitles:nil, nil];
        [alert show];
        return;
    }
    if (self.imagePicker == nil)
    {
        self.imagePicker = [[UIImagePickerController alloc] init];
        self.imagePicker.delegate = self;
        self.imagePicker.sourceType = UIImagePickerControllerSourceTypeCamera;
        self.imagePicker.mediaTypes = [UIImagePickerController
            availableMediaTypesForSourceType:UIImagePickerControllerSourceTypeCamera];
        self.imagePicker.allowsEditing = YES;
         
    }
    [self presentViewController:self.imagePicker animated:YES completion:NULL];
}

Next, you need to instruct your application on how to handle when the user records and uses a video. To do this, link the Mobile Core Services framework to your project and import its API in your view controller’s header file, as shown in Listing 9-11.

Listing 9-11.  Importing the framework to the ViewController.h file

//
//  ViewController.h
//  Recipe 9-2 Recording Videos
//

#import <UIKit/UIKit.h>
#import <MobileCoreServices/MobileCoreServices.h>

@interface ViewController : UIViewController<UIImagePickerControllerDelegate, UINavigationControllerDelegate>

@property (weak, nonatomic) IBOutlet UIImageView *imageView;
@property (weak, nonatomic) IBOutlet UIButton *cameraButton;
@property (strong, nonatomic) UIImagePickerController *imagePicker;

- (IBAction)takePicture:(id)sender;

@end

Now add the bold code in Listing 9-12 to your UIImagePickerController’s delegate method.

Listing 9-12.  Adding video comparison to the imagePickerController:didFinishPickingMediaWithInfo: method

-(void)imagePickerController:(UIImagePickerController *)picker didFinishPickingMediaWithInfo:(NSDictionary *)info
{
    NSString *mediaType = [info objectForKey: UIImagePickerControllerMediaType];
     
    if (CFStringCompare((__bridge CFStringRef) mediaType, kUTTypeMovie, 0) ==
        kCFCompareEqualTo)
    {
        // Movie Captured
        NSString *moviePath =
           (NSString *) [[info objectForKey: UIImagePickerControllerMediaURL] path];
         
        if (UIVideoAtPathIsCompatibleWithSavedPhotosAlbum (moviePath))
        {
            UISaveVideoAtPathToSavedPhotosAlbum (moviePath, nil, nil, nil);
        }
    }
    else
    {
        // Picture Taken
        UIImage *image =
            (UIImage *)[info objectForKey:UIImagePickerControllerEditedImage];
        UIImageWriteToSavedPhotosAlbum (image, nil, nil , nil);
        self.imageView.image = image;
        self.imageView.contentMode = UIViewContentModeScaleAspectFill;
    }
    [self dismissViewControllerAnimated:YES completion:NULL];
}

Essentially, what you are doing in Listing 9-12 is comparing the media type of the saved file. The main issue comes into play when you attempt to compare mediaType, which is an NSString, with kUTTypeMovie, which is of the type CFStringRef. You accomplish this by casting your NSString down to a CFStringRef. In iOS 5+ this process became slightly more complicated with the introduction of Automatic Reference Counting (ARC) because ARC deals with Objective-C object types such as NSString, but not with C types like CFStringRef. You create a bridged casting by placing __bridge before your CFStringRef, as shown earlier, to instruct ARC not to deal with this object.

If all has gone well, your app should now be able to record video by selecting the video mode in the image-picker view, as shown in Figure 9-6. The video is then saved (if allowed by the user) to the private photos library.

Recipe 9-3: Editing Videos

Although your UIImagePickerController offers a convenient way to record and save video files, it does nothing to allow you to edit them. Fortunately, iOS has another built-in controller called UIVideoEditorController, which you can use to edit your recorded videos.

You can build this fairly simple recipe off your second project from Recipe 9-2, in which you added video functionality to your UIImagePickerController.

Start by adding a second button with the title “Edit Video” to your view controller’s interface file. Arrange the two buttons, as shown in Figure 9-7.

Next, create an action named editVideo for when the user taps the “Edit Video” button.

You’ll also need a property to store the path to the video that the user records. Define it in the view controller’s header file, as shown in Listing 9-13.

Listing 9-13.  The ViewController.h file with the new additions

//
//  ViewController.h
//  Recipe 9-3 Editing Videos
//

#import <UIKit/UIKit.h>
#import <MobileCoreServices/MobileCoreServices.h>

@interface ViewController : UIViewController<UIImagePickerControllerDelegate, UINavigationControllerDelegate>

@property (weak, nonatomic) IBOutlet UIImageView *imageView;
@property (weak, nonatomic) IBOutlet UIButton *cameraButton;
@property (strong, nonatomic) UIImagePickerController *imagePicker;
@property (strong, nonatomic) NSString *pathToRecordedVideo;

- (IBAction)takePicture:(id)sender;
- (IBAction)editVideo:(id)sender;

@end

Now, in the imagePickerController:didFinishPickingMediaWithInfo: method, make sure the pathToRecordedVideo property gets updated with the path to the newly recorded video, as shown in Listing 9-14.

Listing 9-14.  Adding the video path for the newly recorded video

-(void)imagePickerController:(UIImagePickerController *)picker didFinishPickingMediaWithInfo:(NSDictionary *)info
{
    NSString *mediaType = [info objectForKey: UIImagePickerControllerMediaType];
     
    if (CFStringCompare((__bridge CFStringRef) mediaType, kUTTypeMovie, 0) ==
        kCFCompareEqualTo)
    {
        NSString *moviePath = (NSString *)[[info objectForKey: UIImagePickerControllerMediaURL] path];
        self.pathToRecordedVideo = moviePath;

        if (UIVideoAtPathIsCompatibleWithSavedPhotosAlbum (moviePath))
        {
            UISaveVideoAtPathToSavedPhotosAlbum (moviePath, nil, nil, nil);
        }
    }
    else
    {
        //...
    }
}

With the pathToRecordedVideo property in place, you can turn your focus to your editVideo action. This action opens the last recorded video for editing in a video editor controller, or displays an error if no video was recorded. Listing 9-15 shows this method implementation.

Listing 9-15.  The editVideo method implementation

- (IBAction)editVideo:(id)sender
{
    if (self.pathToRecordedVideo)
    {
        UIVideoEditorController *editor = [[UIVideoEditorController alloc] init];
        editor.videoPath = self.pathToRecordedVideo;
        editor.delegate = self;
        [self presentViewController:editor animated:YES completion:NULL];
    }
    else
    {
        UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"Error"
            message:@"No Video Recorded Yet"
            delegate:self
            cancelButtonTitle:@"Cancel"
            otherButtonTitles:nil, nil];
        [alert show];
    }
}

Because the video editor’s receiving delegate is your view controller, you need to make sure it conforms to the UIVideoEditorControllerDelegate protocol. Add the protocol to the header file, as shown in Listing 9-16.

Listing 9-16.  Declaring the UIVideoEditorControllerDelegate protocol

// ...

@interface ViewController : UIViewController<UIImagePickerControllerDelegate,
                                             UINavigationControllerDelegate ,
                                             UIVideoEditorControllerDelegate>

// ...

@end

Finally, you need to implement a few delegate methods for your UIVideoEditorController. First, you need a delegate method to handle a successful editing/trimming. Listing 9-17 shows this method.

Listing 9-17.  The VideoEditorController:didSaveEditedVideoToPath: delegate method implementation

-(void)videoEditorController:(UIVideoEditorController *)editor didSaveEditedVideoToPath:(NSString *)editedVideoPath
{
    self.pathToRecordedVideo = editedVideoPath;
    if (UIVideoAtPathIsCompatibleWithSavedPhotosAlbum (editedVideoPath))
    {
        UISaveVideoAtPathToSavedPhotosAlbum (editedVideoPath, nil, nil, nil);
    }
    [self dismissViewControllerAnimated:YES completion:NULL];
}

As you can see, your application sets the newly edited video as your next video to be edited so that you can create increasingly trimmed clips. It also saves each edited version to your photo album, if possible.

You need one more delegate method to handle the cancellation of your UIVideoEditorController. Add the implementation of the method shown in Listing 9-18.

Listing 9-18.  Implementation of the videoEditorControllerDidCancel: delegate method

-(void)videoEditorControllerDidCancel:(UIVideoEditorController *)editor
{
    [self dismissViewControllerAnimated:YES completion:NULL];
}

Upon testing on a physical device, your application should now successfully allow you to edit your videos. Figure 9-8 shows a view of your application giving you the option to edit a recorded video.

Recipe 9-4: Using Custom Camera Overlays

There are a variety of applications that implement the camera interface but also implement a custom overlay—for example, to display constellations on the sky or simply to implement their own custom camera controls. In this recipe, you’ll continue building on the project from the preceding recipes and implement a very basic custom camera screen overlay. Specifically, you replace the default button controls with your own versions of them. Although simple, the example should give you an idea of how to create your own, more useful overlay functionalities.

You build your custom overlay view directly in code in a method you’ll name “customViewForImagePicker :.” This method creates an overlay view and populates it with three buttons: one for taking the picture, one for turning the flash on and off, and one to toggle between the front and rear cameras. Listing 9-19 shows this code, which you add to the ViewController.m from Recipe 9-3.

Listing 9-19.  Implementation of the customViewForImagePicker: method

-(UIView *)customViewForImagePicker:(UIImagePickerController *)imagePicker;
{
    UIView *view = [[UIView alloc] initWithFrame:CGRectMake(0, 20, 280, 480)];
    view.backgroundColor = [UIColor clearColor];
     
    UIButton *flashButton =
        [[UIButton alloc] initWithFrame:CGRectMake(10, 10, 120, 44)];
    flashButton.backgroundColor = [UIColor colorWithRed:.5 green:.5 blue:.5 alpha:.5];
    [flashButton setTitle:@"Flash Auto" forState:UIControlStateNormal];
    [flashButton setTitleColor:[UIColor whiteColor] forState:UIControlStateNormal];
    flashButton.layer.cornerRadius = 10.0;
     
    UIButton *changeCameraButton =
        [[UIButton alloc] initWithFrame:CGRectMake(190, 10, 120, 44)];
    changeCameraButton.backgroundColor =
        [UIColor colorWithRed:.5 green:.5 blue:.5 alpha:.5];
    [changeCameraButton setTitle:@"Rear Camera" forState:UIControlStateNormal];
    [changeCameraButton setTitleColor:[UIColor whiteColor]
        forState:UIControlStateNormal];
    changeCameraButton.layer.cornerRadius = 10.0;
     
    UIButton *takePictureButton =
        [[UIButton alloc] initWithFrame:CGRectMake(100, 432, 120, 44)];
    takePictureButton.backgroundColor =
        [UIColor colorWithRed:.5 green:.5 blue:.5 alpha:.5];
    [takePictureButton setTitle:@"Click!" forState:UIControlStateNormal];
    [takePictureButton setTitleColor:[UIColor whiteColor]
        forState:UIControlStateNormal];
    takePictureButton.layer.cornerRadius = 10.0;
     
    [flashButton addTarget:self action:@selector(toggleFlash:)
        forControlEvents:UIControlEventTouchUpInside];
    [changeCameraButton addTarget:self action:@selector(toggleCamera:)
        forControlEvents:UIControlEventTouchUpInside];
    [takePictureButton addTarget:imagePicker action:@selector(takePicture)
        forControlEvents:UIControlEventTouchUpInside];
     
    [view addSubview:flashButton];
    [view addSubview:changeCameraButton];
    [view addSubview:takePictureButton];
     
    return view;
}

In Listing 9-19, you have defined your UIView as well as the buttons to be put in it, given them their actions to perform and added them into the view, set the title of each button to be either its starting value or its purpose, and also set their cornerRadius so that the buttons will have rounded corners. One of the most important details here is that you set your buttons to be semitransparent, as they are placed over your camera’s display. You do not want to cover up any of your picture, so the buttons have to be at least partially see-through.

As you may have noticed, the action for the takePictureButton is directly connected to the takePicture method on the image picker. The other two buttons, on the other hand, are connected to methods (toggleFlash and toggleCamera, respectively) on your view controller. At this point, those two methods don’t exist, so you need to implement them. Listing 9-20 shows their implementation.

Listing 9-20.  Implementation for the toggleFlash: and toggleCamera: methods

-(void)toggleFlash:(UIButton *)sender
{
    if (self.imagePicker.cameraFlashMode == UIImagePickerControllerCameraFlashModeOff)
    {
        self.imagePicker.cameraFlashMode = UIImagePickerControllerCameraFlashModeOn;
        [sender setTitle:@"Flash On" forState:UIControlStateNormal];
    }
    else
    {
        self.imagePicker.cameraFlashMode = UIImagePickerControllerCameraFlashModeOff;
        [sender setTitle:@"Flash Off" forState:UIControlStateNormal];
    }
}

-(void)toggleCamera:(UIButton *)sender
{
    if (self.imagePicker.cameraDevice == UIImagePickerControllerCameraDeviceRear)
    {
        self.imagePicker.cameraDevice = UIImagePickerControllerCameraDeviceFront;
        [sender setTitle:@"Front Camera" forState:UIControlStateNormal];
    }
    else
    {
        self.imagePicker.cameraDevice = UIImagePickerControllerCameraDeviceRear;
        [sender setTitle:@"Rear Camera" forState:UIControlStateNormal];
    }
}

Next, hide the default camera buttons and provide the image picker with your custom overlay view. Add the two lines of code shown in Listing 9-21 to your takePicture: method. You can also comment out the setting of the allowsEditing property because the new way of taking pictures doesn’t support that.

Listing 9-21.  Modifying the takePicture method to hide the default camera buttons and to set the custom overlay

- (IBAction)takePicture:(id)sender
{
        // Make sure camera is available
    if ([UIImagePickerController
         isSourceTypeAvailable:UIImagePickerControllerSourceTypeCamera] == NO)
    {
        UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"Error"
                                                        message:@"Camera Unavailable"
                                                       delegate:self
                                              cancelButtonTitle:@"Cancel"
                                              otherButtonTitles:nil, nil];
        [alert show];
        return;
    }
    if (self.imagePicker == nil)
    {
        self.imagePicker = [[UIImagePickerController alloc] init];
        self.imagePicker.delegate = self;
        self.imagePicker.sourceType = UIImagePickerControllerSourceTypeCamera;
        self.imagePicker.mediaTypes = [UIImagePickerController
            availableMediaTypesForSourceType:UIImagePickerControllerSourceTypeCamera];
        // self.imagePicker.allowsEditing = YES;
        self.imagePicker.showsCameraControls = NO;
        self.imagePicker.cameraOverlayView =
            [self customViewForImagePicker:self.imagePicker];
    }
    [self presentViewController:self.imagePicker animated:YES completion:NULL];
}

Finally, you need to make a small change to the imagePickerController:didFinishPickingMediaWithInfo: method. As mentioned earlier, the takePicture method of the image picker doesn’t support editing. This means that you have to retrieve your picture from the info dictionary using the UIImagePickerControllerOriginalImage key instead of UIImagePickerControllerEditedImage, as shown in Listing 9-22.

Listing 9-22.  Modifying the imagePickerController: didFinishPickingMediaWithInfo: to use the original image

-(void)imagePickerController:(UIImagePickerController *)picker didFinishPickingMediaWithInfo:(NSDictionary *)info
{
    NSString *mediaType = [info objectForKey: UIImagePickerControllerMediaType];
     
    if (CFStringCompare((__bridge CFStringRef) mediaType, kUTTypeMovie, 0) ==
        kCFCompareEqualTo)
    {
        NSString *moviePath =
           (NSString *) [[info objectForKey: UIImagePickerControllerMediaURL] path];
        self.pathToRecordedVideo = moviePath;
         
        if (UIVideoAtPathIsCompatibleWithSavedPhotosAlbum (moviePath))
        {
            UISaveVideoAtPathToSavedPhotosAlbum (moviePath, nil, nil, nil);
        }
    }
    else
    {
        UIImage *image =
            (UIImage *)[info objectForKey: UIImagePickerControllerOriginalImage];
        UIImageWriteToSavedPhotosAlbum(image, nil, nil , nil);
        self.imageView.image = image;
        self.imageView.contentMode = UIViewContentModeScaleAspectFill;
    }
    [self dismissViewControllerAnimated:YES completion:NULL];
}

If you run your app now, your camera should, as shown in Figure 9-9, display your three buttons in an overlay.

From here you can create your own custom overlays and easily change their functions to fit nearly any situation. The following recipes leave the image-picker controller and instead look into the Audiovisual (AV) Foundation framework for capturing your pictures and videos.

Recipe 9-5: Displaying Camera Preview with AVCaptureSession

While the UIImagePickerController and UIVideoEditorController interfaces are incredibly useful, they certainly aren’t as customizable as they could be. With the AV Foundation framework, however, you can create your camera interfaces from scratch, making them just the way you want. The AV Foundation framework gives you access to more audio and video tools so you can fully customize the user experience.

In this recipe and the ones that follow, you will use the AVCaptureSession API to essentially create your own version of the camera. You’ll do this in steps, starting with the displaying of a camera preview.

Begin by creating a new single-view project. You’ll use the same project for the rest of this chapter, so name it accordingly (such as “MyCamera”). Also, make sure to add the AVFoundation framework to your project or you’ll run into linker errors later.

Now, add a property to your view controller to hold your AVCaptureSession instance and one to hold the video input instance by making the changes in Listing 9-23 to your ViewController.h file.

Listing 9-23.  The ViewController.h file with added AVCaptureSession and AVCaptureDeviceInput properties

//
//  ViewController.h
//  Recipe 9-5 Displaying Camera Preview With AVCaptureSession
//

#import <UIKit/UIKit.h>
#import <AVFoundation/AVFoundation.h>

@interface ViewController : UIViewController

@property (strong, nonatomic) AVCaptureSession *captureSession;
@property (strong, nonatomic) AVCaptureDeviceInput *videoInput;

@end

Next, switch to the ViewController.m file and locate the viewDidLoad method. There you set up the capture session to receive input from the camera. We’ll show you step-by-step now and later will present you with the complete viewDidLoad implementation.

First, create your AVCaptureSession. Optionally, you might also want to change the resolution preset, which is set to AVCaptureSessionPresetHigh by default. Add the code in Listing 9-24 to the viewDidLoad method.

Listing 9-24.  Creating and initializing an AVCaptureSession instance

self.captureSession = [[AVCaptureSession alloc] init];
//Optional: self.captureSession.sessionPreset = AVCaptureSessionPresetMedium;

Next, specify your input device, which is your rear camera (assuming one is accessible), as shown in Listing 9-25. You specify this through the use of the AVCaptureDevice class method +defaultDeviceWithMediaType:, which can take a variety of different arguments depending on the type of media desired, the most prominent of which are AVMediaTypeVideo and AVMediaTypeAudio.

Listing 9-25.  Specifying the capture device

AVCaptureDevice *device = [AVCaptureDevice defaultDeviceWithMediaType:AVMediaTypeVideo];

Next, you need to set up the instance of AVCaptureDeviceInput to specify your chosen device as an input for your capture session. Also, include a check to make sure the input has been correctly created before adding it to your session. Listing 9-26 shows this instance and check statement.

Listing 9-26.  Setting the input instance and checking its existence before assigning the video input

NSError *error = nil;
self.videoInput = [AVCaptureDeviceInput deviceInputWithDevice:device error:&error];
if (self.videoInput)
{
    [self.captureSession addInput:self.videoInput];
}
else
{
    NSLog(@"Input Error: %@", error);
}

The last part of your viewDidLoad, as shown in Listing 9-27, is the creation of a preview layer, with which you can see what your camera is viewing. Set your preview layer to be the layer of your main view, but with a slightly altered height so as not to block a button that you’ll set up in the next recipe.

Listing 9-27.  Creating the preview layer

AVCaptureVideoPreviewLayer *previewLayer =
    [AVCaptureVideoPreviewLayer layerWithSession:self.captureSession];
UIView *aView = self.view;
previewLayer.frame =
    CGRectMake(0, 20, self.view.frame.size.width, self.view.frame.size.height-70);
[aView.layer addSublayer:previewLayer];

Once all these steps are complete, the viewDidLoad method should look like Listing 9-28.

Listing 9-28.  The complete viewDidLoad method

- (void)viewDidLoad
{
    [super viewDidLoad];
    // Do any additional setup after loading the view, typically from a nib.

    self.captureSession = [[AVCaptureSession alloc] init];
    //Optional: self.captureSession.sessionPreset = AVCaptureSessionPresetMedium;

    AVCaptureDevice *device =
        [AVCaptureDevice defaultDeviceWithMediaType:AVMediaTypeVideo];

    NSError *error = nil;
    self.videoInput = [AVCaptureDeviceInput deviceInputWithDevice:device error:&error];
    if (self.videoInput)
    {
        [self.captureSession addInput:self.videoInput ];
    }
    else
    {
        NSLog(@"Input Error: %@", error);
    }
     
    AVCaptureVideoPreviewLayer *previewLayer =
        [AVCaptureVideoPreviewLayer layerWithSession:self.captureSession];
    UIView *aView = self.view;
    previewLayer.frame =
        CGRectMake(0, 0, self.view.frame.size.width,
            self.view.frame.size.height-70);
    [aView.layer addSublayer:previewLayer];
}

Now the only thing that needs to be added is code to start and stop your capture session. In this app, you’ll display the camera preview upon application launch, so a good place to put the start code is in the viewWillAppear: method, as shown in Listing 9-29.

Listing 9-29.  Implementation of the viewWillAppear method

- (void)viewWillAppear:(BOOL)animated
{
    [super viewWillAppear:animated];
    [self.captureSession startRunning];
}

You will also add the corresponding stopping code for the capture session, as shown in Listing 9-30.

Listing 9-30.  Implementation of the viewWillDisappear method

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

If you build and run your application now, it should display a live camera preview, as shown in Figure 9-10.

Recipe 9-6: Capturing Still Images with AVCaptureSession

In the preceding recipe, you learned how to set up an AVCaptureSession with input from the camera. You also saw how you can connect an AVCaptureVideoPreviewLayer to display a live camera preview in your app. Now you will expand the project by connecting an AVCaptureStillImageOutput object to take still images and save them to the saved photos library on the device.

Before digging into the coding, you need to make a couple of changes to the project. The first is to add the AssetsLibrary.framework to your project. You use functionality from that framework to write the photos to the photos library.

Because you access the shared photos library of the device, you need to provide a usage description in the application’s Info.plist file. Go ahead and add the NSPhotoLibraryUsageDescription key (displayed as “Privacy—Photo Library Usage Description” in the property editor) with a brief text containing the reason why your app seeks the access (such as “Testing AVCaptureSession”). Refer to Recipe 1-7 in Chapter 1 for a refresher on this procedure.

//
//  ViewController.h
//  Recipe 9-6: Taking Still Images With AVCaptureSession
//

#import <UIKit/UIKit.h>
#import <AVFoundation/AVFoundation.h>
#import <AssetsLibrary/AssetsLibrary.h>

@interface ViewController : UIViewController

@property (strong, nonatomic) AVCaptureSession *captureSession;
@property (strong, nonatomic) AVCaptureDeviceInput *videoInput;
@property (strong, nonatomic) AVCaptureStillImageOutput *stillImageOutput;

- (IBAction)capture:(id)sender;

@end

- (void)viewDidLoad
{
    [super viewDidLoad];
        // Do any additional setup after loading the view, typically from a nib.
    self.captureSession = [[AVCaptureSession alloc] init];
    //Optional: self.captureSession.sessionPreset = AVCaptureSessionPresetMedium;
     
    AVCaptureDevice *device =
        [AVCaptureDevice defaultDeviceWithMediaType:AVMediaTypeVideo];
     
    NSError *error = nil;
    self.videoInput = [AVCaptureDeviceInput deviceInputWithDevice:device error:&error];
    if (self.videoInput)
    {
        [self.captureSession addInput:self.videoInput];
    }
    else
    {
        NSLog(@"Input Error: %@", error);
    }
     
    self.stillImageOutput = [[AVCaptureStillImageOutput alloc] init];
    NSDictionary *stillImageOutputSettings =
        [[NSDictionary alloc] initWithObjectsAndKeys:
            AVVideoCodecJPEG, AVVideoCodecKey, nil];
    [self.stillImageOutput setOutputSettings:stillImageOutputSettings];
    [self.captureSession addOutput:self.stillImageOutput];

    AVCaptureVideoPreviewLayer *previewLayer =
        [AVCaptureVideoPreviewLayer layerWithSession:self.captureSession];
    UIView *aView = self.view;
    previewLayer.frame =
        CGRectMake(0, 0, self.view.frame.size.width, self.view.frame.size.height-70);
    [aView.layer addSublayer:previewLayer];
}

- (IBAction)capture:(id)sender
{
    [self captureStillImage];
}

- (void) captureStillImage
{
    AVCaptureConnection *stillImageConnection =
       [self.stillImageOutput.connections objectAtIndex:0];
    if ([stillImageConnection isVideoOrientationSupported])
       [stillImageConnection setVideoOrientation:AVCaptureVideoOrientationPortrait];

    // ...
}

[self.stillImageOutput
    captureStillImageAsynchronouslyFromConnection:stillImageConnection
    completionHandler:^(CMSampleBufferRef imageDataSampleBuffer, NSError *error)
    {
        // ...
    }
];

[self.stillImageOutput
    captureStillImageAsynchronouslyFromConnection:stillImageConnection
    completionHandler:^(CMSampleBufferRef imageDataSampleBuffer, NSError *error)
    {
        if (imageDataSampleBuffer != NULL)
        {
            // ...
        }
        else
        {
            NSLog(@"Error capturing still image: %@", error);
        }
    }
 ];

if (imageDataSampleBuffer != NULL)
{
    NSData *imageData = [AVCaptureStillImageOutput
        jpegStillImageNSDataRepresentation:imageDataSampleBuffer];
    UIImage *image = [[UIImage alloc] initWithData:imageData];
     
    // ...
}

ALAssetsLibrary *library = [[ALAssetsLibrary alloc] init];
[library writeImageToSavedPhotosAlbum:[image CGImage]
    orientation:(ALAssetOrientation)[image imageOrientation]
    completionBlock:^(NSURL *assetURL, NSError *error)
    {
        UIAlertView *alert;
        if (!error)
        {
            alert = [[UIAlertView alloc] initWithTitle:@"Photo Saved"
                message:@"The photo was successfully saved to your photos library"
                delegate:nil
                cancelButtonTitle:@"OK"
                otherButtonTitles:nil, nil];
        }
        else
        {
            alert = [[UIAlertView alloc] initWithTitle:@"Error Saving Photo"
                message:@"The photo was not saved to your photos library"
                delegate:nil
                cancelButtonTitle:@"OK"
                otherButtonTitles:nil, nil];
        }
                     
        [alert show];
    }
];

- (void) captureStillImage
{
    AVCaptureConnection *stillImageConnection =
        [self.stillImageOutput.connections objectAtIndex:0];
    if ([stillImageConnection isVideoOrientationSupported])
        [stillImageConnection setVideoOrientation:AVCaptureVideoOrientationPortrait];
     
    [self.stillImageOutput
        captureStillImageAsynchronouslyFromConnection:stillImageConnection
        completionHandler:^(CMSampleBufferRef imageDataSampleBuffer, NSError *error)
        {
            if (imageDataSampleBuffer != NULL)
            {
                NSData *imageData = [AVCaptureStillImageOutput
                    jpegStillImageNSDataRepresentation:imageDataSampleBuffer];
                ALAssetsLibrary *library = [[ALAssetsLibrary alloc] init];
                UIImage *image = [[UIImage alloc] initWithData:imageData];
                [library writeImageToSavedPhotosAlbum:[image CGImage]
                    orientation:(ALAssetOrientation)[image imageOrientation]
                    completionBlock:^(NSURL *assetURL, NSError *error)
                    {
                        UIAlertView *alert;
                        if (!error)
                        {
                            alert = [[UIAlertView alloc] initWithTitle:@"Photo Saved"
                                message:@"The photo was successfully saved to your photos library"
                                delegate:nil
                                cancelButtonTitle:@"OK"
                                otherButtonTitles:nil, nil];
                        }
                        else
                        {
                            alert = [[UIAlertView alloc] initWithTitle:@"Error Saving Photo"
                                message:@"The photo was not saved to your photos library"
                                delegate:nil
                                cancelButtonTitle:@"OK"
                                otherButtonTitles:nil, nil];
                         }
                     
                         [alert show];
                     }
                ];
            }
            else
            {
                NSLog(@"Error capturing still image: %@", error);
            }
        }
    ];
}

Recipe 9-7: Capturing Video with AVCaptureSession

Now that you have covered some of the basics of using AVFoundation, you will use it to implement a slightly more complicated project. This time, you’ll extend your app to include a capturing video mode. To do this, you’ll need to allow the user to switch between taking pictures and recording videos. First you will build the functionality to switch modes, then you will implement the video capture using AVCaptureSession. You’ll build on the same project that you have been working on since Recipe 9-5.

//
//  ViewController.h
//  Recipe 9-7 Recording Video With AVCaptureSession
//

#import <UIKit/UIKit.h>
#import <AVFoundation/AVFoundation.h>
#import <AssetsLibrary/AssetsLibrary.h>

@interface ViewController : UIViewController <AVCaptureFileOutputRecordingDelegate>

@property (strong, nonatomic) AVCaptureSession *captureSession;
@property (strong, nonatomic) AVCaptureDeviceInput *videoInput;
@property (strong, nonatomic) AVCaptureDeviceInput *audioInput;
@property (strong, nonatomic) AVCaptureStillImageOutput *stillImageOutput;
@property (strong, nonatomic) AVCaptureMovieFileOutput *movieOutput;

@property (weak, nonatomic) IBOutlet UIButton *captureButton;
@property (weak, nonatomic) IBOutlet UISegmentedControl *modeControl;

- (IBAction)capture:(id)sender;
- (IBAction)updateMode:(id)sender;

@end

- (void)viewDidLoad
{
    [super viewDidLoad];
    self.captureSession = [[AVCaptureSession alloc] init];
    //Optional: self.captureSession.sessionPreset = AVCaptureSessionPresetMedium;
     
    AVCaptureDevice * videoDevice=
        [AVCaptureDevice defaultDeviceWithMediaType:AVMediaTypeVideo];
    AVCaptureDevice *audioDevice =
        [AVCaptureDevice defaultDeviceWithMediaType:AVMediaTypeAudio];
         
    NSError *error = nil;
     
    self.videoInput =
        [AVCaptureDeviceInput deviceInputWithDevice:videoDevice error:nil];
    self.audioInput =
        [[AVCaptureDeviceInput alloc] initWithDevice:audioDevice error:nil];

    // ...
}

- (void)viewDidLoad
{
  
        [super viewDidLoad];
        self.captureSession = [[AVCaptureSession alloc] init];
        //Optional: self.captureSession.sessionPreset = AVCaptureSessionPresetMedium;
         
        AVCaptureDevice *videoDevice =
        [AVCaptureDevice defaultDeviceWithMediaType:AVMediaTypeVideo];
        AVCaptureDevice *audioDevice =
        [AVCaptureDevice defaultDeviceWithMediaType:AVMediaTypeAudio];

        NSError *error = nil;
     
        self.videoInput =
        [AVCaptureDeviceInput deviceInputWithDevice:videoDevice error:&error];
        self.audioInput =
        [[AVCaptureDeviceInput alloc] initWithDevice:audioDevice error:&error];
     

        if (self.videoInput)
        {
             
            self.stillImageOutput = [[AVCaptureStillImageOutput alloc] init];
            NSDictionary *stillImageOutputSettings = [[NSDictionary alloc]
                                                      initWithObjectsAndKeys:AVVideoCodecJPEG, AVVideoCodecKey, nil];
            [self.stillImageOutput setOutputSettings:stillImageOutputSettings];
            [self.captureSession addOutput:self.stillImageOutput];
        }
        else
        {
            NSLog(@"Video Input Error: %@", error);
        }
        if (!self.videoInput)
        {
            NSLog(@"Audio Input Error: %@", error);
        }
//...
}

- (void)viewDidLoad
{
    // ...

    self.stillImageOutput = [[AVCaptureStillImageOutput alloc] init];
    NSDictionary *stillImageOutputSettings = [[NSDictionary alloc]
        initWithObjectsAndKeys:AVVideoCodecJPEG, AVVideoCodecKey, nil];
    [self.stillImageOutput setOutputSettings:stillImageOutputSettings];
     
    self.movieOutput = [[AVCaptureMovieFileOutput alloc] init];

    [self.captureSession addOutput:self.stillImageOutput];

    // ...
}

if (self.videoInput)
{
     
    self.stillImageOutput = [[AVCaptureStillImageOutput alloc] init];
    NSDictionary *stillImageOutputSettings = [[NSDictionary alloc]
                                              initWithObjectsAndKeys:AVVideoCodecJPEG, AVVideoCodecKey, nil];
    [self.stillImageOutput setOutputSettings:stillImageOutputSettings];
     
    self.movieOutput = [[AVCaptureMovieFileOutput alloc] init];
     
    // Setup capture session for taking pictures
    [self.captureSession addInput:self.videoInput];
    [self.captureSession addOutput:self.stillImageOutput];
}

- (void)viewDidLoad
{
  
        [super viewDidLoad];
        self.captureSession = [[AVCaptureSession alloc] init];
        //Optional: self.captureSession.sessionPreset = AVCaptureSessionPresetMedium;
         
        AVCaptureDevice *videoDevice =
        [AVCaptureDevice defaultDeviceWithMediaType:AVMediaTypeVideo];
        AVCaptureDevice *audioDevice =
        [AVCaptureDevice defaultDeviceWithMediaType:AVMediaTypeAudio];
     
        NSError *error = nil;
     
        self.videoInput =
        [AVCaptureDeviceInput deviceInputWithDevice:videoDevice error:&error];
        self.audioInput =
        [[AVCaptureDeviceInput alloc] initWithDevice:audioDevice error:&error];
     
        if (self.videoInput)
        {
             
            self.stillImageOutput = [[AVCaptureStillImageOutput alloc] init];
            NSDictionary *stillImageOutputSettings = [[NSDictionary alloc]
                                                      initWithObjectsAndKeys:AVVideoCodecJPEG, AVVideoCodecKey, nil];
            [self.stillImageOutput setOutputSettings:stillImageOutputSettings];
             
            self.movieOutput = [[AVCaptureMovieFileOutput alloc] init];
             
            // Setup capture session for taking pictures
            [self.captureSession addInput:self.videoInput];
            [self.captureSession addOutput:self.stillImageOutput];
        }
        else
        {
            NSLog(@"Video Input Error: %@", error);
        }
        if (!self.videoInput)
        {
            NSLog(@"Audio Input Error: %@", error);
        }

        AVCaptureVideoPreviewLayer *previewLayer =
        [AVCaptureVideoPreviewLayer layerWithSession:self.captureSession];
        UIView *aView = self.view;
        previewLayer.frame =
        CGRectMake(0, 70, self.view.frame.size.width, self.view.frame.size.height-140);
        [aView.layer addSublayer:previewLayer];

}

- (IBAction)capture:(id)sender
{
    if (self.modeControl.selectedSegmentIndex == 0)
    {
        // Picture Mode
        [self captureStillImage];
    }
    else
    {
        // Video Mode
    }
}

- (IBAction)capture:(id)sender
{
    if (self.modeControl.selectedSegmentIndex == 0)
    {
        // Picture Mode
        [self captureStillImage];
    }
    else
    {
        // Video Mode
        if (self.movieOutput.isRecording == YES)
        {
            [self.captureButton setTitle:@"Capture" forState:UIControlStateNormal];
            [self.movieOutput stopRecording];
        }
        else
        {
            [self.captureButton setTitle:@"Stop" forState:UIControlStateNormal];
            [self.movieOutput startRecordingToOutputFileURL:[self tempFileURL]
                recordingDelegate:self];
        }
    }
}

- (NSURL *) tempFileURL
{
    NSString *outputPath = [[NSString alloc] initWithFormat:@"%@%@",
        NSTemporaryDirectory(), @"output.mov"];
    NSURL *outputURL = [[NSURL alloc] initFileURLWithPath:outputPath];
    NSFileManager *manager = [[NSFileManager alloc] init];
    if ([manager fileExistsAtPath:outputPath])
    {
        [manager removeItemAtPath:outputPath error:nil];
    }
    return outputURL;
}

- (void)captureOutput:(AVCaptureFileOutput *)captureOutput
didFinishRecordingToOutputFileAtURL:(NSURL *)outputFileURL
      fromConnections:(NSArray *)connections
                error:(NSError *)error
{
    BOOL recordedSuccessfully = YES;
    if ([error code] != noErr)
    {
        // A problem occurred: Find out if the recording was successful.
        id value = [[error userInfo]
            objectForKey:AVErrorRecordingSuccessfullyFinishedKey];
        if (value)
            recordedSuccessfully = [value boolValue];
        // Logging the problem anyway:
        NSLog(@"A problem occurred while recording: %@", error);
    }
    if (recordedSuccessfully)
    {
        ALAssetsLibrary *library = [[ALAssetsLibrary alloc] init];
         
        [library writeVideoAtPathToSavedPhotosAlbum:outputFileURL
            completionBlock:^(NSURL *assetURL, NSError *error)
            {
                UIAlertView *alert;
                if (!error)
                {
                    alert = [[UIAlertView alloc] initWithTitle:@"Video Saved"
                       message:@"The movie was successfully saved to your photos library"
                       delegate:nil
                       cancelButtonTitle:@"OK"
                       otherButtonTitles:nil, nil];
                }
                else
                {
                    alert = [[UIAlertView alloc] initWithTitle:@"Error Saving Video"
                       message:@"The movie was not saved to your photos library"
                       delegate:nil
                       cancelButtonTitle:@"OK"
                       otherButtonTitles:nil, nil];
                }
              
                [alert show];
            }
        ];
    }
}

- (IBAction)updateMode:(id)sender
{
    [self.captureSession stopRunning];
    if (self.modeControl.selectedSegmentIndex == 0)
    {
        // Still Image Mode
        if (self.movieOutput.isRecording == YES)
        {
            [self.movieOutput stopRecording];
        }
        [self.captureSession removeInput:self.audioInput];
        [self.captureSession removeOutput:self.movieOutput];
        [self.captureSession addOutput:self.stillImageOutput];
    }
    else
    {
        if([self.captureSession canAddInput:self.audioInput])
        {
            // Video Mode
            [self.captureSession removeOutput:self.stillImageOutput];
            [self.captureSession addInput:self.audioInput];
            [self.captureSession addOutput:self.movieOutput];
         
            // Set orientation of capture connections to portrait
            NSArray *array = [[self.captureSession.outputs objectAtIndex:0] connections];
            for (AVCaptureConnection *connection in array)
            {
                connection.videoOrientation = AVCaptureVideoOrientationPortrait;
            }
        }
        else
        {
            self.modeControl.selectedSegmentIndex = 0;
            NSLog(@"User turned off access to microphone");
            UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"Can't Access Audio" message:@"Verify microphone access is turned on in Settings->Privacy->Microphone" delegate:nil cancelButtonTitle:@"OK" otherButtonTitles:nil];
            [alert show];
             
        }
    }
    [self.captureButton setTitle:@"Capture" forState:UIControlStateNormal];
     
    [self.captureSession startRunning];
}

Recipe 9-8: Capturing Video Frames

For many applications that utilize videos, a thumbnail image is a useful way to “represent” a given video. In this recipe, you expand the preceding recipe and generate and display a thumbnail image when a video has been recorded.

Start by adding the CoreMedia framework to your project. You use it to generate the thumbnail.

Next, add an image view to the lower-left corner of your main view’s user interface so that it resembles Figure 9-15. Once again, you will want to add some constraints to the image view by selecting “Add Missing Constraints” from the Resolve Auto Layout Issues menu in the lower-right corner of the storyboard window. This will ensure it looks fine on a 3.5" device. With UIImage selected, add a width and height constraint from the pin menu, as shown in Figure 9-16.

Add an outlet with the name “thumbnailImageView” for the image view so you can reference it later from your code.

Now, let’s get to the core of this recipe. The method in Listing 9-51 extracts an image from the halfway point of the movie and updates the thumbnail image view. This method basically creates an asset using a URL and creates an image generator from it. Then we check for proper rotation and set the time of the clip we want to take the image from. Then we generate the image asynchronously.

Listing 9-51.  Implementation of createThumbnailForVideoURL

-(void)createThumbnailForVideoURL:(NSURL *)videoURL
{
    AVURLAsset *myAsset = [[AVURLAsset alloc] initWithURL:videoURL options:[NSDictionary dictionaryWithObject:@"YES" forKey:AVURLAssetPreferPreciseDurationAndTimingKey]];
     
    AVAssetImageGenerator *imageGenerator =
        [AVAssetImageGenerator assetImageGeneratorWithAsset:myAsset];
    //Make sure images are correctly rotated.
    imageGenerator.appliesPreferredTrackTransform = YES;
    Float64 durationSeconds = CMTimeGetSeconds([myAsset duration]);
    CMTime half = CMTimeMakeWithSeconds(durationSeconds/2.0, 600);
    NSArray *times = [NSArray arrayWithObjects: [NSValue valueWithCMTime:half], nil];
     
    [imageGenerator generateCGImagesAsynchronouslyForTimes:times
        completionHandler:^(CMTime requestedTime, CGImageRef image, CMTime actualTime,
                            AVAssetImageGeneratorResult result, NSError *error)
        {
            if (result == AVAssetImageGeneratorSucceeded)
            {
                self.thumbnailImageView.image = [UIImage imageWithCGImage:image];
            }
            else if (result == AVAssetImageGeneratorFailed)
            {
                NSLog(@"Failed with error: %@", [error localizedDescription]);
            }
        }
    ];
}

Now all that’s left is to call the method when a video has been recorded, as shown in Listing 9-52. All that we’re doing here is adding one line of code that calls the method in Listing 9-51 when a video is successfully captured.

Listing 9-52.  Modifying the captureOutput:didFinishRecordingToOutputFuleAtURL:fromConnections: method

- (void)captureOutput:(AVCaptureFileOutput *)captureOutput
didFinishRecordingToOutputFileAtURL:(NSURL *)outputFileURL
      fromConnections:(NSArray *)connections
                error:(NSError *)error
{
    BOOL recordedSuccessfully = YES;
    if ([error code] != noErr)
    {
        // A problem occurred: Find out if the recording was successful.
        id value =
            [[error userInfo] objectForKey:AVErrorRecordingSuccessfullyFinishedKey];
        if (value)
            recordedSuccessfully = [value boolValue];
        // Logging the problem anyway:
        NSLog(@"A problem occurred while recording: %@", error);
    }
    if (recordedSuccessfully)
    {
        [self createThumbnailForVideoURL:outputFileURL];
        ALAssetsLibrary *library = [[ALAssetsLibrary alloc] init];
         
        [library writeVideoAtPathToSavedPhotosAlbum:outputFileURL
            completionBlock:^(NSURL *assetURL, NSError *error)
            {
                UIAlertView *alert;
                if (!error)
                {
                    alert = [[UIAlertView alloc] initWithTitle:@"Video Saved"
                        message:@"The movie was successfully saved to your photos library"
                        delegate:nil
                        cancelButtonTitle:@"OK"
                        otherButtonTitles:nil, nil];
                }
                else
                {
                    alert = [[UIAlertView alloc] initWithTitle:@"Error Saving Video"
                        message:@"The movie was not saved to your photos library"
                        delegate:nil
                        cancelButtonTitle:@"OK"
                        otherButtonTitles:nil, nil];
                }
              
                [alert show];
            }
         ];
    }
}

Now build and run your application and switch to the “Record Video” mode when it has launched. Record a video by clicking the “Capture” button twice (once for start and again for stop). A few seconds later a thumbnail from halfway into your movie will be displayed in the lower-left corner, as Figure 9-17 shows.

Recipe 9-9: Capturing Machine-Readable Codes

With iOS 7 we now have a new functionality in the AVCaptureMetadataOutput class that makes reading machine-readable codes very easy to implement. Machine-readable codes are basically just one-dimensional or two-dimensional barcodes such as UPC-E or QR codes. As an example, Apple’s passbook app uses this functionality to read various types of codes. Now you, too, can add this functionality to your app with very little code. This class now gives us the ability to read any of the following types of machine-readable codes:

One–Dimensional

• UPC-E
• EAN-8, EAN-13
• Code 39 (with and without checksum)
• Code 93
• Code 128

Two–Dimensional

• PDF417
• QR
• Aztec

To start, you will be creating a new single view application that is similar to Recipe 9-5. As you did before, you need to add the AssetsLibrary, AVFoundation, and CoreGraphics frameworks. Drag a label to the screen and arrange it as shown in Figure 9-18. Make the label three lines high and resize it to be the width of the screen. Select the label and add some constraints by choosing “Add Missing Constraints” from the Resolve Auto Layout Issues menu in the lower-right side of the storyboard editor.

Next, create an outlet for the text label with the name “codeLabel.”

Now that you have a starting place set up, add a few properties as well as a delegate declaration to the view controller header file. The properties will be used to handle a capture session, the input device, and the metadata output. We’ll need to add a delegate to our view controller to retrieve information when a bar code or QR code is scanned. Listing 9-53 shows the completed ViewController.h file.

Listing 9-53.  The completed ViewController.h file with required properties and delegate declaration

//
//  ViewController.h
//  Recipe 9-9 Capturing Machine-Readable Codes
//

#import <UIKit/UIKit.h>
#import <AVFoundation/AVFoundation.h>

@interface ViewController : UIViewController <AVCaptureMetadataOutputObjectsDelegate>

@property (weak, nonatomic) IBOutlet UILabel *codeLabel;
@property (strong, nonatomic) AVCaptureSession *captureSession;
@property (strong, nonatomic) AVCaptureDeviceInput *videoInput;
@property (strong, nonatomic) AVCaptureMetadataOutput *metadataOutput;

@end

Next, we need to add a little bit of code to the viewDidLoad: method and add the delegates. Because there are a few different things we’ll be adding to the viewDidLoad method, we’ll first explain each piece and reveal the complete viewDidLoad method when we’re done.

To begin, we’ll create an AVCaptureSession and provide the input type and the input device, as shown in Listing 9-54. As we did in the preceding two recipes, we are checking for errors and the existence of the video input before assigning the input.

Listing 9-54.  Adding an AVCaptureSession and video input

//
//  ViewController.m
//  Recipe 9-9 Capturing Machine-Readable Codes
//

//...
- (void)viewDidLoad
{

    [super viewDidLoad];

    self.captureSession = [[AVCaptureSession alloc] init];

    AVCaptureDevice *device =
    [AVCaptureDevice defaultDeviceWithMediaType:AVMediaTypeVideo];
     
    NSError *error = nil;
    self.videoInput = [AVCaptureDeviceInput deviceInputWithDevice:device error:&error];
    if (self.videoInput)
    {
        [self.captureSession addInput:self.videoInput];
    }
    else
    {
        NSLog(@"Input Error: %@", error);
    }

//...
}

Next, you should allocate and initialize your metadataOutput property and then set the delegate and the dispatch queue to the main thread. Because QR codes aren’t really that intensive, the main thread should be fine for handling these operations. You also need to set a couple of metadata types. For this example, we will use UPC-E code and QR code types. You can expand these as much as you please using any of the types listed earlier. Add the code in Listing 9-55 to the viewDidLoad method.

Listing 9-55.  Creating an AVCaptureMetadagaOutput instance and setting the object types

self.metadataOutput = [[AVCaptureMetadataOutput alloc] init];
[self.captureSession addOutput:self.metadataOutput];

[self.metadataOutput setMetadataObjectsDelegate:self queue:dispatch_get_main_queue()];

self.metadataOutput.metadataObjectTypes = @[AVMetadataObjectTypeUPCECode, AVMetadataObjectTypeQRCode];

As we did in Recipe 9-5, we’ll create a new preview layer and set it to a view that will allow us to view what the camera is seeing. Add the code in Listing 9-56 to the viewDidLoad method as well.

Listing 9-56.  Creating a preview layer to view the current camera view

AVCaptureVideoPreviewLayer *previewLayer =
[AVCaptureVideoPreviewLayer layerWithSession:self.captureSession];
UIView *aView = self.view;
previewLayer.frame =
CGRectMake(0, 20, self.view.frame.size.width,
           self.view.frame.size.height-100);
[aView.layer addSublayer:previewLayer];

When you are done, your viewDidLoad method should look like Listing 9-57.

Listing 9-57.  The completed viewDidLoad method

- (void)viewDidLoad
{
    [super viewDidLoad];
    // Do any additional setup after loading the view, typically from a nib.
     
    self.captureSession = [[AVCaptureSession alloc] init];
     
    AVCaptureDevice *device =
    [AVCaptureDevice defaultDeviceWithMediaType:AVMediaTypeVideo];
     
    NSError *error = nil;
    self.videoInput = [AVCaptureDeviceInput deviceInputWithDevice:device error:&error];
    if (self.videoInput)
    {
        [self.captureSession addInput:self.videoInput];
    }
    else
    {
        NSLog(@"Input Error: %@", error);
    }
     
    self.metadataOutput = [[AVCaptureMetadataOutput alloc] init];
    [self.captureSession addOutput:self.metadataOutput];
     
    [self.metadataOutput setMetadataObjectsDelegate:self queue:dispatch_get_main_queue()];
     
    self.metadataOutput.metadataObjectTypes = @[AVMetadataObjectTypeUPCECode, AVMetadataObjectTypeQRCode];
     
    AVCaptureVideoPreviewLayer *previewLayer =
    [AVCaptureVideoPreviewLayer layerWithSession:self.captureSession];
    UIView *aView = self.view;
    previewLayer.frame =
    CGRectMake(0, 20, self.view.frame.size.width,
               self.view.frame.size.height-70);
    [aView.layer addSublayer:previewLayer];
     
}

Now the only action left is to create the delegate method. All we’ll do here is simply set the text label to the value received. Add the code in Listing 9-58 to the implementation file.

Listing 9-58.  The captureOutput:didOutputMetadataObjects:fromConnection: method implementation

- (void)captureOutput:(AVCaptureOutput *)captureOutput didOutputMetadataObjects:(NSArray *)metadataObjects fromConnection:(AVCaptureConnection *)connection
{
     
        self.codeLabel.text = [NSString stringWithFormat:@" Type - %@: Value - %@",object.type,object.stringValue];

}

The last step is to start and stop the capture session using the viewWillAppear and viewWillDisappear methods, as we did in Recipe 9-5. Add the two methods and their code shown in Listing 9-59 to the view controller as well.

Listing 9-59.  Adding the viewWillAppear and viewWillDisappear method implementations

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

That’s it! If you run it and find either a UPC-E or QR code, your app should look similar to Figure 9-19.

Summary

As a developer, you have a great deal of choice when it comes to dealing with your device’s camera. The predefined interfaces, such as UIImagePickerController and UIVideoEditorController, are incredibly useful and well designed, but Apple’s implementation of the AV Foundation framework allows for more possibilities. Everything from dealing with video and audio to handling barcodes and still images is possible. Even a quick glance at the full documentation reveals countless other functionalities not discussed here, including everything from device capabilities (such as the video camera’s LED “torch”) to the implementation of your own “Touch-To-Focus” functionality. We live in a world where images, audio, and video fly around the world in a matter of seconds, and as developers we must be able to design and create innovative solutions that fit in with our media-based community.